From c7bc409d8d4fa0cc63fb94e9219f3dc854d13074 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8F=AD=E6=89=AC?= <xingjun.wxj@alibaba-inc.com>
Date: Wed, 16 Sep 2026 16:25:14 +0800
Subject: [PATCH 01/10] bump version

---
 src/leapflow/version.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/leapflow/version.py b/src/leapflow/version.py
index 1a745016..441a47b0 100644
--- a/src/leapflow/version.py
+++ b/src/leapflow/version.py
@@ -1,4 +1,4 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
 """Version information for leapflow."""
 
-__version__ = "0.2.0+main"
+__version__ = "0.2.1+main"

From 40ef78eef716d26a1139c8cc16b9b8089e3803ce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8F=AD=E6=89=AC?= <xingjun.wxj@alibaba-inc.com>
Date: Fri, 18 Sep 2026 10:54:43 +0800
Subject: [PATCH 02/10] feat(board,evolution): fix LeapBoard P0-P2 defects and
 add explicit evolution trigger

LeapBoard / evolution observability
- Markdown node now parses blockquote/strong/inline-code (escape-then-whitelist,
  no third-party parser) instead of printing raw markup
- evolution_live metrics split into live vs snapshot provenance with a drift note,
  so figures that cannot refresh no longer freeze while looking current
- co-evolution governance sweep runs on an empty trajectory too (moved out of the
  `if trajectory:` branch); effect-verification/quarantine/reclamation segments
  become observable
- page-level provenance bar: observed_at vs checked_at, stale verdict at 2x cadence,
  and a Refresh now affordance that closes the prescribe->confirm loop
- lifecycle segment judged by state transition, not row count (all-PENDING queue
  reads no_evidence); empty live lanes carry guidance and equal height; removed the
  duplicate evolution_live KPI grid
- evolution axis (Pipeline evidence over time); sparkline draws a single sample

Evolution trigger
- run_learning_boundary() + evolution.run RPC + `leap evolve` CLI so the boundary
  is callable on demand, not only at process shutdown
- bounded trajectory buffer; manual watch refresh records run bookkeeping;
  WatchView exposes interval_seconds for freshness judging

Tests: +49 dashboard/provenance/trigger regressions; full i18n coverage in 6 locales

Also folds in pending feat/demo_exp work (leapspace app_space refactor, AAAI-27
demo scaffolding, and related tests).
---
 .gitignore                                    |  19 +
 src/leapflow/cli/cli.py                       |  19 +-
 src/leapflow/cli/commands/evolve.py           |  95 +++
 src/leapflow/cli/context.py                   | 181 +++++-
 src/leapflow/daemon/client.py                 |   4 +
 src/leapflow/daemon/monitor_coordinator.py    |  23 +-
 src/leapflow/daemon/protocol.py               |  10 +
 src/leapflow/daemon/service.py                |  17 +
 src/leapflow/dashboard/hub.py                 |  18 +
 src/leapflow/dashboard/server.py              |  12 +-
 src/leapflow/dashboard/service.py             | 149 +++++
 src/leapflow/dashboard/static/app.js          | 542 +++++++++++++++++-
 src/leapflow/dashboard/static/index.html      |   4 +-
 src/leapflow/dashboard/static/styles.css      |  80 ++-
 .../dashboard/templates/causal_trace.yaml     |  87 +++
 .../dashboard/templates/evolution.yaml        |  32 ++
 .../dashboard/templates/evolution_live.yaml   |  58 ++
 src/leapflow/engine/engine.py                 |   7 +-
 src/leapflow/learning/degradation_sink.py     |  38 +-
 src/leapflow/learning/world_model_driver.py   | 223 ++++++-
 src/leapflow/llm/openai_provider.py           |  13 +-
 src/leapflow/monitor/evolution_producer.py    |  41 +-
 src/leapflow/monitor/manager.py               |  27 +-
 src/leapflow/monitor/types.py                 |   7 +
 .../plugins/tool_plugins/self_management.py   |  82 ++-
 .../storage/capability_proposal_queue.py      |  40 +-
 .../telemetry/evolution_presentation.py       |  91 +++
 src/leapflow/version.py                       |   2 +-
 src/leapflow/world_model/prediction.py        |  16 +-
 src/leapspace/app_space/actor.py              |   2 +-
 src/leapspace/app_space/apps/_base.py         |  45 +-
 src/leapspace/app_space/harness.py            |   4 +-
 src/leapspace/app_space/host_rpc.py           | 162 ++++++
 src/leapspace/app_space/image.py              |  78 +++
 src/leapspace/app_space/signal.py             |   2 +-
 .../app_space/{utils.py => state.py}          |  77 +--
 .../app_space/tasks/task-001/action.py        |   2 +-
 temp/papers/aaai27_demo/aaai_demo/__init__.py |  17 +
 temp/papers/aaai27_demo/aaai_demo/cli.py      | 107 ++++
 temp/papers/aaai27_demo/aaai_demo/evidence.py | 528 +++++++++++++++++
 .../aaai27_demo/aaai_demo/headless_seam.py    | 220 +++++++
 temp/papers/aaai27_demo/aaai_demo/poster.py   | 113 ++++
 temp/papers/aaai27_demo/aaai_demo/render.py   | 169 ++++++
 .../headless-chat-probe-drifts.json           |  69 +++
 .../task-001-structural-drifts.json           | 124 ++++
 ...31\344\275\234\350\256\241\345\210\222.md" | 280 +++++++++
 temp/papers/aaai27_demo/reproduction.md       | 118 ++++
 .../aaai27_demo/tests/test_demo_artifacts.py  | 210 +++++++
 tests/leapspace/test_actor.py                 |   2 +-
 tests/leapspace/test_harness.py               |   2 +-
 tests/leapspace/test_signal_bridge_live.py    | 113 ++++
 .../{test_utils.py => test_state.py}          |  27 +-
 tests/test_adaptation_verdict.py              |  28 +-
 tests/test_coevolution_sweep_wiring.py        |  50 ++
 tests/test_dashboard_frontend_static.py       | 200 +++++++
 tests/test_dashboard_launcher.py              |   6 +-
 tests/test_dashboard_provenance.py            | 170 ++++++
 tests/test_dashboard_view.py                  |  54 +-
 tests/test_evolution_governance_reachable.py  |  44 ++
 tests/test_evolution_presentation.py          |  45 ++
 tests/test_evolution_producer.py              |   6 +
 tests/test_evolution_tap.py                   |  40 ++
 tests/test_evolution_trigger_boundary.py      | 267 +++++++++
 tests/test_llm_provider_retry_ownership.py    |  51 ++
 tests/test_world_model_driver.py              |  67 +++
 ...test_world_model_proposal_sink_contract.py | 133 +++++
 66 files changed, 5411 insertions(+), 158 deletions(-)
 create mode 100644 src/leapflow/cli/commands/evolve.py
 create mode 100644 src/leapflow/dashboard/templates/causal_trace.yaml
 create mode 100644 src/leapflow/dashboard/templates/evolution_live.yaml
 create mode 100644 src/leapflow/telemetry/evolution_presentation.py
 create mode 100644 src/leapspace/app_space/host_rpc.py
 create mode 100644 src/leapspace/app_space/image.py
 rename src/leapspace/app_space/{utils.py => state.py} (68%)
 create mode 100644 temp/papers/aaai27_demo/aaai_demo/__init__.py
 create mode 100644 temp/papers/aaai27_demo/aaai_demo/cli.py
 create mode 100644 temp/papers/aaai27_demo/aaai_demo/evidence.py
 create mode 100644 temp/papers/aaai27_demo/aaai_demo/headless_seam.py
 create mode 100644 temp/papers/aaai27_demo/aaai_demo/poster.py
 create mode 100644 temp/papers/aaai27_demo/aaai_demo/render.py
 create mode 100644 temp/papers/aaai27_demo/demo_fixtures/headless-chat-probe-drifts.json
 create mode 100644 temp/papers/aaai27_demo/demo_fixtures/task-001-structural-drifts.json
 create mode 100644 "temp/papers/aaai27_demo/plan/AAAI-27_Demo_\350\256\272\346\226\207\345\206\231\344\275\234\350\256\241\345\210\222.md"
 create mode 100644 temp/papers/aaai27_demo/reproduction.md
 create mode 100644 temp/papers/aaai27_demo/tests/test_demo_artifacts.py
 create mode 100644 tests/leapspace/test_signal_bridge_live.py
 rename tests/leapspace/{test_utils.py => test_state.py} (66%)
 create mode 100644 tests/test_dashboard_frontend_static.py
 create mode 100644 tests/test_dashboard_provenance.py
 create mode 100644 tests/test_evolution_presentation.py
 create mode 100644 tests/test_evolution_trigger_boundary.py
 create mode 100644 tests/test_llm_provider_retry_ownership.py
 create mode 100644 tests/test_world_model_proposal_sink_contract.py

diff --git a/.gitignore b/.gitignore
index ccaffcb7..b762e5b9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -235,5 +235,24 @@ Package.resolved
 leapflow.sock
 
 temp
+# The AAAI demo tooling is a reproducible artifact, not disposable scratch data.
+# Re-ignore every other temporary artifact after reopening each parent directory.
+!temp/
+temp/*
+!temp/papers/
+temp/papers/*
+!temp/papers/aaai27_demo/
+temp/papers/aaai27_demo/*
+!temp/papers/aaai27_demo/aaai_demo/
+!temp/papers/aaai27_demo/aaai_demo/*.py
+!temp/papers/aaai27_demo/demo_fixtures/
+!temp/papers/aaai27_demo/demo_fixtures/task-001-structural-drifts.json
+!temp/papers/aaai27_demo/demo_fixtures/headless-chat-probe-drifts.json
+!temp/papers/aaai27_demo/plan/
+temp/papers/aaai27_demo/plan/*
+!temp/papers/aaai27_demo/plan/AAAI-27_Demo_论文写作计划.md
+!temp/papers/aaai27_demo/reproduction.md
+!temp/papers/aaai27_demo/tests/
+!temp/papers/aaai27_demo/tests/test_demo_artifacts.py
 .DS_Store
 AGENTS.md
diff --git a/src/leapflow/cli/cli.py b/src/leapflow/cli/cli.py
index 8054ef3e..e25e9e60 100644
--- a/src/leapflow/cli/cli.py
+++ b/src/leapflow/cli/cli.py
@@ -286,6 +286,16 @@ def main(argv: list[str] | None = None) -> int:
     dashboard_parser.add_argument("--bind", default="", help="Override the dashboard bind address")
     dashboard_parser.add_argument("--no-open", action="store_true", help="Print the URL instead of opening a browser")
 
+    # leap evolve (run the learning boundary now)
+    evolve_parser = subparsers.add_parser(
+        "evolve", help="Run the learning boundary now and report what it did"
+    )
+    evolve_parser.add_argument(
+        "--reason", default="manual",
+        help="Label recorded with this run (default: manual)",
+    )
+    evolve_parser.add_argument("--json", action="store_true", help="Emit machine-readable JSON")
+
     # leap hw (hardware inspection and direct intervention)
     hw_parser = subparsers.add_parser("hw", help="Inspect hardware and intervene in it directly")
     hw_sub = hw_parser.add_subparsers(dest="hw_action")
@@ -359,7 +369,7 @@ def main(argv: list[str] | None = None) -> int:
 
     # ── Pre-parse: detect if first non-flag arg is a known subcommand ──
     # If not, treat everything non-flag as a chat prompt.
-    known_commands = {"teach", "run", "skills", "relearn", "host", "daemon", "config", "board", "hw"}
+    known_commands = {"teach", "run", "skills", "relearn", "host", "daemon", "config", "board", "hw", "evolve"}
     effective_argv = list(argv) if argv is not None else sys.argv[1:]
 
     # Find first non-flag argument, skipping values owned by global options.
@@ -459,6 +469,13 @@ def main(argv: list[str] | None = None) -> int:
         from leapflow.cli.commands.dashboard import cmd_dashboard
         return cmd_dashboard(args)
 
+    # Evolve routes to leapd, which owns the context holding the trajectory buffer.
+    # Running it in this process would build a second, empty context and grade
+    # nothing, so no Context is initialized here either.
+    if args.command == "evolve":
+        from leapflow.cli.commands.evolve import cmd_evolve
+        return cmd_evolve(args)
+
     # Hardware inspection/intervention: reads run in-process, pause/resume route
     # to leapd over RPC. No engine Context is needed either way.
     if args.command == "hw":
diff --git a/src/leapflow/cli/commands/evolve.py b/src/leapflow/cli/commands/evolve.py
new file mode 100644
index 00000000..3700f946
--- /dev/null
+++ b/src/leapflow/cli/commands/evolve.py
@@ -0,0 +1,95 @@
+"""`leap evolve` — run the learning boundary now, and report what it did.
+
+Capability evolution is driven from exactly one place: the learning boundary, which
+grades the recorded trajectory, lets the world model propose capabilities it found
+missing, and runs the cold-path governance sweep. That boundary used to be reachable
+only from context cleanup, which in daemon mode means *process shutdown* — so a
+daemon that ran for a week never evolved, one killed with SIGKILL never evolved at
+all, and there was no way to answer "did it evolve, and what happened" without
+stopping the daemon and reading its log.
+
+This command makes the boundary an explicit, observable operation. It routes to the
+daemon rather than doing the work locally, because the daemon owns the context that
+holds the trajectory buffer and the proposal queue; a second context would grade an
+empty buffer and truthfully report that nothing happened.
+
+It decides nothing on its own: whether a proposal is even *written* still depends on
+``evolution.enabled``, and whether it is acted on still depends on generation,
+review, approval and trust. Running this is asking the framework to look at what it
+has already done, not granting it new permission.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+
+from leapflow.config import load_config
+
+
+def cmd_evolve(args: argparse.Namespace) -> int:
+    """Entry point for the ``leap evolve`` subcommand."""
+    try:
+        return asyncio.run(_run(args))
+    except KeyboardInterrupt:
+        return 130
+
+
+async def _run(args: argparse.Namespace) -> int:
+    from leapflow.daemon.client import ensure_daemon_client
+
+    settings = load_config()
+    as_json = bool(getattr(args, "json", False))
+
+    try:
+        client = await ensure_daemon_client(settings)
+    except Exception as exc:  # noqa: BLE001 - a missing daemon is a normal outcome here
+        _report_error(f"leapd unavailable: {exc}", as_json)
+        return 1
+
+    try:
+        result = await client.evolution_run(reason=str(getattr(args, "reason", "") or "manual"))
+    except Exception as exc:  # noqa: BLE001 - surfaced, never a traceback
+        _report_error(str(exc), as_json)
+        return 1
+
+    if as_json:
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+        return 0 if result.get("ok") else 1
+
+    if not result.get("ok"):
+        print(f"Learning boundary failed: {result.get('error', 'unknown error')}")
+        return 1
+
+    steps = int(result.get("trajectory_steps") or 0)
+    print(
+        f"Learning boundary ran ({result.get('reason', 'manual')}) in "
+        f"{result.get('duration_s', 0)}s — {steps} trajectory step(s) graded."
+    )
+    if not steps:
+        # Said plainly, because an empty trajectory is the common case and looks
+        # identical to a failure otherwise. The governance sweep still ran: that is
+        # the whole reason it sits outside the trajectory branch.
+        print(
+            "  No turns were recorded since the last boundary, so the teacher had "
+            "nothing to grade. The governance sweep still ran."
+        )
+    if not getattr(settings, "evolution_enabled", False):
+        print(
+            "  Self-evolution is off, so no capability proposal was written. "
+            "The world model still graded and recorded what it learned. "
+            "Enable with: leap config set evolution.enabled true"
+        )
+    print("  See the result on the board: leap board evolution")
+    return 0
+
+
+def _report_error(message: str, as_json: bool) -> None:
+    if as_json:
+        print(json.dumps({"ok": False, "error": message}, ensure_ascii=False))
+    else:
+        print(f"evolve: {message}")
+
+
+__all__ = ["cmd_evolve"]
diff --git a/src/leapflow/cli/context.py b/src/leapflow/cli/context.py
index 11a3e91c..288e80b2 100644
--- a/src/leapflow/cli/context.py
+++ b/src/leapflow/cli/context.py
@@ -3114,12 +3114,15 @@ def _capability_observation_service(self):
         )
         return self._observation_service
 
-    def _current_environment_dict(self):
-        """The environment evidence is recorded against.
-
-        Carried with each degradation so one application upgrade that breaks N
-        capabilities is recognisable as one transition rather than N coincidences -- the
-        teacher can then answer once, and usually with a rebind rather than N rebuilds.
+    def _current_environment_fingerprint(self):
+        """The environment a capability decision is made against, as a fingerprint.
+
+        A single object so the world-model driver's distillation path and its
+        acquisition path agree on the environment: the distilled-knowledge store tags
+        each entry with the fingerprint id, and a queued proposal carries the same
+        fingerprint into the lifecycle queue so the causal ledger can place it. Returns
+        ``None`` when the platform layer is unavailable, which the callers degrade
+        around.
         """
         try:
             from leapflow.domain.environment_fingerprint import EnvironmentFingerprint
@@ -3128,10 +3131,20 @@ def _current_environment_dict(self):
             return EnvironmentFingerprint.from_platform_manifest(
                 PlatformManifest.default_darwin(),
                 workspace_root=str(getattr(self.settings, "workspace_root", "") or ""),
-            ).to_dict()
+            )
         except (ImportError, AttributeError, TypeError, ValueError):
             logger.debug("environment fingerprint unavailable", exc_info=True)
-            return {}
+            return None
+
+    def _current_environment_dict(self):
+        """The environment evidence is recorded against.
+
+        Carried with each degradation so one application upgrade that breaks N
+        capabilities is recognisable as one transition rather than N coincidences -- the
+        teacher can then answer once, and usually with a rebind rather than N rebuilds.
+        """
+        fingerprint = self._current_environment_fingerprint()
+        return fingerprint.to_dict() if fingerprint is not None else {}
 
     def _current_affordances(self):
         """App-level affordances the task environment currently offers.
@@ -3198,6 +3211,14 @@ def _resolve_lifecycle_governor(self):
                     profile_layout.capability_proposal_queue_path
                 ),
                 outcome_store=JsonPluginOutcomeStore(profile_layout.plugin_outcomes_path),
+                # The approval-gated actor that actually disables a plugin. Without it the
+                # governor decided "quarantine" and nothing happened: trust dropped but the
+                # plugin kept serving, and the queue never advanced past PROBATION. Built
+                # from the live registry's self_management plugin, and left ``None`` only
+                # when that plugin is absent (an in-process CLI that composed no lifecycle
+                # surface) -- in which case quarantine records intent without executing it,
+                # which is the honest degradation rather than a silent no-op.
+                lifecycle_actor=self._plugin_lifecycle_actor(),
                 # The process ledger, hydrated from DuckDB -- not a fresh one. Letting
                 # the governor default to its own would give one process two divergent
                 # views of trust: the transitions it computed would land in a throwaway
@@ -3233,6 +3254,69 @@ def _process_trust_ledger(self):
             return None
         return getattr(advisor, "_trust_ledger", None) if advisor is not None else None
 
+    def _plugin_lifecycle_actor(self):
+        """The approval-gated actor that executes governance decisions, or ``None``.
+
+        ``LifecycleGovernor`` decides *quarantine*; something has to carry it out, and
+        that something is the ``self_management`` plugin's approval-gated disable/remove
+        path. Without an actor the governor's decision was inert -- trust fell but the
+        plugin kept serving and the queue never advanced -- which is a wiring gap a unit
+        test cannot see because every unit test injects its own actor.
+
+        Returns ``None`` when the registry has no ``self_management`` plugin (an
+        in-process CLI that composed no lifecycle surface). That is honest degradation:
+        the governor still records the intended transition; it simply cannot execute it
+        until a runtime with the plugin is present.
+        """
+        try:
+            from leapflow.plugins import get_registry
+            from leapflow.plugins.adaptive_loop import SelfManagementLifecycleActor
+
+            return SelfManagementLifecycleActor.from_registry(get_registry())
+        except (ImportError, RuntimeError, AttributeError):
+            logger.debug("plugin lifecycle actor unavailable", exc_info=True)
+            return None
+
+    def _active_proposal_ids(self) -> dict:
+        """Map ``plugin_id -> proposal_id`` from the live lifecycle queue.
+
+        The sweep verifies an acquired plugin's effect and feeds the verdict to
+        ``LifecycleGovernor.record_outcome``, which keys the lifecycle record by
+        proposal id. The plugin only knows its own id, so this bridges the two: the
+        proposal sink stamped ``metadata.plugin_id`` on each queued item, so the map is
+        a read of the queue rather than a second bookkeeping structure that could drift.
+
+        Empty on any failure -- an unresolvable map degrades a governance outcome to an
+        untracked one, which is preferable to failing the cold-path sweep.
+        """
+        settings = getattr(self, "settings", None)
+        profile_layout = getattr(settings, "profile_layout", None)
+        if profile_layout is None:
+            return {}
+        try:
+            from leapflow.storage.capability_proposal_queue import (
+                JsonCapabilityProposalQueue,
+            )
+
+            queue = JsonCapabilityProposalQueue(
+                profile_layout.capability_proposal_queue_path
+            )
+            mapping: dict = {}
+            # ``active()`` returns items newest-first (sorted by updated/created), so the
+            # first mapping seen for a plugin is its most recent lifecycle record. Keep
+            # that one: a plugin can hold several active records (different capability,
+            # environment, or source), and governing the *newest* is what the sweep
+            # means by "this plugin's outcome". Overwriting unconditionally would leave
+            # the map pointing at the oldest record and update the wrong one.
+            for item in queue.active(limit=0):
+                plugin_id = str(dict(item.metadata).get("plugin_id") or "")
+                if plugin_id and plugin_id not in mapping:
+                    mapping[plugin_id] = item.proposal_id
+            return mapping
+        except (ImportError, AttributeError, OSError, RuntimeError, TypeError, ValueError):
+            logger.debug("active proposal id map unavailable", exc_info=True)
+            return {}
+
     async def _run_coevolution_sweep(self):
         """Cold-path governance sweep: verify effects, drain quarantine, find residue.
 
@@ -3260,6 +3344,11 @@ async def _run_coevolution_sweep(self):
                 governor=self._resolve_lifecycle_governor(),
                 tracker=getattr(self, "_quarantine_tracker", None)
                 or current_quarantine_tracker(),
+                # plugin_id -> proposal_id, so a governance outcome updates the *right*
+                # lifecycle record rather than calling ``record_outcome`` with an empty
+                # proposal id (a silent no-op that left the queue frozen). Read from the
+                # queue's live items, whose ``metadata.plugin_id`` the proposal sink set.
+                proposal_ids=self._active_proposal_ids(),
             )
             # Facts are collected where they are produced -- the engine's resolution
             # path, the install tools, and the tool-outcome sink -- so the sweep reads
@@ -3350,16 +3439,52 @@ async def _drive_world_model_evolution(self, trajectory: list, goal: str):
                     if getattr(settings, "evolution_enabled", False)
                     else None
                 ),
+                # P5 authority in the production path: only an authorised requirement
+                # origin may drive an acquisition. Rebind-vs-acquire (whether an
+                # installed provider already covers the capability) is decided upstream
+                # by the teacher from failed-outcome hindsight and the alternatives it
+                # was shown -- a declared-fitness re-check here would re-introduce the
+                # semantic-regression blind spot -- so the driver adds authority only.
+                authorising_origins=tuple(
+                    getattr(settings, "evolution_authorising_origins", ()) or ()
+                ),
             )
             return await driver.drive(
                 trajectory,
                 goal,
+                environment=self._current_environment_fingerprint(),
                 workspace_root=str(getattr(settings, "workspace_root", "") or ""),
             )
         except (ImportError, AttributeError, OSError, RuntimeError, TypeError, ValueError):
             logger.debug("world-model evolution driver unavailable", exc_info=True)
             return None
 
+    async def run_learning_boundary(self, *, reason: str = "shutdown") -> dict[str, Any]:
+        """Run the learning boundary once and report what it did.
+
+        This is the only place capability evolution is driven from, so *when* it is
+        called decides when the framework can evolve at all. It used to be reachable
+        only from :meth:`cleanup`, which in daemon mode means process shutdown: a
+        daemon that ran for a week never evolved, one killed with SIGKILL never
+        evolved at all, and the single flush at the end mixed every session and every
+        workspace of that lifetime into one episode carrying the last user's goal.
+
+        Named and public so a semantic boundary can drive it -- a finished session,
+        or an explicit ``leap evolve`` -- instead of only the process dying.
+        ``reason`` is recorded rather than inspected: the pipeline does the same work
+        either way, and the label is what lets a reader tell a shutdown flush from a
+        session boundary from a hand-run one.
+        """
+        started = time.perf_counter()
+        before = len(self.prediction_loop.trajectory_buffer) if self.prediction_loop else 0
+        await self._on_session_end_learning()
+        return {
+            "ok": True,
+            "reason": reason,
+            "trajectory_steps": before,
+            "duration_s": round(time.perf_counter() - started, 3),
+        }
+
     async def _on_session_end_learning(self) -> None:
         """End-of-session OPD learning pipeline (8 phases) with full observability.
 
@@ -3390,6 +3515,7 @@ async def _on_session_end_learning(self) -> None:
             t0 = time.perf_counter()
             try:
                 trajectory, goal = self.prediction_loop.flush_trajectory()
+                phase_detail: dict[str, Any] = {}
                 if trajectory:
                     # The world model is the first driver of capability evolution:
                     # the same hindsight call that grades the episode also proposes
@@ -3404,26 +3530,29 @@ async def _on_session_end_learning(self) -> None:
                         )
                     if grades and self.replay_engine is not None:
                         self.replay_engine.set_replay_priorities(grades)
-                    phase_detail = {"actions_graded": len(grades) if grades else 0}
+                    phase_detail["actions_graded"] = len(grades) if grades else 0
                     if drive is not None:
                         phase_detail.update(drive.to_dict())
-                    # Cold-path governance sweep: effect verification, quarantine
-                    # drain, reclamation. Runs whether or not the teacher proposed
-                    # anything, so its no-op traces distinguish a quiet session from
-                    # a sweep that never ran.
-                    sweep = await self._run_coevolution_sweep()
-                    if sweep is not None:
-                        phase_detail.update(sweep.to_dict())
-                    observer.on_phase_success(
-                        "trajectory_grading", time.perf_counter() - t0, phase_detail,
-                    )
-                    phases_ok += 1
                 else:
-                    observer.on_phase_success(
-                        "trajectory_grading", time.perf_counter() - t0,
-                        {"actions_graded": 0, "note": "empty_trajectory"},
-                    )
-                    phases_ok += 1
+                    phase_detail.update({"actions_graded": 0, "note": "empty_trajectory"})
+                # Cold-path governance sweep: effect verification, quarantine drain,
+                # reclamation. Outside the trajectory branch, because its whole
+                # purpose is that its no-op traces distinguish a quiet session from a
+                # sweep that never ran -- and nested inside it, an empty trajectory
+                # skipped the sweep entirely and produced exactly the ambiguity it
+                # was written to remove. Three reachability segments read
+                # "no sweep trace observed" on a live board for that reason alone.
+                #
+                # Nothing here depends on the trajectory: the sweep reads the process
+                # observation buffer and the proposal queue, both of which carry work
+                # from turns that predate this boundary.
+                sweep = await self._run_coevolution_sweep()
+                if sweep is not None:
+                    phase_detail.update(sweep.to_dict())
+                observer.on_phase_success(
+                    "trajectory_grading", time.perf_counter() - t0, phase_detail,
+                )
+                phases_ok += 1
             except Exception as exc:
                 observer.on_phase_failure("trajectory_grading", exc, time.perf_counter() - t0)
                 phases_failed += 1
@@ -3776,7 +3905,7 @@ async def cleanup(self) -> None:
             logger.debug("EventBus shutdown failed", exc_info=True)
         # OPD end-of-session learning pipeline
         if self.settings.replay_on_session_end:
-            await self._on_session_end_learning()
+            await self.run_learning_boundary(reason="shutdown")
         # Persist session summary before memory shutdown
         await self._persist_session_summary()
         # Shutdown all memory providers (stops GC, closes DB)
diff --git a/src/leapflow/daemon/client.py b/src/leapflow/daemon/client.py
index 93095770..bfebee0a 100644
--- a/src/leapflow/daemon/client.py
+++ b/src/leapflow/daemon/client.py
@@ -522,6 +522,10 @@ async def session_analyze(self) -> dict[str, Any]:
         """Ensure a session-analysis watch and run one analysis cycle now."""
         return dict(await self.request("session.analyze") or {})
 
+    async def evolution_run(self, reason: str = "manual") -> dict[str, Any]:
+        """Run the learning boundary in the daemon now."""
+        return dict(await self.request("evolution.run", {"reason": reason}) or {})
+
     async def signal_record(self, event_type: str, payload: dict[str, Any]) -> dict[str, Any]:
         """Inject a signal event into the daemon's EventBus."""
         return dict(await self.request(
diff --git a/src/leapflow/daemon/monitor_coordinator.py b/src/leapflow/daemon/monitor_coordinator.py
index 5945b5d2..c48b9c76 100644
--- a/src/leapflow/daemon/monitor_coordinator.py
+++ b/src/leapflow/daemon/monitor_coordinator.py
@@ -69,6 +69,9 @@ async def start(self, ctx: Any, notification_bus: Any, settings: Any) -> None:
             from leapflow.monitor.signal_producer import SignalObservationProducer
 
             bus = notification_bus
+            # The evolution publisher captures this before the trace sink is installed.
+            # It schedules display fan-out on the event loop, never on a probe site.
+            self._notification_bus = bus
             self._monitors = MonitorManager(
                 holder=ctx._db_holder,
                 emit=lambda event_type, payload: bus.emit_event(event_type, **payload),
@@ -178,6 +181,8 @@ def _make_evolution_publisher(self, ctx: Any) -> Any:
         except RuntimeError:
             return None
 
+        notification_bus = self._notification_bus
+
         def _publish(trace: Any) -> None:
             detail = dict(getattr(trace, "detail", None) or {})
             if detail.get("phase") == "composition":
@@ -189,10 +194,22 @@ def _publish(trace: Any) -> None:
                 "correlation": dict(getattr(trace, "correlation", None) or {}),
             }
             event_type = f"evolution.{payload['kind'] or 'trace'}"
+
+            def _dispatch() -> None:
+                asyncio.ensure_future(bus.handle_event(event_type, payload))
+                if notification_bus is not None:
+                    try:
+                        from leapflow.telemetry.evolution_presentation import EvolutionPresentationEvent
+
+                        presentation = EvolutionPresentationEvent.from_trace(trace).to_dict()
+                        notification_bus.emit(Notification(
+                            event_type="evolution.presentation", payload=presentation,
+                        ))
+                    except Exception:  # noqa: BLE001 - display fan-out must stay best-effort
+                        logger.debug("daemon: evolution presentation not published", exc_info=True)
+
             try:
-                loop.call_soon_threadsafe(
-                    lambda: asyncio.ensure_future(bus.handle_event(event_type, payload))
-                )
+                loop.call_soon_threadsafe(_dispatch)
             except RuntimeError:
                 # Loop already closed (shutdown). The trace is still buffered and
                 # will be flushed by the atexit hook; only the live refresh is lost.
diff --git a/src/leapflow/daemon/protocol.py b/src/leapflow/daemon/protocol.py
index bd81e417..c2f0ea84 100644
--- a/src/leapflow/daemon/protocol.py
+++ b/src/leapflow/daemon/protocol.py
@@ -248,6 +248,15 @@ async def session_analyze(self) -> Dict[str, Any]:
         """Ensure a session-analysis watch and run one analysis cycle now."""
         ...
 
+    async def evolution_run(self, reason: str = "manual") -> Dict[str, Any]:
+        """Run the learning boundary now, the one path that drives evolution.
+
+        Exposed because the boundary was otherwise reachable only from context
+        cleanup -- process shutdown in daemon mode -- which made "when does the
+        framework evolve" unanswerable and untestable without killing the daemon.
+        """
+        ...
+
     async def status(self, session_id: str = "") -> Dict[str, Any]:
         """Return daemon status (uptime, connections, db path, etc.).
 
@@ -480,6 +489,7 @@ async def gateway_send(
     "session.history": "session_history",
     "session.detail": "session_detail",
     "session.analyze": "session_analyze",
+    "evolution.run": "evolution_run",
     "daemon.status": "status",
     "daemon.shutdown": "shutdown",
     "host.status": "host_status",
diff --git a/src/leapflow/daemon/service.py b/src/leapflow/daemon/service.py
index 39727bc7..718e9371 100644
--- a/src/leapflow/daemon/service.py
+++ b/src/leapflow/daemon/service.py
@@ -936,6 +936,23 @@ async def session_detail(
     async def session_analyze(self) -> dict[str, Any]:
         return await self._session_coordinator.analyze(self._monitors, self._ctx, self._settings)
 
+    async def evolution_run(self, reason: str = "manual") -> dict[str, Any]:
+        """Drive the learning boundary in the daemon's context, now.
+
+        The daemon owns the context that holds the trajectory buffer, the world-model
+        teacher and the proposal queue, so this has to run here rather than in the
+        calling CLI process -- a second context would grade an empty buffer and
+        report success having done nothing.
+        """
+        ctx = self._ctx
+        if ctx is None:
+            return {"ok": False, "error": "daemon context unavailable"}
+        try:
+            return await ctx.run_learning_boundary(reason=str(reason or "manual"))
+        except Exception as exc:  # noqa: BLE001 - reported to the caller, never fatal
+            logger.warning("daemon: learning boundary failed: %s", exc, exc_info=True)
+            return {"ok": False, "error": str(exc), "reason": str(reason or "manual")}
+
     def _ensure_session_registry(self, base_engine: Any) -> Any:
         return self._session_coordinator.ensure_registry(base_engine, self._settings)
 
diff --git a/src/leapflow/dashboard/hub.py b/src/leapflow/dashboard/hub.py
index 1912e7ab..285f168d 100644
--- a/src/leapflow/dashboard/hub.py
+++ b/src/leapflow/dashboard/hub.py
@@ -21,6 +21,9 @@ class ViewHub:
 
     def __init__(self, maxsize: int = 128) -> None:
         self._subscribers: dict[str, asyncio.Queue[Optional[dict[str, Any]]]] = {}
+        # A dropped increment must not leave a live lens permanently stale. The next
+        # successful delivery asks that browser to fetch its authoritative snapshot.
+        self._resync_required: set[str] = set()
         self._maxsize = maxsize
 
     def subscribe(self, subscriber_id: str) -> asyncio.Queue[Optional[dict[str, Any]]]:
@@ -32,6 +35,7 @@ def subscribe(self, subscriber_id: str) -> asyncio.Queue[Optional[dict[str, Any]
     def unsubscribe(self, subscriber_id: str) -> None:
         """Remove a browser subscriber."""
         self._subscribers.pop(subscriber_id, None)
+        self._resync_required.discard(subscriber_id)
 
     def broadcast(self, message: dict[str, Any]) -> int:
         """Deliver a message to all subscribers (non-blocking); return count.
@@ -41,10 +45,23 @@ def broadcast(self, message: dict[str, Any]) -> int:
         """
         delivered = 0
         for sid, queue in list(self._subscribers.items()):
+            resynced = False
+            if sid in self._resync_required:
+                try:
+                    queue.put_nowait({"type": "view.resync", "payload": {"reason": "dropped_events"}})
+                    self._resync_required.discard(sid)
+                    resynced = True
+                except asyncio.QueueFull:
+                    continue
             try:
                 queue.put_nowait(message)
                 delivered += 1
             except asyncio.QueueFull:
+                # A successful resync marker already occupies the one available
+                # slot. Do not re-arm it because the marker itself tells the client
+                # to fetch the snapshot and discard this increment.
+                if not resynced:
+                    self._resync_required.add(sid)
                 logger.debug("view_hub: dropped message for slow subscriber %s", sid)
         return delivered
 
@@ -60,6 +77,7 @@ async def shutdown(self) -> None:
             except asyncio.QueueFull:
                 pass
         self._subscribers.clear()
+        self._resync_required.clear()
 
 
 __all__ = ["ViewHub"]
diff --git a/src/leapflow/dashboard/server.py b/src/leapflow/dashboard/server.py
index 3aeb237f..b5d183f4 100644
--- a/src/leapflow/dashboard/server.py
+++ b/src/leapflow/dashboard/server.py
@@ -76,7 +76,17 @@ def _index_html(index: Path) -> str:
     return _ASSET_VERSION_RE.sub(rf"\1?v={_asset_version()}", index.read_text(encoding="utf-8"))
 
 
-_MONITOR_EVENTS = frozenset({EVENT_FINDING, EVENT_WATCH_STATE, EVENT_ERROR, EVENT_HEARTBEAT, "signal.stream"})
+_MONITOR_EVENTS = frozenset({
+    EVENT_FINDING,
+    EVENT_WATCH_STATE,
+    EVENT_ERROR,
+    EVENT_HEARTBEAT,
+    "signal.stream",
+    # Presentation-only increment for the hidden evolution_live lens. The daemon
+    # publishes it after buffering the trace and from the event loop, never inline
+    # with a registry/trust mutation.
+    "evolution.presentation",
+})
 # Only these RPCs may be triggered by browser actions (least privilege).
 #
 # The hardware entries are read-or-request only, and that boundary is the whole point.
diff --git a/src/leapflow/dashboard/service.py b/src/leapflow/dashboard/service.py
index 507e8620..c0e20000 100644
--- a/src/leapflow/dashboard/service.py
+++ b/src/leapflow/dashboard/service.py
@@ -11,6 +11,7 @@
 from __future__ import annotations
 
 import logging
+import time
 from typing import Any, Protocol, runtime_checkable
 
 from leapflow.dashboard.intent import DashboardIntent
@@ -215,6 +216,130 @@ def _empty_state(domain: str, watch: dict[str, Any]) -> dict[str, Any]:
     }
 
 
+def _provenance(payload: dict[str, Any], watch: dict[str, Any]) -> dict[str, Any]:
+    """State when the rendered data was observed, when it was last confirmed, and
+    whether the watch behind it is keeping its cadence.
+
+    Two instants, deliberately not merged, because merging them is what made the
+    board unreadable:
+
+    * ``observed_at`` -- when the content on screen was produced. Findings dedup on
+      a content fingerprint, so an unchanged subject keeps its previous finding and
+      this can legitimately be hours old.
+    * ``checked_at`` -- when a cycle last completed. It advances on every run,
+      including one that concluded nothing had changed and therefore wrote nothing.
+
+    Reporting only the first made a correct system look broken: pressing refresh ran
+    a real cycle, the fingerprint matched, no finding was written, and every figure
+    on the page -- including its own age -- stayed frozen. Reporting only the second
+    would be worse: it would age a stale page from the clock and call it current.
+
+    So ``stale`` is a verdict about the *watch*, not the content: a cycle has not
+    completed in two cadences, which means the page cannot be trusted to reflect
+    anything. Content that is old but freshly confirmed is not stale, it is stable,
+    and ``unchanged_for_seconds`` says how long it has been so.
+
+    Two cadences rather than a fixed number of seconds: one missed cycle is
+    scheduling jitter, two is a cadence that is not being kept. With no declared
+    cadence (event, cron, condition) the verdict is withheld rather than guessed --
+    judging an event-driven watch against an invented interval would be the same
+    class of error this block exists to remove.
+    """
+    now = time.time()
+    observed_at = float(payload.get("observed_at") or 0.0)
+    checked_at = float(watch.get("last_run_at") or 0.0)
+    # A payload with no instant of its own is dated by the cycle that produced it.
+    if observed_at <= 0.0:
+        observed_at = checked_at
+    cadence = float(watch.get("interval_seconds") or 0.0)
+    next_due_at = float(watch.get("next_due_at") or 0.0)
+    return {
+        "observed_at": observed_at,
+        "age_seconds": max(0.0, now - observed_at) if observed_at > 0.0 else 0.0,
+        "checked_at": checked_at,
+        "checked_age_seconds": max(0.0, now - checked_at) if checked_at > 0.0 else 0.0,
+        # How long the subject has held still. Only meaningful once a check has
+        # happened after the observation; otherwise there is nothing to compare.
+        "unchanged_for_seconds": (
+            max(0.0, checked_at - observed_at)
+            if checked_at > 0.0 and observed_at > 0.0
+            else 0.0
+        ),
+        "cadence_seconds": cadence,
+        "next_due_at": next_due_at,
+        "next_due_in_seconds": max(0.0, next_due_at - now) if next_due_at > 0.0 else 0.0,
+        "run_count": int(watch.get("run_count") or 0),
+        "watch_state": str(watch.get("state") or ""),
+        "muted": bool(watch.get("muted")),
+        # The identity of what produced the page, so the bar can offer a refresh
+        # rather than only report that the page is behind. Being able to re-run the
+        # cycle from here is what turns the freshness reading into a closed loop:
+        # the reader changes something the board told them to change, refreshes, and
+        # sees whether it landed.
+        "watch_id": str(watch.get("watch_id") or ""),
+        # Absent is not the same as fresh. A board whose watch never ran has no
+        # instant to age, and saying "0s ago" there would invent one.
+        "observed": observed_at > 0.0,
+        "checked": checked_at > 0.0,
+        "stale": bool(
+            cadence > 0.0
+            and checked_at > 0.0
+            and (now - checked_at) > cadence * 2
+        ),
+    }
+
+
+def _evidence_trend(findings: list[dict[str, Any]]) -> dict[str, Any]:
+    """Turn the retained framework_evolution findings into one evolution axis.
+
+    The board could say what the framework *is* and never what direction it is
+    moving. Every panel was a cross-section of one instant; the only time-shaped
+    element was the episode timeline, which is gated on episodes and therefore hidden
+    in exactly the state where "has anything started yet" is the question being asked.
+
+    So the axis is built from the findings already retained for the domain. They are
+    persisted newest-first and deduped on content, which makes them a record of
+    *changes* rather than of ticks -- one point per distinct state, which is the right
+    granularity for this question and cheaper than sampling every cycle.
+
+    A single point is emitted and drawn. It reads "one observation, here it is",
+    which is a fact; suppressing it until a second arrives would hide the beginning
+    of every evolution the board exists to show.
+    """
+    points: list[dict[str, Any]] = []
+    for finding in reversed(findings or []):  # oldest first, so the axis reads left to right
+        payload = finding.get("payload")
+        if not isinstance(payload, dict):
+            continue
+        summary = payload.get("summary")
+        if not isinstance(summary, dict):
+            continue
+        with_evidence = summary.get("segments_with_evidence")
+        if with_evidence is None:
+            continue
+        observed_at = float(payload.get("observed_at") or finding.get("ts") or 0.0)
+        points.append({
+            "x": observed_at,
+            "y": int(with_evidence),
+            "at": observed_at,
+        })
+    total = 0
+    for finding in findings or []:
+        payload = finding.get("payload")
+        if isinstance(payload, dict) and isinstance(payload.get("summary"), dict):
+            total = int(payload["summary"].get("segments_total") or 0)
+            break
+    return {
+        "series": [{"label": "Segments with runtime evidence", "points": points}] if points else [],
+        "samples": len(points),
+        "segments_total": total,
+        "first_at": points[0]["at"] if points else 0.0,
+        "last_at": points[-1]["at"] if points else 0.0,
+        # Direction, stated rather than left to the reader's eye on a two-point line.
+        "delta": (points[-1]["y"] - points[0]["y"]) if len(points) > 1 else 0,
+    }
+
+
 def _hardware_notice(
     inventory: dict[str, Any], digest: dict[str, Any]
 ) -> dict[str, str] | None:
@@ -332,6 +457,12 @@ def _short_id(value: Any) -> str:
     # template -> (finding domain, data key the template binds to)
     "capability": ("capability_adaptation", "capability_plan"),
     "evolution": ("framework_evolution", "evolution"),
+    # The hidden demo/audit lens reads the same immutable evolution snapshot.
+    # It adds no data source or mutation path.
+    "causal_trace": ("framework_evolution", "evolution"),
+    # The live lens consumes the same authoritative snapshot and only augments it
+    # with presentation events delivered through the browser WebSocket.
+    "evolution_live": ("framework_evolution", "evolution"),
     "hardware": ("hardware", "hardware"),
 }
 """Templates whose data is a producer's finding payload, not a session lens.
@@ -524,6 +655,7 @@ async def _build_from_finding_payload(
             data_key: payload,
             "findings": domain_findings or None,
             "watch": watch,
+            "provenance": _provenance(payload, watch),
             "observation": {
                 "watch_state": watch.get("state", ""),
                 "watch_muted": watch.get("muted", False),
@@ -539,6 +671,13 @@ async def _build_from_finding_payload(
             # idle with nothing to report, and no watch at all means the producer is
             # not being scheduled -- three different next steps.
             data["empty"] = _empty_state(finding_domain, watch)
+        if finding_domain == "framework_evolution":
+            # A sibling top-level key, not folded into the bound payload. The producer
+            # owns everything under ``evolution.*`` and a test asserts that contract;
+            # this series is derived here because only the retained finding list
+            # carries history, and hiding a service-derived figure inside the
+            # producer's namespace would make that ownership unreadable.
+            data["evidence_trend"] = _evidence_trend(domain_findings or [])
         if template == "hardware":
             # The fleet list comes from the live registry rather than the cycle payload.
             # The digest is capped at eight charted channels and is up to a monitor
@@ -587,6 +726,7 @@ async def _build_session(self, template: str, provider: DashboardDataProvider) -
             "title": "Session Analysis",
             "analysis": analysis,
             "observation": observation,
+            "provenance": _provenance(analysis, session_watch),
             "artifact_context": analysis.get("artifact_context") or [],
             "findings": session_findings,
             "watch": session_watch,
@@ -607,6 +747,15 @@ def _render(self, template: str, data: dict[str, Any]) -> dict[str, Any]:
                 meta["templates"] = self._templates.visible_names()
                 meta["hidden_templates"] = self._templates.hidden_names()
                 meta["active_template"] = name
+                # Freshness rides in ``meta`` rather than the component tree so it is
+                # page chrome on every lens at once, and so a template author cannot
+                # forget to bind it. Lifted here for the same reason the lens list is:
+                # this is the one place every build path passes through. A build path
+                # that computes no provenance says nothing rather than claiming the
+                # page is current.
+                provenance = data.get("provenance")
+                if isinstance(provenance, dict):
+                    meta["provenance"] = provenance
         return spec
 
     async def _build_signals(self, template: str, provider: DashboardDataProvider) -> dict[str, Any]:
diff --git a/src/leapflow/dashboard/static/app.js b/src/leapflow/dashboard/static/app.js
index 6992c1da..29473de5 100644
--- a/src/leapflow/dashboard/static/app.js
+++ b/src/leapflow/dashboard/static/app.js
@@ -18,6 +18,9 @@
   const HIDDEN_NAV_TEMPLATES = new Set(["finance", "research", "sentiment"]);
   let figSeq = 0;  // academic figure counter, reset each render()
   let tblSeq = 0;  // academic table counter, reset each render()
+  // Custom live lenses are recreated from the authoritative snapshot after every
+  // fetch. WebSocket increments only update the currently rendered instances.
+  let _evolutionLiveControllers = [];
 
   // ── Signal auto-refresh state ──
   let _signalRefreshTimer = null;
@@ -221,26 +224,172 @@
       "near": "у границы", "outside": "вне допуска", "unknown": "неизвестно"
     }
   };
+  const I18N_LIVE = {
+    en: {
+      "Evolution live": "Evolution live", "Read-only event lanes for environment, decision, and governance evidence.": "Read-only event lanes for environment, decision, and governance evidence.",
+      "Run posture": "Run posture", "Current snapshot and live increments stay distinct; missing evidence remains visible.": "Current snapshot and live increments stay distinct; missing evidence remains visible.",
+      "Episodes": "Episodes", "Pipeline evidence": "Pipeline evidence", "Unadmitted intents": "Unadmitted intents", "Regressions": "Regressions",
+      "Live event lanes": "Live event lanes", "Presentation-only trace projection. Reconnect resynchronizes from the current evolution snapshot.": "Presentation-only trace projection. Reconnect resynchronizes from the current evolution snapshot.",
+      "Counterfactual / mutation matrix": "Counterfactual / mutation matrix", "Latest durable episode projection; rows do not imply an unrecorded install or approval.": "Latest durable episode projection; rows do not imply an unrecorded install or approval.",
+      "Trigger": "Trigger", "Capability": "Capability", "Decision": "Decision", "Mutation": "Mutation", "Evidence tier": "Evidence tier", "Gap closure": "Gap closure",
+      "Environment lane": "Environment lane", "Decision lane": "Decision lane", "Governance lane": "Governance lane", "Live events": "Live events", "Event count": "Event count", "No live events": "No live events", "Event detail": "Event detail", "Select a live event to inspect its evidence references.": "Select a live event to inspect its evidence references.",
+      "Live since snapshot": "Live since snapshot",
+      "{count} event(s) arrived after this snapshot. Snapshot metrics refresh on the next monitor cycle.": "{count} event(s) arrived after this snapshot. Snapshot metrics refresh on the next monitor cycle.",
+      "Environment events appear when a probe records a change in the surroundings.": "Environment events appear when a probe records a change in the surroundings.",
+      "Decision events appear when a recorded observation drives a capability choice.": "Decision events appear when a recorded observation drives a capability choice.",
+      "Governance events appear when trust, quarantine or reclamation moves.": "Governance events appear when trust, quarantine or reclamation moves."
+    },
+    zh: {
+      "Evolution live": "演化实时视图", "Read-only event lanes for environment, decision, and governance evidence.": "面向环境、决策和治理证据的只读事件泳道。",
+      "Run posture": "运行态势", "Current snapshot and live increments stay distinct; missing evidence remains visible.": "当前快照与实时增量保持区分；缺失证据保持可见。",
+      "Episodes": "剧集", "Pipeline evidence": "管道证据", "Unadmitted intents": "未准入意图", "Regressions": "回归",
+      "Live event lanes": "实时事件泳道", "Presentation-only trace projection. Reconnect resynchronizes from the current evolution snapshot.": "仅展示的追踪投影。重连时从当前演化快照重新同步。",
+      "Counterfactual / mutation matrix": "反事实 / 变更矩阵", "Latest durable episode projection; rows do not imply an unrecorded install or approval.": "最新持久剧集投影；行内容不代表未记录的安装或审批。",
+      "Trigger": "触发源", "Capability": "能力", "Decision": "决策", "Mutation": "变更", "Evidence tier": "证据层级", "Gap closure": "缺口闭合",
+      "Environment lane": "环境泳道", "Decision lane": "决策泳道", "Governance lane": "治理泳道", "Live events": "实时事件", "Event count": "事件数", "No live events": "暂无实时事件", "Event detail": "事件详情", "Select a live event to inspect its evidence references.": "选择实时事件以查看其证据引用。",
+      "Live since snapshot": "快照后新增",
+      "{count} event(s) arrived after this snapshot. Snapshot metrics refresh on the next monitor cycle.": "{count} 条事件在此快照之后到达。快照类指标将在下一个监控周期刷新。",
+      "Environment events appear when a probe records a change in the surroundings.": "当探针记录到周边环境发生变化时，环境事件会出现在这里。",
+      "Decision events appear when a recorded observation drives a capability choice.": "当已记录的观测驱动一次能力选择时，决策事件会出现在这里。",
+      "Governance events appear when trust, quarantine or reclamation moves.": "当信任、隔离或回收发生变动时，治理事件会出现在这里。"
+    },
+    fr: {
+      "Evolution live": "Évolution en direct", "Read-only event lanes for environment, decision, and governance evidence.": "Voies d’événements en lecture seule pour les preuves d’environnement, de décision et de gouvernance.",
+      "Run posture": "État d’exécution", "Current snapshot and live increments stay distinct; missing evidence remains visible.": "L’instantané et les incréments restent distincts ; les preuves manquantes restent visibles.",
+      "Episodes": "Épisodes", "Pipeline evidence": "Preuves du pipeline", "Unadmitted intents": "Intentions non admises", "Regressions": "Régressions",
+      "Live event lanes": "Voies d’événements live", "Presentation-only trace projection. Reconnect resynchronizes from the current evolution snapshot.": "Projection de trace réservée à l’affichage. La reconnexion se resynchronise depuis l’instantané d’évolution actuel.",
+      "Counterfactual / mutation matrix": "Matrice contrefactuelle / mutations", "Latest durable episode projection; rows do not imply an unrecorded install or approval.": "Projection du dernier épisode durable ; les lignes n’impliquent ni installation ni approbation non enregistrée.",
+      "Trigger": "Déclencheur", "Capability": "Capacité", "Decision": "Décision", "Mutation": "Mutation", "Evidence tier": "Niveau de preuve", "Gap closure": "Clôture de l’écart",
+      "Environment lane": "Voie environnement", "Decision lane": "Voie décision", "Governance lane": "Voie gouvernance", "Live events": "Événements live", "Event count": "Nombre d’événements", "No live events": "Aucun événement live", "Event detail": "Détail de l’événement", "Select a live event to inspect its evidence references.": "Sélectionnez un événement live pour examiner ses références de preuve.",
+      "Live since snapshot": "En direct depuis l’instantané",
+      "{count} event(s) arrived after this snapshot. Snapshot metrics refresh on the next monitor cycle.": "{count} événement(s) sont arrivés après cet instantané. Les métriques d’instantané seront actualisées au prochain cycle de surveillance.",
+      "Environment events appear when a probe records a change in the surroundings.": "Les événements d’environnement apparaissent lorsqu’une sonde enregistre un changement des alentours.",
+      "Decision events appear when a recorded observation drives a capability choice.": "Les événements de décision apparaissent lorsqu’une observation enregistrée motive un choix de capacité.",
+      "Governance events appear when trust, quarantine or reclamation moves.": "Les événements de gouvernance apparaissent lorsque la confiance, la quarantaine ou la récupération évolue."
+    },
+    es: {
+      "Evolution live": "Evolución en vivo", "Read-only event lanes for environment, decision, and governance evidence.": "Carriles de eventos de solo lectura para evidencia de entorno, decisión y gobernanza.",
+      "Run posture": "Estado de ejecución", "Current snapshot and live increments stay distinct; missing evidence remains visible.": "La instantánea y los incrementos en vivo siguen siendo distintos; la evidencia faltante permanece visible.",
+      "Episodes": "Episodios", "Pipeline evidence": "Evidencia del pipeline", "Unadmitted intents": "Intenciones no admitidas", "Regressions": "Regresiones",
+      "Live event lanes": "Carriles de eventos en vivo", "Presentation-only trace projection. Reconnect resynchronizes from the current evolution snapshot.": "Proyección de trazas solo para presentación. La reconexión resincroniza desde la instantánea de evolución actual.",
+      "Counterfactual / mutation matrix": "Matriz contrafactual / de mutaciones", "Latest durable episode projection; rows do not imply an unrecorded install or approval.": "Proyección del último episodio durable; las filas no implican instalación ni aprobación no registradas.",
+      "Trigger": "Desencadenante", "Capability": "Capacidad", "Decision": "Decisión", "Mutation": "Mutación", "Evidence tier": "Nivel de evidencia", "Gap closure": "Cierre de la brecha",
+      "Environment lane": "Carril de entorno", "Decision lane": "Carril de decisión", "Governance lane": "Carril de gobernanza", "Live events": "Eventos en vivo", "Event count": "Conteo de eventos", "No live events": "No hay eventos en vivo", "Event detail": "Detalle del evento", "Select a live event to inspect its evidence references.": "Seleccione un evento en vivo para inspeccionar sus referencias de evidencia.",
+      "Live since snapshot": "En vivo desde la instantánea",
+      "{count} event(s) arrived after this snapshot. Snapshot metrics refresh on the next monitor cycle.": "{count} evento(s) llegaron después de esta instantánea. Las métricas de instantánea se actualizarán en el próximo ciclo de monitoreo.",
+      "Environment events appear when a probe records a change in the surroundings.": "Los eventos de entorno aparecen cuando una sonda registra un cambio en el entorno.",
+      "Decision events appear when a recorded observation drives a capability choice.": "Los eventos de decisión aparecen cuando una observación registrada impulsa una elección de capacidad.",
+      "Governance events appear when trust, quarantine or reclamation moves.": "Los eventos de gobernanza aparecen cuando cambian la confianza, la cuarentena o la recuperación."
+    },
+    ar: {
+      "Evolution live": "التطور المباشر", "Read-only event lanes for environment, decision, and governance evidence.": "مسارات أحداث للقراءة فقط لأدلة البيئة والقرار والحوكمة.",
+      "Run posture": "حالة التشغيل", "Current snapshot and live increments stay distinct; missing evidence remains visible.": "تظل اللقطة والزيادات المباشرة منفصلة؛ وتبقى الأدلة المفقودة مرئية.",
+      "Episodes": "الحلقات", "Pipeline evidence": "أدلة المسار", "Unadmitted intents": "نيات غير مقبولة", "Regressions": "الانحدارات",
+      "Live event lanes": "مسارات الأحداث المباشرة", "Presentation-only trace projection. Reconnect resynchronizes from the current evolution snapshot.": "إسقاط أثر للعرض فقط. تعيد إعادة الاتصال المزامنة من لقطة التطور الحالية.",
+      "Counterfactual / mutation matrix": "مصفوفة الافتراضات المضادة / التغييرات", "Latest durable episode projection; rows do not imply an unrecorded install or approval.": "إسقاط أحدث حلقة دائمة؛ لا تعني الصفوف تثبيتًا أو موافقة غير مسجلة.",
+      "Trigger": "المحفز", "Capability": "القدرة", "Decision": "القرار", "Mutation": "التغيير", "Evidence tier": "طبقة الدليل", "Gap closure": "إغلاق الفجوة",
+      "Environment lane": "مسار البيئة", "Decision lane": "مسار القرار", "Governance lane": "مسار الحوكمة", "Live events": "الأحداث المباشرة", "Event count": "عدد الأحداث", "No live events": "لا توجد أحداث مباشرة", "Event detail": "تفاصيل الحدث", "Select a live event to inspect its evidence references.": "اختر حدثًا مباشرًا لفحص مراجع أدلته.",
+      "Live since snapshot": "مباشر منذ اللقطة",
+      "{count} event(s) arrived after this snapshot. Snapshot metrics refresh on the next monitor cycle.": "وصل {count} حدث بعد هذه اللقطة. تُحدَّث مقاييس اللقطة في دورة المراقبة التالية.",
+      "Environment events appear when a probe records a change in the surroundings.": "تظهر أحداث البيئة عندما يسجّل مِجَسّ تغيّرًا في المحيط.",
+      "Decision events appear when a recorded observation drives a capability choice.": "تظهر أحداث القرار عندما تدفع ملاحظة مسجّلة إلى اختيار قدرة.",
+      "Governance events appear when trust, quarantine or reclamation moves.": "تظهر أحداث الحوكمة عند تغيّر الثقة أو الحجر أو الاستعادة."
+    },
+    ru: {
+      "Evolution live": "Эволюция в реальном времени", "Read-only event lanes for environment, decision, and governance evidence.": "Потоки событий только для чтения для доказательств окружения, решений и управления.",
+      "Run posture": "Состояние запуска", "Current snapshot and live increments stay distinct; missing evidence remains visible.": "Снимок и живые приращения остаются раздельными; отсутствующие доказательства остаются видимыми.",
+      "Episodes": "Эпизоды", "Pipeline evidence": "Свидетельства конвейера", "Unadmitted intents": "Непринятые намерения", "Regressions": "Регрессии",
+      "Live event lanes": "Потоки живых событий", "Presentation-only trace projection. Reconnect resynchronizes from the current evolution snapshot.": "Проекция трассы только для отображения. При переподключении выполняется синхронизация из текущего снимка эволюции.",
+      "Counterfactual / mutation matrix": "Контрфактическая матрица / мутации", "Latest durable episode projection; rows do not imply an unrecorded install or approval.": "Проекция последнего долговечного эпизода; строки не означают незафиксированную установку или согласование.",
+      "Trigger": "Триггер", "Capability": "Возможность", "Decision": "Решение", "Mutation": "Изменение", "Evidence tier": "Уровень доказательств", "Gap closure": "Закрытие пробела",
+      "Environment lane": "Поток окружения", "Decision lane": "Поток решений", "Governance lane": "Поток управления", "Live events": "Живые события", "Event count": "Число событий", "No live events": "Нет живых событий", "Event detail": "Детали события", "Select a live event to inspect its evidence references.": "Выберите живое событие, чтобы просмотреть ссылки на его доказательства.",
+      "Live since snapshot": "Живых с момента снимка",
+      "{count} event(s) arrived after this snapshot. Snapshot metrics refresh on the next monitor cycle.": "{count} событий поступило после этого снимка. Метрики снимка обновятся в следующем цикле мониторинга.",
+      "Environment events appear when a probe records a change in the surroundings.": "События окружения появляются, когда зонд фиксирует изменение обстановки.",
+      "Decision events appear when a recorded observation drives a capability choice.": "События решений появляются, когда записанное наблюдение приводит к выбору возможности.",
+      "Governance events appear when trust, quarantine or reclamation moves.": "События управления появляются при изменении доверия, карантина или высвобождения."
+    }
+  };
   const I18N_TEMPLATES = {
     // Every literal a board template renders, per locale. Held apart from I18N and
     // I18N_PATCH because those two grew with the first two lenses and were never
     // extended: five of seven templates shipped untranslated in every language, and
     // the i18n test only checked signal keys, so nothing failed. Keyed by the English
     // source string, so an untranslated key still renders readable English.
-    zh: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **尚未记录任何效果判定**，因此没有可度量的奖励信号。上面的比率有意留空而非显示 0%。只有当需求声明了预期效果才可能验证，而目前只有世界模型撰写的需求带有预期效果。", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **回归：已闭合的缺口再次复发。** 一次看起来成功的演进并未站住。这是本看板上唯一需要立即处理的发现。", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **仅快照。** 目前尚无可重建的因果历史，因此时间线是「缺席」而非「空白」。原因由管道贯通度中的 `策略决策` 一行说明；实时快照与贯通度表本身不受影响。", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **部分插件因内部缺陷被冻结。** 冻结的插件仍报告 `DRAFT`，而信任维度只做「打分」，因此若未同时注销，它仍可被选中——请查看 `可被选中` 列。", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **验证层级：L2（声明式适配）。** 观测被退役，只意味着某个候选**声明**自己提供该能力，并不意味着该能力被观测到确实生效。效果验证（L3）尚未接线，因此本看板上的任何闭合都不应被读作「已证实」。", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> 需要至少完成一个观测周期才会有内容。若持续为空，请检查调度器是否启用、`framework-evolution` watch 是否已 armed 且未静音。", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> 当一次环境观测导向一次能力决策时，才会写下一条剧集。目前尚无记录——这既可能是系统本就安静，也可能是管道更早就断了：**管道**页签会指出它断在哪一段，以及什么能解除阻塞。", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> 目前没有任何机制自动回收它们。每一个都占着一个工具名、出现在能力列表里，却不可被选中——注册表朝着没有任何需求能用的方向增长。", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> 这些提议未进入任何管道，因此不会出现在任何决策记录或观测中。是否准入是一项配置选择。", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "比值低于 1.0 表示采样循环未能维持其声明的节奏。", "Abstained": "弃权", "Acquisition authority": "获取授权", "Acquisition lifecycle": "获取生命周期", "Action": "动作", "After": "变更后", "An unverified declaration has its writable channels demoted to read-only.": "未核验的声明，其可写通道会被降级为只读。", "Approval": "审批", "Autonomous governance": "自主治理", "Autonomy": "自主级别", "Before": "变更前", "CANDIDATE": "候选级", "Calibrated at": "校准时间", "Calibration health": "校准健康度", "Calls": "调用次数", "Calls (decisions)": "观点（决策）", "Candlestick": "K 线", "Capability": "能力", "Capability adaptation": "能力适配", "Capability observations": "能力观测", "Capability ownership": "能力归属", "Capability topology": "能力拓扑", "Change": "变化", "Channel": "通道", "Channels": "通道数", "Channels that have never been calibrated or whose calibration has expired are shown first.": "从未校准或校准已过期的通道排在最前。", "Command": "命令", "Commanded versus observed, best tracking first": "命令值与实测值对比，跟随最好者在前", "Composition": "组成", "Concerns (open questions)": "关切（待答问题）", "Confidence": "置信度", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "统计所有绘制通道。“接近”指处于声明边界的 5% 以内。", "Cycles run": "已运行周期", "DRAFT": "草稿级", "Days since": "距今天数", "Decision": "决策", "Decisions read as calls; action items as the execution checklist.": "决策即观点，行动项即执行清单。", "Declared Hz": "声明频率 (Hz)", "Desk brief": "交易台简报", "Device": "设备", "Dropped samples": "丢弃的样本", "Each row names one blocked segment and the change that would unblock it.": "每一行指出一个受阻环节，以及能解除阻塞的那项变更。", "Effect verification (L3)": "效果验证（L3）", "Effects declared": "已声明效果", "Entities as references, and recommended next prompts to advance the work.": "实体作为参考，并给出推进工作的后续追问。", "Entities in play and the open risks still to resolve.": "涉及的实体，以及尚未解决的敞口风险。", "Envelope, rate, staleness and quality observations · newest first": "包络、速率、失联与质量观测 · 最新在前", "Environment": "环境", "Environment to framework": "环境 → 框架", "Environment, selected plugin tools, and orchestration order.": "环境、已选插件工具及编排顺序。", "Error rate": "错误率", "Events paced out": "被配速抑制的事件", "Ever used": "是否用过", "Evidence": "证据", "Evidence admission": "证据准入", "Evolution": "演进", "Evolution timeline": "演进时间线", "Executable": "可执行", "Execution checklist": "执行清单", "Extracted from this session's tool/file output (not model-generated).": "数据来自本次会话的工具/文件产物（非模型生成）。", "Failures": "失败次数", "Fiber": "Fiber 状态", "Fiber state changes since the previous cycle, including load retries.": "自上一周期以来的 Fiber 状态变化，含加载重试。", "Finance lens": "金融视图", "Follow-ups": "后续事项", "Framework change": "框架变更", "Framework changes as they happened, from runtime probes.": "来自运行时探针的框架变更实况。", "Framework evolution": "框架演进", "Framework size and how much of the evolution pipeline shows runtime evidence.": "框架规模，以及演进管道中有多少环节呈现运行时证据。", "From": "从", "Frozen plugins": "已冻结插件", "Gap closure": "缺口闭合", "Halt": "可急停", "How closures are verified": "闭合是如何验证的", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "效果信号中有多少可真正用作反馈。这决定了是否值得构建学习策略。", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "框架中有多少是它自己长出来的，以及演进管道中有多少环节呈现运行时证据。", "How often each window sat inside, near, or outside its declared limits": "各窗口处于声明限值内、接近边界或越界的频次", "Inquiry brief": "研究简报", "Insights carded as evidence, capped for fast review.": "洞察以证据卡呈现，数量受限以便快速浏览。", "Instruments & counterparties": "标的与交易对手", "Kept": "保留", "Latest capability decision": "最新能力决策", "Lifecycle records": "生命周期记录", "Lifecycle timeline": "生命周期时间线", "Lifecycle transitions": "生命周期迁移", "Line of inquiry": "研究主线", "Live activity": "实时动态", "Location": "位置", "Loop phase": "循环阶段", "Mean of each downsample window. Declared limits are listed per channel below.": "每个降采样窗口的均值。各通道的声明限值见下方。", "Model's reasoning": "模型的推理", "Mutation": "变更", "Narrative": "叙事", "Narrative pulse": "叙事脉搏", "Needs attention": "需要关注", "Next recal due": "下次校准期限", "Next step": "下一步", "No causal history yet": "尚无因果历史", "Normalized error": "归一化误差", "Normalized error is the residual as a share of the channel's declared span.": "归一化误差是残差占该通道声明量程的比例。", "Not yet observed": "尚未观测", "Nothing has driven a framework change, so there is no episode to narrate.": "尚无任何事驱动过框架变更，因此没有可讲述的剧集。", "OHLC extracted from captured session market data.": "OHLC 提取自本次会话捕获的行情数据。", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "观测待办、提案状态、策略决策与生命周期结果。", "Observations": "观测数", "Observed Hz": "实测频率 (Hz)", "Observed rate against declared rate": "实测速率与声明速率对比", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "单一全局命名空间，先注册者胜。挑战者会被记录，绝不静默丢弃。", "Open": "已连接", "Open risks": "敞口风险", "Open/high/low/close from captured tool output.": "开/高/低/收，来自捕获的工具输出。", "Origin": "来源", "Outcome": "结果", "PRODUCTION": "生产级", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "逐条剧集：触发源、决策、变更，以及缺口是否闭合。", "Per-channel calibration state, freshness, and residual correction": "各通道的校准状态、时效性与残差校正", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "逐段运行时证据。模块存在并不等于有任何代码调用它。", "Pipeline": "管道", "Pipeline evidence": "管道证据", "Pipeline reachability": "管道贯通度", "Plan": "计划", "Plan steps": "计划步骤", "Plugin": "插件", "Plugin roster and trust": "插件名册与信任", "Plugins": "插件数", "Plugins by origin": "按来源分布的插件", "Plugins by trust class": "按信任等级分布的插件", "Policy": "策略", "Policy decisions": "策略决策", "Positions & actions": "持仓与操作", "Posture": "态势", "Price action": "价格行为", "Proposal": "提案", "Proposal status": "提案状态", "Proposed, not admitted": "已提议，未准入", "Pulse": "脉搏", "Quarantine feed": "隔离进料", "Ratio": "比值", "Read live from the registry and trust ledger every cycle.": "每个周期从注册表与信任账本实时读取。", "Recent episodes": "近期剧集", "Reclaim candidates": "可回收候选", "Reclaimable": "可回收", "References & follow-ups": "参考与后续", "References (entities)": "参考（实体）", "Registry": "注册表", "Registry delta": "注册表变化", "Registry version": "注册表版本", "Regressions": "回归", "Rejected": "被拒", "Representative observations, capped for quick scanning.": "代表性观察，数量受限以便快速浏览。", "Requirements": "能力需求", "Research lens": "研究视图", "Residual": "残差", "Reward signal bandwidth": "奖励信号带宽", "Runtime evidence": "运行时证据", "Sampled history per channel, newest on the right": "按通道的采样历史，最新在右侧", "Segment": "管道段", "Segments by status": "按状态分布的管道段", "Selectable": "可被选中", "Selection delta": "选择变化", "Self-acquired": "自获取", "Self-acquired plugins that are registered but unselectable or never once used.": "已注册但不可被选中、或从未被使用过的自获取插件。", "Sentiment lens": "情绪视图", "Series": "序列", "Session analysis": "会话分析", "Signal strength": "信号强度", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "表明某处长错了、或被扣下未放行的信号。无论打开哪个页签都会显示。", "Skipped slots": "跳过的采样点", "State": "状态", "Storyline and signal strength before drilling into positions and actions.": "先看叙事与信号强度，再深入持仓与操作。", "Streaming": "采样中", "Suggested next steps": "建议的下一步", "The line of investigation and where the open questions concentrate.": "研究主线，以及待答问题的集中之处。", "The narrative arc and how strongly themes are trending.": "叙事走向，以及主题的趋势强度。", "The world model asked for these capabilities and nothing took them up.": "世界模型请求了这些能力，但无人受理。", "Theme intensity": "主题强度", "Themes": "主题", "This board reports how the framework changes itself. Nothing has been recorded yet.": "本看板报告框架如何改变自身。目前尚无任何记录。", "To": "到", "Tool": "工具", "Tool-name conflicts": "工具名冲突", "Tools": "工具数", "Transport": "传输方式", "Transport, provenance and channel counts": "传输方式、来源与通道数量", "Trust": "信任级别", "Trust accrual": "信任累积", "Trust class": "信任语义", "Unselectable reclamation": "不可选回收", "Usable": "可用", "VERIFIED": "已验证级", "Verdicts": "判定数", "Verdicts by reason": "按原因分布的判定", "Verified": "已核验", "Verified by": "验证依据", "Voices & concerns": "声音与关切", "Watchlist": "关注列表", "What changed in the environment, and what the framework did about it.": "环境发生了什么变化，框架又为此做了什么。", "Which plugin owns which tool, and which capability that tool provides.": "哪个插件拥有哪个工具，以及该工具提供什么能力。", "Who/what is in the conversation, and the concerns still open.": "谁/什么在被讨论，以及尚未解决的关切。", "Why": "原因", "Why not admitted": "未准入原因", "Why this page is empty": "这个页面为何是空的", "World-model driver": "世界模型驱动器", "Writable": "可写", "aborted": "已中断", "accruing": "正在累积", "active": "运行中", "appeared": "新出现", "armed": "已就绪", "assess_compatibility": "评估兼容性", "built_in": "内置", "capability_expand": "扩展能力", "committed": "已定论", "conformance": "合规", "declared_fitness": "声明式适配", "disable": "停用", "disposed": "已释放", "effect_observed": "效果已观测", "environment_probe": "环境探测", "execution_failed": "执行失败", "expected_effect_absent": "预期效果未出现", "failed": "已失败", "frozen": "已冻结", "gone": "已消失", "idle": "空闲无变化", "install": "安装", "loading": "加载中", "manual": "人工", "moved": "已迁移", "new_unproven": "新，未验证", "no": "否", "no_evidence": "无证据", "no_expected_effect_declared": "未声明预期效果", "no_outcome_observed": "未观测到结果", "none": "无", "not_admitted": "未准入", "not_applicable": "不适用", "observe_only": "仅观察", "observed_effect": "观测效果", "open": "进行中", "pending": "待启", "reload": "重载", "remove": "移除", "reopened": "已复发", "resolved": "已闭合", "rollback": "回滚", "runtime": "运行时", "self_acquired": "自获取", "still_open": "仍未闭合", "tool_reported_no_effect": "工具未报告效果", "trusted": "已信任", "unknown": "未知", "unknown_tool": "未知工具", "unloading": "卸载中", "unscheduled": "未调度", "unverifiable": "无法核实", "unverified": "未验证", "waiting": "等待首个周期", "watching": "监视中", "wired": "已贯通", "world_model": "世界模型", "yes": "是"},
-    fr: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **Aucun verdict d'effet n'a encore été enregistré**, il n'y a donc aucun signal de récompense à mesurer. Les taux ci-dessus sont volontairement vides plutôt que nuls. Un effet ne peut être vérifié que si l'exigence en a déclaré un, et seules les exigences rédigées par le modèle du monde en portent aujourd'hui.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **Régression : un écart comblé s'est reproduit.** Une évolution qui semblait réussie n'a pas tenu. C'est le seul constat de ce tableau qui exige une attention immédiate.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **Instantané seulement.** Aucun historique causal à reconstruire pour l'instant : la chronologie est absente, non vide. La raison est indiquée par la ligne `Décisions de politique` sous la couverture du pipeline ; l'instantané et le tableau de couverture ne sont pas affectés.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **Certains plugins sont gelés par un défaut interne.** Un plugin gelé signale toujours `DRAFT`, et la dimension de confiance ne fait que *noter*, donc il reste sélectionnable tant qu'il n'est pas également désenregistré — voir la colonne `Sélectionnable`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **Niveau de vérification : L2 (aptitude déclarée).** Une observation retirée signifie qu'un candidat a *déclaré* fournir la capacité, non que la capacité a été observée en fonctionnement. La vérification d'effet (L3) n'est pas câblée, donc aucune clôture de ce tableau ne doit être lue comme prouvée.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> Un cycle d'observation doit s'achever avant qu'il y ait quoi que ce soit à montrer. Si cela persiste, vérifiez que le planificateur est actif et que la surveillance `framework-evolution` est armée et non silencée.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> Un épisode est écrit lorsqu'une observation de l'environnement conduit à une décision de capacité. Aucun n'a été enregistré : soit le système est calme, soit le pipeline s'arrête plus tôt — l'onglet **Pipeline** nomme le segment où il s'arrête et ce qui le débloquerait.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> Rien ne les récupère automatiquement. Chacun occupe un nom d'outil et figure dans la liste des capacités sans être sélectionnable : le registre grandit dans une direction qu'aucune exigence ne peut utiliser.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> Ces propositions n'ont intégré aucun pipeline : elles n'apparaissent donc dans aucun enregistrement de décision ni observation. Les admettre est un choix de configuration.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "Un ratio inférieur à 1,0 signifie que la boucle d’échantillonnage ne tient pas sa cadence déclarée.", "Abstained": "Abstention", "Acquisition authority": "Autorité d'acquisition", "Acquisition lifecycle": "Cycle de vie d'acquisition", "Action": "Action", "After": "Après", "An unverified declaration has its writable channels demoted to read-only.": "Une déclaration non vérifiée voit ses canaux inscriptibles rétrogradés en lecture seule.", "Approval": "Approbation", "Autonomous governance": "Gouvernance autonome", "Autonomy": "Autonomie", "Before": "Avant", "CANDIDATE": "Candidat", "Calibrated at": "Calibré le", "Calibration health": "État de calibration", "Calls": "Appels", "Calls (decisions)": "Recommandations (décisions)", "Candlestick": "Chandeliers", "Capability": "Capacité", "Capability adaptation": "Adaptation des capacités", "Capability observations": "Observations de capacités", "Capability ownership": "Propriété des capacités", "Capability topology": "Topologie des capacités", "Change": "Changement", "Channel": "Canal", "Channels": "Canaux", "Channels that have never been calibrated or whose calibration has expired are shown first.": "Les canaux jamais calibrés ou dont la calibration a expiré apparaissent en premier.", "Command": "Commande", "Commanded versus observed, best tracking first": "Commandé contre observé, meilleur suivi d’abord", "Composition": "Composition", "Concerns (open questions)": "Préoccupations (questions ouvertes)", "Confidence": "Confiance", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "Compté sur tous les canaux tracés. « près » signifie à moins de 5 % d’une borne déclarée.", "Cycles run": "Cycles exécutés", "DRAFT": "Brouillon", "Days since": "Jours écoulés", "Decision": "Décision", "Decisions read as calls; action items as the execution checklist.": "Les décisions se lisent comme des recommandations ; les actions comme la liste d’exécution.", "Declared Hz": "Hz déclarés", "Desk brief": "Note de desk", "Device": "Appareil", "Dropped samples": "Échantillons perdus", "Each row names one blocked segment and the change that would unblock it.": "Chaque ligne nomme un segment bloqué et le changement qui le débloquerait.", "Effect verification (L3)": "Vérification d'effet (L3)", "Effects declared": "Effets déclarés", "Entities as references, and recommended next prompts to advance the work.": "Entités comme références, et invites suivantes recommandées pour avancer.", "Entities in play and the open risks still to resolve.": "Entités concernées et risques ouverts à résoudre.", "Envelope, rate, staleness and quality observations · newest first": "Observations d’enveloppe, de débit, d’obsolescence et de qualité · les plus récentes d’abord", "Environment": "Environnement", "Environment to framework": "De l'environnement au framework", "Environment, selected plugin tools, and orchestration order.": "Environnement, outils de plugin sélectionnés et ordre d’orchestration.", "Error rate": "Taux d'erreur", "Events paced out": "Événements limités", "Ever used": "Déjà utilisé", "Evidence": "Preuve", "Evidence admission": "Admission des preuves", "Evolution": "Évolution", "Evolution timeline": "Chronologie de l'évolution", "Executable": "Exécutable", "Execution checklist": "Liste d’exécution", "Extracted from this session's tool/file output (not model-generated).": "Extrait des sorties d’outils/fichiers de cette session (non généré par le modèle).", "Failures": "Échecs", "Fiber": "Fibre", "Fiber state changes since the previous cycle, including load retries.": "Changements d'état de fiber depuis le cycle précédent, y compris les tentatives de chargement.", "Finance lens": "Vue finance", "Follow-ups": "Suivis", "Framework change": "Changement du framework", "Framework changes as they happened, from runtime probes.": "Changements du framework en temps réel, via les sondes d'exécution.", "Framework evolution": "Évolution du framework", "Framework size and how much of the evolution pipeline shows runtime evidence.": "Taille du framework et part du pipeline d'évolution qui présente des preuves d'exécution.", "From": "De", "Frozen plugins": "Plugins gelés", "Gap closure": "Clôture de l'écart", "Halt": "Arrêt", "How closures are verified": "Comment les clôtures sont vérifiées", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "Quelle part du signal d'effet est exploitable comme rétroaction. C'est ce qui détermine s'il vaut la peine de construire une politique d'apprentissage.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "Quelle part du framework il a fait croître lui-même, et quelle part du pipeline présente des preuves d'exécution.", "How often each window sat inside, near, or outside its declared limits": "Fréquence à laquelle chaque fenêtre était dans, près de, ou hors de ses limites déclarées", "Inquiry brief": "Note d’enquête", "Insights carded as evidence, capped for fast review.": "Analyses présentées comme preuves, limitées pour une revue rapide.", "Instruments & counterparties": "Instruments et contreparties", "Kept": "Conservé", "Latest capability decision": "Dernière décision de capacité", "Lifecycle records": "Enregistrements de cycle de vie", "Lifecycle timeline": "Chronologie du cycle de vie", "Lifecycle transitions": "Transitions de cycle de vie", "Line of inquiry": "Ligne d’enquête", "Live activity": "Activité en direct", "Location": "Emplacement", "Loop phase": "Phase de boucle", "Mean of each downsample window. Declared limits are listed per channel below.": "Moyenne de chaque fenêtre de sous-échantillonnage. Les limites déclarées figurent par canal ci-dessous.", "Model's reasoning": "Raisonnement du modèle", "Mutation": "Mutation", "Narrative": "Récit", "Narrative pulse": "Pouls narratif", "Needs attention": "Requiert attention", "Next recal due": "Prochaine recalibration", "Next step": "Étape suivante", "No causal history yet": "Pas encore d'historique causal", "Normalized error": "Erreur normalisée", "Normalized error is the residual as a share of the channel's declared span.": "L’erreur normalisée est le résidu en proportion de l’étendue déclarée du canal.", "Not yet observed": "Pas encore observé", "Nothing has driven a framework change, so there is no episode to narrate.": "Rien n'a encore déclenché de changement du framework : il n'y a donc aucun épisode à raconter.", "OHLC extracted from captured session market data.": "OHLC extrait des données de marché capturées durant la session.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "File d’observations, état des propositions, décisions de politique et résultats du cycle de vie.", "Observations": "Observations", "Observed Hz": "Hz observés", "Observed rate against declared rate": "Débit observé par rapport au débit déclaré", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "Un espace de noms global unique, arbitré au premier arrivé. Le concurrent est enregistré, jamais supprimé en silence.", "Open": "Ouvert", "Open risks": "Risques ouverts", "Open/high/low/close from captured tool output.": "Ouverture/haut/bas/clôture issus des sorties d’outils capturées.", "Origin": "Origine", "Outcome": "Résultat", "PRODUCTION": "Production", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "Par épisode : le déclencheur, la décision, le changement, et si l'écart a été comblé.", "Per-channel calibration state, freshness, and residual correction": "État de calibration, fraîcheur et correction résiduelle par canal", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "Preuves d'exécution par segment. L'existence d'un module ne prouve pas qu'il soit appelé.", "Pipeline": "Pipeline", "Pipeline evidence": "Preuves du pipeline", "Pipeline reachability": "Accessibilité du pipeline", "Plan": "Plan", "Plan steps": "Étapes du plan", "Plugin": "Plugin", "Plugin roster and trust": "Registre des plugins et confiance", "Plugins": "Plugins", "Plugins by origin": "Plugins par origine", "Plugins by trust class": "Plugins par classe de confiance", "Policy": "Politique", "Policy decisions": "Décisions de politique", "Positions & actions": "Positions et actions", "Posture": "Posture", "Price action": "Action des prix", "Proposal": "Proposition", "Proposal status": "Statut de la proposition", "Proposed, not admitted": "Proposé, non admis", "Pulse": "Pouls", "Quarantine feed": "Flux de quarantaine", "Ratio": "Ratio", "Read live from the registry and trust ledger every cycle.": "Lu en direct depuis le registre et le registre de confiance à chaque cycle.", "Recent episodes": "Épisodes récents", "Reclaim candidates": "Candidats à la récupération", "Reclaimable": "Récupérable", "References & follow-ups": "Références et suivis", "References (entities)": "Références (entités)", "Registry": "Registre", "Registry delta": "Delta du registre", "Registry version": "Version du registre", "Regressions": "Régressions", "Rejected": "Rejeté", "Representative observations, capped for quick scanning.": "Observations représentatives, limitées pour une lecture rapide.", "Requirements": "Exigences", "Research lens": "Vue recherche", "Residual": "Résidu", "Reward signal bandwidth": "Bande passante du signal de récompense", "Runtime evidence": "Preuve d'exécution", "Sampled history per channel, newest on the right": "Historique échantillonné par canal, le plus récent à droite", "Segment": "Segment", "Segments by status": "Segments par statut", "Selectable": "Sélectionnable", "Selection delta": "Delta de sélection", "Self-acquired": "Auto-acquis", "Self-acquired plugins that are registered but unselectable or never once used.": "Plugins auto-acquis qui sont enregistrés mais non sélectionnables, ou jamais utilisés une seule fois.", "Sentiment lens": "Vue sentiment", "Series": "Série", "Session analysis": "Analyse de session", "Signal strength": "Force du signal", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "Signaux indiquant qu'une évolution a mal tourné ou a été retenue. Affichés quel que soit l'onglet ouvert.", "Skipped slots": "Créneaux manqués", "State": "État", "Storyline and signal strength before drilling into positions and actions.": "Récit et force du signal avant d’examiner positions et actions.", "Streaming": "Diffusion", "Suggested next steps": "Prochaines étapes suggérées", "The line of investigation and where the open questions concentrate.": "La ligne d’investigation et où se concentrent les questions ouvertes.", "The narrative arc and how strongly themes are trending.": "L’arc narratif et l’intensité des tendances thématiques.", "The world model asked for these capabilities and nothing took them up.": "Le modèle du monde a demandé ces capacités et personne ne les a prises en charge.", "Theme intensity": "Intensité des thèmes", "Themes": "Thèmes", "This board reports how the framework changes itself. Nothing has been recorded yet.": "Ce tableau rend compte de la façon dont le framework se modifie lui-même. Rien n'a encore été enregistré.", "To": "Vers", "Tool": "Outil", "Tool-name conflicts": "Conflits de noms d'outils", "Tools": "Outils", "Transport": "Transport", "Transport, provenance and channel counts": "Transport, provenance et nombre de canaux", "Trust": "Confiance", "Trust accrual": "Accumulation de confiance", "Trust class": "Classe de confiance", "Unselectable reclamation": "Récupération non sélectionnable", "Usable": "Exploitable", "VERIFIED": "Vérifié", "Verdicts": "Verdicts", "Verdicts by reason": "Verdicts par motif", "Verified": "Vérifié", "Verified by": "Vérifié par", "Voices & concerns": "Voix et préoccupations", "Watchlist": "Liste de suivi", "What changed in the environment, and what the framework did about it.": "Ce qui a changé dans l'environnement, et ce que le framework a fait en réponse.", "Which plugin owns which tool, and which capability that tool provides.": "Quel plugin possède quel outil, et quelle capacité cet outil fournit.", "Who/what is in the conversation, and the concerns still open.": "Qui/quoi est dans la conversation, et les préoccupations encore ouvertes.", "Why": "Pourquoi", "Why not admitted": "Motif de non-admission", "Why this page is empty": "Pourquoi cette page est vide", "World-model driver": "Pilote du modèle du monde", "Writable": "Inscriptible", "aborted": "Abandonné", "accruing": "En accumulation", "active": "Actif", "appeared": "Apparu", "armed": "Armé", "assess_compatibility": "Évaluer la compatibilité", "built_in": "Intégré", "capability_expand": "Étendre les capacités", "committed": "Conclu", "conformance": "Conformité", "declared_fitness": "Aptitude déclarée", "disable": "Désactiver", "disposed": "Libéré", "effect_observed": "Effet observé", "environment_probe": "Sonde d'environnement", "execution_failed": "Échec d'exécution", "expected_effect_absent": "Effet attendu absent", "failed": "Échoué", "frozen": "Gelé", "gone": "Disparu", "idle": "Au repos", "install": "Installer", "loading": "Chargement", "manual": "Manuel", "moved": "Déplacé", "new_unproven": "Nouveau, non éprouvé", "no": "Non", "no_evidence": "Aucune preuve", "no_expected_effect_declared": "Aucun effet attendu déclaré", "no_outcome_observed": "Aucun résultat observé", "none": "Aucun", "not_admitted": "Non admis", "not_applicable": "Sans objet", "observe_only": "Observer seulement", "observed_effect": "Effet observé", "open": "Ouvert", "pending": "En attente", "reload": "Recharger", "remove": "Supprimer", "reopened": "Réouvert", "resolved": "Résolu", "rollback": "Annuler", "runtime": "Exécution", "self_acquired": "Auto-acquis", "still_open": "Toujours ouvert", "tool_reported_no_effect": "L'outil n'a signalé aucun effet", "trusted": "De confiance", "unknown": "Inconnu", "unknown_tool": "Outil inconnu", "unloading": "Déchargement", "unscheduled": "Non planifié", "unverifiable": "Invérifiable", "unverified": "Non vérifié", "waiting": "En attente", "watching": "En surveillance", "wired": "Câblé", "world_model": "Modèle du monde", "yes": "Oui"},
-    es: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **Aún no se ha registrado ningún veredicto de efecto**, por lo que no hay señal de recompensa que medir. Las tasas anteriores están en blanco a propósito, no en cero. Un efecto solo puede verificarse si el requisito declaró uno, y hoy solo los requisitos redactados por el modelo del mundo lo llevan.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **Regresión: una brecha cerrada ha vuelto a aparecer.** Una evolución que parecía exitosa no se sostuvo. Es el único hallazgo de este panel que exige atención inmediata.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **Solo instantánea.** Todavía no hay historia causal que reconstruir, por lo que la cronología está ausente, no vacía. El motivo lo indica la fila `Decisiones de política` bajo la cobertura del pipeline; la instantánea y la tabla de cobertura no se ven afectadas.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **Algunos plugins están congelados por un defecto interno.** Un plugin congelado sigue informando `DRAFT`, y la dimensión de confianza solo *puntúa*, por lo que permanece seleccionable a menos que también se desregistre — consulte la columna `Seleccionable`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **Nivel de verificación: L2 (aptitud declarada).** Una observación retirada significa que un candidato *declaró* que proporciona la capacidad, no que se observara funcionando. La verificación de efecto (L3) no está conectada, así que ningún cierre de este panel debe leerse como probado.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> Debe completarse un ciclo de observación antes de que haya algo que mostrar. Si persiste, compruebe que el planificador está activo y que la vigilancia `framework-evolution` está armada y no silenciada.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> Un episodio se escribe cuando una observación del entorno conduce a una decisión de capacidad. No se ha registrado ninguno: o el sistema está tranquilo o el pipeline se detiene antes — la pestaña **Pipeline** nombra el segmento donde se detiene y qué lo desbloquearía.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> Nada los recupera automáticamente. Cada uno ocupa un nombre de herramienta y aparece en la lista de capacidades sin ser seleccionable: el registro crece en una dirección que ningún requisito puede usar.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> Estas propuestas no entraron en ningún pipeline, por lo que no aparecen en ningún registro de decisión ni observación. Admitirlas es una elección de configuración.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "Una relación inferior a 1,0 significa que el bucle de muestreo no mantiene su cadencia declarada.", "Abstained": "Abstenido", "Acquisition authority": "Autoridad de adquisición", "Acquisition lifecycle": "Ciclo de vida de adquisición", "Action": "Acción", "After": "Después", "An unverified declaration has its writable channels demoted to read-only.": "Una declaración no verificada degrada sus canales escribibles a solo lectura.", "Approval": "Aprobación", "Autonomous governance": "Gobernanza autónoma", "Autonomy": "Autonomía", "Before": "Antes", "CANDIDATE": "Candidato", "Calibrated at": "Calibrado el", "Calibration health": "Estado de calibración", "Calls": "Llamadas", "Calls (decisions)": "Recomendaciones (decisiones)", "Candlestick": "Velas", "Capability": "Capacidad", "Capability adaptation": "Adaptación de capacidades", "Capability observations": "Observaciones de capacidad", "Capability ownership": "Propiedad de capacidades", "Capability topology": "Topología de capacidades", "Change": "Cambio", "Channel": "Canal", "Channels": "Canales", "Channels that have never been calibrated or whose calibration has expired are shown first.": "Los canales nunca calibrados o con calibración vencida se muestran primero.", "Command": "Comando", "Commanded versus observed, best tracking first": "Comandado frente a observado, mejor seguimiento primero", "Composition": "Composición", "Concerns (open questions)": "Inquietudes (preguntas abiertas)", "Confidence": "Confianza", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "Contado en todos los canales graficados. «cerca» significa dentro del 5 % de un límite declarado.", "Cycles run": "Ciclos ejecutados", "DRAFT": "Borrador", "Days since": "Días desde", "Decision": "Decisión", "Decisions read as calls; action items as the execution checklist.": "Las decisiones se leen como recomendaciones; las acciones como la lista de ejecución.", "Declared Hz": "Hz declarados", "Desk brief": "Informe de mesa", "Device": "Dispositivo", "Dropped samples": "Muestras descartadas", "Each row names one blocked segment and the change that would unblock it.": "Cada fila nombra un segmento bloqueado y el cambio que lo desbloquearía.", "Effect verification (L3)": "Verificación de efecto (L3)", "Effects declared": "Efectos declarados", "Entities as references, and recommended next prompts to advance the work.": "Entidades como referencias y siguientes preguntas recomendadas para avanzar.", "Entities in play and the open risks still to resolve.": "Entidades implicadas y riesgos abiertos por resolver.", "Envelope, rate, staleness and quality observations · newest first": "Observaciones de envolvente, tasa, obsolescencia y calidad · las más recientes primero", "Environment": "Entorno", "Environment to framework": "Del entorno al framework", "Environment, selected plugin tools, and orchestration order.": "Entorno, herramientas de plugin seleccionadas y orden de orquestación.", "Error rate": "Tasa de error", "Events paced out": "Eventos limitados", "Ever used": "Alguna vez usado", "Evidence": "Evidencia", "Evidence admission": "Admisión de evidencia", "Evolution": "Evolución", "Evolution timeline": "Cronología de la evolución", "Executable": "Ejecutable", "Execution checklist": "Lista de ejecución", "Extracted from this session's tool/file output (not model-generated).": "Extraído de la salida de herramientas/archivos de esta sesión (no generado por el modelo).", "Failures": "Fallos", "Fiber": "Fibra", "Fiber state changes since the previous cycle, including load retries.": "Cambios de estado de fiber desde el ciclo anterior, incluidos los reintentos de carga.", "Finance lens": "Vista financiera", "Follow-ups": "Seguimientos", "Framework change": "Cambio del framework", "Framework changes as they happened, from runtime probes.": "Cambios del framework en tiempo real, desde sondas de ejecución.", "Framework evolution": "Evolución del framework", "Framework size and how much of the evolution pipeline shows runtime evidence.": "Tamaño del framework y qué parte del pipeline de evolución muestra evidencia en ejecución.", "From": "Desde", "Frozen plugins": "Plugins congelados", "Gap closure": "Cierre de la brecha", "Halt": "Parada", "How closures are verified": "Cómo se verifican los cierres", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "Cuánto de la señal de efecto es utilizable como retroalimentación. Esto decide si vale la pena construir una política de aprendizaje.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "Cuánto del framework hizo crecer por sí mismo y cuánto del pipeline muestra evidencia de ejecución.", "How often each window sat inside, near, or outside its declared limits": "Con qué frecuencia cada ventana estuvo dentro, cerca o fuera de sus límites declarados", "Inquiry brief": "Informe de indagación", "Insights carded as evidence, capped for fast review.": "Hallazgos presentados como evidencia, limitados para revisión rápida.", "Instruments & counterparties": "Instrumentos y contrapartes", "Kept": "Conservado", "Latest capability decision": "Última decisión de capacidad", "Lifecycle records": "Registros de ciclo de vida", "Lifecycle timeline": "Cronología del ciclo de vida", "Lifecycle transitions": "Transiciones de ciclo de vida", "Line of inquiry": "Línea de indagación", "Live activity": "Actividad en vivo", "Location": "Ubicación", "Loop phase": "Fase del bucle", "Mean of each downsample window. Declared limits are listed per channel below.": "Media de cada ventana de submuestreo. Los límites declarados se listan por canal abajo.", "Model's reasoning": "Razonamiento del modelo", "Mutation": "Mutación", "Narrative": "Narrativa", "Narrative pulse": "Pulso narrativo", "Needs attention": "Requiere atención", "Next recal due": "Próxima recalibración", "Next step": "Siguiente paso", "No causal history yet": "Aún no hay historia causal", "Normalized error": "Error normalizado", "Normalized error is the residual as a share of the channel's declared span.": "El error normalizado es el residuo como fracción del rango declarado del canal.", "Not yet observed": "Aún no observado", "Nothing has driven a framework change, so there is no episode to narrate.": "Nada ha impulsado todavía un cambio del framework, por lo que no hay ningún episodio que narrar.", "OHLC extracted from captured session market data.": "OHLC extraído de los datos de mercado capturados en la sesión.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "Cola de observaciones, estado de propuestas, decisiones de política y resultados del ciclo de vida.", "Observations": "Observaciones", "Observed Hz": "Hz observados", "Observed rate against declared rate": "Tasa observada frente a la tasa declarada", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "Un único espacio de nombres global, arbitrado por orden de llegada. El aspirante queda registrado, nunca se descarta en silencio.", "Open": "Abierto", "Open risks": "Riesgos abiertos", "Open/high/low/close from captured tool output.": "Apertura/máximo/mínimo/cierre desde la salida de herramientas capturada.", "Origin": "Origen", "Outcome": "Resultado", "PRODUCTION": "Producción", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "Por episodio: el desencadenante, la decisión, el cambio y si la brecha se cerró.", "Per-channel calibration state, freshness, and residual correction": "Estado de calibración, vigencia y corrección residual por canal", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "Evidencia en ejecución por segmento. Que un módulo exista no prueba que algo lo invoque.", "Pipeline": "Pipeline", "Pipeline evidence": "Evidencia del pipeline", "Pipeline reachability": "Alcanzabilidad del pipeline", "Plan": "Plan", "Plan steps": "Pasos del plan", "Plugin": "Plugin", "Plugin roster and trust": "Registro de plugins y confianza", "Plugins": "Plugins", "Plugins by origin": "Plugins por origen", "Plugins by trust class": "Plugins por clase de confianza", "Policy": "Política", "Policy decisions": "Decisiones de política", "Positions & actions": "Posiciones y acciones", "Posture": "Postura", "Price action": "Acción del precio", "Proposal": "Propuesta", "Proposal status": "Estado de la propuesta", "Proposed, not admitted": "Propuesto, no admitido", "Pulse": "Pulso", "Quarantine feed": "Entrada de cuarentena", "Ratio": "Relación", "Read live from the registry and trust ledger every cycle.": "Leído en vivo del registro y del libro de confianza en cada ciclo.", "Recent episodes": "Episodios recientes", "Reclaim candidates": "Candidatos a recuperación", "Reclaimable": "Recuperable", "References & follow-ups": "Referencias y seguimientos", "References (entities)": "Referencias (entidades)", "Registry": "Registro", "Registry delta": "Delta del registro", "Registry version": "Versión del registro", "Regressions": "Regresiones", "Rejected": "Rechazado", "Representative observations, capped for quick scanning.": "Observaciones representativas, limitadas para lectura rápida.", "Requirements": "Requisitos", "Research lens": "Vista de investigación", "Residual": "Residuo", "Reward signal bandwidth": "Ancho de banda de la señal de recompensa", "Runtime evidence": "Evidencia en ejecución", "Sampled history per channel, newest on the right": "Historial muestreado por canal, el más reciente a la derecha", "Segment": "Segmento", "Segments by status": "Segmentos por estado", "Selectable": "Seleccionable", "Selection delta": "Delta de selección", "Self-acquired": "Autoadquirido", "Self-acquired plugins that are registered but unselectable or never once used.": "Plugins autoadquiridos que están registrados pero no son seleccionables, o nunca se han usado.", "Sentiment lens": "Vista de sentimiento", "Series": "Serie", "Session analysis": "Análisis de sesión", "Signal strength": "Fuerza de la señal", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "Señales de que algo creció mal o fue retenido. Se muestran independientemente de la pestaña abierta.", "Skipped slots": "Ranuras omitidas", "State": "Estado", "Storyline and signal strength before drilling into positions and actions.": "Narrativa y fuerza de la señal antes de entrar en posiciones y acciones.", "Streaming": "Transmisión", "Suggested next steps": "Próximos pasos sugeridos", "The line of investigation and where the open questions concentrate.": "La línea de investigación y dónde se concentran las preguntas abiertas.", "The narrative arc and how strongly themes are trending.": "El arco narrativo y con qué fuerza se mueven los temas.", "The world model asked for these capabilities and nothing took them up.": "El modelo del mundo pidió estas capacidades y nada las asumió.", "Theme intensity": "Intensidad temática", "Themes": "Temas", "This board reports how the framework changes itself. Nothing has been recorded yet.": "Este panel informa de cómo el framework se modifica a sí mismo. Todavía no se ha registrado nada.", "To": "Hasta", "Tool": "Herramienta", "Tool-name conflicts": "Conflictos de nombres de herramientas", "Tools": "Herramientas", "Transport": "Transporte", "Transport, provenance and channel counts": "Transporte, procedencia y número de canales", "Trust": "Confianza", "Trust accrual": "Acumulación de confianza", "Trust class": "Clase de confianza", "Unselectable reclamation": "Recuperación no seleccionable", "Usable": "Utilizable", "VERIFIED": "Verificado", "Verdicts": "Veredictos", "Verdicts by reason": "Veredictos por motivo", "Verified": "Verificado", "Verified by": "Verificado por", "Voices & concerns": "Voces e inquietudes", "Watchlist": "Lista de seguimiento", "What changed in the environment, and what the framework did about it.": "Qué cambió en el entorno y qué hizo el framework al respecto.", "Which plugin owns which tool, and which capability that tool provides.": "Qué plugin posee qué herramienta y qué capacidad proporciona esa herramienta.", "Who/what is in the conversation, and the concerns still open.": "Quién/qué está en la conversación y las inquietudes aún abiertas.", "Why": "Por qué", "Why not admitted": "Motivo de no admisión", "Why this page is empty": "Por qué esta página está vacía", "World-model driver": "Controlador del modelo del mundo", "Writable": "Escribible", "aborted": "Abortado", "accruing": "Acumulando", "active": "Activo", "appeared": "Apareció", "armed": "Armado", "assess_compatibility": "Evaluar compatibilidad", "built_in": "Integrado", "capability_expand": "Ampliar capacidad", "committed": "Concluido", "conformance": "Conformidad", "declared_fitness": "Aptitud declarada", "disable": "Desactivar", "disposed": "Liberado", "effect_observed": "Efecto observado", "environment_probe": "Sonda de entorno", "execution_failed": "Ejecución fallida", "expected_effect_absent": "Efecto esperado ausente", "failed": "Fallido", "frozen": "Congelado", "gone": "Desapareció", "idle": "Inactivo", "install": "Instalar", "loading": "Cargando", "manual": "Manual", "moved": "Se movió", "new_unproven": "Nuevo, no probado", "no": "No", "no_evidence": "Sin evidencia", "no_expected_effect_declared": "Sin efecto esperado declarado", "no_outcome_observed": "Sin resultado observado", "none": "Ninguno", "not_admitted": "No admitido", "not_applicable": "No aplicable", "observe_only": "Solo observar", "observed_effect": "Efecto observado", "open": "Abierto", "pending": "Pendiente", "reload": "Recargar", "remove": "Eliminar", "reopened": "Reabierto", "resolved": "Resuelto", "rollback": "Revertir", "runtime": "Tiempo de ejecución", "self_acquired": "Autoadquirido", "still_open": "Aún abierto", "tool_reported_no_effect": "La herramienta no informó efecto", "trusted": "De confianza", "unknown": "Desconocido", "unknown_tool": "Herramienta desconocida", "unloading": "Descargando", "unscheduled": "No planificado", "unverifiable": "No verificable", "unverified": "No verificado", "waiting": "En espera", "watching": "Vigilando", "wired": "Conectado", "world_model": "Modelo del mundo", "yes": "Sí"},
-    ar: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **لم يُسجَّل أي حكم على الأثر بعد**، لذا لا توجد إشارة مكافأة لقياسها. النسب أعلاه فارغة عن قصد وليست صفرًا. لا يمكن التحقق من الأثر إلا إذا أعلنه المطلب، واليوم لا تحمل الأثر المتوقع سوى المطالب التي كتبها نموذج العالم.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **انحدار: فجوة أُغلقت عادت للظهور.** تطوّر بدا ناجحًا لم يصمد. هذا هو الاكتشاف الوحيد في هذه اللوحة الذي يستدعي انتباهًا فوريًا.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **لقطة فقط.** لا يوجد بعد تاريخ سببي لإعادة بنائه، لذا فالخط الزمني غائب وليس فارغًا. السبب مبيَّن في صف `قرارات السياسة` تحت تغطية المسار؛ اللقطة الحيّة وجدول التغطية غير متأثرين.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **بعض الإضافات مُجمَّدة بسبب خلل داخلي.** الإضافة المُجمَّدة لا تزال تُبلِّغ `DRAFT`، وبُعد الثقة يقوم بالتقييم فقط، لذا تبقى قابلة للاختيار إلا إذا أُلغي تسجيلها أيضًا — راجع عمود `قابل للاختيار`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **مستوى التحقق: L2 (الملاءمة المُعلنة).** سحب الرصد يعني أن مرشّحًا *أعلن* أنه يوفّر القدرة، لا أن القدرة رُصدت وهي تعمل. التحقق من الأثر (L3) غير موصول، لذا لا ينبغي قراءة أي إغلاق في هذه اللوحة كأمر مُثبَت.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> يجب أن تكتمل دورة مراقبة واحدة قبل ظهور أي محتوى. إذا استمر ذلك، تحقّق من تمكين المُجدول وأن مراقبة `framework-evolution` مُسلّحة وغير مكتومة.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> تُكتب الحلقة عندما يؤدي رصد للبيئة إلى قرار بشأن قدرة. لم يُسجَّل أي منها، وهذا يعني إمّا نظامًا هادئًا أو مسارًا يتوقف قبل ذلك — تبويب **المسار** يحدّد الجزء الذي يتوقف عنده وما الذي يزيل التعطيل.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> لا شيء يستعيدها تلقائيًا. كل واحدة تحتجز اسم أداة وتظهر في قائمة القدرات دون أن تكون قابلة للاختيار، فينمو السجل في اتجاه لا يمكن لأي مطلب استخدامه.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> لم تدخل هذه المقترحات أي مسار، لذا لا تظهر في أي سجل قرار أو رصد. قبولها خيار في الإعدادات.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "نسبة أقل من 1.0 تعني أن حلقة أخذ العينات لا تحافظ على وتيرتها المعلنة.", "Abstained": "امتناع", "Acquisition authority": "سلطة الاكتساب", "Acquisition lifecycle": "دورة حياة الاكتساب", "Action": "الإجراء", "After": "بعد", "An unverified declaration has its writable channels demoted to read-only.": "الإعلان غير المُتحقَّق منه تُخفَّض قنواته القابلة للكتابة إلى القراءة فقط.", "Approval": "الموافقة", "Autonomous governance": "الحكم الذاتي", "Autonomy": "الاستقلالية", "Before": "قبل", "CANDIDATE": "مرشّح", "Calibrated at": "تاريخ المعايرة", "Calibration health": "سلامة المعايرة", "Calls": "الاستدعاءات", "Calls (decisions)": "التوصيات (القرارات)", "Candlestick": "الشموع", "Capability": "القدرة", "Capability adaptation": "تكييف القدرات", "Capability observations": "رصد القدرات", "Capability ownership": "ملكية القدرات", "Capability topology": "طوبولوجيا القدرات", "Change": "التغيير", "Channel": "القناة", "Channels": "القنوات", "Channels that have never been calibrated or whose calibration has expired are shown first.": "تظهر أولاً القنوات التي لم تُعاير قط أو التي انتهت صلاحية معايرتها.", "Command": "الأمر", "Commanded versus observed, best tracking first": "المأمور مقابل المرصود، الأفضل تتبعاً أولاً", "Composition": "التركيب", "Concerns (open questions)": "المخاوف (أسئلة مفتوحة)", "Confidence": "الثقة", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "محسوب على كل قناة مرسومة. \"قريب\" تعني داخل 5% من حد معلن.", "Cycles run": "الدورات المنفَّذة", "DRAFT": "مسوّدة", "Days since": "الأيام المنقضية", "Decision": "القرار", "Decisions read as calls; action items as the execution checklist.": "القرارات تُقرأ كتوصيات؛ والإجراءات كقائمة تنفيذ.", "Declared Hz": "الهرتز المعلن", "Desk brief": "موجز المكتب", "Device": "الجهاز", "Dropped samples": "العينات المفقودة", "Each row names one blocked segment and the change that would unblock it.": "كل صف يحدّد جزءًا معطَّلًا والتغيير الذي يزيل التعطيل.", "Effect verification (L3)": "التحقق من الأثر (L3)", "Effects declared": "الآثار المُعلنة", "Entities as references, and recommended next prompts to advance the work.": "الكيانات كمراجع، والمطالبات التالية الموصى بها لدفع العمل.", "Entities in play and the open risks still to resolve.": "الكيانات المعنية والمخاطر المفتوحة التي لم تُحل.", "Envelope, rate, staleness and quality observations · newest first": "رصدات المغلف والمعدل والتقادم والجودة · الأحدث أولاً", "Environment": "البيئة", "Environment to framework": "من البيئة إلى الإطار", "Environment, selected plugin tools, and orchestration order.": "البيئة والأدوات المختارة وترتيب التنسيق.", "Error rate": "معدل الأخطاء", "Events paced out": "الأحداث المُقيَّدة", "Ever used": "استُخدم سابقًا", "Evidence": "الدليل", "Evidence admission": "قبول الأدلة", "Evolution": "التطور", "Evolution timeline": "الخط الزمني للتطور", "Executable": "قابل للتنفيذ", "Execution checklist": "قائمة التنفيذ", "Extracted from this session's tool/file output (not model-generated).": "مستخرج من مخرجات الأدوات/الملفات في هذه الجلسة (ليس من إنشاء النموذج).", "Failures": "الأعطال", "Fiber": "الخيط", "Fiber state changes since the previous cycle, including load retries.": "تغييرات حالة الـ fiber منذ الدورة السابقة، بما في ذلك محاولات التحميل.", "Finance lens": "منظور مالي", "Follow-ups": "المتابعات", "Framework change": "تغيير الإطار", "Framework changes as they happened, from runtime probes.": "تغييرات الإطار لحظة حدوثها، من مجسّات وقت التشغيل.", "Framework evolution": "تطور الإطار", "Framework size and how much of the evolution pipeline shows runtime evidence.": "حجم الإطار ومقدار ما يُظهره مسار التطور من أدلة وقت التشغيل.", "From": "من", "Frozen plugins": "الإضافات المُجمَّدة", "Gap closure": "إغلاق الفجوة", "Halt": "إيقاف", "How closures are verified": "كيف يُتحقَّق من الإغلاقات", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "ما مقدار إشارة الأثر القابل للاستخدام كتغذية راجعة. هذا يحدّد ما إذا كان بناء سياسة تعلّم يستحق العناء.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "ما مقدار ما نمّاه الإطار بنفسه، وما مقدار المسار الذي يُظهر أدلة وقت التشغيل.", "How often each window sat inside, near, or outside its declared limits": "عدد المرات التي كانت فيها كل نافذة داخل حدودها المعلنة أو قريبة منها أو خارجها", "Inquiry brief": "موجز الاستقصاء", "Insights carded as evidence, capped for fast review.": "الرؤى معروضة كأدلة، ومحدودة العدد للمراجعة السريعة.", "Instruments & counterparties": "الأدوات والأطراف المقابلة", "Kept": "المحتفظ به", "Latest capability decision": "أحدث قرار للقدرات", "Lifecycle records": "سجلات دورة الحياة", "Lifecycle timeline": "الخط الزمني لدورة الحياة", "Lifecycle transitions": "انتقالات دورة الحياة", "Line of inquiry": "خط الاستقصاء", "Live activity": "النشاط المباشر", "Location": "الموقع", "Loop phase": "مرحلة الحلقة", "Mean of each downsample window. Declared limits are listed per channel below.": "متوسط كل نافذة تخفيض للعينات. الحدود المعلنة مدرجة لكل قناة أدناه.", "Model's reasoning": "استدلال النموذج", "Mutation": "التغيير", "Narrative": "السرد", "Narrative pulse": "نبض السرد", "Needs attention": "يستدعي الانتباه", "Next recal due": "موعد إعادة المعايرة", "Next step": "الخطوة التالية", "No causal history yet": "لا يوجد تاريخ سببي بعد", "Normalized error": "الخطأ المعياري", "Normalized error is the residual as a share of the channel's declared span.": "الخطأ المعياري هو المتبقي كنسبة من المدى المعلن للقناة.", "Not yet observed": "لم يُرصد بعد", "Nothing has driven a framework change, so there is no episode to narrate.": "لم يدفع أي شيء بعد إلى تغيير في الإطار، لذا لا توجد حلقة لسردها.", "OHLC extracted from captured session market data.": "OHLC مستخرج من بيانات السوق المسجلة في الجلسة.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "قائمة الرصد وحالة المقترحات وقرارات السياسة ونتائج دورة الحياة.", "Observations": "الرصدات", "Observed Hz": "الهرتز المرصود", "Observed rate against declared rate": "المعدل المرصود مقابل المعدل المعلن", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "مساحة أسماء عالمية واحدة، تُحكَّم بأسبقية التسجيل. يُسجَّل المتنافس ولا يُهمَل بصمت.", "Open": "مفتوح", "Open risks": "المخاطر المفتوحة", "Open/high/low/close from captured tool output.": "الافتتاح/الأعلى/الأدنى/الإغلاق من مخرجات الأدوات المسجلة.", "Origin": "المصدر", "Outcome": "النتيجة", "PRODUCTION": "إنتاج", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "لكل حلقة: المُحفِّز والقرار والتغيير وما إذا أُغلقت الفجوة.", "Per-channel calibration state, freshness, and residual correction": "حالة المعايرة وحداثتها وتصحيح المتبقي لكل قناة", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "أدلة وقت التشغيل لكل مقطع. وجود وحدة لا يعني أن شيئًا يستدعيها.", "Pipeline": "المسار", "Pipeline evidence": "أدلة المسار", "Pipeline reachability": "إمكانية الوصول إلى المسار", "Plan": "الخطة", "Plan steps": "خطوات الخطة", "Plugin": "الملحق", "Plugin roster and trust": "قائمة الملحقات والثقة", "Plugins": "الملحقات", "Plugins by origin": "الإضافات حسب المصدر", "Plugins by trust class": "الإضافات حسب فئة الثقة", "Policy": "السياسة", "Policy decisions": "قرارات السياسة", "Positions & actions": "المراكز والإجراءات", "Posture": "الوضع", "Price action": "حركة السعر", "Proposal": "المقترح", "Proposal status": "حالة المقترح", "Proposed, not admitted": "مُقترح وغير مقبول", "Pulse": "النبض", "Quarantine feed": "تغذية الحجر", "Ratio": "النسبة", "Read live from the registry and trust ledger every cycle.": "يُقرأ مباشرة من السجل ودفتر الثقة في كل دورة.", "Recent episodes": "الحلقات الأخيرة", "Reclaim candidates": "مرشّحو الاسترجاع", "Reclaimable": "قابل للاسترجاع", "References & follow-ups": "المراجع والمتابعات", "References (entities)": "المراجع (الكيانات)", "Registry": "السجل", "Registry delta": "فرق السجل", "Registry version": "إصدار السجل", "Regressions": "الانحدارات", "Rejected": "المرفوض", "Representative observations, capped for quick scanning.": "رصدات تمثيلية، محدودة العدد للقراءة السريعة.", "Requirements": "المتطلبات", "Research lens": "منظور بحثي", "Residual": "المتبقي", "Reward signal bandwidth": "نطاق إشارة المكافأة", "Runtime evidence": "دليل وقت التشغيل", "Sampled history per channel, newest on the right": "سجل العينات لكل قناة، الأحدث على اليمين", "Segment": "المقطع", "Segments by status": "الأجزاء حسب الحالة", "Selectable": "قابل للاختيار", "Selection delta": "فرق الاختيار", "Self-acquired": "مُكتسَب ذاتيًا", "Self-acquired plugins that are registered but unselectable or never once used.": "إضافات مُكتسَبة ذاتيًا مُسجَّلة لكنها غير قابلة للاختيار أو لم تُستخدم قطّ.", "Sentiment lens": "منظور المشاعر", "Series": "السلسلة", "Session analysis": "تحليل الجلسة", "Signal strength": "قوة الإشارة", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "إشارات على أن شيئًا نما بشكل خاطئ أو تم حجبه. تظهر أيًا كان التبويب المفتوح.", "Skipped slots": "الفتحات المتخطاة", "State": "الحالة", "Storyline and signal strength before drilling into positions and actions.": "السرد وقوة الإشارة قبل التوسع في المراكز والإجراءات.", "Streaming": "بث", "Suggested next steps": "الخطوات التالية المقترحة", "The line of investigation and where the open questions concentrate.": "خط البحث وأين تتركز الأسئلة المفتوحة.", "The narrative arc and how strongly themes are trending.": "قوس السرد ومدى قوة اتجاه الموضوعات.", "The world model asked for these capabilities and nothing took them up.": "طلب نموذج العالم هذه القدرات ولم يتبنّها شيء.", "Theme intensity": "شدة الموضوعات", "Themes": "الموضوعات", "This board reports how the framework changes itself. Nothing has been recorded yet.": "تُبلِّغ هذه اللوحة عن كيفية تغيير الإطار لنفسه. لم يُسجَّل أي شيء بعد.", "To": "إلى", "Tool": "الأداة", "Tool-name conflicts": "تعارضات أسماء الأدوات", "Tools": "الأدوات", "Transport": "النقل", "Transport, provenance and channel counts": "النقل والمنشأ وعدد القنوات", "Trust": "الثقة", "Trust accrual": "تراكم الثقة", "Trust class": "فئة الثقة", "Unselectable reclamation": "استرجاع غير القابل للاختيار", "Usable": "قابل للاستخدام", "VERIFIED": "مُتحقَّق", "Verdicts": "الأحكام", "Verdicts by reason": "الأحكام حسب السبب", "Verified": "مُتحقَّق", "Verified by": "تم التحقق بواسطة", "Voices & concerns": "الأصوات والمخاوف", "Watchlist": "قائمة المتابعة", "What changed in the environment, and what the framework did about it.": "ما تغيّر في البيئة، وما فعله الإطار حيال ذلك.", "Which plugin owns which tool, and which capability that tool provides.": "أي ملحق يملك أي أداة، وأي قدرة توفرها تلك الأداة.", "Who/what is in the conversation, and the concerns still open.": "من/ما هو في المحادثة، والمخاوف التي لا تزال مفتوحة.", "Why": "السبب", "Why not admitted": "سبب عدم القبول", "Why this page is empty": "لماذا هذه الصفحة فارغة", "World-model driver": "مُشغِّل نموذج العالم", "Writable": "قابل للكتابة", "aborted": "مُلغى", "accruing": "قيد التراكم", "active": "نشط", "appeared": "ظهر", "armed": "مُسلّح", "assess_compatibility": "تقييم التوافق", "built_in": "مدمج", "capability_expand": "توسيع القدرة", "committed": "مُنجَز", "conformance": "المطابقة", "declared_fitness": "الملاءمة المُعلنة", "disable": "تعطيل", "disposed": "تم التخلص منه", "effect_observed": "تم رصد الأثر", "environment_probe": "مِجَس البيئة", "execution_failed": "فشل التنفيذ", "expected_effect_absent": "الأثر المتوقع غائب", "failed": "فشل", "frozen": "مُجمَّد", "gone": "اختفى", "idle": "خامل", "install": "تثبيت", "loading": "قيد التحميل", "manual": "يدوي", "moved": "انتقل", "new_unproven": "جديد وغير مُثبَت", "no": "لا", "no_evidence": "لا يوجد دليل", "no_expected_effect_declared": "لم يُعلَن أثر متوقع", "no_outcome_observed": "لم يُرصد أي ناتج", "none": "لا شيء", "not_admitted": "غير مقبول", "not_applicable": "غير منطبق", "observe_only": "المراقبة فقط", "observed_effect": "الأثر المرصود", "open": "مفتوح", "pending": "معلّق", "reload": "إعادة تحميل", "remove": "إزالة", "reopened": "أُعيد فتحه", "resolved": "تم الحل", "rollback": "تراجع", "runtime": "وقت التشغيل", "self_acquired": "مُكتسَب ذاتيًا", "still_open": "لا يزال مفتوحًا", "tool_reported_no_effect": "الأداة لم تُبلِّغ عن أثر", "trusted": "موثوق", "unknown": "غير معروف", "unknown_tool": "أداة غير معروفة", "unloading": "قيد الإلغاء", "unscheduled": "غير مُجدول", "unverifiable": "غير قابل للتحقق", "unverified": "غير مُتحقَّق", "waiting": "في الانتظار", "watching": "يراقب", "wired": "موصول", "world_model": "نموذج العالم", "yes": "نعم"},
-    ru: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **Ни одного заключения об эффекте пока не записано**, поэтому измерять нечего. Показатели выше намеренно пусты, а не равны нулю. Эффект можно проверить только если требование его заявило, а сегодня заявленный эффект несут лишь требования, составленные моделью мира.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **Регрессия: закрытый пробел возобновился.** Эволюция, казавшаяся успешной, не удержалась. Это единственный вывод на этой панели, требующий немедленного внимания.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **Только снимок.** Причинной истории для восстановления пока нет, поэтому хронология отсутствует, а не пуста. Причина указана в строке `Решения политики` под покрытием конвейера; снимок и таблица покрытия не затронуты.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **Некоторые плагины заморожены из-за внутреннего дефекта.** Замороженный плагин по-прежнему сообщает `DRAFT`, а измерение доверия только *оценивает*, поэтому он остаётся выбираемым, пока не будет также снят с регистрации — см. столбец `Выбираемо`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **Уровень проверки: L2 (заявленная пригодность).** Снятое наблюдение означает, что кандидат *заявил* о предоставлении возможности, а не что возможность наблюдалась в работе. Проверка эффекта (L3) не подключена, поэтому ни одно закрытие на этой панели не следует считать доказанным.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> Прежде чем появятся данные, должен завершиться хотя бы один цикл наблюдения. Если это сохраняется, проверьте, включён ли планировщик и что наблюдение `framework-evolution` активно и не отключено.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> Эпизод записывается, когда наблюдение окружения приводит к решению о возможности. Ни одного не зафиксировано: либо система спокойна, либо конвейер останавливается раньше — вкладка **Конвейер** называет сегмент остановки и то, что его разблокирует.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> Ничто не утилизирует их автоматически. Каждый занимает имя инструмента и присутствует в списке возможностей, не будучи выбираемым: реестр растёт в направлении, непригодном ни для одного требования.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> Эти предложения не вошли ни в один конвейер, поэтому не отражены ни в одной записи решения или наблюдения. Их приём — вопрос конфигурации.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "Отношение ниже 1,0 означает, что цикл выборки не выдерживает объявленный ритм.", "Abstained": "Воздержалось", "Acquisition authority": "Право на получение", "Acquisition lifecycle": "Жизненный цикл получения", "Action": "Действие", "After": "После", "An unverified declaration has its writable channels demoted to read-only.": "У непроверенного объявления записываемые каналы понижаются до только чтения.", "Approval": "Согласование", "Autonomous governance": "Автономное управление", "Autonomy": "Автономность", "Before": "До", "CANDIDATE": "Кандидат", "Calibrated at": "Калиброван", "Calibration health": "Состояние калибровки", "Calls": "Вызовы", "Calls (decisions)": "Рекомендации (решения)", "Candlestick": "Свечи", "Capability": "Возможность", "Capability adaptation": "Адаптация возможностей", "Capability observations": "Наблюдения возможностей", "Capability ownership": "Владение возможностями", "Capability topology": "Топология возможностей", "Change": "Изменение", "Channel": "Канал", "Channels": "Каналы", "Channels that have never been calibrated or whose calibration has expired are shown first.": "Каналы, которые никогда не калибровались или чья калибровка истекла, показаны первыми.", "Command": "Команда", "Commanded versus observed, best tracking first": "Заданное против наблюдаемого, лучшее отслеживание первым", "Composition": "Состав", "Concerns (open questions)": "Опасения (открытые вопросы)", "Confidence": "Уверенность", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "Подсчитано по всем отображаемым каналам. «У границы» — в пределах 5% от объявленного предела.", "Cycles run": "Выполнено циклов", "DRAFT": "Черновик", "Days since": "Дней с тех пор", "Decision": "Решение", "Decisions read as calls; action items as the execution checklist.": "Решения читаются как рекомендации; действия — как чек-лист исполнения.", "Declared Hz": "Объявл. Гц", "Desk brief": "Сводка деска", "Device": "Устройство", "Dropped samples": "Отброшенные образцы", "Each row names one blocked segment and the change that would unblock it.": "Каждая строка называет заблокированный сегмент и изменение, которое его разблокирует.", "Effect verification (L3)": "Проверка эффекта (L3)", "Effects declared": "Заявлено эффектов", "Entities as references, and recommended next prompts to advance the work.": "Сущности как ссылки и рекомендуемые следующие запросы.", "Entities in play and the open risks still to resolve.": "Задействованные сущности и нерешённые риски.", "Envelope, rate, staleness and quality observations · newest first": "Наблюдения по огибающей, частоте, устареванию и качеству · сначала новые", "Environment": "Окружение", "Environment to framework": "От окружения к фреймворку", "Environment, selected plugin tools, and orchestration order.": "Окружение, выбранные инструменты плагинов и порядок оркестрации.", "Error rate": "Частота ошибок", "Events paced out": "Событий подавлено", "Ever used": "Использовался", "Evidence": "Обоснование", "Evidence admission": "Приём данных", "Evolution": "Эволюция", "Evolution timeline": "Хронология эволюции", "Executable": "Исполнимо", "Execution checklist": "Чек-лист исполнения", "Extracted from this session's tool/file output (not model-generated).": "Извлечено из вывода инструментов/файлов этой сессии (не сгенерировано моделью).", "Failures": "Сбои", "Fiber": "Файбер", "Fiber state changes since the previous cycle, including load retries.": "Изменения состояния fiber с предыдущего цикла, включая повторные загрузки.", "Finance lens": "Финансовый ракурс", "Follow-ups": "Продолжения", "Framework change": "Изменение фреймворка", "Framework changes as they happened, from runtime probes.": "Изменения фреймворка в момент их появления, от рантайм-зондов.", "Framework evolution": "Эволюция фреймворка", "Framework size and how much of the evolution pipeline shows runtime evidence.": "Размер фреймворка и какая часть конвейера эволюции показывает свидетельства времени выполнения.", "From": "Из", "Frozen plugins": "Замороженные плагины", "Gap closure": "Закрытие пробела", "Halt": "Останов", "How closures are verified": "Как проверяются закрытия", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "Какая часть сигнала об эффекте пригодна как обратная связь. Это определяет, стоит ли строить обучающую политику.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "Какую часть фреймворка он вырастил сам и какая часть конвейера показывает данные времени выполнения.", "How often each window sat inside, near, or outside its declared limits": "Как часто каждое окно было внутри, у границы или вне объявленных пределов", "Inquiry brief": "Сводка исследования", "Insights carded as evidence, capped for fast review.": "Инсайты как карточки-обоснования, ограничены для быстрого просмотра.", "Instruments & counterparties": "Инструменты и контрагенты", "Kept": "Оставлен", "Latest capability decision": "Последнее решение о возможностях", "Lifecycle records": "Записи жизненного цикла", "Lifecycle timeline": "Хронология жизненного цикла", "Lifecycle transitions": "Переходы жизненного цикла", "Line of inquiry": "Линия исследования", "Live activity": "Текущая активность", "Location": "Расположение", "Loop phase": "Фаза цикла", "Mean of each downsample window. Declared limits are listed per channel below.": "Среднее по каждому окну прореживания. Объявленные пределы указаны по каналам ниже.", "Model's reasoning": "Обоснование модели", "Mutation": "Изменение", "Narrative": "Сюжет", "Narrative pulse": "Нарративный пульс", "Needs attention": "Требует внимания", "Next recal due": "Следующая рекалибровка", "Next step": "Следующий шаг", "No causal history yet": "Причинной истории пока нет", "Normalized error": "Нормированная ошибка", "Normalized error is the residual as a share of the channel's declared span.": "Нормированная ошибка — остаток как доля объявленного диапазона канала.", "Not yet observed": "Ещё не наблюдалось", "Nothing has driven a framework change, so there is no episode to narrate.": "Ничто пока не вызвало изменения фреймворка, поэтому рассказывать не о чем.", "OHLC extracted from captured session market data.": "OHLC извлечён из рыночных данных, записанных в сессии.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "Очередь наблюдений, состояние предложений, решения политики и итоги жизненного цикла.", "Observations": "Наблюдения", "Observed Hz": "Наблюд. Гц", "Observed rate against declared rate": "Наблюдаемая частота против объявленной", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "Единое глобальное пространство имён, арбитраж по первому пришедшему. Претендент записывается, а не отбрасывается молча.", "Open": "Открыт", "Open risks": "Открытые риски", "Open/high/low/close from captured tool output.": "Открытие/максимум/минимум/закрытие из записанного вывода инструментов.", "Origin": "Источник", "Outcome": "Результат", "PRODUCTION": "Продакшн", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "По эпизодам: триггер, решение, изменение и закрылся ли пробел.", "Per-channel calibration state, freshness, and residual correction": "Состояние калибровки, актуальность и остаточная поправка по каналам", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "Свидетельства времени выполнения по сегментам. Наличие модуля не доказывает, что его кто-то вызывает.", "Pipeline": "Конвейер", "Pipeline evidence": "Свидетельства конвейера", "Pipeline reachability": "Достижимость конвейера", "Plan": "План", "Plan steps": "Шаги плана", "Plugin": "Плагин", "Plugin roster and trust": "Реестр плагинов и доверие", "Plugins": "Плагины", "Plugins by origin": "Плагины по происхождению", "Plugins by trust class": "Плагины по классу доверия", "Policy": "Политика", "Policy decisions": "Решения политики", "Positions & actions": "Позиции и действия", "Posture": "Состояние", "Price action": "Ценовое движение", "Proposal": "Предложение", "Proposal status": "Статус предложения", "Proposed, not admitted": "Предложено, не принято", "Pulse": "Пульс", "Quarantine feed": "Поток карантина", "Ratio": "Отношение", "Read live from the registry and trust ledger every cycle.": "Читается напрямую из реестра и журнала доверия каждый цикл.", "Recent episodes": "Недавние эпизоды", "Reclaim candidates": "Кандидаты на утилизацию", "Reclaimable": "Утилизируемо", "References & follow-ups": "Ссылки и продолжения", "References (entities)": "Ссылки (сущности)", "Registry": "Реестр", "Registry delta": "Изменение реестра", "Registry version": "Версия реестра", "Regressions": "Регрессии", "Rejected": "Отклонён", "Representative observations, capped for quick scanning.": "Показательные наблюдения, ограничены для быстрого просмотра.", "Requirements": "Требования", "Research lens": "Исследовательский ракурс", "Residual": "Остаток", "Reward signal bandwidth": "Пропускная способность сигнала вознаграждения", "Runtime evidence": "Свидетельство времени выполнения", "Sampled history per channel, newest on the right": "История выборок по каналам, самое новое справа", "Segment": "Сегмент", "Segments by status": "Сегменты по статусу", "Selectable": "Выбираемый", "Selection delta": "Изменение выбора", "Self-acquired": "Самостоятельно получено", "Self-acquired plugins that are registered but unselectable or never once used.": "Самостоятельно полученные плагины, которые зарегистрированы, но невыбираемы или ни разу не использовались.", "Sentiment lens": "Ракурс тональности", "Series": "Серия", "Session analysis": "Анализ сессии", "Signal strength": "Сила сигнала", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "Признаки того, что что-то выросло неверно или было задержано. Показываются независимо от открытой вкладки.", "Skipped slots": "Пропущенные слоты", "State": "Состояние", "Storyline and signal strength before drilling into positions and actions.": "Сюжет и сила сигнала до перехода к позициям и действиям.", "Streaming": "Потоковая передача", "Suggested next steps": "Рекомендуемые следующие шаги", "The line of investigation and where the open questions concentrate.": "Линия исследования и где сосредоточены открытые вопросы.", "The narrative arc and how strongly themes are trending.": "Нарративная дуга и насколько сильно растут темы.", "The world model asked for these capabilities and nothing took them up.": "Модель мира запросила эти возможности, и никто их не принял.", "Theme intensity": "Интенсивность тем", "Themes": "Темы", "This board reports how the framework changes itself. Nothing has been recorded yet.": "Эта панель сообщает, как фреймворк изменяет сам себя. Пока ничего не записано.", "To": "В", "Tool": "Инструмент", "Tool-name conflicts": "Конфликты имён инструментов", "Tools": "Инструменты", "Transport": "Транспорт", "Transport, provenance and channel counts": "Транспорт, происхождение и число каналов", "Trust": "Доверие", "Trust accrual": "Накопление доверия", "Trust class": "Класс доверия", "Unselectable reclamation": "Утилизация невыбираемого", "Usable": "Пригодно", "VERIFIED": "Проверено", "Verdicts": "Заключений", "Verdicts by reason": "Заключения по причине", "Verified": "Проверено", "Verified by": "Подтверждено", "Voices & concerns": "Голоса и опасения", "Watchlist": "Список наблюдения", "What changed in the environment, and what the framework did about it.": "Что изменилось в окружении и что фреймворк с этим сделал.", "Which plugin owns which tool, and which capability that tool provides.": "Какой плагин владеет каким инструментом и какую возможность этот инструмент предоставляет.", "Who/what is in the conversation, and the concerns still open.": "Кто/что в разговоре и какие опасения остаются.", "Why": "Почему", "Why not admitted": "Причина отклонения", "Why this page is empty": "Почему эта страница пуста", "World-model driver": "Драйвер модели мира", "Writable": "Записываемый", "aborted": "Прервано", "accruing": "Накапливается", "active": "Активно", "appeared": "Появился", "armed": "Активно", "assess_compatibility": "Оценка совместимости", "built_in": "Встроенный", "capability_expand": "Расширение возможностей", "committed": "Завершено", "conformance": "Соответствие", "declared_fitness": "Заявленная пригодность", "disable": "Отключение", "disposed": "Освобождено", "effect_observed": "Эффект наблюдался", "environment_probe": "Зонд окружения", "execution_failed": "Сбой выполнения", "expected_effect_absent": "Ожидаемый эффект отсутствует", "failed": "Сбой", "frozen": "Заморожено", "gone": "Исчез", "idle": "Простой", "install": "Установка", "loading": "Загрузка", "manual": "Вручную", "moved": "Перешёл", "new_unproven": "Новое, непроверенное", "no": "Нет", "no_evidence": "Нет данных", "no_expected_effect_declared": "Ожидаемый эффект не заявлен", "no_outcome_observed": "Результат не наблюдался", "none": "Нет", "not_admitted": "Не принято", "not_applicable": "Неприменимо", "observe_only": "Только наблюдение", "observed_effect": "Наблюдаемый эффект", "open": "Открыто", "pending": "Ожидает", "reload": "Перезагрузка", "remove": "Удаление", "reopened": "Возобновлено", "resolved": "Закрыто", "rollback": "Откат", "runtime": "Среда выполнения", "self_acquired": "Самостоятельно получено", "still_open": "Всё ещё открыто", "tool_reported_no_effect": "Инструмент не сообщил об эффекте", "trusted": "Доверенное", "unknown": "Неизвестно", "unknown_tool": "Неизвестный инструмент", "unloading": "Выгрузка", "unscheduled": "Не запланировано", "unverifiable": "Не проверяемо", "unverified": "Непроверенное", "waiting": "Ожидание", "watching": "Наблюдает", "wired": "Подключено", "world_model": "Модель мира", "yes": "Да"}
+    zh: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **尚未记录任何效果判定**，因此没有可度量的奖励信号。上面的比率有意留空而非显示 0%。只有当需求声明了预期效果才可能验证，而目前只有世界模型撰写的需求带有预期效果。", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **回归：已闭合的缺口再次复发。** 一次看起来成功的演进并未站住。这是本看板上唯一需要立即处理的发现。", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **仅快照。** 目前尚无可重建的因果历史，因此时间线是「缺席」而非「空白」。原因由管道贯通度中的 `策略决策` 一行说明；实时快照与贯通度表本身不受影响。", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **部分插件因内部缺陷被冻结。** 冻结的插件仍报告 `DRAFT`，而信任维度只做「打分」，因此若未同时注销，它仍可被选中——请查看 `可被选中` 列。", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **验证层级：L2（声明式适配）。** 观测被退役，只意味着某个候选**声明**自己提供该能力，并不意味着该能力被观测到确实生效。效果验证（L3）尚未接线，因此本看板上的任何闭合都不应被读作「已证实」。", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> 需要至少完成一个观测周期才会有内容。若持续为空，请检查调度器是否启用、`framework-evolution` watch 是否已 armed 且未静音。", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> 当一次环境观测导向一次能力决策时，才会写下一条剧集。目前尚无记录——这既可能是系统本就安静，也可能是管道更早就断了：**管道**页签会指出它断在哪一段，以及什么能解除阻塞。", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> 目前没有任何机制自动回收它们。每一个都占着一个工具名、出现在能力列表里，却不可被选中——注册表朝着没有任何需求能用的方向增长。", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> 这些提议未进入任何管道，因此不会出现在任何决策记录或观测中。是否准入是一项配置选择。", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "比值低于 1.0 表示采样循环未能维持其声明的节奏。", "Abstained": "弃权", "Acquisition authority": "获取授权", "Acquisition lifecycle": "获取生命周期", "Action": "动作", "After": "变更后", "An unverified declaration has its writable channels demoted to read-only.": "未核验的声明，其可写通道会被降级为只读。", "Approval": "审批", "Autonomous governance": "自主治理", "Autonomy": "自主级别", "Before": "变更前", "CANDIDATE": "候选级", "Calibrated at": "校准时间", "Calibration health": "校准健康度", "Calls": "调用次数", "Calls (decisions)": "观点（决策）", "Candlestick": "K 线", "Capability": "能力", "Capability adaptation": "能力适配", "Capability observations": "能力观测", "Capability ownership": "能力归属", "Capability topology": "能力拓扑", "Change": "变化", "Channel": "通道", "Channels": "通道数", "Channels that have never been calibrated or whose calibration has expired are shown first.": "从未校准或校准已过期的通道排在最前。", "Command": "命令", "Commanded versus observed, best tracking first": "命令值与实测值对比，跟随最好者在前", "Composition": "组成", "Concerns (open questions)": "关切（待答问题）", "Confidence": "置信度", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "统计所有绘制通道。“接近”指处于声明边界的 5% 以内。", "Cycles run": "已运行周期", "DRAFT": "草稿级", "Days since": "距今天数", "Decision": "决策", "Decisions read as calls; action items as the execution checklist.": "决策即观点，行动项即执行清单。", "Declared Hz": "声明频率 (Hz)", "Desk brief": "交易台简报", "Device": "设备", "Dropped samples": "丢弃的样本", "Each row names one blocked segment and the change that would unblock it.": "每一行指出一个受阻环节，以及能解除阻塞的那项变更。", "Effect verification (L3)": "效果验证（L3）", "Effects declared": "已声明效果", "Entities as references, and recommended next prompts to advance the work.": "实体作为参考，并给出推进工作的后续追问。", "Entities in play and the open risks still to resolve.": "涉及的实体，以及尚未解决的敞口风险。", "Envelope, rate, staleness and quality observations · newest first": "包络、速率、失联与质量观测 · 最新在前", "Environment": "环境", "Environment to framework": "环境 → 框架", "Environment, selected plugin tools, and orchestration order.": "环境、已选插件工具及编排顺序。", "Error rate": "错误率", "Events paced out": "被配速抑制的事件", "Ever used": "是否用过", "Evidence": "证据", "Evidence admission": "证据准入", "Evolution": "演进", "Evolution timeline": "演进时间线", "Executable": "可执行", "Execution checklist": "执行清单", "Extracted from this session's tool/file output (not model-generated).": "数据来自本次会话的工具/文件产物（非模型生成）。", "Failures": "失败次数", "Fiber": "Fiber 状态", "Fiber state changes since the previous cycle, including load retries.": "自上一周期以来的 Fiber 状态变化，含加载重试。", "Finance lens": "金融视图", "Follow-ups": "后续事项", "Framework change": "框架变更", "Framework changes as they happened, from runtime probes.": "来自运行时探针的框架变更实况。", "Framework evolution": "框架演进", "Framework size and how much of the evolution pipeline shows runtime evidence.": "框架规模，以及演进管道中有多少环节呈现运行时证据。", "From": "从", "Frozen plugins": "已冻结插件", "Gap closure": "缺口闭合", "Halt": "可急停", "How closures are verified": "闭合是如何验证的", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "效果信号中有多少可真正用作反馈。这决定了是否值得构建学习策略。", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "框架中有多少是它自己长出来的，以及演进管道中有多少环节呈现运行时证据。", "How often each window sat inside, near, or outside its declared limits": "各窗口处于声明限值内、接近边界或越界的频次", "Inquiry brief": "研究简报", "Insights carded as evidence, capped for fast review.": "洞察以证据卡呈现，数量受限以便快速浏览。", "Instruments & counterparties": "标的与交易对手", "Kept": "保留", "Latest capability decision": "最新能力决策", "Lifecycle records": "生命周期记录", "Lifecycle timeline": "生命周期时间线", "Lifecycle transitions": "生命周期迁移", "Line of inquiry": "研究主线", "Live activity": "实时动态", "Location": "位置", "Loop phase": "循环阶段", "Mean of each downsample window. Declared limits are listed per channel below.": "每个降采样窗口的均值。各通道的声明限值见下方。", "Model's reasoning": "模型的推理", "Mutation": "变更", "Narrative": "叙事", "Narrative pulse": "叙事脉搏", "Needs attention": "需要关注", "Next recal due": "下次校准期限", "Next step": "下一步", "No causal history yet": "尚无因果历史", "Normalized error": "归一化误差", "Normalized error is the residual as a share of the channel's declared span.": "归一化误差是残差占该通道声明量程的比例。", "Not yet observed": "尚未观测", "Nothing has driven a framework change, so there is no episode to narrate.": "尚无任何事驱动过框架变更，因此没有可讲述的剧集。", "OHLC extracted from captured session market data.": "OHLC 提取自本次会话捕获的行情数据。", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "观测待办、提案状态、策略决策与生命周期结果。", "Observations": "观测数", "Observed Hz": "实测频率 (Hz)", "Observed rate against declared rate": "实测速率与声明速率对比", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "单一全局命名空间，先注册者胜。挑战者会被记录，绝不静默丢弃。", "Open": "已连接", "Open risks": "敞口风险", "Open/high/low/close from captured tool output.": "开/高/低/收，来自捕获的工具输出。", "Origin": "来源", "Outcome": "结果", "PRODUCTION": "生产级", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "逐条剧集：触发源、决策、变更，以及缺口是否闭合。", "Per-channel calibration state, freshness, and residual correction": "各通道的校准状态、时效性与残差校正", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "逐段运行时证据。模块存在并不等于有任何代码调用它。", "Pipeline": "管道", "Pipeline evidence": "管道证据", "Pipeline reachability": "管道贯通度", "Plan": "计划", "Plan steps": "计划步骤", "Plugin": "插件", "Plugin roster and trust": "插件名册与信任", "Plugins": "插件数", "Plugins by origin": "按来源分布的插件", "Plugins by trust class": "按信任等级分布的插件", "Policy": "策略", "Policy decisions": "策略决策", "Positions & actions": "持仓与操作", "Posture": "态势", "Price action": "价格行为", "Proposal": "提案", "Proposal status": "提案状态", "Proposed, not admitted": "已提议，未准入", "Pulse": "脉搏", "Quarantine feed": "隔离进料", "Ratio": "比值", "Read live from the registry and trust ledger every cycle.": "每个周期从注册表与信任账本实时读取。", "Recent episodes": "近期剧集", "Reclaim candidates": "可回收候选", "Reclaimable": "可回收", "References & follow-ups": "参考与后续", "References (entities)": "参考（实体）", "Registry": "注册表", "Registry delta": "注册表变化", "Registry version": "注册表版本", "Regressions": "回归", "Rejected": "被拒", "Representative observations, capped for quick scanning.": "代表性观察，数量受限以便快速浏览。", "Requirements": "能力需求", "Research lens": "研究视图", "Residual": "残差", "Reward signal bandwidth": "奖励信号带宽", "Runtime evidence": "运行时证据", "Sampled history per channel, newest on the right": "按通道的采样历史，最新在右侧", "Segment": "管道段", "Segments by status": "按状态分布的管道段", "Selectable": "可被选中", "Selection delta": "选择变化", "Self-acquired": "自获取", "Self-acquired plugins that are registered but unselectable or never once used.": "已注册但不可被选中、或从未被使用过的自获取插件。", "Sentiment lens": "情绪视图", "Series": "序列", "Session analysis": "会话分析", "Signal strength": "信号强度", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "表明某处长错了、或被扣下未放行的信号。无论打开哪个页签都会显示。", "Skipped slots": "跳过的采样点", "State": "状态", "Storyline and signal strength before drilling into positions and actions.": "先看叙事与信号强度，再深入持仓与操作。", "Streaming": "采样中", "Suggested next steps": "建议的下一步", "The line of investigation and where the open questions concentrate.": "研究主线，以及待答问题的集中之处。", "The narrative arc and how strongly themes are trending.": "叙事走向，以及主题的趋势强度。", "The world model asked for these capabilities and nothing took them up.": "世界模型请求了这些能力，但无人受理。", "Theme intensity": "主题强度", "Themes": "主题", "This board reports how the framework changes itself. Nothing has been recorded yet.": "本看板报告框架如何改变自身。目前尚无任何记录。", "To": "到", "Tool": "工具", "Tool-name conflicts": "工具名冲突", "Tools": "工具数", "Transport": "传输方式", "Transport, provenance and channel counts": "传输方式、来源与通道数量", "Trust": "信任级别", "Trust accrual": "信任累积", "Trust class": "信任语义", "Unselectable reclamation": "不可选回收", "Usable": "可用", "VERIFIED": "已验证级", "Verdicts": "判定数", "Verdicts by reason": "按原因分布的判定", "Verified": "已核验", "Verified by": "验证依据", "Voices & concerns": "声音与关切", "Watchlist": "关注列表", "What changed in the environment, and what the framework did about it.": "环境发生了什么变化，框架又为此做了什么。", "Which plugin owns which tool, and which capability that tool provides.": "哪个插件拥有哪个工具，以及该工具提供什么能力。", "Who/what is in the conversation, and the concerns still open.": "谁/什么在被讨论，以及尚未解决的关切。", "Why": "原因", "Why not admitted": "未准入原因", "Why this page is empty": "这个页面为何是空的", "World-model driver": "世界模型驱动器", "Writable": "可写", "aborted": "已中断", "accruing": "正在累积", "active": "运行中", "appeared": "新出现", "armed": "已就绪", "assess_compatibility": "评估兼容性", "built_in": "内置", "capability_expand": "扩展能力", "committed": "已定论", "conformance": "合规", "declared_fitness": "声明式适配", "disable": "停用", "disposed": "已释放", "effect_observed": "效果已观测", "environment_probe": "环境探测", "execution_failed": "执行失败", "expected_effect_absent": "预期效果未出现", "failed": "已失败", "frozen": "已冻结", "gone": "已消失", "idle": "空闲无变化", "install": "安装", "loading": "加载中", "manual": "人工", "moved": "已迁移", "new_unproven": "新，未验证", "no": "否", "no_evidence": "无证据", "no_expected_effect_declared": "未声明预期效果", "no_outcome_observed": "未观测到结果", "none": "无", "not_admitted": "未准入", "not_applicable": "不适用", "observe_only": "仅观察", "observed_effect": "观测效果", "open": "进行中", "pending": "待启", "reload": "重载", "remove": "移除", "reopened": "已复发", "resolved": "已闭合", "rollback": "回滚", "runtime": "运行时", "self_acquired": "自获取", "still_open": "仍未闭合", "tool_reported_no_effect": "工具未报告效果", "trusted": "已信任", "unknown": "未知", "unknown_tool": "未知工具", "unloading": "卸载中", "unscheduled": "未调度", "unverifiable": "无法核实", "unverified": "未验证", "waiting": "等待首个周期", "watching": "监视中", "wired": "已贯通", "world_model": "世界模型", "yes": "是", "Causal trace": "因果追踪", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "单个框架演进快照的只读环境到治理证据。", "Evidence boundary": "证据边界", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "因果追踪展示已记录的事实；不推断缺失的审批或已观测效果。", "Episodes": "剧集", "Declared-fitness closures": "声明式适配闭合", "Counterfactual / mutation matrix": "反事实 / 变更矩阵", "Each row preserves the driver, decision, registry delta, and verification tier.": "每一行保留驱动因素、决策、注册表变化和验证层级。", "Trigger": "触发源", "Evidence tier": "证据层级", "Episode timeline": "剧集时间线", "Rebuilt from existing decision and observation records.": "从现有决策和观测记录重建。", "Durable trace feed": "持久追踪流", "Rejected and no-op decisions remain visible when their trace sink is installed.": "安装追踪接收器后，被拒绝和无操作决策仍保持可见。", "Lifecycle": "生命周期", "Pipeline evidence over time": "管道证据随时间变化", "One point per recorded change in framework state, oldest first.": "每一个点对应一次已记录的框架状态变化，最旧在左。", "Samples": "样本数", "Net change": "净变化"},
+    fr: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **Aucun verdict d'effet n'a encore été enregistré**, il n'y a donc aucun signal de récompense à mesurer. Les taux ci-dessus sont volontairement vides plutôt que nuls. Un effet ne peut être vérifié que si l'exigence en a déclaré un, et seules les exigences rédigées par le modèle du monde en portent aujourd'hui.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **Régression : un écart comblé s'est reproduit.** Une évolution qui semblait réussie n'a pas tenu. C'est le seul constat de ce tableau qui exige une attention immédiate.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **Instantané seulement.** Aucun historique causal à reconstruire pour l'instant : la chronologie est absente, non vide. La raison est indiquée par la ligne `Décisions de politique` sous la couverture du pipeline ; l'instantané et le tableau de couverture ne sont pas affectés.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **Certains plugins sont gelés par un défaut interne.** Un plugin gelé signale toujours `DRAFT`, et la dimension de confiance ne fait que *noter*, donc il reste sélectionnable tant qu'il n'est pas également désenregistré — voir la colonne `Sélectionnable`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **Niveau de vérification : L2 (aptitude déclarée).** Une observation retirée signifie qu'un candidat a *déclaré* fournir la capacité, non que la capacité a été observée en fonctionnement. La vérification d'effet (L3) n'est pas câblée, donc aucune clôture de ce tableau ne doit être lue comme prouvée.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> Un cycle d'observation doit s'achever avant qu'il y ait quoi que ce soit à montrer. Si cela persiste, vérifiez que le planificateur est actif et que la surveillance `framework-evolution` est armée et non silencée.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> Un épisode est écrit lorsqu'une observation de l'environnement conduit à une décision de capacité. Aucun n'a été enregistré : soit le système est calme, soit le pipeline s'arrête plus tôt — l'onglet **Pipeline** nomme le segment où il s'arrête et ce qui le débloquerait.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> Rien ne les récupère automatiquement. Chacun occupe un nom d'outil et figure dans la liste des capacités sans être sélectionnable : le registre grandit dans une direction qu'aucune exigence ne peut utiliser.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> Ces propositions n'ont intégré aucun pipeline : elles n'apparaissent donc dans aucun enregistrement de décision ni observation. Les admettre est un choix de configuration.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "Un ratio inférieur à 1,0 signifie que la boucle d’échantillonnage ne tient pas sa cadence déclarée.", "Abstained": "Abstention", "Acquisition authority": "Autorité d'acquisition", "Acquisition lifecycle": "Cycle de vie d'acquisition", "Action": "Action", "After": "Après", "An unverified declaration has its writable channels demoted to read-only.": "Une déclaration non vérifiée voit ses canaux inscriptibles rétrogradés en lecture seule.", "Approval": "Approbation", "Autonomous governance": "Gouvernance autonome", "Autonomy": "Autonomie", "Before": "Avant", "CANDIDATE": "Candidat", "Calibrated at": "Calibré le", "Calibration health": "État de calibration", "Calls": "Appels", "Calls (decisions)": "Recommandations (décisions)", "Candlestick": "Chandeliers", "Capability": "Capacité", "Capability adaptation": "Adaptation des capacités", "Capability observations": "Observations de capacités", "Capability ownership": "Propriété des capacités", "Capability topology": "Topologie des capacités", "Change": "Changement", "Channel": "Canal", "Channels": "Canaux", "Channels that have never been calibrated or whose calibration has expired are shown first.": "Les canaux jamais calibrés ou dont la calibration a expiré apparaissent en premier.", "Command": "Commande", "Commanded versus observed, best tracking first": "Commandé contre observé, meilleur suivi d’abord", "Composition": "Composition", "Concerns (open questions)": "Préoccupations (questions ouvertes)", "Confidence": "Confiance", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "Compté sur tous les canaux tracés. « près » signifie à moins de 5 % d’une borne déclarée.", "Cycles run": "Cycles exécutés", "DRAFT": "Brouillon", "Days since": "Jours écoulés", "Decision": "Décision", "Decisions read as calls; action items as the execution checklist.": "Les décisions se lisent comme des recommandations ; les actions comme la liste d’exécution.", "Declared Hz": "Hz déclarés", "Desk brief": "Note de desk", "Device": "Appareil", "Dropped samples": "Échantillons perdus", "Each row names one blocked segment and the change that would unblock it.": "Chaque ligne nomme un segment bloqué et le changement qui le débloquerait.", "Effect verification (L3)": "Vérification d'effet (L3)", "Effects declared": "Effets déclarés", "Entities as references, and recommended next prompts to advance the work.": "Entités comme références, et invites suivantes recommandées pour avancer.", "Entities in play and the open risks still to resolve.": "Entités concernées et risques ouverts à résoudre.", "Envelope, rate, staleness and quality observations · newest first": "Observations d’enveloppe, de débit, d’obsolescence et de qualité · les plus récentes d’abord", "Environment": "Environnement", "Environment to framework": "De l'environnement au framework", "Environment, selected plugin tools, and orchestration order.": "Environnement, outils de plugin sélectionnés et ordre d’orchestration.", "Error rate": "Taux d'erreur", "Events paced out": "Événements limités", "Ever used": "Déjà utilisé", "Evidence": "Preuve", "Evidence admission": "Admission des preuves", "Evolution": "Évolution", "Evolution timeline": "Chronologie de l'évolution", "Executable": "Exécutable", "Execution checklist": "Liste d’exécution", "Extracted from this session's tool/file output (not model-generated).": "Extrait des sorties d’outils/fichiers de cette session (non généré par le modèle).", "Failures": "Échecs", "Fiber": "Fibre", "Fiber state changes since the previous cycle, including load retries.": "Changements d'état de fiber depuis le cycle précédent, y compris les tentatives de chargement.", "Finance lens": "Vue finance", "Follow-ups": "Suivis", "Framework change": "Changement du framework", "Framework changes as they happened, from runtime probes.": "Changements du framework en temps réel, via les sondes d'exécution.", "Framework evolution": "Évolution du framework", "Framework size and how much of the evolution pipeline shows runtime evidence.": "Taille du framework et part du pipeline d'évolution qui présente des preuves d'exécution.", "From": "De", "Frozen plugins": "Plugins gelés", "Gap closure": "Clôture de l'écart", "Halt": "Arrêt", "How closures are verified": "Comment les clôtures sont vérifiées", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "Quelle part du signal d'effet est exploitable comme rétroaction. C'est ce qui détermine s'il vaut la peine de construire une politique d'apprentissage.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "Quelle part du framework il a fait croître lui-même, et quelle part du pipeline présente des preuves d'exécution.", "How often each window sat inside, near, or outside its declared limits": "Fréquence à laquelle chaque fenêtre était dans, près de, ou hors de ses limites déclarées", "Inquiry brief": "Note d’enquête", "Insights carded as evidence, capped for fast review.": "Analyses présentées comme preuves, limitées pour une revue rapide.", "Instruments & counterparties": "Instruments et contreparties", "Kept": "Conservé", "Latest capability decision": "Dernière décision de capacité", "Lifecycle records": "Enregistrements de cycle de vie", "Lifecycle timeline": "Chronologie du cycle de vie", "Lifecycle transitions": "Transitions de cycle de vie", "Line of inquiry": "Ligne d’enquête", "Live activity": "Activité en direct", "Location": "Emplacement", "Loop phase": "Phase de boucle", "Mean of each downsample window. Declared limits are listed per channel below.": "Moyenne de chaque fenêtre de sous-échantillonnage. Les limites déclarées figurent par canal ci-dessous.", "Model's reasoning": "Raisonnement du modèle", "Mutation": "Mutation", "Narrative": "Récit", "Narrative pulse": "Pouls narratif", "Needs attention": "Requiert attention", "Next recal due": "Prochaine recalibration", "Next step": "Étape suivante", "No causal history yet": "Pas encore d'historique causal", "Normalized error": "Erreur normalisée", "Normalized error is the residual as a share of the channel's declared span.": "L’erreur normalisée est le résidu en proportion de l’étendue déclarée du canal.", "Not yet observed": "Pas encore observé", "Nothing has driven a framework change, so there is no episode to narrate.": "Rien n'a encore déclenché de changement du framework : il n'y a donc aucun épisode à raconter.", "OHLC extracted from captured session market data.": "OHLC extrait des données de marché capturées durant la session.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "File d’observations, état des propositions, décisions de politique et résultats du cycle de vie.", "Observations": "Observations", "Observed Hz": "Hz observés", "Observed rate against declared rate": "Débit observé par rapport au débit déclaré", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "Un espace de noms global unique, arbitré au premier arrivé. Le concurrent est enregistré, jamais supprimé en silence.", "Open": "Ouvert", "Open risks": "Risques ouverts", "Open/high/low/close from captured tool output.": "Ouverture/haut/bas/clôture issus des sorties d’outils capturées.", "Origin": "Origine", "Outcome": "Résultat", "PRODUCTION": "Production", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "Par épisode : le déclencheur, la décision, le changement, et si l'écart a été comblé.", "Per-channel calibration state, freshness, and residual correction": "État de calibration, fraîcheur et correction résiduelle par canal", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "Preuves d'exécution par segment. L'existence d'un module ne prouve pas qu'il soit appelé.", "Pipeline": "Pipeline", "Pipeline evidence": "Preuves du pipeline", "Pipeline reachability": "Accessibilité du pipeline", "Plan": "Plan", "Plan steps": "Étapes du plan", "Plugin": "Plugin", "Plugin roster and trust": "Registre des plugins et confiance", "Plugins": "Plugins", "Plugins by origin": "Plugins par origine", "Plugins by trust class": "Plugins par classe de confiance", "Policy": "Politique", "Policy decisions": "Décisions de politique", "Positions & actions": "Positions et actions", "Posture": "Posture", "Price action": "Action des prix", "Proposal": "Proposition", "Proposal status": "Statut de la proposition", "Proposed, not admitted": "Proposé, non admis", "Pulse": "Pouls", "Quarantine feed": "Flux de quarantaine", "Ratio": "Ratio", "Read live from the registry and trust ledger every cycle.": "Lu en direct depuis le registre et le registre de confiance à chaque cycle.", "Recent episodes": "Épisodes récents", "Reclaim candidates": "Candidats à la récupération", "Reclaimable": "Récupérable", "References & follow-ups": "Références et suivis", "References (entities)": "Références (entités)", "Registry": "Registre", "Registry delta": "Delta du registre", "Registry version": "Version du registre", "Regressions": "Régressions", "Rejected": "Rejeté", "Representative observations, capped for quick scanning.": "Observations représentatives, limitées pour une lecture rapide.", "Requirements": "Exigences", "Research lens": "Vue recherche", "Residual": "Résidu", "Reward signal bandwidth": "Bande passante du signal de récompense", "Runtime evidence": "Preuve d'exécution", "Sampled history per channel, newest on the right": "Historique échantillonné par canal, le plus récent à droite", "Segment": "Segment", "Segments by status": "Segments par statut", "Selectable": "Sélectionnable", "Selection delta": "Delta de sélection", "Self-acquired": "Auto-acquis", "Self-acquired plugins that are registered but unselectable or never once used.": "Plugins auto-acquis qui sont enregistrés mais non sélectionnables, ou jamais utilisés une seule fois.", "Sentiment lens": "Vue sentiment", "Series": "Série", "Session analysis": "Analyse de session", "Signal strength": "Force du signal", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "Signaux indiquant qu'une évolution a mal tourné ou a été retenue. Affichés quel que soit l'onglet ouvert.", "Skipped slots": "Créneaux manqués", "State": "État", "Storyline and signal strength before drilling into positions and actions.": "Récit et force du signal avant d’examiner positions et actions.", "Streaming": "Diffusion", "Suggested next steps": "Prochaines étapes suggérées", "The line of investigation and where the open questions concentrate.": "La ligne d’investigation et où se concentrent les questions ouvertes.", "The narrative arc and how strongly themes are trending.": "L’arc narratif et l’intensité des tendances thématiques.", "The world model asked for these capabilities and nothing took them up.": "Le modèle du monde a demandé ces capacités et personne ne les a prises en charge.", "Theme intensity": "Intensité des thèmes", "Themes": "Thèmes", "This board reports how the framework changes itself. Nothing has been recorded yet.": "Ce tableau rend compte de la façon dont le framework se modifie lui-même. Rien n'a encore été enregistré.", "To": "Vers", "Tool": "Outil", "Tool-name conflicts": "Conflits de noms d'outils", "Tools": "Outils", "Transport": "Transport", "Transport, provenance and channel counts": "Transport, provenance et nombre de canaux", "Trust": "Confiance", "Trust accrual": "Accumulation de confiance", "Trust class": "Classe de confiance", "Unselectable reclamation": "Récupération non sélectionnable", "Usable": "Exploitable", "VERIFIED": "Vérifié", "Verdicts": "Verdicts", "Verdicts by reason": "Verdicts par motif", "Verified": "Vérifié", "Verified by": "Vérifié par", "Voices & concerns": "Voix et préoccupations", "Watchlist": "Liste de suivi", "What changed in the environment, and what the framework did about it.": "Ce qui a changé dans l'environnement, et ce que le framework a fait en réponse.", "Which plugin owns which tool, and which capability that tool provides.": "Quel plugin possède quel outil, et quelle capacité cet outil fournit.", "Who/what is in the conversation, and the concerns still open.": "Qui/quoi est dans la conversation, et les préoccupations encore ouvertes.", "Why": "Pourquoi", "Why not admitted": "Motif de non-admission", "Why this page is empty": "Pourquoi cette page est vide", "World-model driver": "Pilote du modèle du monde", "Writable": "Inscriptible", "aborted": "Abandonné", "accruing": "En accumulation", "active": "Actif", "appeared": "Apparu", "armed": "Armé", "assess_compatibility": "Évaluer la compatibilité", "built_in": "Intégré", "capability_expand": "Étendre les capacités", "committed": "Conclu", "conformance": "Conformité", "declared_fitness": "Aptitude déclarée", "disable": "Désactiver", "disposed": "Libéré", "effect_observed": "Effet observé", "environment_probe": "Sonde d'environnement", "execution_failed": "Échec d'exécution", "expected_effect_absent": "Effet attendu absent", "failed": "Échoué", "frozen": "Gelé", "gone": "Disparu", "idle": "Au repos", "install": "Installer", "loading": "Chargement", "manual": "Manuel", "moved": "Déplacé", "new_unproven": "Nouveau, non éprouvé", "no": "Non", "no_evidence": "Aucune preuve", "no_expected_effect_declared": "Aucun effet attendu déclaré", "no_outcome_observed": "Aucun résultat observé", "none": "Aucun", "not_admitted": "Non admis", "not_applicable": "Sans objet", "observe_only": "Observer seulement", "observed_effect": "Effet observé", "open": "Ouvert", "pending": "En attente", "reload": "Recharger", "remove": "Supprimer", "reopened": "Réouvert", "resolved": "Résolu", "rollback": "Annuler", "runtime": "Exécution", "self_acquired": "Auto-acquis", "still_open": "Toujours ouvert", "tool_reported_no_effect": "L'outil n'a signalé aucun effet", "trusted": "De confiance", "unknown": "Inconnu", "unknown_tool": "Outil inconnu", "unloading": "Déchargement", "unscheduled": "Non planifié", "unverifiable": "Invérifiable", "unverified": "Non vérifié", "waiting": "En attente", "watching": "En surveillance", "wired": "Câblé", "world_model": "Modèle du monde", "yes": "Oui", "Causal trace": "Trace causale", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "Preuves en lecture seule reliant l’environnement à la gouvernance pour un instantané d’évolution du framework.", "Evidence boundary": "Limite des preuves", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "Une trace causale montre les faits enregistrés ; elle n’infère ni approbation manquante ni effet observé.", "Episodes": "Épisodes", "Declared-fitness closures": "Clôtures par aptitude déclarée", "Counterfactual / mutation matrix": "Matrice contrefactuelle / mutations", "Each row preserves the driver, decision, registry delta, and verification tier.": "Chaque ligne conserve le déclencheur, la décision, le delta du registre et le niveau de vérification.", "Trigger": "Déclencheur", "Evidence tier": "Niveau de preuve", "Episode timeline": "Chronologie des épisodes", "Rebuilt from existing decision and observation records.": "Reconstruite à partir des enregistrements existants de décision et d’observation.", "Durable trace feed": "Flux de traces durables", "Rejected and no-op decisions remain visible when their trace sink is installed.": "Les décisions rejetées et sans action restent visibles lorsque leur récepteur de traces est installé.", "Lifecycle": "Cycle de vie", "Pipeline evidence over time": "Évolution des preuves du convéoyeur", "One point per recorded change in framework state, oldest first.": "Un point par changement enregistré de l’état du framework, du plus ancien au plus récent.", "Samples": "Échantillons", "Net change": "Variation nette"},
+    es: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **Aún no se ha registrado ningún veredicto de efecto**, por lo que no hay señal de recompensa que medir. Las tasas anteriores están en blanco a propósito, no en cero. Un efecto solo puede verificarse si el requisito declaró uno, y hoy solo los requisitos redactados por el modelo del mundo lo llevan.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **Regresión: una brecha cerrada ha vuelto a aparecer.** Una evolución que parecía exitosa no se sostuvo. Es el único hallazgo de este panel que exige atención inmediata.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **Solo instantánea.** Todavía no hay historia causal que reconstruir, por lo que la cronología está ausente, no vacía. El motivo lo indica la fila `Decisiones de política` bajo la cobertura del pipeline; la instantánea y la tabla de cobertura no se ven afectadas.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **Algunos plugins están congelados por un defecto interno.** Un plugin congelado sigue informando `DRAFT`, y la dimensión de confianza solo *puntúa*, por lo que permanece seleccionable a menos que también se desregistre — consulte la columna `Seleccionable`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **Nivel de verificación: L2 (aptitud declarada).** Una observación retirada significa que un candidato *declaró* que proporciona la capacidad, no que se observara funcionando. La verificación de efecto (L3) no está conectada, así que ningún cierre de este panel debe leerse como probado.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> Debe completarse un ciclo de observación antes de que haya algo que mostrar. Si persiste, compruebe que el planificador está activo y que la vigilancia `framework-evolution` está armada y no silenciada.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> Un episodio se escribe cuando una observación del entorno conduce a una decisión de capacidad. No se ha registrado ninguno: o el sistema está tranquilo o el pipeline se detiene antes — la pestaña **Pipeline** nombra el segmento donde se detiene y qué lo desbloquearía.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> Nada los recupera automáticamente. Cada uno ocupa un nombre de herramienta y aparece en la lista de capacidades sin ser seleccionable: el registro crece en una dirección que ningún requisito puede usar.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> Estas propuestas no entraron en ningún pipeline, por lo que no aparecen en ningún registro de decisión ni observación. Admitirlas es una elección de configuración.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "Una relación inferior a 1,0 significa que el bucle de muestreo no mantiene su cadencia declarada.", "Abstained": "Abstenido", "Acquisition authority": "Autoridad de adquisición", "Acquisition lifecycle": "Ciclo de vida de adquisición", "Action": "Acción", "After": "Después", "An unverified declaration has its writable channels demoted to read-only.": "Una declaración no verificada degrada sus canales escribibles a solo lectura.", "Approval": "Aprobación", "Autonomous governance": "Gobernanza autónoma", "Autonomy": "Autonomía", "Before": "Antes", "CANDIDATE": "Candidato", "Calibrated at": "Calibrado el", "Calibration health": "Estado de calibración", "Calls": "Llamadas", "Calls (decisions)": "Recomendaciones (decisiones)", "Candlestick": "Velas", "Capability": "Capacidad", "Capability adaptation": "Adaptación de capacidades", "Capability observations": "Observaciones de capacidad", "Capability ownership": "Propiedad de capacidades", "Capability topology": "Topología de capacidades", "Change": "Cambio", "Channel": "Canal", "Channels": "Canales", "Channels that have never been calibrated or whose calibration has expired are shown first.": "Los canales nunca calibrados o con calibración vencida se muestran primero.", "Command": "Comando", "Commanded versus observed, best tracking first": "Comandado frente a observado, mejor seguimiento primero", "Composition": "Composición", "Concerns (open questions)": "Inquietudes (preguntas abiertas)", "Confidence": "Confianza", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "Contado en todos los canales graficados. «cerca» significa dentro del 5 % de un límite declarado.", "Cycles run": "Ciclos ejecutados", "DRAFT": "Borrador", "Days since": "Días desde", "Decision": "Decisión", "Decisions read as calls; action items as the execution checklist.": "Las decisiones se leen como recomendaciones; las acciones como la lista de ejecución.", "Declared Hz": "Hz declarados", "Desk brief": "Informe de mesa", "Device": "Dispositivo", "Dropped samples": "Muestras descartadas", "Each row names one blocked segment and the change that would unblock it.": "Cada fila nombra un segmento bloqueado y el cambio que lo desbloquearía.", "Effect verification (L3)": "Verificación de efecto (L3)", "Effects declared": "Efectos declarados", "Entities as references, and recommended next prompts to advance the work.": "Entidades como referencias y siguientes preguntas recomendadas para avanzar.", "Entities in play and the open risks still to resolve.": "Entidades implicadas y riesgos abiertos por resolver.", "Envelope, rate, staleness and quality observations · newest first": "Observaciones de envolvente, tasa, obsolescencia y calidad · las más recientes primero", "Environment": "Entorno", "Environment to framework": "Del entorno al framework", "Environment, selected plugin tools, and orchestration order.": "Entorno, herramientas de plugin seleccionadas y orden de orquestación.", "Error rate": "Tasa de error", "Events paced out": "Eventos limitados", "Ever used": "Alguna vez usado", "Evidence": "Evidencia", "Evidence admission": "Admisión de evidencia", "Evolution": "Evolución", "Evolution timeline": "Cronología de la evolución", "Executable": "Ejecutable", "Execution checklist": "Lista de ejecución", "Extracted from this session's tool/file output (not model-generated).": "Extraído de la salida de herramientas/archivos de esta sesión (no generado por el modelo).", "Failures": "Fallos", "Fiber": "Fibra", "Fiber state changes since the previous cycle, including load retries.": "Cambios de estado de fiber desde el ciclo anterior, incluidos los reintentos de carga.", "Finance lens": "Vista financiera", "Follow-ups": "Seguimientos", "Framework change": "Cambio del framework", "Framework changes as they happened, from runtime probes.": "Cambios del framework en tiempo real, desde sondas de ejecución.", "Framework evolution": "Evolución del framework", "Framework size and how much of the evolution pipeline shows runtime evidence.": "Tamaño del framework y qué parte del pipeline de evolución muestra evidencia en ejecución.", "From": "Desde", "Frozen plugins": "Plugins congelados", "Gap closure": "Cierre de la brecha", "Halt": "Parada", "How closures are verified": "Cómo se verifican los cierres", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "Cuánto de la señal de efecto es utilizable como retroalimentación. Esto decide si vale la pena construir una política de aprendizaje.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "Cuánto del framework hizo crecer por sí mismo y cuánto del pipeline muestra evidencia de ejecución.", "How often each window sat inside, near, or outside its declared limits": "Con qué frecuencia cada ventana estuvo dentro, cerca o fuera de sus límites declarados", "Inquiry brief": "Informe de indagación", "Insights carded as evidence, capped for fast review.": "Hallazgos presentados como evidencia, limitados para revisión rápida.", "Instruments & counterparties": "Instrumentos y contrapartes", "Kept": "Conservado", "Latest capability decision": "Última decisión de capacidad", "Lifecycle records": "Registros de ciclo de vida", "Lifecycle timeline": "Cronología del ciclo de vida", "Lifecycle transitions": "Transiciones de ciclo de vida", "Line of inquiry": "Línea de indagación", "Live activity": "Actividad en vivo", "Location": "Ubicación", "Loop phase": "Fase del bucle", "Mean of each downsample window. Declared limits are listed per channel below.": "Media de cada ventana de submuestreo. Los límites declarados se listan por canal abajo.", "Model's reasoning": "Razonamiento del modelo", "Mutation": "Mutación", "Narrative": "Narrativa", "Narrative pulse": "Pulso narrativo", "Needs attention": "Requiere atención", "Next recal due": "Próxima recalibración", "Next step": "Siguiente paso", "No causal history yet": "Aún no hay historia causal", "Normalized error": "Error normalizado", "Normalized error is the residual as a share of the channel's declared span.": "El error normalizado es el residuo como fracción del rango declarado del canal.", "Not yet observed": "Aún no observado", "Nothing has driven a framework change, so there is no episode to narrate.": "Nada ha impulsado todavía un cambio del framework, por lo que no hay ningún episodio que narrar.", "OHLC extracted from captured session market data.": "OHLC extraído de los datos de mercado capturados en la sesión.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "Cola de observaciones, estado de propuestas, decisiones de política y resultados del ciclo de vida.", "Observations": "Observaciones", "Observed Hz": "Hz observados", "Observed rate against declared rate": "Tasa observada frente a la tasa declarada", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "Un único espacio de nombres global, arbitrado por orden de llegada. El aspirante queda registrado, nunca se descarta en silencio.", "Open": "Abierto", "Open risks": "Riesgos abiertos", "Open/high/low/close from captured tool output.": "Apertura/máximo/mínimo/cierre desde la salida de herramientas capturada.", "Origin": "Origen", "Outcome": "Resultado", "PRODUCTION": "Producción", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "Por episodio: el desencadenante, la decisión, el cambio y si la brecha se cerró.", "Per-channel calibration state, freshness, and residual correction": "Estado de calibración, vigencia y corrección residual por canal", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "Evidencia en ejecución por segmento. Que un módulo exista no prueba que algo lo invoque.", "Pipeline": "Pipeline", "Pipeline evidence": "Evidencia del pipeline", "Pipeline reachability": "Alcanzabilidad del pipeline", "Plan": "Plan", "Plan steps": "Pasos del plan", "Plugin": "Plugin", "Plugin roster and trust": "Registro de plugins y confianza", "Plugins": "Plugins", "Plugins by origin": "Plugins por origen", "Plugins by trust class": "Plugins por clase de confianza", "Policy": "Política", "Policy decisions": "Decisiones de política", "Positions & actions": "Posiciones y acciones", "Posture": "Postura", "Price action": "Acción del precio", "Proposal": "Propuesta", "Proposal status": "Estado de la propuesta", "Proposed, not admitted": "Propuesto, no admitido", "Pulse": "Pulso", "Quarantine feed": "Entrada de cuarentena", "Ratio": "Relación", "Read live from the registry and trust ledger every cycle.": "Leído en vivo del registro y del libro de confianza en cada ciclo.", "Recent episodes": "Episodios recientes", "Reclaim candidates": "Candidatos a recuperación", "Reclaimable": "Recuperable", "References & follow-ups": "Referencias y seguimientos", "References (entities)": "Referencias (entidades)", "Registry": "Registro", "Registry delta": "Delta del registro", "Registry version": "Versión del registro", "Regressions": "Regresiones", "Rejected": "Rechazado", "Representative observations, capped for quick scanning.": "Observaciones representativas, limitadas para lectura rápida.", "Requirements": "Requisitos", "Research lens": "Vista de investigación", "Residual": "Residuo", "Reward signal bandwidth": "Ancho de banda de la señal de recompensa", "Runtime evidence": "Evidencia en ejecución", "Sampled history per channel, newest on the right": "Historial muestreado por canal, el más reciente a la derecha", "Segment": "Segmento", "Segments by status": "Segmentos por estado", "Selectable": "Seleccionable", "Selection delta": "Delta de selección", "Self-acquired": "Autoadquirido", "Self-acquired plugins that are registered but unselectable or never once used.": "Plugins autoadquiridos que están registrados pero no son seleccionables, o nunca se han usado.", "Sentiment lens": "Vista de sentimiento", "Series": "Serie", "Session analysis": "Análisis de sesión", "Signal strength": "Fuerza de la señal", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "Señales de que algo creció mal o fue retenido. Se muestran independientemente de la pestaña abierta.", "Skipped slots": "Ranuras omitidas", "State": "Estado", "Storyline and signal strength before drilling into positions and actions.": "Narrativa y fuerza de la señal antes de entrar en posiciones y acciones.", "Streaming": "Transmisión", "Suggested next steps": "Próximos pasos sugeridos", "The line of investigation and where the open questions concentrate.": "La línea de investigación y dónde se concentran las preguntas abiertas.", "The narrative arc and how strongly themes are trending.": "El arco narrativo y con qué fuerza se mueven los temas.", "The world model asked for these capabilities and nothing took them up.": "El modelo del mundo pidió estas capacidades y nada las asumió.", "Theme intensity": "Intensidad temática", "Themes": "Temas", "This board reports how the framework changes itself. Nothing has been recorded yet.": "Este panel informa de cómo el framework se modifica a sí mismo. Todavía no se ha registrado nada.", "To": "Hasta", "Tool": "Herramienta", "Tool-name conflicts": "Conflictos de nombres de herramientas", "Tools": "Herramientas", "Transport": "Transporte", "Transport, provenance and channel counts": "Transporte, procedencia y número de canales", "Trust": "Confianza", "Trust accrual": "Acumulación de confianza", "Trust class": "Clase de confianza", "Unselectable reclamation": "Recuperación no seleccionable", "Usable": "Utilizable", "VERIFIED": "Verificado", "Verdicts": "Veredictos", "Verdicts by reason": "Veredictos por motivo", "Verified": "Verificado", "Verified by": "Verificado por", "Voices & concerns": "Voces e inquietudes", "Watchlist": "Lista de seguimiento", "What changed in the environment, and what the framework did about it.": "Qué cambió en el entorno y qué hizo el framework al respecto.", "Which plugin owns which tool, and which capability that tool provides.": "Qué plugin posee qué herramienta y qué capacidad proporciona esa herramienta.", "Who/what is in the conversation, and the concerns still open.": "Quién/qué está en la conversación y las inquietudes aún abiertas.", "Why": "Por qué", "Why not admitted": "Motivo de no admisión", "Why this page is empty": "Por qué esta página está vacía", "World-model driver": "Controlador del modelo del mundo", "Writable": "Escribible", "aborted": "Abortado", "accruing": "Acumulando", "active": "Activo", "appeared": "Apareció", "armed": "Armado", "assess_compatibility": "Evaluar compatibilidad", "built_in": "Integrado", "capability_expand": "Ampliar capacidad", "committed": "Concluido", "conformance": "Conformidad", "declared_fitness": "Aptitud declarada", "disable": "Desactivar", "disposed": "Liberado", "effect_observed": "Efecto observado", "environment_probe": "Sonda de entorno", "execution_failed": "Ejecución fallida", "expected_effect_absent": "Efecto esperado ausente", "failed": "Fallido", "frozen": "Congelado", "gone": "Desapareció", "idle": "Inactivo", "install": "Instalar", "loading": "Cargando", "manual": "Manual", "moved": "Se movió", "new_unproven": "Nuevo, no probado", "no": "No", "no_evidence": "Sin evidencia", "no_expected_effect_declared": "Sin efecto esperado declarado", "no_outcome_observed": "Sin resultado observado", "none": "Ninguno", "not_admitted": "No admitido", "not_applicable": "No aplicable", "observe_only": "Solo observar", "observed_effect": "Efecto observado", "open": "Abierto", "pending": "Pendiente", "reload": "Recargar", "remove": "Eliminar", "reopened": "Reabierto", "resolved": "Resuelto", "rollback": "Revertir", "runtime": "Tiempo de ejecución", "self_acquired": "Autoadquirido", "still_open": "Aún abierto", "tool_reported_no_effect": "La herramienta no informó efecto", "trusted": "De confianza", "unknown": "Desconocido", "unknown_tool": "Herramienta desconocida", "unloading": "Descargando", "unscheduled": "No planificado", "unverifiable": "No verificable", "unverified": "No verificado", "waiting": "En espera", "watching": "Vigilando", "wired": "Conectado", "world_model": "Modelo del mundo", "yes": "Sí", "Causal trace": "Traza causal", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "Evidencia de solo lectura del entorno a la gobernanza para una instantánea de evolución del framework.", "Evidence boundary": "Límite de evidencia", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "Una traza causal muestra hechos registrados; no infiere aprobación ausente ni efecto observado.", "Episodes": "Episodios", "Declared-fitness closures": "Cierres por aptitud declarada", "Counterfactual / mutation matrix": "Matriz contrafactual / de mutaciones", "Each row preserves the driver, decision, registry delta, and verification tier.": "Cada fila conserva el desencadenante, la decisión, el delta del registro y el nivel de verificación.", "Trigger": "Desencadenante", "Evidence tier": "Nivel de evidencia", "Episode timeline": "Cronología de episodios", "Rebuilt from existing decision and observation records.": "Reconstruida a partir de registros existentes de decisión y observación.", "Durable trace feed": "Flujo de trazas durables", "Rejected and no-op decisions remain visible when their trace sink is installed.": "Las decisiones rechazadas y sin acción permanecen visibles cuando se instala su receptor de trazas.", "Lifecycle": "Ciclo de vida", "Pipeline evidence over time": "Evidencia del canal a lo largo del tiempo", "One point per recorded change in framework state, oldest first.": "Un punto por cada cambio registrado del estado del framework, del más antiguo al más reciente.", "Samples": "Muestras", "Net change": "Cambio neto"},
+    ar: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **لم يُسجَّل أي حكم على الأثر بعد**، لذا لا توجد إشارة مكافأة لقياسها. النسب أعلاه فارغة عن قصد وليست صفرًا. لا يمكن التحقق من الأثر إلا إذا أعلنه المطلب، واليوم لا تحمل الأثر المتوقع سوى المطالب التي كتبها نموذج العالم.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **انحدار: فجوة أُغلقت عادت للظهور.** تطوّر بدا ناجحًا لم يصمد. هذا هو الاكتشاف الوحيد في هذه اللوحة الذي يستدعي انتباهًا فوريًا.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **لقطة فقط.** لا يوجد بعد تاريخ سببي لإعادة بنائه، لذا فالخط الزمني غائب وليس فارغًا. السبب مبيَّن في صف `قرارات السياسة` تحت تغطية المسار؛ اللقطة الحيّة وجدول التغطية غير متأثرين.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **بعض الإضافات مُجمَّدة بسبب خلل داخلي.** الإضافة المُجمَّدة لا تزال تُبلِّغ `DRAFT`، وبُعد الثقة يقوم بالتقييم فقط، لذا تبقى قابلة للاختيار إلا إذا أُلغي تسجيلها أيضًا — راجع عمود `قابل للاختيار`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **مستوى التحقق: L2 (الملاءمة المُعلنة).** سحب الرصد يعني أن مرشّحًا *أعلن* أنه يوفّر القدرة، لا أن القدرة رُصدت وهي تعمل. التحقق من الأثر (L3) غير موصول، لذا لا ينبغي قراءة أي إغلاق في هذه اللوحة كأمر مُثبَت.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> يجب أن تكتمل دورة مراقبة واحدة قبل ظهور أي محتوى. إذا استمر ذلك، تحقّق من تمكين المُجدول وأن مراقبة `framework-evolution` مُسلّحة وغير مكتومة.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> تُكتب الحلقة عندما يؤدي رصد للبيئة إلى قرار بشأن قدرة. لم يُسجَّل أي منها، وهذا يعني إمّا نظامًا هادئًا أو مسارًا يتوقف قبل ذلك — تبويب **المسار** يحدّد الجزء الذي يتوقف عنده وما الذي يزيل التعطيل.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> لا شيء يستعيدها تلقائيًا. كل واحدة تحتجز اسم أداة وتظهر في قائمة القدرات دون أن تكون قابلة للاختيار، فينمو السجل في اتجاه لا يمكن لأي مطلب استخدامه.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> لم تدخل هذه المقترحات أي مسار، لذا لا تظهر في أي سجل قرار أو رصد. قبولها خيار في الإعدادات.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "نسبة أقل من 1.0 تعني أن حلقة أخذ العينات لا تحافظ على وتيرتها المعلنة.", "Abstained": "امتناع", "Acquisition authority": "سلطة الاكتساب", "Acquisition lifecycle": "دورة حياة الاكتساب", "Action": "الإجراء", "After": "بعد", "An unverified declaration has its writable channels demoted to read-only.": "الإعلان غير المُتحقَّق منه تُخفَّض قنواته القابلة للكتابة إلى القراءة فقط.", "Approval": "الموافقة", "Autonomous governance": "الحكم الذاتي", "Autonomy": "الاستقلالية", "Before": "قبل", "CANDIDATE": "مرشّح", "Calibrated at": "تاريخ المعايرة", "Calibration health": "سلامة المعايرة", "Calls": "الاستدعاءات", "Calls (decisions)": "التوصيات (القرارات)", "Candlestick": "الشموع", "Capability": "القدرة", "Capability adaptation": "تكييف القدرات", "Capability observations": "رصد القدرات", "Capability ownership": "ملكية القدرات", "Capability topology": "طوبولوجيا القدرات", "Change": "التغيير", "Channel": "القناة", "Channels": "القنوات", "Channels that have never been calibrated or whose calibration has expired are shown first.": "تظهر أولاً القنوات التي لم تُعاير قط أو التي انتهت صلاحية معايرتها.", "Command": "الأمر", "Commanded versus observed, best tracking first": "المأمور مقابل المرصود، الأفضل تتبعاً أولاً", "Composition": "التركيب", "Concerns (open questions)": "المخاوف (أسئلة مفتوحة)", "Confidence": "الثقة", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "محسوب على كل قناة مرسومة. \"قريب\" تعني داخل 5% من حد معلن.", "Cycles run": "الدورات المنفَّذة", "DRAFT": "مسوّدة", "Days since": "الأيام المنقضية", "Decision": "القرار", "Decisions read as calls; action items as the execution checklist.": "القرارات تُقرأ كتوصيات؛ والإجراءات كقائمة تنفيذ.", "Declared Hz": "الهرتز المعلن", "Desk brief": "موجز المكتب", "Device": "الجهاز", "Dropped samples": "العينات المفقودة", "Each row names one blocked segment and the change that would unblock it.": "كل صف يحدّد جزءًا معطَّلًا والتغيير الذي يزيل التعطيل.", "Effect verification (L3)": "التحقق من الأثر (L3)", "Effects declared": "الآثار المُعلنة", "Entities as references, and recommended next prompts to advance the work.": "الكيانات كمراجع، والمطالبات التالية الموصى بها لدفع العمل.", "Entities in play and the open risks still to resolve.": "الكيانات المعنية والمخاطر المفتوحة التي لم تُحل.", "Envelope, rate, staleness and quality observations · newest first": "رصدات المغلف والمعدل والتقادم والجودة · الأحدث أولاً", "Environment": "البيئة", "Environment to framework": "من البيئة إلى الإطار", "Environment, selected plugin tools, and orchestration order.": "البيئة والأدوات المختارة وترتيب التنسيق.", "Error rate": "معدل الأخطاء", "Events paced out": "الأحداث المُقيَّدة", "Ever used": "استُخدم سابقًا", "Evidence": "الدليل", "Evidence admission": "قبول الأدلة", "Evolution": "التطور", "Evolution timeline": "الخط الزمني للتطور", "Executable": "قابل للتنفيذ", "Execution checklist": "قائمة التنفيذ", "Extracted from this session's tool/file output (not model-generated).": "مستخرج من مخرجات الأدوات/الملفات في هذه الجلسة (ليس من إنشاء النموذج).", "Failures": "الأعطال", "Fiber": "الخيط", "Fiber state changes since the previous cycle, including load retries.": "تغييرات حالة الـ fiber منذ الدورة السابقة، بما في ذلك محاولات التحميل.", "Finance lens": "منظور مالي", "Follow-ups": "المتابعات", "Framework change": "تغيير الإطار", "Framework changes as they happened, from runtime probes.": "تغييرات الإطار لحظة حدوثها، من مجسّات وقت التشغيل.", "Framework evolution": "تطور الإطار", "Framework size and how much of the evolution pipeline shows runtime evidence.": "حجم الإطار ومقدار ما يُظهره مسار التطور من أدلة وقت التشغيل.", "From": "من", "Frozen plugins": "الإضافات المُجمَّدة", "Gap closure": "إغلاق الفجوة", "Halt": "إيقاف", "How closures are verified": "كيف يُتحقَّق من الإغلاقات", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "ما مقدار إشارة الأثر القابل للاستخدام كتغذية راجعة. هذا يحدّد ما إذا كان بناء سياسة تعلّم يستحق العناء.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "ما مقدار ما نمّاه الإطار بنفسه، وما مقدار المسار الذي يُظهر أدلة وقت التشغيل.", "How often each window sat inside, near, or outside its declared limits": "عدد المرات التي كانت فيها كل نافذة داخل حدودها المعلنة أو قريبة منها أو خارجها", "Inquiry brief": "موجز الاستقصاء", "Insights carded as evidence, capped for fast review.": "الرؤى معروضة كأدلة، ومحدودة العدد للمراجعة السريعة.", "Instruments & counterparties": "الأدوات والأطراف المقابلة", "Kept": "المحتفظ به", "Latest capability decision": "أحدث قرار للقدرات", "Lifecycle records": "سجلات دورة الحياة", "Lifecycle timeline": "الخط الزمني لدورة الحياة", "Lifecycle transitions": "انتقالات دورة الحياة", "Line of inquiry": "خط الاستقصاء", "Live activity": "النشاط المباشر", "Location": "الموقع", "Loop phase": "مرحلة الحلقة", "Mean of each downsample window. Declared limits are listed per channel below.": "متوسط كل نافذة تخفيض للعينات. الحدود المعلنة مدرجة لكل قناة أدناه.", "Model's reasoning": "استدلال النموذج", "Mutation": "التغيير", "Narrative": "السرد", "Narrative pulse": "نبض السرد", "Needs attention": "يستدعي الانتباه", "Next recal due": "موعد إعادة المعايرة", "Next step": "الخطوة التالية", "No causal history yet": "لا يوجد تاريخ سببي بعد", "Normalized error": "الخطأ المعياري", "Normalized error is the residual as a share of the channel's declared span.": "الخطأ المعياري هو المتبقي كنسبة من المدى المعلن للقناة.", "Not yet observed": "لم يُرصد بعد", "Nothing has driven a framework change, so there is no episode to narrate.": "لم يدفع أي شيء بعد إلى تغيير في الإطار، لذا لا توجد حلقة لسردها.", "OHLC extracted from captured session market data.": "OHLC مستخرج من بيانات السوق المسجلة في الجلسة.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "قائمة الرصد وحالة المقترحات وقرارات السياسة ونتائج دورة الحياة.", "Observations": "الرصدات", "Observed Hz": "الهرتز المرصود", "Observed rate against declared rate": "المعدل المرصود مقابل المعدل المعلن", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "مساحة أسماء عالمية واحدة، تُحكَّم بأسبقية التسجيل. يُسجَّل المتنافس ولا يُهمَل بصمت.", "Open": "مفتوح", "Open risks": "المخاطر المفتوحة", "Open/high/low/close from captured tool output.": "الافتتاح/الأعلى/الأدنى/الإغلاق من مخرجات الأدوات المسجلة.", "Origin": "المصدر", "Outcome": "النتيجة", "PRODUCTION": "إنتاج", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "لكل حلقة: المُحفِّز والقرار والتغيير وما إذا أُغلقت الفجوة.", "Per-channel calibration state, freshness, and residual correction": "حالة المعايرة وحداثتها وتصحيح المتبقي لكل قناة", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "أدلة وقت التشغيل لكل مقطع. وجود وحدة لا يعني أن شيئًا يستدعيها.", "Pipeline": "المسار", "Pipeline evidence": "أدلة المسار", "Pipeline reachability": "إمكانية الوصول إلى المسار", "Plan": "الخطة", "Plan steps": "خطوات الخطة", "Plugin": "الملحق", "Plugin roster and trust": "قائمة الملحقات والثقة", "Plugins": "الملحقات", "Plugins by origin": "الإضافات حسب المصدر", "Plugins by trust class": "الإضافات حسب فئة الثقة", "Policy": "السياسة", "Policy decisions": "قرارات السياسة", "Positions & actions": "المراكز والإجراءات", "Posture": "الوضع", "Price action": "حركة السعر", "Proposal": "المقترح", "Proposal status": "حالة المقترح", "Proposed, not admitted": "مُقترح وغير مقبول", "Pulse": "النبض", "Quarantine feed": "تغذية الحجر", "Ratio": "النسبة", "Read live from the registry and trust ledger every cycle.": "يُقرأ مباشرة من السجل ودفتر الثقة في كل دورة.", "Recent episodes": "الحلقات الأخيرة", "Reclaim candidates": "مرشّحو الاسترجاع", "Reclaimable": "قابل للاسترجاع", "References & follow-ups": "المراجع والمتابعات", "References (entities)": "المراجع (الكيانات)", "Registry": "السجل", "Registry delta": "فرق السجل", "Registry version": "إصدار السجل", "Regressions": "الانحدارات", "Rejected": "المرفوض", "Representative observations, capped for quick scanning.": "رصدات تمثيلية، محدودة العدد للقراءة السريعة.", "Requirements": "المتطلبات", "Research lens": "منظور بحثي", "Residual": "المتبقي", "Reward signal bandwidth": "نطاق إشارة المكافأة", "Runtime evidence": "دليل وقت التشغيل", "Sampled history per channel, newest on the right": "سجل العينات لكل قناة، الأحدث على اليمين", "Segment": "المقطع", "Segments by status": "الأجزاء حسب الحالة", "Selectable": "قابل للاختيار", "Selection delta": "فرق الاختيار", "Self-acquired": "مُكتسَب ذاتيًا", "Self-acquired plugins that are registered but unselectable or never once used.": "إضافات مُكتسَبة ذاتيًا مُسجَّلة لكنها غير قابلة للاختيار أو لم تُستخدم قطّ.", "Sentiment lens": "منظور المشاعر", "Series": "السلسلة", "Session analysis": "تحليل الجلسة", "Signal strength": "قوة الإشارة", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "إشارات على أن شيئًا نما بشكل خاطئ أو تم حجبه. تظهر أيًا كان التبويب المفتوح.", "Skipped slots": "الفتحات المتخطاة", "State": "الحالة", "Storyline and signal strength before drilling into positions and actions.": "السرد وقوة الإشارة قبل التوسع في المراكز والإجراءات.", "Streaming": "بث", "Suggested next steps": "الخطوات التالية المقترحة", "The line of investigation and where the open questions concentrate.": "خط البحث وأين تتركز الأسئلة المفتوحة.", "The narrative arc and how strongly themes are trending.": "قوس السرد ومدى قوة اتجاه الموضوعات.", "The world model asked for these capabilities and nothing took them up.": "طلب نموذج العالم هذه القدرات ولم يتبنّها شيء.", "Theme intensity": "شدة الموضوعات", "Themes": "الموضوعات", "This board reports how the framework changes itself. Nothing has been recorded yet.": "تُبلِّغ هذه اللوحة عن كيفية تغيير الإطار لنفسه. لم يُسجَّل أي شيء بعد.", "To": "إلى", "Tool": "الأداة", "Tool-name conflicts": "تعارضات أسماء الأدوات", "Tools": "الأدوات", "Transport": "النقل", "Transport, provenance and channel counts": "النقل والمنشأ وعدد القنوات", "Trust": "الثقة", "Trust accrual": "تراكم الثقة", "Trust class": "فئة الثقة", "Unselectable reclamation": "استرجاع غير القابل للاختيار", "Usable": "قابل للاستخدام", "VERIFIED": "مُتحقَّق", "Verdicts": "الأحكام", "Verdicts by reason": "الأحكام حسب السبب", "Verified": "مُتحقَّق", "Verified by": "تم التحقق بواسطة", "Voices & concerns": "الأصوات والمخاوف", "Watchlist": "قائمة المتابعة", "What changed in the environment, and what the framework did about it.": "ما تغيّر في البيئة، وما فعله الإطار حيال ذلك.", "Which plugin owns which tool, and which capability that tool provides.": "أي ملحق يملك أي أداة، وأي قدرة توفرها تلك الأداة.", "Who/what is in the conversation, and the concerns still open.": "من/ما هو في المحادثة، والمخاوف التي لا تزال مفتوحة.", "Why": "السبب", "Why not admitted": "سبب عدم القبول", "Why this page is empty": "لماذا هذه الصفحة فارغة", "World-model driver": "مُشغِّل نموذج العالم", "Writable": "قابل للكتابة", "aborted": "مُلغى", "accruing": "قيد التراكم", "active": "نشط", "appeared": "ظهر", "armed": "مُسلّح", "assess_compatibility": "تقييم التوافق", "built_in": "مدمج", "capability_expand": "توسيع القدرة", "committed": "مُنجَز", "conformance": "المطابقة", "declared_fitness": "الملاءمة المُعلنة", "disable": "تعطيل", "disposed": "تم التخلص منه", "effect_observed": "تم رصد الأثر", "environment_probe": "مِجَس البيئة", "execution_failed": "فشل التنفيذ", "expected_effect_absent": "الأثر المتوقع غائب", "failed": "فشل", "frozen": "مُجمَّد", "gone": "اختفى", "idle": "خامل", "install": "تثبيت", "loading": "قيد التحميل", "manual": "يدوي", "moved": "انتقل", "new_unproven": "جديد وغير مُثبَت", "no": "لا", "no_evidence": "لا يوجد دليل", "no_expected_effect_declared": "لم يُعلَن أثر متوقع", "no_outcome_observed": "لم يُرصد أي ناتج", "none": "لا شيء", "not_admitted": "غير مقبول", "not_applicable": "غير منطبق", "observe_only": "المراقبة فقط", "observed_effect": "الأثر المرصود", "open": "مفتوح", "pending": "معلّق", "reload": "إعادة تحميل", "remove": "إزالة", "reopened": "أُعيد فتحه", "resolved": "تم الحل", "rollback": "تراجع", "runtime": "وقت التشغيل", "self_acquired": "مُكتسَب ذاتيًا", "still_open": "لا يزال مفتوحًا", "tool_reported_no_effect": "الأداة لم تُبلِّغ عن أثر", "trusted": "موثوق", "unknown": "غير معروف", "unknown_tool": "أداة غير معروفة", "unloading": "قيد الإلغاء", "unscheduled": "غير مُجدول", "unverifiable": "غير قابل للتحقق", "unverified": "غير مُتحقَّق", "waiting": "في الانتظار", "watching": "يراقب", "wired": "موصول", "world_model": "نموذج العالم", "yes": "نعم", "Causal trace": "الأثر السببي", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "دليل للقراءة فقط يربط البيئة بالحوكمة للّقطة واحدة من تطور الإطار.", "Evidence boundary": "حدود الدليل", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "يعرض الأثر السببي الحقائق المسجلة ولا يستنتج موافقة مفقودة أو أثرًا مرصودًا.", "Episodes": "الحلقات", "Declared-fitness closures": "إغلاقات الملاءمة المعلنة", "Counterfactual / mutation matrix": "مصفوفة الافتراضات المضادة / التغييرات", "Each row preserves the driver, decision, registry delta, and verification tier.": "يحفظ كل صف المحفز والقرار وفرق السجل ومستوى التحقق.", "Trigger": "المحفز", "Evidence tier": "طبقة الدليل", "Episode timeline": "الخط الزمني للحلقات", "Rebuilt from existing decision and observation records.": "أُعيد بناؤه من سجلات القرار والرصد الموجودة.", "Durable trace feed": "تدفق آثار دائم", "Rejected and no-op decisions remain visible when their trace sink is installed.": "تبقى القرارات المرفوضة والتي بلا إجراء مرئية عند تثبيت مستقبل آثارها.", "Lifecycle": "دورة الحياة", "Pipeline evidence over time": "أدلة المسار عبر الزمن", "One point per recorded change in framework state, oldest first.": "نقطة واحدة لكل تغيير مسجّل في حالة الإطار، الأقدم أولًا.", "Samples": "العينات", "Net change": "التغير الصافي"},
+    ru: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **Ни одного заключения об эффекте пока не записано**, поэтому измерять нечего. Показатели выше намеренно пусты, а не равны нулю. Эффект можно проверить только если требование его заявило, а сегодня заявленный эффект несут лишь требования, составленные моделью мира.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **Регрессия: закрытый пробел возобновился.** Эволюция, казавшаяся успешной, не удержалась. Это единственный вывод на этой панели, требующий немедленного внимания.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **Только снимок.** Причинной истории для восстановления пока нет, поэтому хронология отсутствует, а не пуста. Причина указана в строке `Решения политики` под покрытием конвейера; снимок и таблица покрытия не затронуты.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **Некоторые плагины заморожены из-за внутреннего дефекта.** Замороженный плагин по-прежнему сообщает `DRAFT`, а измерение доверия только *оценивает*, поэтому он остаётся выбираемым, пока не будет также снят с регистрации — см. столбец `Выбираемо`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **Уровень проверки: L2 (заявленная пригодность).** Снятое наблюдение означает, что кандидат *заявил* о предоставлении возможности, а не что возможность наблюдалась в работе. Проверка эффекта (L3) не подключена, поэтому ни одно закрытие на этой панели не следует считать доказанным.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> Прежде чем появятся данные, должен завершиться хотя бы один цикл наблюдения. Если это сохраняется, проверьте, включён ли планировщик и что наблюдение `framework-evolution` активно и не отключено.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> Эпизод записывается, когда наблюдение окружения приводит к решению о возможности. Ни одного не зафиксировано: либо система спокойна, либо конвейер останавливается раньше — вкладка **Конвейер** называет сегмент остановки и то, что его разблокирует.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> Ничто не утилизирует их автоматически. Каждый занимает имя инструмента и присутствует в списке возможностей, не будучи выбираемым: реестр растёт в направлении, непригодном ни для одного требования.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> Эти предложения не вошли ни в один конвейер, поэтому не отражены ни в одной записи решения или наблюдения. Их приём — вопрос конфигурации.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "Отношение ниже 1,0 означает, что цикл выборки не выдерживает объявленный ритм.", "Abstained": "Воздержалось", "Acquisition authority": "Право на получение", "Acquisition lifecycle": "Жизненный цикл получения", "Action": "Действие", "After": "После", "An unverified declaration has its writable channels demoted to read-only.": "У непроверенного объявления записываемые каналы понижаются до только чтения.", "Approval": "Согласование", "Autonomous governance": "Автономное управление", "Autonomy": "Автономность", "Before": "До", "CANDIDATE": "Кандидат", "Calibrated at": "Калиброван", "Calibration health": "Состояние калибровки", "Calls": "Вызовы", "Calls (decisions)": "Рекомендации (решения)", "Candlestick": "Свечи", "Capability": "Возможность", "Capability adaptation": "Адаптация возможностей", "Capability observations": "Наблюдения возможностей", "Capability ownership": "Владение возможностями", "Capability topology": "Топология возможностей", "Change": "Изменение", "Channel": "Канал", "Channels": "Каналы", "Channels that have never been calibrated or whose calibration has expired are shown first.": "Каналы, которые никогда не калибровались или чья калибровка истекла, показаны первыми.", "Command": "Команда", "Commanded versus observed, best tracking first": "Заданное против наблюдаемого, лучшее отслеживание первым", "Composition": "Состав", "Concerns (open questions)": "Опасения (открытые вопросы)", "Confidence": "Уверенность", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "Подсчитано по всем отображаемым каналам. «У границы» — в пределах 5% от объявленного предела.", "Cycles run": "Выполнено циклов", "DRAFT": "Черновик", "Days since": "Дней с тех пор", "Decision": "Решение", "Decisions read as calls; action items as the execution checklist.": "Решения читаются как рекомендации; действия — как чек-лист исполнения.", "Declared Hz": "Объявл. Гц", "Desk brief": "Сводка деска", "Device": "Устройство", "Dropped samples": "Отброшенные образцы", "Each row names one blocked segment and the change that would unblock it.": "Каждая строка называет заблокированный сегмент и изменение, которое его разблокирует.", "Effect verification (L3)": "Проверка эффекта (L3)", "Effects declared": "Заявлено эффектов", "Entities as references, and recommended next prompts to advance the work.": "Сущности как ссылки и рекомендуемые следующие запросы.", "Entities in play and the open risks still to resolve.": "Задействованные сущности и нерешённые риски.", "Envelope, rate, staleness and quality observations · newest first": "Наблюдения по огибающей, частоте, устареванию и качеству · сначала новые", "Environment": "Окружение", "Environment to framework": "От окружения к фреймворку", "Environment, selected plugin tools, and orchestration order.": "Окружение, выбранные инструменты плагинов и порядок оркестрации.", "Error rate": "Частота ошибок", "Events paced out": "Событий подавлено", "Ever used": "Использовался", "Evidence": "Обоснование", "Evidence admission": "Приём данных", "Evolution": "Эволюция", "Evolution timeline": "Хронология эволюции", "Executable": "Исполнимо", "Execution checklist": "Чек-лист исполнения", "Extracted from this session's tool/file output (not model-generated).": "Извлечено из вывода инструментов/файлов этой сессии (не сгенерировано моделью).", "Failures": "Сбои", "Fiber": "Файбер", "Fiber state changes since the previous cycle, including load retries.": "Изменения состояния fiber с предыдущего цикла, включая повторные загрузки.", "Finance lens": "Финансовый ракурс", "Follow-ups": "Продолжения", "Framework change": "Изменение фреймворка", "Framework changes as they happened, from runtime probes.": "Изменения фреймворка в момент их появления, от рантайм-зондов.", "Framework evolution": "Эволюция фреймворка", "Framework size and how much of the evolution pipeline shows runtime evidence.": "Размер фреймворка и какая часть конвейера эволюции показывает свидетельства времени выполнения.", "From": "Из", "Frozen plugins": "Замороженные плагины", "Gap closure": "Закрытие пробела", "Halt": "Останов", "How closures are verified": "Как проверяются закрытия", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "Какая часть сигнала об эффекте пригодна как обратная связь. Это определяет, стоит ли строить обучающую политику.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "Какую часть фреймворка он вырастил сам и какая часть конвейера показывает данные времени выполнения.", "How often each window sat inside, near, or outside its declared limits": "Как часто каждое окно было внутри, у границы или вне объявленных пределов", "Inquiry brief": "Сводка исследования", "Insights carded as evidence, capped for fast review.": "Инсайты как карточки-обоснования, ограничены для быстрого просмотра.", "Instruments & counterparties": "Инструменты и контрагенты", "Kept": "Оставлен", "Latest capability decision": "Последнее решение о возможностях", "Lifecycle records": "Записи жизненного цикла", "Lifecycle timeline": "Хронология жизненного цикла", "Lifecycle transitions": "Переходы жизненного цикла", "Line of inquiry": "Линия исследования", "Live activity": "Текущая активность", "Location": "Расположение", "Loop phase": "Фаза цикла", "Mean of each downsample window. Declared limits are listed per channel below.": "Среднее по каждому окну прореживания. Объявленные пределы указаны по каналам ниже.", "Model's reasoning": "Обоснование модели", "Mutation": "Изменение", "Narrative": "Сюжет", "Narrative pulse": "Нарративный пульс", "Needs attention": "Требует внимания", "Next recal due": "Следующая рекалибровка", "Next step": "Следующий шаг", "No causal history yet": "Причинной истории пока нет", "Normalized error": "Нормированная ошибка", "Normalized error is the residual as a share of the channel's declared span.": "Нормированная ошибка — остаток как доля объявленного диапазона канала.", "Not yet observed": "Ещё не наблюдалось", "Nothing has driven a framework change, so there is no episode to narrate.": "Ничто пока не вызвало изменения фреймворка, поэтому рассказывать не о чем.", "OHLC extracted from captured session market data.": "OHLC извлечён из рыночных данных, записанных в сессии.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "Очередь наблюдений, состояние предложений, решения политики и итоги жизненного цикла.", "Observations": "Наблюдения", "Observed Hz": "Наблюд. Гц", "Observed rate against declared rate": "Наблюдаемая частота против объявленной", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "Единое глобальное пространство имён, арбитраж по первому пришедшему. Претендент записывается, а не отбрасывается молча.", "Open": "Открыт", "Open risks": "Открытые риски", "Open/high/low/close from captured tool output.": "Открытие/максимум/минимум/закрытие из записанного вывода инструментов.", "Origin": "Источник", "Outcome": "Результат", "PRODUCTION": "Продакшн", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "По эпизодам: триггер, решение, изменение и закрылся ли пробел.", "Per-channel calibration state, freshness, and residual correction": "Состояние калибровки, актуальность и остаточная поправка по каналам", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "Свидетельства времени выполнения по сегментам. Наличие модуля не доказывает, что его кто-то вызывает.", "Pipeline": "Конвейер", "Pipeline evidence": "Свидетельства конвейера", "Pipeline reachability": "Достижимость конвейера", "Plan": "План", "Plan steps": "Шаги плана", "Plugin": "Плагин", "Plugin roster and trust": "Реестр плагинов и доверие", "Plugins": "Плагины", "Plugins by origin": "Плагины по происхождению", "Plugins by trust class": "Плагины по классу доверия", "Policy": "Политика", "Policy decisions": "Решения политики", "Positions & actions": "Позиции и действия", "Posture": "Состояние", "Price action": "Ценовое движение", "Proposal": "Предложение", "Proposal status": "Статус предложения", "Proposed, not admitted": "Предложено, не принято", "Pulse": "Пульс", "Quarantine feed": "Поток карантина", "Ratio": "Отношение", "Read live from the registry and trust ledger every cycle.": "Читается напрямую из реестра и журнала доверия каждый цикл.", "Recent episodes": "Недавние эпизоды", "Reclaim candidates": "Кандидаты на утилизацию", "Reclaimable": "Утилизируемо", "References & follow-ups": "Ссылки и продолжения", "References (entities)": "Ссылки (сущности)", "Registry": "Реестр", "Registry delta": "Изменение реестра", "Registry version": "Версия реестра", "Regressions": "Регрессии", "Rejected": "Отклонён", "Representative observations, capped for quick scanning.": "Показательные наблюдения, ограничены для быстрого просмотра.", "Requirements": "Требования", "Research lens": "Исследовательский ракурс", "Residual": "Остаток", "Reward signal bandwidth": "Пропускная способность сигнала вознаграждения", "Runtime evidence": "Свидетельство времени выполнения", "Sampled history per channel, newest on the right": "История выборок по каналам, самое новое справа", "Segment": "Сегмент", "Segments by status": "Сегменты по статусу", "Selectable": "Выбираемый", "Selection delta": "Изменение выбора", "Self-acquired": "Самостоятельно получено", "Self-acquired plugins that are registered but unselectable or never once used.": "Самостоятельно полученные плагины, которые зарегистрированы, но невыбираемы или ни разу не использовались.", "Sentiment lens": "Ракурс тональности", "Series": "Серия", "Session analysis": "Анализ сессии", "Signal strength": "Сила сигнала", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "Признаки того, что что-то выросло неверно или было задержано. Показываются независимо от открытой вкладки.", "Skipped slots": "Пропущенные слоты", "State": "Состояние", "Storyline and signal strength before drilling into positions and actions.": "Сюжет и сила сигнала до перехода к позициям и действиям.", "Streaming": "Потоковая передача", "Suggested next steps": "Рекомендуемые следующие шаги", "The line of investigation and where the open questions concentrate.": "Линия исследования и где сосредоточены открытые вопросы.", "The narrative arc and how strongly themes are trending.": "Нарративная дуга и насколько сильно растут темы.", "The world model asked for these capabilities and nothing took them up.": "Модель мира запросила эти возможности, и никто их не принял.", "Theme intensity": "Интенсивность тем", "Themes": "Темы", "This board reports how the framework changes itself. Nothing has been recorded yet.": "Эта панель сообщает, как фреймворк изменяет сам себя. Пока ничего не записано.", "To": "В", "Tool": "Инструмент", "Tool-name conflicts": "Конфликты имён инструментов", "Tools": "Инструменты", "Transport": "Транспорт", "Transport, provenance and channel counts": "Транспорт, происхождение и число каналов", "Trust": "Доверие", "Trust accrual": "Накопление доверия", "Trust class": "Класс доверия", "Unselectable reclamation": "Утилизация невыбираемого", "Usable": "Пригодно", "VERIFIED": "Проверено", "Verdicts": "Заключений", "Verdicts by reason": "Заключения по причине", "Verified": "Проверено", "Verified by": "Подтверждено", "Voices & concerns": "Голоса и опасения", "Watchlist": "Список наблюдения", "What changed in the environment, and what the framework did about it.": "Что изменилось в окружении и что фреймворк с этим сделал.", "Which plugin owns which tool, and which capability that tool provides.": "Какой плагин владеет каким инструментом и какую возможность этот инструмент предоставляет.", "Who/what is in the conversation, and the concerns still open.": "Кто/что в разговоре и какие опасения остаются.", "Why": "Почему", "Why not admitted": "Причина отклонения", "Why this page is empty": "Почему эта страница пуста", "World-model driver": "Драйвер модели мира", "Writable": "Записываемый", "aborted": "Прервано", "accruing": "Накапливается", "active": "Активно", "appeared": "Появился", "armed": "Активно", "assess_compatibility": "Оценка совместимости", "built_in": "Встроенный", "capability_expand": "Расширение возможностей", "committed": "Завершено", "conformance": "Соответствие", "declared_fitness": "Заявленная пригодность", "disable": "Отключение", "disposed": "Освобождено", "effect_observed": "Эффект наблюдался", "environment_probe": "Зонд окружения", "execution_failed": "Сбой выполнения", "expected_effect_absent": "Ожидаемый эффект отсутствует", "failed": "Сбой", "frozen": "Заморожено", "gone": "Исчез", "idle": "Простой", "install": "Установка", "loading": "Загрузка", "manual": "Вручную", "moved": "Перешёл", "new_unproven": "Новое, непроверенное", "no": "Нет", "no_evidence": "Нет данных", "no_expected_effect_declared": "Ожидаемый эффект не заявлен", "no_outcome_observed": "Результат не наблюдался", "none": "Нет", "not_admitted": "Не принято", "not_applicable": "Неприменимо", "observe_only": "Только наблюдение", "observed_effect": "Наблюдаемый эффект", "open": "Открыто", "pending": "Ожидает", "reload": "Перезагрузка", "remove": "Удаление", "reopened": "Возобновлено", "resolved": "Закрыто", "rollback": "Откат", "runtime": "Среда выполнения", "self_acquired": "Самостоятельно получено", "still_open": "Всё ещё открыто", "tool_reported_no_effect": "Инструмент не сообщил об эффекте", "trusted": "Доверенное", "unknown": "Неизвестно", "unknown_tool": "Неизвестный инструмент", "unloading": "Выгрузка", "unscheduled": "Не запланировано", "unverifiable": "Не проверяемо", "unverified": "Непроверенное", "waiting": "Ожидание", "watching": "Наблюдает", "wired": "Подключено", "world_model": "Модель мира", "yes": "Да", "Causal trace": "Причинная трасса", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "Доказательства только для чтения от окружения к управлению для одного снимка эволюции фреймворка.", "Evidence boundary": "Граница доказательств", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "Причинная трасса показывает записанные факты и не выводит отсутствующее согласование или наблюдаемый эффект.", "Episodes": "Эпизоды", "Declared-fitness closures": "Закрытия по заявленной пригодности", "Counterfactual / mutation matrix": "Контрфактическая матрица / мутации", "Each row preserves the driver, decision, registry delta, and verification tier.": "Каждая строка сохраняет триггер, решение, изменение реестра и уровень проверки.", "Trigger": "Триггер", "Evidence tier": "Уровень доказательств", "Episode timeline": "Хронология эпизодов", "Rebuilt from existing decision and observation records.": "Восстановлена из существующих записей решений и наблюдений.", "Durable trace feed": "Поток долговечных трасс", "Rejected and no-op decisions remain visible when their trace sink is installed.": "Отклонённые решения и решения без действия остаются видимыми, когда установлен их приёмник трасс.", "Lifecycle": "Жизненный цикл", "Pipeline evidence over time": "Свидетельства конвейера во времени", "One point per recorded change in framework state, oldest first.": "Одна точка на каждое зафиксированное изменение состояния фреймворка, старшие слева.", "Samples": "Выборки", "Net change": "Итоговое изменение"}
   };
-  Object.keys(I18N).concat(Object.keys(I18N_PATCH), Object.keys(I18N_TEMPLATES))
+  // Page-chrome freshness strings. A table of their own because the provenance bar
+  // is not a lens: it renders above every board, so keying it off any one lens's
+  // table would tie a page-wide fact to an unrelated view.
+  const I18N_PROVENANCE = {
+    en: {
+      "Observed": "Observed", "Not yet observed": "Not yet observed",
+      "every {interval}": "every {interval}", "next in {interval}": "next in {interval}",
+      "event-driven": "event-driven", "muted": "muted",
+      "Stale: no cycle completed in over {interval}. Nothing below can be trusted as current.": "Stale: no cycle completed in over {interval}. Nothing below can be trusted as current.",
+      "confirmed unchanged {interval} later": "confirmed unchanged {interval} later",
+      "{count} sec": "{count}s", "{count} min": "{count}m", "{count} hr": "{count}h", "{count} days": "{count}d",
+      "Refresh now": "Refresh now", "Refreshing\u2026": "Refreshing\u2026"
+    },
+    zh: {
+      "Observed": "观测于", "Not yet observed": "尚未观测",
+      "every {interval}": "每 {interval}", "next in {interval}": "{interval} 后下一次",
+      "event-driven": "事件驱动", "muted": "已静音",
+      "Stale: no cycle completed in over {interval}. Nothing below can be trusted as current.": "已过期：超过 {interval} 无任何周期完成。下方内容不可被当作当前状态。",
+      "confirmed unchanged {interval} later": "{interval} 后确认未变",
+      "{count} sec": "{count} 秒", "{count} min": "{count} 分钟", "{count} hr": "{count} 小时", "{count} days": "{count} 天",
+      "Refresh now": "立即刷新", "Refreshing\u2026": "刷新中…"
+    },
+    fr: {
+      "Observed": "Observé à", "Not yet observed": "Pas encore observé",
+      "every {interval}": "toutes les {interval}", "next in {interval}": "prochain dans {interval}",
+      "event-driven": "piloté par événements", "muted": "en sourdine",
+      "Stale: no cycle completed in over {interval}. Nothing below can be trusted as current.": "Périmé : aucun cycle achevé depuis plus de {interval}. Rien ci-dessous ne peut être considéré comme à jour.",
+      "confirmed unchanged {interval} later": "confirmé inchangé {interval} plus tard",
+      "{count} sec": "{count} s", "{count} min": "{count} min", "{count} hr": "{count} h", "{count} days": "{count} j",
+      "Refresh now": "Actualiser", "Refreshing\u2026": "Actualisation…"
+    },
+    es: {
+      "Observed": "Observado a las", "Not yet observed": "Aún no observado",
+      "every {interval}": "cada {interval}", "next in {interval}": "siguiente en {interval}",
+      "event-driven": "impulsado por eventos", "muted": "silenciado",
+      "Stale: no cycle completed in over {interval}. Nothing below can be trusted as current.": "Obsoleto: ningún ciclo completado en más de {interval}. Nada de lo siguiente puede considerarse actual.",
+      "confirmed unchanged {interval} later": "confirmado sin cambios {interval} después",
+      "{count} sec": "{count} s", "{count} min": "{count} min", "{count} hr": "{count} h", "{count} days": "{count} d",
+      "Refresh now": "Actualizar ahora", "Refreshing\u2026": "Actualizando…"
+    },
+    ar: {
+      "Observed": "رُصِد عند", "Not yet observed": "لم يُرصَد بعد",
+      "every {interval}": "كل {interval}", "next in {interval}": "التالي بعد {interval}",
+      "event-driven": "مدفوع بالأحداث", "muted": "مكتوم",
+      "Stale: no cycle completed in over {interval}. Nothing below can be trusted as current.": "قديم: لم تكتمل أي دورة لأكثر من {interval}. لا يمكن اعتبار أي مما أدناه حاليًا.",
+      "confirmed unchanged {interval} later": "تأكّد عدم تغيَّره بعد {interval}",
+      "{count} sec": "{count} ث", "{count} min": "{count} د", "{count} hr": "{count} س", "{count} days": "{count} ي",
+      "Refresh now": "تحديث الآن", "Refreshing\u2026": "جارٍ التحديث…"
+    },
+    ru: {
+      "Observed": "Наблюдено в", "Not yet observed": "Ещё не наблюдалось",
+      "every {interval}": "каждые {interval}", "next in {interval}": "следующее через {interval}",
+      "event-driven": "по событиям", "muted": "без уведомлений",
+      "Stale: no cycle completed in over {interval}. Nothing below can be trusted as current.": "Устарело: ни один цикл не завершён более {interval}. Ничто ниже нельзя считать актуальным.",
+      "confirmed unchanged {interval} later": "подтверждено без изменений через {interval}",
+      "{count} sec": "{count} с", "{count} min": "{count} мин", "{count} hr": "{count} ч", "{count} days": "{count} д",
+      "Refresh now": "Обновить", "Refreshing\u2026": "Обновление…"
+    }
+  };
+  Object.keys(I18N).concat(Object.keys(I18N_PATCH), Object.keys(I18N_LIVE), Object.keys(I18N_TEMPLATES), Object.keys(I18N_PROVENANCE))
     .filter((lang, at, all) => all.indexOf(lang) === at)
     .forEach((lang) => {
       // Later sources win, so a locale-specific template string overrides the English
       // fallback while an absent one still resolves to readable English.
       I18N[lang] = Object.assign(
         {}, I18N.en || {}, I18N[lang] || {},
-        I18N_PATCH[lang] || {}, I18N_TEMPLATES[lang] || {},
+        I18N_PATCH[lang] || {}, I18N_LIVE[lang] || {}, I18N_TEMPLATES[lang] || {},
+        I18N_PROVENANCE[lang] || {},
       );
     });
 
@@ -308,6 +457,7 @@
       render(payload);
       renderNav(payload.meta || {});
       renderServerHealth(payload.meta || {});
+      renderProvenance(payload.meta || {});
       // Manage signal auto-refresh lifecycle on template switch
       var newTemplate = (payload.meta && payload.meta.active_template) || current.template || "";
       if (newTemplate === "signals") {
@@ -324,6 +474,106 @@
     }
   }
 
+  // Freshness, stated on every lens. A finding-backed board renders the newest
+  // *persisted* finding, and findings dedup on a content fingerprint, so an
+  // unchanged subject keeps its previous finding and the page can be minutes old
+  // while looking current. ``observed_at`` was already in the payload and rendered
+  // nowhere, so a reader had no way to tell -- and a board that prescribes a fix it
+  // cannot confirm landed is a broken loop, not a slow one.
+  //
+  // Placed above the rendered tree rather than inside it: it describes the whole
+  // page, and putting it in the component tree would make it a template author's
+  // job to remember on each of ten lenses.
+  function renderProvenance(meta) {
+    const root = document.getElementById("root");
+    const old = document.getElementById("provenance-bar");
+    if (old) old.remove();
+    const p = meta.provenance;
+    if (!root || !p || typeof p !== "object") return;
+    const bar = el("div", "provenance" + (p.stale ? " is-stale" : ""));
+    bar.id = "provenance-bar";
+
+    const facts = [];
+    if (p.observed) {
+      facts.push(t("Observed") + " " + clockLabel(p.observed_at)
+        + " \u00b7 " + relativeLabel(p.age_seconds));
+    } else {
+      // No instant to age. Saying "0s ago" here would invent one, which is the
+      // failure this bar exists to prevent rather than commit.
+      facts.push(t("Not yet observed"));
+    }
+    // The second instant, and the reason the bar is trustworthy. A cycle that found
+    // nothing changed writes no finding, so without this the page looked frozen
+    // whenever it was in fact being confirmed correct on every tick.
+    if (p.checked && p.unchanged_for_seconds > 1) {
+      facts.push(fmt("confirmed unchanged {interval} later",
+        { interval: durationLabel(p.unchanged_for_seconds) }));
+    }
+    if (p.cadence_seconds > 0) {
+      facts.push(fmt("every {interval}", { interval: durationLabel(p.cadence_seconds) }));
+      if (p.next_due_in_seconds > 0) {
+        facts.push(fmt("next in {interval}", { interval: durationLabel(p.next_due_in_seconds) }));
+      }
+    } else {
+      facts.push(t("event-driven"));
+    }
+    if (p.muted) facts.push(t("muted"));
+    bar.appendChild(el("span", "provenance-facts", esc(facts.join("  \u00b7  "))));
+
+    if (p.stale) {
+      // The verdict is about the watch, not the content: no cycle has completed in
+      // two cadences, so nothing on the page can be trusted to reflect the present.
+      // Old-but-confirmed content is stable, not stale, and is not flagged here.
+      bar.appendChild(el("span", "provenance-stale", esc("\u26a0 " + fmt(
+        "Stale: no cycle completed in over {interval}. Nothing below can be trusted as current.",
+        { interval: durationLabel(p.cadence_seconds * 2) },
+      ))));
+    }
+    // The affordance that closes the loop. Several boards prescribe a fix ("Next
+    // step: run this command"); without a way to re-run the cycle the reader had to
+    // wait out a whole cadence to learn whether it landed, and had no way to tell a
+    // failed change from a page that had not caught up. ``watch.refresh`` is already
+    // on the server's allow-list and re-runs one producer -- it decides nothing.
+    if (p.watch_id) {
+      const button = el("button", "provenance-refresh", esc(t("Refresh now")));
+      button.type = "button";
+      button.addEventListener("click", async () => {
+        button.disabled = true;
+        button.textContent = t("Refreshing\u2026");
+        // postAction already refetches the view for an rpc, so the bar it rebuilds
+        // carries the new observed_at without a second request.
+        await postAction({ kind: "rpc", name: "watch.refresh", params: { watch_id: p.watch_id } });
+      });
+      bar.appendChild(button);
+    }
+    root.insertAdjacentElement("beforebegin", bar);
+  }
+
+  // Wall-clock, for "which cycle am I looking at". Locale-independent digits on
+  // purpose: this is matched against log lines, not read as prose.
+  function clockLabel(epochSeconds) {
+    const at = new Date(Number(epochSeconds || 0) * 1000);
+    if (!isFinite(at.getTime())) return "";
+    const pad = (n) => String(n).padStart(2, "0");
+    return pad(at.getHours()) + ":" + pad(at.getMinutes()) + ":" + pad(at.getSeconds());
+  }
+
+  function durationLabel(seconds) {
+    const s = Math.max(0, Math.round(Number(seconds || 0)));
+    if (s < 60) return fmt("{count} sec", { count: s });
+    if (s < 3600) return fmt("{count} min", { count: Math.round(s / 60) });
+    if (s < 86400) return fmt("{count} hr", { count: Math.round(s / 3600) });
+    return fmt("{count} days", { count: Math.round(s / 86400) });
+  }
+
+  // Reuses the signal timeline's relative keys, which are interpolated on {count}.
+  function relativeLabel(seconds) {
+    const s = Math.max(0, Math.round(Number(seconds || 0)));
+    if (s < 60) return fmt("seconds ago", { count: s });
+    if (s < 3600) return fmt("minutes ago", { count: Math.round(s / 60) });
+    return fmt("hours ago", { count: Math.round(s / 3600) });
+  }
+
   // Long-lived-process staleness: warns when this dashboard server process
   // predates the current source tree (see leapflow.utils.build_info). Purely
   // informational — the page still renders whatever data the stale process
@@ -410,6 +660,80 @@
     return e;
   }
 
+  // ── Markdown: the three constructs the templates actually author ─────────
+  //
+  // The ``Markdown`` node used to escape its text and print it verbatim, so every
+  // aside on the evolution board read as raw markup -- a leading ``>`` and literal
+  // ``**`` in front of the very sentence meant to carry the most weight.
+  //
+  // Escaping runs first and every transform below operates on the *escaped* text,
+  // so prose can never introduce an element: the only tags in the result are the
+  // ones added here. A general Markdown library is deliberately not pulled in --
+  // the SDUI contract is a closed component catalog whose whole security argument
+  // is that no untrusted string reaches innerHTML unescaped, and widening that
+  // surface to gain three constructs is a bad trade.
+  //
+  // Recognised: ``> `` aside (consecutive lines fold into one blockquote),
+  // ``**bold**``, and ``` `code` ```. Anything else stays literal, which is the
+  // honest outcome for a construct the renderer does not claim to support.
+  function mdInline(escaped) {
+    const parts = String(escaped).split("`");
+    // An unmatched trailing backtick is literal text, not an unterminated code
+    // span: an odd count re-joins the tail so a stray backtick cannot swallow the
+    // rest of the sentence into <code>.
+    if (parts.length % 2 === 0) {
+      const tail = parts.pop();
+      parts[parts.length - 1] += "`" + tail;
+    }
+    return parts
+      .map((part, at) => (at % 2
+        // Odd segments sit between a backtick pair. Bold is not applied inside
+        // them, because a config key containing ``**`` is a key, not emphasis.
+        ? "<code>" + part + "</code>"
+        : part.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>")))
+      .join("");
+  }
+
+  function renderMarkdown(raw) {
+    const host = el("div", "md prose");
+    let quote = [];
+    let para = [];
+    // Both flushes join with a space rather than preserving the newline: the
+    // templates author these as YAML folded scalars, so a line break in the source
+    // is a wrapping artifact of the file and never an intended hard break.
+    const flushQuote = () => {
+      if (!quote.length) return;
+      host.appendChild(el("blockquote", "quote", mdInline(esc(quote.join(" ")))));
+      quote = [];
+    };
+    const flushPara = () => {
+      if (!para.length) return;
+      host.appendChild(el("p", null, mdInline(esc(para.join(" ")))));
+      para = [];
+    };
+    String(raw == null ? "" : raw).split(/\r?\n/).forEach((line) => {
+      const text = line.trim();
+      if (!text) { flushQuote(); flushPara(); return; }
+      // Tested on the raw line, before escaping turns ``>`` into ``&gt;``.
+      if (text.charAt(0) === ">") {
+        flushPara();
+        quote.push(text.slice(1).trim());
+      } else if (quote.length) {
+        // Lazy continuation: an unprefixed line directly under an aside belongs to
+        // it. The templates author these as YAML folded scalars, which arrive
+        // pre-joined, so this path exists for text that reaches the renderer any
+        // other way -- a literal scalar, or a bound payload string. Without it such
+        // a notice splits into a one-line quote plus an orphan paragraph.
+        quote.push(text);
+      } else {
+        para.push(text);
+      }
+    });
+    flushQuote();
+    flushPara();
+    return host;
+  }
+
   function renderChildren(node, parent) {
     (node.children || []).forEach((c) => parent.appendChild(renderNode(c)));
     return parent;
@@ -430,6 +754,7 @@
       d.appendChild(el("div", "chart-placeholder", esc(data.length + " " + t("Series")))); return d; },
     gauge: (p) => renderGaugeValue(p.label || "Gauge", p.data),
     signalTimeline: renderSignalTimeline,
+    evolutionLive: renderEvolutionLive,
   };
 
   function asArray(value) { return Array.isArray(value) ? value : []; }
@@ -496,6 +821,175 @@
       .concat(Object.keys(counts).sort().map((key) => ({ key, label: signalFamilyLabel(key), count: counts[key] })));
   }
 
+  function normalizeEvolutionEvent(value) {
+    if (!value || typeof value !== "object") return null;
+    const stage = String(value.stage || "");
+    const kind = String(value.kind || "");
+    if (!stage || !kind) return null;
+    const correlation = value.correlation && typeof value.correlation === "object" ? value.correlation : {};
+    return {
+      event_id: String(value.event_id || value.trace_id || (stage + ":" + kind + ":" + String(value.ts || ""))),
+      episode_id: String(value.episode_id || correlation.record_id || correlation.intent_id || correlation.requirement_id || value.trace_id || ""),
+      stage: stage,
+      kind: kind,
+      ts: Number(value.ts || 0),
+      summary: String(value.summary || ""),
+      evidence_level: String(value.evidence_level || "runtime_trace"),
+      verification_tier: String(value.verification_tier || "not_recorded"),
+      side_effect_state: String(value.side_effect_state || "not_recorded"),
+      payload_ref: value.payload_ref && typeof value.payload_ref === "object" ? value.payload_ref : correlation,
+    };
+  }
+
+  function evolutionLaneFor(stage) {
+    if (stage === "observe") return "environment";
+    if (stage === "orient" || stage === "decide") return "decision";
+    return "governance";
+  }
+
+  function evolutionSeverity(event) {
+    if (event.kind === "trust_frozen" || event.side_effect_state === "unknown") return "alert";
+    if (event.kind.indexOf("unregistered") >= 0 || event.verification_tier === "not_recorded") return "notable";
+    return "info";
+  }
+
+  function evolutionTimeLabel(event) {
+    const ms = Number(event.ts || 0) * 1000;
+    if (!Number.isFinite(ms) || ms <= 0) return "--:--:--";
+    return new Date(ms).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
+  }
+
+  function showEvolutionDrawer(drawer, event) {
+    drawer.innerHTML = "";
+    if (!event) {
+      drawer.appendChild(el("div", "card-title", esc(t("Event detail"))));
+      drawer.appendChild(el("div", "summary", esc(t("Select a live event to inspect its evidence references."))));
+      return;
+    }
+    drawer.appendChild(el("div", "card-title", esc(event.stage + " · " + event.kind)));
+    drawer.appendChild(el("div", "summary", esc(event.summary || t("No entries."))));
+    drawer.appendChild(el("pre", "evolution-live-json", esc(JSON.stringify({
+      episode_id: event.episode_id,
+      evidence_level: event.evidence_level,
+      verification_tier: event.verification_tier,
+      side_effect_state: event.side_effect_state,
+      payload_ref: event.payload_ref,
+    }, null, 2))));
+  }
+
+  // Two provenances meet in this lens and must not be blended. ``Event count`` and
+  // ``Live since snapshot`` are recomputed from the event list on every append, so
+  // they are genuinely live. Everything else needs a full producer cycle -- a
+  // presentation event carries one fact, never a recount -- so those are labelled
+  // as of the snapshot instead of being redrawn as though the increment had moved
+  // them. The producer's own fingerprint docstring names this failure: a rendered
+  // value that cannot be refreshed "freezes on the page while still looking
+  // current, which is worse than not showing it". It held on the server and was
+  // then committed here, where five of six metrics sat on load-time values while
+  // the lanes advanced beside them.
+  function evolutionLiveStat(label, value, provenance) {
+    const stat = el("div", "stat prov-" + provenance);
+    stat.appendChild(el("div", "label", esc(t(label))));
+    stat.appendChild(el("div", "value", esc(value)));
+    return stat;
+  }
+
+  function renderEvolutionLive(props) {
+    const snapshot = props.data && typeof props.data === "object" ? props.data : {};
+    const maxEvents = _clampInt(props.max_events || 60, 8, 120) || 60;
+    // The instant the snapshot metrics describe. Events at or before it are already
+    // counted in them; only strictly newer ones are uncounted increments.
+    const baselineAt = Number(snapshot.observed_at || 0);
+    const host = el("div", "evolution-live");
+    const metrics = el("div", "evolution-live-metrics metric-strip");
+    const drift = el("div", "evolution-live-drift");
+    const lanes = el("div", "evolution-live-lanes");
+    const drawer = el("div", "evolution-live-drawer card");
+    const controller = {
+      events: asArray(snapshot.traces).map(normalizeEvolutionEvent).filter(Boolean),
+      maxEvents: maxEvents,
+      render: function () {
+        this.events.sort((left, right) => Number(right.ts || 0) - Number(left.ts || 0));
+        this.events = this.events.slice(0, this.maxEvents);
+        const since = baselineAt
+          ? this.events.filter((event) => Number(event.ts || 0) > baselineAt).length
+          : 0;
+        metrics.innerHTML = "";
+        const summary = snapshot.summary && typeof snapshot.summary === "object" ? snapshot.summary : {};
+        [
+          ["Event count", this.events.length, "live"],
+          ["Live since snapshot", since, "live"],
+          ["Episodes", summary.episode_count || 0, "snapshot"],
+          ["Mutation", summary.mutation_count || 0, "snapshot"],
+          ["Regressions", summary.regression_count || 0, "snapshot"],
+          ["Unadmitted intents", summary.unadmitted_intent_count || 0, "snapshot"],
+          ["Pipeline evidence", String(summary.segments_with_evidence || 0) + "/" + String(summary.segments_total || 0), "snapshot"],
+        ].forEach((triple) => {
+          metrics.appendChild(evolutionLiveStat(triple[0], triple[1], triple[2]));
+        });
+        // Stated only when it is true. A permanent "these may be stale" caption is
+        // noise a reader learns to skip; a count that appears exactly when the two
+        // provenances have diverged is a fact, and it names what closes the gap.
+        drift.innerHTML = "";
+        if (since > 0) {
+          drift.appendChild(el("div", "drift-note", esc(fmt(
+            "{count} event(s) arrived after this snapshot. Snapshot metrics refresh on the next monitor cycle.",
+            { count: since },
+          ))));
+        }
+        lanes.innerHTML = "";
+        const definitions = [
+          ["environment", "Environment lane", "Environment events appear when a probe records a change in the surroundings."],
+          ["decision", "Decision lane", "Decision events appear when a recorded observation drives a capability choice."],
+          ["governance", "Governance lane", "Governance events appear when trust, quarantine or reclamation moves."],
+        ];
+        definitions.forEach((definition) => {
+          const lane = el("section", "evolution-live-lane " + definition[0]);
+          lane.appendChild(el("div", "card-title", esc(t(definition[1]))));
+          const items = this.events.filter((event) => evolutionLaneFor(event.stage) === definition[0]);
+          if (!items.length) {
+            // An empty lane answers what would appear here and why nothing has, so
+            // "quiet" is distinguishable from "broken" without leaving the page.
+            // Reporting only "No live events" left the reader unable to tell which.
+            lane.appendChild(el("div", "empty-inline", esc(t("No live events"))));
+            lane.appendChild(el("div", "lane-hint", esc(t(definition[2]))));
+          } else {
+            items.forEach((event) => {
+              const row = el("button", "evolution-live-event sev-" + evolutionSeverity(event));
+              row.type = "button";
+              row.appendChild(el("span", "evolution-live-time", esc(evolutionTimeLabel(event))));
+              row.appendChild(el("span", "evolution-live-kind", esc(event.stage + " \u00b7 " + event.kind)));
+              if (event.summary) row.appendChild(el("span", "evolution-live-summary", esc(event.summary)));
+              row.addEventListener("click", () => { showEvolutionDrawer(drawer, event); });
+              lane.appendChild(row);
+            });
+          }
+          lanes.appendChild(lane);
+        });
+      },
+      append: function (event) {
+        if (this.events.some((item) => item.event_id === event.event_id)) return;
+        this.events.unshift(event);
+        this.render();
+      },
+    };
+    showEvolutionDrawer(drawer, null);
+    controller.render();
+    _evolutionLiveControllers.push(controller);
+    host.appendChild(metrics);
+    host.appendChild(drift);
+    host.appendChild(lanes);
+    host.appendChild(drawer);
+    return host;
+  }
+
+  function updateEvolutionLive(payload) {
+    if (getCurrentTemplate() !== "evolution_live") return;
+    const event = normalizeEvolutionEvent(payload);
+    if (!event) return;
+    _evolutionLiveControllers.forEach((controller) => controller.append(event));
+  }
+
   function renderSignalTimeline(props) {
     const box = el("div", "signal-timeline");
     box._signalTimelineOptions = { maxItems: _clampInt(props.max_items || props.maxItems || 12, 1, 24) || 12 };
@@ -630,9 +1124,14 @@
   function renderSparkline(data, title, opts) {
     const d = el("div", "chart card");
     if (title) d.appendChild(el("div", "card-title", esc(tx(title))));
+    // One point is kept, not discarded. A series with a single sample used to be
+    // filtered out and the chart reported "No entries." -- the reader was told there
+    // was no data when in fact there was exactly one observation, which for a board
+    // whose subject has just started evolving is the most important reading it has.
+    // A lone sample is drawn as a marker rather than an invented line.
     const groups = seriesGroups(data).slice(0, 4)
       .map((g) => ({ label: String(g.label || ""), points: asArray(g.points).map((p, i) => ({ x: p.x != null ? p.x : i, y: Number(p.y) })).filter((p) => Number.isFinite(p.y)) }))
-      .filter((g) => g.points.length >= 2);
+      .filter((g) => g.points.length >= 1);
     if (!groups.length) { d.appendChild(el("div", "chart-placeholder", esc(t("No entries.")))); return d; }
     const ys = []; groups.forEach((g) => g.points.forEach((p) => ys.push(p.y)));
     const min = Math.min.apply(null, ys), max = Math.max.apply(null, ys), span = (max - min) || 1;
@@ -640,14 +1139,27 @@
     const svg = svgEl("svg"); svg.setAttribute("viewBox", "0 0 " + W + " " + H); svg.setAttribute("preserveAspectRatio", "none"); svg.setAttribute("class", "sparkline");
     const strokes = ["var(--accent)", "var(--info)", "var(--notable)", "var(--faint)"];
     groups.forEach((g, gi) => {
+      const stroke = strokes[gi % strokes.length];
+      const yAt = (p) => H - pad - ((p.y - min) / span) * (H - pad * 2);
+      if (g.points.length === 1) {
+        // Centred, because a single sample has no span to lay out along and pinning
+        // it to the left edge would read as the start of a trend that does not exist.
+        const dot = svgEl("circle");
+        dot.setAttribute("cx", String(W / 2));
+        dot.setAttribute("cy", yAt(g.points[0]).toFixed(1));
+        dot.setAttribute("r", "3.5");
+        dot.setAttribute("style", "fill:" + stroke + ";stroke:none");
+        svg.appendChild(dot);
+        return;
+      }
       const n = Math.max(1, g.points.length - 1);
-      const coords = g.points.map((p, i) => (i * (W / n)).toFixed(1) + "," + (H - pad - ((p.y - min) / span) * (H - pad * 2)).toFixed(1)).join(" ");
+      const coords = g.points.map((p, i) => (i * (W / n)).toFixed(1) + "," + yAt(p).toFixed(1)).join(" ");
       if (opts && opts.area) {
         const poly = svgEl("polygon"); poly.setAttribute("points", "0," + (H - pad) + " " + coords + " " + W + "," + (H - pad));
-        poly.setAttribute("style", "fill:" + strokes[gi % strokes.length] + ";opacity:.12;stroke:none"); svg.appendChild(poly);
+        poly.setAttribute("style", "fill:" + stroke + ";opacity:.12;stroke:none"); svg.appendChild(poly);
       }
       const line = svgEl("polyline"); line.setAttribute("points", coords);
-      line.setAttribute("style", "stroke:" + strokes[gi % strokes.length]); svg.appendChild(line);
+      line.setAttribute("style", "stroke:" + stroke); svg.appendChild(line);
     });
     d.appendChild(svg);
     // Always name the line(s) so the chart is self-describing, even for a single
@@ -1330,7 +1842,7 @@
     // stayed English in all six locales; interpolated text still cannot match a
     // dictionary key, which is why templates keep counts in Stat and the prose
     // here literal.
-    Markdown: (n) => el("div", "md prose", esc(tx((n.props || {}).text))),
+    Markdown: (n) => renderMarkdown(tx((n.props || {}).text)),
     StoryPanel: (n) => { const p = n.props || {}; const d = el("div", "card story-panel");
       d.appendChild(el("div", "card-title", esc(tx(p.title || "Storyline"))));
       d.appendChild(renderAbstract(p.text)); return d; },
@@ -1410,6 +1922,7 @@
 
   function render(spec) {
     disposePreviews();
+    _evolutionLiveControllers = [];
     rootEl.innerHTML = "";
     figSeq = 0; tblSeq = 0;
     (spec.root || []).forEach((n) => rootEl.appendChild(renderNode(n)));
@@ -1431,12 +1944,17 @@
     const proto = location.protocol === "https:" ? "wss" : "ws";
     const ws = new WebSocket(proto + "://" + location.host + "/ws?token=" + encodeURIComponent(TOKEN));
     ws.onopen = () => { setConnectionStatus("live"); };
+    // A reconnect may have missed bounded live events; the authoritative snapshot
+    // restores the live lens without asking the daemon to replay a mutation.
+    ws.addEventListener("open", () => { fetchView(); });
     ws.onclose = () => { setConnectionStatus("reconnecting…"); setTimeout(connectWS, 3000); };
     ws.onmessage = (ev) => {
       let msg; try { msg = JSON.parse(ev.data); } catch (_) { return; }
       if (msg.type === "monitor.finding") { toast(msg.payload || {}); fetchView(); }
       else if (msg.type === "approval_request") { showApproval(msg.payload || {}); }
       else if (msg.type === "watch.state") { fetchView(); }
+      else if (msg.type === "evolution.presentation") { updateEvolutionLive(msg.payload || {}); }
+      else if (msg.type === "view.resync") { fetchView(); }
       else if (msg.type === "signal.stream") {
         // Append to local signal stream buffer (max 50)
         if (!window._signalStream) window._signalStream = [];
diff --git a/src/leapflow/dashboard/static/index.html b/src/leapflow/dashboard/static/index.html
index c86b2145..de06d2a7 100644
--- a/src/leapflow/dashboard/static/index.html
+++ b/src/leapflow/dashboard/static/index.html
@@ -7,7 +7,7 @@
   <link rel="preconnect" href="https://fonts.googleapis.com" />
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
   <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;700;800&family=Source+Serif+4:opsz,wght@8..60,400;8..60,600&display=swap" rel="stylesheet" />
-  <link rel="stylesheet" href="/static/styles.css?v=status-i18n-20260808" />
+  <link rel="stylesheet" href="/static/styles.css?v=provenance-md-20260918" />
 </head>
 <body>
   <header class="topbar">
@@ -30,6 +30,6 @@
   </header>
   <main id="root" class="root"><div class="empty" data-i18n="Loading…">Loading…</div></main>
   <div id="toasts" class="toasts"></div>
-  <script src="/static/app.js?v=status-i18n-20260808"></script>
+  <script src="/static/app.js?v=provenance-md-20260918"></script>
 </body>
 </html>
diff --git a/src/leapflow/dashboard/static/styles.css b/src/leapflow/dashboard/static/styles.css
index 33fd6940..9d4869b4 100644
--- a/src/leapflow/dashboard/static/styles.css
+++ b/src/leapflow/dashboard/static/styles.css
@@ -233,9 +233,40 @@ button, .btn {
 }
 button:hover { border-color: var(--accent); color: var(--accent); }
 
-/* ── Prose fallback ──────────────────────────────────────────────────────── */
+/* ── Prose ───────────────────────────────────────────────────────────────── */
 .md { white-space: pre-wrap; }
 .prose { line-height: 1.55; color: var(--ink); }
+/* The Markdown renderer emits blocks, so pre-wrap has to be released here or the
+   folded-scalar indentation the YAML carried would reappear as leading gaps. */
+.md.prose { white-space: normal; }
+.md.prose > p { margin: 0 0 7px; }
+.md.prose > p:last-child, .md.prose > blockquote:last-child { margin-bottom: 0; }
+.md.prose > blockquote + p { margin-top: 7px; }
+.md.prose > .quote { margin: 0 0 7px; }
+.md.prose code, .evolution-live-lane code, .data-table code {
+  padding: 0 3px; background: var(--panel-2); font: 0.92em/1.4 var(--mono);
+  overflow-wrap: anywhere;
+}
+
+/* ── Provenance bar (page-level freshness) ───────────────────────────────── */
+/* Above the rendered tree and on every lens: it describes the whole page, so it
+   must not compete with a section heading or be mistaken for one. Muted and thin
+   while the page is current; only the stale verdict earns colour. */
+.provenance {
+  display: flex; flex-wrap: wrap; align-items: baseline; gap: 6px 14px;
+  margin: 0 0 12px; padding: 5px 0 6px;
+  border-bottom: 1px solid var(--line);
+  color: var(--muted); font-size: 0.79rem; letter-spacing: .02em;
+  font-variant-numeric: tabular-nums;
+}
+.provenance.is-stale { border-bottom-color: var(--alert); }
+.provenance-stale { color: var(--alert); font-weight: 650; }
+/* Sized down to the bar it lives in: this is a utility, not the page's action. */
+.provenance-refresh {
+  margin-inline-start: auto; padding: 2px 9px;
+  font-size: 0.76rem; color: var(--muted);
+}
+.provenance-refresh:disabled { color: var(--line); cursor: default; border-color: var(--line); }
 
 /* ── Toasts ──────────────────────────────────────────────────────────────── */
 .toasts { position: fixed; right: 18px; bottom: 18px; display: flex; flex-direction: column; gap: 8px; }
@@ -370,3 +401,50 @@ button:hover { border-color: var(--accent); color: var(--accent); }
   border-top: 1px solid var(--rule); border-bottom: 1px solid var(--rule);
   background: rgba(23, 24, 28, .015);
 }
+
+/* ── Evolution live (presentation-only event lanes) ──────────────────────── */
+.evolution-live { display: flex; flex-direction: column; gap: 10px; }
+/* metric-strip supplies borders only; the custom live renderer owns its layout. */
+.evolution-live-metrics { display: flex; flex-wrap: wrap; margin-bottom: 0; }
+/* Provenance is carried in the label, not the number: a snapshot-derived metric
+   gets a dotted underline so a reader can see at a glance which figures a live
+   event can move and which wait for the next producer cycle. */
+.evolution-live-metrics .prov-snapshot .label {
+  text-decoration: underline dotted var(--line); text-underline-offset: 3px;
+}
+.evolution-live-metrics .prov-live .label { color: var(--accent); }
+.drift-note {
+  padding: 5px 9px; border-inline-start: 2px solid var(--notable);
+  background: var(--panel-2); color: var(--muted); font-size: .82rem;
+}
+/* Equal-height lanes: stretch is the grid default, but the fixed min-height meant
+   an empty lane stayed short and the row read as ragged. align-items keeps the
+   three columns level while the content decides how tall the row is. */
+.evolution-live-lanes {
+  display: grid; grid-template-columns: repeat(3, minmax(0, 1fr));
+  align-items: stretch; gap: 9px;
+}
+.evolution-live-lane {
+  display: flex; flex-direction: column; min-width: 0; min-height: 132px;
+  padding: 9px; border: 1px solid var(--line); background: var(--panel);
+}
+/* The hint sits at the bottom of an otherwise empty lane, so the three lanes read
+   as one row of equal cards rather than three differently-filled boxes. */
+.evolution-live-lane .lane-hint {
+  margin-top: auto; padding-top: 7px; color: var(--muted); font-size: .78rem;
+  line-height: 1.4; border-top: 1px dashed var(--line);
+}
+.evolution-live-lane.environment { border-top: 3px solid var(--info); }
+.evolution-live-lane.decision { border-top: 3px solid var(--notable); }
+.evolution-live-lane.governance { border-top: 3px solid var(--accent); }
+.evolution-live-event { display: grid; grid-template-columns: max-content 1fr; gap: 2px 7px; width: 100%; margin-top: 6px; padding: 5px 0 5px 8px; border: 0; border-left: 2px solid var(--line); text-align: left; background: transparent; }
+.evolution-live-event:hover { border-left-color: var(--accent); color: inherit; }
+.evolution-live-event.sev-alert { border-left-color: var(--alert); }
+.evolution-live-event.sev-notable { border-left-color: var(--notable); }
+.evolution-live-event.sev-info { border-left-color: var(--info); }
+.evolution-live-time { grid-row: span 2; color: var(--muted); font-size: .76rem; font-variant-numeric: tabular-nums; }
+.evolution-live-kind { font-weight: 650; font-size: .84rem; overflow-wrap: anywhere; }
+.evolution-live-summary { grid-column: 2; color: var(--muted); font-size: .82rem; overflow-wrap: anywhere; }
+.evolution-live-drawer { min-height: 76px; }
+.evolution-live-json { margin: 7px 0 0; padding: 7px; overflow: auto; border-top: 1px solid var(--line); background: var(--panel-2); color: var(--muted); font: .76rem/1.45 var(--mono); }
+@media (max-width: 900px) { .evolution-live-lanes { grid-template-columns: 1fr; } }
diff --git a/src/leapflow/dashboard/templates/causal_trace.yaml b/src/leapflow/dashboard/templates/causal_trace.yaml
new file mode 100644
index 00000000..a4033389
--- /dev/null
+++ b/src/leapflow/dashboard/templates/causal_trace.yaml
@@ -0,0 +1,87 @@
+# Read-only causal trace lens for the AAAI demonstration and audit sessions.
+#
+# It consumes the existing framework_evolution payload. The template introduces no
+# actions and therefore cannot approve, install, reload, or otherwise mutate a plugin.
+template: causal_trace
+version: 1
+hidden: true
+title: "Causal trace"
+domain: framework_evolution
+meta:
+  title: "Causal trace"
+  description: "Read-only environment-to-governance evidence for one framework-evolution snapshot."
+layout:
+  - type: Page
+    props:
+      title: "Causal trace"
+    children:
+      - type: Section
+        when: evolution.summary
+        props:
+          title: "Evidence boundary"
+          subtitle: "A causal trace shows recorded facts; it does not infer missing approval or observed effect."
+        children:
+          - type: Grid
+            props:
+              cols: 4
+            children:
+              - type: Stat
+                props:
+                  label: "Episodes"
+                  value: "{{ evolution.summary.episode_count }}"
+              - type: Stat
+                props:
+                  label: "Self-acquired"
+                  value: "{{ evolution.summary.self_acquired_count }}"
+              - type: Stat
+                props:
+                  label: "Pipeline evidence"
+                  value: "{{ evolution.summary.segments_with_evidence }}/{{ evolution.summary.segments_total }}"
+              - type: Stat
+                props:
+                  label: "Declared-fitness closures"
+                  value: "{{ evolution.summary.resolved_count }}"
+      - type: Section
+        when: evolution.mutation_matrix
+        props:
+          title: "Counterfactual / mutation matrix"
+          subtitle: "Each row preserves the driver, decision, registry delta, and verification tier."
+        children:
+          - type: Table
+            props:
+              bind: evolution.mutation_matrix
+              columns:
+                - key: driver
+                  label: "Trigger"
+                - key: capability
+                  label: "Capability"
+                - key: policy_action
+                  label: "Decision"
+                - key: mutation_action
+                  label: "Mutation"
+                - key: registry_delta
+                  label: "Registry"
+                - key: lifecycle_status
+                  label: "Lifecycle"
+                - key: verification_tier
+                  label: "Evidence tier"
+                - key: gap_closure
+                  label: "Gap closure"
+      - type: Section
+        when: evolution.timeline
+        props:
+          title: "Episode timeline"
+          subtitle: "Rebuilt from existing decision and observation records."
+        children:
+          - type: Timeline
+            props:
+              bind: evolution.timeline
+      - type: Section
+        when: evolution.trace_feed
+        props:
+          title: "Durable trace feed"
+          subtitle: "Rejected and no-op decisions remain visible when their trace sink is installed."
+        children:
+          - type: Timeline
+            props:
+              bind: evolution.trace_feed
diff --git a/src/leapflow/dashboard/templates/evolution.yaml b/src/leapflow/dashboard/templates/evolution.yaml
index d78fb74d..43ee3a92 100644
--- a/src/leapflow/dashboard/templates/evolution.yaml
+++ b/src/leapflow/dashboard/templates/evolution.yaml
@@ -166,6 +166,38 @@ layout:
                 props:
                   label: "Pipeline evidence"
                   value: "{{ evolution.summary.segments_with_evidence }}/{{ evolution.summary.segments_total }}"
+          # ── The evolution axis ──────────────────────────────────────────
+          # Gated on the *series*, not on having two of them: the renderer draws a
+          # lone sample as a marker, and "one observation, here it is" is the most
+          # important reading a board has on the day its subject starts evolving.
+          # Every other panel on this page is a cross-section of one instant; this
+          # is the only one that answers which way the framework is moving. It sits
+          # outside the tabs with the posture strip because that question is not a
+          # detail of any one tab.
+          #
+          # Bound at ``evidence_trend`` rather than ``evolution.evidence_trend``:
+          # the producer owns the ``evolution.*`` namespace, and this series is
+          # derived by the view service from retained findings, which are the only
+          # thing that carries history across daemon restarts.
+          - type: AreaChart
+            when: evidence_trend.series
+            props:
+              title: "Pipeline evidence over time"
+              bind: evidence_trend.series
+              caption: "One point per recorded change in framework state, oldest first."
+          - type: Row
+            when: evidence_trend.series
+            props:
+              variant: meta
+            children:
+              - type: Stat
+                props:
+                  label: "Samples"
+                  value: "{{ evidence_trend.samples }}"
+              - type: Stat
+                props:
+                  label: "Net change"
+                  value: "{{ evidence_trend.delta }}"
           - type: Markdown
             when: evolution.degraded_reason
             props:
diff --git a/src/leapflow/dashboard/templates/evolution_live.yaml b/src/leapflow/dashboard/templates/evolution_live.yaml
new file mode 100644
index 00000000..c2b461bb
--- /dev/null
+++ b/src/leapflow/dashboard/templates/evolution_live.yaml
@@ -0,0 +1,58 @@
+# Presentation-only live evolution lens for demonstrations and audits.
+#
+# The initial view binds the existing framework_evolution snapshot. Browser-side
+# increments may append display events, but every reconnect resynchronizes from this
+# immutable producer payload. No node declares an action.
+#
+# There is deliberately no metric row here. One used to sit above the lanes
+# repeating Episodes, Pipeline evidence, Unadmitted intents and Regressions --
+# four of the six figures the live renderer already draws, forty pixels below and
+# with no way to tell which of the two could move. The renderer owns the strip
+# because only it knows which figures a live event can advance and which wait for
+# the next producer cycle, and it labels them accordingly. Page-level freshness is
+# carried by the provenance bar, above every lens.
+template: evolution_live
+version: 1
+hidden: true
+title: "Evolution live"
+domain: framework_evolution
+meta:
+  title: "Evolution live"
+  description: "Read-only event lanes for environment, decision, and governance evidence."
+layout:
+  - type: Page
+    props:
+      title: "Evolution live"
+    children:
+      - type: Section
+        props:
+          title: "Live event lanes"
+          subtitle: "Presentation-only trace projection. Reconnect resynchronizes from the current evolution snapshot."
+        children:
+          - type: Custom
+            props:
+              render: evolutionLive
+              bind: evolution
+              max_events: 60
+      - type: Section
+        when: evolution.mutation_matrix
+        props:
+          title: "Counterfactual / mutation matrix"
+          subtitle: "Latest durable episode projection; rows do not imply an unrecorded install or approval."
+        children:
+          - type: Table
+            props:
+              bind: evolution.mutation_matrix
+              columns:
+                - key: driver
+                  label: "Trigger"
+                - key: capability
+                  label: "Capability"
+                - key: policy_action
+                  label: "Decision"
+                - key: mutation_action
+                  label: "Mutation"
+                - key: verification_tier
+                  label: "Evidence tier"
+                - key: gap_closure
+                  label: "Gap closure"
diff --git a/src/leapflow/engine/engine.py b/src/leapflow/engine/engine.py
index 6dc9420d..7cdf2d04 100644
--- a/src/leapflow/engine/engine.py
+++ b/src/leapflow/engine/engine.py
@@ -5703,7 +5703,12 @@ def _observe_capability_result(self, result: Any) -> None:
                 registry_version_after=registry.version,
                 mutation={
                     "action": "observe",
-                    "error_type": "unknown_tool",
+                    # The real evidence kind, not a hardcoded literal. Stamping every
+                    # observation as "unknown_tool" made the causal ledger classify a
+                    # world-model or environment-driven episode as an unknown-tool one,
+                    # so the driver attribution on the board was wrong for exactly the
+                    # episodes self-evolution cares about.
+                    "error_type": str(result.get("error_type") or "unknown_tool"),
                     "observation_id": (observation_record or {}).get("observation_id", ""),
                 },
             )
diff --git a/src/leapflow/learning/degradation_sink.py b/src/leapflow/learning/degradation_sink.py
index a5da6b61..df609e2c 100644
--- a/src/leapflow/learning/degradation_sink.py
+++ b/src/leapflow/learning/degradation_sink.py
@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, Callable, Mapping
+from typing import Any, Callable, Mapping, Sequence
 
 logger = logging.getLogger(__name__)
 
@@ -120,7 +120,7 @@ def sink(
     return sink
 
 
-def build_proposal_sink(*, queue: Any) -> Callable[[Any], str]:
+def build_proposal_sink(*, queue: Any) -> Callable[..., str]:
     """Return the sink that turns an accepted acquisition into a queued proposal.
 
     The last hop of the acquisition chain, and it was missing: the driver derived an
@@ -134,9 +134,19 @@ def build_proposal_sink(*, queue: Any) -> Callable[[Any], str]:
     generated, so this hop makes the proposal *visible and actionable* rather than
     executed. That separation is why the sink can be wired by default while generation
     stays governed.
+
+    ``observation_ids`` and ``environment`` are threaded from the driver so the queue
+    item carries the evidence and the task environment it was born from. The causal
+    ledger joins a proposal back to its motivating observations by exactly these ids;
+    without them a queued acquisition is an orphan the ledger cannot reconstruct.
     """
 
-    def sink(proposal: Any) -> str:
+    def sink(
+        proposal: Any,
+        *,
+        observation_ids: Sequence[str] = (),
+        environment: Any = None,
+    ) -> str:
         requirement = _requirement_from(proposal)
         if requirement is None:
             # Without a capability the queue has nothing to deduplicate on and resolution
@@ -148,14 +158,21 @@ def sink(proposal: Any) -> str:
             return ""
         evidence = tuple(getattr(proposal, "evidence", ()) or ())
         metadata = dict(getattr(evidence[0], "metadata", {})) if evidence else {}
+        env_payload = _environment_dict(environment)
         try:
             item = queue.enqueue(
                 requirements=(requirement,),
+                environment=env_payload,
                 source="world_model",
+                observation_ids=tuple(str(o) for o in observation_ids if str(o)),
                 risk={"max_risk_level": requirement.max_risk_level},
                 metadata={
                     "plugin_id": str(getattr(proposal, "plugin_id", "")),
                     "capability_summary": str(getattr(proposal, "capability_summary", "")),
+                    # The world model's own words and identity, carried so the ledger can
+                    # render "why this evolved" and so a reviewer sees the hypothesis.
+                    "intent_id": str(metadata.get("intent_id", "")),
+                    "confidence": str(metadata.get("confidence", "")),
                     # Carried so a reviewer can see what a challenger is challenging, and
                     # so a rival stays distinguishable from a gap fill for the same
                     # capability.
@@ -170,6 +187,21 @@ def sink(proposal: Any) -> str:
     return sink
 
 
+def _environment_dict(environment: Any) -> dict[str, Any]:
+    """Coerce a fingerprint or mapping into the queue's plain-dict environment."""
+    if environment is None:
+        return {}
+    to_dict = getattr(environment, "to_dict", None)
+    if callable(to_dict):
+        try:
+            return dict(to_dict())
+        except Exception:  # noqa: BLE001 - a fingerprint is context, not a gate
+            return {}
+    if isinstance(environment, Mapping):
+        return dict(environment)
+    return {}
+
+
 def _requirement_from(proposal: Any) -> Any:
     """Rebuild the requirement the queue keys on, from the proposal's own evidence.
 
diff --git a/src/leapflow/learning/world_model_driver.py b/src/leapflow/learning/world_model_driver.py
index 7e3002d4..d771a409 100644
--- a/src/leapflow/learning/world_model_driver.py
+++ b/src/leapflow/learning/world_model_driver.py
@@ -29,6 +29,7 @@
 
 from __future__ import annotations
 
+import inspect
 import logging
 from dataclasses import dataclass, field
 from typing import Any, Mapping, Protocol, Sequence, runtime_checkable
@@ -36,12 +37,38 @@
 from leapflow.domain.capability_requirement import CapabilityRequirement
 from leapflow.domain.evolution_intent import (
     MODEL_AUTHORED_RISK_CEILING,
+    WORLD_MODEL_ORIGIN,
     EvolutionIntent,
 )
 from leapflow.domain.plugin_proposal import RiskLevel
 
 logger = logging.getLogger(__name__)
 
+#: Exception types that mean "this call was wired wrongly", not "this datum was bad".
+#: They are separated from the resilient catch-all so a contract break is reported
+#: instead of being absorbed as one more skipped intent.
+_INTERNAL_DEFECTS = (TypeError, AttributeError, NameError)
+
+
+def _accepted_kwargs(target: Any, candidates: Sequence[str]) -> frozenset[str]:
+    """Which of ``candidates`` this callable can actually receive by keyword.
+
+    Optional context must stay optional. A collaborator supplied by a caller keeps
+    whatever signature it was written against, so newer keywords are offered only to
+    the ones that declare them (or accept ``**kwargs``). When the signature cannot be
+    read -- a builtin, a C callable -- nothing extra is passed, which is the safe
+    direction: the original positional contract always works.
+    """
+    if target is None:
+        return frozenset()
+    try:
+        parameters = inspect.signature(target).parameters
+    except (TypeError, ValueError):
+        return frozenset()
+    if any(p.kind is inspect.Parameter.VAR_KEYWORD for p in parameters.values()):
+        return frozenset(candidates)
+    return frozenset(name for name in candidates if name in parameters)
+
 
 @runtime_checkable
 class CapabilityGapTeacher(Protocol):
@@ -89,6 +116,15 @@ class WorldModelDriveResult:
     the evidence gate accepted. The two differ whenever the operator has not opted
     in, which is the normal default -- so a non-zero ``proposed`` with an empty
     ``admitted`` is a correct, quiet outcome, not a failure.
+
+    Admission is only the first gate. An admitted requirement then passes the
+    authority filter: a hypothesis whose requirement origin the operator has not
+    authorised to drive acquisition is recorded in ``unauthorised`` -- a durable no-op,
+    the record of *why the framework did not change*, not dropped telemetry. Whether an
+    installed provider already covers the capability (rebind vs acquire) is decided
+    upstream by the teacher, which sees the failed-outcome hindsight the resolver never
+    does; re-checking it here by declared fitness would re-introduce the blind spot the
+    world model exists to bypass, so the driver does not.
     """
 
     grades: tuple[Any, ...] = ()
@@ -107,6 +143,10 @@ class WorldModelDriveResult:
     #: Proposals queued for governed acquisition. Empty when no sink is installed,
     #: which is the default: an intent then reaches a requirement and stops there.
     queued_proposal_ids: tuple[str, ...] = ()
+    #: Capabilities whose requirement origin may not authorise an acquisition. A
+    #: durable no-op, retired with its reason, so a rejected authority branch is
+    #: reconstructable rather than invisible.
+    unauthorised: tuple[str, ...] = ()
 
     @property
     def proposed(self) -> int:
@@ -122,6 +162,7 @@ def to_dict(self) -> dict[str, Any]:
             "proposed": self.proposed,
             "admitted": self.admitted,
             "queued": len(self.queued_proposal_ids),
+            "unauthorised": list(self.unauthorised),
             "capabilities": sorted({r.capability for r in self.requirements}),
             # Counted per action so a session that adapted purely by distilling
             # knowledge is distinguishable from one that did nothing.
@@ -146,6 +187,7 @@ def __init__(
         proposal_sink: Any = None,
         knowledge_store: Any = None,
         alternatives_for: Any = None,
+        authorising_origins: Sequence[str] = (),
     ) -> None:
         self._teacher = teacher
         self._intake = intake
@@ -162,6 +204,15 @@ def __init__(
         # and it stays optional because queueing proposals is a governed, opt-in
         # capability rather than something grading should do by default.
         self._proposal_sink = proposal_sink
+        # Which optional context this particular sink accepts. The sink is caller-supplied
+        # and its original contract was ``sink(proposal)``; passing newer keywords
+        # unconditionally raised ``TypeError`` inside the per-intent guard below, which
+        # swallowed it at debug level and silently stopped queueing *every* acquisition
+        # for any sink that had not adopted them. Resolving the signature once keeps the
+        # extra causal context additive instead of breaking the contract.
+        self._sink_kwargs = _accepted_kwargs(
+            proposal_sink, ("observation_ids", "environment")
+        )
         # Where the cheap verdicts land. Three of the four actions change nothing except
         # what the acting agent knows, so without this they would be graded, traced, and
         # then thrown away -- the teacher would have judged correctly and the next
@@ -173,6 +224,13 @@ def __init__(
         # capability covers this") and ``acquire`` ("nothing does") without being told
         # which is true -- the deciding fact for both.
         self._alternatives_for = alternatives_for
+        # Requirement origins permitted to drive an acquisition. Empty means
+        # unrestricted (shipped default). Setting it to ``("world_model",)`` is the
+        # executable form of "self-evolution's first driver is the world model": a
+        # requirement of any other origin is retired as a no-op rather than queued.
+        self._authorising_origins = tuple(
+            str(origin) for origin in (authorising_origins or ()) if str(origin)
+        )
 
     async def drive(
         self,
@@ -232,6 +290,10 @@ async def drive(
         # admitted, so a rejected hypothesis reached the proposal queue through a side
         # door -- the exact bypass the opt-in gate exists to prevent.
         admitted_intents: list[EvolutionIntent] = []
+        # capability -> the observation ids that motivated it, so a queued proposal can
+        # carry the evidence back to the causal ledger instead of minting a fresh id
+        # the ledger cannot join.
+        obs_by_capability: dict[str, list[str]] = {}
         for intent in intents:
             try:
                 record = self._intake.observe_result(
@@ -250,6 +312,9 @@ async def drive(
                 if observation_id:
                     admitted.append(observation_id)
                     admitted_intents.append(intent)
+                    obs_by_capability.setdefault(intent.capability, []).append(
+                        observation_id
+                    )
 
         requirements: tuple[CapabilityRequirement, ...] = ()
         if admitted:
@@ -263,6 +328,9 @@ async def drive(
                 "'world_model_intent' to accepted_evidence_kinds to enable",
                 len(intents),
             )
+        queued, unauthorised = self._govern(
+            admitted_intents, requirements, environment, obs_by_capability, degraded
+        )
         result = WorldModelDriveResult(
             grades=grades,
             verdicts=verdicts,
@@ -270,15 +338,96 @@ async def drive(
             intents=intents,
             admitted_observation_ids=tuple(admitted),
             requirements=requirements,
-            queued_proposal_ids=(
-                self._queue_proposals(admitted_intents, degraded)
-                if admitted_intents
-                else ()
-            ),
+            queued_proposal_ids=queued,
+            unauthorised=unauthorised,
         )
         self._trace_drive(result)
         return result
 
+    def _govern(
+        self,
+        admitted_intents: Sequence[EvolutionIntent],
+        requirements: Sequence[CapabilityRequirement],
+        environment: Any,
+        obs_by_capability: Mapping[str, Sequence[str]],
+        degraded: Sequence[Mapping[str, Any]],
+    ) -> tuple[tuple[str, ...], tuple[str, ...]]:
+        """Turn admitted hypotheses into queued proposals, gated by authority.
+
+        One gate stands between an admitted hypothesis and a queued proposal, and it
+        records its rejections rather than dropping them: a requirement whose origin
+        ``authorising_origins`` does not permit is retired with ``origin_not_authorised``
+        -- the executable form of "only the world model may drive acquisition".
+
+        There is deliberately no second, declared-fitness resolution-first gate here.
+        Rebind-vs-acquire -- whether an installed provider already covers the capability
+        in this environment -- is decided upstream by the teacher, which reasons from
+        failed-outcome hindsight and the alternatives it was shown. A declared-fitness
+        re-check would count a behaviourally broken but structurally present incumbent as
+        "satisfied" and suppress exactly the semantic-regression acquire the world model
+        exists to catch, so the acquire verdict is trusted as the resolution result.
+
+        Only what survives authority is queued, and the scope is this session's admitted
+        intents -- they are by construction what this episode produced, so a stale
+        requirement from an earlier episode cannot be re-queued here. The proposal is
+        built from the intent itself (``proposal_from_evolution_intent``), so queueing
+        deliberately does not wait on the store having derived a requirement row: an
+        intersection with the requirement backlog silently made acquisition depend on
+        store thresholds and dropped every proposal when the backlog was empty.
+        """
+        if not admitted_intents:
+            return (), ()
+        capabilities = tuple(
+            sorted({str(getattr(i, "capability", "")) for i in admitted_intents} - {""})
+        )
+        # Everything this driver admits is world-model-authored, so authority is a
+        # single question about that origin rather than a per-requirement lookup.
+        if not self._origin_authorised(WORLD_MODEL_ORIGIN):
+            for capability in capabilities:
+                self._record_no_op(capability, "origin_not_authorised")
+            return (), capabilities
+
+        queued = self._queue_proposals(
+            list(admitted_intents),
+            degraded,
+            obs_by_capability,
+            environment,
+        )
+        return queued, ()
+
+    def _origin_authorised(self, origin: str) -> bool:
+        """Whether ``authorising_origins`` permits this origin to drive acquisition.
+
+        Empty ``authorising_origins`` is unrestricted, so everything is authorised --
+        the shipped default. The check is the same ``origin_may_authorise`` the
+        resolution-first gap gate uses on the observation path, so the driver and the
+        loop cannot disagree about who may authorise an acquisition.
+        """
+        if not self._authorising_origins:
+            return True
+        from leapflow.learning.outcome_governance_feed import origin_may_authorise
+
+        return bool(origin_may_authorise(origin, self._authorising_origins))
+
+    def _record_no_op(self, capability: str, reason: str) -> None:
+        """Retire a capability's evidence as a durable no-op, and trace why.
+
+        A no-op branch is a first-class result: it is *why the framework did not
+        change*. Retiring the observation with a reason makes it reconstructable from
+        the store (the ledger reads observation status), and the trace makes it visible
+        on the board. Contained: bookkeeping a no-op must never fail the session.
+        """
+        resolver = getattr(self._intake, "resolve_capability", None)
+        if callable(resolver):
+            try:
+                resolver(capability, reason=reason)
+            except Exception:  # noqa: BLE001 - retirement is advisory
+                logger.debug(
+                    "world_model_driver: could not retire %s (%s)",
+                    capability, reason, exc_info=True,
+                )
+        self._trace_no_op(capability, reason)
+
     def _distil(self, verdicts: Any, environment: Any) -> tuple[str, ...]:
         """Persist what each verdict concluded, returning the capabilities recorded.
 
@@ -387,14 +536,20 @@ def _queue_proposals(
         self,
         admitted_intents: Sequence[EvolutionIntent],
         degraded: Sequence[Mapping[str, Any]] = (),
+        obs_by_capability: Mapping[str, Sequence[str]] | None = None,
+        environment: Any = None,
     ) -> tuple[str, ...]:
-        """Turn *admitted* intents into queued proposals, if a sink is installed.
+        """Turn *unmet* intents into queued proposals, if a sink is installed.
+
+        Takes only the intents that survived the authority and resolution-first gates,
+        never the full admitted set: an intent the operator has not opted into, or one
+        the catalog already satisfies, must not become a queued acquisition by a side
+        door. The proposal itself mutates nothing -- generation and installation remain
+        separately approval-gated -- so queueing is the last *observation-only* step.
 
-        Takes only the intents the evidence gate accepted, never the full set: an
-        intent the operator has not opted into must not become a queued acquisition by
-        a side door. The proposal itself mutates nothing -- generation and installation
-        remain separately approval-gated -- so queueing is the last *observation-only*
-        step.
+        The motivating ``observation_ids`` and the task ``environment`` travel with the
+        proposal so the causal ledger can join a queued acquisition back to the evidence
+        that produced it, rather than facing a proposal minted from nowhere.
 
         An intent whose capability appears in ``degraded`` is queued as a *rival* to the
         named incumbent rather than as a gap fill. That is a factual lookup against the
@@ -408,6 +563,7 @@ def _queue_proposals(
         """
         if self._proposal_sink is None or not admitted_intents:
             return ()
+        obs_map = {k: tuple(v) for k, v in dict(obs_by_capability or {}).items()}
         incumbents = {
             str(item.get("capability") or ""): str(item.get("plugin_id") or "")
             for item in degraded or ()
@@ -428,13 +584,55 @@ def _queue_proposals(
                     risk_ceiling=self._risk_ceiling,
                     incumbent=incumbents.get(str(getattr(intent, "capability", "")), ""),
                 )
-                identifier = self._proposal_sink(proposal)
+                extra: dict[str, Any] = {}
+                if "observation_ids" in self._sink_kwargs:
+                    extra["observation_ids"] = obs_map.get(
+                        str(getattr(intent, "capability", "")), ()
+                    )
+                if "environment" in self._sink_kwargs:
+                    extra["environment"] = environment
+                identifier = self._proposal_sink(proposal, **extra)
+            except _INTERNAL_DEFECTS:
+                # A wiring fault, not a bad intent: the sink or the detector was called
+                # wrongly. Logged loudly because the loop continues -- at debug level
+                # this exact case hid a regression that silently disabled queueing.
+                logger.warning(
+                    "world_model_driver: proposal sink rejected the call for %r; "
+                    "acquisition not queued",
+                    getattr(intent, "capability", ""),
+                    exc_info=True,
+                )
+                continue
             except Exception:  # noqa: BLE001 - one bad intent must not stop the rest
                 logger.debug("world_model_driver: proposal not queued", exc_info=True)
                 continue
             queued.append(str(identifier or getattr(proposal, "proposal_id", "")))
         return tuple(q for q in queued if q)
 
+    def _trace_no_op(self, capability: str, reason: str) -> None:
+        """Emit the no-op branch as a first-class evolution fact.
+
+        An unauthorised requirement is *why the framework did not change*, which the
+        co-evolution contract requires to be as visible as why it did. Emitting it here
+        means the board can distinguish "the world model saw a gap it was not permitted
+        to act on" from "the world model saw nothing".
+        """
+        try:
+            from leapflow.domain.evolution_trace import EvolutionStage
+            from leapflow.telemetry.evolution_tap import emit_trace, is_enabled
+
+            if not is_enabled():
+                return
+            emit_trace(
+                EvolutionStage.DECIDE,
+                "world_model_no_op",
+                correlation={"capability": str(capability)},
+                summary=f"{capability}: {reason}",
+                detail={"capability": str(capability), "reason": str(reason)},
+            )
+        except Exception:  # noqa: BLE001 - the teacher is advisory; telemetry more so
+            logger.debug("world_model_driver: no-op trace failed", exc_info=True)
+
     def _trace_drive(self, result: WorldModelDriveResult) -> None:
         """Emit what the teacher concluded, admitted or not.
 
@@ -482,6 +680,7 @@ def _trace_drive(self, result: WorldModelDriveResult) -> None:
                     "intents": [self._intent_detail(i) for i in intents],
                     "admitted_observation_ids": list(admitted),
                     "queued_proposal_ids": list(result.queued_proposal_ids),
+                    "unauthorised": list(result.unauthorised),
                     "graded": len(result.grades),
                     "requirements": len(result.requirements),
                     "not_admitted_reason": (
diff --git a/src/leapflow/llm/openai_provider.py b/src/leapflow/llm/openai_provider.py
index 0392789b..4edf53a1 100644
--- a/src/leapflow/llm/openai_provider.py
+++ b/src/leapflow/llm/openai_provider.py
@@ -138,8 +138,17 @@ def __init__(
             write=30.0,
             pool=30.0,
         )
-        self._sync = OpenAI(api_key=api_key, base_url=base_url, timeout=timeout)
-        self._async = AsyncOpenAI(api_key=api_key, base_url=base_url, timeout=timeout)
+        # ``max_retries=0`` is load-bearing: the SDK retries twice by default, and this
+        # class already owns a retry policy with backoff. Leaving the SDK's default in
+        # place multiplies them -- effective attempts become ``max_retries * 3`` and a
+        # hard timeout blocks for three times the configured budget before surfacing,
+        # which breaks the turn-level deadline and recovery-budget accounting that
+        # assume ``timeout_s`` bounds one attempt. Measured: a 45s timeout failed after
+        # 137s. One retry owner, and it is this class.
+        self._sync = OpenAI(api_key=api_key, base_url=base_url, timeout=timeout, max_retries=0)
+        self._async = AsyncOpenAI(
+            api_key=api_key, base_url=base_url, timeout=timeout, max_retries=0
+        )
         self._model = model
         self._max_retries = max(1, int(max_retries))
         self._base_url = base_url
diff --git a/src/leapflow/monitor/evolution_producer.py b/src/leapflow/monitor/evolution_producer.py
index b90b4d9c..541bfaad 100644
--- a/src/leapflow/monitor/evolution_producer.py
+++ b/src/leapflow/monitor/evolution_producer.py
@@ -121,6 +121,13 @@ def _percent(value: Any) -> str:
 UNVERIFIABLE = "unverifiable"
 NOT_ADMITTED = "not_admitted"
 
+# Acquisition-lifecycle states a record is *created* in. Anything else is proof
+# that something read the queue back and advanced it, which is what distinguishes a
+# governed queue from a write-only one. Kept as a set of entry states rather than a
+# list of advanced ones so a new terminal state cannot silently read as "not yet
+# governed" (see storage.capability_proposal_queue.ProposalStatus).
+_LIFECYCLE_ENTRY_STATES = frozenset({"PENDING", "UNKNOWN", ""})
+
 
 class EvolutionProducer:
     """Emit one framework-evolution snapshot per cycle."""
@@ -993,7 +1000,19 @@ def _segment_observations(self, store: Any) -> dict[str, Any]:
         )
 
     def _segment_lifecycle(self) -> dict[str, Any]:
-        """Whether the trust/probation/quarantine tier has anything to govern."""
+        """Whether the trust/probation/quarantine tier is actually governing.
+
+        A non-empty queue used to be reported ``wired``, which read as the healthy
+        class beside a genuinely healthy ``Trust accrual``. On a real profile that
+        was 212 records, every one of them ``PENDING``, none carrying a policy
+        decision or install result, all of them written by ``plugin_propose`` and
+        nothing draining them: a monotonically growing dead end presented as a
+        working segment.
+
+        So the evidence is a *transition*, not a row count. Records existing prove
+        the queue is writable; a record past ``PENDING`` proves something reads it
+        back and advances it, which is the only thing this segment claims to check.
+        """
         store = self._json_store("capability_proposal_queue_path", "capability_proposal_queue", "JsonCapabilityProposalQueue")
         if store is None:
             return self._row("lifecycle", "Lifecycle records", UNVERIFIABLE, "queue unreadable")
@@ -1008,7 +1027,25 @@ def _segment_lifecycle(self) -> dict[str, Any]:
                 status = str(getattr(item, "status", "") or "unknown")
                 counts[status] = counts.get(status, 0) + 1
             spread = ", ".join(f"{k}={v}" for k, v in sorted(counts.items()))
-            return self._row("lifecycle", "Lifecycle records", WIRED, spread)
+            advanced = sum(
+                count for status, count in counts.items()
+                if status.upper() not in _LIFECYCLE_ENTRY_STATES
+            )
+            if advanced:
+                return self._row("lifecycle", "Lifecycle records", WIRED, spread)
+            # Entry state only. The queue is written but never read back, so the
+            # governor is not running -- and the row says which way the count grows.
+            return self._row(
+                "lifecycle",
+                "Lifecycle records",
+                NO_EVIDENCE,
+                spread,
+                next_step=(
+                    f"{len(items)} record(s) have never left their entry state, so nothing "
+                    "reads the queue back. The governor advances a record only when the "
+                    "co-evolution sweep runs; until then the queue only grows."
+                ),
+            )
         return self._row(
             "lifecycle",
             "Lifecycle records",
diff --git a/src/leapflow/monitor/manager.py b/src/leapflow/monitor/manager.py
index 1c8227de..38355ab1 100644
--- a/src/leapflow/monitor/manager.py
+++ b/src/leapflow/monitor/manager.py
@@ -356,6 +356,13 @@ async def run_watch_once(self, watch_id: str, *, force: bool = False) -> dict:
         Bypasses the tick timer while reusing the same producer -> persist ->
         push path, so a user-triggered refresh is identical to a scheduled one.
         ``force=True`` signals producers to re-analyze even without new input.
+
+        Run bookkeeping is applied here because it is the scheduler that normally
+        does it, and this path deliberately skips the scheduler. Without it a manual
+        refresh left no trace at all: findings dedup on content, so a cycle that
+        confirmed "nothing changed" wrote nothing and advanced nothing, and the board
+        could not tell a refresh that ran from one that never happened -- which is
+        precisely what a reader presses refresh to find out.
         """
         task = self._task_store.load(watch_id)
         if task is None or not _is_watch(task):
@@ -364,7 +371,15 @@ async def run_watch_once(self, watch_id: str, *, force: bool = False) -> dict:
         params.setdefault("watch_id", task.task_id)
         if force:
             params["_force"] = True
-        return await self._executor.execute(task.skill_name, params)
+        result = await self._executor.execute(task.skill_name, params)
+        # After the cycle, not before: ``last_run_at`` means "a cycle completed",
+        # and a producer that raised did not complete one.
+        if isinstance(result, dict) and result.get("ok"):
+            try:
+                self._task_store.increment_run_count(task.task_id)
+            except Exception:  # noqa: BLE001 - bookkeeping must not fail the refresh
+                logger.debug("monitor: run bookkeeping failed for %s", watch_id, exc_info=True)
+        return result
 
     def schedule_watch_once(self, watch_id: str, *, force: bool = False) -> None:
         """Fire one observation cycle in the background (non-blocking).
@@ -398,6 +413,7 @@ def _transition(self, watch_id: str, state: str) -> Optional[WatchView]:
     def _to_view(self, task: ArmedTask) -> WatchView:
         meta = task.metadata if isinstance(task.metadata, dict) else {}
         params = task.parameters if isinstance(task.parameters, dict) else {}
+        cfg = task.trigger_config if isinstance(task.trigger_config, dict) else {}
         return WatchView(
             watch_id=task.task_id,
             name=str(params.get("name") or task.task_id[:8]),
@@ -410,6 +426,15 @@ def _to_view(self, task: ArmedTask) -> WatchView:
             last_run_at=task.last_run_at,
             finding_count=self._finding_store.count(watch_id=task.task_id),
             client_coupled=bool(meta.get(METADATA_CLIENT_COUPLED_KEY, False)),
+            # Only an interval trigger has one. Left at 0.0 for event, cron and
+            # condition watches, which the board reads as "no cadence to judge
+            # against" and so withholds a staleness verdict rather than inventing
+            # an interval for a watch that does not have one.
+            interval_seconds=(
+                float(cfg.get("interval_seconds", 0) or 0)
+                if task.trigger_type == "interval"
+                else 0.0
+            ),
         )
 
     def _emit_state(self, task: ArmedTask) -> None:
diff --git a/src/leapflow/monitor/types.py b/src/leapflow/monitor/types.py
index 1618c92a..3dcc5467 100644
--- a/src/leapflow/monitor/types.py
+++ b/src/leapflow/monitor/types.py
@@ -266,6 +266,12 @@ class WatchView:
     last_run_at: float
     finding_count: int = 0
     client_coupled: bool = False
+    # Declared cadence in seconds, 0.0 for a watch with no fixed one (event, cron,
+    # condition). Exposed because the board judges its own freshness against it: a
+    # page two cadences past its last observation is stale, and only the watch knows
+    # what one cadence is. Deriving it from ``next_due_at - last_run_at`` was the
+    # alternative and is wrong after a skipped or forced run.
+    interval_seconds: float = 0.0
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -280,6 +286,7 @@ def to_dict(self) -> dict[str, Any]:
             "last_run_at": self.last_run_at,
             "finding_count": self.finding_count,
             "client_coupled": self.client_coupled,
+            "interval_seconds": self.interval_seconds,
         }
 
 
diff --git a/src/leapflow/plugins/tool_plugins/self_management.py b/src/leapflow/plugins/tool_plugins/self_management.py
index 826e4971..2a519ce8 100644
--- a/src/leapflow/plugins/tool_plugins/self_management.py
+++ b/src/leapflow/plugins/tool_plugins/self_management.py
@@ -590,12 +590,16 @@ async def _plugin_generate_handler(
         the LLM generates conformant plugin code, and it's rigorously validated.
         Installation is a SEPARATE approval-gated step (plugin_install).
         """
+        provides_capabilities: tuple[str, ...] = ()
+        source = ""
         if proposal_id:
-            proposal = self._proposal_store().get(proposal_id)
-            if proposal is None:
+            source, resolved_plugin_id, resolved_description, provides_capabilities = (
+                self._resolve_generation_source(proposal_id)
+            )
+            if not source:
                 return {"ok": False, "error": f"Plugin proposal '{proposal_id}' not found"}
-            plugin_id = plugin_id or proposal.plugin_id
-            description = description or proposal.capability_summary
+            plugin_id = plugin_id or resolved_plugin_id
+            description = description or resolved_description
         if not plugin_id or not description:
             return {
                 "ok": False,
@@ -631,17 +635,83 @@ async def _plugin_generate_handler(
             request = PluginGenerationRequest(
                 plugin_id=plugin_id,
                 description=description,
-                provides_capabilities=_declared_capabilities(proposal if proposal_id else None),
+                provides_capabilities=provides_capabilities,
             )
             result = await generator.generate_and_validate(request)
             if proposal_id:
                 result["proposal_id"] = proposal_id
                 if result.get("ok"):
-                    self._proposal_store().update_status(proposal_id, "review")
+                    self._mark_generation_started(source, proposal_id)
             return result
         except (AttributeError, RuntimeError) as exc:
             return {"ok": False, "error": f"Generation failed: {exc}"}
 
+    def _resolve_generation_source(
+        self, proposal_id: str
+    ) -> tuple[str, str, str, tuple[str, ...]]:
+        """Resolve a generation request from *either* proposal store.
+
+        Two stores can name a proposal, and both must reach generation:
+
+        * the **review store** (``JsonPluginProposalStore``) holds a rich
+          ``PluginProposal`` created by the manual ``plugin_propose`` UX flow;
+        * the **lifecycle queue** (``JsonCapabilityProposalQueue``) holds the
+          acquisition record the world-model driver enqueues -- a
+          ``prop-<hash>`` id keyed on the requirement, carrying the capability,
+          the ``plugin_id`` the sink stamped, and the hypothesis as its summary.
+
+        Before this, ``plugin_generate`` looked only in the review store, so a
+        world-model proposal could never be generated from its own id: Scene C could
+        not proceed from a real teacher verdict to a validated artifact. Returning a
+        normalised ``(source, plugin_id, description, provides_capabilities)`` unifies
+        the two consumption points without collapsing their distinct lifecycle
+        vocabularies. ``source`` is ``""`` when neither store knows the id.
+        """
+        review = self._proposal_store().get(proposal_id)
+        if review is not None:
+            return (
+                "review",
+                str(review.plugin_id),
+                str(review.capability_summary),
+                _declared_capabilities(review),
+            )
+        try:
+            item = self._lifecycle_store().get(proposal_id)
+        except (RuntimeError, OSError, ValueError, AttributeError):
+            item = None
+        if item is not None:
+            requirements = [dict(r) for r in (item.requirements or ())]
+            capability = str((requirements[0].get("capability") if requirements else "") or "")
+            metadata = dict(item.metadata or {})
+            plugin_id = str(metadata.get("plugin_id") or "")
+            description = str(
+                metadata.get("capability_summary")
+                or (requirements[0].get("evidence") if requirements else "")
+                or capability
+            )
+            provides = (capability,) if capability else ()
+            return ("lifecycle", plugin_id, description, provides)
+        return ("", "", "", ())
+
+    def _mark_generation_started(self, source: str, proposal_id: str) -> None:
+        """Advance the proposal's status in whichever store owns it.
+
+        The two stores speak different vocabularies on purpose (see
+        ``evolution_contracts``): the review store moves to ``review`` (a human-accept
+        state), the lifecycle queue to ``GENERATED`` (an acquisition-lifecycle state
+        ``AdaptiveEvolutionPolicy`` reads next). Contained: a status write must not fail
+        a generation that already succeeded.
+        """
+        try:
+            if source == "review":
+                self._proposal_store().update_status(proposal_id, "review")
+            elif source == "lifecycle":
+                self._lifecycle_store().update(proposal_id, status="GENERATED")
+        except (RuntimeError, OSError, ValueError, AttributeError):
+            logger.debug(
+                "plugin_generate: could not advance %s status", proposal_id, exc_info=True
+            )
+
     # ── Compatibility assessment (read-only) ─────────────────
 
     async def _assess_compatibility_handler(
diff --git a/src/leapflow/storage/capability_proposal_queue.py b/src/leapflow/storage/capability_proposal_queue.py
index d8f3d28f..84648857 100644
--- a/src/leapflow/storage/capability_proposal_queue.py
+++ b/src/leapflow/storage/capability_proposal_queue.py
@@ -115,7 +115,7 @@ def enqueue(
     ) -> CapabilityProposalItem:
         """Create or return an active proposal for the requirement/environment pair."""
         req_payload = tuple(_requirement_dict(item) for item in requirements)
-        proposal_id = self._proposal_id(req_payload, environment or {}, observation_ids)
+        proposal_id = self._proposal_id(req_payload, environment or {})
         existing = self.get(proposal_id)
         if existing is not None and existing.status in _ACTIVE_STATUSES:
             return existing
@@ -203,9 +203,11 @@ def list_items(
         return items if limit <= 0 else items[:limit]
 
     def active(self, *, limit: int = 50) -> list[CapabilityProposalItem]:
-        return [item for item in self.list_items(limit=0) if item.status in _ACTIVE_STATUSES][
-            :limit
-        ]
+        # ``limit <= 0`` means "all", matching ``list_items``. Slicing ``[:limit]``
+        # unconditionally made ``active(limit=0)`` return an empty list -- the opposite
+        # of "no cap" -- which silently emptied any caller that asked for the full set.
+        items = [item for item in self.list_items(limit=0) if item.status in _ACTIVE_STATUSES]
+        return items if limit <= 0 else items[:limit]
 
     def _upsert(self, item: CapabilityProposalItem) -> None:
         payload = self._load_payload()
@@ -219,16 +221,40 @@ def _proposal_id(
         self,
         requirements: Sequence[Mapping[str, Any]],
         environment: Mapping[str, Any],
-        observation_ids: Sequence[str],
     ) -> str:
+        """A content id over *stable identity only*, so dedup survives rewording.
+
+        Hashing the whole requirement payload made the id a function of the free-text
+        ``evidence`` (the world model's hypothesis) and its metadata, so the same
+        capability re-proposed with different wording every session minted a fresh id
+        and the queue filled with duplicates -- the health of the queue then measured
+        how long the process had run rather than how many real gaps existed. Identity is
+        what a requirement *is* (its id, capability, origin, risk ceiling and platform
+        needs) plus the environment fingerprint it was raised in; the prose that
+        justifies it is not identity. ``observation_ids`` are carried on the item for
+        the causal ledger but deliberately excluded here: two profiles observing the
+        same gap mint different observation ids, and folding those into identity would
+        defeat dedup for the very case it exists to collapse.
+        """
+        identity = [
+            {
+                "requirement_id": str(item.get("requirement_id") or ""),
+                "capability": str(item.get("capability") or ""),
+                "origin": str(item.get("origin") or ""),
+                "max_risk_level": str(item.get("max_risk_level") or ""),
+                "required_platform_capabilities": sorted(
+                    str(cap) for cap in (item.get("required_platform_capabilities") or [])
+                ),
+            }
+            for item in requirements
+        ]
         material = {
-            "requirements": [dict(item) for item in requirements],
+            "identity": identity,
             "environment": {
                 "fingerprint_id": environment.get("fingerprint_id", ""),
                 "platform_capabilities": environment.get("platform_capabilities", []),
                 "workspace_markers": environment.get("workspace_markers", []),
             },
-            "observation_ids": sorted(str(item) for item in observation_ids),
         }
         text = json.dumps(material, sort_keys=True, ensure_ascii=False, default=str)
         import hashlib
diff --git a/src/leapflow/telemetry/evolution_presentation.py b/src/leapflow/telemetry/evolution_presentation.py
new file mode 100644
index 00000000..60a11901
--- /dev/null
+++ b/src/leapflow/telemetry/evolution_presentation.py
@@ -0,0 +1,91 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Read-only presentation projection for one runtime evolution trace.
+
+The projection is intentionally smaller than :class:`EvolutionTrace`: it carries
+only the stable identifiers and labels a live display needs. It is created after a
+trace has been buffered, then published from the daemon event loop. It never
+persists, approves, selects, or mutates anything.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+from leapflow.domain.evolution_trace import EvolutionTrace
+
+
+@dataclass(frozen=True)
+class EvolutionPresentationEvent:
+    """One safe, display-oriented view of a runtime evolution fact."""
+
+    event_id: str
+    episode_id: str
+    stage: str
+    kind: str
+    ts: float
+    correlation: Mapping[str, str]
+    payload_ref: Mapping[str, str]
+    summary: str
+    evidence_level: str
+    verification_tier: str
+    side_effect_state: str
+
+    @classmethod
+    def from_trace(cls, trace: EvolutionTrace) -> "EvolutionPresentationEvent":
+        """Project a trace without exposing its unbounded domain-private detail."""
+        correlation = {str(key): str(value) for key, value in trace.correlation.items() if str(value)}
+        detail = dict(trace.detail)
+        episode_id = (
+            correlation.get("record_id")
+            or correlation.get("intent_id")
+            or correlation.get("requirement_id")
+            or correlation.get("observation_id")
+            or correlation.get("lifecycle_proposal_id")
+            or trace.trace_id
+        )
+        payload_ref = {
+            key: value
+            for key, value in correlation.items()
+            if key in {
+                "record_id",
+                "intent_id",
+                "requirement_id",
+                "observation_id",
+                "lifecycle_proposal_id",
+                "plugin_id",
+                "registry_version",
+            }
+        }
+        return cls(
+            event_id=trace.trace_id,
+            episode_id=episode_id,
+            stage=trace.stage.value,
+            kind=trace.kind,
+            ts=trace.ts,
+            correlation=correlation,
+            payload_ref=payload_ref,
+            summary=trace.summary,
+            evidence_level=str(detail.get("evidence_level") or "runtime_trace"),
+            verification_tier=str(detail.get("verification_tier") or "not_recorded"),
+            side_effect_state=str(detail.get("side_effect_state") or "not_recorded"),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the JSON-safe event shape delivered to display clients."""
+        return {
+            "event_id": self.event_id,
+            "episode_id": self.episode_id,
+            "stage": self.stage,
+            "kind": self.kind,
+            "ts": self.ts,
+            "correlation": dict(self.correlation),
+            "payload_ref": dict(self.payload_ref),
+            "summary": self.summary,
+            "evidence_level": self.evidence_level,
+            "verification_tier": self.verification_tier,
+            "side_effect_state": self.side_effect_state,
+        }
+
+
+__all__ = ["EvolutionPresentationEvent"]
diff --git a/src/leapflow/version.py b/src/leapflow/version.py
index 441a47b0..bf3c1dd4 100644
--- a/src/leapflow/version.py
+++ b/src/leapflow/version.py
@@ -1,4 +1,4 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
 """Version information for leapflow."""
 
-__version__ = "0.2.1+main"
+__version__ = "0.3.0+main"
diff --git a/src/leapflow/world_model/prediction.py b/src/leapflow/world_model/prediction.py
index 6378fa58..3a83805c 100644
--- a/src/leapflow/world_model/prediction.py
+++ b/src/leapflow/world_model/prediction.py
@@ -16,6 +16,7 @@
 
 import logging
 import time
+from collections import deque
 from dataclasses import dataclass, replace
 from typing import TYPE_CHECKING, Any, Awaitable, Callable, Optional, Tuple
 
@@ -30,6 +31,12 @@
 
 logger = logging.getLogger(__name__)
 
+# Trajectory buffer ceiling. Sized for a long working session rather than a single
+# task: the teacher grades the whole arc, so cutting it too fine would hide the
+# early steps that explain a late failure. It exists to stop a long-lived daemon
+# growing without bound, not to scope one episode -- the learning boundary does that.
+_MAX_TRAJECTORY_STEPS = 2000
+
 _PREDICT_PROMPT = """\
 Given the current state:
 - App: {app_bundle_id} | Window: {window_title}
@@ -130,7 +137,14 @@ def __init__(
         self._failure_advantage = failure_advantage
         self._on_outcome = on_prediction_outcome
         self._hardware_learning_enabled = hardware_learning_enabled
-        self._trajectory_buffer: list[dict] = []
+        # Bounded, because the only thing that drains it is the learning boundary and
+        # in daemon mode that used to be process shutdown: an unbounded list then
+        # accumulated every turn of every session for the daemon's whole lifetime.
+        # A deque discards oldest-first, which is the right end to lose -- the
+        # teacher grades with hindsight, so the most recent steps carry the most
+        # signal, and a truncated tail is far better than unbounded growth in a
+        # long-lived process.
+        self._trajectory_buffer: deque[dict] = deque(maxlen=_MAX_TRAJECTORY_STEPS)
         self._last_goal: str = ""
         self._pending_pre_snapshot: Any = None
 
diff --git a/src/leapspace/app_space/actor.py b/src/leapspace/app_space/actor.py
index 53e75fd8..1e7df6d7 100644
--- a/src/leapspace/app_space/actor.py
+++ b/src/leapspace/app_space/actor.py
@@ -49,7 +49,7 @@
 from mcp.client.session import ClientSession
 from mcp.client.streamable_http import streamable_http_client
 
-from leapspace.app_space.utils import (
+from leapspace.app_space.state import (
     CUA_MCP_PORT,
     LINUX_LEAPFLOW_SRC,
     get_actor_stage_dir,
diff --git a/src/leapspace/app_space/apps/_base.py b/src/leapspace/app_space/apps/_base.py
index 9c6f9b31..156fceb5 100644
--- a/src/leapspace/app_space/apps/_base.py
+++ b/src/leapspace/app_space/apps/_base.py
@@ -64,7 +64,7 @@
     QWidget,
 )
 
-from leapspace.app_space.utils import get_sandbox_state_dir, write_atomic
+from leapspace.app_space.state import get_sandbox_state_dir, write_atomic
 
 # Widget types an agent may act on; self-check requires each to be named.
 INTERACTIVE_TYPES: tuple[type[QWidget], ...] = (
@@ -94,6 +94,16 @@ class BaseLeapApp(QMainWindow, ABC, metaclass=_LeapAppMeta):
     app_title: ClassVar[str]
     version: ClassVar[str]
 
+    # App-level affordances this version of the surface offers, e.g.
+    # ``("app.chat.v2",)``. Declared, never inferred: a capability provider states
+    # which affordances it needs (``requires_environment_affordances``) and the
+    # resolver excludes one the environment does not offer, so this is the channel
+    # that lets an app version express "the way to do this changed". Deliberately
+    # separate from *host* platform capabilities -- an app affordance is a property
+    # of the surface, not of the machine. Empty by default: an app that models no
+    # affordance simply says nothing.
+    affordances: ClassVar[tuple[str, ...]] = ()
+
     # Hook points this app opens to task hooks; apps extend with their own
     # before_xxx/after_xxx points (a superset tuple, always keeping
     # "before_launch" — the base fires it in the template below).
@@ -367,6 +377,18 @@ def _persist(self) -> None:
             "app_title": self.app_title,
             "version": self.version,
             "interface": sorted(self._interface),
+            # App-level affordances this version declares (see the ClassVar). Part of
+            # the ground truth because an environment probe compares them across
+            # versions to tell an affordance migration from a pure rename.
+            "affordances": list(type(self).affordances),
+            # Role-aware structural view of the bound interface, derived from the
+            # live widget tree (not the declared name list). This is the AX-like
+            # signal LeapFlow's perception reads to tell one control from another
+            # and to name *which* element changed -- a renamed or removed control
+            # shows up here as a changed role/name set, which a bare name list can
+            # show only as "the set changed". Additive: consumers that read only
+            # ``interface`` are unaffected.
+            "elements": self._structure(),
             "a11y_violations": list(self._violations),
             "data": self._snapshot_data(),
         }
@@ -379,3 +401,24 @@ def _persist(self) -> None:
             self._state_dir / "events.jsonl",
             "".join(json.dumps(event) + "\n" for event in self._events),
         )
+
+    def _structure(self) -> list[dict[str, Any]]:
+        """Role-aware view of the bound interface: ``[{name, role, enabled}]``.
+
+        ``role`` is the Qt widget class (``QPushButton``, ``QLineEdit``, ...), the
+        closest headless analogue of an accessibility role. Derived from the live
+        widget objects ``bind`` recorded, so it tracks the real UI rather than a
+        declaration. Each widget read is guarded: a persist during teardown (the
+        C++ object already gone) must degrade to a stable placeholder, never crash
+        the ground-truth write.
+        """
+        structure: list[dict[str, Any]] = []
+        for name in sorted(self._interface):
+            widget = self._interface[name]
+            try:
+                role = type(widget).__name__
+                enabled = bool(widget.isEnabled())
+            except RuntimeError:
+                role, enabled = "QWidget", True
+            structure.append({"name": name, "role": role, "enabled": enabled})
+        return structure
diff --git a/src/leapspace/app_space/harness.py b/src/leapspace/app_space/harness.py
index 152844c4..8824eb1f 100644
--- a/src/leapspace/app_space/harness.py
+++ b/src/leapspace/app_space/harness.py
@@ -29,9 +29,9 @@
     RECORD_START_FILE,
     RECORD_STOP_FILE,
 )
-from leapspace.app_space.utils import (
+from leapspace.app_space.image import get_image
+from leapspace.app_space.state import (
     LeapAppImage,
-    get_image,
     get_image_venv_python,
     get_sandbox_state_dir,
     load_action,
diff --git a/src/leapspace/app_space/host_rpc.py b/src/leapspace/app_space/host_rpc.py
new file mode 100644
index 00000000..40010614
--- /dev/null
+++ b/src/leapspace/app_space/host_rpc.py
@@ -0,0 +1,162 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""LeapSpaceHostRpc — serve LeapFlow's HostRpc from leapspace ground truth.
+
+EVO-02 LS-3. The missing adapter that lets the *shipped* LeapFlow perception
+(``StateSnapshotService``) observe a leapspace environment directly, instead of
+LeapFlow's snapshots being disconnected from the environment the apps actually
+render. It reads the ground truth ``BaseLeapApp`` already writes -- ``state.json``
+per app under the shared state root -- and answers the ``HostRpc`` method set
+LeapFlow calls (``ax.tree``, ``window.active``, ``clipboard.get``, ``app.list``).
+
+Design constraints (executable, not aspirational):
+
+* **Stdlib only, no host SDK.** It reads JSON files; it never imports
+  ``cua_sandbox``. So it runs headless -- an offscreen Qt app (or any producer of
+  the real envelope) writes ``state.json`` and LeapFlow observes it, on any host,
+  with no hypervisor.
+* **No LeapFlow import.** It satisfies the ``HostRpc`` Protocol structurally
+  (one ``async call`` method), keeping the dependency direction one-way: leapspace
+  never imports engine/registry/perception. The connection is a discoverable
+  adapter, which is what "Everything Is a Plugin" requires here.
+* **Never raises.** An unknown method or a missing/corrupt ``state.json`` returns
+  a structured empty result, matching how ``StateSnapshotService`` already treats
+  RPC facets that degrade -- an absent environment lowers fidelity, it does not
+  fail a turn.
+
+Pixels are deliberately absent (``screen.capture_frame`` returns ``{}``): a
+headless run has no framebuffer. The real-AX/pixel tier belongs to the VM lane
+where the CUA driver is present; this adapter delivers the structural + event
+signal that lane and this one share.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class LeapSpaceHostRpc:
+    """A ``HostRpc`` backed by the app state root a leapspace run writes to.
+
+    ``state_root`` is the directory holding one ``<app_id>/`` subdir per running
+    app (the ``get_sandbox_state_dir`` convention); each subdir carries the app's
+    atomically written ``state.json`` and ``events.jsonl``.
+    """
+
+    def __init__(self, state_root: Path | str) -> None:
+        self._root = Path(state_root)
+
+    async def call(self, method: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        """Answer one HostRpc method from the on-disk ground truth."""
+        params = dict(params or {})
+        if method == "ax.tree":
+            return self._ax_tree(str(params.get("app_id") or ""))
+        if method == "window.active":
+            return self._window_active()
+        if method == "clipboard.get":
+            # A leapspace app models no system clipboard; report empty rather
+            # than fabricate, so the snapshot's clipboard facet is honestly blank.
+            return {"text": ""}
+        if method == "app.list":
+            return {"apps": self._app_ids()}
+        if method == "screen.capture_frame":
+            # No framebuffer headless; the phash facet degrades to empty.
+            return {}
+        # Unknown method: structured, non-raising, matching the graceful-degrade
+        # contract every HostRpc caller in LeapFlow already assumes.
+        return {"error": "unsupported_method", "method": str(method)}
+
+    # ── ground-truth reads ────────────────────────────────────────────────
+
+    def _ax_tree(self, app_id: str) -> Dict[str, Any]:
+        """Structural element list for one app, in the shape ax.tree consumers read.
+
+        Prefers an enriched ``elements`` channel (role + name), which a
+        role-aware ``BaseLeapApp`` can emit; falls back to the always-present
+        ``interface`` names so the digest is meaningful even before that
+        enrichment lands. Either way a rename/removal changes the element set,
+        which is exactly the structural signal a hash-only ``ax_digest`` needs.
+        """
+        envelope = self._read_state(app_id) if app_id else self._read_active_state()
+        if not envelope:
+            return {"elements": []}
+        elements = _elements_from_envelope(envelope)
+        return {
+            "app_id": str(envelope.get("app_id") or ""),
+            "app_title": str(envelope.get("app_title") or ""),
+            "version": str(envelope.get("version") or ""),
+            "elements": elements,
+        }
+
+    def _window_active(self) -> Dict[str, Any]:
+        envelope = self._read_active_state()
+        if not envelope:
+            return {"app_id": "", "title": ""}
+        return {
+            "app_id": str(envelope.get("app_id") or ""),
+            "title": str(envelope.get("app_title") or ""),
+        }
+
+    def _app_ids(self) -> list[str]:
+        if not self._root.exists():
+            return []
+        return sorted(
+            child.name
+            for child in self._root.iterdir()
+            if child.is_dir()
+            and not child.name.startswith(".")
+            and (child / "state.json").exists()
+        )
+
+    def _read_state(self, app_id: str) -> Dict[str, Any]:
+        path = self._root / app_id / "state.json"
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError, TypeError, ValueError):
+            return {}
+        return data if isinstance(data, dict) else {}
+
+    def _read_active_state(self) -> Dict[str, Any]:
+        """The most recently modified app state -- the closest thing to focus.
+
+        A single-app run has exactly one; a multi-app run reports the one whose
+        ground truth changed last, which is the app the last action touched.
+        """
+        latest: tuple[float, Dict[str, Any]] | None = None
+        for app_id in self._app_ids():
+            path = self._root / app_id / "state.json"
+            try:
+                mtime = path.stat().st_mtime
+            except OSError:
+                continue
+            envelope = self._read_state(app_id)
+            if envelope and (latest is None or mtime > latest[0]):
+                latest = (mtime, envelope)
+        return latest[1] if latest is not None else {}
+
+
+def _elements_from_envelope(envelope: Dict[str, Any]) -> list[Dict[str, str]]:
+    """Project a state envelope into ``[{role, label}]`` for ax.tree consumers."""
+    raw = envelope.get("elements")
+    if isinstance(raw, list) and raw:
+        rendered: list[Dict[str, str]] = []
+        for item in raw:
+            if isinstance(item, dict):
+                label = str(item.get("name") or item.get("label") or "")
+                if label:
+                    rendered.append({"role": str(item.get("role") or "widget"), "label": label})
+        if rendered:
+            return rendered
+    # Fallback: the always-present interface names. Role is unknown headless, so
+    # it is reported uniformly; the label carries the identity a delta keys on.
+    interface = envelope.get("interface")
+    if isinstance(interface, list):
+        return [{"role": "widget", "label": str(name)} for name in interface if str(name)]
+    return []
+
+
+__all__ = ["LeapSpaceHostRpc"]
diff --git a/src/leapspace/app_space/image.py b/src/leapspace/app_space/image.py
new file mode 100644
index 00000000..521606d4
--- /dev/null
+++ b/src/leapspace/app_space/image.py
@@ -0,0 +1,78 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Host-only leapspace image construction.
+
+This is the half of the former ``utils.py`` that must import the host SDK
+(``cua_sandbox``). It is kept strictly separate from ``state.py`` (EVO-02 LS-1)
+so that importing the in-box verdict, the pure state helpers, or the PyQt6 apps
+never drags in ``cua_sandbox`` -- the coupling that made a headless/off-sandbox
+run impossible. Only the harness (which already needs the sandbox to boot a VM)
+imports this module.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+from cua_sandbox import Image
+
+from leapspace.app_space.state import (
+    CUA_MCP_PORT,
+    LEAPFLOW_ARCHIVE_DST,
+    LINUX_LEAPFLOW_PATH,
+    PYQT_SYSTEM_LIBS,
+    LeapAppImage,
+)
+
+
+def _archive_checkout() -> Path:
+    """Pack this checkout's committed state for the image to copy in.
+
+    The build VM reaches GitHub only through the host's flaky link, so the
+    repo travels as a host-built archive: no in-box clone, and the box runs
+    exactly the code under test (HEAD, not some remote ref).
+    """
+    repo_root = Path(__file__).resolve().parents[3]
+    fd, name = tempfile.mkstemp(suffix=".tar.gz")
+    os.close(fd)
+    result = subprocess.run(
+        ["git", "archive", "--format=tar.gz", "-o", name, "HEAD"],
+        cwd=repo_root,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f"git archive failed: {result.stderr.strip()}")
+    return Path(name)
+
+
+def get_image(image: LeapAppImage) -> Image:
+    """Return the preset image spec, rooted in an archive of this checkout.
+
+    Image is frozen and chainable -- every mutation returns a new instance --
+    so callers get a fresh spec (and a fresh archive) per run. needrestart
+    is removed before apt: installing python3-dev upgrades service
+    libraries, and needrestart's service restarts SIGTERM the layer's own
+    command transport. Host feasibility: LINUX runs under local QEMU+KVM;
+    WINDOWS is untested; MACOS requires an Apple Silicon host (Lume).
+    """
+    archive = _archive_checkout()
+    if image == LeapAppImage.LINUX:
+        return (
+            Image.linux(distro="ubuntu", version="24.04", kind="vm")
+            .expose(CUA_MCP_PORT)
+            .run("sudo apt-get remove -y needrestart")
+            .apt_install("python3-pyatspi", "python3-dev", *PYQT_SYSTEM_LIBS, "git", "make")
+            .pip_install("PyQt6", "uv")
+            .copy(str(archive), LEAPFLOW_ARCHIVE_DST)
+            .run(
+                f"mkdir -p {LINUX_LEAPFLOW_PATH} && "
+                f"tar xzf {LEAPFLOW_ARCHIVE_DST} -C {LINUX_LEAPFLOW_PATH} && "
+                f"rm {LEAPFLOW_ARCHIVE_DST}"
+            )
+            .run(f"cd {LINUX_LEAPFLOW_PATH} && make space-sync")
+        )
+    else:
+        raise NotImplementedError(f"image preset not defined for {image}")
diff --git a/src/leapspace/app_space/signal.py b/src/leapspace/app_space/signal.py
index c12198d0..0f103eba 100644
--- a/src/leapspace/app_space/signal.py
+++ b/src/leapspace/app_space/signal.py
@@ -17,7 +17,7 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-from leapspace.app_space.utils import write_atomic
+from leapspace.app_space.state import write_atomic
 
 if TYPE_CHECKING:
     from leapflow.analysis.intent_inferrer import InferenceResult
diff --git a/src/leapspace/app_space/utils.py b/src/leapspace/app_space/state.py
similarity index 68%
rename from src/leapspace/app_space/utils.py
rename to src/leapspace/app_space/state.py
index 3e87dc91..7531e2c2 100644
--- a/src/leapspace/app_space/utils.py
+++ b/src/leapspace/app_space/state.py
@@ -1,18 +1,24 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
-"""Shared leapspace helpers: image presets, the state-dir convention, and
-task action loading."""
+"""In-box-safe leapspace helpers: the state-dir convention, atomic writes,
+the verdict ``check`` line, and task action loading.
+
+Split out from the former ``utils.py`` (EVO-02 LS-1). Everything here is
+stdlib-only and imports no host SDK, so the in-box verdict program
+(``action.py``'s ``expect()``), the pure state helpers, and the PyQt6 apps
+(``apps/_base``) are importable with ``cua_sandbox`` absent -- which is what
+lets a real app run headless (offscreen Qt) or a verdict run on any host.
+Host-only image construction lives in the sibling ``image.py``.
+"""
+
+from __future__ import annotations
 
 import importlib.util
 import os
 import platform
-import subprocess
-import tempfile
 from enum import Enum
 from pathlib import Path, PurePath, PurePosixPath, PureWindowsPath
 from typing import TYPE_CHECKING, Awaitable, Callable, Literal
 
-from cua_sandbox import Image
-
 if TYPE_CHECKING:
     from leapspace.app_space.actor import LeapAppActor
 
@@ -41,7 +47,7 @@ def load_action(
     """Import a task's action.py once; return its (reference, expect) pair.
 
     Module-level imports are lint-guaranteed in-sandbox-safe (stdlib /
-    PyQt6 / leapspace) — a set the host import satisfies as well — and
+    PyQt6 / leapspace) -- a set the host import satisfies as well -- and
     exec_module honors the __main__ guard, so loading never triggers the
     verdict.
     """
@@ -81,13 +87,13 @@ def get_sandbox_state_dir(
     in_sandbox: bool,
     system: Literal["linux", "macos", "windows"] | None = None,
 ) -> PurePath:
-    """The apps' state root — the one path harness and apps must agree on.
+    """The apps' state root -- the one path harness and apps must agree on.
 
     Two consumers, two ways to know the sandbox OS: apps run inside and
     detect it with platform.system(); the harness runs on the host, where
     detection would answer the host's OS, so it names the sandbox's OS
     (an image preset's value) instead. Callers append the app_id. No env
-    override — hermetic tests monkeypatch this function.
+    override -- hermetic tests monkeypatch this function.
     """
     if in_sandbox:
         system = platform.system().lower()
@@ -124,7 +130,7 @@ def get_sandbox_state_dir(
 # Repo checkout path inside the sandbox image.
 LINUX_LEAPFLOW_PATH = "/opt/leapflow"
 
-# Source tree inside the checkout — PYTHONPATH for interpreters outside the
+# Source tree inside the checkout -- PYTHONPATH for interpreters outside the
 # repo venv (the OS python's apt stack: pyatspi).
 LINUX_LEAPFLOW_SRC = f"{LINUX_LEAPFLOW_PATH}/src"
 
@@ -132,57 +138,6 @@ def get_sandbox_state_dir(
 LEAPFLOW_ARCHIVE_DST = "/tmp/leapflow-checkout.tar.gz"
 
 
-def _archive_checkout() -> Path:
-    """Pack this checkout's committed state for the image to copy in.
-
-    The build VM reaches GitHub only through the host's flaky link, so the
-    repo travels as a host-built archive: no in-box clone, and the box runs
-    exactly the code under test (HEAD, not some remote ref).
-    """
-    repo_root = Path(__file__).resolve().parents[3]
-    fd, name = tempfile.mkstemp(suffix=".tar.gz")
-    os.close(fd)
-    result = subprocess.run(
-        ["git", "archive", "--format=tar.gz", "-o", name, "HEAD"],
-        cwd=repo_root,
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode != 0:
-        raise RuntimeError(f"git archive failed: {result.stderr.strip()}")
-    return Path(name)
-
-
-def get_image(image: LeapAppImage) -> Image:
-    """Return the preset image spec, rooted in an archive of this checkout.
-
-    Image is frozen and chainable — every mutation returns a new instance —
-    so callers get a fresh spec (and a fresh archive) per run. needrestart
-    is removed before apt: installing python3-dev upgrades service
-    libraries, and needrestart's service restarts SIGTERM the layer's own
-    command transport. Host feasibility: LINUX runs under local QEMU+KVM;
-    WINDOWS is untested; MACOS requires an Apple Silicon host (Lume).
-    """
-    archive = _archive_checkout()
-    if image == LeapAppImage.LINUX:
-        return (
-            Image.linux(distro="ubuntu", version="24.04", kind="vm")
-            .expose(CUA_MCP_PORT)
-            .run("sudo apt-get remove -y needrestart")
-            .apt_install("python3-pyatspi", "python3-dev", *PYQT_SYSTEM_LIBS, "git", "make")
-            .pip_install("PyQt6", "uv")
-            .copy(str(archive), LEAPFLOW_ARCHIVE_DST)
-            .run(
-                f"mkdir -p {LINUX_LEAPFLOW_PATH} && "
-                f"tar xzf {LEAPFLOW_ARCHIVE_DST} -C {LINUX_LEAPFLOW_PATH} && "
-                f"rm {LEAPFLOW_ARCHIVE_DST}"
-            )
-            .run(f"cd {LINUX_LEAPFLOW_PATH} && make space-sync")
-        )
-    else:
-        raise NotImplementedError(f"image preset not defined for {image}")
-
-
 def get_image_venv_python(system: Literal["linux", "macos", "windows"]) -> str:
     """Interpreter inside the image's repo venv, keyed by sandbox OS.
 
diff --git a/src/leapspace/app_space/tasks/task-001/action.py b/src/leapspace/app_space/tasks/task-001/action.py
index e5f34270..748193a2 100644
--- a/src/leapspace/app_space/tasks/task-001/action.py
+++ b/src/leapspace/app_space/tasks/task-001/action.py
@@ -34,7 +34,7 @@
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from leapspace.app_space.utils import check
+from leapspace.app_space.state import check
 
 if TYPE_CHECKING:
     from leapspace.app_space.actor import LeapAppActor
diff --git a/temp/papers/aaai27_demo/aaai_demo/__init__.py b/temp/papers/aaai27_demo/aaai_demo/__init__.py
new file mode 100644
index 00000000..333f92f8
--- /dev/null
+++ b/temp/papers/aaai27_demo/aaai_demo/__init__.py
@@ -0,0 +1,17 @@
+"""Publication-local tooling for the AAAI-27 LeapFlow demonstration."""
+
+from aaai_demo.evidence import (
+    EvidenceBundleError,
+    build_evidence_bundle,
+    export_evidence_bundle,
+)
+from aaai_demo.poster import render_poster_source
+from aaai_demo.render import render_demo_package
+
+__all__ = [
+    "EvidenceBundleError",
+    "build_evidence_bundle",
+    "export_evidence_bundle",
+    "render_poster_source",
+    "render_demo_package",
+]
diff --git a/temp/papers/aaai27_demo/aaai_demo/cli.py b/temp/papers/aaai27_demo/aaai_demo/cli.py
new file mode 100644
index 00000000..36fdebb7
--- /dev/null
+++ b/temp/papers/aaai27_demo/aaai_demo/cli.py
@@ -0,0 +1,107 @@
+"""Command-line entry points for AAAI demo evidence packaging."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Sequence
+
+from aaai_demo.evidence import EvidenceBundleError, export_evidence_bundle
+from aaai_demo.headless_seam import export_headless_seam
+from aaai_demo.poster import render_poster_source
+from aaai_demo.render import compose_backup_reel, render_demo_package
+
+
+def _parser() -> argparse.ArgumentParser:
+    """Create the narrow, read-only-or-derived demo command surface."""
+    parser = argparse.ArgumentParser(description="Build auditable AAAI demo artifacts.")
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    bundle = commands.add_parser("bundle", help="Export a write-once CE-X evidence bundle.")
+    bundle.add_argument("--run-dir", type=Path, required=True)
+    bundle.add_argument("--output-dir", type=Path, required=True)
+    bundle.add_argument("--drift-fixture", type=Path)
+    bundle.add_argument("--trajectory-dir", type=Path)
+    bundle.add_argument(
+        "--signal-archive",
+        type=Path,
+        help="Manifest that binds signal-mode media, state/event evidence, and expect() result.",
+    )
+    bundle.add_argument(
+        "--headless-seam",
+        type=Path,
+        help="Write-once real-widget structural-seam record from the headless-seam command.",
+    )
+    bundle.add_argument("--include-media", action="store_true")
+
+    seam = commands.add_parser("headless-seam", help="Run and record the real offscreen PyQt structural seam.")
+    seam.add_argument("--output-dir", type=Path, required=True)
+
+    render = commands.add_parser("render", help="Render a static causal-trace console and EDL.")
+    render.add_argument("--bundle", type=Path, required=True)
+    render.add_argument("--output-dir", type=Path, required=True)
+
+    poster = commands.add_parser("poster", help="Render a provisional accepted-demo poster source.")
+    poster.add_argument("--bundle", type=Path, required=True)
+    poster.add_argument("--output-dir", type=Path, required=True)
+    poster.add_argument("--viewer-url", default="")
+
+    reel = commands.add_parser("backup-reel", help="Concatenate reviewed clips without re-encoding.")
+    reel.add_argument("--clip", type=Path, action="append", required=True)
+    reel.add_argument("--output", type=Path, required=True)
+    return parser
+
+
+def _bundle_from_path(path: Path) -> dict:
+    """Read a normalized evidence bundle and reject malformed input."""
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise EvidenceBundleError(f"cannot read bundle: {path}") from exc
+    if not isinstance(value, dict) or value.get("kind") != "aaai_demo_evidence_bundle":
+        raise EvidenceBundleError("input is not an AAAI demo evidence bundle")
+    return value
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run one explicit packaging operation and print only resulting artifact paths."""
+    args = _parser().parse_args(argv)
+    try:
+        if args.command == "bundle":
+            bundle = export_evidence_bundle(
+                args.run_dir,
+                args.output_dir,
+                drift_fixture=args.drift_fixture,
+                trajectory_dir=args.trajectory_dir,
+                signal_archive=args.signal_archive,
+                headless_seam=args.headless_seam,
+                include_media=args.include_media,
+            )
+            print(json.dumps({"bundle": str(args.output_dir), "run_id": bundle["run"]["run_id"]}, sort_keys=True))
+            return 0
+        if args.command == "headless-seam":
+            record = export_headless_seam(args.output_dir)
+            print(json.dumps({"headless_seam": str(args.output_dir), "run_id": record["run_id"]}, sort_keys=True))
+            return 0
+        if args.command == "render":
+            paths = render_demo_package(_bundle_from_path(args.bundle), args.output_dir)
+            print(json.dumps({key: str(value) for key, value in paths.items()}, sort_keys=True))
+            return 0
+        if args.command == "poster":
+            paths = render_poster_source(
+                _bundle_from_path(args.bundle), args.output_dir, viewer_url=args.viewer_url,
+            )
+            print(json.dumps({key: str(value) for key, value in paths.items()}, sort_keys=True))
+            return 0
+        if args.command == "backup-reel":
+            print(compose_backup_reel(args.clip, args.output))
+            return 0
+    except EvidenceBundleError as exc:
+        print(f"error: {exc}")
+        return 2
+    raise AssertionError(f"unhandled command: {args.command}")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/temp/papers/aaai27_demo/aaai_demo/evidence.py b/temp/papers/aaai27_demo/aaai_demo/evidence.py
new file mode 100644
index 00000000..53fbfb71
--- /dev/null
+++ b/temp/papers/aaai27_demo/aaai_demo/evidence.py
@@ -0,0 +1,528 @@
+"""Build a conservative, immutable evidence bundle for the AAAI demo.
+
+This module is deliberately publication-local. It reads existing experiment
+artifacts and trajectory recordings; it never drives a model, approves a
+mutation, or changes a registry. Its output distinguishes what was observed
+from what the L1 CE-X instrument intentionally did not exercise.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import shutil
+import time
+from pathlib import Path
+from typing import Any, Iterable, Mapping
+
+
+SCHEMA_VERSION = 1
+CE_X_ARMS = (
+    "unchanged_baseline",
+    "irrelevant_delta_rejected",
+    "satisfied_by_catalog",
+    "unmet_traverses_lifecycle",
+)
+_REQUIRED_RECORD_FIELDS = frozenset({"arm", "expected_action", "action", "ok"})
+
+
+class EvidenceBundleError(ValueError):
+    """Raised when input cannot support a truthful, replayable demo bundle."""
+
+
+def sha256_file(path: Path) -> str:
+    """Return the SHA-256 digest of a regular file without loading it all at once."""
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _read_mapping(path: Path) -> dict[str, Any]:
+    """Read one JSON object or raise an evidence-specific error."""
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise EvidenceBundleError(f"cannot read JSON object: {path}") from exc
+    if not isinstance(value, dict):
+        raise EvidenceBundleError(f"expected a JSON object: {path}")
+    return value
+
+
+def _read_jsonl(path: Path) -> list[dict[str, Any]]:
+    """Read JSONL records and reject malformed or non-object rows."""
+    try:
+        lines = path.read_text(encoding="utf-8").splitlines()
+    except OSError as exc:
+        raise EvidenceBundleError(f"cannot read records: {path}") from exc
+    records: list[dict[str, Any]] = []
+    for number, line in enumerate(lines, start=1):
+        if not line.strip():
+            continue
+        try:
+            record = json.loads(line)
+        except json.JSONDecodeError as exc:
+            raise EvidenceBundleError(f"invalid JSONL at {path}:{number}") from exc
+        if not isinstance(record, dict):
+            raise EvidenceBundleError(f"non-object JSONL record at {path}:{number}")
+        records.append(record)
+    return records
+
+
+def _require_file(directory: Path, name: str) -> Path:
+    """Return a required regular file beneath an experiment run directory."""
+    path = directory / name
+    if not path.is_file():
+        raise EvidenceBundleError(f"missing required run artifact: {path}")
+    return path
+
+
+def _artifact(path: Path, *, root: Path) -> dict[str, Any]:
+    """Return immutable metadata for a source artifact without copying it."""
+    try:
+        relative = path.relative_to(root)
+    except ValueError:
+        relative = Path(path.name)
+    return {
+        "path": relative.as_posix(),
+        "sha256": sha256_file(path),
+        "bytes": path.stat().st_size,
+    }
+
+
+def _validate_records(records: Iterable[Mapping[str, Any]]) -> list[dict[str, Any]]:
+    """Validate the canonical CE-X arm set and preserve its declared order."""
+    by_arm: dict[str, dict[str, Any]] = {}
+    for raw in records:
+        missing = _REQUIRED_RECORD_FIELDS - set(raw)
+        if missing:
+            raise EvidenceBundleError(f"counterfactual record misses fields: {sorted(missing)}")
+        arm = str(raw["arm"])
+        if arm in by_arm:
+            raise EvidenceBundleError(f"duplicate CE-X arm record: {arm}")
+        by_arm[arm] = dict(raw)
+    unknown = set(by_arm) - set(CE_X_ARMS)
+    missing = set(CE_X_ARMS) - set(by_arm)
+    if unknown or missing:
+        raise EvidenceBundleError(
+            f"CE-X must contain exactly {CE_X_ARMS}; missing={sorted(missing)}, unknown={sorted(unknown)}"
+        )
+    return [by_arm[arm] for arm in CE_X_ARMS]
+
+
+def _effect_status(record: Mapping[str, Any]) -> dict[str, str]:
+    """Describe effect evidence without upgrading handler reports into an oracle."""
+    if int(record.get("effect_verified") or 0) > 0:
+        return {
+            "status": "handler_reported_effect_confirmed",
+            "independent_oracle": "not_available",
+            "note": "The CE-X L1 runner reports a handler-observed effect; no Leapspace expect() oracle was run.",
+        }
+    if int(record.get("effect_refuted") or 0) > 0:
+        return {
+            "status": "effect_refuted",
+            "independent_oracle": "not_available",
+            "note": "The instrument reported a refuted effect; this arm must not be presented as successful.",
+        }
+    return {
+        "status": "not_exercised",
+        "independent_oracle": "not_available",
+        "note": "No effect verification exists for this arm in the L1 CE-X run.",
+    }
+
+
+def _arm_label(record: Mapping[str, Any]) -> str:
+    """Name the non-mutation outcome in a form suitable for a compact matrix."""
+    arm = str(record["arm"])
+    if arm == "unchanged_baseline":
+        return "no_op"
+    if arm == "irrelevant_delta_rejected":
+        return "rejected"
+    if arm == "satisfied_by_catalog":
+        return "catalog_reuse"
+    return "acquire_hypothesis"
+
+
+def _normalise_arm(record: Mapping[str, Any], manifest: Mapping[str, Any]) -> dict[str, Any]:
+    """Map one CE-X record to a demo row while retaining its evidentiary boundary."""
+    substitutions = manifest.get("substitutions")
+    substitutions = dict(substitutions) if isinstance(substitutions, Mapping) else {}
+    not_exercised = str(substitutions.get("not_exercised") or "")
+    arm = str(record["arm"])
+    action = str(record["action"])
+    return {
+        "arm": arm,
+        "outcome": _arm_label(record),
+        "expected_action": str(record["expected_action"]),
+        "actual_action": action,
+        "matches_oracle": bool(record["ok"]),
+        "drift_relevance": (
+            "unchanged" if arm == "unchanged_baseline"
+            else "irrelevant" if arm == "irrelevant_delta_rejected"
+            else "task_relevant"
+        ),
+        "resolution": (
+            "not_required" if arm in {"unchanged_baseline", "irrelevant_delta_rejected"}
+            else "incumbent_satisfies" if arm == "satisfied_by_catalog"
+            else "unmet_requirement"
+        ),
+        "proposal_count": int(record.get("proposed") or 0),
+        "admitted_count": int(record.get("admitted") or 0),
+        "requirement_count": int(record.get("requirements") or 0),
+        "authorised": bool(record.get("authorised", False)),
+        "profile_root": str(record.get("profile_root") or ""),
+        "approval": "not_exercised",
+        "registry_mutation": "not_exercised",
+        "lifecycle": "mechanism_level_only" if action == "acquire" else "not_applicable",
+        "effect": _effect_status(record),
+        "notes": str(record.get("notes") or ""),
+        "boundary": not_exercised,
+    }
+
+
+def _trajectory_metadata(trajectory_dir: Path | None) -> dict[str, Any]:
+    """Index legacy optional trajectory assets without asserting an oracle verdict."""
+    if trajectory_dir is None:
+        return {"status": "not_supplied", "media": [], "turns": []}
+    root = trajectory_dir.expanduser().resolve()
+    if not root.is_dir():
+        raise EvidenceBundleError(f"trajectory directory does not exist: {root}")
+    media: list[dict[str, Any]] = []
+    for name in ("recording.mp4", "cursor.jsonl"):
+        path = root / name
+        if path.is_file():
+            media.append(_artifact(path, root=root))
+    turns: list[dict[str, Any]] = []
+    for turn_dir in sorted(path for path in root.glob("turn-*") if path.is_dir()):
+        files = [
+            _artifact(path, root=root)
+            for path in sorted(turn_dir.iterdir())
+            if path.is_file() and path.name in {"action.json", "app_state.json", "screenshot.png"}
+        ]
+        turns.append({"turn": turn_dir.name, "artifacts": files})
+    return {
+        "status": "available" if media or turns else "empty",
+        "pixel_capture": "available" if any(item["path"] == "recording.mp4" for item in media) else "not_available",
+        "media": media,
+        "turns": turns,
+    }
+
+
+_SIGNAL_ARCHIVE_REQUIRED_KINDS = frozenset({
+    "recording", "cursor_path", "state_snapshot", "event_log", "expect_stdout",
+})
+
+
+def _safe_archive_artifact(root: Path, raw: Mapping[str, Any]) -> tuple[dict[str, Any] | None, str]:
+    """Hash one declared signal artifact without allowing an archive-path escape."""
+    kind = str(raw.get("kind") or "").strip()
+    relative = Path(str(raw.get("path") or ""))
+    if not kind or not relative.parts or relative.is_absolute() or ".." in relative.parts:
+        return None, kind or "invalid_artifact"
+    path = root / relative
+    if not path.is_file():
+        return None, kind
+    artifact = _artifact(path, root=root)
+    artifact.update({"kind": kind, "sensitive": bool(raw.get("sensitive", False))})
+    return artifact, ""
+
+
+def load_signal_archive(path: Path | None) -> dict[str, Any]:
+    """Load a declared signal-mode archive without upgrading missing evidence to PASS.
+
+    The manifest is deliberately file-oriented. It binds a recording, state/event
+    evidence, and the independent ``expect()`` verdict to one run while allowing a
+    renderer to show an incomplete archive honestly instead of failing the whole CE-X
+    bundle.
+    """
+    if path is None:
+        return {"status": "not_supplied", "artifacts": [], "missing": []}
+    manifest_path = path.expanduser().resolve()
+    manifest = _read_mapping(manifest_path)
+    if manifest.get("schema_version") != SCHEMA_VERSION or manifest.get("kind") != "leapspace_signal_archive":
+        raise EvidenceBundleError("signal archive must declare the current schema and kind")
+    raw_artifacts = manifest.get("artifacts")
+    if not isinstance(raw_artifacts, list):
+        raise EvidenceBundleError("signal archive artifacts must be a list")
+    artifacts: list[dict[str, Any]] = []
+    missing: list[str] = []
+    for raw in raw_artifacts:
+        if not isinstance(raw, Mapping):
+            raise EvidenceBundleError("signal archive contains a non-object artifact")
+        artifact, problem = _safe_archive_artifact(manifest_path.parent, raw)
+        if artifact is None:
+            missing.append(problem)
+        else:
+            artifacts.append(artifact)
+    present = {str(item["kind"]) for item in artifacts}
+    missing.extend(sorted(_SIGNAL_ARCHIVE_REQUIRED_KINDS - present))
+    expect = manifest.get("expect")
+    expect = dict(expect) if isinstance(expect, Mapping) else {}
+    verdict = str(expect.get("verdict") or "not_recorded")
+    exit_code = expect.get("exit_code")
+    passed = verdict == "pass" and exit_code == 0 and not missing
+    return {
+        "status": "available" if passed else "incomplete",
+        "run_id": str(manifest.get("run_id") or ""),
+        "expect": {"verdict": verdict, "exit_code": exit_code},
+        "artifacts": artifacts,
+        "missing": sorted(set(missing)),
+        "pixel_capture": "available" if "recording" in present else "not_available",
+    }
+
+
+def load_headless_seam(path: Path | None) -> dict[str, Any]:
+    """Load a write-once real-widget seam record, or name its absence explicitly."""
+    if path is None:
+        return {"status": "not_supplied"}
+    record_path = path.expanduser().resolve()
+    record = _read_mapping(record_path)
+    if record.get("schema_version") != SCHEMA_VERSION or record.get("kind") != "aaai_demo_headless_seam":
+        raise EvidenceBundleError("headless seam record must declare the current schema and kind")
+    required = {"rename", "benign_control", "default_refusal", "requirement"}
+    missing = sorted(key for key in required if key not in record)
+    return {
+        "status": "available" if not missing else "incomplete",
+        "artifact": _artifact(record_path, root=record_path.parent),
+        "run_id": str(record.get("run_id") or ""),
+        "rename": dict(record.get("rename") or {}),
+        "benign_control": dict(record.get("benign_control") or {}),
+        "default_refusal": dict(record.get("default_refusal") or {}),
+        "requirement": dict(record.get("requirement") or {}),
+        "missing": missing,
+    }
+
+
+def load_drift_fixture(path: Path | None) -> dict[str, Any] | None:
+    """Load and validate a declarative, reversible interface-drift fixture."""
+    if path is None:
+        return None
+    fixture = _read_mapping(path)
+    drifts = fixture.get("drifts")
+    if fixture.get("schema_version") != SCHEMA_VERSION or not isinstance(drifts, list) or not drifts:
+        raise EvidenceBundleError("drift fixture must declare schema_version and a non-empty drifts list")
+    seen: set[str] = set()
+    for drift in drifts:
+        if not isinstance(drift, Mapping):
+            raise EvidenceBundleError("drift fixture contains a non-object drift")
+        drift_id = str(drift.get("drift_id") or "")
+        if not drift_id or drift_id in seen:
+            raise EvidenceBundleError("each drift fixture entry requires a unique drift_id")
+        seen.add(drift_id)
+        if not isinstance(drift.get("before"), Mapping) or not isinstance(drift.get("after"), Mapping):
+            raise EvidenceBundleError(f"drift {drift_id} must contain before and after snapshots")
+    return fixture
+
+
+def build_evidence_bundle(
+    run_dir: Path,
+    *,
+    drift_fixture: Path | None = None,
+    trajectory_dir: Path | None = None,
+    signal_archive: Path | None = None,
+    headless_seam: Path | None = None,
+) -> dict[str, Any]:
+    """Normalise a completed CE-X run into a conservative publication artifact."""
+    root = run_dir.expanduser().resolve()
+    if not root.is_dir():
+        raise EvidenceBundleError(f"CE-X run directory does not exist: {root}")
+    manifest_path = _require_file(root, "manifest.json")
+    records_path = _require_file(root, "records.jsonl")
+    summary_path = _require_file(root, "summary.json")
+    manifest = _read_mapping(manifest_path)
+    summary = _read_mapping(summary_path)
+    records = _validate_records(_read_jsonl(records_path))
+    lane = str(manifest.get("lane") or "")
+    if lane != "L1":
+        raise EvidenceBundleError(f"this demo normalizer currently accepts L1 CE-X runs, got {lane!r}")
+    profiles = {str(record.get("profile_root") or "") for record in records}
+    if "" in profiles or len(profiles) != len(CE_X_ARMS):
+        raise EvidenceBundleError("CE-X arms must retain four distinct non-empty profile roots")
+    fixture = load_drift_fixture(drift_fixture)
+    arms = [_normalise_arm(record, manifest) for record in records]
+    trace = [
+        {
+            "stage": "observe",
+            "arm": arm["arm"],
+            "title": f"OBSERVE · {arm['drift_relevance']}",
+            "summary": arm["notes"],
+            "severity": "info" if arm["matches_oracle"] else "alert",
+        }
+        for arm in arms
+    ] + [
+        {
+            "stage": "decide",
+            "arm": arm["arm"],
+            "title": f"DECIDE · {arm['outcome']}",
+            "summary": f"expected={arm['expected_action']}; actual={arm['actual_action']}",
+            "severity": "notable" if arm["outcome"] in {"rejected", "catalog_reuse"} else "info",
+        }
+        for arm in arms
+    ]
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "kind": "aaai_demo_evidence_bundle",
+        "created_at": time.time(),
+        "evidence_level": "L1",
+        "run": {
+            "run_id": str(manifest.get("run_id") or root.name),
+            "family": str(manifest.get("family") or ""),
+            "protocol_id": str(manifest.get("protocol_id") or ""),
+            "experiment_version": str(manifest.get("experiment_version") or ""),
+            "subject": dict(manifest.get("subject") or {}),
+            "manifest": _artifact(manifest_path, root=root),
+            "records": _artifact(records_path, root=root),
+            "summary": _artifact(summary_path, root=root),
+            "substitutions": dict(manifest.get("substitutions") or {}),
+        },
+        "claims": {
+            "supported": [
+                "The controlled L1 CE-X instrument distinguishes no-op, rejection, catalog reuse, and an acquisition hypothesis.",
+                "Each counterfactual arm uses an isolated profile root and emits a durable run record.",
+            ],
+            "not_supported": [
+                "End-to-end Leapspace agent execution.",
+                "A real plugin installation or approval decision.",
+                "Independent expect() oracle confirmation for the L1 CE-X acquisition arm.",
+                "Longitudinal governed self-evolution in the daemon runtime.",
+            ],
+        },
+        "summary": summary,
+        "arms": arms,
+        "causal_trace": trace,
+        # ``trajectory`` is a legacy media index. Only ``signal_archive`` binds media
+        # to state/event evidence and an independent expect() verdict.
+        "trajectory": _trajectory_metadata(trajectory_dir),
+        "signal_archive": load_signal_archive(signal_archive),
+        "headless_seam": load_headless_seam(headless_seam),
+        "drift_fixture": fixture,
+    }
+
+
+def _write_json(path: Path, value: Mapping[str, Any]) -> None:
+    """Write one JSON document atomically without overwriting an existing artifact."""
+    if path.exists():
+        raise EvidenceBundleError(f"write-once artifact already exists: {path}")
+    temporary = path.with_name(f".{path.name}.tmp")
+    try:
+        temporary.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+        temporary.replace(path)
+    except OSError as exc:
+        temporary.unlink(missing_ok=True)
+        raise EvidenceBundleError(f"cannot write evidence artifact: {path}") from exc
+
+
+def _copy_raw(path: Path, destination: Path) -> None:
+    """Copy one selected source artifact, refusing to replace an existing copy."""
+    if destination.exists():
+        raise EvidenceBundleError(f"write-once raw artifact already exists: {destination}")
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        shutil.copy2(path, destination)
+    except OSError as exc:
+        raise EvidenceBundleError(f"cannot copy evidence artifact: {path}") from exc
+
+
+def export_evidence_bundle(
+    run_dir: Path,
+    output_dir: Path,
+    *,
+    drift_fixture: Path | None = None,
+    trajectory_dir: Path | None = None,
+    signal_archive: Path | None = None,
+    headless_seam: Path | None = None,
+    include_media: bool = False,
+) -> dict[str, Any]:
+    """Create a write-once derived bundle and return its normalized content."""
+    target = output_dir.expanduser().resolve()
+    if target.exists():
+        raise EvidenceBundleError(f"write-once bundle directory already exists: {target}")
+    bundle = build_evidence_bundle(
+        run_dir,
+        drift_fixture=drift_fixture,
+        trajectory_dir=trajectory_dir,
+        signal_archive=signal_archive,
+        headless_seam=headless_seam,
+    )
+    target.mkdir(parents=True, exist_ok=False)
+    try:
+        source = Path(run_dir).expanduser().resolve()
+        raw_dir = target / "raw"
+        for name in ("manifest.json", "records.jsonl", "summary.json"):
+            _copy_raw(source / name, raw_dir / name)
+        if drift_fixture is not None:
+            _copy_raw(drift_fixture.expanduser().resolve(), raw_dir / "drift_fixture.json")
+        if signal_archive is not None:
+            _copy_raw(signal_archive.expanduser().resolve(), raw_dir / "signal_archive.json")
+        if headless_seam is not None:
+            _copy_raw(headless_seam.expanduser().resolve(), raw_dir / "headless_seam.json")
+        if include_media and trajectory_dir is not None:
+            trajectory = trajectory_dir.expanduser().resolve()
+            for path in sorted(trajectory.rglob("*")):
+                if not path.is_file():
+                    continue
+                relative = path.relative_to(trajectory)
+                if path.name in {"recording.mp4", "cursor.jsonl", "action.json", "app_state.json", "screenshot.png"}:
+                    _copy_raw(path, raw_dir / "trajectory" / relative)
+        bundle["packaged_files"] = [
+            _artifact(path, root=target)
+            for path in sorted(target.rglob("*"))
+            if path.is_file()
+        ]
+        _write_json(target / "bundle.json", bundle)
+        lines = [
+            f"{sha256_file(path)}  {path.relative_to(target).as_posix()}"
+            for path in sorted(target.rglob("*"))
+            if path.is_file()
+        ]
+        (target / "checksums.sha256").write_text("\n".join(lines) + "\n", encoding="utf-8")
+    except Exception:
+        shutil.rmtree(target, ignore_errors=True)
+        raise
+    return bundle
+
+
+def viewspec_data(bundle: Mapping[str, Any]) -> dict[str, Any]:
+    """Project bundle facts into the existing read-only Causal Trace template shape."""
+    arms = [dict(item) for item in bundle.get("arms") or [] if isinstance(item, Mapping)]
+    trace = [dict(item) for item in bundle.get("causal_trace") or [] if isinstance(item, Mapping)]
+    summary = dict(bundle.get("summary") or {})
+    run = dict(bundle.get("run") or {})
+    return {
+        "title": f"AAAI Causal Trace · {run.get('run_id') or 'unknown run'}",
+        "causal_trace": {
+            "evidence_level": str(bundle.get("evidence_level") or ""),
+            "arms": arms,
+            "timeline": trace,
+            "summary": {
+                "arms_total": summary.get("arms_total", len(arms)),
+                "arms_correct": summary.get("arms_correct", 0),
+                "mutations": summary.get("mutations", 0),
+                "effect_confirmed": summary.get("effect_confirmed", 0),
+            },
+            "manifest": {
+                "run_id": run.get("run_id", ""),
+                "protocol_id": run.get("protocol_id", ""),
+                "subject_commit": dict(run.get("subject") or {}).get("commit", ""),
+                "records_sha256": dict(run.get("records") or {}).get("sha256", ""),
+            },
+            "claims": dict(bundle.get("claims") or {}),
+            "signal_archive": dict(bundle.get("signal_archive") or {}),
+            "headless_seam": dict(bundle.get("headless_seam") or {}),
+        },
+    }
+
+
+__all__ = [
+    "CE_X_ARMS",
+    "SCHEMA_VERSION",
+    "EvidenceBundleError",
+    "build_evidence_bundle",
+    "export_evidence_bundle",
+    "load_drift_fixture",
+    "load_headless_seam",
+    "load_signal_archive",
+    "sha256_file",
+    "viewspec_data",
+]
diff --git a/temp/papers/aaai27_demo/aaai_demo/headless_seam.py b/temp/papers/aaai27_demo/aaai_demo/headless_seam.py
new file mode 100644
index 00000000..64e43fca
--- /dev/null
+++ b/temp/papers/aaai27_demo/aaai_demo/headless_seam.py
@@ -0,0 +1,220 @@
+"""Export a write-once record of the real offscreen Leapspace structural seam.
+
+The demo uses this helper instead of presenting a fixture as if it were a real UI.
+It creates two actual PyQt6 ``BaseLeapApp`` surfaces, lets their normal persistence
+write the envelopes, and routes the observed rename through the production
+``CapabilityObservationService``.  It has no engine, registry, approval, or plugin
+mutation capability.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import time
+import uuid
+from pathlib import Path
+from typing import Any
+
+from aaai_demo.evidence import EvidenceBundleError, SCHEMA_VERSION, sha256_file
+
+
+def _write_once(path: Path, value: dict[str, Any]) -> None:
+    """Write one JSON record atomically without replacing an existing artifact."""
+    if path.exists():
+        raise EvidenceBundleError(f"write-once artifact already exists: {path}")
+    temporary = path.with_name(f".{path.name}.tmp")
+    try:
+        temporary.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+        temporary.replace(path)
+    except OSError as exc:
+        temporary.unlink(missing_ok=True)
+        raise EvidenceBundleError(f"cannot write headless seam artifact: {path}") from exc
+
+
+def _artifact(path: Path, *, root: Path) -> dict[str, Any]:
+    """Describe one local artifact relative to the seam run root."""
+    return {
+        "path": path.relative_to(root).as_posix(),
+        "sha256": sha256_file(path),
+        "bytes": path.stat().st_size,
+    }
+
+
+def _require_pyqt() -> tuple[Any, Any, Any, Any, Any, Any, Any]:
+    """Load optional GUI dependencies only for the explicit headless-seam command."""
+    try:
+        from PyQt6.QtWidgets import QApplication, QLineEdit, QPushButton, QVBoxLayout, QWidget
+        from leapspace.app_space.apps import _base as base_module
+        from leapspace.app_space.apps._base import BaseLeapApp
+    except ImportError as exc:
+        raise EvidenceBundleError(
+            "headless-seam requires the leapspace extra with PyQt6; run it in the PyQt-enabled environment"
+        ) from exc
+    return QApplication, QLineEdit, QPushButton, QVBoxLayout, QWidget, base_module, BaseLeapApp
+
+
+def export_headless_seam(output_dir: Path) -> dict[str, Any]:
+    """Run the real offscreen rename/negative-control seam and export its evidence.
+
+    ``output_dir`` is write-once. The record contains no widget values or message
+    contents: only structural identities, persisted evidence identifiers, and hashes.
+    """
+    target = output_dir.expanduser().resolve()
+    if target.exists():
+        raise EvidenceBundleError(f"write-once headless seam directory already exists: {target}")
+    QApplication, QLineEdit, QPushButton, QVBoxLayout, QWidget, base_module, BaseLeapApp = _require_pyqt()
+    target.mkdir(parents=True, exist_ok=False)
+    original_state_dir = base_module.get_sandbox_state_dir
+    try:
+        import os
+
+        os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+        app = QApplication.instance() or QApplication([])
+
+        class _ChatV1(BaseLeapApp):
+            app_id = "chat_probe"
+            app_title = "ChatProbe"
+            version = "1.0"
+
+            def build_ui(self) -> None:
+                central = QWidget()
+                layout = QVBoxLayout(central)
+                layout.addWidget(self.bind(QLineEdit(), "message_input"))
+                layout.addWidget(self.bind(QPushButton("Send"), self._send_name()))
+                self.setCentralWidget(central)
+
+            def _send_name(self) -> str:
+                return "send_button"
+
+            def reset(self, data: dict[str, Any]) -> None:
+                return None
+
+            def state(self) -> dict[str, Any]:
+                return {}
+
+        class _ChatV2(_ChatV1):
+            version = "1.1"
+
+            def _send_name(self) -> str:
+                return "dispatch_button"
+
+        class _ChatBenign(_ChatV1):
+            version = "1.1-benign"
+
+            def build_ui(self) -> None:
+                central = QWidget()
+                layout = QVBoxLayout(central)
+                layout.addWidget(self.bind(QLineEdit(), "message_input"))
+                layout.addWidget(self.bind(QPushButton("Send"), "send_button"))
+                layout.addWidget(self.bind(QPushButton("Emoji"), "emoji_picker"))
+                self.setCentralWidget(central)
+
+        def _write_state(app_type: type[Any], name: str) -> Path:
+            state_root = target / "states" / name
+            base_module.get_sandbox_state_dir = lambda in_sandbox=True, system=None: state_root
+            window = app_type()
+            window.close()
+            window.deleteLater()
+            app.processEvents()
+            return state_root / "chat_probe" / "state.json"
+
+        before_path = _write_state(_ChatV1, "before")
+        renamed_path = _write_state(_ChatV2, "renamed")
+        benign_path = _write_state(_ChatBenign, "benign")
+
+        from leapflow.learning.capability_observation import (
+            CapabilityEvidenceClassifier,
+            CapabilityObservationService,
+        )
+        from leapflow.storage.capability_observation_store import JsonCapabilityObservationStore
+        from leapexp2.contracts import CapabilityPrecondition
+        from leapexp2.leapspace_source import LeapSpaceEnvironmentSource
+
+        precondition = CapabilityPrecondition(
+            capability="chat.reply", bound_names=frozenset({"send_button"})
+        )
+        before = LeapSpaceEnvironmentSource(target / "states" / "before").read_snapshot("chat_probe")
+        renamed_source = LeapSpaceEnvironmentSource(
+            target / "states" / "renamed", workspace_root="demo-headless-seam"
+        )
+        renamed = renamed_source.read_snapshot("chat_probe")
+        evidence = renamed_source.detect(before, renamed, precondition)
+        if len(evidence) != 1 or evidence[0].evidence_kind != "interface_drift":
+            raise EvidenceBundleError("real rename did not produce exactly one interface_drift observation")
+
+        store = JsonCapabilityObservationStore(target / "observations.json")
+        admitted_service = CapabilityObservationService(
+            store,
+            classifier=CapabilityEvidenceClassifier.from_kinds(
+                ["unknown_tool", "interface_drift", "affordance_removed"]
+            ),
+        )
+        observation = renamed_source.emit(admitted_service, evidence[0])
+        requirements = admitted_service.requirements(min_count=1)
+        if observation is None or len(requirements) != 1:
+            raise EvidenceBundleError("admitted structural evidence did not produce one requirement")
+        requirement = requirements[0]
+
+        benign_source = LeapSpaceEnvironmentSource(target / "states" / "benign")
+        benign = benign_source.read_snapshot("chat_probe")
+        benign_evidence = benign_source.detect(before, benign, precondition)
+        if benign_evidence:
+            raise EvidenceBundleError("benign structural change unexpectedly produced evidence")
+
+        default_store = JsonCapabilityObservationStore(target / "default_observations.json")
+        default_service = CapabilityObservationService(default_store)
+        default_record = renamed_source.emit(default_service, evidence[0])
+        if default_record is not None:
+            raise EvidenceBundleError("default classifier unexpectedly admitted environment evidence")
+
+        store_artifacts = [_artifact(target / "observations.json", root=target)]
+        default_store_path = target / "default_observations.json"
+        if default_store_path.is_file():
+            store_artifacts.append(_artifact(default_store_path, root=target))
+
+        record = {
+            "schema_version": SCHEMA_VERSION,
+            "kind": "aaai_demo_headless_seam",
+            "run_id": f"headless-seam-{uuid.uuid4().hex[:12]}",
+            "created_at": time.time(),
+            "evidence_level": "real_headless_structural_seam",
+            "limitations": [
+                "No framebuffer or pixel evidence is available in the offscreen lane.",
+                "The seam creates an observation and requirement; it does not execute an agent, install a plugin, or approve a mutation.",
+            ],
+            "rename": {
+                "before": _artifact(before_path, root=target),
+                "after": _artifact(renamed_path, root=target),
+                "evidence_kind": evidence[0].evidence_kind,
+                "recovery_hint": evidence[0].recovery_hint,
+                "suggestions": list(evidence[0].suggestions),
+                "observation_id": str(observation.get("observation_id") or ""),
+            },
+            "benign_control": {
+                "state": _artifact(benign_path, root=target),
+                "evidence_count": 0,
+            },
+            # A refused observation does not need to create a store file; that absence
+            # is itself part of the default-off evidence, not an export failure.
+            "default_refusal": {
+                "admitted": False,
+                "store_created": default_store_path.is_file(),
+            },
+            "requirement": {
+                "capability": requirement.capability,
+                "origin": requirement.origin,
+                "requirement_id": requirement.requirement_id,
+            },
+            "stores": store_artifacts,
+        }
+        _write_once(target / "headless_seam.json", record)
+        return record
+    except Exception:
+        shutil.rmtree(target, ignore_errors=True)
+        raise
+    finally:
+        base_module.get_sandbox_state_dir = original_state_dir
+
+
+__all__ = ["export_headless_seam"]
diff --git a/temp/papers/aaai27_demo/aaai_demo/poster.py b/temp/papers/aaai27_demo/aaai_demo/poster.py
new file mode 100644
index 00000000..a959e349
--- /dev/null
+++ b/temp/papers/aaai27_demo/aaai_demo/poster.py
@@ -0,0 +1,113 @@
+"""Create a provisional, editable poster source for an accepted demo station.
+
+AAAI-27 supplies a poster board only after acceptance and defers exhibit format
+information to the Chairs. This module therefore produces a responsive 3:4 design
+source, not an asserted print size or a submission replacement for the required
+video/slides material.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+from typing import Any, Mapping
+
+from aaai_demo.evidence import EvidenceBundleError, sha256_file
+
+
+_PROVISIONAL_FORMAT = {
+    "status": "provisional",
+    "design_ratio": "3:4 portrait",
+    "official_size": "pending_chairs_exhibit_format_information",
+    "print_export": "deferred_until_official_format_is_confirmed",
+}
+
+
+def _write_once(path: Path, content: str) -> None:
+    """Write a source artifact atomically without replacing an existing one."""
+    if path.exists():
+        raise EvidenceBundleError(f"write-once poster artifact already exists: {path}")
+    temporary = path.with_name(f".{path.name}.tmp")
+    try:
+        temporary.write_text(content, encoding="utf-8")
+        temporary.replace(path)
+    except OSError as exc:
+        temporary.unlink(missing_ok=True)
+        raise EvidenceBundleError(f"cannot write poster artifact: {path}") from exc
+
+
+def _safe_json(value: Any) -> str:
+    """Embed data without allowing a script closing tag to escape the document."""
+    return json.dumps(value, indent=2, sort_keys=True).replace("</", "<\\/")
+
+
+def _poster_html(bundle: Mapping[str, Any], viewer_url: str) -> str:
+    """Render a vector-friendly poster source inspired by the supplied hierarchy."""
+    payload = _safe_json(bundle)
+    target = str(viewer_url or "SET_AFTER_ANONYMITY_REVIEW")
+    return f"""<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>LeapFlow Demonstration Poster Source</title>
+<style>
+:root {{ --ink:#173b69; --blue:#2f5f95; --pale:#eaf1f8; --line:#9eb3c8; --text:#18222d; --muted:#566575; --l1:#396b99; --headless:#956b20; --archive:#3e7b68; --absent:#9a3d3d; }}
+* {{ box-sizing:border-box; }} body {{ margin:0; background:#dfe6ed; color:var(--text); font:15px/1.35 Arial,Helvetica,sans-serif; }}
+.poster {{ width:min(100vw,900px); min-height:1200px; margin:auto; padding:30px; background:#fff; display:grid; grid-template-columns:1.1fr .9fr; gap:18px; }}
+header {{ grid-column:1/-1; border-bottom:4px solid var(--ink); padding-bottom:15px; position:relative; }} h1 {{ margin:0; color:var(--ink); font-size:38px; line-height:1.05; letter-spacing:.01em; }} .thesis {{ margin:10px 180px 0 0; color:var(--muted); font-size:17px; }}
+.format {{ position:absolute; right:0; top:0; max-width:160px; border:1px solid var(--line); padding:8px; color:var(--muted); font-size:11px; }}
+.panel {{ border:1px solid var(--line); border-radius:10px; overflow:hidden; background:#fff; }} .panel h2 {{ margin:0; padding:8px 12px; background:linear-gradient(90deg,var(--blue),#8ba9c7); color:#fff; font-size:18px; }} .body {{ padding:12px; }}
+.wide {{ grid-column:1/-1; }} .flow {{ display:flex; flex-wrap:wrap; align-items:center; gap:7px; }} .node {{ padding:6px 8px; border:1px solid var(--line); background:var(--pale); font-size:12px; }} .arrow {{ color:var(--blue); font-weight:bold; }}
+.legend {{ display:flex; flex-wrap:wrap; gap:6px; margin:8px 0; }} .tag {{ border:1px solid var(--line); padding:3px 6px; font-size:11px; }} .l1 {{ border-color:var(--l1); color:var(--l1); }} .headless {{ border-color:var(--headless); color:var(--headless); }} .archive {{ border-color:var(--archive); color:var(--archive); }} .absent {{ border-color:var(--absent); color:var(--absent); }}
+table {{ width:100%; border-collapse:collapse; font-size:12px; }} th,td {{ text-align:left; border-bottom:1px solid #d9e1e9; padding:5px; vertical-align:top; }} th {{ color:var(--ink); }} .metric {{ display:grid; grid-template-columns:repeat(3,1fr); gap:6px; }} .metric div {{ background:var(--pale); padding:8px; }} .metric b {{ display:block; color:var(--ink); font-size:20px; }}
+.qr {{ min-height:118px; border:2px dashed var(--line); display:flex; align-items:center; justify-content:center; text-align:center; color:var(--muted); font-size:12px; padding:12px; }} code {{ overflow-wrap:anywhere; font-size:10px; }} .limit {{ border-left:5px solid var(--absent); padding:8px 10px; background:#fff5f5; }}
+footer {{ grid-column:1/-1; border-top:2px dashed var(--line); padding-top:10px; color:var(--muted); font-size:11px; }} @media print {{ body {{ background:#fff; }} .poster {{ width:100%; min-height:0; }} }}
+</style></head><body><main class="poster">
+<header><h1>LeapFlow: From Environment Signal to Governed Capability Decision</h1><p class="thesis">A static guide to the live Harness demonstration. Every claim is bound to an auditable evidence lane; missing steps remain visible rather than being inferred.</p><div class="format">PROVISIONAL SOURCE<br>3:4 design sketch only<br>Final size pending Chairs</div></header>
+<section class="panel"><h2>1. WHY A HARNESS NEEDS EVIDENCE</h2><div class="body"><p>Environmental drift is a hypothesis, not an instruction to rewrite capability. The demonstration makes baseline/no-op, irrelevant/reject, catalog reuse, and acquisition hypotheses equally visible.</p><div class="legend"><span class="tag l1">L1 controlled CE-X</span><span class="tag headless">real headless seam</span><span class="tag archive">conditional archive</span><span class="tag absent">not exercised</span></div></div></section>
+<section class="panel"><h2>4. QUANTIFIED COUNTERFACTUALS</h2><div class="body"><table id="arms"></table><div class="metric" id="metrics"></div></div></section>
+<section class="panel"><h2>2. SIGNAL CONTRACT</h2><div class="body"><div class="flow"><span class="node">real offscreen widget</span><span class="arrow">→</span><span class="node">role-aware elements</span><span class="arrow">→</span><span class="node">InterfaceDelta</span><span class="arrow">→</span><span class="node">opt-in environment_probe requirement</span></div><p>Benign additions remain no-op. The headless lane has no framebuffer and is not GUI-agent e2e.</p></div></section>
+<section class="panel"><h2>5. LIVE INTERACTION</h2><div class="body"><ol><li>Open the evidence viewer.</li><li>Select an episode or CE-X arm.</li><li>Observe Environment / Decision / Governance lanes in Evolution Live.</li></ol><div class="qr">QR target is set only after anonymity review:<br><code>{target}</code></div></div></section>
+<section class="panel wide"><h2>3. DECISION AND GOVERNANCE</h2><div class="body"><div class="flow"><span class="node">observe</span><span class="arrow">→</span><span class="node">requirement</span><span class="arrow">→</span><span class="node">resolution</span><span class="arrow">→</span><span class="node">absorb / rebind / acquire / escalate</span><span class="arrow">→</span><span class="node">policy / lifecycle</span></div><p>Acquire is a hypothesis. Approval, install, daemon-runtime trust, and independent oracle outcomes are shown only when a same-run artifact exists.</p></div></section>
+<section class="panel wide"><h2>6. CLAIMS AND LIMITS</h2><div class="body"><div class="limit" id="limits"></div><p>Reproduce: <code>headless-seam → run_c2 → bundle → render</code>. The monitor hosts dynamic replay; this poster is only the static entry point.</p></div></section>
+<footer>Poster source is not a submission replacement. The AAAI-27 initial submission requires a short paper plus a ≤5-minute video or slides. Generate the final printed artifact only after official exhibit format information is supplied.</footer>
+</main><script>
+const BUNDLE = {payload};
+const esc = value => String(value ?? '').replace(/[&<>\"']/g, c => ({{'&':'&amp;','<':'&lt;','>':'&gt;','\"':'&quot;',"'":'&#39;'}}[c]));
+const arms = Array.isArray(BUNDLE.arms) ? BUNDLE.arms : [];
+document.getElementById('arms').innerHTML = '<thead><tr><th>Arm</th><th>Expected / actual</th><th>Evidence boundary</th></tr></thead><tbody>' + arms.map(a => '<tr><td>' + esc(a.arm) + '</td><td>' + esc(a.expected_action) + ' / ' + esc(a.actual_action) + '</td><td>' + esc(a.effect?.status || 'not_recorded') + '</td></tr>').join('') + '</tbody>';
+const summary = BUNDLE.summary || {{}}; document.getElementById('metrics').innerHTML = [['Arms',summary.arms_total || arms.length],['Correct',summary.arms_correct || 0],['Mutations',summary.mutations || 0]].map(p => '<div><b>' + esc(p[1]) + '</b>' + esc(p[0]) + '</div>').join('');
+document.getElementById('limits').innerHTML = '<b>Not supported in this bundle:</b><br>' + esc((BUNDLE.claims?.not_supported || []).join(' · '));
+</script></body></html>"""
+
+
+def render_poster_source(
+    bundle: Mapping[str, Any], output_dir: Path, *, viewer_url: str = ""
+) -> dict[str, Path]:
+    """Write a provisional poster source and its evidence data without overwriting."""
+    if bundle.get("kind") != "aaai_demo_evidence_bundle":
+        raise EvidenceBundleError("poster source requires an AAAI demo evidence bundle")
+    target = output_dir.expanduser().resolve()
+    if target.exists():
+        raise EvidenceBundleError(f"write-once poster directory already exists: {target}")
+    target.mkdir(parents=True, exist_ok=False)
+    try:
+        poster = target / "poster.html"
+        data = target / "poster-data.json"
+        format_note = target / "format-status.json"
+        _write_once(poster, _poster_html(bundle, viewer_url))
+        _write_once(data, json.dumps(bundle, indent=2, sort_keys=True) + "\n")
+        _write_once(format_note, json.dumps(_PROVISIONAL_FORMAT, indent=2, sort_keys=True) + "\n")
+        checksums = target / "checksums.sha256"
+        lines = [
+            f"{sha256_file(path)}  {path.name}"
+            for path in sorted(target.iterdir())
+            if path.is_file()
+        ]
+        _write_once(checksums, "\n".join(lines) + "\n")
+    except Exception:
+        shutil.rmtree(target, ignore_errors=True)
+        raise
+    return {"poster": poster, "data": data, "format": format_note, "checksums": checksums}
+
+
+__all__ = ["render_poster_source"]
diff --git a/temp/papers/aaai27_demo/aaai_demo/render.py b/temp/papers/aaai27_demo/aaai_demo/render.py
new file mode 100644
index 00000000..d5f4c967
--- /dev/null
+++ b/temp/papers/aaai27_demo/aaai_demo/render.py
@@ -0,0 +1,169 @@
+"""Render a read-only demo console and a reviewable video edit decision list.
+
+The renderer produces a local HTML evidence view and an edit decision list rather
+than fabricating a movie from unavailable GUI footage. The backup-reel helper
+concatenates supplied recordings with ffmpeg but never overwrites an output.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+
+from aaai_demo.evidence import EvidenceBundleError, sha256_file, viewspec_data
+
+
+_STORYBOARD = (
+    (0, 35, "Overview and evidence contract", "State L1/headless/archive boundaries before any success claim.", "mixed"),
+    (35, 85, "Real headless structural seam", "Show the real PyQt rename, benign control, and opt-in admission.", "headless_structural"),
+    (85, 130, "World model and OODA boundary", "Show architecture or archived record; do not report uncalibrated live accuracy.", "controlled"),
+    (130, 235, "CE-X counterfactual matrix", "Show no-op, rejection, reuse, and acquisition hypothesis symmetrically.", "L1"),
+    (235, 275, "Conditional signal archive", "Play only a complete archive with state/event evidence and expect() PASS.", "archive_conditional"),
+    (275, 300, "Limitations and reproduction", "Link every claim to a hash and state unexercised boundaries.", "mixed"),
+)
+
+
+def _write_once(path: Path, content: str) -> None:
+    """Write text atomically and reject accidental evidence replacement."""
+    if path.exists():
+        raise EvidenceBundleError(f"write-once render artifact already exists: {path}")
+    temporary = path.with_name(f".{path.name}.tmp")
+    try:
+        temporary.write_text(content, encoding="utf-8")
+        temporary.replace(path)
+    except OSError as exc:
+        temporary.unlink(missing_ok=True)
+        raise EvidenceBundleError(f"cannot write render artifact: {path}") from exc
+
+
+def _safe_json(value: Any) -> str:
+    """Serialize data for an inline script without allowing a closing-script escape."""
+    return json.dumps(value, indent=2, sort_keys=True).replace("</", "<\\/")
+
+
+def _html(bundle: Mapping[str, Any]) -> str:
+    """Return a self-contained four-column read-only evidence console."""
+    payload = _safe_json(bundle)
+    return f"""<!doctype html>
+<html lang=\"en\"><head><meta charset=\"utf-8\"><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">
+<title>LeapFlow AAAI Causal Trace</title>
+<style>
+:root {{ color-scheme:dark; --bg:#10141b; --panel:#18212d; --line:#344253; --text:#e8eef8; --muted:#a4b0c0; --ok:#66d9a6; --accent:#7ab7ff; }}
+* {{ box-sizing:border-box; }} body {{ margin:0; background:var(--bg); color:var(--text); font:14px/1.45 Inter,system-ui,sans-serif; }}
+header {{ padding:18px 24px; border-bottom:1px solid var(--line); display:flex; justify-content:space-between; gap:24px; align-items:center; }} h1 {{ margin:0; font-size:20px; }} h2 {{ margin:0 0 10px; font-size:14px; color:var(--accent); letter-spacing:.04em; text-transform:uppercase; }}
+small,.muted {{ color:var(--muted); }} .badge {{ border:1px solid var(--line); border-radius:999px; padding:4px 9px; color:var(--accent); white-space:nowrap; }}
+.timeline {{ display:flex; gap:6px; padding:12px 24px; overflow:auto; border-bottom:1px solid var(--line); }} .tick {{ min-width:132px; color:var(--muted); border-left:2px solid var(--accent); padding-left:8px; }}
+.grid {{ display:grid; grid-template-columns:2.2fr 1fr 1fr .8fr; gap:10px; padding:12px; min-height:54vh; }} .panel {{ background:var(--panel); border:1px solid var(--line); border-radius:10px; padding:14px; overflow:auto; }}
+.card {{ border-top:1px solid var(--line); padding:10px 0; }} .card:first-of-type {{ border-top:0; }} .key {{ color:var(--muted); display:block; font-size:12px; }}
+button {{ background:#243247; border:1px solid var(--line); color:var(--text); padding:7px 9px; border-radius:6px; cursor:pointer; margin:0 5px 6px 0; }} button:hover,button.active {{ border-color:var(--accent); color:var(--accent); }}
+table {{ width:100%; border-collapse:collapse; }} th,td {{ text-align:left; padding:7px; border-bottom:1px solid var(--line); vertical-align:top; }} th {{ color:var(--muted); font-weight:500; }} .ok {{ color:var(--ok); }} pre {{ white-space:pre-wrap; overflow-wrap:anywhere; color:var(--muted); }}
+footer {{ padding:12px 24px 24px; color:var(--muted); }} @media(max-width:1000px) {{ .grid {{ grid-template-columns:1fr 1fr; }} }} @media(max-width:640px) {{ .grid {{ grid-template-columns:1fr; }} header {{ align-items:flex-start; flex-direction:column; }} }}
+</style></head><body>
+<header><div><h1>LeapFlow AAAI Demo · Causal Trace</h1><small id=\"run\"></small></div><span class=\"badge\" id=\"level\"></span></header>
+<div class=\"timeline\"><div class=\"tick\">t0 · State snapshot</div><div class=\"tick\">t1 · Action</div><div class=\"tick\">t2 · Actual effect</div><div class=\"tick\">t3 · Independent oracle</div><div class=\"tick\">t4 · Teacher hindsight</div><div class=\"tick\">t5 · Governance</div><div class=\"tick\">t6 · Next turn</div></div>
+<main class=\"grid\"><section class=\"panel\"><h2>Real Leapspace evidence</h2><div id=\"trajectory\"></div></section><section class=\"panel\"><h2>Observe / Orient</h2><div id=\"observe\"></div></section><section class=\"panel\"><h2>Decide / PCD</h2><div id=\"decide\"></div></section><section class=\"panel\"><h2>Governance / Effect</h2><div id=\"governance\"></div></section></main>
+<section class=\"panel\" style=\"margin:0 12px\"><h2>CE-X four-arm matrix</h2><div id=\"arms\"></div></section><section class=\"panel\" style=\"margin:12px\"><h2>Evidence drawer</h2><div id=\"drawer\"></div></section>
+<footer>Read-only derived view. It displays declared evidence boundaries rather than inferring unrecorded approval, installation, independent oracle, or daemon-runtime outcomes.</footer>
+<script>
+const BUNDLE = {payload};
+const el = id => document.getElementById(id);
+const esc = value => String(value ?? '').replace(/[&<>\"']/g, c => ({{'&':'&amp;','<':'&lt;','>':'&gt;','\"':'&quot;',"'":'&#39;'}}[c]));
+const card = (key, value, cls='') => `<div class=\"card ${{cls}}\"><span class=\"key\">${{esc(key)}}</span>${{esc(value)}}</div>`;
+const arms = Array.isArray(BUNDLE.arms) ? BUNDLE.arms : [];
+let selected = arms[0] || null;
+function render() {{
+  el('run').textContent = `${{BUNDLE.run?.run_id || 'unknown run'}} · ${{BUNDLE.run?.protocol_id || 'unknown protocol'}}`;
+  el('level').textContent = `Evidence level: ${{BUNDLE.evidence_level || 'unknown'}}`;
+  const t = BUNDLE.trajectory || {{}};
+  const archive = BUNDLE.signal_archive || {{}};
+  const seam = BUNDLE.headless_seam || {{}};
+  el('trajectory').innerHTML = card('Signal archive', archive.status || 'not_supplied') + card('Archive expect()', archive.expect?.verdict || 'not_recorded') + card('Archive artifacts', (archive.artifacts || []).length) + card('Legacy trajectory index', t.status || 'not_supplied') + card('Headless seam', seam.status || 'not_supplied');
+  const trace = (BUNDLE.causal_trace || []).filter(x => x.arm === selected?.arm && x.stage === 'observe');
+  el('observe').innerHTML = card('Drift relevance', selected?.drift_relevance) + card('Resolution', selected?.resolution) + card('Headless requirement', seam.requirement?.capability || 'not_supplied') + card('Benign control evidence', seam.benign_control?.evidence_count ?? 'not_supplied') + trace.map(x => card(x.title, x.summary)).join('');
+  el('decide').innerHTML = card('Expected action', selected?.expected_action) + card('Actual action', selected?.actual_action) + card('Match to declared oracle', selected?.matches_oracle ? 'yes' : 'no', selected?.matches_oracle ? 'ok' : '') + card('Proposal / admitted', `${{selected?.proposal_count ?? 0}} / ${{selected?.admitted_count ?? 0}}`);
+  el('governance').innerHTML = card('Approval', selected?.approval) + card('Registry mutation', selected?.registry_mutation) + card('Lifecycle', selected?.lifecycle) + card('Effect status', selected?.effect?.status) + card('Oracle boundary', selected?.effect?.note) + card('Not supported', (BUNDLE.claims?.not_supported || []).join(' · '));
+  el('arms').innerHTML = `<p>${{arms.map(a => `<button class=\"${{a.arm === selected?.arm ? 'active' : ''}}\" data-arm=\"${{esc(a.arm)}}\">${{esc(a.arm)}}</button>`).join('')}}</p><table><thead><tr><th>Arm</th><th>Relevance</th><th>Resolution</th><th>Outcome</th><th>Registry</th><th>Oracle</th></tr></thead><tbody>${{arms.map(a => `<tr><td>${{esc(a.arm)}}</td><td>${{esc(a.drift_relevance)}}</td><td>${{esc(a.resolution)}}</td><td>${{esc(a.outcome)}}</td><td>${{esc(a.registry_mutation)}}</td><td>${{esc(a.effect?.independent_oracle)}}</td></tr>`).join('')}}</tbody></table>`;
+  document.querySelectorAll('[data-arm]').forEach(button => button.onclick = () => {{ selected = arms.find(a => a.arm === button.dataset.arm) || selected; render(); }});
+  el('drawer').innerHTML = `<pre>${{esc(JSON.stringify({{selected_arm:selected, claims:BUNDLE.claims, manifest:BUNDLE.run}}, null, 2))}}</pre>`;
+}}
+render();
+</script></body></html>"""
+
+
+def _storyboard(bundle: Mapping[str, Any]) -> dict[str, Any]:
+    """Build a five-minute edit decision list with explicit evidence boundaries."""
+    run = dict(bundle.get("run") or {})
+    segments = [
+        {
+            "start_s": start,
+            "end_s": end,
+            "title": title,
+            "narration_constraint": constraint,
+            "evidence_level": evidence_level,
+        }
+        for start, end, title, constraint, evidence_level in _STORYBOARD
+    ]
+    return {
+        "schema_version": 1,
+        "kind": "aaai_demo_edit_decision_list",
+        "run_id": run.get("run_id", ""),
+        "duration_s": 300,
+        "segments": segments,
+        "required_corner_bug": "Evidence level and run ID must remain visible.",
+        "prohibited_claims": list(dict(bundle.get("claims") or {}).get("not_supported") or []),
+        "source_video": dict(bundle.get("trajectory") or {}).get("root", ""),
+    }
+
+
+def render_demo_package(bundle: Mapping[str, Any], output_dir: Path) -> dict[str, Path]:
+    """Create a write-once interactive evidence page and video composition inputs."""
+    target = output_dir.expanduser().resolve()
+    if target.exists():
+        raise EvidenceBundleError(f"write-once render directory already exists: {target}")
+    target.mkdir(parents=True, exist_ok=False)
+    try:
+        index = target / "index.html"
+        storyboard = target / "storyboard.json"
+        viewspec = target / "causal-trace.viewspec-data.json"
+        _write_once(index, _html(bundle))
+        _write_once(storyboard, json.dumps(_storyboard(bundle), indent=2, sort_keys=True) + "\n")
+        _write_once(viewspec, json.dumps(viewspec_data(bundle), indent=2, sort_keys=True) + "\n")
+        checksums = target / "checksums.sha256"
+        rows = [f"{sha256_file(path)}  {path.name}" for path in sorted(target.iterdir()) if path.is_file()]
+        _write_once(checksums, "\n".join(rows) + "\n")
+    except Exception:
+        shutil.rmtree(target, ignore_errors=True)
+        raise
+    return {"index": index, "storyboard": storyboard, "viewspec": viewspec, "checksums": checksums}
+
+
+def compose_backup_reel(clips: Sequence[Path], output_path: Path) -> Path:
+    """Concatenate reviewed video clips with ffmpeg while preserving their pixels."""
+    if not clips:
+        raise EvidenceBundleError("at least one reviewed video clip is required")
+    if output_path.exists():
+        raise EvidenceBundleError(f"write-once video output already exists: {output_path}")
+    ffmpeg = shutil.which("ffmpeg")
+    if ffmpeg is None:
+        raise EvidenceBundleError("ffmpeg is unavailable; render the HTML and EDL instead")
+    resolved = [clip.expanduser().resolve() for clip in clips]
+    if any(not clip.is_file() for clip in resolved):
+        raise EvidenceBundleError("a requested backup clip does not exist")
+    concat = output_path.with_suffix(".concat.txt")
+    if concat.exists():
+        raise EvidenceBundleError(f"write-once concat list already exists: {concat}")
+    concat.parent.mkdir(parents=True, exist_ok=True)
+    lines = ["file '" + str(clip).replace("'", "'\\''") + "'" for clip in resolved]
+    _write_once(concat, "\n".join(lines) + "\n")
+    command = [ffmpeg, "-n", "-f", "concat", "-safe", "0", "-i", str(concat), "-c", "copy", str(output_path)]
+    try:
+        subprocess.run(command, check=True, capture_output=True, text=True, timeout=600)
+    except (OSError, subprocess.SubprocessError) as exc:
+        raise EvidenceBundleError(f"ffmpeg could not compose backup reel: {exc}") from exc
+    return output_path
+
+
+__all__ = ["compose_backup_reel", "render_demo_package"]
diff --git a/temp/papers/aaai27_demo/demo_fixtures/headless-chat-probe-drifts.json b/temp/papers/aaai27_demo/demo_fixtures/headless-chat-probe-drifts.json
new file mode 100644
index 00000000..cabe1259
--- /dev/null
+++ b/temp/papers/aaai27_demo/demo_fixtures/headless-chat-probe-drifts.json
@@ -0,0 +1,69 @@
+{
+  "schema_version": 1,
+  "kind": "leapspace_structural_drift_fixture",
+  "evidence_level": "real_headless_structural_seam",
+  "source_test": "temp/leapspace_exp/evo-02/tests/test_environment_source_live.py",
+  "description": "The exact value-free before/after identities exercised by the real offscreen PyQt6 structural-seam test. This fixture is distinct from task-001's message_input rename scenario.",
+  "drifts": [
+    {
+      "drift_id": "chat-probe.send-button.rename.v1",
+      "class": "interface_rename",
+      "reversible": true,
+      "before": {
+        "app_id": "chat_probe",
+        "version": "1.0",
+        "elements": [
+          {"name": "message_input", "role": "QLineEdit"},
+          {"name": "send_button", "role": "QPushButton"}
+        ]
+      },
+      "after": {
+        "app_id": "chat_probe",
+        "version": "1.1",
+        "elements": [
+          {"name": "message_input", "role": "QLineEdit"},
+          {"name": "dispatch_button", "role": "QPushButton"}
+        ]
+      },
+      "capability_precondition": {
+        "capability": "chat.reply",
+        "bound_names": ["send_button"]
+      },
+      "expected": {
+        "evidence_kind": "interface_drift",
+        "requirement_origin": "environment_probe",
+        "admission": "experiment_opt_in_only"
+      }
+    },
+    {
+      "drift_id": "chat-probe.benign-emoji-added.v1",
+      "class": "benign_negative_control",
+      "reversible": true,
+      "before": {
+        "app_id": "chat_probe",
+        "version": "1.0",
+        "elements": [
+          {"name": "message_input", "role": "QLineEdit"},
+          {"name": "send_button", "role": "QPushButton"}
+        ]
+      },
+      "after": {
+        "app_id": "chat_probe",
+        "version": "1.1-benign",
+        "elements": [
+          {"name": "message_input", "role": "QLineEdit"},
+          {"name": "send_button", "role": "QPushButton"},
+          {"name": "emoji_picker", "role": "QPushButton"}
+        ]
+      },
+      "capability_precondition": {
+        "capability": "chat.reply",
+        "bound_names": ["send_button"]
+      },
+      "expected": {
+        "evidence_kind": "none",
+        "requirement_count": 0
+      }
+    }
+  ]
+}
diff --git a/temp/papers/aaai27_demo/demo_fixtures/task-001-structural-drifts.json b/temp/papers/aaai27_demo/demo_fixtures/task-001-structural-drifts.json
new file mode 100644
index 00000000..453e9f04
--- /dev/null
+++ b/temp/papers/aaai27_demo/demo_fixtures/task-001-structural-drifts.json
@@ -0,0 +1,124 @@
+{
+  "schema_version": 1,
+  "kind": "leapspace_structural_drift_fixture",
+  "evidence_level": "L2-planned",
+  "task_ref": "src/leapspace/app_space/tasks/task-001/config.yaml",
+  "description": "Declarative before/after StateSnapshot projections for the AAAI demo. These fixtures are not recorded evidence and must be paired with a real Leapspace trajectory and expect() output before they are presented as L2 results.",
+  "drifts": [
+    {
+      "drift_id": "chat.message-input.rename.v1",
+      "class": "interface_rename",
+      "reversible": true,
+      "before": {
+        "app_id": "chat",
+        "version": "1",
+        "elements": [
+          {"name": "contact_list", "role": "QListWidget"},
+          {"name": "message_history", "role": "QTextEdit"},
+          {"name": "message_input", "role": "QLineEdit"},
+          {"name": "send_button", "role": "QPushButton"}
+        ]
+      },
+      "after": {
+        "app_id": "chat",
+        "version": "2",
+        "elements": [
+          {"name": "contact_list", "role": "QListWidget"},
+          {"name": "message_history", "role": "QTextEdit"},
+          {"name": "reply_editor", "role": "QLineEdit"},
+          {"name": "send_button", "role": "QPushButton"}
+        ]
+      },
+      "capability_precondition": {
+        "capability": "chat.reply",
+        "bound_names": ["message_input", "send_button"],
+        "affordances": ["app.chat.reply"]
+      },
+      "expected": {
+        "evidence_kind": "interface_drift",
+        "lowest_cost_actions": ["absorb", "rebind"],
+        "must_not_default_to": "acquire"
+      },
+      "oracle": {
+        "kind": "leapspace_expect",
+        "status": "not_recorded",
+        "required_checks": ["reply-sent", "followup-arrived", "event-reply", "event-followup"]
+      }
+    },
+    {
+      "drift_id": "chat.reply-affordance.removed.v1",
+      "class": "affordance_removed",
+      "reversible": true,
+      "before": {
+        "app_id": "chat",
+        "version": "1",
+        "affordances": ["app.chat.reply"],
+        "elements": [
+          {"name": "message_input", "role": "QLineEdit"},
+          {"name": "send_button", "role": "QPushButton"}
+        ]
+      },
+      "after": {
+        "app_id": "chat",
+        "version": "2",
+        "affordances": [],
+        "elements": [
+          {"name": "message_input", "role": "QLineEdit"},
+          {"name": "send_button", "role": "QPushButton"}
+        ]
+      },
+      "capability_precondition": {
+        "capability": "chat.reply",
+        "bound_names": ["message_input", "send_button"],
+        "affordances": ["app.chat.reply"]
+      },
+      "expected": {
+        "evidence_kind": "affordance_removed",
+        "eligible_actions": ["rebind", "acquire", "escalate"],
+        "requires_resolution_first": true
+      },
+      "oracle": {
+        "kind": "leapspace_expect",
+        "status": "not_recorded",
+        "required_checks": ["reply-sent", "followup-arrived"]
+      }
+    },
+    {
+      "drift_id": "chat.benign-status.added.v1",
+      "class": "benign_negative_control",
+      "reversible": true,
+      "before": {
+        "app_id": "chat",
+        "version": "1",
+        "elements": [
+          {"name": "message_input", "role": "QLineEdit"},
+          {"name": "send_button", "role": "QPushButton"}
+        ]
+      },
+      "after": {
+        "app_id": "chat",
+        "version": "2",
+        "elements": [
+          {"name": "message_input", "role": "QLineEdit"},
+          {"name": "send_button", "role": "QPushButton"},
+          {"name": "sync_status", "role": "QLabel"}
+        ]
+      },
+      "capability_precondition": {
+        "capability": "chat.reply",
+        "bound_names": ["message_input", "send_button"],
+        "affordances": ["app.chat.reply"]
+      },
+      "expected": {
+        "evidence_kind": "none",
+        "action": "no_op",
+        "proposal_count": 0
+      },
+      "oracle": {
+        "kind": "leapspace_expect",
+        "status": "not_recorded",
+        "required_checks": ["reply-sent"]
+      }
+    }
+  ]
+}
diff --git "a/temp/papers/aaai27_demo/plan/AAAI-27_Demo_\350\256\272\346\226\207\345\206\231\344\275\234\350\256\241\345\210\222.md" "b/temp/papers/aaai27_demo/plan/AAAI-27_Demo_\350\256\272\346\226\207\345\206\231\344\275\234\350\256\241\345\210\222.md"
new file mode 100644
index 00000000..b08ef61d
--- /dev/null
+++ "b/temp/papers/aaai27_demo/plan/AAAI-27_Demo_\350\256\272\346\226\207\345\206\231\344\275\234\350\256\241\345\210\222.md"
@@ -0,0 +1,280 @@
+# AAAI-27 Demo 论文写作计划
+
+> 主题：从**自我进化 Harness**视角，结合 LeapFlow 的 **LLM world model + leapspace + 自我进化机制**，并以面向真实世界信号的 **OODA loop** 为辅线，写一篇 AAAI-27 Demonstrations Program 短论文（demo paper）。
+>
+> 本计划为写作蓝图，不是论文正文；正文按第 4 节大纲分节撰写。
+>
+> 约束来源：`../official/AAAI-27_Demonstration_Program_官方信息与投稿要求.md`（下称 official 文档，其中 [S1]=官方 Call，[S2]=Author Kit，[S3]=OpenReview 站点）。
+> 技术事实来源：`/Users/jason/work/github/leapflow` 代码库只读核查（文件路径见第 13 节证据台账）。
+
+---
+
+## 0. 官方硬约束回执（写作前必须锁定）
+
+以下每条都直接决定写作与排版，均取自 official 文档，不得违反：
+
+| 约束 | 取值 | 对写作的含义 |
+|---|---|---|
+| 正文篇幅 | two-page short paper | 正文严格控制在 **2 页**，超出即被退回。 |
+| 参考文献 | one page of references only | references 单独占 **1 页**，且该页只能放参考文献。 |
+| 排版 | AAAI two-column style（`aaai2027.sty` / `aaai2027.bst`） | 用 [S2] 的 `AnonymousSubmission2027.tex` 起稿；不得改 page layout。 |
+| 视频 | video up to 5 minutes（可用 slides 替代，但 video 权重更高） | 必须产出 ≤5 分钟 demo 视频，作为 supplementary materials 传 OpenReview。 |
+| 视频开头 | highly recommend 加 30s–1min overview（非强制） | 视频前 30–60s 放系统总览。 |
+| 内容要求 | 呈现 technical details + 讨论 related work + 描述 significance + previously unpublished | 四要素在 2 页内都要出现，缺一不可。 |
+| 新颖性 | 必须是 new ideas，非 mainstream products/services 已有 | 论文主张要落在“治理化、可解释、可回滚的信号驱动进化”这一差异点。 |
+| 盲审 | single-blind 或 double-blind 二选一 | 见第 3 节匿名策略；默认建议 double-blind。 |
+| reproducibility checklist | Demo track 不要求 | 不写、不传 checklist。 |
+| 现场义务 | 至少一位 author 现场 in-person 演示；有 live demo 时段 | 论文与视频都要体现“可现场跑”，不是纯录播概念。 |
+| 提交入口/截止 | [S3] OpenReview；实际底线取较早者 | [S1] 名义 Sep 18, 2026 11:59 PM AOE (UTC-12)；但 [S3] 系统强制 **Sep 18, 2026 11:59 UTC**（约早 24h），以较早的 [S3] 时间为提交底线，见第 12 节。 |
+| Author Kit 范围 | 仅取 two-column style / anonymous 参考 | [S2]（含 `CameraReady2027.tex`）是面向 accepted-paper publication 的通用发表指南；其 source 上传、文件命名、copyright form、page charge 等**不作为 Demo 初投义务**，除非 [S1] 明确要求。 |
+| 附录/页数边界 | Content Appendices 计入 page limits | 附录不为 Demo 增加页；全部非参考文献内容须落在 2 页内，额外一页只放 references。 |
+| backup mode | official 措辞为 `It is expected`（非 `must`） | 仍应准备不依赖 special arrangement 的 backup，但定位为“预期”而非强制。 |
+
+---
+
+## 1. 论文定位与核心主张
+
+### 1.1 一句话定位（demo thesis）
+
+> **展示一个“自我进化 Harness”：它把真实 headless structural signal、条件性 signal-mode archive 与受控 counterfactual evidence 组织为可审计的 capability decision——cold-path world model 提供 teacher/student 与 four-value action space，OODA/PCD 解释执行深度，leapspace 提供 ground-truth structural envelope，而 off-by-default 的 governed pipeline 将 capability hypothesis 与实际 mutation authority 分离。**
+
+### 1.2 差异化卖点（对应 [S1] 的 new ideas 要求）
+
+主流 agent 产品的能力集要么是硬编码、要么是无治理地自动写代码。本 demo 的新点在于把“进化”做成一条**可治理、可审计、可回滚**的管线，并显式区分两层：
+
+- **“agent 知道什么”**（world model 的 grading + distillation）：始终运行、不写代码、不改能力集、零额外风险；
+- **“agent 能做什么”**（acquire→proposal→…→verified 的能力写入）：off-by-default、逐门放行、每步留痕。
+
+这一“knows vs can-do”分离，加上对 no-op/reject/reuse/unexercised boundary 的 causal evidence 可视化，是可现场演示的系统贡献；真实 install/approval/daemon long-horizon 仍按第 2 节的证据边界处理。
+
+### 1.3 贡献点（demo paper 版，写进 Introduction 末尾，3 条以内）
+
+- **C1**：一个可观测、可干预的 `signal → OODA → world model → governed decision` Harness：真实 headless structural signal 与受控 CE-X 反事实都能进入同一证据叙事；不把它表述为 GUI-agent end-to-end execution。
+- **C2**：cold-path teacher/student world model 的 information-context 不对称与 four-value action space（absorb/rebind/acquire/escalate），分别服务知识蒸馏与 capability hypothesis；在 controlled ablation 完成前，不以现有 N=3/confounded 样本宣称可泛化诊断准确率。
+- **C3**：把 capability evolution 的 policy/lifecycle/approval contracts 与可审计 evidence boundary 展示为治理对象；CE-X 保留 no-op/reject/reuse/acquire-hypothesis，但真实 install、approval、daemon long-horizon trust/rollback 只在已有同 run artifact 时宣称。
+
+---
+
+## 2. 忠实性边界（本计划最重要的一节：可宣称 vs 不可宣称）
+
+demo paper 必须 previously unpublished 且不得 overclaim。以下边界基于代码核查，务必在正文/视频中严格遵守。
+
+### 2.1 可以作为“可运行/可现场演示”宣称
+
+- world model 的 **grading + distillation 始终运行**（不受 `evolution_enabled` 控制）：对每个 session 打分、把学到的环境知识蒸馏进下一轮 context、并推荐优先使用哪个已装 provider。证据：`config.py` 注释、`world_model/trajectory_grader.py`、`storage/distilled_knowledge_store.py`。
+- **four-value 裁决**（absorb/rebind/acquire/escalate）与 `rebind`/`acquire` 的替代者判定逻辑（`build_alternatives_provider` + `requires_environment_affordances`）。证据：`domain/adaptation_verdict.py`、`learning/degradation_sink.py`。
+- **OODA loop + 弹性预算 + PCD**：`_run_agent_loop()`、`IterationBudget`（fixed/elastic）、`DisclosurePlanner`（CORE/EXPANDED/FULL）。证据：`engine/engine.py`、`engine/budget.py`、`engine/context_disclosure.py`、`engine/agent_loop.py`。
+- **治理管线的 Protocol 可达性与状态机**：`EvolutionProposalView`/`EvolutionLifecycleStore`/`OutcomeStore`、`AdaptiveEvolutionPolicy`、`LifecycleGovernor`、`PluginTrustLedger`；acquisition lifecycle 状态 `PENDING→GENERATED→APPROVED→INSTALLED→PROBATION→VERIFIED→REJECTED/FAILED/QUARANTINED`。证据：`plugins/evolution_contracts.py`、`plugins/adaptive_policy.py`、`plugins/lifecycle_governor.py`、`learning/plugin_trust.py`。
+- **可现场展示的入口**：CLI（`leap`）、TUI、leapd daemon；`leap config` 查看 `evolution_enabled` 等开关；`plugin_list` 的 live `capability_report`；`self_management` 工具插件的 `plugin_propose`/`plugin_generate`/`plugin_install`。证据：`cli/`、`daemon/`、`plugins/tool_plugins/self_management.py`。
+- **leapspace signal 模式**可运行：sandbox 内 `BaseLeapApp` 原子写 `state.json` / `events.jsonl`，`LeapAppHarness` 录制 reference stimulus 并运行 `expect()` 判定 PASS/FAIL。证据：`src/leapspace/app_space/harness.py`、`.../apps/_base.py`、`.../signal.py`。这不是 agent 在 sandbox 内求解任务。
+- **真实 headless structural seam**可运行：两个 offscreen PyQt6 `BaseLeapApp` 版本写出 role-aware `elements`；`LeapSpaceHostRpc` 以 `state.json` 满足 HostRpc 的结构查询；实验侧 `LeapSpaceEnvironmentSource` 将真实 rename 送入 shipped `CapabilityObservationService`，获得 opt-in `interface_drift` observation 和 `CapabilityRequirement(origin=environment_probe)`，并有 benign negative control/default refusal。证据：`src/leapspace/app_space/host_rpc.py`、`temp/leapspace_exp/evo-02/leapexp2/leapspace_source.py`、对应 tests。
+
+### 2.2 必须明确标注为“off-by-default / 实验性 / 未实现”，不可当既成能力宣称
+
+- **`evolution_enabled` 默认 False**：`acquire` 裁决→排队 proposal 的分支默认关闭；即便开启，generation/validation/approval/sandbox/trust 仍是其前方多道门。→ 正文措辞用“governed, opt-in pipeline”，**不要**写“系统会自主写代码上线”。
+- **learning 回路需显式配置**：`accepted_evidence_kinds` / `active_signal_sources` 为空时评分-获取回路处于惰性；现有 skills 皆 builtin。→ 演示自进化时须说明这是“operator opt-in”的实验配置。
+- **leapspace e2e 模式 = NotImplementedError**（`app_space/e2e.py` 为空）：signal mode 只录制 reference stimulus 与 ground-truth verdict，不能让 agent 在 sandbox 里“求解”。→ 演示 leapspace 时不得暗示 e2e 闭环。
+- **headless structural seam 无 framebuffer**：`LeapSpaceHostRpc.screen.capture_frame` 诚实返回空；真实 widget rename→requirement 不等同于 Linux/KVM/AT-SPI 的 L2 GUI/OS/pixel 证据。→ 作为独立 lane，不升级为 EXP-7 已完成。
+- **C2 的 acquire 不等于真实 mutation**：canonical runner 明示未执行 code generation、approval prompt、real install、daemon、RecoveryCoordinator 与真实 LLM diagnosis。→ 画面必须显示 `not_exercised`，不可展示为 plugin 已上线。
+- **S1–S4（持久化方向、事件驱动重入、在线校准、常驻无限循环/resident agent）** 多为设计或默认关闭（`agent.reentry_enabled` 默认关闭）。→ 归入 “future work / roadmap”，不进 demo 主线。
+- `temp/leapspace_exp` 的 headless environment source 已是受测实验 seam，但仍是 experiment/reference layer；正文应描述其真实 widget→observation 事实，同时注明它尚非 e2e/daemon runtime 证据。
+
+### 2.3 写作纪律
+
+- 动词分级：始终运行的用“does / runs”；开关后的用“can, when enabled / opt-in”；未实现的用“is designed to / planned”。
+- 每条能力主张尽量对应视频里一个真实可见的画面（第 6、7 节）。
+
+---
+
+## 3. 标题、作者与匿名策略
+
+### 3.1 候选标题（保持术语原文，二选一或微调）
+
+- 主推：**“LeapFlow: A Self-Evolving Harness that Turns Real-World Signals into Governed Capability Evolution”**
+- 备选：**“From Signals to Governed Evolution: Demonstrating a World-Model-Driven Self-Evolving Agent Harness”**
+
+要点：标题需含 demo/system 气质，并同时出现 self-evolving / Harness / world model / governed 等关键词。
+
+### 3.2 匿名策略（对应 official 第 7 节）
+
+- **默认建议 double-blind**：用 [S2] `AnonymousSubmission2027.tex`（`\usepackage[submission]{aaai2027}`），作者写 “Anonymous Submission”、清空 affiliations、提交前用 metadata-cleaning 工具清 PDF metadata、首页不放 copyright footer。
+- 视频与代码链接也要匿名化（去掉含真实机构/个人的仓库 URL、账号、水印）；如需公开仓库，改用匿名镜像或 anonymized 链接。
+- 若最终选 single-blind，则作者信息正常出现，但仍需保证内容一致。
+
+---
+
+## 4. 逐节写作大纲与篇幅预算（2 页正文）
+
+> 目标：2 页两栏。建议总正文 ~1300–1600 词 + 1 张主图 +（可选）1 张小图/小表。references 另占第 3 页。以下“预算”为占版比例的经验值，撰写时以不超 2 页为硬红线。
+
+### 4.1 Title + Abstract（~8%）
+- Abstract 100–130 词：点出 gap（固定能力集/无治理自写代码）→ 我们 demo 什么（Harness + world model + governed evolution + OODA/leapspace）→ 现场观众能看到什么 → 差异点（knows vs can-do 的治理化分离）。
+
+### 4.2 §1 Introduction & Motivation（~22%）
+- 真实世界信号驱动的 agent 面临的问题：环境会漂移，能力集要么僵化、要么被不受控地自动改写。
+- 提出 demo 的核心命题（1.1）与 3 条贡献（1.3）。
+- 明确“这是一个可现场交互的系统 demo”，并预告 §3 现场脚本。
+
+### 4.3 §2 System Overview（~30%，配主图 Figure 1）
+分 4 个小段，每段 2–4 句，对应架构 4 大件：
+- **(a) OODA loop 与自适应深度**：Observe（意图分类/技能触发）→ Orient（PCD 分层定向，CORE/EXPANDED/FULL）→ Decide（LLM 选工具/回复）→ Act（执行+观察）；`IterationBudget` 按 difficulty 弹性调节迭代上限。
+- **(b) leapspace 环境侧信号**：`BaseLeapApp` 原子写 `state.json`/`events.jsonl` 与 role-aware `elements`；`LeapSpaceHostRpc` 将这些 ground truth 暴露为结构化 HostRpc facets。signal mode 可录制 reference stimulus 并运行 `expect()`；独立的 offscreen real-widget seam 证明 rename→`interface_drift`→`environment_probe` requirement，且保留 benign/default-off negative controls。
+- **(c) LLM world model（teacher/student, cold path）**：teacher 见全轨迹、student 只见当前态（information-context 不对称，源自 On-Policy Distillation 的 teacher-as-reward-model 思路）；`grade_and_propose()` 单次 LLM 调用同时产出 grades 与 four-value verdicts；`absorb/rebind` 走知识蒸馏与 provider 优选，`acquire` 才是能力获取的 hypothesis，`escalate` 上抛。
+- **(d) Governed self-evolution pipeline**：acquire→proposal→generate→validate（syntax/structure/import/protocol）→compatibility→approval→install→sandbox smoke→register(DRAFT)→behavior tests→probation→trust accrual→verify；由 `AdaptiveEvolutionPolicy` 读结构化 (trust/risk/status/autonomy) 决策，`LifecycleGovernor` 记录转移与 trust ledger。**强调 off-by-default 与逐门放行。**
+
+### 4.4 §3 Demonstration（~28%，可配 Figure 2 或时间线小图）
+- 现场剧本（见第 6 节）压缩为 3 个 scene：①真实 headless widget rename/benign control→opt-in requirement；②CE-X 的 none/reject/reuse/acquire-hypothesis 与 teacher/student/OODA 边界；③完整时才出现的 signal archive 与 read-only evidence console。
+- 明确“观众看到的界面”：headless seam record、`records.jsonl`/`summary.json`、bundle console、条件性的 signal archive、以及可选 live `causal_trace` lens；不把 `plugin_list` 或 `plugin_install` 的普通入口当作该 experiment 已执行的证据。
+- 一句话点出可交互性：观众可选择 rename/benign fixture、是否 opt-in evidence kind 和 C2 arm，观察 observation、requirement、resolution 与明确的 `not_exercised` 边界；不在现场改写 capability。
+
+### 4.5 §4 Significance, Related Work & Limitations（~12%）
+- Significance：对 AI 社区的意义——把 self-evolution 从“黑箱自改写”变成“可解释、可回滚、可审计”的治理对象；knows/can-do 分离降低风险。
+- Related work（2–4 句，密集引用，见第 8 节）：train-free / on-policy distillation、LLM agents 与 tool learning、self-improving/self-modifying agents、agent governance & safety、world models for agents。
+- Limitations（1–2 句，诚实）：acquire 通道 opt-in；CE-X 未执行真实 install/approval/daemon/independent oracle；leapspace e2e 未实现，headless seam 无 pixels；teacher live diagnosis 仍是 N=3/confounded；resident/reentry 未默认启用——与第 2.2 节一致。
+
+### 4.6 References（第 3 页，仅参考文献）
+- 用 `\bibliography` + `aaai2027.bst`；控制在能放满但不溢出 1 页的数量（约 12–20 条）。
+
+---
+
+## 5. 图表计划（适配两栏，PDFLaTeX 只接受 .pdf/.png/.jpg）
+
+- **Figure 1（主图，跨栏或单栏均可）— 系统架构与信号流**：从 leapspace/真实交互的 signals → OODA loop（含 PCD 分层与 elastic budget）→ world model（teacher/student + four-value verdict）→ 分叉：`absorb/rebind`（distilled knowledge / provider 优选，always-on）与 `acquire`（governed pipeline，gated）。图上用不同底色区分 always-on vs off-by-default。**这是必备图**，承担 §2 主要信息量。
+- **Figure 2（可选，小图/时间线）— governed evolution lifecycle**：画 acquisition lifecycle 状态机（PENDING→…→VERIFIED，以及 REJECTED/FAILED/QUARANTINED 分支），标出 approval 门与 trust/probation 节点。若 2 页排不下则并入 Figure 1 或省略。
+- **不使用**：截图堆叠、type-3 字体、.gif/.eps；图内文字用矢量 pdf，保证 300dpi 以上或矢量。
+- 图注（caption）承担部分说明，减轻正文字数压力。
+
+---
+
+## 6. Demo 现场脚本（storyboard，供 §3 与视频共用）
+
+3 幕均以可核验 artifact 为前提；TUI/直接 `plugin_install` 不再是主线，避免用未闭合的 e2e/approval 代替证据：
+
+- **Scene A — 真实 headless structural signal（~1.25 min）**
+  - 运行 write-once headless seam：真实 offscreen PyQt6 widgets 写 `elements`，`send_button → dispatch_button` 经 `LeapSpaceEnvironmentSource` 产生 `interface_drift` 与 `environment_probe` requirement。
+  - 同屏展示 benign negative control 和 default classifier refusal，强调 observation ingress 不授予 mutation authority；明确无 pixels/GUI-agent e2e。
+
+- **Scene B — CE-X 受控四臂与 world-model/OODA 边界（~2 min）**
+  - 运行/回放 `run_c2.py` 的 `records.jsonl`/`summary.json`，对称展示 none、rejected、reuse 和 acquire hypothesis；C2 的 live catalog resolution、profile isolation、authorisation 和 handler-reported verifier 是可见事实。
+  - world model/PCD 仅展示架构或同 run 记录的 information boundary 与 four-value action space；不把 N=3/confounded 样本说成 accuracy result。
+
+- **Scene C — 条件性 signal archive 与 read-only evidence console（~1 min）**
+  - 有完整 manifest 时播放 reference stimulus + `expect()` PASS、state/event 与 media hashes；无 archive 时 console 显示 `not_supplied`，不以代理画面替代。
+  - `aaai_demo render` 的 bundle console 展示 claims、unexercised approval/install/daemon/independent oracle；`causal_trace` 仅在 live framework-evolution finding 存在时作为只读补充。
+
+- **收尾（~0.5 min）**：回到 thesis——knows/can-do 分离、负结果可见、每种证据层级不互相升级。
+
+> 备用/backup mode（official 第 10 节；[S1] 措辞为 `It is expected`，非 `must`）：若现场 LLM/网络不可用，运行 deterministic headless seam + C2 + 已封存 bundle；若已审核 signal archive 存在，使用 `backup-reel` 拼接它。不得为了 backup 伪造 GUI/e2e/approval 成功。
+
+---
+
+## 7. 视频计划（≤5 分钟）
+
+| 时间 | 内容 | 对应 |
+|---|---|---|
+| 0:00–0:35 | overview：一句话 thesis + evidence-level architecture（对应 [S1] 建议的 30–60s overview） | §Abstract/§1 |
+| 0:35–1:25 | Scene A：headless PyQt rename、negative control、opt-in observation admission | §2(b), §3① |
+| 1:25–2:10 | teacher/student + OODA/PCD 的结构边界，不报告未校准 rate | §2(a,c) |
+| 2:10–3:55 | Scene B：CE-X 四臂与 `not_exercised` 证据边界 | §2(d), §3② |
+| 3:55–4:35 | Scene C：完整时才播放 signal archive；否则显示 `not_supplied` | §2(b), §3③ |
+| 4:35–5:00 | 收尾、limitations、`run_c2 → bundle → render` 复现路径 | §4 |
+
+- 主视频严格 ≤5 分钟；`aaai_demo.render` 的 EDL 必须是 300 秒。录屏用真实 terminal output、bundle console 和已审核 archive；关键处持续显示 evidence level 与 run ID。
+- double-blind：视频去除机构水印、真实账号、可识别路径；导出前清 metadata。
+- 交付格式：常见 mp4/H.264；作为 supplementary materials 上传 OpenReview。
+
+---
+
+## 8. Related work 引用清单（供撰写与 .bib 组织，按主题）
+
+按主题各选代表作，密集但精炼（最终 12–20 条，放第 3 页）：
+
+- **On-Policy Distillation / train-free learning**：teacher-as-reward-model、hindsight 轨迹打分（对应 `trajectory_grader.py` 的思想来源）。
+- **LLM agents & tool learning**：ReAct、Toolformer、以及 tool-use/agent survey。
+- **Self-improving / self-modifying agents**：Voyager（skill library 自增长）、自反思类（Reflexion）、自动化 agent 构建。
+- **Agent governance / safety / approval**：human-in-the-loop 审批、能力沙箱与隔离、progressive autonomy/trust 的相关工作。
+- **World models for agents**：world-model-based planning/adaptation 的代表作。
+- **Environment / benchmark & CUA sandbox**：computer-use agent、GUI/desktop 交互环境（对应 leapspace 定位）。
+
+> 写作时每个主题 1–3 句带过，用 `\citep`/`\citet`；避免逐篇展开（篇幅不允许）。真实 bib 条目在起稿时据实补全，勿编造引用。
+
+---
+
+## 9. 术语与命名规范（保持原文，不翻译）
+
+正文中以下术语**一律保留英文原样**（首次出现可加一句中文/英文释义，其后直接用原词）：
+
+- 架构/机制：`Harness`、`world model`、`teacher/student`、`OODA loop`、`Observe/Orient/Decide/Act`、`Progressive Context Disclosure (PCD)`、`leapspace`、`self-evolution`、`capability`、`plugin`。
+- 裁决/生命周期：`absorb / rebind / acquire / escalate`、`EvolutionIntent`、`CapabilityRequirement`、`AdaptiveEvolutionPolicy`、`LifecycleGovernor`、`trust / probation / quarantine`、lifecycle 状态 `PENDING/GENERATED/APPROVED/INSTALLED/PROBATION/VERIFIED/REJECTED/FAILED/QUARANTINED`。
+- 开关/配置：`evolution_enabled`、`accepted_evidence_kinds`、`selection_policy`、`distilled_knowledge_ttl_s`。
+- 入口：`leapd`、`TUI`、`leap config`、`plugin_list`、`capability_report`、`plugin_propose/generate/install`。
+
+统一大小写与拼写（如 `LeapFlow`、`leapspace`、`OODA`），全篇一致。
+
+---
+
+## 10. 排版与提交 checklist（AAAI Kit + OpenReview）
+
+起稿与交付逐项核对（对应 official 第 6/7/11 节）：
+
+- [ ] 用 `AnonymousSubmission2027.tex` 起稿，加载 `\usepackage[submission]{aaai2027}`；引用 `aaai2027.bst`。
+- [ ] 正文 ≤2 页；references 单独 1 页且只放参考文献。
+- [ ] 不改 page layout（禁 `\columnsep`/`\textwidth`/geometry 等）；不打印页码；正文 10pt Times、无正文着色。
+- [ ] 图为 .pdf/.png/.jpg，无 type-3 字体，不侵入 margin。
+- [ ] double-blind：无作者名/机构、清 PDF metadata、首页无 copyright footer；视频/链接同步匿名。
+- [ ] 不含 reproducibility checklist（Demo track 不要求）。
+- [ ] 视频 ≤5min，含 30–60s overview，作为 supplementary 上传；（可选）代码作为 supplementary。
+- [ ] 按官方“expected”预期具备 backup mode（预录 signal trace + cassette 回放）；[S1] 用词为 `It is expected`、非 `must`。
+- [ ] Author Kit 范围自限：不把 [S2] 中仅面向 accepted-paper publication 的事项（LaTeX source 上传、文件命名、copyright form、page charge）当作 Demo 初投义务，除非 [S1] 明确要求。
+- [ ] 页数边界自检：Content Appendices 计入 page limits、不为 Demo 增加附录页；全部非参考文献内容落在 2 页内，额外一页只放 references。
+- [ ] OpenReview 账号就绪，经 [S3] 提交；以较早的 [S3] 系统强制时间 **Sep 18, 2026 11:59 UTC** 为实际底线（[S1] 名义为 Sep 18 11:59 PM AOE / UTC-12，约晚 24h），务必按较早者完成 final submission。
+- [ ] 全篇“动词分级”自检（第 2.3 节），无 overclaim。
+
+---
+
+## 11. 建议的 plan 目录产出物
+
+本次先产出本写作计划；后续在同目录（`../plan/`）可逐步补齐：
+
+- `outline.md`（可选）：把第 4 节大纲拆成逐段 bullet，供直接填字。
+- `figures/`（可选）：Figure 1/2 的草图与最终矢量图源。
+- `related_work.bib`（可选）：第 8 节引用的真实 bib 条目。
+- `video_script.md`（可选）：第 7 节脚本逐镜头细化 + 旁白稿。
+
+（正文 `.tex` 建议放到独立的 `../submission/` 目录，与 plan 分离。）
+
+---
+
+## 12. 任务分解与时间线（实际提交底线 [S3] Sep 18, 2026 11:59 UTC / notify Nov 6 / camera-ready Nov 20）
+
+> 截止时间跨来源核对：[S1] 名义 Sep 18, 2026 11:59 PM AOE (UTC-12)（≈Sep 19 11:59 UTC），[S3] OpenReview 系统强制 Sep 18, 2026 11:59 UTC（约早 24h）。本计划一律以较早的 [S3] 时间为底线。
+
+| 阶段 | 产出 | 建议完成点 |
+|---|---|---|
+| T0 计划确认 | 本文件 + 与合作者确认 thesis/边界 | 立即 |
+| T1 证据固化 | 复核第 2 节可宣称/不可宣称清单，逐条对齐代码 | +2 天 |
+| T2 主图 | Figure 1 定稿（架构+信号流+always-on/gated 分色） | +4 天 |
+| T3 初稿 | §1–§4 正文（控 2 页）+ references 草表 | +8 天 |
+| T4 demo 环境 | 现场剧本三幕可跑 + backup（cassette）验证 | +10 天 |
+| T5 视频 | 录屏 + 剪辑 ≤5min + overview + 匿名化 | +13 天 |
+| T6 匿名与排版终审 | double-blind 自检 + Kit 合规 checklist 全绿 | 截止前 3 天 |
+| T7 提交 | OpenReview 上传 paper + 视频/补充材料 | [S3] Sep 18, 2026 11:59 UTC 前（较 [S1] 名义 AOE 早约 24h，取较早者） |
+
+（若录用：Nov 20 前完成 camera-ready，并按 official 第 10 节与 Chairs 敲定现场展台/特殊需求。）
+
+---
+
+## 13. 证据台账（技术主张 → 代码路径）
+
+供撰写与自检时溯源，避免 overclaim：
+
+- world model / teacher-student：`src/leapflow/world_model/trajectory_grader.py`、`src/leapflow/learning/world_model_driver.py`、`src/leapflow/storage/distilled_knowledge_store.py`
+- four-value / 替代者判定：`src/leapflow/domain/adaptation_verdict.py`、`src/leapflow/domain/evolution_intent.py`、`src/leapflow/learning/degradation_sink.py`（`build_alternatives_provider` / `requires_environment_affordances`）
+- OODA / 预算 / PCD：`src/leapflow/engine/engine.py`（`_run_agent_loop`）、`src/leapflow/engine/budget.py`（`IterationBudget`）、`src/leapflow/engine/context_disclosure.py`（`DisclosurePlanner`）、`src/leapflow/engine/agent_loop.py`
+- 治理管线：`src/leapflow/plugins/evolution_contracts.py`、`src/leapflow/plugins/adaptive_policy.py`、`src/leapflow/plugins/lifecycle_governor.py`、`src/leapflow/learning/plugin_trust.py`、`src/leapflow/learning/capability_gap_detector.py`、`src/leapflow/learning/plugin_generator.py`
+- 开关/配置：`src/leapflow/config.py`（`evolution_enabled` 默认 False、`accepted_evidence_kinds`、`distilled_knowledge_*`、`selection_policy`）
+- 入口/演示：`src/leapflow/cli/`、`src/leapflow/daemon/`、`src/leapflow/plugins/tool_plugins/self_management.py`
+- leapspace：`src/leapspace/app_space/harness.py`（signal 可用 / e2e `NotImplementedError`）、`src/leapspace/app_space/apps/_base.py`（role-aware elements）、`src/leapspace/app_space/host_rpc.py`（headless structural HostRpc）、`src/leapspace/app_space/signal.py`、`src/leapspace/app_space/e2e.py`（空）
+- headless environment seam：`temp/leapspace_exp/evo-02/leapexp2/leapspace_source.py`、`tests/test_environment_source_l1.py`、`tests/test_environment_source_live.py`；它们证明 widget→observation/requirement，不替代 e2e。
+- Demo evidence tooling：`temp/papers/aaai27_demo/aaai_demo/{headless_seam,evidence,render,cli}.py`、`demo_fixtures/`、`reproduction.md`。
+- 诚实局限性素材：`temp/leapspace_exp/` 的实验计划与 reports，尤其是 L1/L2/L3 划分、real-LLM N=3/confounded 与 C2 substitutions。
diff --git a/temp/papers/aaai27_demo/reproduction.md b/temp/papers/aaai27_demo/reproduction.md
new file mode 100644
index 00000000..4955eeb3
--- /dev/null
+++ b/temp/papers/aaai27_demo/reproduction.md
@@ -0,0 +1,118 @@
+# AAAI Demo Reproduction Guide
+
+## Evidence Levels
+
+The demo keeps three intentionally separate evidence lanes:
+
+- **L1 controlled mechanism evidence** is the CE-X four-arm counterfactual run. It supports no-op, rejection, catalog reuse, and acquisition-hypothesis routing under isolated profiles.
+- **Real headless structural seam** uses two offscreen PyQt6 `BaseLeapApp` versions, role-aware state envelopes, `LeapSpaceEnvironmentSource`, and the shipped `CapabilityObservationService`. It proves a real widget rename can become an opt-in `environment_probe` requirement; it has no framebuffer and is not GUI-agent e2e.
+- **Conditional signal archive** consists of a real Leapspace signal-mode trajectory, state/event evidence, and an unmodified `expect()` result declared in one archive manifest. Do not call this lane live or end-to-end unless every declared artifact is present and the verdict is PASS.
+- **L3 runtime-governance evidence** requires the real daemon, approval route, lifecycle/trust trajectory, and rollback evidence. It is not inferred from L1, the headless seam, or a signal archive.
+
+Never describe a missing lane as completed. The generated evidence bundle enumerates its own `claims.not_supported` list and the reviewer console renders those boundaries verbatim.
+
+## Prerequisites
+
+- A completed CE-X run directory containing `manifest.json`, `records.jsonl`, and `summary.json`.
+- Python with the repository dependencies available.
+- A PyQt6-enabled environment for the real offscreen structural-seam export. The repository's default lightweight environment may skip this lane.
+- Optionally, a declared signal archive manifest with a recording, cursor path, state snapshot, event log, and `expect()` stdout.
+- A Linux/KVM/AT-SPI environment is required to create new full GUI footage. On a host without that environment, use the L1 lane plus the real headless seam; do not synthesize a screen recording.
+
+## Create a CE-X Run
+
+```bash
+PYTHONPATH=temp/leapspace_exp/evo-02 uv run python temp/leapspace_exp/evo-02/orchestrator/run_c2.py
+```
+
+The command prints the run directory. Preserve the entire directory as a raw experiment artifact. It contains substitutions that delimit the L1 claim, including the absence of real approval, installation, and independent GUI oracle coverage.
+
+## Export the Real Headless Structural Seam
+
+Run this only in the PyQt6-enabled environment. The output is write-once and contains hashes for the real widget envelopes, durable observation, requirement identity, benign negative control, and default refusal.
+
+```bash
+PYTHONPATH=temp/papers/aaai27_demo:temp/leapspace_exp/evo-02 uv run python -m aaai_demo.cli headless-seam \
+  --output-dir temp/papers/aaai27_demo/demo/headless/<run-id>
+```
+
+## Declare a Signal Archive
+
+A signal archive manifest is a JSON object with `schema_version: 1`, `kind: "leapspace_signal_archive"`, `run_id`, `expect: {"verdict": "pass", "exit_code": 0}`, and relative artifact entries of kinds `recording`, `cursor_path`, `state_snapshot`, `event_log`, and `expect_stdout`. Each artifact has `path` and optional `sensitive`. Missing files or a non-PASS verdict render the archive `incomplete`; they never become a successful L2 claim.
+
+## Export the Evidence Bundle
+
+Use a new output directory for every export. The exporter refuses to replace a bundle or its files.
+
+```bash
+PYTHONPATH=temp/papers/aaai27_demo:temp/leapspace_exp/evo-02 uv run python -m aaai_demo.cli bundle \
+  --run-dir temp/leapspace_exp/runs/<c2-run-id> \
+  --output-dir temp/papers/aaai27_demo/demo/evidence/<c2-run-id> \
+  --drift-fixture temp/papers/aaai27_demo/demo_fixtures/headless-chat-probe-drifts.json \
+  --headless-seam temp/papers/aaai27_demo/demo/headless/<run-id>/headless_seam.json \
+  --signal-archive /absolute/path/signal_archive.json
+```
+
+Omit `--signal-archive` when no complete archive exists; the bundle will show `not_supplied`. `--trajectory-dir` remains a legacy media index and does not establish an independent oracle. Add `--include-media` only after confirming that the media is safe to place in the evidence package.
+
+The bundle includes hashes for the CE-X source files, headless seam and signal-archive status, a compact causal trace, per-arm evidence boundaries, and the copied fixture. It intentionally labels CE-X effect confirmation as a handler-reported outcome rather than an independent `expect()` oracle.
+
+## Render the Read-Only Console and Video EDL
+
+```bash
+PYTHONPATH=temp/papers/aaai27_demo uv run python -m aaai_demo.cli render \
+  --bundle temp/papers/aaai27_demo/demo/evidence/<c2-run-id>/bundle.json \
+  --output-dir temp/papers/aaai27_demo/demo/render/<c2-run-id>
+```
+
+Open `index.html` locally. It has four synchronized columns: Leapspace evidence, Observe/Orient, Decide/PCD, and Governance/Effect. The matrix gives no-op, rejection, reuse, and acquisition-hypothesis equal visual weight. The view distinguishes the legacy trajectory index, declared signal archive, and real headless seam. `storyboard.json` is the 300-second edit decision list; it includes narration constraints and prohibited claims.
+
+The hidden LeapBoard `causal_trace` template is an alternative read-only lens over a live `framework_evolution` finding. It is hidden from ordinary navigation so it cannot broaden the normal product surface. Invoke it explicitly only for the experiment/audit workflow.
+
+## Evolution Live Lens
+
+`evolution_live` is a hidden, read-only LeapBoard lens over the same authoritative `framework_evolution` snapshot. Runtime traces are projected into Environment, Decision, and Governance lanes through `evolution.presentation` WebSocket messages. On reconnect, the browser fetches the authoritative snapshot again; the lens never writes a proposal, resolves approval, or runs a replay against the runtime.
+
+## Provisional Accepted-Demo Poster Source
+
+A poster is **not** a replacement for the required initial video/slides material. It is an accepted-demo station aid: the official call provides a poster board but defers final exhibit format information to the Chairs. Generate only the responsive source until that information arrives.
+
+```bash
+PYTHONPATH=temp/papers/aaai27_demo uv run python -m aaai_demo.cli poster \
+  --bundle temp/papers/aaai27_demo/demo/evidence/<c2-run-id>/bundle.json \
+  --output-dir temp/papers/aaai27_demo/demo/poster/<c2-run-id>
+```
+
+The output records `3:4 portrait` only as a provisional design ratio and explicitly marks the official print size as pending. Do not print or claim a final format before the Chairs provide the station specification.
+
+## Backup Reel
+
+After reviewing clip provenance and continuity, concatenate archived clips without re-encoding:
+
+```bash
+PYTHONPATH=temp/papers/aaai27_demo uv run python -m aaai_demo.cli backup-reel \
+  --clip /absolute/path/intro.mp4 \
+  --clip /absolute/path/trajectory.mp4 \
+  --output temp/papers/aaai27_demo/demo/backup-90s.mp4
+```
+
+The helper uses `ffmpeg -n`, so an existing output is never replaced. The main five-minute video is assembled from the 300-second EDL with reviewed overlays and narration; the tool does not fabricate unavailable signal-archive, e2e, approval, or L3 footage.
+
+## Verification
+
+```bash
+uv run pytest temp/papers/aaai27_demo/tests -q
+uv run pytest tests/test_dashboard_sdui.py tests/test_dashboard_view.py -q
+PYTHONPATH=src:temp/papers/aaai27_demo:temp/leapspace_exp/evo-02 \
+  conda run -n leap pytest temp/papers/aaai27_demo/tests/test_demo_artifacts.py -q
+```
+
+Before recording or submission, verify all of the following:
+
+1. Every visible claim maps to a hash-listed source artifact.
+2. The four CE-X arms have four distinct profile roots and the expected action for each arm.
+3. No-op and rejected arms appear in the rendered matrix and causal trace.
+4. Any actual GUI footage has a declared signal archive, PASS `expect()` output, and aligned state/event artifacts.
+5. Any headless structural seam record contains the rename, benign control, default refusal, and `environment_probe` requirement.
+6. Any real mutation has its own approval record; L1 acquisition hypotheses must remain labelled as non-install evidence.
+7. The video is at most 300 seconds, and the dashboard, paper captions, and evidence bundle use the same evidence language.
diff --git a/temp/papers/aaai27_demo/tests/test_demo_artifacts.py b/temp/papers/aaai27_demo/tests/test_demo_artifacts.py
new file mode 100644
index 00000000..3ef42fdd
--- /dev/null
+++ b/temp/papers/aaai27_demo/tests/test_demo_artifacts.py
@@ -0,0 +1,210 @@
+"""Tests for AAAI demo evidence packaging without a live GUI or LLM."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+
+_DEMO_ROOT = Path(__file__).resolve().parents[1]
+_EVO2_ROOT = _DEMO_ROOT.parents[1] / "leapspace_exp" / "evo-02"
+for path in (str(_DEMO_ROOT), str(_EVO2_ROOT)):
+    if path not in sys.path:
+        sys.path.insert(0, path)
+
+from aaai_demo.evidence import (  # noqa: E402
+    EvidenceBundleError,
+    build_evidence_bundle,
+    export_evidence_bundle,
+)
+from aaai_demo.headless_seam import export_headless_seam  # noqa: E402
+from aaai_demo.poster import render_poster_source  # noqa: E402
+from aaai_demo.render import render_demo_package  # noqa: E402
+
+
+_ARMS = (
+    ("unchanged_baseline", "none", "none", 0),
+    ("irrelevant_delta_rejected", "none", "none", 0),
+    ("satisfied_by_catalog", "reuse", "reuse", 0),
+    ("unmet_traverses_lifecycle", "acquire", "acquire", 1),
+)
+
+
+def _run(tmp_path: Path) -> Path:
+    run = tmp_path / "c2-test"
+    run.mkdir()
+    manifest = {
+        "run_id": "c2-test",
+        "lane": "L1",
+        "family": "C2_coevolution_counterfactual",
+        "protocol_id": "LEAPSPACE-EVO-02",
+        "experiment_version": "v1",
+        "subject": {"commit": "abc123"},
+        "substitutions": {"not_exercised": "approval prompt, real install, daemon"},
+    }
+    summary = {"arms_total": 4, "arms_correct": 4, "mutations": 1, "effect_confirmed": 1}
+    records = []
+    for index, (arm, expected, action, verified) in enumerate(_ARMS):
+        records.append({
+            "arm": arm,
+            "expected_action": expected,
+            "action": action,
+            "ok": True,
+            "proposed": 1 if arm == "unmet_traverses_lifecycle" else 0,
+            "admitted": 1 if arm == "unmet_traverses_lifecycle" else 0,
+            "requirements": 1 if arm in {"satisfied_by_catalog", "unmet_traverses_lifecycle"} else 0,
+            "authorised": arm != "irrelevant_delta_rejected",
+            "effect_verified": verified,
+            "effect_refuted": 0,
+            "profile_root": str(run / "isolated" / f"profile-{index}"),
+            "notes": f"evidence for {arm}",
+        })
+    (run / "manifest.json").write_text(json.dumps(manifest), encoding="utf-8")
+    (run / "summary.json").write_text(json.dumps(summary), encoding="utf-8")
+    (run / "records.jsonl").write_text(
+        "".join(json.dumps(record) + "\n" for record in records), encoding="utf-8"
+    )
+    return run
+
+
+def _fixture() -> Path:
+    return _DEMO_ROOT / "demo_fixtures" / "task-001-structural-drifts.json"
+
+
+def _signal_archive(tmp_path: Path, *, complete: bool = True) -> Path:
+    archive = tmp_path / "signal-archive"
+    archive.mkdir()
+    paths = {
+        "recording": "recording.mp4",
+        "cursor_path": "cursor.jsonl",
+        "state_snapshot": "chat/state.json",
+        "event_log": "chat/events.jsonl",
+        "expect_stdout": "expect.stdout",
+    }
+    for path in paths.values():
+        artifact = archive / path
+        artifact.parent.mkdir(parents=True, exist_ok=True)
+        artifact.write_text("evidence", encoding="utf-8")
+    artifacts = [
+        {"kind": kind, "path": path, "sensitive": kind in {"recording", "state_snapshot"}}
+        for kind, path in paths.items()
+        if complete or kind != "event_log"
+    ]
+    manifest = {
+        "schema_version": 1,
+        "kind": "leapspace_signal_archive",
+        "run_id": "signal-test",
+        "expect": {"verdict": "pass", "exit_code": 0},
+        "artifacts": artifacts,
+    }
+    path = archive / "signal_archive.json"
+    path.write_text(json.dumps(manifest), encoding="utf-8")
+    return path
+
+
+def _headless_seam(tmp_path: Path) -> Path:
+    path = tmp_path / "headless_seam.json"
+    path.write_text(json.dumps({
+        "schema_version": 1,
+        "kind": "aaai_demo_headless_seam",
+        "run_id": "headless-test",
+        "rename": {"evidence_kind": "interface_drift"},
+        "benign_control": {"evidence_count": 0},
+        "default_refusal": {"admitted": False},
+        "requirement": {"capability": "chat.reply", "origin": "environment_probe"},
+    }), encoding="utf-8")
+    return path
+
+
+def test_bundle_preserves_l1_boundaries_and_counterfactual_order(tmp_path: Path) -> None:
+    bundle = build_evidence_bundle(_run(tmp_path), drift_fixture=_fixture())
+
+    assert [arm["arm"] for arm in bundle["arms"]] == [item[0] for item in _ARMS]
+    unmet = bundle["arms"][-1]
+    assert unmet["outcome"] == "acquire_hypothesis"
+    assert unmet["approval"] == "not_exercised"
+    assert unmet["registry_mutation"] == "not_exercised"
+    assert unmet["effect"]["independent_oracle"] == "not_available"
+    assert "End-to-end Leapspace agent execution." in bundle["claims"]["not_supported"]
+    assert len(bundle["drift_fixture"]["drifts"]) == 3
+    assert bundle["signal_archive"]["status"] == "not_supplied"
+    assert bundle["headless_seam"]["status"] == "not_supplied"
+
+
+def test_bundle_binds_complete_signal_archive_and_headless_seam(tmp_path: Path) -> None:
+    bundle = build_evidence_bundle(
+        _run(tmp_path),
+        signal_archive=_signal_archive(tmp_path),
+        headless_seam=_headless_seam(tmp_path),
+    )
+
+    assert bundle["signal_archive"]["status"] == "available"
+    assert bundle["signal_archive"]["expect"] == {"verdict": "pass", "exit_code": 0}
+    assert len(bundle["signal_archive"]["artifacts"]) == 5
+    assert bundle["headless_seam"]["status"] == "available"
+    assert bundle["headless_seam"]["requirement"]["origin"] == "environment_probe"
+
+
+def test_incomplete_signal_archive_is_visible_not_upgraded_to_pass(tmp_path: Path) -> None:
+    bundle = build_evidence_bundle(_run(tmp_path), signal_archive=_signal_archive(tmp_path, complete=False))
+
+    assert bundle["signal_archive"]["status"] == "incomplete"
+    assert "event_log" in bundle["signal_archive"]["missing"]
+
+
+def test_headless_seam_export_records_real_widget_evidence_when_pyqt_is_available(tmp_path: Path) -> None:
+    pytest.importorskip("PyQt6")
+
+    record = export_headless_seam(tmp_path / "headless")
+
+    assert record["rename"]["evidence_kind"] == "interface_drift"
+    assert record["benign_control"]["evidence_count"] == 0
+    assert record["default_refusal"]["admitted"] is False
+    assert record["requirement"]["origin"] == "environment_probe"
+    seam_path = tmp_path / "headless" / "headless_seam.json"
+    assert seam_path.is_file()
+    assert build_evidence_bundle(_run(tmp_path), headless_seam=seam_path)["headless_seam"]["status"] == "available"
+
+
+def test_export_and_render_are_write_once(tmp_path: Path) -> None:
+    source = _run(tmp_path)
+    bundle_dir = tmp_path / "bundle"
+    bundle = export_evidence_bundle(
+        source,
+        bundle_dir,
+        drift_fixture=_fixture(),
+        signal_archive=_signal_archive(tmp_path),
+        headless_seam=_headless_seam(tmp_path),
+    )
+
+    assert (bundle_dir / "bundle.json").is_file()
+    assert (bundle_dir / "checksums.sha256").is_file()
+    assert (bundle_dir / "raw" / "records.jsonl").is_file()
+    assert (bundle_dir / "raw" / "signal_archive.json").is_file()
+    assert (bundle_dir / "raw" / "headless_seam.json").is_file()
+    with pytest.raises(EvidenceBundleError, match="already exists"):
+        export_evidence_bundle(source, bundle_dir, drift_fixture=_fixture())
+
+    render_dir = tmp_path / "render"
+    paths = render_demo_package(bundle, render_dir)
+    html = paths["index"].read_text(encoding="utf-8")
+    assert "CE-X four-arm matrix" in html
+    assert "End-to-end Leapspace agent execution." in html
+    storyboard = json.loads(paths["storyboard"].read_text(encoding="utf-8"))
+    assert storyboard["duration_s"] == 300
+    assert storyboard["segments"][-1]["end_s"] == 300
+    assert "Signal archive" in html
+    assert "Headless seam" in html
+    poster_dir = tmp_path / "poster"
+    poster = render_poster_source(bundle, poster_dir)
+    assert "PROVISIONAL SOURCE" in poster["poster"].read_text(encoding="utf-8")
+    assert json.loads(poster["format"].read_text(encoding="utf-8"))["official_size"] == (
+        "pending_chairs_exhibit_format_information"
+    )
+    with pytest.raises(EvidenceBundleError, match="already exists"):
+        render_poster_source(bundle, poster_dir)
+    with pytest.raises(EvidenceBundleError, match="already exists"):
+        render_demo_package(bundle, render_dir)
diff --git a/tests/leapspace/test_actor.py b/tests/leapspace/test_actor.py
index 14e6b285..e0159239 100644
--- a/tests/leapspace/test_actor.py
+++ b/tests/leapspace/test_actor.py
@@ -13,7 +13,7 @@
     element_center,
     find_ax_element,
 )
-from leapspace.app_space.utils import get_image_venv_python
+from leapspace.app_space.state import get_image_venv_python
 
 VENV_PYTHON = get_image_venv_python("linux")
 SYSTEM_PYTHON = "/usr/bin/python3"
diff --git a/tests/leapspace/test_harness.py b/tests/leapspace/test_harness.py
index 4e7fc0a3..6fb6c106 100644
--- a/tests/leapspace/test_harness.py
+++ b/tests/leapspace/test_harness.py
@@ -24,7 +24,7 @@
     RECORD_START_FILE,
     RECORD_STOP_FILE,
 )
-from leapspace.app_space.utils import LeapAppImage, get_image_venv_python
+from leapspace.app_space.state import LeapAppImage, get_image_venv_python
 
 PYTHON = get_image_venv_python("linux")
 
diff --git a/tests/leapspace/test_signal_bridge_live.py b/tests/leapspace/test_signal_bridge_live.py
new file mode 100644
index 00000000..60ea0aa5
--- /dev/null
+++ b/tests/leapspace/test_signal_bridge_live.py
@@ -0,0 +1,113 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Live-Qt signal bridge: a real offscreen app's ground truth reaches LeapFlow.
+
+The strongest headless realism available without a hypervisor: a real PyQt6
+``BaseLeapApp`` runs offscreen, writes its own ``state.json`` from the live
+widget tree (role-aware ``elements``), and LeapFlow's *shipped*
+``StateSnapshotService`` perceives it through ``LeapSpaceHostRpc``. This upgrades
+the earlier bridge test from a hand-written envelope to one a real app emitted.
+
+Runs in the conda ``leap`` env (PyQt6 present); skips where PyQt6 is absent.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+pytest.importorskip("PyQt6")
+# Must be set before any QApplication is constructed.
+os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
+
+from PyQt6.QtWidgets import QApplication  # noqa: E402
+
+from leapflow.perception.state_snapshot import (  # noqa: E402
+    SnapshotFidelity,
+    StateSnapshotService,
+)
+from leapspace.app_space.apps import _base as base_mod  # noqa: E402
+from leapspace.app_space.apps.chat import ChatApp  # noqa: E402
+from leapspace.app_space.host_rpc import LeapSpaceHostRpc  # noqa: E402
+
+
+class _FakeEpisodic:
+    def recent(self, limit: int = 5):
+        return []
+
+    def search_fragments(self, terms, limit: int = 1):
+        return []
+
+
+@pytest.fixture(scope="session")
+def qapp():
+    """One process-wide QApplication, mirroring test_base's proven pattern.
+
+    Session-scoped and never torn down: constructing/destroying QApplication per
+    test aborts the offscreen platform, and a live app instance is what keeps
+    ``QApplication.instance()`` valid across the file when it runs standalone.
+    """
+    return QApplication.instance() or QApplication([])
+
+
+def _make_app(state_root: Path, monkeypatch) -> ChatApp:
+    """Instantiate a real ChatApp offscreen; __init__ writes state.json."""
+    monkeypatch.setattr(
+        base_mod,
+        "get_sandbox_state_dir",
+        lambda in_sandbox=True, system=None: state_root,
+    )
+    return ChatApp()
+
+
+def _dispose(win: ChatApp, qapp: QApplication) -> None:
+    """Tear one app down cleanly: stop its timer, schedule deletion, flush it.
+
+    ChatApp starts an inbox poll ``QTimer``; leaving it live while a second
+    top-level window is created aborts the offscreen platform. Stopping it and
+    letting ``deleteLater`` run under ``processEvents`` keeps repeated
+    instantiation stable, which is what a standalone run of this file needs.
+    """
+    timer = getattr(win, "_inbox_timer", None)
+    if timer is not None:
+        timer.stop()
+    win.close()
+    win.deleteLater()
+    qapp.processEvents()
+
+
+def test_real_app_emits_role_aware_elements(qapp, tmp_path, monkeypatch):
+    win = _make_app(tmp_path, monkeypatch)
+    try:
+        state = json.loads((tmp_path / "chat" / "state.json").read_text())
+        elements = {e["name"]: e for e in state["elements"]}
+        # Roles come from the live widget classes, not a declaration.
+        assert elements["send_button"]["role"] == "QPushButton"
+        assert elements["message_input"]["role"] == "QLineEdit"
+        assert elements["contact_list"]["role"] == "QListWidget"
+        # The role-aware channel and the bare name list agree on membership.
+        assert set(state["interface"]) == set(elements)
+    finally:
+        _dispose(win, qapp)
+
+
+def test_live_app_signal_reaches_leapflow_perception(qapp, tmp_path, monkeypatch):
+    win = _make_app(tmp_path, monkeypatch)
+    try:
+        rpc = LeapSpaceHostRpc(tmp_path)
+        svc = StateSnapshotService(
+            rpc, _FakeEpisodic(), default_fidelity=SnapshotFidelity.FULL
+        )
+        svc.update_focus("chat", "LeapChat")
+        snap = asyncio.run(svc.capture(SnapshotFidelity.FULL))
+
+        assert snap.app_bundle_id == "chat"
+        assert snap.ax_digest, "perception saw an empty environment"
+        # The real Qt role and the bound name both flow through the summary.
+        assert "QPushButton" in snap.ax_summary
+        assert "send_button" in snap.ax_summary
+    finally:
+        _dispose(win, qapp)
diff --git a/tests/leapspace/test_utils.py b/tests/leapspace/test_state.py
similarity index 66%
rename from tests/leapspace/test_utils.py
rename to tests/leapspace/test_state.py
index 568d400a..6e119026 100644
--- a/tests/leapspace/test_utils.py
+++ b/tests/leapspace/test_state.py
@@ -1,14 +1,17 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
-"""Tests for leapspace.app_space.utils: check() lines and path conventions."""
+"""Tests for leapspace.app_space.state: check() lines, path conventions, and the
+LS-1 decoupling contract (state helpers import with cua_sandbox absent)."""
 
 import asyncio
+import importlib
 import platform
+import sys
 
 import pytest
 
-pytest.importorskip("cua_sandbox")  # leapspace extra only (utils imports cua_sandbox)
-
-from leapspace.app_space.utils import (
+# No cua_sandbox importorskip: the whole point of LS-1 is that these helpers are
+# importable without the host SDK. This test runs on any host.
+from leapspace.app_space.state import (
     check,
     get_image_venv_python,
     get_sandbox_state_dir,
@@ -16,6 +19,22 @@
 )
 
 
+def test_state_module_imports_without_the_sandbox_sdk():
+    """LS-1: importing state must not require cua_sandbox.
+
+    Loads the module in a fresh import with cua_sandbox forced absent. Before the
+    split this was impossible -- ``from cua_sandbox import Image`` sat at module
+    scope, so the in-box verdict and pure helpers could not import off-sandbox.
+    """
+    saved = {k: v for k, v in sys.modules.items() if k == "cua_sandbox"}
+    sys.modules["cua_sandbox"] = None  # any import attempt raises ImportError
+    try:
+        importlib.reload(importlib.import_module("leapspace.app_space.state"))
+    finally:
+        sys.modules.pop("cua_sandbox", None)
+        sys.modules.update(saved)
+
+
 def test_check_pass_line(capsys):
     assert check("reply-sent", True, "found") is True
     assert capsys.readouterr().out == "PASS reply-sent: found\n"
diff --git a/tests/test_adaptation_verdict.py b/tests/test_adaptation_verdict.py
index abfbf74a..7d51eabb 100644
--- a/tests/test_adaptation_verdict.py
+++ b/tests/test_adaptation_verdict.py
@@ -191,11 +191,37 @@ async def grade_and_propose(self, trajectory, goal="", **kwargs):
 
 
 class _Intake:
+    """Stands in for ``CapabilityObservationService``.
+
+    ``requirements`` derives a need for whatever was just observed, because that is what
+    a real store does: the driver asks at ``min_count=1``, so the observation written a
+    moment earlier already clears the threshold. A stub that returned nothing here would
+    quietly assert the opposite of the shipped contract -- that the driver queues an
+    acquisition the detector never turned into a requirement -- and the driver now
+    records that case as a ``requirement_not_derived`` no-op instead of acting on it.
+    """
+
+    def __init__(self) -> None:
+        self.observed: list[str] = []
+
     def observe_result(self, result, **kwargs):
+        capability = str((result or {}).get("capability") or "")
+        if capability:
+            self.observed.append(capability)
         return {"observation_id": "o1"}
 
     def requirements(self, *, min_count: int = 1, limit: int = 50):
-        return ()
+        from leapflow.domain.capability_requirement import CapabilityRequirement
+
+        return tuple(
+            CapabilityRequirement.create(
+                capability,
+                "world_model",
+                max_risk_level="read_only",
+                requirement_id=f"req-{capability}",
+            )
+            for capability in dict.fromkeys(self.observed)
+        )
 
 
 def _drive(verdicts, sink=None):
diff --git a/tests/test_coevolution_sweep_wiring.py b/tests/test_coevolution_sweep_wiring.py
index 02469e5a..7f21aa93 100644
--- a/tests/test_coevolution_sweep_wiring.py
+++ b/tests/test_coevolution_sweep_wiring.py
@@ -245,6 +245,18 @@ def _resolve_lifecycle_governor(self):
 
         return Context._resolve_lifecycle_governor(self)
 
+    def _active_proposal_ids(self):
+        """Bound because the production hook maps plugin_id -> proposal_id through it.
+
+        The sweep now feeds ``LifecycleGovernor.record_outcome`` a proposal id keyed off
+        the live queue, so the real hook calls this. With no profile layout on the double
+        it degrades to an empty map -- the honest 'no queued proposals' state -- and the
+        assertions still run the real ``_run_coevolution_sweep`` body.
+        """
+        from leapflow.cli.context import Context
+
+        return Context._active_proposal_ids(self)
+
 
 def test_production_sweep_hook_builds_and_runs_a_real_sweep():
     """Drives `_run_coevolution_sweep` itself, not a hand-made CoevolutionSweep.
@@ -305,6 +317,44 @@ def test_production_hook_uses_the_shared_process_tracker():
         _teardown()
 
 
+def test_active_proposal_ids_targets_the_newest_record_for_a_plugin(tmp_path):
+    """One plugin, several active records: governance must target the newest.
+
+    ``active()`` is newest-first, so a naive overwrite would leave the map pointing at
+    the *oldest* record and ``record_outcome`` would update the wrong lifecycle entry.
+    A plugin can legitimately hold several active records (different capability,
+    environment, or source), so this is a reachable case, not a corner one.
+    """
+    from types import SimpleNamespace
+
+    from leapflow.cli.context import Context
+    from leapflow.domain.capability_requirement import CapabilityRequirement
+    from leapflow.layout import ProfileLayout
+    from leapflow.storage.capability_proposal_queue import JsonCapabilityProposalQueue
+
+    layout = ProfileLayout(root=tmp_path / "profile", profile_id="p")
+    layout.root.mkdir(parents=True, exist_ok=True)
+    queue = JsonCapabilityProposalQueue(layout.capability_proposal_queue_path)
+    queue.enqueue(
+        requirements=(
+            CapabilityRequirement.create("chat.reply", "world_model", requirement_id="req-a"),
+        ),
+        metadata={"plugin_id": "shared_plugin"},
+    )
+    newer = queue.enqueue(
+        requirements=(
+            CapabilityRequirement.create("chat.send", "world_model", requirement_id="req-b"),
+        ),
+        metadata={"plugin_id": "shared_plugin"},
+    )
+    # Bump the second record so it is unambiguously the most recently touched.
+    queue.update(newer.proposal_id, status="GENERATED")
+
+    ctx = _Ctx(settings=SimpleNamespace(profile_layout=layout))
+    mapping = Context._active_proposal_ids(ctx)
+    assert mapping["shared_plugin"] == newer.proposal_id
+
+
 def test_production_hook_survives_a_broken_collaborator():
     """A failure to govern must not fail the session that produced the trajectory."""
     _sink()
diff --git a/tests/test_dashboard_frontend_static.py b/tests/test_dashboard_frontend_static.py
new file mode 100644
index 00000000..8f40ac25
--- /dev/null
+++ b/tests/test_dashboard_frontend_static.py
@@ -0,0 +1,200 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Static regressions for the frontend defects measured on a live board.
+
+There is no JS test runner in this repository, so these guard the shipped source
+directly — the same approach ``test_dashboard_i18n_static.py`` takes. Each test names
+the symptom a reader saw, because that is what must never come back.
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+_STATIC = Path(__file__).parents[1] / "src" / "leapflow" / "dashboard" / "static"
+_APP_JS = _STATIC / "app.js"
+_STYLES = _STATIC / "styles.css"
+_INDEX = _STATIC / "index.html"
+
+
+def _app() -> str:
+    return _APP_JS.read_text(encoding="utf-8")
+
+
+# ════════════════════════════════════════════════════════════════
+# Markdown: nine notices rendered as raw markup
+# ════════════════════════════════════════════════════════════════
+
+
+def test_markdown_node_is_parsed_not_printed_verbatim() -> None:
+    """The defect: the component named Markdown did not parse Markdown.
+
+    It escaped its text and inserted it as-is, so every explanatory aside on the
+    evolution board showed a literal ``>`` and literal ``**`` — nine of eleven
+    Markdown notices in the shipped templates, all of them on the one board whose
+    job is explaining how the framework evolves.
+    """
+    src = _app()
+    assert "Markdown: (n) => renderMarkdown(" in src
+    assert 'Markdown: (n) => el("div", "md prose", esc(' not in src, (
+        "the renderer must not go back to printing escaped text verbatim"
+    )
+
+
+def test_markdown_escapes_before_it_transforms() -> None:
+    """Order is the whole security argument: escape, then add only known tags.
+
+    ``esc`` must be applied to the text before any transform runs, so prose can never
+    introduce an element and the only tags in the output are the ones added here.
+    """
+    src = _app()
+    assert "mdInline(esc(" in src, "transforms must run on already-escaped text"
+    assert "esc(mdInline(" not in src, (
+        "escaping after transforming would neutralise the tags this renderer adds"
+    )
+
+
+def test_markdown_recognises_exactly_the_three_authored_constructs() -> None:
+    """Blockquote, bold, inline code — and no general parser was pulled in.
+
+    The SDUI contract is a closed component catalog; widening the trusted surface to
+    a Markdown library to gain three constructs would be a bad trade.
+    """
+    src = _app()
+    assert '<blockquote' in src or 'el("blockquote"' in src
+    assert "<strong>$1</strong>" in src
+    assert "<code>" in src
+    for library in ("marked", "showdown", "markdown-it", "remark"):
+        assert library not in src, f"no third-party markdown parser ({library})"
+
+
+def test_parsed_prose_releases_pre_wrap() -> None:
+    """The blocks the renderer emits must not inherit whitespace preservation.
+
+    ``.md`` sets ``pre-wrap`` for raw text elsewhere; leaving it on would reintroduce
+    the folded-scalar indentation the YAML carried as visible leading gaps.
+    """
+    css = _STYLES.read_text(encoding="utf-8")
+    assert ".md.prose { white-space: normal; }" in css
+    assert ".md.prose code" in css, "inline code needs a monospace treatment"
+
+
+# ════════════════════════════════════════════════════════════════
+# Live lens: five of six metrics froze while looking current
+# ════════════════════════════════════════════════════════════════
+
+
+def test_live_metrics_declare_their_provenance() -> None:
+    """The defect: snapshot-derived figures sat on load-time values silently.
+
+    A presentation event carries one fact, never a recount, so those metrics cannot
+    move between producer cycles. They are now labelled rather than redrawn as though
+    they had, which is the distinction the producer's own fingerprint docstring
+    warns about.
+    """
+    src = _app()
+    assert "function evolutionLiveStat(label, value, provenance)" in src
+    assert '"stat prov-" + provenance' in src
+    assert '"Live since snapshot"' in src, (
+        "the count of uncounted increments is the figure that makes the strip honest"
+    )
+    for label, provenance in (
+        ("Event count", "live"),
+        ("Live since snapshot", "live"),
+        ("Episodes", "snapshot"),
+        ("Mutation", "snapshot"),
+        ("Regressions", "snapshot"),
+        ("Unadmitted intents", "snapshot"),
+    ):
+        assert re.search(
+            rf'\["{re.escape(label)}",[^\]]*"{provenance}"\]', src
+        ), f"{label!r} must be declared as {provenance}-derived"
+
+
+def test_live_lens_counts_increments_against_the_snapshot_instant() -> None:
+    """Only events strictly newer than the snapshot are uncounted by it."""
+    src = _app()
+    assert "const baselineAt = Number(snapshot.observed_at || 0);" in src
+    assert "Number(event.ts || 0) > baselineAt" in src
+
+
+def test_drift_is_stated_only_when_the_two_provenances_diverge() -> None:
+    """A permanent caveat is noise; a count that appears when true is a fact."""
+    src = _app()
+    assert "if (since > 0)" in src
+    assert "Snapshot metrics refresh on the next monitor cycle." in src
+
+
+def test_empty_lanes_say_what_would_appear_and_why_nothing_has() -> None:
+    """"No live events" alone left quiet indistinguishable from broken."""
+    src = _app()
+    assert '"lane-hint"' in src
+    for hint in (
+        "Environment events appear when a probe records a change in the surroundings.",
+        "Decision events appear when a recorded observation drives a capability choice.",
+        "Governance events appear when trust, quarantine or reclamation moves.",
+    ):
+        assert hint in src, f"missing lane guidance: {hint!r}"
+
+
+def test_lanes_are_equal_height_rather_than_a_fixed_short_box() -> None:
+    """Three lanes with different fill read as a ragged row when height is fixed."""
+    css = _STYLES.read_text(encoding="utf-8")
+    assert "align-items: stretch" in css
+    assert "min-height: 148px" not in css, "the fixed lane height is what made it ragged"
+    assert ".evolution-live-lane .lane-hint" in css
+
+
+# ════════════════════════════════════════════════════════════════
+# Sparkline: a one-point series reported "No entries."
+# ════════════════════════════════════════════════════════════════
+
+
+def test_a_single_sample_series_is_drawn_not_discarded() -> None:
+    """The defect: ``length >= 2`` filtered out the only reading a new board has.
+
+    The chart then printed "No entries.", telling the reader there was no data when
+    there was exactly one observation.
+    """
+    src = _app()
+    assert "g.points.length >= 1" in src
+    assert "g.points.length >= 2" not in src, (
+        "a one-point series must not be filtered back out"
+    )
+    assert "g.points.length === 1" in src, "a lone sample needs its own marker branch"
+    assert 'svgEl("circle")' in src
+
+
+# ════════════════════════════════════════════════════════════════
+# Provenance bar: page-level freshness on every lens
+# ════════════════════════════════════════════════════════════════
+
+
+def test_the_provenance_bar_renders_on_every_view_fetch() -> None:
+    """Freshness is page chrome, not a panel a template author must remember."""
+    src = _app()
+    assert "renderProvenance(payload.meta || {})" in src
+    assert "function renderProvenance(meta)" in src
+
+
+def test_the_bar_offers_a_refresh_so_the_loop_closes() -> None:
+    """Several boards prescribe a fix; without this the reader cannot confirm it landed."""
+    src = _app()
+    assert '"Refresh now"' in src
+    assert 'name: "watch.refresh"' in src
+
+
+def test_an_unobserved_board_is_not_aged_from_the_clock() -> None:
+    """Saying "0s ago" where nothing was observed invents the fact the bar exists for."""
+    src = _app()
+    assert 't("Not yet observed")' in src
+
+
+def test_static_assets_are_cache_busted_together() -> None:
+    """A stale cached app.js against a new stylesheet is its own class of bug report."""
+    html = _INDEX.read_text(encoding="utf-8")
+    versions = re.findall(r"/static/(?:app\.js|styles\.css)\?v=([\w-]+)", html)
+    assert len(versions) == 2, "both assets must carry a cache-busting version"
+    assert versions[0] == versions[1], "asset versions must be bumped together"
+    assert versions[0] != "status-i18n-20260808", (
+        "the version predates the markdown and provenance changes"
+    )
diff --git a/tests/test_dashboard_launcher.py b/tests/test_dashboard_launcher.py
index 4cf422c6..04dd050f 100644
--- a/tests/test_dashboard_launcher.py
+++ b/tests/test_dashboard_launcher.py
@@ -16,7 +16,7 @@
 import pytest
 
 from leapflow.dashboard import launcher
-from leapflow.dashboard.server import DashboardServer
+from leapflow.dashboard.server import DashboardServer, _MONITOR_EVENTS
 
 
 def _settings(tmp_path: Path) -> SimpleNamespace:
@@ -217,6 +217,10 @@ def test_check_origin_matches_loopback_host_exactly() -> None:
         assert check(SimpleNamespace(headers={"Origin": origin})) is False
 
 
+def test_dashboard_forwards_presentation_only_evolution_events() -> None:
+    assert "evolution.presentation" in _MONITOR_EVENTS
+
+
 # ── DashboardServer.dispatch_action (allow-listed, transport-free) ───────────
 
 
diff --git a/tests/test_dashboard_provenance.py b/tests/test_dashboard_provenance.py
new file mode 100644
index 00000000..bfc4a746
--- /dev/null
+++ b/tests/test_dashboard_provenance.py
@@ -0,0 +1,170 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Regressions for the freshness contract and the evolution axis.
+
+Each test here corresponds to a defect measured on a live board, and states the
+symptom rather than the implementation, so a refactor that keeps the behaviour keeps
+the test.
+"""
+from __future__ import annotations
+
+import time
+
+from leapflow.dashboard.service import _evidence_trend, _provenance
+
+
+# ════════════════════════════════════════════════════════════════
+# Provenance: two instants, never merged
+# ════════════════════════════════════════════════════════════════
+
+
+def test_content_age_and_check_age_are_reported_separately() -> None:
+    """The defect: one instant could not answer both questions.
+
+    A finding-backed board renders the newest *persisted* finding and findings dedup
+    on content, so the content can be much older than the last completed cycle.
+    Reporting only the content instant made a healthy system look frozen; reporting
+    only the cycle instant would age a stale page from the clock.
+    """
+    now = time.time()
+    prov = _provenance(
+        {"observed_at": now - 600},
+        {"last_run_at": now - 5, "interval_seconds": 120, "watch_id": "w1"},
+    )
+
+    assert prov["age_seconds"] > 590, "content age must reflect the payload instant"
+    assert prov["checked_age_seconds"] < 10, "check age must reflect the last cycle"
+    assert prov["unchanged_for_seconds"] > 590
+
+
+def test_old_but_freshly_checked_content_is_not_stale() -> None:
+    """Stable is not stale, and conflating them is what made refresh look broken.
+
+    The verdict is about the watch: a cycle completed 5s ago, so the page reflects
+    the present even though its content has not changed for ten minutes.
+    """
+    now = time.time()
+    prov = _provenance(
+        {"observed_at": now - 600},
+        {"last_run_at": now - 5, "interval_seconds": 120},
+    )
+    assert prov["stale"] is False
+
+
+def test_a_watch_that_stopped_running_is_stale() -> None:
+    """Two cadences without a completed cycle means nothing on the page is current."""
+    now = time.time()
+    prov = _provenance(
+        {"observed_at": now - 900},
+        {"last_run_at": now - 500, "interval_seconds": 120},
+    )
+    assert prov["stale"] is True
+
+
+def test_one_missed_cycle_is_jitter_not_staleness() -> None:
+    """The threshold is two cadences on purpose: scheduling is not exact."""
+    now = time.time()
+    prov = _provenance(
+        {"observed_at": now - 200},
+        {"last_run_at": now - 150, "interval_seconds": 120},
+    )
+    assert prov["stale"] is False
+
+
+def test_a_watch_with_no_declared_cadence_gets_no_staleness_verdict() -> None:
+    """An event-driven watch has no interval, so judging it would mean inventing one."""
+    now = time.time()
+    prov = _provenance(
+        {"observed_at": now - 100000},
+        {"last_run_at": now - 100000, "interval_seconds": 0},
+    )
+    assert prov["stale"] is False
+    assert prov["cadence_seconds"] == 0.0
+
+
+def test_a_never_run_watch_reports_absent_rather_than_zero_age() -> None:
+    """Absent is not fresh. "0s ago" on a board that never observed invents a fact."""
+    prov = _provenance({}, {})
+    assert prov["observed"] is False
+    assert prov["checked"] is False
+    assert prov["age_seconds"] == 0.0
+    assert prov["stale"] is False
+
+
+def test_provenance_carries_the_watch_id_so_the_bar_can_refresh() -> None:
+    """Without it the bar can report the page is behind but not do anything about it."""
+    prov = _provenance({"observed_at": 1.0}, {"watch_id": "w-42", "last_run_at": 2.0})
+    assert prov["watch_id"] == "w-42"
+
+
+def test_a_payload_without_its_own_instant_is_dated_by_the_cycle() -> None:
+    now = time.time()
+    prov = _provenance({}, {"last_run_at": now - 30, "interval_seconds": 120})
+    assert prov["observed"] is True
+    assert 25 < prov["age_seconds"] < 35
+
+
+# ════════════════════════════════════════════════════════════════
+# Evolution axis: the only panel that shows direction
+# ════════════════════════════════════════════════════════════════
+
+
+def _finding(observed_at: float, with_evidence: int, total: int = 10) -> dict:
+    return {
+        "ts": observed_at,
+        "payload": {
+            "observed_at": observed_at,
+            "summary": {
+                "segments_with_evidence": with_evidence,
+                "segments_total": total,
+            },
+        },
+    }
+
+
+def test_a_single_sample_still_produces_a_series() -> None:
+    """The defect this exists to prevent.
+
+    Suppressing a one-point series hides the beginning of every evolution the board
+    is for -- and on a new profile that is the only reading there is.
+    """
+    trend = _evidence_trend([_finding(100.0, 2)])
+    assert trend["samples"] == 1
+    assert trend["series"], "one sample must still yield a drawable series"
+    assert trend["series"][0]["points"] == [{"x": 100.0, "y": 2, "at": 100.0}]
+
+
+def test_the_axis_reads_oldest_first() -> None:
+    """Findings are persisted newest-first; a time axis must not be."""
+    trend = _evidence_trend([_finding(300.0, 5), _finding(200.0, 3), _finding(100.0, 2)])
+    assert [p["y"] for p in trend["series"][0]["points"]] == [2, 3, 5]
+    assert trend["first_at"] == 100.0
+    assert trend["last_at"] == 300.0
+
+
+def test_net_change_states_the_direction() -> None:
+    """Direction is stated rather than left to the reader's eye on a short line."""
+    assert _evidence_trend([_finding(300.0, 5), _finding(100.0, 2)])["delta"] == 3
+    assert _evidence_trend([_finding(300.0, 1), _finding(100.0, 4)])["delta"] == -3
+
+
+def test_a_single_sample_declares_no_direction() -> None:
+    """One point is a reading, not a trend."""
+    assert _evidence_trend([_finding(100.0, 2)])["delta"] == 0
+
+
+def test_no_findings_yields_no_series_rather_than_a_fake_zero() -> None:
+    trend = _evidence_trend([])
+    assert trend["series"] == []
+    assert trend["samples"] == 0
+
+
+def test_malformed_findings_are_skipped_not_charted_as_zero() -> None:
+    """A payload with no summary is unknown, and unknown is not zero evidence."""
+    trend = _evidence_trend([
+        {"ts": 1.0, "payload": None},
+        {"ts": 2.0, "payload": {"observed_at": 2.0}},
+        {"ts": 3.0, "payload": {"observed_at": 3.0, "summary": {}}},
+        _finding(4.0, 3),
+    ])
+    assert trend["samples"] == 1
+    assert trend["series"][0]["points"][0]["y"] == 3
diff --git a/tests/test_dashboard_view.py b/tests/test_dashboard_view.py
index 3daa0ff0..268b854d 100644
--- a/tests/test_dashboard_view.py
+++ b/tests/test_dashboard_view.py
@@ -149,7 +149,43 @@ async def test_builder_exposes_template_switcher_meta() -> None:
     assert "finance" not in spec["meta"]["templates"]
     assert "research" not in spec["meta"]["templates"]
     assert "sentiment" not in spec["meta"]["templates"]
-    assert {"finance", "research", "sentiment"}.issubset(set(spec["meta"]["hidden_templates"]))
+    assert {"causal_trace", "evolution_live", "finance", "research", "sentiment"}.issubset(
+        set(spec["meta"]["hidden_templates"])
+    )
+
+
+def test_causal_trace_is_hidden_but_renderable_as_a_read_only_lens() -> None:
+    spec = _build(_evolution_provider(), template="causal_trace")
+
+    assert spec["meta"]["active_template"] == "causal_trace"
+    assert "causal_trace" not in spec["meta"]["templates"]
+    assert "causal_trace" in spec["meta"]["hidden_templates"]
+    assert {"Page", "Grid"}.issubset({node["type"] for node in _flatten(spec)})
+    assert not [node for node in _flatten(spec) if "action" in node]
+
+
+def test_evolution_live_is_hidden_and_binds_the_authoritative_snapshot() -> None:
+    provider = _evolution_provider()
+    provider._findings[0]["payload"].update({
+        "traces": [{"trace_id": "t-1", "stage": "observe", "kind": "interface_drift", "ts": 1.0}],
+        "summary": {
+            "episode_count": 1,
+            "segments_with_evidence": 2,
+            "segments_total": 4,
+            "unadmitted_intent_count": 0,
+            "regression_count": 0,
+        },
+    })
+
+    spec = _build(provider, template="evolution_live")
+    custom = [node for node in _flatten(spec) if node["type"] == "Custom"]
+
+    assert spec["meta"]["active_template"] == "evolution_live"
+    assert "evolution_live" not in spec["meta"]["templates"]
+    assert "evolution_live" in spec["meta"]["hidden_templates"]
+    assert custom[0]["props"]["render"] == "evolutionLive"
+    assert custom[0]["props"]["data"]["traces"][0]["kind"] == "interface_drift"
+    assert not [node for node in _flatten(spec) if "action" in node]
 
 
 async def test_builder_signals_template_renders_dense_operational_layout() -> None:
@@ -245,6 +281,22 @@ async def test_view_hub_backpressure_drops_when_full() -> None:
     assert hub.subscriber_count == 0
 
 
+async def test_view_hub_requests_snapshot_resync_after_a_drop() -> None:
+    hub = ViewHub(maxsize=1)
+    queue = hub.subscribe("slow")
+    assert hub.broadcast({"n": 1}) == 1
+    assert hub.broadcast({"n": 2}) == 0
+    assert (await queue.get())["n"] == 1
+
+    # The first delivery after capacity returns is the resync instruction. The
+    # dropped current increment is intentionally not replayed; fetchView() is the
+    # authoritative recovery path.
+    assert hub.broadcast({"n": 3}) == 0
+    assert (await queue.get())["type"] == "view.resync"
+    assert hub.broadcast({"n": 4}) == 1
+    assert (await queue.get())["n"] == 4
+
+
 # ── An empty hardware board must say why ────────────────────────────────────
 #
 # Every panel on the hardware lens gates on the data it renders, which is what lets a new
diff --git a/tests/test_evolution_governance_reachable.py b/tests/test_evolution_governance_reachable.py
index 1d383acb..5a1a5581 100644
--- a/tests/test_evolution_governance_reachable.py
+++ b/tests/test_evolution_governance_reachable.py
@@ -282,3 +282,47 @@ def test_lifecycle_record_carries_the_declared_risk_ceiling(tmp_path):
     record = queue.get(result["lifecycle_proposal_id"])
     assert dict(record.risk)["risk_level"] == "medium"
     assert dict(record.requirements[0])["max_risk_level"] == "medium"
+
+
+# ── plugin_generate bridges *both* proposal stores (G3) ───────────────────────
+
+
+def test_generate_resolves_a_world_model_lifecycle_proposal(tmp_path):
+    """A world-model queue id must reach generation, not only a review-store id.
+
+    The world-model driver enqueues into the lifecycle queue (``prop-<hash>``); before
+    the bridge, ``plugin_generate`` looked only in the review store, so Scene C could
+    never proceed from a real teacher verdict. This drives the resolver that closes
+    that gap -- no LLM needed, because it is the resolution, not the generation, under
+    test.
+    """
+    from leapflow.domain.capability_requirement import CapabilityRequirement
+
+    plugin, queue = _plugin_with_stores(tmp_path)
+    requirement = CapabilityRequirement.create(
+        "chat.reply", "world_model", evidence="the send path silently no-ops",
+        max_risk_level="read_only", requirement_id="req-wm-chat.reply",
+    )
+    item = queue.enqueue(
+        requirements=(requirement,),
+        source="world_model",
+        observation_ids=("obs-1",),
+        metadata={"plugin_id": "chat_reply_alt_plugin", "capability_summary": "reply via v2"},
+    )
+
+    source, plugin_id, description, provides = plugin._resolve_generation_source(
+        item.proposal_id
+    )
+    assert source == "lifecycle"
+    assert plugin_id == "chat_reply_alt_plugin"
+    assert provides == ("chat.reply",)          # capability preserved for generation
+    assert description                          # non-empty description derived
+
+    # A review-store id still resolves as its own source, unchanged.
+    review = _propose(plugin, requested_capability="chat.send", risk_level="read_only")
+    assert plugin._resolve_generation_source(
+        review["proposal"]["proposal_id"]
+    )[0] == "review"
+
+    # An id neither store knows resolves to nothing, so generate returns not-found.
+    assert plugin._resolve_generation_source("prop-does-not-exist")[0] == ""
diff --git a/tests/test_evolution_presentation.py b/tests/test_evolution_presentation.py
new file mode 100644
index 00000000..eeacdb73
--- /dev/null
+++ b/tests/test_evolution_presentation.py
@@ -0,0 +1,45 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Presentation-only projections for live framework-evolution displays."""
+
+from __future__ import annotations
+
+from leapflow.domain.evolution_trace import EvolutionStage, EvolutionTrace
+from leapflow.telemetry.evolution_presentation import EvolutionPresentationEvent
+
+
+def test_presentation_event_uses_existing_correlation_as_episode_identity() -> None:
+    trace = EvolutionTrace(
+        stage=EvolutionStage.DECIDE,
+        kind="policy_decision",
+        trace_id="trace-1",
+        ts=42.0,
+        correlation={"record_id": "plan-9", "plugin_id": "example", "secret": "not-a-reference"},
+        summary="The policy selected reuse.",
+        detail={
+            "evidence_level": "L1_controlled",
+            "verification_tier": "declared_fitness",
+            "side_effect_state": "none",
+            "unbounded_private_detail": "must not reach the browser event",
+        },
+    )
+
+    event = EvolutionPresentationEvent.from_trace(trace).to_dict()
+
+    assert event["event_id"] == "trace-1"
+    assert event["episode_id"] == "plan-9"
+    assert event["payload_ref"] == {"record_id": "plan-9", "plugin_id": "example"}
+    assert event["evidence_level"] == "L1_controlled"
+    assert event["verification_tier"] == "declared_fitness"
+    assert "unbounded_private_detail" not in event
+
+
+def test_presentation_event_uses_trace_identity_when_no_correlation_exists() -> None:
+    trace = EvolutionTrace(stage=EvolutionStage.OBSERVE, kind="interface_drift", trace_id="trace-2")
+
+    event = EvolutionPresentationEvent.from_trace(trace)
+
+    assert event.episode_id == "trace-2"
+    assert event.payload_ref == {}
+    assert event.evidence_level == "runtime_trace"
+    assert event.verification_tier == "not_recorded"
+    assert event.side_effect_state == "not_recorded"
diff --git a/tests/test_evolution_producer.py b/tests/test_evolution_producer.py
index 81fa24d5..d122eb34 100644
--- a/tests/test_evolution_producer.py
+++ b/tests/test_evolution_producer.py
@@ -559,6 +559,12 @@ def test_evolution_template_binds_only_shapes_its_renderers_read():
         "evolution.reclaim_candidates",
         "evolution.reward_bandwidth.by_reason",
         "evolution.summary.suggestions",
+        # Not this producer's: derived by the view service from the retained finding
+        # list, which is the only thing carrying history across daemon restarts. It
+        # is deliberately outside the ``evolution.*`` namespace so that ownership is
+        # readable from the bind alone, and listed here because this assertion checks
+        # every bind in the template rather than only the producer's own.
+        "evidence_trend.series",
     }
     #: Every shipped renderer that coerces ``props.data`` with ``asArray``.
     DATA_LIST_COMPONENTS = (
diff --git a/tests/test_evolution_tap.py b/tests/test_evolution_tap.py
index a096f7b9..f6f86354 100644
--- a/tests/test_evolution_tap.py
+++ b/tests/test_evolution_tap.py
@@ -526,6 +526,46 @@ async def _drive():
     assert seen == ["evolution.registry_plugin_registered"]
 
 
+def test_runtime_trace_publishes_a_presentation_only_notification():
+    import asyncio
+
+    from leapflow.daemon.monitor_coordinator import MonitorCoordinator
+
+    seen_events: list[str] = []
+    presentation: list[object] = []
+
+    class _EventBus:
+        async def handle_event(self, event_type, payload):
+            seen_events.append(event_type)
+
+    class _NotificationBus:
+        def emit(self, notification):
+            presentation.append(notification)
+
+    async def _drive():
+        coordinator = MonitorCoordinator()
+        coordinator._notification_bus = _NotificationBus()
+        publisher = coordinator._make_evolution_publisher(SimpleNamespace(event_bus=_EventBus()))
+        assert publisher is not None
+        publisher(EvolutionTrace(
+            stage=EvolutionStage.DECIDE,
+            kind="policy_decision",
+            trace_id="trace-live",
+            detail={"phase": "runtime", "unbounded": "must not be displayed"},
+            correlation={"record_id": "record-live"},
+        ))
+        await asyncio.sleep(0.05)
+
+    asyncio.run(_drive())
+
+    assert seen_events == ["evolution.policy_decision"]
+    assert len(presentation) == 1
+    notification = presentation[0]
+    assert notification.event_type == "evolution.presentation"
+    assert notification.payload["episode_id"] == "record-live"
+    assert "unbounded" not in notification.payload
+
+
 def test_the_publisher_is_absent_rather_than_broken_without_a_bus():
     """No event bus is a normal state (in-process CLI), not a failure to report."""
     from leapflow.daemon.monitor_coordinator import MonitorCoordinator
diff --git a/tests/test_evolution_trigger_boundary.py b/tests/test_evolution_trigger_boundary.py
new file mode 100644
index 00000000..374c2cfc
--- /dev/null
+++ b/tests/test_evolution_trigger_boundary.py
@@ -0,0 +1,267 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Regressions for the evolution trigger and the segments it makes observable.
+
+Three defects measured against a live daemon, each of which made the board report an
+absence that was really a skipped step:
+
+* the governance sweep was nested inside the trajectory branch, so an empty
+  trajectory skipped it entirely — producing exactly the ambiguity the sweep's own
+  comment said its no-op traces existed to remove;
+* a proposal queue full of never-advanced records was reported ``wired``, the healthy
+  class, beside a genuinely healthy segment;
+* the learning boundary was reachable only from context cleanup, which in daemon mode
+  means process shutdown.
+"""
+from __future__ import annotations
+
+import ast
+import inspect
+from pathlib import Path
+
+import pytest
+
+from leapflow.monitor.evolution_producer import (
+    NO_EVIDENCE,
+    UNVERIFIABLE,
+    WIRED,
+    EvolutionProducer,
+)
+
+_CONTEXT_PY = Path(__file__).parents[1] / "src" / "leapflow" / "cli" / "context.py"
+
+
+# ════════════════════════════════════════════════════════════════
+# The sweep runs on a quiet boundary too
+# ════════════════════════════════════════════════════════════════
+
+
+def _learning_phase_body() -> ast.AST:
+    """Return the AST of ``_on_session_end_learning``'s trajectory-grading phase."""
+    tree = ast.parse(_CONTEXT_PY.read_text(encoding="utf-8"))
+    for node in ast.walk(tree):
+        if isinstance(node, ast.AsyncFunctionDef) and node.name == "_on_session_end_learning":
+            return node
+    raise AssertionError("_on_session_end_learning not found")
+
+
+def test_the_governance_sweep_is_not_nested_in_the_trajectory_branch() -> None:
+    """The defect, asserted structurally so a refactor cannot quietly re-nest it.
+
+    ``_run_coevolution_sweep`` documents that it "runs whether or not the teacher
+    proposed anything, so its no-op traces distinguish a quiet session from a sweep
+    that never ran". Nested inside ``if trajectory:`` it did neither, and three
+    reachability segments read "no sweep trace observed" on a live board for that
+    reason alone.
+    """
+    phase = _learning_phase_body()
+
+    sweep_calls = [
+        node for node in ast.walk(phase)
+        if isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Attribute)
+        and node.func.attr == "_run_coevolution_sweep"
+    ]
+    assert len(sweep_calls) == 1, "the sweep must be driven from exactly one place"
+    sweep_line = sweep_calls[0].lineno
+
+    # Any `if` whose test mentions the trajectory must not contain the sweep call.
+    for node in ast.walk(phase):
+        if not isinstance(node, ast.If):
+            continue
+        test_names = {n.id for n in ast.walk(node.test) if isinstance(n, ast.Name)}
+        if "trajectory" not in test_names:
+            continue
+        guarded = [
+            child.lineno
+            for stmt in node.body
+            for child in ast.walk(stmt)
+            if hasattr(child, "lineno")
+        ]
+        assert sweep_line not in guarded, (
+            "the sweep is nested inside a trajectory guard again; an empty trajectory "
+            "would skip it and the board would report 'no sweep trace observed'"
+        )
+
+
+def test_an_empty_trajectory_still_reports_its_phase() -> None:
+    """The quiet path must remain observable, not silent."""
+    source = _CONTEXT_PY.read_text(encoding="utf-8")
+    assert '"note": "empty_trajectory"' in source
+
+
+# ════════════════════════════════════════════════════════════════
+# The learning boundary is callable, not only reachable at shutdown
+# ════════════════════════════════════════════════════════════════
+
+
+def test_the_learning_boundary_has_a_public_entry_point() -> None:
+    """Bound to ``cleanup`` alone, "when does it evolve" was unanswerable.
+
+    A daemon that ran for a week never evolved and one killed with SIGKILL never
+    evolved at all, because the only caller was process teardown.
+    """
+    from leapflow.cli.context import Context
+
+    assert hasattr(Context, "run_learning_boundary")
+    signature = inspect.signature(Context.run_learning_boundary)
+    assert "reason" in signature.parameters, (
+        "the caller must be recorded, so a shutdown flush is distinguishable from a "
+        "session boundary and from a hand-run one"
+    )
+
+
+def test_cleanup_drives_the_boundary_through_the_public_entry_point() -> None:
+    """One path, so the shutdown flush and an explicit run cannot diverge."""
+    source = _CONTEXT_PY.read_text(encoding="utf-8")
+    assert 'run_learning_boundary(reason="shutdown")' in source
+
+
+def test_the_daemon_exposes_the_boundary_as_an_rpc() -> None:
+    """It has to run in the daemon: that is the process holding the trajectory."""
+    from leapflow.daemon.protocol import METHOD_REGISTRY
+
+    assert METHOD_REGISTRY.get("evolution.run") == "evolution_run"
+
+
+def test_the_cli_can_run_the_boundary_without_stopping_the_daemon() -> None:
+    from leapflow.cli.commands.evolve import cmd_evolve
+
+    assert callable(cmd_evolve)
+
+
+def test_the_trajectory_buffer_is_bounded() -> None:
+    """Unbounded, it accumulated every turn of every session for a daemon lifetime."""
+    from leapflow.world_model.prediction import _MAX_TRAJECTORY_STEPS, PredictionLoop
+
+    source = inspect.getsource(PredictionLoop.__init__)
+    assert "deque(maxlen=_MAX_TRAJECTORY_STEPS)" in source
+    assert _MAX_TRAJECTORY_STEPS > 0
+
+
+# ════════════════════════════════════════════════════════════════
+# A write-only queue is not a governed one
+# ════════════════════════════════════════════════════════════════
+
+
+class _Item:
+    def __init__(self, status: str) -> None:
+        self.status = status
+
+
+class _Queue:
+    def __init__(self, *statuses: str) -> None:
+        self._items = [_Item(s) for s in statuses]
+
+    def list_items(self, limit: int = 0) -> list[_Item]:
+        return list(self._items)
+
+
+class _RaisingQueue:
+    def list_items(self, limit: int = 0) -> list[_Item]:
+        raise OSError("queue unreadable")
+
+
+@pytest.fixture()
+def producer() -> EvolutionProducer:
+    return EvolutionProducer()
+
+
+def _run(producer: EvolutionProducer, queue: object) -> dict:
+    """Call the segment with a stubbed store, since the store lookup reads settings."""
+    original = producer._json_store
+    producer._json_store = lambda *args, **kwargs: queue  # type: ignore[assignment]
+    try:
+        return producer._segment_lifecycle()
+    finally:
+        producer._json_store = original  # type: ignore[assignment]
+
+
+def test_a_queue_that_never_advances_is_not_wired(producer: EvolutionProducer) -> None:
+    """The defect: 212 records, every one PENDING, reported as the healthy class.
+
+    Nothing drained the queue and nothing ever would, so it grew monotonically while
+    the board showed it green beside a genuinely healthy ``Trust accrual``.
+    """
+    row = _run(producer, _Queue(*["PENDING"] * 212))
+    assert row["status"] == NO_EVIDENCE
+    assert "PENDING=212" in row["evidence"], "the spread stays visible"
+    assert "212 record(s)" in row["next_step"]
+    assert "only grows" in row["next_step"], "the row must name the consequence"
+
+
+def test_one_advanced_record_is_evidence_the_queue_is_read_back(
+    producer: EvolutionProducer,
+) -> None:
+    """Evidence is a transition, not a row count."""
+    row = _run(producer, _Queue("PENDING", "PENDING", "INSTALLED"))
+    assert row["status"] == WIRED
+
+
+@pytest.mark.parametrize("status", ["GENERATED", "APPROVED", "PROBATION", "VERIFIED",
+                                    "REJECTED", "FAILED", "QUARANTINED"])
+def test_every_post_entry_state_counts_as_advanced(
+    producer: EvolutionProducer, status: str
+) -> None:
+    """Entry states are enumerated, so a new terminal state cannot read as ungoverned."""
+    assert _run(producer, _Queue("PENDING", status))["status"] == WIRED
+
+
+def test_an_empty_queue_is_distinguished_from_a_stuck_one(
+    producer: EvolutionProducer,
+) -> None:
+    row = _run(producer, _Queue())
+    assert row["status"] == NO_EVIDENCE
+    assert "queue is empty" in row["evidence"]
+    assert "plugin_propose" in row["next_step"]
+
+
+def test_an_unreadable_queue_is_unverifiable_not_no_evidence(
+    producer: EvolutionProducer,
+) -> None:
+    """A source that could not be read is a fault, not an absence of activity."""
+    assert _run(producer, _RaisingQueue())["status"] == UNVERIFIABLE
+    assert _run(producer, None)["status"] == UNVERIFIABLE
+
+
+# ════════════════════════════════════════════════════════════════
+# A manual refresh must leave a trace that it ran
+# ════════════════════════════════════════════════════════════════
+
+
+def test_a_manual_refresh_records_that_a_cycle_completed() -> None:
+    """The defect: refresh looked broken because nothing it touched moved.
+
+    Findings dedup on content, so a cycle confirming "nothing changed" writes nothing.
+    The scheduler normally does the run bookkeeping and this path skips the scheduler,
+    so without it the board could not tell a refresh that ran from one that never
+    happened — which is the one thing a reader presses refresh to find out.
+    """
+    from leapflow.monitor.manager import MonitorManager
+
+    source = inspect.getsource(MonitorManager.run_watch_once)
+    assert "increment_run_count" in source
+    # After the cycle, not before: last_run_at means "a cycle completed".
+    assert source.index("self._executor.execute") < source.index("increment_run_count")
+    assert 'result.get("ok")' in source, "a producer that raised did not complete a cycle"
+
+
+def test_a_watch_view_publishes_its_declared_cadence() -> None:
+    """The board judges its own freshness against it; only the watch knows it."""
+    from leapflow.monitor.types import WatchView
+
+    view = WatchView(
+        watch_id="w", name="n", domain="d", trigger="every 120s", state="armed",
+        muted=False, run_count=1, next_due_at=2.0, last_run_at=1.0,
+        interval_seconds=120.0,
+    )
+    assert view.to_dict()["interval_seconds"] == 120.0
+
+
+def test_a_watch_with_no_interval_trigger_declares_no_cadence() -> None:
+    """Zero means "no fixed cadence", which the board reads as a withheld verdict."""
+    from leapflow.monitor.types import WatchView
+
+    assert WatchView(
+        watch_id="w", name="n", domain="d", trigger="event:x", state="armed",
+        muted=False, run_count=0, next_due_at=0.0, last_run_at=0.0,
+    ).to_dict()["interval_seconds"] == 0.0
diff --git a/tests/test_llm_provider_retry_ownership.py b/tests/test_llm_provider_retry_ownership.py
new file mode 100644
index 00000000..ce6b16d3
--- /dev/null
+++ b/tests/test_llm_provider_retry_ownership.py
@@ -0,0 +1,51 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""The provider owns retry; the SDK must not add a second, hidden one.
+
+``OpenAIChat`` implements a retry policy with backoff, and the recovery layer's
+budgets assume ``timeout_s`` bounds *one* attempt. The OpenAI SDK retries twice by
+default, so leaving that default in place multiplies the two policies: effective
+attempts become ``max_retries * 3`` and a hard timeout surfaces after three times
+the configured budget. Measured on a live endpoint before the fix: a 45s timeout
+raised ``APITimeoutError`` after 137s (~3 x 45s), which is exactly the failure a
+turn-level deadline cannot absorb.
+
+These tests pin the single-owner contract without any network access.
+"""
+
+from __future__ import annotations
+
+from leapflow.llm.openai_provider import OpenAIChat
+
+
+def _provider(**kwargs) -> OpenAIChat:
+    return OpenAIChat(
+        api_key="sk-test-not-a-real-key",
+        base_url="https://example.invalid/v1",
+        model="test-model",
+        **kwargs,
+    )
+
+
+def test_sdk_clients_do_not_retry_on_their_own():
+    """Both SDK clients must be constructed with retries disabled."""
+    provider = _provider()
+    # ``max_retries`` is public on the SDK client and is what multiplies attempts.
+    assert provider._async.max_retries == 0
+    assert provider._sync.max_retries == 0
+
+
+def test_provider_keeps_its_own_retry_policy():
+    """Disabling SDK retry must not disable ours -- the policy just has one owner."""
+    provider = _provider(max_retries=4)
+    assert provider._max_retries == 4
+    # Floor of one attempt: a zero would mean "never call the model".
+    assert _provider(max_retries=0)._max_retries == 1
+
+
+def test_configured_timeout_bounds_one_attempt():
+    """The read timeout the caller asked for is the one the client carries."""
+    provider = _provider(timeout_s=45.0)
+    assert provider._async.timeout.read == 45.0
+    # Connect/write/pool stay bounded independently so a stalled handshake cannot
+    # consume the whole read budget.
+    assert provider._async.timeout.connect == 30.0
diff --git a/tests/test_world_model_driver.py b/tests/test_world_model_driver.py
index a840f8a0..7ff353f7 100644
--- a/tests/test_world_model_driver.py
+++ b/tests/test_world_model_driver.py
@@ -217,6 +217,73 @@ def test_drive_result_is_reportable(tmp_path):
     assert payload["capabilities"] == ["chat.reply"]
 
 
+# ── authority gate (P5 in the driver) ──────────────────────────────────
+
+
+def test_admitted_hypothesis_is_queued_with_evidence_linkage(tmp_path):
+    """An admitted, authorised hypothesis is queued, carrying its observation ids.
+
+    The linkage is what lets the causal ledger join a queued acquisition back to the
+    evidence that produced it; a proposal minted with no observation ids is an orphan.
+    """
+    _, service = _service(tmp_path, opted_in=True)
+    captured: dict = {}
+
+    def sink(proposal, *, observation_ids=(), environment=None):
+        captured["observation_ids"] = tuple(observation_ids)
+        captured["environment"] = environment
+        return "prop-unmet"
+
+    driver = WorldModelEvolutionDriver(
+        teacher=_Teacher(intents=[_intent()]),
+        intake=service,
+        proposal_sink=sink,
+    )
+    result = asyncio.run(driver.drive(_TRAJECTORY, "reply in chat"))
+
+    assert result.unauthorised == ()
+    assert result.queued_proposal_ids == ("prop-unmet",)
+    assert len(captured["observation_ids"]) == 1
+    assert captured["observation_ids"][0].startswith("obs-")
+
+
+def test_unauthorised_origin_is_a_durable_no_op(tmp_path):
+    """With authority restricted away from world_model, the hypothesis cannot acquire."""
+    store, service = _service(tmp_path, opted_in=True)
+    queued: list = []
+
+    driver = WorldModelEvolutionDriver(
+        teacher=_Teacher(intents=[_intent()]),
+        intake=service,
+        proposal_sink=lambda p, **k: queued.append(p) or "prop-x",
+        # A drive-the-wiring assertion of P5: the world model's own origin is refused
+        # authority, so even an admitted hypothesis is retired rather than queued.
+        authorising_origins=("some_other_origin",),
+    )
+    result = asyncio.run(driver.drive(_TRAJECTORY, "reply in chat"))
+
+    assert result.unauthorised == ("chat.reply",)
+    assert result.queued_proposal_ids == ()
+    assert queued == []
+    # Durable no-op: the observation is retired with a recorded reason.
+    assert store.unresolved() == []
+
+
+def test_world_model_origin_is_authorised_when_named(tmp_path):
+    """Naming world_model in authorising_origins lets its hypothesis through."""
+    _, service = _service(tmp_path, opted_in=True)
+    queued: list = []
+    driver = WorldModelEvolutionDriver(
+        teacher=_Teacher(intents=[_intent()]),
+        intake=service,
+        proposal_sink=lambda p, **k: queued.append(p) or "prop-x",
+        authorising_origins=("world_model",),
+    )
+    result = asyncio.run(driver.drive(_TRAJECTORY, "reply in chat"))
+    assert result.unauthorised == ()
+    assert result.queued_proposal_ids == ("prop-x",)
+
+
 # ── the real grader satisfies the teacher contract ────────────────────────────
 
 
diff --git a/tests/test_world_model_proposal_sink_contract.py b/tests/test_world_model_proposal_sink_contract.py
new file mode 100644
index 00000000..2177068d
--- /dev/null
+++ b/tests/test_world_model_proposal_sink_contract.py
@@ -0,0 +1,133 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""A caller-supplied proposal sink keeps its own signature.
+
+Measured regression: the driver began passing ``observation_ids`` and ``environment``
+to ``proposal_sink`` so the causal ledger could join a proposal to the observations
+that caused it. The sink is supplied by the caller and its contract was
+``sink(proposal)``, so every sink that had not adopted the new keywords raised
+``TypeError`` -- inside a per-intent ``except Exception`` that logged at debug level
+and continued. The visible effect was that **no acquisition was ever queued**, with a
+green targeted test suite and no warning in the log.
+
+Two contracts are pinned here, because either alone would have let it through:
+
+* optional context is offered only to sinks that declare it (or take ``**kwargs``),
+  so extending the causal payload can never break an existing sink;
+* a wiring fault is logged as a warning rather than absorbed, so if this ever breaks
+  again it says so instead of going quiet.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+from leapflow.domain.adaptation_verdict import ACQUIRE, AdaptationVerdict
+from leapflow.learning.world_model_driver import WorldModelEvolutionDriver
+from leapflow.world_model.trajectory_grader import TeacherVerdict
+
+
+class _Teacher:
+    def __init__(self, verdict: TeacherVerdict) -> None:
+        self._verdict = verdict
+
+    async def grade_and_propose(self, *args: Any, **kwargs: Any) -> TeacherVerdict:
+        return self._verdict
+
+
+class _Intake:
+    """Minimal stand-in that derives a need for what it just observed."""
+
+    def __init__(self) -> None:
+        self.observed: list[str] = []
+
+    def observe_result(self, result, **kwargs):
+        capability = str((result or {}).get("capability") or "")
+        if capability:
+            self.observed.append(capability)
+        return {"observation_id": f"o{len(self.observed)}"}
+
+    def requirements(self, *, min_count: int = 1, limit: int = 50):
+        from leapflow.domain.capability_requirement import CapabilityRequirement
+
+        return tuple(
+            CapabilityRequirement.create(
+                capability, "world_model", max_risk_level="read_only",
+                requirement_id=f"req-{capability}",
+            )
+            for capability in dict.fromkeys(self.observed)
+        )
+
+
+def _drive(sink) -> Any:
+    driver = WorldModelEvolutionDriver(
+        teacher=_Teacher(
+            TeacherVerdict(
+                grades=(),
+                verdicts=(
+                    AdaptationVerdict.create(ACQUIRE, "mail.send", "the app is now v3"),
+                ),
+            )
+        ),
+        intake=_Intake(),
+        proposal_sink=sink,
+    )
+    return asyncio.run(driver.drive([{"action": "a"}], "reply in the thread"))
+
+
+def test_legacy_single_argument_sink_still_receives_proposals():
+    """The original contract: ``sink(proposal)`` and nothing else."""
+    seen: list[Any] = []
+
+    def sink(proposal):
+        seen.append(proposal)
+        return proposal.proposal_id
+
+    result = _drive(sink)
+    assert len(seen) == 1, "a one-argument sink must still be called"
+    assert result.to_dict()["queued"] == 1
+
+
+def test_sink_declaring_the_extras_receives_them():
+    """A sink that opts in gets the causal context, so the ledger can join it."""
+    captured: dict[str, Any] = {}
+
+    def sink(proposal, *, observation_ids=(), environment=None):
+        captured["observation_ids"] = tuple(observation_ids)
+        captured["environment"] = environment
+        return proposal.proposal_id
+
+    result = _drive(sink)
+    assert result.to_dict()["queued"] == 1
+    assert captured["observation_ids"], "observation ids must reach an opted-in sink"
+
+
+def test_var_keyword_sink_receives_the_extras():
+    """``**kwargs`` counts as opting in; nothing needs to be listed explicitly."""
+    captured: dict[str, Any] = {}
+
+    def sink(proposal, **kwargs):
+        captured.update(kwargs)
+        return proposal.proposal_id
+
+    assert _drive(sink).to_dict()["queued"] == 1
+    assert "observation_ids" in captured
+
+
+def test_a_sink_that_raises_a_wiring_fault_is_reported_not_swallowed(caplog):
+    """A TypeError from inside the sink must be visible, not debug-only.
+
+    The loop still continues -- one bad intent may not stop the rest -- but silence is
+    what turned the original defect into an invisible outage.
+    """
+    def sink(proposal, *, observation_ids=(), environment=None):
+        raise TypeError("sink is misconfigured")
+
+    with caplog.at_level(logging.WARNING, logger="leapflow.learning.world_model_driver"):
+        result = _drive(sink)
+
+    assert result.to_dict()["queued"] == 0
+    assert any(
+        "acquisition not queued" in record.message for record in caplog.records
+    ), "a wiring fault must be logged at warning level"

From 60cf9596035a9bb8e1320934d1fc50f6903ce2e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8F=AD=E6=89=AC?= <xingjun.wxj@alibaba-inc.com>
Date: Sat, 19 Sep 2026 13:31:00 +0800
Subject: [PATCH 03/10] feat(evolution): durable event-sourced self-evolution
 closed loop + legacy cleanup

Land the full evolution closed loop on the append-only DuckDB evolution event
stream as the single source of truth, and remove the superseded in-process
driver/JSON paths.

Core
- Unified ActionExecutor/ActionRecorder record real executions as session-scoped
  facts; SessionFinalizer seals sessions by generation/cursor and enqueues durable
  teacher jobs; shutdown only drains unfinished sessions.
- DurableTeacherWorker (lease/heartbeat/retry) grades hindsight once, resolves each
  acquire verdict against the live registry BEFORE proposal creation, and commits
  requirement.resolved + proposal.created atomically with job completion; satisfied/
  unauthorised/disabled/no-resolver cases become durable no-ops.
- EvolutionDistilledKnowledgeStore projects TEACHER_VERDICT_RECORDED into an in-memory
  read model (all four actions); the D1 feedback edge (prior verdict shown to the
  teacher) is preserved in the worker via the knowledge projection.
- LeapBoard projection adds resolution/no-op/knowledge-retraction; governance sweep is
  driven from run_learning_boundary so quiet boundaries still leave evidence.

Cleanup (no back-compat; single source of truth)
- Delete WorldModelEvolutionDriver, build_proposal_sink, build_alternatives_provider,
  JsonDistilledKnowledgeStore and the shutdown-only _on_session_end_learning /
  _drive_world_model_evolution paths; migrate their tests to the durable worker,
  event-sourced knowledge store, and proposal queue.

Verification: ruff clean; full suite 3862 passed, 7 skipped, 1 xfailed; journeys replay green.
---
 .learnings/ERRORS.md                          |  98 +++
 docs/plugins/plugin_lifecycle_management.md   |  23 +-
 .../plugins/third_party_plugin_development.md |  18 +-
 src/leapflow/cli/cli.py                       |  21 +-
 src/leapflow/cli/commands/evolve.py           |  52 +-
 src/leapflow/cli/context.py                   | 683 ++++++---------
 src/leapflow/config.py                        |  95 +++
 src/leapflow/config_service.py                |  19 +
 src/leapflow/daemon/_service_helpers.py       |   4 +
 src/leapflow/daemon/approval_coordinator.py   |  35 +
 src/leapflow/daemon/client.py                 |  53 +-
 src/leapflow/daemon/monitor_coordinator.py    |  15 +-
 src/leapflow/daemon/protocol.py               |  33 +-
 src/leapflow/daemon/service.py                | 149 +++-
 src/leapflow/dashboard/intent.py              |  19 +-
 src/leapflow/dashboard/server.py              |   1 +
 src/leapflow/dashboard/service.py             |  62 +-
 src/leapflow/domain/__init__.py               |  20 +
 src/leapflow/domain/adaptation_verdict.py     |   2 +
 src/leapflow/domain/environment_signal.py     | 322 +++++++
 src/leapflow/domain/event_types.py            |  33 +
 src/leapflow/domain/evolution_event.py        | 351 ++++++++
 src/leapflow/domain/plugin_fiber.py           |  25 +-
 src/leapflow/domain/plugin_proposal.py        |  48 +-
 src/leapflow/domain/skill_types.py            |   1 +
 src/leapflow/engine/action_executor.py        | 164 ++++
 src/leapflow/engine/engine.py                 | 539 +++++++-----
 src/leapflow/engine/scheduler.py              |  94 +--
 src/leapflow/engine/session.py                |  44 +-
 src/leapflow/engine/tool_execution.py         |  55 +-
 src/leapflow/evolution/__init__.py            |   8 +
 src/leapflow/evolution/action_recorder.py     | 220 +++++
 src/leapflow/evolution/artifact_store.py      | 162 ++++
 src/leapflow/evolution/outbox.py              | 233 ++++++
 src/leapflow/evolution/projection.py          | 526 ++++++++++++
 src/leapflow/evolution/session_finalizer.py   | 194 +++++
 src/leapflow/evolution/sink.py                |   8 +-
 src/leapflow/evolution/teacher_worker.py      | 698 +++++++++++++++
 src/leapflow/hardware/transports/__init__.py  |  17 +-
 src/leapflow/layout.py                        |  32 +-
 src/leapflow/learning/degradation_sink.py     | 234 ++----
 src/leapflow/learning/world_model_driver.py   | 716 ----------------
 src/leapflow/monitor/evolution_producer.py    | 184 ++--
 src/leapflow/perception/__init__.py           |   3 +
 src/leapflow/perception/environment_source.py | 156 ++++
 src/leapflow/perception/leapspace_source.py   | 120 +++
 src/leapflow/perception/signal_source.py      |   2 +-
 .../perception/signal_sources_builtin.py      |   1 -
 src/leapflow/performance.py                   |  67 ++
 src/leapflow/platform/event_bus.py            |   3 +-
 src/leapflow/plugins/adaptive_loop.py         |  78 --
 src/leapflow/plugins/dsh/plugin.py            |  15 +-
 src/leapflow/plugins/evolution_contracts.py   |  17 +-
 src/leapflow/plugins/lifecycle_governor.py    |  49 +-
 src/leapflow/plugins/proposal_orchestrator.py | 306 +++++++
 src/leapflow/plugins/protocol.py              |   3 +
 src/leapflow/plugins/registry.py              |  60 +-
 src/leapflow/plugins/sandbox/sandbox_host.py  |  67 +-
 src/leapflow/plugins/sandbox/worker.py        |  18 +
 src/leapflow/plugins/scoped_registry.py       |  55 ++
 src/leapflow/plugins/tool_plugins/file_ops.py |   2 +
 src/leapflow/plugins/tool_plugins/gateway.py  |   8 +
 src/leapflow/plugins/tool_plugins/hub.py      |   3 +
 .../plugins/tool_plugins/self_management.py   | 748 +++++++++++------
 .../plugins/tool_plugins/shell_terminal.py    |   4 +
 src/leapflow/skills/registry.py               |  16 +-
 src/leapflow/storage/__init__.py              |  12 +
 .../storage/capability_proposal_queue.py      | 447 ++++++----
 .../storage/distilled_knowledge_store.py      | 327 +++-----
 src/leapflow/storage/evolution_event_store.py | 792 ++++++++++++++++++
 src/leapflow/storage/evolution_store.py       |  34 +-
 src/leapflow/storage/evolution_trace_store.py | 121 ---
 src/leapflow/storage/plugin_outcome_store.py  |  82 +-
 src/leapflow/storage/plugin_proposal_store.py | 126 ---
 src/leapflow/storage/plugin_version_store.py  |  30 +-
 src/leapflow/storage/schema.py                | 224 ++++-
 src/leapflow/tools/name_resolver.py           |  75 +-
 src/leapflow/world_model/prediction.py        |  93 +-
 src/leapflow/world_model/trajectory_grader.py |  13 +-
 src/leapspace/app_space/harness.py            |  15 +
 ...sette-model-367e09460741491b.cassette.json |  55 ++
 ...sette-model-9b6460bbb9f20b6f.cassette.json |  75 ++
 ...sette-model-bc00bc1c3adb5c03.cassette.json |  59 ++
 ...sette-model-d963d1a7c85f827a.cassette.json |  59 ++
 ...sette-model-21df7e8e74778e3f.cassette.json |  55 ++
 ...sette-model-73ddd7ce361986cc.cassette.json |  59 ++
 ...sette-model-aff723a22088e665.cassette.json |  59 ++
 ...sette-model-ef55f6a7257d5165.cassette.json |  55 ++
 ...sette-model-4ecd277d081b281e.cassette.json |  55 ++
 ...sette-model-114913c6ced49c00.cassette.json |  60 ++
 ...sette-model-8f4a60fd5352920b.cassette.json |  64 ++
 ...sette-model-bd1578d59776ef42.cassette.json |  64 ++
 ...sette-model-f4840e1191c49c9c.cassette.json |  64 ++
 ...sette-model-06eeece3f570a148.cassette.json |  55 ++
 ...sette-model-077a17b141c44fb6.cassette.json |  59 ++
 ...sette-model-31d350ae8f4ff81e.cassette.json |  67 ++
 ...sette-model-8bfb5eaeaf86d401.cassette.json |  59 ++
 ...sette-model-158ec6b3661786da.cassette.json |  76 ++
 ...sette-model-17557e9ee9842679.cassette.json |  72 ++
 ...sette-model-1e18a0da1790b11f.cassette.json |  60 ++
 ...sette-model-30b7ab3ad4a5a107.cassette.json |  60 ++
 ...sette-model-3798e4163d6b2128.cassette.json |  56 ++
 ...sette-model-4d1f12200292b229.cassette.json |  60 ++
 ...sette-model-898001f1b5122a8a.cassette.json |  71 ++
 ...sette-model-a7782cf136290032.cassette.json |  55 ++
 ...sette-model-ada1fc7ddc57492e.cassette.json |  76 ++
 ...sette-model-b5a61ebb6aabdcfb.cassette.json |  76 ++
 ...sette-model-b9831df577183d53.cassette.json |  60 ++
 ...sette-model-c0ef153884a21ac7.cassette.json |  72 ++
 ...sette-model-d352b6f5b033a2d7.cassette.json |  56 ++
 ...sette-model-e6109a845a1dd79f.cassette.json |  76 ++
 ...sette-model-33afdab4bc90b747.cassette.json | 119 +++
 ...sette-model-3705093e647723c3.cassette.json |  55 ++
 ...sette-model-38aa0b5a67f18052.cassette.json |  75 ++
 ...sette-model-6dccb60364d7af34.cassette.json |  75 ++
 ...sette-model-7ad0336ee1e5a800.cassette.json |  75 ++
 ...sette-model-a690658cc3ac97da.cassette.json |  59 ++
 ...sette-model-b5283e275ca539f0.cassette.json |  59 ++
 ...sette-model-cc5cd4f23919fe0b.cassette.json |  76 ++
 ...sette-model-d6eb6c82ef17961b.cassette.json |  60 ++
 ...sette-model-14785ee2b98ad8a2.cassette.json |  59 ++
 ...sette-model-2ecead8ad64bd2b2.cassette.json |  75 ++
 ...sette-model-3253e1220413e5f3.cassette.json |  75 ++
 ...sette-model-3dc49087c1103fb6.cassette.json |  87 ++
 ...sette-model-5be074139ef16c9a.cassette.json |  75 ++
 ...sette-model-5fa148b50481fec6.cassette.json |  75 ++
 ...sette-model-63f72b6ae055dd95.cassette.json |  91 ++
 ...sette-model-6d0e8558c8ee265e.cassette.json |  71 ++
 ...sette-model-81c3f24286673f15.cassette.json |  87 ++
 ...sette-model-bb795810fcb3b193.cassette.json |  91 ++
 ...sette-model-d70fc70163a8902a.cassette.json |  75 ++
 ...sette-model-ef8c4f88764ca616.cassette.json |  91 ++
 tests/test_action_recorder_wiring.py          | 209 +++++
 tests/test_active_signal_source.py            |   6 +-
 tests/test_adaptation_verdict.py              | 103 +--
 tests/test_agent_execution.py                 |  11 +
 tests/test_capability_proposal_policy.py      |  99 ++-
 tests/test_capability_replacement_trigger.py  | 366 +-------
 tests/test_capability_resolver.py             |  39 +
 tests/test_coevolution_sweep_wiring.py        |  12 +-
 tests/test_dashboard_view.py                  |  40 +-
 tests/test_degradation_feedback_loop.py       | 189 ++---
 tests/test_distilled_knowledge.py             | 460 ++++------
 tests/test_distilled_preference.py            |  81 +-
 tests/test_durable_teacher.py                 | 427 ++++++++++
 tests/test_effect_scope.py                    |  20 +-
 tests/test_environment_source.py              | 128 +++
 tests/test_evolution_event_store.py           | 378 +++++++++
 tests/test_evolution_governance_reachable.py  | 108 +--
 tests/test_evolution_producer.py              |  20 +-
 tests/test_evolution_projection.py            | 215 +++++
 tests/test_evolution_tap.py                   |  94 +--
 tests/test_evolution_trigger_boundary.py      |  64 +-
 tests/test_evolution_verify_and_govern.py     |  19 +-
 tests/test_gateway_adapter_registry.py        |   4 +-
 tests/test_hardware_transport_contract.py     |   4 +-
 tests/test_inert_wiring_audit.py              |  65 +-
 tests/test_lifecycle_governor.py              |  57 +-
 tests/test_llm_coevolution_e2e.py             |   3 -
 tests/test_llm_provider_registry.py           |   2 +-
 tests/test_marketplace_server.py              |   3 -
 tests/test_performance_metrics.py             |  33 +
 tests/test_phase3_learning_autonomy.py        |   6 +-
 tests/test_plugin_learning.py                 |   5 +-
 tests/test_plugin_proposal_store.py           |  38 -
 tests/test_plugin_sandbox.py                  |  17 +-
 tests/test_plugin_stats_persistence.py        |   1 -
 tests/test_proposal_orchestrator.py           | 303 +++++++
 tests/test_scoped_registry.py                 |  50 ++
 tests/test_self_evolution_switch.py           |   4 +-
 tests/test_self_management.py                 | 204 ++++-
 tests/test_signal_source.py                   |   2 -
 tests/test_telegram_signal_source.py          |   2 +-
 tests/test_tool_concurrency.py                |  16 +-
 tests/test_world_model_driver.py              | 335 --------
 ...test_world_model_proposal_sink_contract.py | 133 ---
 176 files changed, 13658 insertions(+), 4773 deletions(-)
 create mode 100644 .learnings/ERRORS.md
 create mode 100644 src/leapflow/domain/environment_signal.py
 create mode 100644 src/leapflow/domain/evolution_event.py
 create mode 100644 src/leapflow/engine/action_executor.py
 create mode 100644 src/leapflow/evolution/action_recorder.py
 create mode 100644 src/leapflow/evolution/artifact_store.py
 create mode 100644 src/leapflow/evolution/outbox.py
 create mode 100644 src/leapflow/evolution/projection.py
 create mode 100644 src/leapflow/evolution/session_finalizer.py
 create mode 100644 src/leapflow/evolution/teacher_worker.py
 delete mode 100644 src/leapflow/learning/world_model_driver.py
 create mode 100644 src/leapflow/perception/environment_source.py
 create mode 100644 src/leapflow/perception/leapspace_source.py
 create mode 100644 src/leapflow/performance.py
 create mode 100644 src/leapflow/plugins/proposal_orchestrator.py
 create mode 100644 src/leapflow/storage/evolution_event_store.py
 delete mode 100644 src/leapflow/storage/evolution_trace_store.py
 delete mode 100644 src/leapflow/storage/plugin_proposal_store.py
 create mode 100644 tests/_fixtures/cassettes/r1_conversation/cassette-model-367e09460741491b.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r1_conversation/cassette-model-9b6460bbb9f20b6f.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r1_conversation/cassette-model-bc00bc1c3adb5c03.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r1_conversation/cassette-model-d963d1a7c85f827a.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r2_isolation/cassette-model-21df7e8e74778e3f.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r2_isolation/cassette-model-73ddd7ce361986cc.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r2_isolation/cassette-model-aff723a22088e665.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r2_isolation/cassette-model-ef55f6a7257d5165.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r3_control_plane/cassette-model-4ecd277d081b281e.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r4_recovery/cassette-model-114913c6ced49c00.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r4_recovery/cassette-model-8f4a60fd5352920b.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r4_recovery/cassette-model-bd1578d59776ef42.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r4_recovery/cassette-model-f4840e1191c49c9c.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r5_learning/cassette-model-06eeece3f570a148.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r5_learning/cassette-model-077a17b141c44fb6.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r5_learning/cassette-model-31d350ae8f4ff81e.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r5_learning/cassette-model-8bfb5eaeaf86d401.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-158ec6b3661786da.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-17557e9ee9842679.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-1e18a0da1790b11f.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-30b7ab3ad4a5a107.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-3798e4163d6b2128.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-4d1f12200292b229.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-898001f1b5122a8a.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-a7782cf136290032.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-ada1fc7ddc57492e.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-b5a61ebb6aabdcfb.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-b9831df577183d53.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-c0ef153884a21ac7.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-d352b6f5b033a2d7.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r6_lifecycle/cassette-model-e6109a845a1dd79f.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-33afdab4bc90b747.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-3705093e647723c3.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-38aa0b5a67f18052.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-6dccb60364d7af34.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-7ad0336ee1e5a800.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-a690658cc3ac97da.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-b5283e275ca539f0.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-cc5cd4f23919fe0b.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-d6eb6c82ef17961b.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r8_hardware/cassette-model-14785ee2b98ad8a2.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r8_hardware/cassette-model-2ecead8ad64bd2b2.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r8_hardware/cassette-model-3253e1220413e5f3.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r8_hardware/cassette-model-3dc49087c1103fb6.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r8_hardware/cassette-model-5be074139ef16c9a.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r8_hardware/cassette-model-5fa148b50481fec6.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r8_hardware/cassette-model-63f72b6ae055dd95.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r8_hardware/cassette-model-6d0e8558c8ee265e.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r8_hardware/cassette-model-81c3f24286673f15.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r8_hardware/cassette-model-bb795810fcb3b193.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r8_hardware/cassette-model-d70fc70163a8902a.cassette.json
 create mode 100644 tests/_fixtures/cassettes/r8_hardware/cassette-model-ef8c4f88764ca616.cassette.json
 create mode 100644 tests/test_action_recorder_wiring.py
 create mode 100644 tests/test_durable_teacher.py
 create mode 100644 tests/test_environment_source.py
 create mode 100644 tests/test_evolution_event_store.py
 create mode 100644 tests/test_evolution_projection.py
 create mode 100644 tests/test_performance_metrics.py
 delete mode 100644 tests/test_plugin_proposal_store.py
 create mode 100644 tests/test_proposal_orchestrator.py
 delete mode 100644 tests/test_world_model_driver.py
 delete mode 100644 tests/test_world_model_proposal_sink_contract.py

diff --git a/.learnings/ERRORS.md b/.learnings/ERRORS.md
new file mode 100644
index 00000000..1fc00387
--- /dev/null
+++ b/.learnings/ERRORS.md
@@ -0,0 +1,98 @@
+# Errors
+
+## [ERR-20260918-P2S] sandbox-resource-default
+
+**Logged**: 2026-09-18T13:52:25Z
+**Priority**: high
+**Status**: resolved
+**Area**: backend
+
+### Summary
+A default RLIMIT_AS ceiling caused Python sandbox workers to exit before responding on macOS.
+
+### Error
+```
+Sandbox smoke test failed: worker did not respond
+```
+
+### Context
+- The plugin sandbox applied a 512 MiB address-space limit before importing runtime modules.
+- macOS virtual address-space accounting exceeded the limit during normal worker startup.
+
+### Suggested Fix
+Keep memory limits configurable but disabled by default unless validated for the deployment platform.
+
+### Metadata
+- Reproducible: yes
+- Related Files: src/leapflow/plugins/sandbox/worker.py, src/leapflow/config.py
+
+### Resolution
+- **Resolved**: 2026-09-18T13:52:25Z
+- **Notes**: Default memory limit changed to zero; explicit configured limits remain enforced.
+
+---
+
+## [ERR-20260918-LNT] repository-wide-ruff-baseline
+
+**Logged**: 2026-09-18T13:52:25Z
+**Priority**: medium
+**Status**: resolved
+**Area**: tests
+
+### Summary
+Repository-wide Ruff validation reports pre-existing unused imports outside the evolution implementation surface.
+
+### Error
+```
+ruff check src tests: 33 F401/F811 findings
+```
+
+### Context
+- Targeted Ruff checks for all files changed by the evolution plan pass.
+- The remaining findings are in unrelated perception, platform, marketplace, and older test modules.
+
+### Suggested Fix
+Run a dedicated repository-wide lint cleanup and verify affected modules with their focused tests.
+
+### Metadata
+- Reproducible: yes
+- Related Files: src/leapflow/perception/signal_source.py, src/leapflow/platform/event_bus.py, tests/test_signal_source.py
+
+### Resolution
+- **Resolved**: 2026-09-18T13:52:25Z
+- **Notes**: Applied safe Ruff fixes and replaced the remaining assigned lambdas with local functions; repository-wide Ruff now passes.
+
+---
+
+## [ERR-20260918-EVP] event-projection-migration-regressions
+
+**Logged**: 2026-09-18T14:30:00Z
+**Priority**: medium
+**Status**: resolved
+**Area**: tests
+
+### Summary
+Targeted tests exposed stale constructor and lazy JSON-store assumptions during the event-derived knowledge migration.
+
+### Error
+```
+3 failed: proposal_sink constructor argument, lazy JSON knowledge binding, missing injected event knowledge store
+```
+
+### Context
+- DurableTeacherWorker now requires an event-backed proposal queue and live resolver.
+- AgentEngine no longer creates a JSON knowledge store on the hot path.
+- A production-wiring unit fixture did not inject the new event-derived knowledge projection.
+
+### Suggested Fix
+Update tests and fixtures to use the event store, inject the knowledge projection explicitly, and assert fail-closed acquisition resolution.
+
+### Metadata
+- Reproducible: yes
+- Related Files: tests/test_durable_teacher.py, tests/test_distilled_knowledge.py, tests/test_degradation_feedback_loop.py
+
+### Resolution
+- **Resolved**: 2026-09-19T00:30:00Z
+- **Notes**: Updated worker tests for atomic proposal preparation, replaced lazy JSON binding with explicit event-projection injection, and fixed production governor fixtures. Full suite passes.
+
+---
diff --git a/docs/plugins/plugin_lifecycle_management.md b/docs/plugins/plugin_lifecycle_management.md
index 64c5d51a..4e70278b 100644
--- a/docs/plugins/plugin_lifecycle_management.md
+++ b/docs/plugins/plugin_lifecycle_management.md
@@ -12,7 +12,7 @@
 
 | Term | Definition |
 |------|-----------|
-| **PluginFiber** | A per-plugin lifecycle state-machine instance (`domain/plugin_fiber.py`). Tracks runtime state transitions (PENDING/LOADING/ACTIVE/FAILED/UNLOADING/DISPOSED) and owns an EffectScope for deterministic cleanup. |
+| **PluginFiber** | A per-plugin lifecycle state-machine instance (`domain/plugin_fiber.py`). Tracks runtime state transitions (PENDING/DRAFT/LOADING/ACTIVE/FAILED/UNLOADING/DISPOSED) and owns an EffectScope for deterministic cleanup. |
 | **EffectScope** | Hierarchical, LIFO-ordered cleanup collector (`domain/effect_scope.py`). Guarantees safe teardown on dispose. |
 | **Trust Level** | Progressive reliability gradient (DRAFT → CANDIDATE → VERIFIED → PRODUCTION) earned by consecutive successes, persisted in DuckDB. |
 | **Generation Counter** | Module-level monotonic integer; each new PluginFiber receives a unique generation. Engine caches key on `(id(plugin), generation)` to detect reloads. |
@@ -56,8 +56,9 @@ A plugin's state is the **composition** of three independent axes: Runtime, Trus
 
 | State | Meaning | Transitions out |
 |-------|---------|----------------|
-| `PENDING` | Created, awaiting activation or async init | `LOADING`, `ACTIVE` (fast path), `DISPOSED` |
-| `LOADING` | Async initialization in progress (dependency resolution) | `ACTIVE`, `FAILED`, `UNLOADING` |
+| `PENDING` | Created, awaiting activation or async init | `DRAFT`, `LOADING`, `ACTIVE` (trusted fast path), `DISPOSED` |
+| `DRAFT` | Isolated candidate; no live handlers are published | `ACTIVE`, `DISPOSED` |
+| `LOADING` | Async initialization in progress (dependency resolution) | `ACTIVE`, `FAILED`, `DISPOSED` |
 | `ACTIVE` | Fully operational, tools registered and available | `UNLOADING` |
 | `FAILED` | Initialization failed; retryable via `retry()`/`begin_loading()` | `LOADING`, `DISPOSED` |
 | `UNLOADING` | Graceful teardown in progress | `DISPOSED` |
@@ -129,9 +130,9 @@ A plugin's state is the **composition** of three independent axes: Runtime, Trus
 | Dimension | Built-in Plugins | Third-Party Plugins |
 |-----------|-----------------|---------------------|
 | **Discovery** | Hardcoded module list in `plugins/tool_plugins/__init__.py` → `get_all_plugins()` | Profile-dir install (`plugin_install` tool) or marketplace fetch |
-| **Boot sequence** | `discover_builtin()` → `register()` → `bind_runtime()` → `assemble()` → `adopt_existing_plugins()` | `plugin_install` → validate → sandbox smoke → register → fiber activate |
+| **Boot sequence** | `discover_builtin()` → `register()` → `bind_runtime()` → `assemble()` → `adopt_existing_plugins()` | `plugin_install` → staging → bounded sandbox smoke/behavior tests → DRAFT fiber → atomic publish |
 | **Initial trust** | Implicitly DRAFT (but never demoted/frozen in practice — no failure path for well-tested built-ins) | Explicitly DRAFT; must earn promotion through usage |
-| **Fiber creation** | `adopt_existing_plugins()` at first `get_scoped_registry()` access; starts in ACTIVE | `create_fiber()` → `scoped_register()` → `activate()` during install |
+| **Fiber creation** | `adopt_existing_plugins()` at first `get_scoped_registry()` access; starts in ACTIVE | `create_draft_fiber()` → `stage_plugin()` → `promote_draft()` after tests |
 | **Approval** | None for registration (they ARE the system); mutations still gated | ALL mutations gated (HIGH risk, no permanent grants) |
 | **Isolation** | In-process (same asyncio loop) | Optionally sandboxed (subprocess JSON-RPC via `SandboxHost`); `requires_sandbox` manifest flag defaults `True` |
 | **Reload** | `reload(plugin_id)` via scoped registry; version bump + cache invalidation | Same mechanism, but PRODUCTION trust → auto-approve; below PRODUCTION → explicit approval |
@@ -147,11 +148,11 @@ A plugin's state is the **composition** of three independent axes: Runtime, Trus
 | **plugin_list** | Agent tool | None | Always | — | No (read-only) |
 | **plugin_status** | Agent tool | None | Always | — | No (read-only) |
 | **plugin_versions** | Agent tool | None | Always | `ProfileLayout.plugin_versions_dir` | No (read-only) |
-| **plugin_propose** | Agent tool | None | Always (proposal only, no LLM/file/runtime mutation) | `ProfileLayout.plugin_proposals_path` | No (proposal store write only) |
+| **plugin_propose** | Agent tool | None | Always (proposal only, no runtime mutation) | Event-sourced lifecycle store | Yes — `proposal.created` |
 | **assess_compatibility** | Agent tool | None | Always (read-only manifest assessment; no file/runtime mutation) | — | No (read-only) |
-| **plugin_generate** | Agent tool | None | Always (code generation only, no filesystem write) | `plugin_generation_enabled` must be `True`; needs `llm_provider` bound | No (ephemeral output) |
+| **plugin_generate** | Agent tool | Content approval | Never for proposal-backed generation | `plugin_generation_enabled`; LLM provider; CAS | Yes — generated artifact and approval lifecycle events |
 | **/plugin generate** | User (slash command) | None (user invocation = consent) | Always auto-approved (user-initiated); installs at DRAFT trust level | `plugin_generation_enabled` must be `True`; needs an LLM provider | Yes — install action descriptor recorded |
-| **plugin_install** | Agent tool | `ApprovalGate` → HIGH, `allow_permanent=False` | Never (always requires human) | `plugin_install_dir`, proposal/version stores, `plugin_marketplace_root/url`, `plugin_marketplace_trusted_pubkeys` | Yes — action descriptor metadata recorded |
+| **plugin_install** | Agent tool | `ApprovalGate` → HIGH, `allow_permanent=False` | Never (always requires human) | `plugin_install_dir`, event lifecycle/version stores, `plugin_marketplace_root/url`, `plugin_marketplace_trusted_pubkeys` | Yes — action descriptor and lifecycle event recorded |
 | **plugin_rollback** | Agent tool | `ApprovalGate` → HIGH, `allow_permanent=False` | Never (always requires human) | `ProfileLayout.plugin_versions_dir` | Yes |
 | **plugin_reload** | Agent tool | `ApprovalGate` → HIGH, `allow_permanent=False` | Trust == PRODUCTION (auto-approved) | proposal/version stores when behavior tests or version labels are used | Yes |
 | **plugin_disable** | Agent tool | `ApprovalGate` → HIGH, `allow_permanent=False` | Never (always requires human) | — | Yes |
@@ -174,8 +175,8 @@ A plugin's state is the **composition** of three independent axes: Runtime, Trus
 **Trigger**: User or agent decides a new capability is needed.
 
 **Sequence**:
-1. **Generate** (optional): `plugin_generate(description="...")` → LLM produces code → `PluginValidator` multi-stage check (syntax → structure → runtime protocol conformance). Returns validated code blob. No filesystem write.
-2. **Install request**: `plugin_install(code=<blob>)` or `plugin_install(marketplace_name="...")`.
+1. **Generate**: `plugin_generate(proposal_id="...")` → LLM produces code → `PluginValidator` multi-stage check → profile CAS write → explicit proposal-content approval. No live registry mutation occurs.
+2. **Install request**: `plugin_install(proposal_id="...")` resolves the approved CAS artifact and requests a separate mutation approval. Direct code/marketplace installs still use the mutation gate.
    - **Compatibility pre-gate (marketplace path only)**: the resolved manifest is run through `assess_plugin()` (the Compatibility Assessment Engine) *before* anything else. An `INCOMPATIBLE` verdict is **rejected here with a structured error, before any file write**; an `ADAPTABLE` verdict proceeds and its adaptation notes are attached to the install result.
 3. **Approval gate**: `ActionDescriptor.platform_action("plugin_management", "install", {...})` → `gate.evaluate()` → user prompted (HIGH risk, one-time).
 4. **Duplicate check**: If `plugin_id` already exists in registry → immediate rejection with error.
@@ -491,7 +492,7 @@ These require human/product input and are not answerable from code alone:
 | Plugin discovery (built-in) | `src/leapflow/plugins/tool_plugins/__init__.py` |
 | Self-management tools (12 tools) | `src/leapflow/plugins/tool_plugins/self_management.py` |
 | Proposal domain records | `src/leapflow/domain/plugin_proposal.py` |
-| Proposal persistence | `src/leapflow/storage/plugin_proposal_store.py` |
+| Proposal persistence | `src/leapflow/storage/capability_proposal_queue.py` (`EvolutionCapabilityProposalStore`) |
 | Behavior test execution | `src/leapflow/learning/plugin_behavior_tests.py` |
 | Version snapshot store | `src/leapflow/storage/plugin_version_store.py` |
 | Trust ledger | `src/leapflow/learning/plugin_trust.py` |
diff --git a/docs/plugins/third_party_plugin_development.md b/docs/plugins/third_party_plugin_development.md
index d0c870a8..580ceb7a 100644
--- a/docs/plugins/third_party_plugin_development.md
+++ b/docs/plugins/third_party_plugin_development.md
@@ -117,6 +117,7 @@ class ToolMetadata:
     handler: Callable[..., Any]
     x_leapflow: dict[str, Any] = field(default_factory=dict)
     mutates_state: bool = False
+    execution_policy: str = ""
 
     def to_openai_schema(self) -> dict[str, Any]:
         """Generate OpenAI function-calling schema dict."""
@@ -135,13 +136,14 @@ class ToolMetadata:
     "x_leapflow": {
       "category": "integration",
       "mutates_state": true,
-      "risk_level": "medium"
+      "risk_level": "medium",
+      "execution_policy": "mutating_once"
     }
   }
 }
 ```
 
-When `mutates_state=True`, `to_openai_schema()` folds it into `x_leapflow.mutates_state` so schema-only consumers can classify side-effecting tools without accessing the metadata object.
+When `mutates_state=True`, `to_openai_schema()` folds it into `x_leapflow.mutates_state`. A non-empty `execution_policy` is folded into `x_leapflow.execution_policy` as well, so schema-only consumers use the same declared execution semantics as the runtime.
 
 **`x_leapflow` well-known keys:**
 
@@ -157,6 +159,7 @@ omit approval/idempotency metadata.
 | `schema_cost` | `str` | `"low"` / `"medium"` / `"high"` — token cost hint for PCD |
 | `requires_approval` | `bool` | Whether the engine gates this tool behind approval |
 | `mutates_state` | `bool` | Auto-populated from the field when `True` |
+| `execution_policy` | `str` | `read_only`, `mutating_idempotent`, `mutating_once`, or `external_side_effect`; undeclared policies fail safe as external |
 
 ### 2.3 GatewayAdapterPlugin Protocol
 
@@ -388,6 +391,7 @@ ToolMetadata(
     parameters_schema={...},
     handler=handle_delete,
     mutates_state=True,
+    execution_policy="external_side_effect",
     x_leapflow={
         "category": "cloud_ops",
         "risk_level": "high",
@@ -396,7 +400,7 @@ ToolMetadata(
 )
 ```
 
-For platform actions (gateway send, external API write), use `ActionDescriptor.platform_action(platform, action, metadata)` within the handler to explicitly request gate evaluation.
+For platform actions (gateway send, external API write), use `execution_policy="external_side_effect"` and `ActionDescriptor.platform_action(platform, action, metadata)`. The action descriptor requests approval; the execution policy controls durable evidence, duplicate suppression, batch stopping, and uncertain-effect reporting. Runtime policy is derived only from these declarations, never from the tool name.
 
 ### 3.6 Code Quality
 
@@ -426,9 +430,9 @@ The following is the ordered sequence from plugin source to tool invocation:
 
 ### Step 4: PluginFiber Lifecycle
 
-5. **`ScopedToolRegistry.adopt_existing_plugins()`**: Called on first `leapflow.plugins.get_scoped_registry()` access. It creates a `PluginFiber` for every already-registered plugin and uses the fast path `PENDING → ACTIVE` for the current built-in/profile ToolPlugin runtime. The `PluginFiber` domain type also supports `LOADING` and `FAILED` retry states for future async initialization paths, but the scoped registry does not yet run a dependency-driven async activation loop.
+5. **`ScopedToolRegistry.adopt_existing_plugins()`**: Called on first `leapflow.plugins.get_scoped_registry()` access. It creates a `PluginFiber` for every already-registered plugin. Dependency-free built-ins use `PENDING → ACTIVE`; dependency-bearing plugins use `PENDING → LOADING → ACTIVE` when providers become available.
 
-Fiber domain state machine: `PENDING → LOADING → ACTIVE → UNLOADING → DISPOSED` (with `LOADING → FAILED → LOADING` retry path). Current ToolPlugin registration uses the fast path `PENDING → ACTIVE`; `LOADING`/`FAILED` are available primitives, not automatic dependency orchestration.
+Fiber domain state machine: `PENDING → DRAFT → ACTIVE → UNLOADING → DISPOSED` for isolated candidates, plus `PENDING → LOADING → ACTIVE` and `LOADING → FAILED → LOADING` for dependency-driven activation. DRAFT plugins expose no live handlers until atomic promotion.
 
 ### Step 5: Per-Turn Engine Assembly
 
@@ -485,7 +489,7 @@ Typical interceptor use cases include audit logging, execution timeout, approval
 
 ### Dependency Binding and Activation
 
-Plugins declare `dependencies`, and `ToolPluginRegistry.bind_runtime()` distributes matching runtime dependencies in topological plugin order. Current ToolPlugin activation still uses the `ScopedToolRegistry` fast path (`PENDING → ACTIVE`) after registration; plugins that require a dependency should degrade gracefully in their handler when the dependency is not bound. A future async activation loop may use the `LOADING`/`FAILED` states for dependency-driven retries, but that is not yet automatic.
+Plugins declare `dependencies`, and `ToolPluginRegistry.bind_runtime()` distributes matching runtime dependencies in topological plugin order. `ScopedToolRegistry` activates dependency-free plugins immediately and keeps dependency-bearing fibers in `LOADING` until their providers are active; handlers must still degrade gracefully when optional runtime dependencies are absent.
 
 ---
 
@@ -530,7 +534,7 @@ description:
 - **`--id <plugin_id>`** — override the auto-derived plugin id (a slug of the
   description). A colliding id is rejected cleanly.
 
-Generation is controlled by `plugin.generation_enabled` (enabled by default in current config; disable via `/config set plugin.generation_enabled false`) and requires an LLM provider. Installation still remains a separate approval-gated action.
+Generation is controlled by `plugin.generation_enabled` and requires an LLM provider. Proposal-backed generation stores validated source in profile CAS and requires explicit content approval. Installation remains a separate mutation approval.
 
 **Difference from the `plugin_generate` agent tool**: `/plugin generate` is a
 *user-initiated* control-plane command — the user's invocation is the consent, so it
diff --git a/src/leapflow/cli/cli.py b/src/leapflow/cli/cli.py
index e25e9e60..797afd5e 100644
--- a/src/leapflow/cli/cli.py
+++ b/src/leapflow/cli/cli.py
@@ -290,10 +290,26 @@ def main(argv: list[str] | None = None) -> int:
     evolve_parser = subparsers.add_parser(
         "evolve", help="Run the learning boundary now and report what it did"
     )
+    evolve_parser.add_argument(
+        "--session",
+        required=True,
+        help="Exact session id whose new evidence should be finalized",
+    )
     evolve_parser.add_argument(
         "--reason", default="manual",
         help="Label recorded with this run (default: manual)",
     )
+    evolve_parser.add_argument(
+        "--wait",
+        action="store_true",
+        help="Wait for the durable teacher job to reach a terminal state",
+    )
+    evolve_parser.add_argument(
+        "--timeout",
+        type=float,
+        default=180.0,
+        help="Maximum wait time in seconds when --wait is set",
+    )
     evolve_parser.add_argument("--json", action="store_true", help="Emit machine-readable JSON")
 
     # leap hw (hardware inspection and direct intervention)
@@ -469,9 +485,8 @@ def main(argv: list[str] | None = None) -> int:
         from leapflow.cli.commands.dashboard import cmd_dashboard
         return cmd_dashboard(args)
 
-    # Evolve routes to leapd, which owns the context holding the trajectory buffer.
-    # Running it in this process would build a second, empty context and grade
-    # nothing, so no Context is initialized here either.
+    # Evolve routes to leapd, the sole writer of the durable event stream and
+    # teacher-job queue. A client-side Context would create a competing writer.
     if args.command == "evolve":
         from leapflow.cli.commands.evolve import cmd_evolve
         return cmd_evolve(args)
diff --git a/src/leapflow/cli/commands/evolve.py b/src/leapflow/cli/commands/evolve.py
index 3700f946..2689ffa2 100644
--- a/src/leapflow/cli/commands/evolve.py
+++ b/src/leapflow/cli/commands/evolve.py
@@ -1,17 +1,12 @@
 """`leap evolve` — run the learning boundary now, and report what it did.
 
-Capability evolution is driven from exactly one place: the learning boundary, which
-grades the recorded trajectory, lets the world model propose capabilities it found
-missing, and runs the cold-path governance sweep. That boundary used to be reachable
-only from context cleanup, which in daemon mode means *process shutdown* — so a
-daemon that ran for a week never evolved, one killed with SIGKILL never evolved at
-all, and there was no way to answer "did it evolve, and what happened" without
-stopping the daemon and reading its log.
-
-This command makes the boundary an explicit, observable operation. It routes to the
-daemon rather than doing the work locally, because the daemon owns the context that
-holds the trajectory buffer and the proposal queue; a second context would grade an
-empty buffer and truthfully report that nothing happened.
+Capability evolution starts at a durable session boundary. The boundary flushes the
+append-only action stream, seals exactly one named session slice, and queues hindsight
+teacher work that survives client exit and daemon restart.
+
+This command routes to the daemon because it is the sole DuckDB writer. Requiring an
+explicit session id prevents one client from accidentally finalizing another client's
+most-recent session.
 
 It decides nothing on its own: whether a proposal is even *written* still depends on
 ``evolution.enabled``, and whether it is acted on still depends on generation,
@@ -49,7 +44,12 @@ async def _run(args: argparse.Namespace) -> int:
         return 1
 
     try:
-        result = await client.evolution_run(reason=str(getattr(args, "reason", "") or "manual"))
+        result = await client.evolution_run(
+            session_id=str(args.session),
+            reason=str(getattr(args, "reason", "") or "manual"),
+            wait=bool(getattr(args, "wait", False)),
+            timeout_s=float(getattr(args, "timeout", 180.0)),
+        )
     except Exception as exc:  # noqa: BLE001 - surfaced, never a traceback
         _report_error(str(exc), as_json)
         return 1
@@ -63,25 +63,25 @@ async def _run(args: argparse.Namespace) -> int:
         return 1
 
     steps = int(result.get("trajectory_steps") or 0)
+    jobs = list(result.get("job_ids") or [])
     print(
-        f"Learning boundary ran ({result.get('reason', 'manual')}) in "
-        f"{result.get('duration_s', 0)}s — {steps} trajectory step(s) graded."
+        f"Session {result.get('session_id', args.session)} finalized "
+        f"({result.get('reason', 'manual')}) in {result.get('duration_s', 0)}s — "
+        f"{steps} evidence event(s), {len(jobs)} teacher job(s) queued."
     )
-    if not steps:
-        # Said plainly, because an empty trajectory is the common case and looks
-        # identical to a failure otherwise. The governance sweep still ran: that is
-        # the whole reason it sits outside the trajectory branch.
-        print(
-            "  No turns were recorded since the last boundary, so the teacher had "
-            "nothing to grade. The governance sweep still ran."
-        )
+    if not jobs:
+        print("  No new action evidence was found after the previous session boundary.")
+    elif result.get("job"):
+        print(f"  Teacher job status: {result['job'].get('status', 'unknown')}")
+    else:
+        print(f"  Durable teacher job: {jobs[0]}")
     if not getattr(settings, "evolution_enabled", False):
         print(
-            "  Self-evolution is off, so no capability proposal was written. "
-            "The world model still graded and recorded what it learned. "
+            "  Self-evolution is off, so teacher output cannot authorize a capability proposal. "
+            "Durable teacher grading remains enabled. "
             "Enable with: leap config set evolution.enabled true"
         )
-    print("  See the result on the board: leap board evolution")
+    print("  See durable progress on the board: leap board evolution")
     return 0
 
 
diff --git a/src/leapflow/cli/context.py b/src/leapflow/cli/context.py
index 288e80b2..4d3fb412 100644
--- a/src/leapflow/cli/context.py
+++ b/src/leapflow/cli/context.py
@@ -26,7 +26,6 @@
     IntentClassifier,
     LLMIntentClassifier,
 )
-from leapflow.engine.scheduler import TaskScheduler
 from leapflow.engine.session import SessionController
 from leapflow.recording.attention import build_attention_filters
 from leapflow.analysis.pipeline import ImitationPipeline
@@ -385,6 +384,21 @@ def __init__(self, settings: Settings, mock_host: bool) -> None:
             settings.duckdb_path,
             volatile_on_lock=True,
         )
+        # Long-running evolution evidence is profile-scoped and daemon-owned. The
+        # store schema initializes on a worker thread in ``initialize_critical``;
+        # the outbox stays on the event loop. Session engines share both while
+        # supplying their own causal identifiers.
+        self._evolution_event_store: Optional[Any] = None
+        self._evolution_artifact_store: Optional[Any] = None
+        self._evolution_outbox: Optional[Any] = None
+        self._action_recorder: Optional[Any] = None
+        self._action_executor: Optional[Any] = None
+        self._session_finalizer: Optional[Any] = None
+        self._teacher_worker: Optional[Any] = None
+        self._evolution_projection_runner: Optional[Any] = None
+        self._evolution_knowledge_store: Optional[Any] = None
+        self._capability_proposal_queue: Optional[Any] = None
+        self._plugin_outcome_store: Optional[Any] = None
 
         # Memory subsystem — provider-based architecture (dual-layer)
         working = WorkingMemoryProvider(max_tokens=settings.memory_working_max_tokens)
@@ -1403,6 +1417,60 @@ async def initialize_critical(self, *, daemon_mode: bool = True) -> None:
         settings = self.settings
 
         await self.memory.initialize_all()
+        if self._action_recorder is None:
+            from leapflow.engine.action_executor import RecordedActionExecutor
+            from leapflow.evolution.action_recorder import ActionRecorder
+            from leapflow.evolution.artifact_store import ContentAddressedArtifactStore
+            from leapflow.evolution.outbox import EvolutionEventOutbox
+            from leapflow.evolution.projection import EvolutionProjectionRunner
+            from leapflow.evolution.session_finalizer import SessionFinalizer
+            from leapflow.storage.capability_proposal_queue import (
+                EvolutionCapabilityProposalStore,
+            )
+            from leapflow.storage.distilled_knowledge_store import (
+                EvolutionDistilledKnowledgeStore,
+            )
+            from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+            from leapflow.storage.plugin_outcome_store import EvolutionPluginOutcomeStore
+            from leapflow.version import __version__
+
+            self._evolution_event_store = await asyncio.to_thread(
+                DuckDBEvolutionEventStore,
+                self._db_holder,
+            )
+            self._evolution_artifact_store = ContentAddressedArtifactStore(
+                settings.profile_layout.evolution_artifacts_dir
+            )
+            self._evolution_outbox = EvolutionEventOutbox(self._evolution_event_store)
+            self._evolution_outbox.start()
+            self._action_recorder = ActionRecorder(
+                self._evolution_outbox,
+                producer_version=__version__,
+            )
+            self._action_executor = RecordedActionExecutor(self._action_recorder)
+            self._session_finalizer = SessionFinalizer(
+                self._evolution_event_store,
+                self._evolution_outbox,
+            )
+            self._evolution_projection_runner = EvolutionProjectionRunner(
+                self._evolution_event_store
+            )
+            self._evolution_knowledge_store = EvolutionDistilledKnowledgeStore(
+                self._evolution_event_store,
+                profile_id=settings.profile_layout.profile_id,
+                ttl_seconds=float(
+                    getattr(settings, "distilled_knowledge_ttl_s", 0.0) or 0.0
+                ),
+            )
+            await asyncio.to_thread(self._evolution_knowledge_store.refresh)
+            self._capability_proposal_queue = EvolutionCapabilityProposalStore(
+                self._evolution_event_store,
+                profile_id=settings.profile_layout.profile_id,
+            )
+            self._plugin_outcome_store = EvolutionPluginOutcomeStore(
+                self._evolution_event_store,
+                profile_id=settings.profile_layout.profile_id,
+            )
         if self.storage_volatile:
             _emit_status(
                 "Primary database is locked; running with volatile session storage."
@@ -1562,9 +1630,6 @@ async def initialize_critical(self, *, daemon_mode: bool = True) -> None:
         # are assembled in initialize_deferred()
         
         graph_planner = GraphPlanner(self.llm, self.registry) if settings.has_llm_credentials else None
-        scheduler = TaskScheduler(
-            self.registry, self.rpc, graph_planner=graph_planner,
-        ) if graph_planner else None
 
         # Bind perception/execution to the desktop semantic plugin
         from leapflow.plugins import get_registry as _get_tool_registry
@@ -1885,7 +1950,6 @@ async def _summarize_via_llm(prompt: str) -> str:
             imitation=None,  # wired in initialize_deferred()
             skill_library=self.skill_lib,
             graph_planner=graph_planner,
-            scheduler=scheduler,
             perception=perception,
             execution=execution_adapter,
             skill_activator=None,  # wired in initialize_deferred()
@@ -1895,7 +1959,9 @@ async def _summarize_via_llm(prompt: str) -> str:
             evolution=self._evolution,
             skill_injector=skill_injector,
             skill_index=skill_index,
+            action_executor=self._action_executor,
         )
+        self.engine.set_distilled_knowledge_store(self._evolution_knowledge_store)
 
         # ── Wire CompressorConfig with archive_fn into engine ──
         from leapflow.engine.context_compressor import ContextCompressor
@@ -2471,6 +2537,56 @@ async def initialize_deferred(self) -> None:
                 experience_store=self.experience_store,
                 budget=self.learning_budget,
             )
+            if (
+                self._teacher_worker is None
+                and self._evolution_event_store is not None
+                and self._evolution_artifact_store is not None
+            ):
+                from leapflow.evolution.teacher_worker import DurableTeacherWorker
+                from leapflow.learning.degradation_sink import (
+                    build_live_capability_resolver,
+                )
+                from leapflow.plugins import get_registry
+                from leapflow.version import __version__
+
+                observation_service = self._capability_observation_service()
+                proposal_queue = (
+                    self._capability_proposal_queue
+                    if settings.evolution_enabled
+                    else None
+                )
+                acquisition_resolver = (
+                    build_live_capability_resolver(
+                        registry_provider=get_registry,
+                        environment_provider=self._current_environment_fingerprint,
+                    )
+                    if proposal_queue is not None
+                    else None
+                )
+                self._teacher_worker = DurableTeacherWorker(
+                    store=self._evolution_event_store,
+                    artifact_store=self._evolution_artifact_store,
+                    teacher=self.trajectory_grader,
+                    profile_id=settings.profile_layout.profile_id,
+                    producer_version=__version__,
+                    poll_interval_s=settings.evolution_teacher_poll_interval_s,
+                    lease_seconds=settings.evolution_teacher_lease_s,
+                    teacher_timeout_s=settings.evolution_teacher_timeout_s,
+                    max_attempts=settings.evolution_teacher_max_attempts,
+                    retry_backoff_s=settings.evolution_teacher_retry_backoff_s,
+                    proposal_queue=proposal_queue,
+                    acquisition_resolver=acquisition_resolver,
+                    authorising_origins=tuple(
+                        getattr(settings, "evolution_authorising_origins", ()) or ()
+                    ),
+                    degraded_capabilities=(
+                        observation_service.degraded_capabilities
+                        if observation_service is not None
+                        else None
+                    ),
+                    knowledge_projection=self._evolution_knowledge_store,
+                )
+                self._teacher_worker.start()
             self.registry.set_prediction_loop(self.prediction_loop)
 
             if perception_session is not None:
@@ -2664,6 +2780,7 @@ def _on_prediction_outcome(outcome: Any) -> None:
             learnability_assessor=learnability_assessor,
             evolution_policy=self._evolution_policy,
             skill_store=self.skill_lib,
+            action_dispatcher=self.engine.execute_action if self.engine is not None else None,
         )
 
         # ── Wire deferred components to engine ──
@@ -2713,6 +2830,7 @@ def _load_evolution_store() -> "tuple[Any, list[dict[str, Any]]]":
         try:
             if getattr(settings, "agent_calibration_enabled", False) and self._evolution_store is not None:
                 self.engine.set_calibration_store(self._evolution_store)
+                self.engine.set_calibration_event_store(self._evolution_event_store)
                 diff_result = await self._run_deferred_db(
                     lambda: self.engine.recalibrate_difficulty(self._evolution_store)
                 )
@@ -3114,6 +3232,46 @@ def _capability_observation_service(self):
         )
         return self._observation_service
 
+    async def record_environment_observation(self, observation: Any) -> None:
+        """Persist one typed environment observation and feed accepted gap evidence."""
+        outbox = self._evolution_outbox
+        if outbox is None:
+            raise RuntimeError("evolution event outbox unavailable")
+        from leapflow.domain.event_types import EvolutionEventType
+        from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent
+
+        context = EvolutionContext.create(
+            profile_id=self.settings.profile_layout.profile_id,
+            workspace_id=str(getattr(observation, "workspace_id", "") or ""),
+            session_id=str(getattr(observation, "session_id", "") or ""),
+            observation_id=str(observation.observation_id),
+            correlation_id=f"environment:{observation.source_id}:{observation.app_id}",
+        )
+        await outbox.publish(
+            EvolutionEvent.create(
+                EvolutionEventType.ENVIRONMENT_OBSERVED,
+                context=context,
+                payload=observation.to_dict(),
+                producer=f"environment.{observation.source_id}",
+                privacy_class="session" if context.session_id else "system",
+                occurred_at=observation.observed_at,
+                dedup_key=f"environment.observed:{observation.observation_id}",
+            )
+        )
+        service = self._capability_observation_service()
+        if service is None:
+            return
+        for result in observation.capability_results():
+            await asyncio.to_thread(
+                service.observe_result,
+                result,
+                environment=self._current_environment_dict(),
+                source="environment_probe",
+                session_id=context.session_id,
+                workspace_root=str(getattr(self.settings, "workspace_root", "") or ""),
+                metadata={"environment_observation_id": observation.observation_id},
+            )
+
     def _current_environment_fingerprint(self):
         """The environment a capability decision is made against, as a fingerprint.
 
@@ -3189,28 +3347,17 @@ def _resolve_lifecycle_governor(self):
             from leapflow.learning.degradation_sink import build_degradation_sink
             from leapflow.plugins import get_registry
             from leapflow.plugins.lifecycle_governor import LifecycleGovernor
-            from leapflow.storage.capability_proposal_queue import (
-                JsonCapabilityProposalQueue,
-            )
-            from leapflow.storage.distilled_knowledge_store import (
-                JsonDistilledKnowledgeStore,
-            )
-            from leapflow.storage.plugin_outcome_store import JsonPluginOutcomeStore
 
             intake = self._capability_observation_service()
             if intake is None:
                 return None
-            knowledge_store = JsonDistilledKnowledgeStore(
-                profile_layout.distilled_knowledge_path,
-                ttl_seconds=float(
-                    getattr(settings, "distilled_knowledge_ttl_s", 0.0) or 0.0
-                ),
-            )
+            knowledge_store = self._evolution_knowledge_store
+            proposal_queue = self._capability_proposal_queue
+            if proposal_queue is None:
+                return None
             self._lifecycle_governor = LifecycleGovernor(
-                proposal_queue=JsonCapabilityProposalQueue(
-                    profile_layout.capability_proposal_queue_path
-                ),
-                outcome_store=JsonPluginOutcomeStore(profile_layout.plugin_outcomes_path),
+                proposal_queue=proposal_queue,
+                outcome_store=self._plugin_outcome_store,
                 # The approval-gated actor that actually disables a plugin. Without it the
                 # governor decided "quarantine" and nothing happened: trust dropped but the
                 # plugin kept serving, and the queue never advanced past PROBATION. Built
@@ -3294,13 +3441,9 @@ def _active_proposal_ids(self) -> dict:
         if profile_layout is None:
             return {}
         try:
-            from leapflow.storage.capability_proposal_queue import (
-                JsonCapabilityProposalQueue,
-            )
-
-            queue = JsonCapabilityProposalQueue(
-                profile_layout.capability_proposal_queue_path
-            )
+            queue = self._capability_proposal_queue
+            if queue is None:
+                return {}
             mapping: dict = {}
             # ``active()`` returns items newest-first (sorted by updated/created), so the
             # first mapping seen for a plugin is its most recent lifecycle record. Keep
@@ -3363,391 +3506,100 @@ async def _run_coevolution_sweep(self):
             logger.debug("co-evolution sweep unavailable", exc_info=True)
             return None
 
-    async def _drive_world_model_evolution(self, trajectory: list, goal: str):
-        """Let the world model propose capability gaps from episode hindsight.
-
-        Returns a ``WorldModelDriveResult`` (whose ``grades`` the caller reuses so
-        no second LLM call is made), or ``None`` when the driver cannot be
-        assembled -- in which case the caller falls back to plain grading.
-
-        Runs only at the session-end learning boundary, so it adds no per-turn
-        cost. Intents are written as ordinary structured evidence and are admitted
-        only if ``accepted_evidence_kinds`` includes ``world_model_intent``; the
-        driver never writes around that gate.
-        """
-        try:
-            from leapflow.learning.degradation_sink import (
-                build_alternatives_provider,
-                build_proposal_sink,
-            )
-            from leapflow.plugins import get_registry
-            from leapflow.learning.world_model_driver import WorldModelEvolutionDriver
-            from leapflow.storage.capability_proposal_queue import (
-                JsonCapabilityProposalQueue,
-            )
-            from leapflow.storage.distilled_knowledge_store import (
-                JsonDistilledKnowledgeStore,
-            )
-
-            settings = self.settings
-            profile_layout = getattr(settings, "profile_layout", None)
-            if profile_layout is None or self.trajectory_grader is None:
-                return None
-            # The shared service, so the requirements the teacher reads are the ones
-            # the degradation sink wrote.
-            service = self._capability_observation_service()
-            if service is None:
-                return None
-            driver = WorldModelEvolutionDriver(
-                teacher=self.trajectory_grader,
-                intake=service,
-                # The C1 channel. Without it the cheap verdicts are graded, traced and
-                # discarded, so the teacher judges correctly and the next session
-                # repeats the same mistake.
-                knowledge_store=JsonDistilledKnowledgeStore(
-                    profile_layout.distilled_knowledge_path,
-                    ttl_seconds=float(
-                        getattr(settings, "distilled_knowledge_ttl_s", 0.0) or 0.0
-                    ),
-                ),
-                # The last hop of the acquisition chain. Without it an ``acquire``
-                # verdict became a requirement and stopped: resolution reported the
-                # capability unmet forever and the only verdict that leads to code had
-                # no effect. Queueing is not acting -- the queue is read by the
-                # dashboard and the self-management tools, which gate on approval.
-                # The fact the rebind/acquire choice is defined by. A teacher that
-                # cannot see whether another provider exists is guessing between them.
-                alternatives_for=build_alternatives_provider(
-                    registry_provider=get_registry,
-                    affordances_provider=self._current_affordances,
-                ),
-                # The last hop of the acquisition chain, and the one the switch governs.
-                # Queueing is still not acting -- the queue is read by the dashboard and the
-                # self-management tools, which gate on approval -- so this is the outermost
-                # of several gates rather than the only one.
-                #
-                # ``None`` when self-evolution is off, which says more than an empty queue
-                # would: the teacher still judges and still records that nothing installed
-                # can serve the capability, and that conclusion reaches the user as
-                # knowledge instead of as a proposal to build something.
-                proposal_sink=(
-                    build_proposal_sink(
-                        queue=JsonCapabilityProposalQueue(
-                            profile_layout.capability_proposal_queue_path
-                        ),
-                    )
-                    if getattr(settings, "evolution_enabled", False)
-                    else None
-                ),
-                # P5 authority in the production path: only an authorised requirement
-                # origin may drive an acquisition. Rebind-vs-acquire (whether an
-                # installed provider already covers the capability) is decided upstream
-                # by the teacher from failed-outcome hindsight and the alternatives it
-                # was shown -- a declared-fitness re-check here would re-introduce the
-                # semantic-regression blind spot -- so the driver adds authority only.
-                authorising_origins=tuple(
-                    getattr(settings, "evolution_authorising_origins", ()) or ()
-                ),
+    async def evolution_projection(
+        self,
+        *,
+        session_id: str = "",
+        aggregate: bool = False,
+        rebuild: bool = False,
+    ) -> dict[str, Any]:
+        """Return a checkpointed event projection for one session or the profile."""
+        runner = self._evolution_projection_runner
+        if runner is None:
+            return {"ok": False, "error": "evolution projection unavailable"}
+        if self._evolution_outbox is not None:
+            await self._evolution_outbox.flush()
+        profile_id = self.settings.profile_layout.profile_id
+        if aggregate:
+            projection = await runner.project_aggregate(
+                profile_id=profile_id,
+                rebuild=rebuild,
             )
-            return await driver.drive(
-                trajectory,
-                goal,
-                environment=self._current_environment_fingerprint(),
-                workspace_root=str(getattr(settings, "workspace_root", "") or ""),
+        else:
+            if not session_id:
+                return {"ok": False, "error": "session_id is required"}
+            projection = await runner.project_session(
+                profile_id=profile_id,
+                session_id=session_id,
+                rebuild=rebuild,
             )
-        except (ImportError, AttributeError, OSError, RuntimeError, TypeError, ValueError):
-            logger.debug("world-model evolution driver unavailable", exc_info=True)
-            return None
+        return {"ok": True, "projection": projection}
 
-    async def run_learning_boundary(self, *, reason: str = "shutdown") -> dict[str, Any]:
-        """Run the learning boundary once and report what it did.
-
-        This is the only place capability evolution is driven from, so *when* it is
-        called decides when the framework can evolve at all. It used to be reachable
-        only from :meth:`cleanup`, which in daemon mode means process shutdown: a
-        daemon that ran for a week never evolved, one killed with SIGKILL never
-        evolved at all, and the single flush at the end mixed every session and every
-        workspace of that lifetime into one episode carrying the last user's goal.
-
-        Named and public so a semantic boundary can drive it -- a finished session,
-        or an explicit ``leap evolve`` -- instead of only the process dying.
-        ``reason`` is recorded rather than inspected: the pipeline does the same work
-        either way, and the label is what lets a reader tell a shutdown flush from a
-        session boundary from a hand-run one.
-        """
+    async def run_learning_boundary(
+        self,
+        *,
+        reason: str = "manual",
+        session_id: str = "",
+        workspace_root: str = "",
+        session_generation: int = 0,
+        wait: bool = False,
+        timeout_s: float = 180.0,
+    ) -> dict[str, Any]:
+        """Seal session evidence and enqueue durable hindsight grading."""
+        finalizer = self._session_finalizer
+        if finalizer is None:
+            return {"ok": False, "error": "evolution event store unavailable"}
         started = time.perf_counter()
-        before = len(self.prediction_loop.trajectory_buffer) if self.prediction_loop else 0
-        await self._on_session_end_learning()
+        profile_id = self.settings.profile_layout.profile_id
+        model = str(getattr(self.settings, "llm_model", "") or "")
+        if session_id:
+            from leapflow.layout import workspace_id_for_path
+
+            workspace_id = (
+                workspace_id_for_path(Path(workspace_root).expanduser().resolve())
+                if workspace_root
+                else ""
+            )
+            finalizations = [
+                await finalizer.finalize(
+                    profile_id=profile_id,
+                    workspace_id=workspace_id,
+                    session_id=session_id,
+                    session_generation=session_generation,
+                    reason=reason,
+                    model=model,
+                )
+            ]
+        elif reason == "shutdown":
+            finalizations = await finalizer.finalize_pending_sessions(
+                profile_id=profile_id,
+                reason=reason,
+                model=model,
+            )
+        else:
+            return {"ok": False, "error": "session_id is required", "reason": reason}
+
+        worker = self._teacher_worker
+        if worker is not None:
+            worker.wake()
+        jobs = [item.job_id for item in finalizations if item.job_id]
+        job_state: dict[str, Any] | None = None
+        if wait and jobs and worker is not None:
+            job_state = await worker.wait_for_job(jobs[0], timeout_s=timeout_s)
+        sweep = await self._run_coevolution_sweep()
         return {
             "ok": True,
             "reason": reason,
-            "trajectory_steps": before,
+            "session_id": session_id,
+            "queued": bool(jobs),
+            "episode_ids": [item.episode_id for item in finalizations if item.episode_id],
+            "job_ids": jobs,
+            "trajectory_steps": sum(item.evidence_count for item in finalizations),
+            "job": job_state,
+            "sweep": sweep.to_dict() if sweep is not None else None,
             "duration_s": round(time.perf_counter() - started, 3),
         }
 
-    async def _on_session_end_learning(self) -> None:
-        """End-of-session OPD learning pipeline (8 phases) with full observability.
-
-        Executes in order:
-        1. Trajectory grading (teacher with full hindsight) — grades consumed by replay_engine
-        2. Off-policy experience replay (high-delta)
-        3. Curiosity-targeted replay (high-curiosity apps) — curiosity fed to attention_tuner
-        4. Regression-gated self-distillation (causal rules)
-        5. Attention statistics feedback (AttentionTuner)
-        6. Long-term memory maintenance (prune old rows)
-        7. Budget rebalancing from session outcomes
-        8. VLM Tier 3 verification (if enabled)
-        """
-        observer = self._pipeline_observer
-        if observer is None:
-            # Deferred init never completed (degraded/critical-only mode):
-            # no learning components were assembled, nothing to flush.
-            logger.debug("Session-end learning skipped: pipeline observer not initialized")
-            return
-        pipeline_start = time.perf_counter()
-        phases_ok = 0
-        phases_failed = 0
-        trajectory: list = []
-
-        # Phase 1: Trajectory grading — FIX A5-1: grades now consumed by replay_engine
-        if self.trajectory_grader is not None and self.prediction_loop is not None:
-            observer.on_phase_start("trajectory_grading")
-            t0 = time.perf_counter()
-            try:
-                trajectory, goal = self.prediction_loop.flush_trajectory()
-                phase_detail: dict[str, Any] = {}
-                if trajectory:
-                    # The world model is the first driver of capability evolution:
-                    # the same hindsight call that grades the episode also proposes
-                    # any capability it found missing, and those proposals enter the
-                    # ordinary governed evidence path. Admission is still gated by
-                    # ``accepted_evidence_kinds``, so this is inert until opted in.
-                    drive = await self._drive_world_model_evolution(trajectory, goal)
-                    grades = list(drive.grades) if drive is not None else None
-                    if grades is None:
-                        grades = await self.trajectory_grader.grade_trajectory(
-                            trajectory, goal=goal,
-                        )
-                    if grades and self.replay_engine is not None:
-                        self.replay_engine.set_replay_priorities(grades)
-                    phase_detail["actions_graded"] = len(grades) if grades else 0
-                    if drive is not None:
-                        phase_detail.update(drive.to_dict())
-                else:
-                    phase_detail.update({"actions_graded": 0, "note": "empty_trajectory"})
-                # Cold-path governance sweep: effect verification, quarantine drain,
-                # reclamation. Outside the trajectory branch, because its whole
-                # purpose is that its no-op traces distinguish a quiet session from a
-                # sweep that never ran -- and nested inside it, an empty trajectory
-                # skipped the sweep entirely and produced exactly the ambiguity it
-                # was written to remove. Three reachability segments read
-                # "no sweep trace observed" on a live board for that reason alone.
-                #
-                # Nothing here depends on the trajectory: the sweep reads the process
-                # observation buffer and the proposal queue, both of which carry work
-                # from turns that predate this boundary.
-                sweep = await self._run_coevolution_sweep()
-                if sweep is not None:
-                    phase_detail.update(sweep.to_dict())
-                observer.on_phase_success(
-                    "trajectory_grading", time.perf_counter() - t0, phase_detail,
-                )
-                phases_ok += 1
-            except Exception as exc:
-                observer.on_phase_failure("trajectory_grading", exc, time.perf_counter() - t0)
-                phases_failed += 1
-
-        # Phase 2: Off-policy replay
-        if self.replay_engine is not None:
-            observer.on_phase_start("off_policy_replay")
-            t0 = time.perf_counter()
-            try:
-                insights = await self.replay_engine.replay_session()
-                observer.on_phase_success(
-                    "off_policy_replay", time.perf_counter() - t0,
-                    {"insights_discovered": len(insights) if insights else 0},
-                )
-                phases_ok += 1
-            except Exception as exc:
-                observer.on_phase_failure("off_policy_replay", exc, time.perf_counter() - t0)
-                phases_failed += 1
-
-        # Phase 3: Curiosity-targeted replay — FIX A5-2: feed curiosity to attention_tuner
-        if self.replay_engine is not None and self.active_observer is not None:
-            observer.on_phase_start("curiosity_replay")
-            t0 = time.perf_counter()
-            try:
-                curious_apps = self.active_observer.drain_high_curiosity_apps()
-                for app_ctx in curious_apps:
-                    await self.replay_engine.replay_targeted(app_ctx)
-                tuner = getattr(self, "attention_tuner", None)
-                if tuner is not None and curious_apps:
-                    tuner.boost_curiosity_domains(curious_apps)
-                observer.on_phase_success(
-                    "curiosity_replay", time.perf_counter() - t0,
-                    {"curious_apps": len(curious_apps)},
-                )
-                phases_ok += 1
-            except Exception as exc:
-                observer.on_phase_failure("curiosity_replay", exc, time.perf_counter() - t0)
-                phases_failed += 1
-
-        # Phase 4: Regression-gated self-distillation
-        if self.replay_engine is not None and trajectory:
-            observer.on_phase_start("regression_distillation")
-            t0 = time.perf_counter()
-            try:
-                if self.replay_engine.detect_regression(trajectory):
-                    distilled = await self.replay_engine.self_distill()
-                    observer.on_phase_success(
-                        "regression_distillation", time.perf_counter() - t0,
-                        {"regression_detected": True, "rules_distilled": len(distilled)},
-                    )
-                else:
-                    observer.on_phase_success(
-                        "regression_distillation", time.perf_counter() - t0,
-                        {"regression_detected": False},
-                    )
-                phases_ok += 1
-            except Exception as exc:
-                observer.on_phase_failure("regression_distillation", exc, time.perf_counter() - t0)
-                phases_failed += 1
-
-        # Phase 5: Attention statistics feedback
-        tuner = getattr(self, "attention_tuner", None)
-        if tuner is not None and trajectory:
-            observer.on_phase_start("attention_feedback")
-            t0 = time.perf_counter()
-            try:
-                from collections import defaultdict
-                app_sums: dict = defaultdict(lambda: [0.0, 0])
-                for step in trajectory:
-                    app = step.get("app_context", "")
-                    delta = step.get("delta", 0.0)
-                    if app:
-                        app_sums[app][0] += delta
-                        app_sums[app][1] += 1
-                app_deltas = {a: s[0] / s[1] for a, s in app_sums.items() if s[1] > 0}
-                if app_deltas:
-                    tuner.on_session_stats(app_deltas)
-                observer.on_phase_success(
-                    "attention_feedback", time.perf_counter() - t0,
-                    {"apps_tracked": len(app_deltas)},
-                )
-                phases_ok += 1
-            except Exception as exc:
-                observer.on_phase_failure("attention_feedback", exc, time.perf_counter() - t0)
-                phases_failed += 1
-
-        # Phase 6: Long-term memory maintenance
-        observer.on_phase_start("memory_prune")
-        t0 = time.perf_counter()
-        try:
-            pruned = self.lt.prune(max_age_days=self.settings.memory_prune_age_days)
-            observer.on_phase_success(
-                "memory_prune", time.perf_counter() - t0,
-                {"rows_pruned": pruned or 0},
-            )
-            phases_ok += 1
-        except Exception as exc:
-            observer.on_phase_failure("memory_prune", exc, time.perf_counter() - t0)
-            phases_failed += 1
-
-        # Phase 6.5: Skill inactivity decay (C4 — after memory prune, before budget rebalance)
-        if self._evolution_policy is not None and self.skill_lib is not None:
-            observer.on_phase_start("skill_decay")
-            t0 = time.perf_counter()
-            try:
-                all_skills = self.skill_lib.load_all_active_parameterized()
-                decayed_count = 0
-                for skill in all_skills:
-                    last_used = skill.get("updated_at", 0.0)
-                    days_inactive = (time.time() - last_used) / 86400.0
-                    if days_inactive > 30:  # Only decay after 30 days of inactivity
-                        outcome = self._evolution_policy.decay_inactive(
-                            skill.get("name", ""),
-                            current_confidence=skill.get("confidence", 0.5),
-                            current_version=skill.get("version", 1),
-                            last_used_ts=last_used,
-                        )
-                        if outcome.tier_changed:
-                            self.skill_lib.update_skill_confidence(
-                                skill.get("name", ""), outcome.new_confidence
-                            )
-                            decayed_count += 1
-                observer.on_phase_success(
-                    "skill_decay", time.perf_counter() - t0,
-                    {"skills_decayed": decayed_count, "skills_checked": len(all_skills)},
-                )
-                phases_ok += 1
-            except Exception as exc:
-                observer.on_phase_failure("skill_decay", exc, time.perf_counter() - t0)
-                phases_failed += 1
-
-        # Phase 7: Budget rebalancing
-        budget = getattr(self, "learning_budget", None)
-        if budget is not None:
-            observer.on_phase_start("budget_rebalance")
-            t0 = time.perf_counter()
-            try:
-                skills_discovered = 0
-                regressions_detected = 0
-                avg_delta = 0.0
-                if trajectory:
-                    deltas = [s.get("delta", 0.0) for s in trajectory if isinstance(s, dict)]
-                    avg_delta = sum(deltas) / max(len(deltas), 1)
-                    regressions_detected = sum(
-                        1 for s in trajectory
-                        if isinstance(s, dict) and s.get("verdict") == "regressed"
-                    )
-                replay_engine = getattr(self, "replay_engine", None)
-                if replay_engine is not None:
-                    skills_discovered = getattr(replay_engine, "session_discoveries", 0)
-                budget.rebalance_from_session_outcome(
-                    skills_discovered=skills_discovered,
-                    regressions_detected=regressions_detected,
-                    avg_prediction_delta=avg_delta,
-                )
-                observer.on_phase_success(
-                    "budget_rebalance", time.perf_counter() - t0,
-                    {"avg_delta": round(avg_delta, 4), "regressions": regressions_detected},
-                )
-                phases_ok += 1
-            except Exception as exc:
-                observer.on_phase_failure("budget_rebalance", exc, time.perf_counter() - t0)
-                phases_failed += 1
-
-        # Phase 8: VLM Tier 3 verification
-        if self.settings.causal_tier3_enabled:
-            observer.on_phase_start("vlm_tier3")
-            t0 = time.perf_counter()
-            try:
-                ps = self.perception_session
-                if ps is not None:
-                    pipeline = ps.causal_pipeline
-                    graph = ps.causal_graph
-
-                    async def _vlm_call(prompt: str) -> str:
-                        vlm = self.vlm or self.llm
-                        resp = await vlm.achat(
-                            [{"role": "user", "content": prompt}],
-                            stream=False,
-                            enable_thinking=False,
-                        )
-                        return (resp.content or "").strip()
-
-                    await pipeline.run_vlm_verification(graph, vlm_call=_vlm_call)
-                observer.on_phase_success("vlm_tier3", time.perf_counter() - t0, {})
-                phases_ok += 1
-            except Exception as exc:
-                observer.on_phase_failure("vlm_tier3", exc, time.perf_counter() - t0)
-                phases_failed += 1
-
-        # Pipeline complete
-        observer.on_pipeline_complete(
-            time.perf_counter() - pipeline_start, phases_ok, phases_failed,
-        )
-
     _NORMALIZER_FACTORIES: dict[str, type] = {}
 
     @staticmethod
@@ -3829,6 +3681,13 @@ async def cleanup(self) -> None:
             db_executor.shutdown(wait=True, cancel_futures=True)
             self._deferred_db_executor = None
 
+        teacher_worker = getattr(self, "_teacher_worker", None)
+        if teacher_worker is not None:
+            try:
+                await teacher_worker.close()
+            except Exception:
+                logger.warning("Teacher worker shutdown failed", exc_info=True)
+
         # Persist evolution episodes to DuckDB before shutdown
         evo_store = getattr(self, "_evolution_store", None)
         if evo_store is not None and self._evolution is not None:
@@ -3903,11 +3762,23 @@ async def cleanup(self) -> None:
             await self.event_bus.shutdown()
         except Exception:
             logger.debug("EventBus shutdown failed", exc_info=True)
-        # OPD end-of-session learning pipeline
-        if self.settings.replay_on_session_end:
+        # Seal every session independently. The teacher worker is already stopped,
+        # so newly queued jobs remain durable and are reclaimed on the next start.
+        try:
             await self.run_learning_boundary(reason="shutdown")
+        except Exception:
+            logger.warning("Evolution session finalization failed", exc_info=True)
         # Persist session summary before memory shutdown
         await self._persist_session_summary()
+        # Drain the append-only evolution outbox while the shared DuckDB holder is
+        # still alive. A shutdown may happen immediately after a mutating action, and
+        # losing its completion fact would make recovery guess whether it ran.
+        evolution_outbox = getattr(self, "_evolution_outbox", None)
+        if evolution_outbox is not None:
+            try:
+                await evolution_outbox.close()
+            except Exception:
+                logger.exception("Evolution event outbox shutdown failed")
         # Shutdown all memory providers (stops GC, closes DB)
         await self.memory.shutdown_all()
         if isinstance(self.rpc, CuaDriverClient):
diff --git a/src/leapflow/config.py b/src/leapflow/config.py
index 1bb6e675..e87643ae 100644
--- a/src/leapflow/config.py
+++ b/src/leapflow/config.py
@@ -128,6 +128,12 @@ class Settings:
     # When non-empty, marketplace installs MUST carry a valid signature from
     # one of these keys; empty tuple -> checksum-only integrity verification.
     plugin_marketplace_trusted_pubkeys: tuple[str, ...] = ()
+    # Python plugin sandbox limits. Zero CPU/memory disables that individual
+    # operating-system limit; request and shutdown timeouts are always bounded.
+    plugin_sandbox_invoke_timeout_s: float = 15.0
+    plugin_sandbox_shutdown_timeout_s: float = 3.0
+    plugin_sandbox_cpu_time_s: int = 30
+    plugin_sandbox_max_memory_mb: int = 0
     # Restricted DeepSeek Harness / Cordis bridge runtime. These are cold-path
     # process limits; changing them requires rebuilding daemon-owned plugin
     # wrappers and therefore takes effect after daemon restart.
@@ -390,6 +396,17 @@ class Settings:
     # driver is the world model" -- other origins keep being recorded and resolved,
     # but can no longer authorise acquiring new code.
     evolution_authorising_origins: tuple[str, ...] = ()
+    evolution_teacher_poll_interval_s: float = 1.0
+    evolution_teacher_lease_s: float = 120.0
+    evolution_teacher_timeout_s: float = 180.0
+    evolution_teacher_max_attempts: int = 3
+    evolution_teacher_retry_backoff_s: float = 5.0
+    evolution_autonomy_level: str = "generate_only"
+    environment_mode: str = "production"
+    environment_leapspace_enabled: bool = False
+    environment_leapspace_state_root: str = ""
+    environment_leapspace_session_id: str = ""
+    environment_leapspace_poll_interval_s: float = 0.5
     # Which registered policy chooses among admissible tool candidates. ``greedy``
     # is the shipped default and reproduces the selection made before the policy
     # seam existed: highest weighted score, stable tie-break.
@@ -524,6 +541,10 @@ class Settings:
     agent_calibration_enabled: bool = False
     agent_calibration_min_confidence: float = 0.3
     agent_calibration_interval_turns: int = 0
+    agent_calibration_difficulty_min_k: float = 0.25
+    agent_calibration_difficulty_max_k: float = 3.0
+    agent_calibration_finalizing_min_ratio: float = 0.6
+    agent_calibration_finalizing_max_ratio: float = 0.98
     agent_compression_writeback: bool = False
     agent_reentry_enabled: bool = False
     agent_reentry_tick_seconds: float = 30.0
@@ -980,6 +1001,37 @@ def _build_settings_from_env(
         for origin in os.getenv("LEAPFLOW_EVOLUTION_AUTHORISING_ORIGINS", "").split(",")
         if origin.strip()
     )
+    evolution_teacher_poll_interval_s = float(
+        os.getenv("LEAPFLOW_EVOLUTION_TEACHER_POLL_INTERVAL_S", "1.0")
+    )
+    evolution_teacher_lease_s = float(
+        os.getenv("LEAPFLOW_EVOLUTION_TEACHER_LEASE_S", "120.0")
+    )
+    evolution_teacher_timeout_s = float(
+        os.getenv("LEAPFLOW_EVOLUTION_TEACHER_TIMEOUT_S", "180.0")
+    )
+    evolution_teacher_max_attempts = int(
+        os.getenv("LEAPFLOW_EVOLUTION_TEACHER_MAX_ATTEMPTS", "3")
+    )
+    evolution_teacher_retry_backoff_s = float(
+        os.getenv("LEAPFLOW_EVOLUTION_TEACHER_RETRY_BACKOFF_S", "5.0")
+    )
+    evolution_autonomy_level = os.getenv(
+        "LEAPFLOW_EVOLUTION_AUTONOMY_LEVEL", "generate_only"
+    ).strip()
+    environment_mode = os.getenv("LEAPFLOW_ENVIRONMENT_MODE", "production").strip().lower()
+    environment_leapspace_enabled = _bool(
+        "LEAPFLOW_ENVIRONMENT_LEAPSPACE_ENABLED", "false"
+    )
+    environment_leapspace_state_root = os.getenv(
+        "LEAPFLOW_ENVIRONMENT_LEAPSPACE_STATE_ROOT", ""
+    ).strip()
+    environment_leapspace_session_id = os.getenv(
+        "LEAPFLOW_ENVIRONMENT_LEAPSPACE_SESSION_ID", ""
+    ).strip()
+    environment_leapspace_poll_interval_s = float(
+        os.getenv("LEAPFLOW_ENVIRONMENT_LEAPSPACE_POLL_INTERVAL_S", "0.5")
+    )
     selection_policy = os.getenv("LEAPFLOW_SELECTION_POLICY", "greedy").strip() or "greedy"
     replay_on_session_end = _bool("LEAPFLOW_REPLAY_ON_SESSION_END", "true")
     distilled_knowledge_ttl_s = float(
@@ -1084,6 +1136,18 @@ def _build_settings_from_env(
     agent_calibration_enabled = os.getenv("LEAPFLOW_AGENT_CALIBRATION_ENABLED", "0").strip().lower() in ("1", "true", "yes")
     agent_calibration_min_confidence = float(os.getenv("LEAPFLOW_AGENT_CALIBRATION_MIN_CONFIDENCE", "0.3"))
     agent_calibration_interval_turns = int(os.getenv("LEAPFLOW_AGENT_CALIBRATION_INTERVAL_TURNS", "0"))
+    agent_calibration_difficulty_min_k = float(
+        os.getenv("LEAPFLOW_AGENT_CALIBRATION_DIFFICULTY_MIN_K", "0.25")
+    )
+    agent_calibration_difficulty_max_k = float(
+        os.getenv("LEAPFLOW_AGENT_CALIBRATION_DIFFICULTY_MAX_K", "3.0")
+    )
+    agent_calibration_finalizing_min_ratio = float(
+        os.getenv("LEAPFLOW_AGENT_CALIBRATION_FINALIZING_MIN_RATIO", "0.6")
+    )
+    agent_calibration_finalizing_max_ratio = float(
+        os.getenv("LEAPFLOW_AGENT_CALIBRATION_FINALIZING_MAX_RATIO", "0.98")
+    )
     agent_compression_writeback = os.getenv("LEAPFLOW_AGENT_COMPRESSION_WRITEBACK", "0").strip().lower() in ("1", "true", "yes")
     agent_reentry_enabled = os.getenv("LEAPFLOW_AGENT_REENTRY_ENABLED", "0").strip().lower() in ("1", "true", "yes")
     agent_reentry_tick_seconds = float(os.getenv("LEAPFLOW_AGENT_REENTRY_TICK_SECONDS", "30"))
@@ -1107,6 +1171,18 @@ def _build_settings_from_env(
     tools_lint_command = os.getenv("LEAPFLOW_TOOLS_LINT_COMMAND", "").strip()
     tools_terminal_session_enabled = os.getenv("LEAPFLOW_TOOLS_TERMINAL_SESSION_ENABLED", "1").strip().lower() in ("1", "true", "yes")
     tools_verify_edits = os.getenv("LEAPFLOW_TOOLS_VERIFY_EDITS", "1").strip().lower() in ("1", "true", "yes")
+    plugin_sandbox_invoke_timeout_s = float(
+        os.getenv("LEAPFLOW_PLUGIN_SANDBOX_INVOKE_TIMEOUT_S", "15")
+    )
+    plugin_sandbox_shutdown_timeout_s = float(
+        os.getenv("LEAPFLOW_PLUGIN_SANDBOX_SHUTDOWN_TIMEOUT_S", "3")
+    )
+    plugin_sandbox_cpu_time_s = int(
+        os.getenv("LEAPFLOW_PLUGIN_SANDBOX_CPU_TIME_S", "30")
+    )
+    plugin_sandbox_max_memory_mb = int(
+        os.getenv("LEAPFLOW_PLUGIN_SANDBOX_MAX_MEMORY_MB", "0")
+    )
     plugins_dsh_invoke_timeout_s = float(os.getenv("LEAPFLOW_PLUGINS_DSH_INVOKE_TIMEOUT_S", "30"))
     plugins_dsh_discovery_timeout_s = float(os.getenv("LEAPFLOW_PLUGINS_DSH_DISCOVERY_TIMEOUT_S", "10"))
     plugins_dsh_max_message_bytes = int(os.getenv("LEAPFLOW_PLUGINS_DSH_MAX_MESSAGE_BYTES", "1000000"))
@@ -1409,6 +1485,17 @@ def _tuple_env(key: str, default: tuple) -> tuple:
         evolution_enabled=evolution_enabled,
         accepted_evidence_kinds=accepted_evidence_kinds,
         evolution_authorising_origins=evolution_authorising_origins,
+        evolution_teacher_poll_interval_s=evolution_teacher_poll_interval_s,
+        evolution_teacher_lease_s=evolution_teacher_lease_s,
+        evolution_teacher_timeout_s=evolution_teacher_timeout_s,
+        evolution_teacher_max_attempts=evolution_teacher_max_attempts,
+        evolution_teacher_retry_backoff_s=evolution_teacher_retry_backoff_s,
+        evolution_autonomy_level=evolution_autonomy_level,
+        environment_mode=environment_mode,
+        environment_leapspace_enabled=environment_leapspace_enabled,
+        environment_leapspace_state_root=environment_leapspace_state_root,
+        environment_leapspace_session_id=environment_leapspace_session_id,
+        environment_leapspace_poll_interval_s=environment_leapspace_poll_interval_s,
         selection_policy=selection_policy,
         replay_on_session_end=replay_on_session_end,
         distilled_knowledge_ttl_s=distilled_knowledge_ttl_s,
@@ -1498,6 +1585,10 @@ def _tuple_env(key: str, default: tuple) -> tuple:
         agent_calibration_enabled=agent_calibration_enabled,
         agent_calibration_min_confidence=agent_calibration_min_confidence,
         agent_calibration_interval_turns=agent_calibration_interval_turns,
+        agent_calibration_difficulty_min_k=agent_calibration_difficulty_min_k,
+        agent_calibration_difficulty_max_k=agent_calibration_difficulty_max_k,
+        agent_calibration_finalizing_min_ratio=agent_calibration_finalizing_min_ratio,
+        agent_calibration_finalizing_max_ratio=agent_calibration_finalizing_max_ratio,
         agent_compression_writeback=agent_compression_writeback,
         agent_reentry_enabled=agent_reentry_enabled,
         agent_reentry_tick_seconds=agent_reentry_tick_seconds,
@@ -1520,6 +1611,10 @@ def _tuple_env(key: str, default: tuple) -> tuple:
         tools_lint_command=tools_lint_command,
         tools_terminal_session_enabled=tools_terminal_session_enabled,
         tools_verify_edits=tools_verify_edits,
+        plugin_sandbox_invoke_timeout_s=plugin_sandbox_invoke_timeout_s,
+        plugin_sandbox_shutdown_timeout_s=plugin_sandbox_shutdown_timeout_s,
+        plugin_sandbox_cpu_time_s=plugin_sandbox_cpu_time_s,
+        plugin_sandbox_max_memory_mb=plugin_sandbox_max_memory_mb,
         plugins_dsh_invoke_timeout_s=plugins_dsh_invoke_timeout_s,
         plugins_dsh_discovery_timeout_s=plugins_dsh_discovery_timeout_s,
         plugins_dsh_max_message_bytes=plugins_dsh_max_message_bytes,
diff --git a/src/leapflow/config_service.py b/src/leapflow/config_service.py
index 8605590d..d7c2d296 100644
--- a/src/leapflow/config_service.py
+++ b/src/leapflow/config_service.py
@@ -300,6 +300,10 @@ class ConfigSnapshot:
     "agent.calibration_enabled": "Enable S3-L3 online difficulty calibration: apply the offline S3-L2 report's bounded suggested weight scale to the difficulty->budget sensitivity (scale_k), derived from the baseline and clamped/reversible (default off).",
     "agent.calibration_min_confidence": "Minimum calibration-report confidence required before an online difficulty-weight adjustment is applied (guards against acting on thin data).",
     "agent.calibration_interval_turns": "Re-run online difficulty/threshold calibration every N root turns as outcome data accumulates (0 = one-shot at startup only; requires calibration enabled).",
+    "agent.calibration_difficulty_min_k": "Operator floor for calibrated difficulty scaling, clamped by the built-in safety envelope.",
+    "agent.calibration_difficulty_max_k": "Operator ceiling for calibrated difficulty scaling, clamped by the built-in safety envelope.",
+    "agent.calibration_finalizing_min_ratio": "Operator floor for calibrated finalization ratio, never below the safety minimum.",
+    "agent.calibration_finalizing_max_ratio": "Operator ceiling for calibrated finalization ratio, never above the safety maximum.",
     "agent.compression_writeback": "Persist structural context compression back into the loop's message history so append-only frozen segments stay byte-stable across rounds (continuous prefix-cache reuse). Opt-in; the recent raw tail is preserved (default off).",
     "agent.reentry_enabled": "Enable event-driven re-entry: allow tasks to register a resume trigger (schedule_reentry) that seeds a future run from the saved orientation (default off).",
     "agent.reentry_tick_seconds": "How often (seconds) the daemon dispatches due re-entry triggers as isolated subagents (only when reentry is enabled).",
@@ -323,6 +327,10 @@ class ConfigSnapshot:
     "signal.noise_path_fragments": "Path fragments treated as monitor/display noise for fs.change events, e.g. OS caches and tool state directories.",
     "signal.noise_dir_names": "Directory names treated as monitor/display noise for fs.change events.",
     "signal.noise_suffixes": "Filename suffixes treated as transient fs.change noise, e.g. WAL/SHM/journal/temp/log files.",
+    "plugins.sandbox_invoke_timeout_s": "Maximum seconds for one Python sandbox RPC; requires daemon restart.",
+    "plugins.sandbox_shutdown_timeout_s": "Maximum graceful shutdown wait for a Python sandbox worker; requires daemon restart.",
+    "plugins.sandbox_cpu_time_s": "CPU-time ceiling in seconds for each Python sandbox worker; zero disables it.",
+    "plugins.sandbox_max_memory_mb": "Address-space ceiling in megabytes for each Python sandbox worker; zero disables it.",
     "plugins.dsh_invoke_timeout_s": "Maximum seconds for one restricted DSH tool invocation; requires daemon restart.",
     "plugins.dsh_discovery_timeout_s": "Maximum seconds for restricted DSH runtime discovery; requires daemon restart.",
     "plugins.dsh_max_message_bytes": "Maximum bytes in one DSH worker NDJSON protocol message; requires daemon restart.",
@@ -346,6 +354,17 @@ class ConfigSnapshot:
         "approval, sandboxing and trust all still apply, and every plugin change asks for "
         "your approval individually."
     ),
+    "evolution.teacher_poll_interval_s": "Seconds between durable teacher queue polls.",
+    "evolution.teacher_lease_s": "Lease duration for one claimed hindsight teacher job.",
+    "evolution.teacher_timeout_s": "Maximum seconds for one hindsight teacher call.",
+    "evolution.teacher_max_attempts": "Maximum attempts before a teacher job fails permanently.",
+    "evolution.teacher_retry_backoff_s": "Base retry delay for failed teacher jobs.",
+    "evolution.autonomy_level": "Maximum automatic proposal action; approvals remain mandatory.",
+    "environment.mode": "Environment-source mode: production or experiment.",
+    "environment.leapspace_enabled": "Enable the LeapSpace filesystem source in experiment mode.",
+    "environment.leapspace_state_root": "Host-visible LeapSpace state directory.",
+    "environment.leapspace_session_id": "Session receiving LeapSpace environment evidence.",
+    "environment.leapspace_poll_interval_s": "Seconds between LeapSpace state scans.",
 }
 
 _SECTION_CATEGORIES = {
diff --git a/src/leapflow/daemon/_service_helpers.py b/src/leapflow/daemon/_service_helpers.py
index 178a5309..a03d80bb 100644
--- a/src/leapflow/daemon/_service_helpers.py
+++ b/src/leapflow/daemon/_service_helpers.py
@@ -218,3 +218,7 @@ async def should_refresh(self, messages: list[dict[str, Any]]) -> bool:
         return await self._service._session_coordinator.should_refresh(
             self._service._ctx, messages
         )
+
+    async def evolution_projection_aggregate(self) -> dict[str, Any]:
+        """Expose only the explicitly aggregate event projection to producers."""
+        return await self._service.evolution_projection_aggregate()
diff --git a/src/leapflow/daemon/approval_coordinator.py b/src/leapflow/daemon/approval_coordinator.py
index 6e82eb4b..2d032e85 100644
--- a/src/leapflow/daemon/approval_coordinator.py
+++ b/src/leapflow/daemon/approval_coordinator.py
@@ -101,7 +101,35 @@ def install_gate(self, ctx: Any, service: Any) -> None:
             # a marketplace client from settings. Both are injected via the same
             # bind_runtime path; self_management declares them as dependencies.
             plugin_install_dir = self._resolve_plugin_install_dir(settings)
+            profile_layout = getattr(settings, "profile_layout", None)
+            plugin_staging_dir = (
+                str(profile_layout.plugin_staging_dir) if profile_layout is not None else None
+            )
             marketplace_client = self._build_marketplace_client(settings, plugin_install_dir)
+            proposal_orchestrator = None
+            try:
+                from leapflow.plugins.adaptive_policy import AdaptiveEvolutionPolicy
+                from leapflow.plugins.proposal_orchestrator import ProposalOrchestrator
+                artifact_store = getattr(ctx, "_evolution_artifact_store", None)
+                proposal_queue = getattr(ctx, "_capability_proposal_queue", None)
+                if (
+                    profile_layout is not None
+                    and artifact_store is not None
+                    and proposal_queue is not None
+                ):
+                    proposal_orchestrator = ProposalOrchestrator(
+                        queue=proposal_queue,
+                        artifact_store=artifact_store,
+                        approval_gate=orchestrator,
+                        policy=AdaptiveEvolutionPolicy(
+                            autonomy_level=str(
+                                getattr(settings, "evolution_autonomy_level", "generate_only")
+                            )
+                        ),
+                    )
+                    ctx._proposal_orchestrator = proposal_orchestrator
+            except (ImportError, OSError, RuntimeError, TypeError, ValueError):
+                logger.warning("ProposalOrchestrator setup failed", exc_info=True)
             _tool_registry.bind_runtime(
                 plugin_approval_gate=orchestrator,
                 hardware_approval_gate=orchestrator,
@@ -110,10 +138,17 @@ def install_gate(self, ctx: Any, service: Any) -> None:
                     getattr(settings, "plugin_generation_enabled", False)
                 ),
                 plugin_install_dir=plugin_install_dir,
+                plugin_staging_dir=plugin_staging_dir,
                 marketplace_client=marketplace_client,
                 marketplace_trusted_pubkeys=tuple(
                     getattr(settings, "plugin_marketplace_trusted_pubkeys", ()) or ()
                 ),
+                proposal_orchestrator=proposal_orchestrator,
+                capability_lifecycle_store=getattr(
+                    ctx, "_capability_proposal_queue", None
+                ),
+                evolution_outbox=getattr(ctx, "_evolution_outbox", None),
+                evolution_profile_id=str(getattr(settings, "profile", "default")),
             )
 
             class _FileReadGate:
diff --git a/src/leapflow/daemon/client.py b/src/leapflow/daemon/client.py
index bfebee0a..4c14bf38 100644
--- a/src/leapflow/daemon/client.py
+++ b/src/leapflow/daemon/client.py
@@ -522,9 +522,56 @@ async def session_analyze(self) -> dict[str, Any]:
         """Ensure a session-analysis watch and run one analysis cycle now."""
         return dict(await self.request("session.analyze") or {})
 
-    async def evolution_run(self, reason: str = "manual") -> dict[str, Any]:
-        """Run the learning boundary in the daemon now."""
-        return dict(await self.request("evolution.run", {"reason": reason}) or {})
+    async def evolution_run(
+        self,
+        *,
+        session_id: str,
+        reason: str = "manual",
+        wait: bool = False,
+        timeout_s: float = 180.0,
+    ) -> dict[str, Any]:
+        """Finalize one named session and optionally await its teacher job."""
+        return dict(
+            await self.request(
+                "evolution.run",
+                {
+                    "session_id": session_id,
+                    "reason": reason,
+                    "wait": wait,
+                    "timeout_s": timeout_s,
+                },
+            )
+            or {}
+        )
+
+    async def evolution_projection(
+        self,
+        *,
+        session_id: str,
+        rebuild: bool = False,
+    ) -> dict[str, Any]:
+        """Return the event projection for one explicitly named session."""
+        return dict(
+            await self.request(
+                "evolution.projection",
+                {"session_id": session_id, "rebuild": rebuild},
+            )
+            or {}
+        )
+
+    async def evolution_projection_aggregate(
+        self,
+        *,
+        rebuild: bool = False,
+    ) -> dict[str, Any]:
+        """Return the explicitly cross-session profile projection."""
+        return dict(
+            await self.request(
+                "evolution.projection.aggregate",
+                {"rebuild": rebuild},
+            )
+            or {}
+        )
 
     async def signal_record(self, event_type: str, payload: dict[str, Any]) -> dict[str, Any]:
         """Inject a signal event into the daemon's EventBus."""
diff --git a/src/leapflow/daemon/monitor_coordinator.py b/src/leapflow/daemon/monitor_coordinator.py
index c48b9c76..4f32754c 100644
--- a/src/leapflow/daemon/monitor_coordinator.py
+++ b/src/leapflow/daemon/monitor_coordinator.py
@@ -139,21 +139,24 @@ def _install_evolution_sink(self, ctx: Any, settings: Any) -> None:
         """
         try:
             from leapflow.evolution import LedgerEvolutionSink
-            from leapflow.storage.evolution_trace_store import JsonEvolutionTraceStore
+            from leapflow.storage.evolution_event_store import EvolutionTraceEventStore
             from leapflow.telemetry.evolution_tap import install_sink
 
-            layout = getattr(settings, "profile_layout", None)
-            path = getattr(layout, "evolution_traces_path", None)
-            if path is None:
+            event_store = getattr(ctx, "_evolution_event_store", None)
+            if event_store is None:
                 return
+            trace_store = EvolutionTraceEventStore(
+                event_store,
+                profile_id=str(getattr(settings, "profile", "default")),
+            )
             sink = LedgerEvolutionSink(
-                store=JsonEvolutionTraceStore(path),
+                store=trace_store,
                 publish=self._make_evolution_publisher(ctx),
             )
             sink.register_atexit()
             install_sink(sink)
             self._evolution_sink = sink
-            logger.debug("daemon: evolution trace sink installed at %s", path)
+            logger.debug("daemon: evolution trace sink installed in evolution_events")
         except Exception:  # noqa: BLE001 - observability is never a startup dependency
             logger.debug("daemon: evolution trace sink not installed", exc_info=True)
 
diff --git a/src/leapflow/daemon/protocol.py b/src/leapflow/daemon/protocol.py
index c2f0ea84..9af21726 100644
--- a/src/leapflow/daemon/protocol.py
+++ b/src/leapflow/daemon/protocol.py
@@ -248,13 +248,32 @@ async def session_analyze(self) -> Dict[str, Any]:
         """Ensure a session-analysis watch and run one analysis cycle now."""
         ...
 
-    async def evolution_run(self, reason: str = "manual") -> Dict[str, Any]:
-        """Run the learning boundary now, the one path that drives evolution.
+    async def evolution_run(
+        self,
+        *,
+        session_id: str,
+        reason: str = "manual",
+        wait: bool = False,
+        timeout_s: float = 180.0,
+    ) -> Dict[str, Any]:
+        """Finalize one explicitly named session and enqueue durable teacher work."""
+        ...
 
-        Exposed because the boundary was otherwise reachable only from context
-        cleanup -- process shutdown in daemon mode -- which made "when does the
-        framework evolve" unanswerable and untestable without killing the daemon.
-        """
+    async def evolution_projection(
+        self,
+        *,
+        session_id: str,
+        rebuild: bool = False,
+    ) -> Dict[str, Any]:
+        """Return the event projection for one explicitly named session."""
+        ...
+
+    async def evolution_projection_aggregate(
+        self,
+        *,
+        rebuild: bool = False,
+    ) -> Dict[str, Any]:
+        """Return the explicitly cross-session profile projection."""
         ...
 
     async def status(self, session_id: str = "") -> Dict[str, Any]:
@@ -490,6 +509,8 @@ async def gateway_send(
     "session.detail": "session_detail",
     "session.analyze": "session_analyze",
     "evolution.run": "evolution_run",
+    "evolution.projection": "evolution_projection",
+    "evolution.projection.aggregate": "evolution_projection_aggregate",
     "daemon.status": "status",
     "daemon.shutdown": "shutdown",
     "host.status": "host_status",
diff --git a/src/leapflow/daemon/service.py b/src/leapflow/daemon/service.py
index 718e9371..720435ff 100644
--- a/src/leapflow/daemon/service.py
+++ b/src/leapflow/daemon/service.py
@@ -451,6 +451,7 @@ def __init__(self, settings: Any, *, mock_host: bool = False, auto_start_deferre
         self._active_engine_request_id: str = ""
         self._active_engines: dict[str, Any] = {}
         self._observation: Any | None = None
+        self._environment_source_manager: Any | None = None
         self._engine_request_ledger: dict[str, dict[str, Any]] = {}
         self._request_ledger_ttl_s = max(1.0, float(getattr(settings, "daemon_request_ledger_ttl_s", 600.0) or 600.0))
         self._request_ledger_max_entries = max(1, int(getattr(settings, "daemon_request_ledger_max_entries", 128) or 128))
@@ -477,6 +478,7 @@ async def start(self) -> None:
         self._approval_coordinator.install_gate(ctx, self)
         install_learn_notifications(ctx, self.notification_bus)
         self._ctx = ctx
+        await self._start_environment_sources(ctx)
         if self._auto_start_deferred:
             self.start_deferred_init()
         # Monitor: start only when scheduler is enabled (coordinator checks internally)
@@ -504,6 +506,38 @@ async def start(self) -> None:
                     logger.debug("daemon: observation subsystem start failed", exc_info=True)
                     self._observation = None
 
+    async def _start_environment_sources(self, ctx: Any) -> None:
+        """Start explicitly enabled experiment sources inside the daemon lifecycle."""
+        settings = getattr(ctx, "settings", self._settings)
+        if str(getattr(settings, "environment_mode", "production")) != "experiment":
+            return
+        if not bool(getattr(settings, "environment_leapspace_enabled", False)):
+            return
+        state_root = str(getattr(settings, "environment_leapspace_state_root", "") or "")
+        session_id = str(getattr(settings, "environment_leapspace_session_id", "") or "")
+        if not state_root or not session_id:
+            logger.warning(
+                "LeapSpace environment source requires both state_root and session_id"
+            )
+            return
+        from leapflow.layout import workspace_id_for_path
+        from leapflow.perception.environment_source import EnvironmentSourceManager
+        from leapflow.perception.leapspace_source import LeapSpaceEnvironmentSource
+
+        manager = EnvironmentSourceManager(ctx.record_environment_observation)
+        manager.register(
+            LeapSpaceEnvironmentSource(
+                state_root,
+                workspace_id=workspace_id_for_path(self._workspace_root()),
+                session_id=session_id,
+                poll_interval_s=float(
+                    getattr(settings, "environment_leapspace_poll_interval_s", 0.5)
+                ),
+            )
+        )
+        await manager.start()
+        self._environment_source_manager = manager
+
     def start_deferred_init(self) -> None:
         """Start background non-critical initialization once."""
         if self._ctx is None:
@@ -517,6 +551,10 @@ async def shutdown(self) -> None:
             return
         ctx = self._ctx
         self._ctx = None
+        environment_sources = self._environment_source_manager
+        self._environment_source_manager = None
+        if environment_sources is not None:
+            await environment_sources.close()
         # Stop background deferred init first: its yield points allow cleanup
         # to interleave with a half-initialized context otherwise.
         task = self._deferred_init_task
@@ -936,22 +974,81 @@ async def session_detail(
     async def session_analyze(self) -> dict[str, Any]:
         return await self._session_coordinator.analyze(self._monitors, self._ctx, self._settings)
 
-    async def evolution_run(self, reason: str = "manual") -> dict[str, Any]:
-        """Drive the learning boundary in the daemon's context, now.
-
-        The daemon owns the context that holds the trajectory buffer, the world-model
-        teacher and the proposal queue, so this has to run here rather than in the
-        calling CLI process -- a second context would grade an empty buffer and
-        report success having done nothing.
-        """
+    async def evolution_run(
+        self,
+        *,
+        session_id: str,
+        reason: str = "manual",
+        wait: bool = False,
+        timeout_s: float = 180.0,
+    ) -> dict[str, Any]:
+        """Finalize one explicitly named session in the daemon-owned event stream."""
         ctx = self._ctx
         if ctx is None:
             return {"ok": False, "error": "daemon context unavailable"}
+        normalized_session_id = str(session_id or "").strip()
+        if not normalized_session_id:
+            return {"ok": False, "error": "session_id is required"}
+        session_registry = self._session_coordinator.registry
+        session_context = (
+            session_registry.get(normalized_session_id)
+            if session_registry is not None
+            else None
+        )
+        workspace_root = (
+            str(session_context.workspace_root) if session_context is not None else ""
+        )
+        if wait:
+            try:
+                await asyncio.wait_for(
+                    ctx._ensure_deferred(),
+                    timeout=self._DEFERRED_WAIT_TIMEOUT_S,
+                )
+            except asyncio.TimeoutError:
+                logger.info("Deferred init still running; teacher job will remain queued")
         try:
-            return await ctx.run_learning_boundary(reason=str(reason or "manual"))
+            return await ctx.run_learning_boundary(
+                reason=str(reason or "manual"),
+                session_id=normalized_session_id,
+                workspace_root=workspace_root,
+                wait=bool(wait),
+                timeout_s=min(max(0.1, float(timeout_s)), 600.0),
+            )
         except Exception as exc:  # noqa: BLE001 - reported to the caller, never fatal
             logger.warning("daemon: learning boundary failed: %s", exc, exc_info=True)
-            return {"ok": False, "error": str(exc), "reason": str(reason or "manual")}
+            return {
+                "ok": False,
+                "error": str(exc),
+                "reason": str(reason or "manual"),
+                "session_id": normalized_session_id,
+            }
+
+    async def evolution_projection(
+        self,
+        *,
+        session_id: str,
+        rebuild: bool = False,
+    ) -> dict[str, Any]:
+        ctx = self._ctx
+        if ctx is None:
+            return {"ok": False, "error": "daemon context unavailable"}
+        normalized_session_id = str(session_id or "").strip()
+        if not normalized_session_id:
+            return {"ok": False, "error": "session_id is required"}
+        return await ctx.evolution_projection(
+            session_id=normalized_session_id,
+            rebuild=bool(rebuild),
+        )
+
+    async def evolution_projection_aggregate(
+        self,
+        *,
+        rebuild: bool = False,
+    ) -> dict[str, Any]:
+        ctx = self._ctx
+        if ctx is None:
+            return {"ok": False, "error": "daemon context unavailable"}
+        return await ctx.evolution_projection(aggregate=True, rebuild=bool(rebuild))
 
     def _ensure_session_registry(self, base_engine: Any) -> Any:
         return self._session_coordinator.ensure_registry(base_engine, self._settings)
@@ -1412,7 +1509,7 @@ async def hardware_write_request(
 
         from leapflow.plugins import get_registry as _get_tool_registry
 
-        handler = dict(_get_tool_registry().tool_handlers).get(tool_name)
+        handler = _get_tool_registry().snapshot_handlers().get(tool_name)
         if handler is None:
             return {
                 "ok": False, "code": "tool_unavailable", "device": device, "channel": channel,
@@ -1610,6 +1707,15 @@ async def status(self, session_id: str = "") -> dict[str, Any]:
             "deferred_init": self._deferred_init_status(ctx),
             "watch_summary": await self._monitor_coordinator.get_summary(),
             "host_backend": host,
+            "environment_sources": {
+                "active": list(self._environment_source_manager.source_ids)
+                if self._environment_source_manager is not None
+                else [],
+                "dropped": self._environment_source_manager.dropped_count
+                if self._environment_source_manager is not None
+                else 0,
+            },
+            "evolution_performance": self._evolution_performance_status(ctx),
             # Whether *this* daemon process still matches the source tree on
             # disk (None when outside a git checkout, e.g. a packaged install).
             "build": {**self._build_info.to_dict(), "stale": build_stale},
@@ -1622,6 +1728,27 @@ def _workspace_root(self) -> Path:
         settings = getattr(ctx, "settings", self._settings) if ctx is not None else self._settings
         return Path(str(getattr(settings, "workspace_root", os.getcwd()))).expanduser().resolve()
 
+    @staticmethod
+    def _evolution_performance_status(ctx: Any) -> dict[str, Any]:
+        """Expose bounded p50/p95/p99 snapshots without adding hot-path I/O."""
+        from dataclasses import asdict, is_dataclass
+
+        from leapflow.plugins import get_registry
+
+        result: dict[str, Any] = {}
+        components = {
+            "action_recorder": getattr(ctx, "_action_recorder", None),
+            "outbox": getattr(ctx, "_evolution_outbox", None),
+            "projection": getattr(ctx, "_evolution_projection_runner", None),
+            "teacher": getattr(ctx, "_teacher_worker", None),
+        }
+        for name, component in components.items():
+            metrics = getattr(component, "metrics", None)
+            if metrics is not None:
+                result[name] = asdict(metrics) if is_dataclass(metrics) else metrics
+        result["registry_snapshot"] = get_registry().snapshot_latency.to_dict()
+        return result
+
     def _turn_admission_status(self, *, queued_delta: int = 0) -> dict[str, Any]:
         snapshot = dict(self._turn_admission.snapshot())
         if queued_delta:
diff --git a/src/leapflow/dashboard/intent.py b/src/leapflow/dashboard/intent.py
index 43e9c0ef..65b3af7f 100644
--- a/src/leapflow/dashboard/intent.py
+++ b/src/leapflow/dashboard/intent.py
@@ -2,8 +2,8 @@
 """DashboardIntent: the single normalized request behind ``/board`` and the tool.
 
 The **template** is the primary view dimension (a rendering lens). Most templates
-analyze the current session and need nothing else; a per-device view needs to know
-*which* device, so the intent also carries an optional target.
+analyze the current session and need nothing else; device and evolution views carry
+an explicit target so they never infer another client's state.
 
 ``device``/``channel`` are explicit fields rather than a generic params bag. The
 board's request surface is small and worth keeping legible, and a typed field is what
@@ -24,11 +24,12 @@
 
 @dataclass(frozen=True)
 class DashboardIntent:
-    """A normalized dashboard request: which lens, and optionally which target."""
+    """A normalized dashboard request with explicit device or session scope."""
 
     template: str = ""
     device: str = ""
     channel: str = ""
+    session_id: str = ""
 
     def to_dict(self) -> dict[str, Any]:
         """Return the wire form, omitting an absent target.
@@ -42,6 +43,8 @@ def to_dict(self) -> dict[str, Any]:
             payload["device"] = self.device
         if self.channel:
             payload["channel"] = self.channel
+        if self.session_id:
+            payload["session_id"] = self.session_id
         return payload
 
     @classmethod
@@ -52,6 +55,7 @@ def from_params(cls, data: Mapping[str, Any]) -> "DashboardIntent":
             template=str(data.get("template", "") or "").strip(),
             device=str(data.get("device", "") or "").strip(),
             channel=str(data.get("channel", "") or "").strip(),
+            session_id=str(data.get("session_id", data.get("session", "")) or "").strip(),
         )
 
     @classmethod
@@ -67,10 +71,13 @@ def from_args(cls, args: str) -> "DashboardIntent":
         except ValueError:
             tokens = tuple((args or "").split())
         parts = [token.strip() for token in tokens if token.strip()]
+        template = parts[0] if parts else ""
+        is_evolution = template in {"evolution", "evolution_live", "causal_trace"}
         return cls(
-            template=parts[0] if parts else "",
-            device=parts[1] if len(parts) > 1 else "",
-            channel=parts[2] if len(parts) > 2 else "",
+            template=template,
+            device=parts[1] if len(parts) > 1 and not is_evolution else "",
+            channel=parts[2] if len(parts) > 2 and not is_evolution else "",
+            session_id=parts[1] if len(parts) > 1 and is_evolution else "",
         )
 
 
diff --git a/src/leapflow/dashboard/server.py b/src/leapflow/dashboard/server.py
index b5d183f4..29cc2790 100644
--- a/src/leapflow/dashboard/server.py
+++ b/src/leapflow/dashboard/server.py
@@ -273,6 +273,7 @@ async def _handle_view(self, request: Any) -> Any:
             "template": request.query.get("template", ""),
             "device": request.query.get("device", ""),
             "channel": request.query.get("channel", ""),
+            "session_id": request.query.get("session_id", request.query.get("session", "")),
         })
         request_id = uuid.uuid4().hex
         try:
diff --git a/src/leapflow/dashboard/service.py b/src/leapflow/dashboard/service.py
index c0e20000..0d94f5d9 100644
--- a/src/leapflow/dashboard/service.py
+++ b/src/leapflow/dashboard/service.py
@@ -36,6 +36,14 @@ async def signal_metrics(self) -> dict[str, Any]:
         """Return signal flow health metrics."""
         ...
 
+    async def evolution_projection(self, *, session_id: str) -> dict[str, Any]:
+        """Return one session-scoped evolution projection."""
+        ...
+
+    async def evolution_projection_aggregate(self) -> dict[str, Any]:
+        """Return the explicitly cross-session evolution projection."""
+        ...
+
     async def hardware_inventory(self) -> dict[str, Any]:
         """Return the admitted device fleet grouped by declared class."""
         ...
@@ -67,6 +75,12 @@ async def signal_metrics(self) -> dict[str, Any]:
             }
         return {"metrics": {}, "signal_stream": []}
 
+    async def evolution_projection(self, *, session_id: str) -> dict[str, Any]:
+        return dict(await self._client.evolution_projection(session_id=session_id) or {})
+
+    async def evolution_projection_aggregate(self) -> dict[str, Any]:
+        return dict(await self._client.evolution_projection_aggregate() or {})
+
     async def hardware_inventory(self) -> dict[str, Any]:
         """Return the device fleet, tolerating a daemon without the RPC.
 
@@ -518,7 +532,12 @@ async def build(self, intent: DashboardIntent, provider: DashboardDataProvider)
             return await self._build_device(template_name, intent, provider)
         payload_domain = _PAYLOAD_DOMAINS.get(template_name)
         if payload_domain is not None:
-            return await self._build_from_finding_payload(template_name, provider, *payload_domain)
+            return await self._build_from_finding_payload(
+                template_name,
+                provider,
+                *payload_domain,
+                session_id=intent.session_id,
+            )
         return await self._build_session(intent.template, provider)
 
     async def _build_device(
@@ -641,6 +660,8 @@ async def _build_from_finding_payload(
         provider: DashboardDataProvider,
         finding_domain: str,
         data_key: str,
+        *,
+        session_id: str = "",
     ) -> dict[str, Any]:
         """Render a template from the newest finding of one producer domain.
 
@@ -650,6 +671,16 @@ async def _build_from_finding_payload(
         """
         watch, domain_findings = await self._domain_watch_payload(provider, finding_domain)
         payload = dict(domain_findings[0].get("payload") or {}) if domain_findings else {}
+        event_projection: dict[str, Any] = {}
+        if finding_domain == "framework_evolution":
+            event_projection = await self._event_projection(provider, session_id=session_id)
+            if event_projection:
+                previous_summary = dict(payload.get("summary") or {})
+                payload.update(event_projection)
+                payload["summary"] = {
+                    **previous_summary,
+                    **dict(event_projection.get("summary") or {}),
+                }
         data = {
             "title": template.replace("_", " ").title(),
             data_key: payload,
@@ -690,7 +721,34 @@ async def _build_from_finding_payload(
             notice = _hardware_notice(inventory, payload)
             if notice is not None:
                 data["notice"] = notice
-        return self._render(template, data)
+        rendered = self._render(template, data)
+        if event_projection:
+            rendered.setdefault("meta", {})["evolution_projection"] = {
+                "scope": event_projection.get("scope", "aggregate"),
+                "session_id": event_projection.get("session_id", ""),
+                "last_sequence": event_projection.get("last_sequence", 0),
+            }
+        return rendered
+
+    @staticmethod
+    async def _event_projection(
+        provider: DashboardDataProvider,
+        *,
+        session_id: str,
+    ) -> dict[str, Any]:
+        """Read the canonical event projection, degrading for older daemons."""
+        try:
+            if session_id:
+                result = await provider.evolution_projection(session_id=session_id)
+            else:
+                result = await provider.evolution_projection_aggregate()
+        except (AttributeError, RuntimeError, TypeError):
+            logger.debug("dashboard: evolution projection unavailable", exc_info=True)
+            return {}
+        if not result.get("ok"):
+            return {}
+        projection = result.get("projection")
+        return dict(projection) if isinstance(projection, dict) else {}
 
     async def _build_session(self, template: str, provider: DashboardDataProvider) -> dict[str, Any]:
         # The session watch emits an insight finding whose payload carries the
diff --git a/src/leapflow/domain/__init__.py b/src/leapflow/domain/__init__.py
index 062d08e7..29f09618 100644
--- a/src/leapflow/domain/__init__.py
+++ b/src/leapflow/domain/__init__.py
@@ -9,6 +9,7 @@
 from leapflow.domain.effect_scope import EffectScope, ScopeState
 from leapflow.domain.event_types import (
     CLIEventType,
+    EvolutionEventType,
     ImplicitFeedbackType,
     LearningEventType,
     NormalizedEventType,
@@ -16,7 +17,18 @@
     UNDO_SHORTCUTS,
 )
 from leapflow.domain.environment_fingerprint import EnvironmentFingerprint
+from leapflow.domain.environment_signal import (
+    EnvironmentObservation,
+    InterfaceElement,
+    InterfaceSnapshot,
+)
 from leapflow.domain.events import SystemEvent, UIElement, UISnapshot
+from leapflow.domain.evolution_event import (
+    EvolutionContext,
+    EvolutionEvent,
+    EvolutionEventRecord,
+    EvolutionEventStore,
+)
 from leapflow.domain.evolution_intent import (
     WORLD_MODEL_INTENT,
     WORLD_MODEL_ORIGIN,
@@ -53,6 +65,11 @@
     "CLIEventType",
     "CapabilityRequirement",
     "EffectScope",
+    "EvolutionContext",
+    "EvolutionEvent",
+    "EvolutionEventRecord",
+    "EvolutionEventStore",
+    "EvolutionEventType",
     "EvolutionIntent",
     "FiberState",
     "GapEvidence",
@@ -65,6 +82,9 @@
     "DEFAULT_DARWIN_CAPABILITIES",
     "DistillationCandidate",
     "EnvironmentFingerprint",
+    "EnvironmentObservation",
+    "InterfaceElement",
+    "InterfaceSnapshot",
     "Episode",
     "IllegalStateTransition",
     "NoiseSignal",
diff --git a/src/leapflow/domain/adaptation_verdict.py b/src/leapflow/domain/adaptation_verdict.py
index 58f4aec3..52d86403 100644
--- a/src/leapflow/domain/adaptation_verdict.py
+++ b/src/leapflow/domain/adaptation_verdict.py
@@ -192,6 +192,8 @@ def to_dict(self) -> dict[str, Any]:
             "max_risk_level": str(self.max_risk_level),
             "expected_effect": self.expected_effect,
             "target_affordance": self.target_affordance,
+            "evidence_ids": list(self.evidence_ids),
+            "created_at": self.created_at,
         }
 
 
diff --git a/src/leapflow/domain/environment_signal.py b/src/leapflow/domain/environment_signal.py
new file mode 100644
index 00000000..9ab42c8d
--- /dev/null
+++ b/src/leapflow/domain/environment_signal.py
@@ -0,0 +1,322 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Typed task-environment snapshots and structural deltas."""
+from __future__ import annotations
+
+import time
+from dataclasses import asdict, dataclass
+from typing import Any, Literal, Mapping
+
+from leapflow.domain.evolution_event import content_hash
+
+EnvironmentObservationKind = Literal["snapshot", "delta", "outcome"]
+EnvironmentOutcome = Literal["PASS", "FAIL", "UNKNOWN"]
+
+
+@dataclass(frozen=True, order=True)
+class InterfaceElement:
+    """Stable, value-free description of one application affordance."""
+
+    name: str
+    role: str = "widget"
+    enabled: bool = True
+
+    @classmethod
+    def from_mapping(cls, value: Mapping[str, Any]) -> "InterfaceElement":
+        return cls(
+            name=str(value.get("name") or value.get("label") or ""),
+            role=str(value.get("role") or "widget"),
+            enabled=bool(value.get("enabled", True)),
+        )
+
+
+@dataclass(frozen=True)
+class InterfaceSnapshot:
+    """Immutable structural view of one task application."""
+
+    source_id: str
+    app_id: str
+    workspace_id: str = ""
+    session_id: str = ""
+    version: str = ""
+    affordances: tuple[str, ...] = ()
+    elements: tuple[InterfaceElement, ...] = ()
+    data_hash: str = ""
+    observed_at: float = 0.0
+    provenance: tuple[tuple[str, str], ...] = ()
+
+    @classmethod
+    def create(
+        cls,
+        *,
+        source_id: str,
+        app_id: str,
+        workspace_id: str = "",
+        session_id: str = "",
+        version: str = "",
+        affordances: Any = (),
+        elements: Any = (),
+        data: Any = None,
+        observed_at: float | None = None,
+        provenance: Mapping[str, Any] | None = None,
+    ) -> "InterfaceSnapshot":
+        normalized_elements = tuple(
+            sorted(
+                (
+                    item
+                    if isinstance(item, InterfaceElement)
+                    else InterfaceElement.from_mapping(item)
+                )
+                for item in (elements or ())
+                if isinstance(item, (InterfaceElement, Mapping))
+            )
+        )
+        return cls(
+            source_id=str(source_id),
+            app_id=str(app_id),
+            workspace_id=str(workspace_id),
+            session_id=str(session_id),
+            version=str(version or ""),
+            affordances=tuple(sorted({str(item) for item in (affordances or ()) if str(item)})),
+            elements=normalized_elements,
+            data_hash=content_hash(data or {}),
+            observed_at=time.time() if observed_at is None else float(observed_at),
+            provenance=tuple(
+                sorted((str(key), str(value)) for key, value in (provenance or {}).items())
+            ),
+        )
+
+    @property
+    def snapshot_id(self) -> str:
+        return "env-" + content_hash(
+            {
+                "source_id": self.source_id,
+                "app_id": self.app_id,
+                "workspace_id": self.workspace_id,
+                "session_id": self.session_id,
+                "version": self.version,
+                "affordances": self.affordances,
+                "elements": [asdict(item) for item in self.elements],
+                "provenance": self.provenance,
+            }
+        )[:32]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "snapshot_id": self.snapshot_id,
+            "source_id": self.source_id,
+            "app_id": self.app_id,
+            "workspace_id": self.workspace_id,
+            "session_id": self.session_id,
+            "version": self.version,
+            "affordances": list(self.affordances),
+            "elements": [asdict(item) for item in self.elements],
+            "data_hash": self.data_hash,
+            "observed_at": self.observed_at,
+            "provenance": dict(self.provenance),
+        }
+
+
+@dataclass(frozen=True)
+class EnvironmentObservation:
+    """A snapshot, structural delta, or ground-truth task outcome."""
+
+    observation_id: str
+    source_id: str
+    kind: EnvironmentObservationKind
+    app_id: str = ""
+    workspace_id: str = ""
+    session_id: str = ""
+    before_snapshot_id: str = ""
+    after_snapshot_id: str = ""
+    version_before: str = ""
+    version_after: str = ""
+    added_affordances: tuple[str, ...] = ()
+    removed_affordances: tuple[str, ...] = ()
+    added_elements: tuple[InterfaceElement, ...] = ()
+    removed_elements: tuple[InterfaceElement, ...] = ()
+    changed_elements: tuple[InterfaceElement, ...] = ()
+    outcome: EnvironmentOutcome = "UNKNOWN"
+    capability: str = ""
+    observed_at: float = 0.0
+    provenance: tuple[tuple[str, str], ...] = ()
+
+    @classmethod
+    def snapshot(cls, snapshot: InterfaceSnapshot) -> "EnvironmentObservation":
+        identity = {"kind": "snapshot", "snapshot_id": snapshot.snapshot_id}
+        return cls(
+            observation_id="obs-" + content_hash(identity)[:32],
+            source_id=snapshot.source_id,
+            kind="snapshot",
+            app_id=snapshot.app_id,
+            workspace_id=snapshot.workspace_id,
+            session_id=snapshot.session_id,
+            after_snapshot_id=snapshot.snapshot_id,
+            version_after=snapshot.version,
+            added_affordances=snapshot.affordances,
+            added_elements=snapshot.elements,
+            observed_at=snapshot.observed_at,
+            provenance=snapshot.provenance,
+        )
+
+    @classmethod
+    def between(
+        cls,
+        before: InterfaceSnapshot,
+        after: InterfaceSnapshot,
+    ) -> "EnvironmentObservation | None":
+        if before.source_id != after.source_id or before.app_id != after.app_id:
+            raise ValueError("environment snapshots must describe the same source and app")
+        before_elements = {(item.name, item.role): item for item in before.elements}
+        after_elements = {(item.name, item.role): item for item in after.elements}
+        added_keys = after_elements.keys() - before_elements.keys()
+        removed_keys = before_elements.keys() - after_elements.keys()
+        changed = tuple(
+            after_elements[key]
+            for key in sorted(before_elements.keys() & after_elements.keys())
+            if before_elements[key].enabled != after_elements[key].enabled
+        )
+        added_affordances = tuple(sorted(set(after.affordances) - set(before.affordances)))
+        removed_affordances = tuple(sorted(set(before.affordances) - set(after.affordances)))
+        added_elements = tuple(after_elements[key] for key in sorted(added_keys))
+        removed_elements = tuple(before_elements[key] for key in sorted(removed_keys))
+        if not any(
+            (
+                before.version != after.version,
+                added_affordances,
+                removed_affordances,
+                added_elements,
+                removed_elements,
+                changed,
+            )
+        ):
+            return None
+        identity = {
+            "kind": "delta",
+            "before": before.snapshot_id,
+            "after": after.snapshot_id,
+        }
+        return cls(
+            observation_id="obs-" + content_hash(identity)[:32],
+            source_id=after.source_id,
+            kind="delta",
+            app_id=after.app_id,
+            workspace_id=after.workspace_id,
+            session_id=after.session_id,
+            before_snapshot_id=before.snapshot_id,
+            after_snapshot_id=after.snapshot_id,
+            version_before=before.version,
+            version_after=after.version,
+            added_affordances=added_affordances,
+            removed_affordances=removed_affordances,
+            added_elements=added_elements,
+            removed_elements=removed_elements,
+            changed_elements=changed,
+            observed_at=after.observed_at,
+            provenance=after.provenance,
+        )
+
+    @classmethod
+    def task_outcome(
+        cls,
+        *,
+        source_id: str,
+        task_id: str,
+        outcome: str,
+        capability: str = "",
+        workspace_id: str = "",
+        session_id: str = "",
+        observed_at: float | None = None,
+        provenance: Mapping[str, Any] | None = None,
+    ) -> "EnvironmentObservation":
+        normalized = str(outcome or "UNKNOWN").upper()
+        if normalized not in {"PASS", "FAIL", "UNKNOWN"}:
+            normalized = "UNKNOWN"
+        identity = {
+            "kind": "outcome",
+            "source_id": source_id,
+            "task_id": task_id,
+            "outcome": normalized,
+            "capability": capability,
+            "provenance": dict(provenance or {}),
+        }
+        return cls(
+            observation_id="obs-" + content_hash(identity)[:32],
+            source_id=str(source_id),
+            kind="outcome",
+            app_id=str(task_id),
+            workspace_id=str(workspace_id),
+            session_id=str(session_id),
+            outcome=normalized,  # type: ignore[arg-type]
+            capability=str(capability),
+            observed_at=time.time() if observed_at is None else float(observed_at),
+            provenance=tuple(
+                sorted((str(key), str(value)) for key, value in (provenance or {}).items())
+            ),
+        )
+
+    @property
+    def is_structural(self) -> bool:
+        return bool(
+            self.version_before != self.version_after
+            or self.added_affordances
+            or self.removed_affordances
+            or self.added_elements
+            or self.removed_elements
+            or self.changed_elements
+        )
+
+    def capability_results(self) -> tuple[dict[str, Any], ...]:
+        """Return only explicitly named capability evidence; never infer from labels."""
+        results = [
+            {
+                "ok": False,
+                "error_type": "affordance_removed",
+                "capability": capability,
+                "observation_id": self.observation_id,
+                "app_id": self.app_id,
+            }
+            for capability in self.removed_affordances
+        ]
+        if self.kind == "outcome" and self.outcome == "FAIL" and self.capability:
+            results.append(
+                {
+                    "ok": False,
+                    "error_type": "task_outcome_failed",
+                    "capability": self.capability,
+                    "observation_id": self.observation_id,
+                    "task_id": self.app_id,
+                }
+            )
+        return tuple(results)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "observation_id": self.observation_id,
+            "source_id": self.source_id,
+            "kind": self.kind,
+            "app_id": self.app_id,
+            "workspace_id": self.workspace_id,
+            "session_id": self.session_id,
+            "before_snapshot_id": self.before_snapshot_id,
+            "after_snapshot_id": self.after_snapshot_id,
+            "version_before": self.version_before,
+            "version_after": self.version_after,
+            "added_affordances": list(self.added_affordances),
+            "removed_affordances": list(self.removed_affordances),
+            "added_elements": [asdict(item) for item in self.added_elements],
+            "removed_elements": [asdict(item) for item in self.removed_elements],
+            "changed_elements": [asdict(item) for item in self.changed_elements],
+            "outcome": self.outcome,
+            "capability": self.capability,
+            "observed_at": self.observed_at,
+            "provenance": dict(self.provenance),
+        }
+
+
+__all__ = [
+    "EnvironmentObservation",
+    "EnvironmentObservationKind",
+    "EnvironmentOutcome",
+    "InterfaceElement",
+    "InterfaceSnapshot",
+]
diff --git a/src/leapflow/domain/event_types.py b/src/leapflow/domain/event_types.py
index fc8ec299..3a3f4669 100644
--- a/src/leapflow/domain/event_types.py
+++ b/src/leapflow/domain/event_types.py
@@ -76,6 +76,39 @@ class LearningEventType:
     COLD_START_PROMPT = "learning.cold_start_prompt"
 
 
+class EvolutionEventType:
+    """Append-only facts emitted by the governed evolution pipeline."""
+
+    ACTION_STARTED = "action.started"
+    ACTION_COMPLETED = "action.completed"
+    ACTION_FAILED = "action.failed"
+    SESSION_FINALIZED = "session.finalized"
+    TEACHER_JOB_QUEUED = "teacher.job_queued"
+    TEACHER_JOB_FAILED = "teacher.job_failed"
+    TEACHER_GRADED = "teacher.graded"
+    TEACHER_VERDICT_RECORDED = "teacher.verdict_recorded"
+    KNOWLEDGE_RETRACTED = "knowledge.retracted"
+    ENVIRONMENT_OBSERVED = "environment.observed"
+    REQUIREMENT_RESOLVED = "requirement.resolved"
+    PROPOSAL_CREATED = "proposal.created"
+    PROPOSAL_UPDATED = "proposal.updated"
+    PROPOSAL_GENERATED = "proposal.generated"
+    PROPOSAL_APPROVED = "proposal.approved"
+    PROPOSAL_REJECTED = "proposal.rejected"
+    PROPOSAL_FAILED = "proposal.failed"
+    PROPOSAL_SUPERSEDED = "proposal.superseded"
+    PROPOSAL_EXPIRED = "proposal.expired"
+    PROPOSAL_NO_OP = "proposal.no_op"
+    PLUGIN_INSTALLED = "plugin.installed"
+    PLUGIN_PROBATION_STARTED = "plugin.probation_started"
+    PLUGIN_VERIFIED = "plugin.verified"
+    PLUGIN_QUARANTINED = "plugin.quarantined"
+    PLUGIN_ROLLED_BACK = "plugin.rolled_back"
+    FRAMEWORK_TRACE_RECORDED = "framework.trace_recorded"
+    PLUGIN_OUTCOME_RECORDED = "plugin.outcome_recorded"
+    CALIBRATION_UPDATED = "calibration.updated"
+
+
 class CLIEventType:
     """Synthetic events from CLI interaction layer."""
 
diff --git a/src/leapflow/domain/evolution_event.py b/src/leapflow/domain/evolution_event.py
new file mode 100644
index 00000000..25151ac6
--- /dev/null
+++ b/src/leapflow/domain/evolution_event.py
@@ -0,0 +1,351 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Immutable causal events for the long-running self-evolution pipeline.
+
+The event log is the one durable vocabulary shared by execution, perception,
+teaching, governance, and presentation.  Facts are appended; state is projected.
+No consumer is allowed to infer missing stages as success.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import time
+import uuid
+from dataclasses import dataclass, field, replace
+from enum import Enum
+from pathlib import Path
+from types import MappingProxyType
+from typing import Any, Mapping, Protocol, Sequence, runtime_checkable
+
+SCHEMA_VERSION = 1
+
+
+class ActionEvidenceUnavailable(RuntimeError):
+    """A mutating action cannot cross its durable evidence barrier."""
+
+
+def _normalize_json(value: Any) -> Any:
+    """Return a deterministic JSON-compatible copy or reject ambiguous values."""
+    if value is None or isinstance(value, (bool, int, str)):
+        return value
+    if isinstance(value, float):
+        if not math.isfinite(value):
+            raise ValueError("evolution event JSON cannot contain NaN or infinity")
+        return value
+    if isinstance(value, Enum):
+        return _normalize_json(value.value)
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, Mapping):
+        normalized: dict[str, Any] = {}
+        for key, item in value.items():
+            name = str(key)
+            if name in normalized:
+                raise ValueError(f"duplicate JSON key after string conversion: {name!r}")
+            normalized[name] = _normalize_json(item)
+        return normalized
+    if isinstance(value, (list, tuple)):
+        return [_normalize_json(item) for item in value]
+    if isinstance(value, (set, frozenset)):
+        items = [_normalize_json(item) for item in value]
+        return sorted(items, key=lambda item: json.dumps(item, ensure_ascii=False, sort_keys=True))
+    raise TypeError(f"unsupported evolution event JSON value: {type(value).__name__}")
+
+
+def _freeze_json(value: Any) -> Any:
+    if isinstance(value, dict):
+        return MappingProxyType({key: _freeze_json(item) for key, item in value.items()})
+    if isinstance(value, list):
+        return tuple(_freeze_json(item) for item in value)
+    return value
+
+
+def _thaw_json(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        return {str(key): _thaw_json(item) for key, item in value.items()}
+    if isinstance(value, tuple):
+        return [_thaw_json(item) for item in value]
+    return value
+
+
+def canonical_json(value: Any) -> str:
+    """Return strict deterministic JSON used for hashes and deduplication."""
+    return json.dumps(
+        _normalize_json(value if value is not None else {}),
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+        allow_nan=False,
+    )
+
+
+def content_hash(value: Any) -> str:
+    """Return a SHA-256 digest for deterministic JSON-compatible content."""
+    return hashlib.sha256(canonical_json(value).encode("utf-8")).hexdigest()
+
+
+@dataclass(frozen=True)
+class EvolutionContext:
+    """Causal identity carried across the complete evolution lifecycle.
+
+    Empty values are explicit unknowns, never permission to join records by guess.
+    ``correlation_id`` identifies one evolution episode and ``causation_id`` points
+    to the direct predecessor event.
+    """
+
+    profile_id: str = ""
+    workspace_id: str = ""
+    session_id: str = ""
+    session_generation: int = 0
+    turn_id: str = ""
+    frame_id: str = ""
+    action_id: str = ""
+    observation_id: str = ""
+    requirement_id: str = ""
+    decision_id: str = ""
+    proposal_id: str = ""
+    artifact_id: str = ""
+    plugin_id: str = ""
+    version_id: str = ""
+    correlation_id: str = ""
+    causation_id: str = ""
+
+    def __post_init__(self) -> None:
+        if int(self.session_generation) < 0:
+            raise ValueError("session_generation must be non-negative")
+        object.__setattr__(self, "session_generation", int(self.session_generation))
+        for name in self.__dataclass_fields__:
+            if name != "session_generation":
+                object.__setattr__(self, name, str(getattr(self, name) or ""))
+
+    @classmethod
+    def create(cls, **values: Any) -> "EvolutionContext":
+        """Create a context, minting one episode correlation id when absent."""
+        normalized = {
+            name: (int(value) if name == "session_generation" else str(value or ""))
+            for name, value in values.items()
+            if name in cls.__dataclass_fields__
+        }
+        if not normalized.get("correlation_id"):
+            normalized["correlation_id"] = f"evo-{uuid.uuid4().hex}"
+        return cls(**normalized)
+
+    @classmethod
+    def from_mapping(cls, value: Mapping[str, Any] | None) -> "EvolutionContext":
+        """Build from a mapping while ignoring unknown future fields."""
+        raw = dict(value or {})
+        return cls(
+            **{
+                name: (
+                    int(raw.get(name) or 0)
+                    if name == "session_generation"
+                    else str(raw.get(name) or "")
+                )
+                for name in cls.__dataclass_fields__
+            }
+        )
+
+    def with_ids(self, **values: Any) -> "EvolutionContext":
+        """Return a copy with selected identifiers updated."""
+        allowed = {
+            key: (int(value) if key == "session_generation" else str(value or ""))
+            for key, value in values.items()
+            if key in self.__dataclass_fields__
+        }
+        return replace(self, **allowed)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            name: getattr(self, name)
+            for name in self.__dataclass_fields__
+        }
+
+
+@dataclass(frozen=True)
+class EvolutionEvent:
+    """One append-only fact in the evolution event stream."""
+
+    event_id: str
+    event_type: str
+    context: EvolutionContext
+    payload: Mapping[str, Any] = field(default_factory=dict)
+    occurred_at: float = 0.0
+    producer: str = ""
+    producer_version: str = ""
+    privacy_class: str = "system"
+    schema_version: int = SCHEMA_VERSION
+    dedup_key: str = ""
+    payload_hash: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.event_id:
+            raise ValueError("event_id is required")
+        if not self.event_type:
+            raise ValueError("event_type is required")
+        if not self.producer:
+            raise ValueError("producer is required")
+        if not self.dedup_key:
+            raise ValueError("dedup_key is required")
+        if self.schema_version <= 0:
+            raise ValueError("schema_version must be positive")
+        if not math.isfinite(float(self.occurred_at)):
+            raise ValueError("occurred_at must be finite")
+        normalized = _normalize_json(dict(self.payload))
+        digest = content_hash(normalized)
+        if self.payload_hash and self.payload_hash != digest:
+            raise ValueError("payload_hash does not match the event payload")
+        object.__setattr__(self, "payload", _freeze_json(normalized))
+        object.__setattr__(self, "payload_hash", digest)
+        object.__setattr__(self, "occurred_at", float(self.occurred_at))
+
+    @classmethod
+    def create(
+        cls,
+        event_type: str,
+        *,
+        context: EvolutionContext,
+        payload: Mapping[str, Any] | None = None,
+        producer: str,
+        producer_version: str = "",
+        privacy_class: str = "system",
+        occurred_at: float | None = None,
+        dedup_key: str = "",
+        event_id: str = "",
+    ) -> "EvolutionEvent":
+        """Create an event with stable payload hash and idempotency identity."""
+        normalized_payload = dict(payload or {})
+        payload_digest = content_hash(normalized_payload)
+        identity = dedup_key or content_hash(
+            {
+                "event_type": str(event_type),
+                "context": context.to_dict(),
+                "payload_hash": payload_digest,
+                "producer": str(producer),
+            }
+        )
+        return cls(
+            event_id=str(event_id or f"evt-{uuid.uuid4().hex}"),
+            event_type=str(event_type),
+            context=context,
+            payload=normalized_payload,
+            occurred_at=float(occurred_at if occurred_at is not None else time.time()),
+            producer=str(producer),
+            producer_version=str(producer_version),
+            privacy_class=str(privacy_class or "system"),
+            dedup_key=identity,
+            payload_hash=payload_digest,
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "event_id": self.event_id,
+            "event_type": self.event_type,
+            "context": self.context.to_dict(),
+            "payload": _thaw_json(self.payload),
+            "occurred_at": self.occurred_at,
+            "producer": self.producer,
+            "producer_version": self.producer_version,
+            "privacy_class": self.privacy_class,
+            "schema_version": self.schema_version,
+            "dedup_key": self.dedup_key,
+            "payload_hash": self.payload_hash,
+        }
+
+    @classmethod
+    def from_dict(cls, value: Mapping[str, Any]) -> "EvolutionEvent":
+        return cls(
+            event_id=str(value.get("event_id") or ""),
+            event_type=str(value.get("event_type") or ""),
+            context=EvolutionContext.from_mapping(value.get("context")),
+            payload=_normalize_json(value.get("payload") or {}),
+            occurred_at=float(value.get("occurred_at") or 0.0),
+            producer=str(value.get("producer") or ""),
+            producer_version=str(value.get("producer_version") or ""),
+            privacy_class=str(value.get("privacy_class") or "system"),
+            schema_version=int(value.get("schema_version") or SCHEMA_VERSION),
+            dedup_key=str(value.get("dedup_key") or ""),
+            payload_hash=str(value.get("payload_hash") or ""),
+        )
+
+
+@dataclass(frozen=True)
+class EvolutionEventRecord:
+    """One persisted event paired with its monotonic stream cursor."""
+
+    sequence: int
+    event: EvolutionEvent
+
+    def __post_init__(self) -> None:
+        if self.sequence <= 0:
+            raise ValueError("event sequence must be positive")
+
+
+@runtime_checkable
+class EvolutionEventStore(Protocol):
+    """Storage boundary for the append-only evolution fact stream."""
+
+    def append(self, event: EvolutionEvent) -> bool: ...
+
+    def append_many(self, events: Sequence[EvolutionEvent]) -> int: ...
+
+    def read(
+        self,
+        *,
+        profile_id: str = "",
+        session_id: str = "",
+        session_generation: int | None = None,
+        correlation_id: str = "",
+        proposal_id: str = "",
+        proposal_events_only: bool = False,
+        event_type: str = "",
+        after_sequence: int = 0,
+        through_sequence: int = 0,
+        limit: int = 500,
+    ) -> list[EvolutionEventRecord]: ...
+
+    def latest_sequence(self, *, profile_id: str = "", session_id: str = "") -> int: ...
+
+    def latest_evidence_sequence(
+        self,
+        *,
+        profile_id: str,
+        session_id: str,
+        session_generation: int | None = None,
+    ) -> int: ...
+
+    def evidence_sessions(self, *, profile_id: str = "") -> list[dict[str, Any]]: ...
+
+    def last_finalized_sequence(
+        self,
+        *,
+        profile_id: str,
+        session_id: str,
+        session_generation: int | None = None,
+    ) -> int: ...
+
+    def finalize_session(
+        self,
+        *,
+        profile_id: str,
+        workspace_id: str,
+        session_id: str,
+        session_generation: int,
+        from_sequence: int,
+        through_sequence: int,
+        reason: str,
+        goal: str = "",
+        model: str = "",
+    ) -> tuple[str, str]: ...
+
+
+__all__ = [
+    "SCHEMA_VERSION",
+    "ActionEvidenceUnavailable",
+    "EvolutionContext",
+    "EvolutionEvent",
+    "EvolutionEventRecord",
+    "EvolutionEventStore",
+    "canonical_json",
+    "content_hash",
+]
diff --git a/src/leapflow/domain/plugin_fiber.py b/src/leapflow/domain/plugin_fiber.py
index 6b92bad9..98d3d16e 100644
--- a/src/leapflow/domain/plugin_fiber.py
+++ b/src/leapflow/domain/plugin_fiber.py
@@ -2,18 +2,20 @@
 """Plugin lifecycle state machine (PluginFiber).
 
 Manages the runtime lifecycle of a single plugin instance through a
-six-state finite automaton with generation tracking:
+seven-state finite automaton with generation tracking:
 
-    PENDING → LOADING → ACTIVE → UNLOADING → DISPOSED
+    PENDING → DRAFT → ACTIVE → UNLOADING → DISPOSED
+    PENDING → LOADING → ACTIVE
               LOADING → FAILED → LOADING (retry)
-    PENDING → ACTIVE (fast path for plugins with no async init)
-    PENDING/LOADING/FAILED → DISPOSED (early cleanup)
+    PENDING → ACTIVE (fast path for trusted built-ins)
+    PENDING/DRAFT/LOADING/FAILED → DISPOSED (early cleanup)
 
 Each fiber owns an EffectScope; dispose() always cascades scope cleanup.
 Generation counter provides identity across reload cycles.
 
 States:
     PENDING   — created, awaiting activation or async init
+    DRAFT     — isolated and testable, not published to the live registry
     LOADING   — async initialization in progress (dependency resolution)
     ACTIVE    — fully operational, tools available
     FAILED    — initialization failed, retryable via retry()/begin_loading()
@@ -47,6 +49,7 @@ def _next_generation() -> int:
 class FiberState(enum.Enum):
     """Plugin fiber lifecycle states."""
     PENDING = "pending"
+    DRAFT = "draft"
     LOADING = "loading"
     ACTIVE = "active"
     FAILED = "failed"
@@ -59,7 +62,13 @@ class IllegalStateTransition(RuntimeError):
 
 
 _VALID_TRANSITIONS: dict[FiberState, set[FiberState]] = {
-    FiberState.PENDING: {FiberState.ACTIVE, FiberState.LOADING, FiberState.DISPOSED},
+    FiberState.PENDING: {
+        FiberState.DRAFT,
+        FiberState.ACTIVE,
+        FiberState.LOADING,
+        FiberState.DISPOSED,
+    },
+    FiberState.DRAFT: {FiberState.ACTIVE, FiberState.DISPOSED},
     FiberState.LOADING: {FiberState.ACTIVE, FiberState.FAILED, FiberState.DISPOSED},
     FiberState.ACTIVE: {FiberState.UNLOADING},
     FiberState.FAILED: {FiberState.LOADING, FiberState.DISPOSED},
@@ -112,8 +121,12 @@ def error(self) -> Optional[Exception]:
         """The stored error from a failed loading attempt, if any."""
         return self._error
 
+    def mark_draft(self) -> None:
+        """Transition a newly created fiber into isolated validation."""
+        self._transition(FiberState.DRAFT)
+
     def activate(self) -> None:
-        """Transition from PENDING or LOADING to ACTIVE."""
+        """Transition from PENDING, DRAFT, or LOADING to ACTIVE."""
         self._transition(FiberState.ACTIVE)
 
     def begin_loading(self) -> None:
diff --git a/src/leapflow/domain/plugin_proposal.py b/src/leapflow/domain/plugin_proposal.py
index 3f797795..f6d8cc26 100644
--- a/src/leapflow/domain/plugin_proposal.py
+++ b/src/leapflow/domain/plugin_proposal.py
@@ -11,7 +11,7 @@
 import time
 import uuid
 from dataclasses import dataclass, field
-from typing import Any, Literal
+from typing import Any, Literal, Mapping
 
 GapType = Literal["tool_plugin", "gateway_adapter", "signal_source", "llm_provider", "unknown"]
 ProposalStatus = Literal["draft", "review", "approved", "rejected"]
@@ -171,3 +171,49 @@ def to_dict(self) -> dict[str, Any]:
             "proposed_tools": [item.to_dict() for item in self.proposed_tools],
             "test_cases": [item.to_dict() for item in self.test_cases],
         }
+
+    @classmethod
+    def from_dict(cls, raw: Mapping[str, Any]) -> "PluginProposal":
+        """Rebuild a proposal embedded in an event-sourced lifecycle record."""
+        evidence = tuple(
+            GapEvidence.create(
+                str(item.get("evidence_type") or "unknown"),
+                str(item.get("summary") or ""),
+                confidence=float(item.get("confidence") or 0.0),
+                metadata=dict(item.get("metadata") or {}),
+            )
+            for item in raw.get("evidence", ())
+            if isinstance(item, Mapping)
+        )
+        tools = tuple(
+            ProposedToolSpec(
+                name=str(item.get("name") or "generated_tool"),
+                description=str(item.get("description") or ""),
+                risk_level=str(item.get("risk_level") or "read_only"),  # type: ignore[arg-type]
+                mutates_state=bool(item.get("mutates_state", False)),
+            )
+            for item in raw.get("proposed_tools", ())
+            if isinstance(item, Mapping)
+        )
+        tests = tuple(
+            BehaviorTestCase.create(
+                str(item.get("tool_name") or ""),
+                arguments=dict(item.get("arguments") or {}),
+                expected_subset=dict(item.get("expected_subset") or {}),
+                description=str(item.get("description") or ""),
+            )
+            for item in raw.get("test_cases", ())
+            if isinstance(item, Mapping)
+        )
+        return cls(
+            proposal_id=str(raw.get("proposal_id") or ""),
+            plugin_id=str(raw.get("plugin_id") or "generated_plugin"),
+            capability_summary=str(raw.get("capability_summary") or ""),
+            gap_type=str(raw.get("gap_type") or "tool_plugin"),  # type: ignore[arg-type]
+            risk_level=str(raw.get("risk_level") or "read_only"),  # type: ignore[arg-type]
+            status=str(raw.get("status") or "draft"),  # type: ignore[arg-type]
+            evidence=evidence,
+            proposed_tools=tools,
+            test_cases=tests,
+            created_at=float(raw.get("created_at") or 0.0),
+        )
diff --git a/src/leapflow/domain/skill_types.py b/src/leapflow/domain/skill_types.py
index 01e75e58..c6ce12c0 100644
--- a/src/leapflow/domain/skill_types.py
+++ b/src/leapflow/domain/skill_types.py
@@ -114,6 +114,7 @@ class SkillMetadata:
     source_repo_id: str = ""           # Hub repo_id (hub source only)
     source_version: str = ""           # Hub version (hub source only)
     source_hub_type: str = ""          # hub_type (hub source only)
+    execution_policy: str = "external_side_effect"
 
     @property
     def tier(self) -> SkillTier:
diff --git a/src/leapflow/engine/action_executor.py b/src/leapflow/engine/action_executor.py
new file mode 100644
index 00000000..a7d6bc85
--- /dev/null
+++ b/src/leapflow/engine/action_executor.py
@@ -0,0 +1,164 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Single execution boundary for durable, no-LLM action evidence."""
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Mapping, Protocol, runtime_checkable
+
+from leapflow.domain.evolution_event import (
+    ActionEvidenceUnavailable,
+    EvolutionContext,
+    EvolutionEvent,
+)
+from leapflow.engine.tool_execution import ExecutionPolicy
+
+logger = logging.getLogger(__name__)
+
+ActionOperation = Callable[[], Awaitable[Any]]
+
+
+@dataclass(frozen=True)
+class ActionInvocation:
+    """Complete execution identity passed to the shared action boundary."""
+
+    action_type: str
+    action_name: str
+    arguments: Mapping[str, Any]
+    execution_id: str
+    execution_policy: ExecutionPolicy
+    context: EvolutionContext
+    goal: str = ""
+
+    @property
+    def requires_durable_start(self) -> bool:
+        """Every mutation must be evidenced before its side effect can begin."""
+        return self.execution_policy != "read_only"
+
+
+@runtime_checkable
+class ActionRecorderPort(Protocol):
+    """Recorder contract kept independent from a concrete event transport."""
+
+    async def started(
+        self,
+        *,
+        context: EvolutionContext,
+        action_type: str,
+        action_name: str,
+        arguments: Mapping[str, Any] | None,
+        execution_policy: str,
+        critical: bool,
+        goal: str = "",
+        occurred_at: float | None = None,
+    ) -> EvolutionEvent: ...
+
+    async def completed(
+        self,
+        *,
+        context: EvolutionContext,
+        started_event: EvolutionEvent,
+        action_type: str,
+        action_name: str,
+        result: Any,
+        duration_ms: float,
+        occurred_at: float | None = None,
+        critical: bool = False,
+    ) -> EvolutionEvent: ...
+
+    async def failed_exception(
+        self,
+        *,
+        context: EvolutionContext,
+        started_event: EvolutionEvent,
+        action_type: str,
+        action_name: str,
+        error: BaseException,
+        duration_ms: float,
+        critical: bool = False,
+    ) -> EvolutionEvent: ...
+
+
+@runtime_checkable
+class ActionExecutor(Protocol):
+    """Execute one action through the system's single evidence boundary."""
+
+    async def execute(self, invocation: ActionInvocation, operation: ActionOperation) -> Any: ...
+
+
+class RecordedActionExecutor:
+    """Record action lifecycle facts without adding an LLM call to the hot path."""
+
+    def __init__(self, recorder: ActionRecorderPort | None) -> None:
+        self._recorder = recorder
+
+    async def execute(self, invocation: ActionInvocation, operation: ActionOperation) -> Any:
+        recorder = self._recorder
+        if recorder is None:
+            return await operation()
+
+        started_at = time.perf_counter()
+        try:
+            started = await recorder.started(
+                context=invocation.context,
+                action_type=invocation.action_type,
+                action_name=invocation.action_name,
+                arguments=invocation.arguments,
+                execution_policy=invocation.execution_policy,
+                critical=invocation.requires_durable_start,
+                goal=invocation.goal,
+            )
+        except Exception as exc:
+            if invocation.requires_durable_start:
+                raise ActionEvidenceUnavailable(
+                    "mutating action refused because its audit start could not be persisted"
+                ) from exc
+            logger.warning("action evidence start unavailable", exc_info=True)
+            return await operation()
+
+        try:
+            result = await operation()
+        except Exception as exc:
+            try:
+                await recorder.failed_exception(
+                    context=invocation.context,
+                    started_event=started,
+                    action_type=invocation.action_type,
+                    action_name=invocation.action_name,
+                    error=exc,
+                    duration_ms=(time.perf_counter() - started_at) * 1000.0,
+                    critical=invocation.requires_durable_start,
+                )
+            except Exception:
+                logger.error("action failure evidence could not be persisted", exc_info=True)
+            raise
+
+        try:
+            await recorder.completed(
+                context=invocation.context,
+                started_event=started,
+                action_type=invocation.action_type,
+                action_name=invocation.action_name,
+                result=result,
+                duration_ms=(time.perf_counter() - started_at) * 1000.0,
+                critical=invocation.requires_durable_start,
+            )
+        except Exception:
+            logger.error("action completion evidence could not be persisted", exc_info=True)
+            if invocation.requires_durable_start and isinstance(result, dict):
+                result = {
+                    **result,
+                    "audit_incomplete": True,
+                    "side_effect_uncertain": True,
+                }
+        return result
+
+
+__all__ = [
+    "ActionExecutor",
+    "ActionInvocation",
+    "ActionOperation",
+    "ActionRecorderPort",
+    "RecordedActionExecutor",
+]
diff --git a/src/leapflow/engine/engine.py b/src/leapflow/engine/engine.py
index 7cdf2d04..821b7445 100644
--- a/src/leapflow/engine/engine.py
+++ b/src/leapflow/engine/engine.py
@@ -9,12 +9,13 @@
 import re
 import sys
 import time
+import uuid
 from dataclasses import asdict, dataclass, replace
 from datetime import datetime
 from pathlib import Path
 from typing import Any, AsyncIterator, ClassVar, Dict, List, Literal, Optional, Union
 
-from leapflow.platform.protocol import HostRpc, Methods
+from leapflow.platform.protocol import HostRpc
 from leapflow.config import Settings
 from leapflow.engine.budget import BudgetConfig, BudgetStatus, IterationBudget
 from leapflow.engine.prefix_commitment import PrefixCommitmentController
@@ -73,11 +74,14 @@
     ToolCall as ConcurrentToolCall,
     ToolConcurrencyPolicy,
 )
+from leapflow.engine.action_executor import ActionExecutor, ActionInvocation, RecordedActionExecutor
 from leapflow.engine.tool_execution import (
+    ExecutionPolicy,
     ToolExecutionLedger,
     effect_is_uncertain_on_failure,
     execution_policy_for,
     exit_code_from,
+    normalize_execution_policy,
 )
 from leapflow.engine.graph_planner import GraphPlanner
 from leapflow.engine.scheduler import TaskScheduler
@@ -1167,7 +1171,6 @@ def __init__(
         imitation: Optional[ImitationPipeline] = None,
         skill_library: Optional[SkillLibraryStore] = None,
         graph_planner: Optional[GraphPlanner] = None,
-        scheduler: Optional[TaskScheduler] = None,
         perception: Optional[Any] = None,
         execution: Optional[Any] = None,
         skill_activator: Optional[Any] = None,
@@ -1178,6 +1181,7 @@ def __init__(
         skill_injector: Optional[Any] = None,
         skill_index: Optional[Any] = None,
         concurrency_policy: Optional[ToolConcurrencyPolicy] = None,
+        action_executor: Optional[ActionExecutor] = None,
     ) -> None:
         self._settings = settings
         self._rpc = rpc
@@ -1196,7 +1200,7 @@ def __init__(
             execution=execution,
         )
         self._graph_planner = graph_planner
-        self._scheduler = scheduler
+        self._scheduler: Optional[TaskScheduler] = None
         self._perception = perception
         self._execution = execution
         self._activator = skill_activator
@@ -1225,6 +1229,15 @@ def __init__(
         self._current_turn_id: str = ""
         self._current_command_id: str = ""
         self._tool_execution_ledger = ToolExecutionLedger()
+        # The executor is profile-scoped while every invocation receives identity
+        # from this session engine, preserving isolation across shallow copies.
+        self._action_executor: ActionExecutor = action_executor or RecordedActionExecutor(None)
+        if self._graph_planner is not None:
+            self._scheduler = TaskScheduler(
+                self._registry,
+                graph_planner=self._graph_planner,
+                action_dispatcher=self.execute_action,
+            )
 
         self._current_request_id: str = ""
 
@@ -1298,6 +1311,7 @@ def __init__(
         self._calibrated_finalizing_ratio: Optional[float] = None
         # S3 periodic re-calibration (opt-in): evolution store + root-turn counter.
         self._calibration_store: Optional[Any] = None
+        self._calibration_event_store: Optional[Any] = None
         self._turns_since_calibration = 0
         self._error_classifier = ErrorClassifier(
             recovery_map=build_recovery_map(
@@ -1427,8 +1441,8 @@ def reconfigure_host_backend(
         if self._settings.has_llm_credentials:
             self._scheduler = TaskScheduler(
                 self._registry,
-                rpc,
                 graph_planner=self._graph_planner,
+                action_dispatcher=self.execute_action,
             )
         else:
             self._scheduler = None
@@ -1462,8 +1476,8 @@ def reconfigure_runtime(
             self._graph_planner = GraphPlanner(self._llm, self._registry)
             self._scheduler = TaskScheduler(
                 self._registry,
-                self._rpc,
                 graph_planner=self._graph_planner,
+                action_dispatcher=self.execute_action,
             )
         else:
             self._graph_planner = None
@@ -1795,6 +1809,11 @@ def set_evolution_store(self, store: Any) -> None:
         """Inject evolution store for incremental episode persistence."""
         self._evolution_store = store
 
+    def set_distilled_knowledge_store(self, store: Any) -> None:
+        """Inject the event-derived knowledge read model shared by session engines."""
+        self._knowledge_store = store
+        self._knowledge_store_unavailable = store is None
+
     def set_model_capabilities(self, registry: Any) -> None:
         """Inject model capability registry."""
         self._model_capabilities = registry
@@ -2209,34 +2228,22 @@ def _resolve_knowledge_store(self) -> Any:
         relying on it would make knowledge appear or vanish for unrelated reasons.
         """
         if self._knowledge_store is not None:
+            if not self._environment_fingerprint_id:
+                try:
+                    from leapflow.domain.environment_fingerprint import EnvironmentFingerprint
+                    from leapflow.domain.platform import PlatformManifest
+
+                    self._environment_fingerprint_id = (
+                        EnvironmentFingerprint.from_platform_manifest(
+                            PlatformManifest.default_darwin(),
+                            workspace_root=getattr(self._settings, "workspace_root", ""),
+                        ).fingerprint_id
+                    )
+                except Exception:  # noqa: BLE001 - context is an improvement, never a gate
+                    logger.debug("engine: environment fingerprint unavailable", exc_info=True)
             return self._knowledge_store
-        if self._knowledge_store_unavailable:
-            return None
-        profile_layout = getattr(self._settings, "profile_layout", None)
-        if profile_layout is None:
-            return None
-        try:
-            from leapflow.domain.environment_fingerprint import EnvironmentFingerprint
-            from leapflow.domain.platform import PlatformManifest
-            from leapflow.storage.distilled_knowledge_store import (
-                JsonDistilledKnowledgeStore,
-            )
-
-            self._knowledge_store = JsonDistilledKnowledgeStore(
-                profile_layout.distilled_knowledge_path,
-                ttl_seconds=float(
-                    getattr(self._settings, "distilled_knowledge_ttl_s", 0.0) or 0.0
-                ),
-            )
-            self._environment_fingerprint_id = EnvironmentFingerprint.from_platform_manifest(
-                PlatformManifest.default_darwin(),
-                workspace_root=getattr(self._settings, "workspace_root", ""),
-            ).fingerprint_id
-        except Exception:  # noqa: BLE001 - context is an improvement, never a gate
-            logger.debug("engine: distilled knowledge store unavailable", exc_info=True)
-            self._knowledge_store = None
-            self._knowledge_store_unavailable = True
-        return self._knowledge_store
+        self._knowledge_store_unavailable = True
+        return None
 
     def _focus_turn_id(self) -> int:
         """Return a stable monotonic turn id for focus observations."""
@@ -2728,14 +2735,32 @@ def recalibrate_difficulty(self, store: Any) -> Any:
                 False,
                 "report build failed",
             )
+        configured_min = float(
+            getattr(self._settings, "agent_calibration_difficulty_min_k", 0.25)
+        )
+        configured_max = float(
+            getattr(self._settings, "agent_calibration_difficulty_max_k", 3.0)
+        )
+        k_min = min(3.0, max(0.25, configured_min))
+        k_max = max(k_min, min(3.0, configured_max))
         result = apply_calibration(
             self._baseline_scale_k,
             report,
             enabled=True,
             min_confidence=float(getattr(self._settings, "agent_calibration_min_confidence", 0.3)),
+            k_min=k_min,
+            k_max=k_max,
         )
         if result.applied:
             self._budget_config = replace(self._budget_config, scale_k=result.effective_k)
+            self._record_calibration_event(
+                "difficulty_scale",
+                baseline=result.baseline_k,
+                effective=result.effective_k,
+                reason=result.reason,
+                lower_bound=k_min,
+                upper_bound=k_max,
+            )
             logger.info(
                 "difficulty calibration applied: scale_k %.3f -> %.3f (%s)",
                 self._baseline_scale_k,
@@ -2777,17 +2802,33 @@ def recalibrate_thresholds(self, store: Any) -> Any:
         except Exception:
             logger.debug("threshold calibration: report build failed", exc_info=True)
             return CalibrationResult(baseline, current, False, "report build failed")
+        configured_min = float(
+            getattr(self._settings, "agent_calibration_finalizing_min_ratio", 0.6)
+        )
+        configured_max = float(
+            getattr(self._settings, "agent_calibration_finalizing_max_ratio", 0.98)
+        )
+        k_min = min(0.98, max(0.6, configured_min))
+        k_max = max(k_min, min(0.98, configured_max))
         result = apply_calibration(
             baseline,
             report,
             enabled=True,
             min_confidence=float(getattr(self._settings, "agent_calibration_min_confidence", 0.3)),
-            k_min=0.6,
-            k_max=0.98,
+            k_min=k_min,
+            k_max=k_max,
         )
         if result.applied:
             self._calibrated_finalizing_ratio = result.effective_k
             self._context_governance_controller = self._new_governance()
+            self._record_calibration_event(
+                "finalizing_ratio",
+                baseline=result.baseline_k,
+                effective=result.effective_k,
+                reason=result.reason,
+                lower_bound=k_min,
+                upper_bound=k_max,
+            )
             logger.info(
                 "threshold calibration applied: finalizing_ratio %.3f -> %.3f (%s)",
                 baseline,
@@ -2802,9 +2843,56 @@ def reset_threshold_calibration(self) -> None:
         self._context_governance_controller = self._new_governance()
 
     def set_calibration_store(self, store: Any) -> None:
-        """Install the evolution store used for periodic S3 re-calibration."""
+        """Install the skill episode store used for periodic calibration input."""
         self._calibration_store = store
 
+    def set_calibration_event_store(self, store: Any) -> None:
+        """Install the append-only audit sink for applied calibration decisions."""
+        self._calibration_event_store = store
+
+    def _record_calibration_event(
+        self,
+        parameter: str,
+        *,
+        baseline: float,
+        effective: float,
+        reason: str,
+        lower_bound: float,
+        upper_bound: float,
+    ) -> None:
+        store = self._calibration_event_store
+        if store is None:
+            return
+        try:
+            import time
+
+            from leapflow.domain.event_types import EvolutionEventType
+            from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent
+
+            occurred_at = time.time()
+            event = EvolutionEvent.create(
+                EvolutionEventType.CALIBRATION_UPDATED,
+                context=EvolutionContext(
+                    profile_id=str(getattr(self._settings, "profile", "default")),
+                    correlation_id=f"calibration:{parameter}",
+                ),
+                payload={
+                    "parameter": parameter,
+                    "baseline": float(baseline),
+                    "effective": float(effective),
+                    "reason": str(reason),
+                    "lower_bound": float(lower_bound),
+                    "upper_bound": float(upper_bound),
+                },
+                producer="engine.online_calibration",
+                privacy_class="profile",
+                occurred_at=occurred_at,
+                dedup_key=f"calibration.updated:{parameter}:{time.time_ns()}",
+            )
+            store.append(event)
+        except Exception:  # noqa: BLE001 - calibration audit cannot break a turn
+            logger.error("calibration decision could not be persisted", exc_info=True)
+
     def _maybe_periodic_recalibration(self) -> None:
         """S3-L3/L4 periodic re-calibration (opt-in via agent.calibration_interval_turns).
 
@@ -4895,7 +4983,7 @@ def _unified_tool_handlers(self) -> Dict[str, Any]:
 
         _plugin_registry = get_registry()
 
-        handlers: Dict[str, Any] = dict(_plugin_registry.tool_handlers)
+        handlers: Dict[str, Any] = _plugin_registry.snapshot_handlers()
         dp = _plugin_registry.get_desktop_semantic_plugin()
         if dp is not None and dp.active:
             handlers.update(dp.get_semantic_handlers())
@@ -5314,7 +5402,17 @@ async def _execute_tool_with_ledger(
         registry = _default_tool_registry()
         resolution = registry.resolve(proposed_name, args)
         if not resolution.auto_executable or resolution.normalized_name is None:
-            return await self._execute_tool_scoped(tool_call, handlers)
+            async def _run_unresolved() -> Dict[str, Any]:
+                return await self._execute_tool_scoped(tool_call, handlers)
+
+            return await self._execute_action_boundary(
+                action_type="tool",
+                action_name=proposed_name,
+                arguments=args,
+                execution_id=f"unresolved-{uuid.uuid4().hex}",
+                execution_policy="external_side_effect",
+                execute=_run_unresolved,
+            )
 
         tool_name = resolution.normalized_name
         spec = registry.specs.get(tool_name)
@@ -5367,44 +5465,73 @@ async def _execute_tool_with_ledger(
             )
             return duplicate
 
+        async def _execute_and_finalize() -> Dict[str, Any]:
+            try:
+                result = await self._execute_tool_scoped(normalized_call, handlers)
+            except Exception as exc:
+                failed_result: Dict[str, Any] = {
+                    "ok": False,
+                    "error": f"{type(exc).__name__}: {exc}",
+                    "retryable": True,
+                    "execution_id": record.execution_id,
+                    "idempotency_key": record.idempotency_key,
+                    "execution_policy": policy,
+                    "tool_call_id": tool_call_id,
+                }
+                _annotate_uncertain_effect(failed_result, policy)
+                self._tool_execution_ledger.complete(record, failed_result)
+                raise
+            if isinstance(result, dict):
+                result_for_ledger: Dict[str, Any] = {
+                    **result,
+                    "execution_id": record.execution_id,
+                    "idempotency_key": record.idempotency_key,
+                    "execution_policy": policy,
+                    "tool_call_id": tool_call_id,
+                }
+            else:
+                result_for_ledger = {
+                    "ok": True,
+                    "result": result,
+                    "execution_id": record.execution_id,
+                    "idempotency_key": record.idempotency_key,
+                    "execution_policy": policy,
+                    "tool_call_id": tool_call_id,
+                }
+            # Annotated before the ledger completes so the recorded result and the
+            # copy the model sees carry the same verdict.
+            _annotate_uncertain_effect(result_for_ledger, policy)
+            completed = self._tool_execution_ledger.complete(record, result_for_ledger)
+            result_for_ledger["execution_status"] = completed.status
+            return result_for_ledger
+
         try:
-            result = await self._execute_tool_scoped(normalized_call, handlers)
+            return await self._execute_action_boundary(
+                action_type="tool",
+                action_name=tool_name,
+                arguments=args,
+                execution_id=record.execution_id,
+                execution_policy=policy,
+                execute=_execute_and_finalize,
+            )
         except Exception as exc:
-            failed_result: Dict[str, Any] = {
+            from leapflow.domain.evolution_event import ActionEvidenceUnavailable
+
+            if not isinstance(exc, ActionEvidenceUnavailable):
+                raise
+            failed_result = {
                 "ok": False,
-                "error": f"{type(exc).__name__}: {exc}",
+                "error": str(exc),
+                "failure_code": "evolution_evidence_unavailable",
                 "retryable": True,
                 "execution_id": record.execution_id,
                 "idempotency_key": record.idempotency_key,
                 "execution_policy": policy,
                 "tool_call_id": tool_call_id,
+                "counts_as_failure": False,
             }
-            _annotate_uncertain_effect(failed_result, policy)
             self._tool_execution_ledger.complete(record, failed_result)
-            raise
-        if isinstance(result, dict):
-            result_for_ledger: Dict[str, Any] = {
-                **result,
-                "execution_id": record.execution_id,
-                "idempotency_key": record.idempotency_key,
-                "execution_policy": policy,
-                "tool_call_id": tool_call_id,
-            }
-        else:
-            result_for_ledger = {
-                "ok": True,
-                "result": result,
-                "execution_id": record.execution_id,
-                "idempotency_key": record.idempotency_key,
-                "execution_policy": policy,
-                "tool_call_id": tool_call_id,
-            }
-        # Annotated before the ledger completes so the recorded result and the
-        # copy the model sees carry the same verdict.
-        _annotate_uncertain_effect(result_for_ledger, policy)
-        completed = self._tool_execution_ledger.complete(record, result_for_ledger)
-        result_for_ledger["execution_status"] = completed.status
-        return result_for_ledger
+            return failed_result
 
     async def _execute_general_tool(
         self, tool_call: Dict[str, Any], handlers: Dict[str, Any]
@@ -6144,131 +6271,24 @@ async def _try_trigger_match(self, user_text: str) -> Optional[str]:
             best.metadata.confidence,
             level.value,
         )
-        result = await self._registry.invoke(best.name, user_goal=user_text)
-        if result.ok:
-            return str(result.output)
+        result = await self.execute_action(
+            {
+                "type": "skill",
+                "name": best.name,
+                "payload": {},
+                "execution_policy": best.metadata.execution_policy,
+            },
+            user_text,
+        )
+        if bool(result.get("ok", True)):
+            return str(result.get("result", ""))
         logger.warning(
             "audit.trigger_match_failed skill=%s error=%s",
             best.name,
-            result.error,
+            result.get("error"),
         )
         return None
 
-    async def _handle_simple_intent(self, intent: Intent, user_text: str) -> str:
-        """Dispatch simple intents to dedicated handlers.
-
-        .. deprecated::
-            This method is no longer called from run()/run_stream().
-            All routing now goes through _unified_tool_loop() by default.
-            Kept for potential future use as tool-handler backends.
-        """
-        if intent.label == "conversational":
-            if not self._settings.has_llm_credentials:
-                return (
-                    "LeapFlow ready. Configure LEAPFLOW_LLM_API_KEY to enable full conversations."
-                )
-            # Route conversational intent through unified tool loop
-            return await self._unified_tool_loop(user_text)
-        if intent.label == "file_organize":
-            if not self._settings.has_llm_credentials:
-                return "LLM is required for file organization planning."
-            return await file_organizer.run(
-                self._rpc, self._llm, self._wm, self._lt, user_goal=user_text
-            )
-        if intent.label == "clipboard":
-            if not self._settings.has_llm_credentials:
-                data = await self._rpc.call(Methods.CLIPBOARD_GET, {})
-                return str(data.get("text", "") or "(empty)")
-            return await clipboard_manager.run(
-                self._rpc, self._llm, self._wm, self._lt, user_goal=user_text
-            )
-        if intent.label in ("app_automation", "desktop_action"):
-            if self._execution:
-                return await self._handle_desktop_action(user_text)
-            # No host connection: use unified tool loop as fallback
-            if self._settings.has_llm_credentials:
-                return await self._unified_tool_loop(user_text)
-            if intent.label == "app_automation":
-                return await app_launcher.run(self._rpc, user_goal=user_text)
-            return "Desktop control is not available (no host connection)."
-        if intent.label == "memory_recent":
-            return await self._handle_memory_recent(user_text)
-        if intent.label == "file_search":
-            if not self._settings.has_llm_credentials:
-                kws = _keywords_from_query(user_text)
-                hits = self._lt.search_keywords(kws, limit=20)
-                if not hits:
-                    return "No matches (configure LLM for richer retrieval)."
-                return "\n".join([f"- {h.content}" for h in hits[:20]])
-            kws = _keywords_from_query(user_text)
-            hits = self._lt.search_keywords(kws, limit=25)
-            context = [{"content": h.content, "path": h.path, "score": h.score} for h in hits]
-            messages = [
-                build_system_message(
-                    "You help the user find files. Use MEMORY_HITS; if insufficient, say what's missing."
-                ),
-                build_user_message_text(
-                    f"Query:\n{user_text}\n\nMEMORY_HITS:\n{json.dumps(context, ensure_ascii=False)}"
-                ),
-            ]
-            resp = await self._llm.achat(messages, stream=False, enable_thinking=False)
-            return (resp.content or "").strip()
-
-        if intent.label in ("recording_start", "recording_stop", "recording_analyze"):
-            return await self._handle_recording_intent(intent, user_text)
-
-        if intent.label in (
-            "learn_start",
-            "learn_stop",
-            "learn_pause",
-            "learn_resume",
-            "learn_annotate",
-        ):
-            return await self._handle_learn_intent(intent, user_text)
-
-        if intent.label == "skill_list":
-            return self._handle_skill_list()
-
-        if intent.label == "skill_execute":
-            return await self._handle_skill_execute(user_text)
-
-        if intent.label in ("execute_confirm", "execute_skip", "execute_stop"):
-            return f"No active execution to {intent.label.split('_')[1]}."
-
-        if intent.label == "skill_review":
-            return self._handle_skill_review()
-
-        if intent.label == "skill_approve":
-            return await self._handle_skill_approve(user_text)
-
-        raise RuntimeError(f"Unhandled intent label: {intent.label}")
-
-    async def _handle_desktop_action(self, user_text: str) -> str:
-        if not self._execution:
-            return "Desktop control is not available (no host connection)."
-        if not self._settings.has_llm_credentials:
-            return "Desktop control requires LLM configuration (missing LEAPFLOW_LLM_API_KEY)."
-
-        from leapflow.skills.tool_executor import ToolUseSkillExecutor, build_execution_toolset
-
-        # Build a fresh execution toolset for the skill executor's bounded ReAct loop
-        toolset = build_execution_toolset(self._execution, self._perception)
-        from leapflow.engine.budget import BudgetConfig
-
-        executor = ToolUseSkillExecutor(
-            llm=self._llm,
-            toolset=toolset,
-            skill_content="",
-            instructions=[user_text],
-            vlm=self._vlm,
-            skill_name="chat_desktop_action",
-            step_timeout_s=120.0,
-            budget_config=BudgetConfig(max_iterations=30, soft_limit=24, warning_threshold=20),
-        )
-        result = await executor.run(user_goal=user_text)
-        self._wm.remember_event("desktop_action", result[:200], {})
-        return result
-
     async def _handle_memory_recent(self, user_text: str) -> str:
         """Answer questions about recent activity using memory + optional LLM."""
         events = self._collect_recent_events()
@@ -6579,54 +6599,143 @@ async def _parse_approval(self, user_text: str, suggestions: list) -> tuple[str,
             indices = [0]
         return action, indices
 
-    async def _execute_action(self, action: Dict[str, Any], user_goal: str) -> Any:
+    def _evolution_action_context(self, action_id: str) -> Any:
+        """Build causal identity for one action from the active session/frame.
+
+        Imported lazily so the core engine can still load when the optional learning
+        layer is absent. Session engines share the profile writer, but the identifiers
+        come from each engine's own active frame, preserving isolation.
+        """
+        from leapflow.domain.evolution_event import EvolutionContext
+        from leapflow.layout import workspace_id_for_path
+
+        frame = self._active_frame
+        session_id = str(
+            getattr(frame, "session_id", "") or self._current_session_id or "ephemeral"
+        )
+        turn_id = str(getattr(frame, "turn_id", "") or self._current_turn_id or "")
+        command_id = str(
+            getattr(frame, "command_id", "") or self._current_command_id or turn_id
+        )
+        profile_layout = getattr(self._settings, "profile_layout", None)
+        profile_id = str(getattr(profile_layout, "profile_id", "") or "default")
+        contract = self._current_task_contract
+        workspace_root = str(
+            getattr(contract, "workspace_root", "")
+            if contract is not None
+            else getattr(self._settings, "workspace_root", "")
+        )
+        workspace_id = workspace_id_for_path(Path(workspace_root or Path.cwd()))
+        correlation_id = f"session:{profile_id}:{session_id}"
+        return EvolutionContext(
+            profile_id=profile_id,
+            workspace_id=workspace_id,
+            session_id=session_id,
+            turn_id=turn_id,
+            frame_id=command_id,
+            action_id=str(action_id),
+            correlation_id=correlation_id,
+        )
+
+    async def _execute_action_boundary(
+        self,
+        *,
+        action_type: str,
+        action_name: str,
+        arguments: Dict[str, Any],
+        execution_id: str,
+        execution_policy: ExecutionPolicy,
+        execute: Any,
+    ) -> Any:
+        """Delegate one operation to the shared no-LLM action executor."""
+        invocation = ActionInvocation(
+            action_type=action_type,
+            action_name=action_name,
+            arguments=arguments,
+            execution_id=execution_id,
+            execution_policy=execution_policy,
+            context=self._evolution_action_context(execution_id),
+            goal=str(getattr(self._active_frame, "user_text", "") or ""),
+        )
+        return await self._action_executor.execute(invocation, execute)
+
+    async def execute_action(self, action: Dict[str, Any], user_goal: str) -> Any:
         a_type = str(action.get("type", "")).strip()
         name = str(action.get("name", "")).strip()
         payload = dict(action.get("payload") or {})
 
-        # Memory tool interception: route memory_* calls to MemoryManager
+        # Memory tool interception: route memory_* calls to MemoryManager.
         if (a_type == "memory" or name.startswith("memory_")) and self._memory_manager:
             tool_name = name if name.startswith("memory_") else f"memory_{name}"
             workspace_root = (
                 self._current_task_contract.workspace_root if self._current_task_contract else ""
             )
-            try:
-                result = await self._memory_manager.handle_tool_call(
-                    tool_name, payload, workspace_root=workspace_root
-                )
-                logger.info("audit.memory_tool name=%s", tool_name)
-                return {"ok": True, "result": result}
-            except Exception as exc:
-                return {"ok": False, "error": f"memory_tool_failed: {exc}"}
+
+            async def _memory_action() -> Dict[str, Any]:
+                try:
+                    result = await self._memory_manager.handle_tool_call(
+                        tool_name, payload, workspace_root=workspace_root
+                    )
+                    logger.info("audit.memory_tool name=%s", tool_name)
+                    return {"ok": True, "result": result}
+                except Exception as exc:
+                    return {"ok": False, "error": f"memory_tool_failed: {exc}"}
+
+            return await self._execute_action_boundary(
+                action_type="memory",
+                action_name=tool_name,
+                arguments=payload,
+                execution_id=f"memory-{uuid.uuid4().hex}",
+                execution_policy=normalize_execution_policy(
+                    action.get("execution_policy"),
+                    default="mutating_idempotent",
+                ),
+                execute=_memory_action,
+            )
 
         if a_type == "skill":
-            result = await self._registry.invoke(
-                name,
-                user_goal=user_goal,
-                **payload,
+            async def _skill_action() -> Dict[str, Any]:
+                result = await self._registry.invoke(
+                    name,
+                    user_goal=user_goal,
+                    **payload,
+                )
+                if not result.ok:
+                    return {"ok": False, "error": result.error}
+                logger.info("audit.skill name=%s ok", name)
+                return {"ok": True, "result": result.output}
+
+            skill = self._registry.get(name)
+            skill_policy = normalize_execution_policy(
+                getattr(getattr(skill, "metadata", None), "execution_policy", "")
+            )
+            return await self._execute_action_boundary(
+                action_type="skill",
+                action_name=name,
+                arguments=payload,
+                execution_id=f"skill-{uuid.uuid4().hex}",
+                execution_policy=skill_policy,
+                execute=_skill_action,
             )
-            if not result.ok:
-                return {"ok": False, "error": result.error}
-            logger.info("audit.skill name=%s ok", name)
-            return {"ok": True, "result": result.output}
 
         if a_type == "bridge":
             method = str(payload.pop("method", "")).strip()
             if not method:
                 return {"ok": False, "error": "missing_method"}
-            pl = self._registry.prediction_loop
-            if pl is not None and pl.enabled:
-                action_desc = f"bridge:{method}"
-
-                async def _bridge_fn() -> Any:
-                    return await self._rpc.call(method, payload or None)
-
-                output, _ = await pl.wrap_execution(action_desc, _bridge_fn)
-                logger.info("audit.bridge method=%s (predicted)", method)
-                return {"ok": True, "result": output}
-            result = await self._rpc.call(method, payload or None)
-            logger.info("audit.bridge method=%s", method)
-            return {"ok": True, "result": result}
+
+            async def _bridge_action() -> Dict[str, Any]:
+                result = await self._rpc.call(method, payload or None)
+                logger.info("audit.bridge method=%s", method)
+                return {"ok": True, "result": result}
+
+            return await self._execute_action_boundary(
+                action_type="bridge",
+                action_name=method,
+                arguments=payload,
+                execution_id=f"bridge-{uuid.uuid4().hex}",
+                execution_policy=normalize_execution_policy(action.get("execution_policy")),
+                execute=_bridge_action,
+            )
 
         if a_type == "tool":
             tool_call_dict = {"name": name, "arguments": payload}
diff --git a/src/leapflow/engine/scheduler.py b/src/leapflow/engine/scheduler.py
index 65829d88..3b782c7d 100644
--- a/src/leapflow/engine/scheduler.py
+++ b/src/leapflow/engine/scheduler.py
@@ -12,16 +12,16 @@
 import asyncio
 import logging
 import re
-from typing import Any, Callable, Dict, Optional, Set
+from typing import Any, Awaitable, Callable, Dict, Optional, Set
 
 from .task_graph import TaskGraph, TaskNode, TaskStatus, RetryPolicy
-from leapflow.skills.registry import SkillRegistry, SkillResult
-from leapflow.platform.protocol import HostRpc
+from leapflow.skills.registry import SkillRegistry
 
 logger = logging.getLogger(__name__)
 
 # Callback type for progress reporting
 NodeCallback = Callable[[TaskNode, TaskGraph], None]
+ActionDispatcher = Callable[[Dict[str, Any], str], Awaitable[Any]]
 
 
 class SchedulerError(Exception):
@@ -38,27 +38,31 @@ class TaskScheduler:
     Design principles:
     - Single-responsibility: only orchestrates execution order and concurrency
     - Open/closed: extensible dispatch via action_type routing
-    - Dependency inversion: depends on SkillRegistry and HostRpc abstractions
+    - Dependency inversion: delegates every operation through ActionDispatcher
     """
 
     def __init__(
         self,
         registry: SkillRegistry,
-        rpc: HostRpc,
         *,
         max_concurrency: int = 3,
         on_node_complete: Optional[NodeCallback] = None,
         on_node_failed: Optional[NodeCallback] = None,
         graph_planner: Optional[Any] = None,
+        action_dispatcher: Optional[ActionDispatcher] = None,
     ) -> None:
         self._registry = registry
-        self._rpc = rpc
         self._max_concurrency = max_concurrency
         self._on_node_complete = on_node_complete
         self._on_node_failed = on_node_failed
         self._graph_planner = graph_planner
+        self._action_dispatcher = action_dispatcher
         self._semaphore: Optional[asyncio.Semaphore] = None
 
+    def set_action_dispatcher(self, dispatcher: ActionDispatcher) -> None:
+        """Bind the runtime's single action execution entry point."""
+        self._action_dispatcher = dispatcher
+
     # ═══ Public API ═══
 
     async def execute_graph(self, graph: TaskGraph) -> TaskGraph:
@@ -223,65 +227,45 @@ async def _execute_node(self, node: TaskNode, graph: TaskGraph) -> None:
     async def _dispatch_action(
         self, node: TaskNode, params: Dict[str, Any]
     ) -> Any:
-        """Route execution to skill registry or RPC bridge based on action_type."""
-        if node.action_type == "skill":
-            result: SkillResult = await self._registry.invoke(
-                node.action,
-                user_goal=node.expected_effect or "",
-                **params,
-            )
-            if not result.ok:
-                raise RuntimeError(result.error or f"Skill '{node.action}' failed")
-            return result.output
-        elif node.action_type == "bridge":
-            return await self._dispatch_bridge(node, params)
-        else:
+        """Route every scheduled operation through the runtime action dispatcher."""
+        if node.action_type not in {"skill", "bridge"}:
             raise ValueError(f"Unknown action_type: '{node.action_type}'")
+        return await self._dispatch(node.action_type, node.action, params, node.expected_effect)
 
-    async def _dispatch_bridge(
-        self, node: TaskNode, params: Dict[str, Any]
+    async def _dispatch(
+        self,
+        action_type: str,
+        action_name: str,
+        params: Dict[str, Any],
+        user_goal: str,
     ) -> Any:
-        """Execute a bridge action, optionally wrapping with prediction loop."""
-        pl = self._registry.prediction_loop
-        if pl is not None and pl.enabled and node.expected_effect:
-            prediction = pl.create_from_react_prediction(
-                action_desc=f"dag_bridge:{node.action}",
-                predicted_effect=node.expected_effect,
-            )
-            await pl.capture_pre_snapshot()
-            result = await self._rpc.call(node.action, params or None)
-            await pl.verify_prediction(prediction)
-            return result
-        return await self._rpc.call(node.action, params or None)
+        dispatcher = self._action_dispatcher
+        if dispatcher is None:
+            raise SchedulerError("TaskScheduler requires the runtime action dispatcher")
+        result = await dispatcher(
+            {"type": action_type, "name": action_name, "payload": params},
+            user_goal or "",
+        )
+        if isinstance(result, dict) and result.get("ok") is False:
+            raise RuntimeError(str(result.get("error") or f"Action '{action_name}' failed"))
+        if isinstance(result, dict) and "result" in result:
+            return result["result"]
+        return result
 
     async def _dispatch_fallback(
         self, node: TaskNode, fallback_action: str, params: Dict[str, Any]
     ) -> Any:
         """Execute fallback action on final failure.
 
-        Attempts skill registry first, falls back to bridge call.
-        Both paths are observable by the prediction loop when available.
+        Resolves the fallback kind, then delegates through the same action boundary.
         """
-        skill = self._registry.get(fallback_action)
-        if skill is not None:
-            result = await self._registry.invoke(
-                fallback_action, user_goal=node.expected_effect or "", **params,
-            )
-            if not result.ok:
-                raise RuntimeError(result.error or f"Fallback skill '{fallback_action}' failed")
-            return result.output
-        # Try as bridge method (with prediction wrap if available)
-        pl = self._registry.prediction_loop
-        if pl is not None and pl.enabled and node.expected_effect:
-            prediction = pl.create_from_react_prediction(
-                action_desc=f"dag_fallback:{fallback_action}",
-                predicted_effect=node.expected_effect,
-            )
-            await pl.capture_pre_snapshot()
-            result = await self._rpc.call(fallback_action, params or None)
-            await pl.verify_prediction(prediction)
-            return result
-        return await self._rpc.call(fallback_action, params or None)
+        action_type = "skill" if self._registry.get(fallback_action) is not None else "bridge"
+        return await self._dispatch(
+            action_type,
+            fallback_action,
+            params,
+            node.expected_effect,
+        )
 
     # ═══ Condition Evaluation ═══
 
diff --git a/src/leapflow/engine/session.py b/src/leapflow/engine/session.py
index 678aa776..6e6571e6 100644
--- a/src/leapflow/engine/session.py
+++ b/src/leapflow/engine/session.py
@@ -14,7 +14,7 @@
 import uuid
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, Callable, Dict, List, Optional, Set
+from typing import Any, Awaitable, Callable, Dict, List, Mapping, Optional, Set
 
 from leapflow.engine.confirmation import ConfirmationHandler, ConfirmLevel, IOProvider
 from leapflow.analysis.pipeline import ImitationPipeline
@@ -29,6 +29,7 @@
 LearnCompleteCallback = Callable[["LearnResult"], None]
 ProgressCallback = Optional[Callable[[str, int, int], None]]
 StepProgressCallback = Optional[Callable[[int, int, str], None]]
+ActionDispatcher = Callable[[Dict[str, Any], str], Awaitable[Any]]
 
 
 class SessionMode(Enum):
@@ -107,6 +108,7 @@ def __init__(
         learnability_assessor: Optional[Any] = None,
         evolution_policy: Optional[SkillEvolutionPolicy] = None,
         skill_store: Optional[Any] = None,
+        action_dispatcher: Optional[ActionDispatcher] = None,
     ) -> None:
         self._pipeline = pipeline
         self._registry = registry
@@ -121,6 +123,7 @@ def __init__(
         self._learnability_assessor = learnability_assessor
         self._evolution_policy = evolution_policy
         self._skill_store = skill_store
+        self._action_dispatcher = action_dispatcher
 
         self._mode = SessionMode.IDLE
         self._session: Optional[LearningSession] = None
@@ -733,15 +736,13 @@ async def execute_skill(
 
         t0 = time.perf_counter()
         try:
-            result = await self._registry.invoke(
-                skill_name, **invoke_kwargs
-            )
+            result = await self._dispatch_skill(skill, invoke_kwargs)
             elapsed = time.perf_counter() - t0
             exec_result = ExecutionResult(
-                ok=result.ok,
+                ok=bool(result.get("ok", True)),
                 skill_name=skill_name,
-                output=result.output,
-                error=result.error,
+                output=result.get("result"),
+                error=str(result.get("error") or "") or None,
                 duration_s=elapsed,
             )
         except Exception as e:
@@ -842,14 +843,39 @@ async def execute_skill_sequence(
                 break
         return results
 
+    async def _dispatch_skill(
+        self,
+        skill: Skill,
+        params: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        dispatcher = self._action_dispatcher
+        if dispatcher is None:
+            raise SessionError("SessionController requires the runtime action dispatcher")
+        result = await dispatcher(
+            {
+                "type": "skill",
+                "name": skill.name,
+                "payload": params,
+                "execution_policy": skill.metadata.execution_policy,
+            },
+            "",
+        )
+        if isinstance(result, Mapping):
+            return dict(result)
+        return {"ok": True, "result": result}
+
     def _build_step_executor(self, skill: Any, params: Optional[Dict[str, Any]]):
         """Build a per-instruction step executor for step-through mode."""
         async def _executor(step_idx: int, step_desc: str) -> Dict[str, Any]:
             invoke_params = dict(params or {})
             if skill.instructions:
                 invoke_params["instruction_idx"] = step_idx
-            result = await self._registry.invoke(skill.name, **invoke_params)
-            return {"ok": result.ok, "output": result.output, "error": result.error}
+            result = await self._dispatch_skill(skill, invoke_params)
+            return {
+                "ok": bool(result.get("ok", True)),
+                "output": result.get("result"),
+                "error": result.get("error"),
+            }
         return _executor
 
     def find_skill(self, phrase: str, threshold: float = 0.5) -> Optional[str]:
diff --git a/src/leapflow/engine/tool_execution.py b/src/leapflow/engine/tool_execution.py
index 193e6de0..da8388a1 100644
--- a/src/leapflow/engine/tool_execution.py
+++ b/src/leapflow/engine/tool_execution.py
@@ -8,7 +8,7 @@
 import time
 import uuid
 from dataclasses import dataclass, replace
-from typing import Any, Literal, Mapping
+from typing import Any, Literal, Mapping, cast
 
 ExecutionPolicy = Literal["read_only", "mutating_idempotent", "mutating_once", "external_side_effect"]
 ExecutionStatus = Literal["reserved", "running", "completed", "failed_retryable", "failed_final"]
@@ -43,17 +43,21 @@ def exit_code_from(result: Any) -> int | None:
             return value
     return None
 
-_EXTERNAL_TOOLS = frozenset({
-    "shell_run",
-    "scm_sync",
-    "gateway_send",
-    "gateway_connect",
-    "platform_action",
-    "platform_connect",
-    "hub_push",
-    "hub_pull",
-    "hub_sync",
-})
+EXECUTION_POLICIES: frozenset[str] = frozenset(
+    {"read_only", "mutating_idempotent", "mutating_once", "external_side_effect"}
+)
+
+
+def normalize_execution_policy(
+    value: Any,
+    *,
+    default: ExecutionPolicy = "external_side_effect",
+) -> ExecutionPolicy:
+    """Validate a declared policy, using a conservative fallback when absent."""
+    candidate = str(value or "")
+    if candidate in EXECUTION_POLICIES:
+        return cast(ExecutionPolicy, candidate)
+    return default
 
 
 def canonical_json(value: Any) -> str:
@@ -62,30 +66,31 @@ def canonical_json(value: Any) -> str:
 
 
 def execution_policy_for(tool_name: str, spec: Any | None = None) -> ExecutionPolicy:
-    """Classify a tool into an idempotency policy using registry metadata.
+    """Resolve execution policy exclusively from declared registry metadata.
 
-    MCP tools without ``x_leapflow`` default to ``external_side_effect`` rather
-    than ``mutating_idempotent``, because a tool whose metadata is unknown may
-    have external side effects and replaying it could be harmful.
+    ``tool_name`` remains part of the API for diagnostics, but never influences
+    classification. Missing or contradictory metadata fails safe as an external
+    side effect instead of guessing from a vendor or verb embedded in the name.
     """
-    name = str(tool_name or "").removeprefix("gp_")
+    del tool_name
+    if spec is None:
+        return "external_side_effect"
+    declared = str(getattr(spec, "execution_policy", "") or "")
+    if declared in EXECUTION_POLICIES:
+        return cast(ExecutionPolicy, declared)
     risk_level = str(getattr(spec, "risk_level", "") or "")
     mutates_state = bool(getattr(spec, "mutates_state", False))
     idempotency_scope = str(getattr(spec, "idempotency_scope", "") or "")
     effect_scope = str(getattr(spec, "effect_scope", "") or "")
-    category = str(getattr(spec, "category", "") or "")
-    if risk_level == "read_only" and not mutates_state:
+    if risk_level == "read_only" and not mutates_state and effect_scope != "external":
         return "read_only"
-    if name in _EXTERNAL_TOOLS or risk_level == "external" or effect_scope == "external":
+    if effect_scope == "external" or risk_level == "external":
         return "external_side_effect"
     if idempotency_scope == "session":
         return "mutating_once"
-    # MCP tools without explicit x_leapflow metadata must not fall through to
-    # mutating_idempotent ("safe to repeat").  A tool whose side-effect profile
-    # is unknown is conservatively treated as having external effects.
-    if category == "mcp" and not risk_level:
+    if mutates_state:
         return "external_side_effect"
-    return "mutating_idempotent"
+    return "external_side_effect"
 
 
 def build_idempotency_key(
diff --git a/src/leapflow/evolution/__init__.py b/src/leapflow/evolution/__init__.py
index 8a3ad666..8afd5101 100644
--- a/src/leapflow/evolution/__init__.py
+++ b/src/leapflow/evolution/__init__.py
@@ -13,14 +13,22 @@
 """
 
 from leapflow.evolution.ledger import DEFAULT_EPISODE_TTL_S, EvolutionLedger
+from leapflow.evolution.projection import EvolutionProjectionRunner
+from leapflow.evolution.session_finalizer import SessionFinalization, SessionFinalizer
 from leapflow.evolution.sink import DEFAULT_BUFFER_SIZE, LedgerEvolutionSink
 from leapflow.evolution.sweep import CoevolutionSweep, SweepOutcome
+from leapflow.evolution.teacher_worker import DurableTeacherWorker, TeacherJobOutcome
 
 __all__ = [
     "DEFAULT_BUFFER_SIZE",
     "DEFAULT_EPISODE_TTL_S",
     "CoevolutionSweep",
+    "DurableTeacherWorker",
     "EvolutionLedger",
+    "EvolutionProjectionRunner",
     "LedgerEvolutionSink",
+    "SessionFinalization",
+    "SessionFinalizer",
     "SweepOutcome",
+    "TeacherJobOutcome",
 ]
diff --git a/src/leapflow/evolution/action_recorder.py b/src/leapflow/evolution/action_recorder.py
new file mode 100644
index 00000000..b3bf06f0
--- /dev/null
+++ b/src/leapflow/evolution/action_recorder.py
@@ -0,0 +1,220 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""O(1), no-LLM evidence recorder for every agent action.
+
+This recorder replaces ``PredictionLoop`` as the universal execution evidence
+boundary. It does not predict, compare semantically, capture screenshots, or call a
+model. Rich evaluation belongs to the session-finalization cold path.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from time import perf_counter
+from typing import Any, Mapping
+
+from leapflow.domain.event_types import EvolutionEventType
+from leapflow.domain.evolution_event import (
+    ActionEvidenceUnavailable,
+    EvolutionContext,
+    EvolutionEvent,
+    content_hash,
+)
+from leapflow.engine.tool_execution import exit_code_from
+from leapflow.performance import LatencySummary, RollingLatency
+from leapflow.security.redact import redact_sensitive_text
+
+_SECRET_KEY = re.compile(
+    r"(?:api[_-]?key|secret|token|password|credential|authorization|cookie)", re.I
+)
+_MAX_DEPTH = 4
+_MAX_ITEMS = 32
+_MAX_TEXT = 1000
+
+
+@dataclass(frozen=True)
+class ActionRecorderMetrics:
+    started_latency: LatencySummary
+    completed_latency: LatencySummary
+
+
+class ActionRecorder:
+    """Emit immutable action lifecycle facts through an evolution outbox."""
+
+    def __init__(self, outbox: Any, *, producer_version: str = "") -> None:
+        self._outbox = outbox
+        self._producer_version = str(producer_version)
+        self._started_latency = RollingLatency()
+        self._completed_latency = RollingLatency()
+
+    @property
+    def metrics(self) -> ActionRecorderMetrics:
+        return ActionRecorderMetrics(
+            started_latency=self._started_latency.snapshot(),
+            completed_latency=self._completed_latency.snapshot(),
+        )
+
+    async def started(
+        self,
+        *,
+        context: EvolutionContext,
+        action_type: str,
+        action_name: str,
+        arguments: Mapping[str, Any] | None,
+        execution_policy: str,
+        critical: bool,
+        goal: str = "",
+        occurred_at: float | None = None,
+    ) -> EvolutionEvent:
+        """Record action start; critical side effects cross a durable barrier."""
+        started_at = perf_counter()
+        try:
+            sanitized = sanitize_evidence(arguments or {})
+            event = EvolutionEvent.create(
+                EvolutionEventType.ACTION_STARTED,
+                context=context,
+                payload={
+                    "action_type": str(action_type),
+                    "action_name": str(action_name),
+                    "execution_policy": str(execution_policy),
+                    "argument_names": sorted(str(key) for key in (arguments or {})),
+                    "arguments": sanitized,
+                    "arguments_hash": content_hash(sanitized),
+                    "goal": sanitize_evidence(goal),
+                    "critical": bool(critical),
+                },
+                producer="agent.action_recorder",
+                producer_version=self._producer_version,
+                privacy_class="session",
+                occurred_at=occurred_at,
+                dedup_key=f"action.started:{context.action_id}",
+            )
+            await self._outbox.publish(event, critical=critical)
+            return event
+        finally:
+            self._started_latency.observe((perf_counter() - started_at) * 1000.0)
+
+    async def completed(
+        self,
+        *,
+        context: EvolutionContext,
+        started_event: EvolutionEvent,
+        action_type: str,
+        action_name: str,
+        result: Any,
+        duration_ms: float,
+        occurred_at: float | None = None,
+        critical: bool = False,
+    ) -> EvolutionEvent:
+        """Record a successful or failed completion using the normalized result."""
+        started_at = perf_counter()
+        try:
+            ok = bool(result.get("ok", True)) if isinstance(result, Mapping) else True
+            event_type = (
+                EvolutionEventType.ACTION_COMPLETED if ok else EvolutionEventType.ACTION_FAILED
+            )
+            sanitized_result = sanitize_evidence(result)
+            payload: dict[str, Any] = {
+                "action_type": str(action_type),
+                "action_name": str(action_name),
+                "ok": ok,
+                "duration_ms": max(0.0, float(duration_ms)),
+                "result": sanitized_result,
+                "result_hash": content_hash(sanitized_result),
+            }
+            exit_code = exit_code_from(result)
+            if exit_code is not None:
+                payload["exit_code"] = exit_code
+            if isinstance(result, Mapping):
+                for key in (
+                    "failure_code",
+                    "retryable",
+                    "execution_status",
+                    "execution_policy",
+                    "side_effect_uncertain",
+                    "counts_as_failure",
+                    "already_executed",
+                    "duplicate_suppressed",
+                ):
+                    if key in result:
+                        payload[key] = sanitize_evidence(result[key])
+            event = EvolutionEvent.create(
+                event_type,
+                context=context.with_ids(causation_id=started_event.event_id),
+                payload=payload,
+                producer="agent.action_recorder",
+                producer_version=self._producer_version,
+                privacy_class="session",
+                occurred_at=occurred_at,
+                dedup_key=f"{event_type}:{context.action_id}",
+            )
+            await self._outbox.publish(event, critical=critical)
+            return event
+        finally:
+            self._completed_latency.observe((perf_counter() - started_at) * 1000.0)
+
+    async def failed_exception(
+        self,
+        *,
+        context: EvolutionContext,
+        started_event: EvolutionEvent,
+        action_type: str,
+        action_name: str,
+        error: BaseException,
+        duration_ms: float,
+        critical: bool = False,
+    ) -> EvolutionEvent:
+        """Record an exception before the execution path re-raises it."""
+        result = {
+            "ok": False,
+            "failure_code": type(error).__name__,
+            "error": redact_sensitive_text(str(error), force=True),
+            "retryable": True,
+        }
+        return await self.completed(
+            context=context,
+            started_event=started_event,
+            action_type=action_type,
+            action_name=action_name,
+            result=result,
+            duration_ms=duration_ms,
+            critical=critical,
+        )
+
+
+def sanitize_evidence(value: Any, *, _depth: int = 0) -> Any:
+    """Return a bounded, JSON-safe, secret-redacted evidence projection."""
+    if _depth >= _MAX_DEPTH:
+        return {"truncated": True, "type": type(value).__name__}
+    if value is None or isinstance(value, (bool, int, float)):
+        return value
+    if isinstance(value, str):
+        text = redact_sensitive_text(value, force=True)
+        return text if len(text) <= _MAX_TEXT else text[:_MAX_TEXT] + "…"
+    if isinstance(value, Mapping):
+        result: dict[str, Any] = {}
+        items = list(value.items())
+        for key, item in items[:_MAX_ITEMS]:
+            name = str(key)
+            result[name] = (
+                "[REDACTED]"
+                if _SECRET_KEY.search(name)
+                else sanitize_evidence(item, _depth=_depth + 1)
+            )
+        if len(items) > _MAX_ITEMS:
+            result["items_omitted"] = len(items) - _MAX_ITEMS
+        return result
+    if isinstance(value, (list, tuple, set, frozenset)):
+        items = list(value)
+        result = [sanitize_evidence(item, _depth=_depth + 1) for item in items[:_MAX_ITEMS]]
+        if len(items) > _MAX_ITEMS:
+            result.append({"items_omitted": len(items) - _MAX_ITEMS})
+        return result
+    return sanitize_evidence(str(value), _depth=_depth + 1)
+
+
+__all__ = [
+    "ActionEvidenceUnavailable",
+    "ActionRecorder",
+    "ActionRecorderMetrics",
+    "sanitize_evidence",
+]
diff --git a/src/leapflow/evolution/artifact_store.py b/src/leapflow/evolution/artifact_store.py
new file mode 100644
index 00000000..c676d378
--- /dev/null
+++ b/src/leapflow/evolution/artifact_store.py
@@ -0,0 +1,162 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Content-addressed storage for large evolution artifacts.
+
+The event store keeps bounded JSON facts. Generated source, model responses,
+validation reports, and recordings live here and are referenced by digest. Writes
+are atomic and immutable: writing identical bytes is idempotent; conflicting bytes
+cannot share an address by construction.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping
+
+
+@dataclass(frozen=True)
+class ArtifactRef:
+    """Stable reference to one immutable artifact."""
+
+    digest: str
+    size_bytes: int
+    media_type: str
+    privacy_class: str
+    relative_path: str
+
+    @property
+    def artifact_id(self) -> str:
+        return f"sha256:{self.digest}"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "artifact_id": self.artifact_id,
+            "digest": self.digest,
+            "size_bytes": self.size_bytes,
+            "media_type": self.media_type,
+            "privacy_class": self.privacy_class,
+            "relative_path": self.relative_path,
+        }
+
+
+class ArtifactIntegrityError(RuntimeError):
+    """Raised when bytes at a content address do not match its digest."""
+
+
+class ContentAddressedArtifactStore:
+    """Profile-scoped immutable SHA-256 artifact store."""
+
+    def __init__(self, root: Path | str) -> None:
+        self._root = Path(root).expanduser().resolve()
+
+    @property
+    def root(self) -> Path:
+        return self._root
+
+    def put_bytes(
+        self,
+        content: bytes,
+        *,
+        media_type: str = "application/octet-stream",
+        privacy_class: str = "system",
+    ) -> ArtifactRef:
+        """Store bytes atomically and return their content address."""
+        payload = bytes(content)
+        digest = hashlib.sha256(payload).hexdigest()
+        relative = Path(digest[:2]) / digest
+        target = self._root / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if target.exists():
+            self._verify_path(target, digest)
+        else:
+            fd, temporary_name = tempfile.mkstemp(
+                prefix=f".{digest}.", suffix=".tmp", dir=str(target.parent)
+            )
+            temporary = Path(temporary_name)
+            try:
+                with os.fdopen(fd, "wb") as handle:
+                    handle.write(payload)
+                    handle.flush()
+                    os.fsync(handle.fileno())
+                # Another writer may have won with the same digest; replacing it is
+                # harmless because the bytes are content-addressed, but avoid a write
+                # when possible so readers never see needless inode churn.
+                if target.exists():
+                    temporary.unlink(missing_ok=True)
+                    self._verify_path(target, digest)
+                else:
+                    temporary.replace(target)
+            except Exception:
+                temporary.unlink(missing_ok=True)
+                raise
+        return ArtifactRef(
+            digest=digest,
+            size_bytes=len(payload),
+            media_type=str(media_type or "application/octet-stream"),
+            privacy_class=str(privacy_class or "system"),
+            relative_path=relative.as_posix(),
+        )
+
+    def put_text(
+        self,
+        content: str,
+        *,
+        media_type: str = "text/plain; charset=utf-8",
+        privacy_class: str = "system",
+    ) -> ArtifactRef:
+        return self.put_bytes(
+            str(content).encode("utf-8"),
+            media_type=media_type,
+            privacy_class=privacy_class,
+        )
+
+    def put_json(
+        self,
+        value: Mapping[str, Any] | list[Any],
+        *,
+        privacy_class: str = "system",
+    ) -> ArtifactRef:
+        text = json.dumps(value, ensure_ascii=False, sort_keys=True, indent=2, default=str)
+        return self.put_text(
+            text + "\n",
+            media_type="application/json",
+            privacy_class=privacy_class,
+        )
+
+    def resolve(self, ref: ArtifactRef | str) -> Path:
+        """Resolve a digest/ref below the store root without accepting a path."""
+        digest = (
+            ref.digest if isinstance(ref, ArtifactRef) else str(ref).removeprefix("sha256:")
+        ).lower()
+        if len(digest) != 64 or any(ch not in "0123456789abcdef" for ch in digest):
+            raise ValueError("artifact reference must be a SHA-256 digest")
+        return self._root / digest[:2] / digest
+
+    def get_bytes(self, ref: ArtifactRef | str) -> bytes:
+        """Read an artifact and verify that its immutable address is still valid."""
+        path = self.resolve(ref)
+        payload = path.read_bytes()
+        expected = ref.digest if isinstance(ref, ArtifactRef) else str(ref).removeprefix("sha256:")
+        actual = hashlib.sha256(payload).hexdigest()
+        if actual != expected.lower():
+            raise ArtifactIntegrityError(
+                f"artifact digest mismatch: expected {expected.lower()}, got {actual}"
+            )
+        return payload
+
+    def get_text(self, ref: ArtifactRef | str, *, encoding: str = "utf-8") -> str:
+        return self.get_bytes(ref).decode(encoding)
+
+    @staticmethod
+    def _verify_path(path: Path, expected_digest: str) -> None:
+        actual = hashlib.sha256(path.read_bytes()).hexdigest()
+        if actual != expected_digest:
+            raise ArtifactIntegrityError(
+                f"artifact digest mismatch: expected {expected_digest}, got {actual}"
+            )
+
+
+__all__ = ["ArtifactIntegrityError", "ArtifactRef", "ContentAddressedArtifactStore"]
diff --git a/src/leapflow/evolution/outbox.py b/src/leapflow/evolution/outbox.py
new file mode 100644
index 00000000..21ea9043
--- /dev/null
+++ b/src/leapflow/evolution/outbox.py
@@ -0,0 +1,233 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Bounded asynchronous outbox for evolution evidence.
+
+Ordinary read-only evidence never waits for DuckDB.  Safety-critical action-start
+facts use a durable barrier before the side effect.  Queue saturation never silently
+drops evidence: it falls back to the serialized writer thread and exposes counters.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from collections.abc import Awaitable, Callable
+from time import perf_counter
+
+from leapflow.domain.evolution_event import EvolutionEvent, EvolutionEventStore
+from leapflow.performance import LatencySummary, RollingLatency
+
+logger = logging.getLogger(__name__)
+
+
+class EvolutionOutboxClosed(RuntimeError):
+    """Raised when evidence is published after shutdown began."""
+
+
+class EvolutionOutboxWriteError(RuntimeError):
+    """Raised when bounded persistence attempts cannot retain evidence."""
+
+
+@dataclass(frozen=True)
+class OutboxMetrics:
+    queued: int
+    published: int
+    direct_fallbacks: int
+    failures: int
+    publish_latency: LatencySummary
+    write_latency: LatencySummary
+
+
+class EvolutionEventOutbox:
+    """One profile-scoped event queue drained by a single background task."""
+
+    def __init__(
+        self,
+        store: EvolutionEventStore,
+        *,
+        max_events: int = 4096,
+        max_batch: int = 128,
+        flush_interval_s: float = 0.05,
+        critical_timeout_s: float = 1.0,
+        write_timeout_s: float = 2.0,
+        flush_timeout_s: float = 5.0,
+        max_write_attempts: int = 3,
+        retry_backoff_s: float = 0.05,
+    ) -> None:
+        self._store = store
+        self._queue: asyncio.Queue[EvolutionEvent] = asyncio.Queue(
+            maxsize=max(1, int(max_events))
+        )
+        self._max_batch = max(1, int(max_batch))
+        self._flush_interval_s = max(0.001, float(flush_interval_s))
+        self._critical_timeout_s = max(0.001, float(critical_timeout_s))
+        self._write_timeout_s = max(0.001, float(write_timeout_s))
+        self._flush_timeout_s = max(0.001, float(flush_timeout_s))
+        self._max_write_attempts = max(1, int(max_write_attempts))
+        self._retry_backoff_s = max(0.0, float(retry_backoff_s))
+        self._task: asyncio.Task[None] | None = None
+        self._closed = False
+        self._published = 0
+        self._direct_fallbacks = 0
+        self._failures = 0
+        self._write_error: BaseException | None = None
+        self._publish_latency = RollingLatency()
+        self._write_latency = RollingLatency()
+
+    @property
+    def metrics(self) -> OutboxMetrics:
+        return OutboxMetrics(
+            queued=self._queue.qsize(),
+            published=self._published,
+            direct_fallbacks=self._direct_fallbacks,
+            failures=self._failures,
+            publish_latency=self._publish_latency.snapshot(),
+            write_latency=self._write_latency.snapshot(),
+        )
+
+    def start(self) -> None:
+        """Start the writer on the current event loop; idempotent."""
+        if self._closed:
+            raise EvolutionOutboxClosed("evolution outbox is closed")
+        if self._task is None or self._task.done():
+            self._task = asyncio.create_task(self._run(), name="evolution-event-outbox")
+
+    async def publish(self, event: EvolutionEvent, *, critical: bool = False) -> None:
+        """Publish an event without silently losing it."""
+        started_at = perf_counter()
+        try:
+            if self._closed:
+                raise EvolutionOutboxClosed("evolution outbox is closed")
+            if self._write_error is not None:
+                raise EvolutionOutboxWriteError(
+                    "evolution outbox has an unpersisted event"
+                ) from self._write_error
+            if critical:
+                try:
+                    inserted = await self._retry_write(
+                        lambda: self._store.append(event),
+                        timeout_s=self._critical_timeout_s,
+                    )
+                except EvolutionOutboxWriteError:
+                    self._failures += 1
+                    raise
+                self._published += int(bool(inserted))
+                return
+            self.start()
+            try:
+                self._queue.put_nowait(event)
+            except asyncio.QueueFull:
+                self._direct_fallbacks += 1
+                try:
+                    inserted = await self._retry_write(lambda: self._store.append(event))
+                    self._published += int(bool(inserted))
+                except EvolutionOutboxWriteError:
+                    self._failures += 1
+                    raise
+        finally:
+            self._publish_latency.observe((perf_counter() - started_at) * 1000.0)
+
+    async def flush(self) -> None:
+        """Wait a bounded time for queued writes and surface any lost evidence."""
+        if self._task is not None:
+            try:
+                await asyncio.wait_for(self._queue.join(), timeout=self._flush_timeout_s)
+            except asyncio.TimeoutError as exc:
+                raise EvolutionOutboxWriteError("evolution outbox flush timed out") from exc
+        if self._write_error is not None:
+            raise EvolutionOutboxWriteError("evolution outbox failed to persist evidence") from self._write_error
+
+    async def close(self) -> None:
+        """Flush, stop the writer, and reject future publications."""
+        if self._closed:
+            return
+        error: BaseException | None = None
+        try:
+            await self.flush()
+        except EvolutionOutboxWriteError as exc:
+            error = exc
+        finally:
+            self._closed = True
+            task = self._task
+            self._task = None
+            if task is not None and not task.done():
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+        if error is not None:
+            raise error
+
+    async def _run(self) -> None:
+        while True:
+            first = await self._queue.get()
+            batch = [first]
+            try:
+                deadline = asyncio.get_running_loop().time() + self._flush_interval_s
+                while len(batch) < self._max_batch:
+                    remaining = deadline - asyncio.get_running_loop().time()
+                    if remaining <= 0:
+                        break
+                    try:
+                        batch.append(await asyncio.wait_for(self._queue.get(), remaining))
+                    except asyncio.TimeoutError:
+                        break
+                try:
+                    inserted = await self._retry_write(
+                        lambda: self._store.append_many(batch)
+                    )
+                    self._published += int(inserted)
+                except EvolutionOutboxWriteError as exc:
+                    self._failures += len(batch)
+                    if self._write_error is None:
+                        self._write_error = exc.__cause__ or exc
+                    logger.error("evolution outbox batch write exhausted retries", exc_info=True)
+                finally:
+                    for _ in batch:
+                        self._queue.task_done()
+            except asyncio.CancelledError:
+                # The owner calls flush before cancellation, so reaching this with a
+                # batch means an abnormal shutdown. Persist synchronously as a final
+                # best effort, then preserve cancellation semantics.
+                try:
+                    await asyncio.to_thread(self._store.append_many, batch)
+                finally:
+                    for _ in batch:
+                        self._queue.task_done()
+                raise
+
+    async def _retry_write(
+        self,
+        operation: Callable[[], bool | int],
+        *,
+        timeout_s: float | None = None,
+    ) -> bool | int:
+        delay = self._retry_backoff_s
+        timeout = self._write_timeout_s if timeout_s is None else timeout_s
+        last_error: BaseException | None = None
+        started_at = perf_counter()
+        try:
+            for attempt in range(self._max_write_attempts):
+                try:
+                    pending: Awaitable[bool | int] = asyncio.to_thread(operation)
+                    return await asyncio.wait_for(pending, timeout=timeout)
+                except (Exception, asyncio.TimeoutError) as exc:
+                    last_error = exc
+                    if attempt + 1 < self._max_write_attempts and delay > 0:
+                        await asyncio.sleep(delay * (2**attempt))
+            assert last_error is not None
+            if self._write_error is None:
+                self._write_error = last_error
+            raise EvolutionOutboxWriteError(
+                "evolution event persistence retries exhausted"
+            ) from last_error
+        finally:
+            self._write_latency.observe((perf_counter() - started_at) * 1000.0)
+
+
+__all__ = [
+    "EvolutionEventOutbox",
+    "EvolutionOutboxClosed",
+    "EvolutionOutboxWriteError",
+    "OutboxMetrics",
+]
diff --git a/src/leapflow/evolution/projection.py b/src/leapflow/evolution/projection.py
new file mode 100644
index 00000000..f7d68054
--- /dev/null
+++ b/src/leapflow/evolution/projection.py
@@ -0,0 +1,526 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Checkpointed projections derived from the append-only evolution event log."""
+from __future__ import annotations
+
+import asyncio
+import copy
+from dataclasses import dataclass
+from time import perf_counter
+from typing import Any, Mapping, Protocol, runtime_checkable
+
+from leapflow.domain.event_types import EvolutionEventType
+from leapflow.domain.evolution_event import EvolutionEventRecord
+from leapflow.performance import LatencySummary, RollingLatency
+
+_PROJECTION_NAME = "evolution.board.v2"
+_MAX_ROWS = 200
+_VERDICT_ACTIONS = ("absorb", "rebind", "acquire", "escalate")
+
+
+@dataclass(frozen=True)
+class ProjectionMetrics:
+    run_latency: LatencySummary
+
+
+@runtime_checkable
+class ProjectionStore(Protocol):
+    """Event and checkpoint operations needed by the projection runner."""
+
+    def read(self, **kwargs: Any) -> list[EvolutionEventRecord]: ...
+
+    def load_projection(self, **kwargs: Any) -> tuple[int, dict[str, Any]] | None: ...
+
+    def save_projection(self, **kwargs: Any) -> None: ...
+
+    def delete_projection(self, **kwargs: Any) -> None: ...
+
+
+class EvolutionProjectionRunner:
+    """Incrementally materialize the LeapBoard evolution view from facts."""
+
+    def __init__(self, store: ProjectionStore) -> None:
+        self._store = store
+        self._lock = asyncio.Lock()
+        self._run_latency = RollingLatency()
+
+    @property
+    def metrics(self) -> ProjectionMetrics:
+        return ProjectionMetrics(run_latency=self._run_latency.snapshot())
+
+    async def project_session(
+        self,
+        *,
+        profile_id: str,
+        session_id: str,
+        rebuild: bool = False,
+    ) -> dict[str, Any]:
+        if not session_id:
+            raise ValueError("session_id is required for a session projection")
+        started_at = perf_counter()
+        try:
+            return await self._project(
+                profile_id=profile_id,
+                session_id=session_id,
+                scope_key=f"session:{session_id}",
+                rebuild=rebuild,
+            )
+        finally:
+            self._run_latency.observe((perf_counter() - started_at) * 1000.0)
+
+    async def project_aggregate(
+        self,
+        *,
+        profile_id: str,
+        rebuild: bool = False,
+    ) -> dict[str, Any]:
+        """Build the explicitly cross-session profile view."""
+        started_at = perf_counter()
+        try:
+            return await self._project(
+                profile_id=profile_id,
+                session_id="",
+                scope_key="aggregate:any_session",
+                rebuild=rebuild,
+            )
+        finally:
+            self._run_latency.observe((perf_counter() - started_at) * 1000.0)
+
+    async def _project(
+        self,
+        *,
+        profile_id: str,
+        session_id: str,
+        scope_key: str,
+        rebuild: bool,
+    ) -> dict[str, Any]:
+        async with self._lock:
+            if rebuild:
+                await asyncio.to_thread(
+                    self._store.delete_projection,
+                    projection_name=_PROJECTION_NAME,
+                    profile_id=profile_id,
+                    scope_key=scope_key,
+                )
+                checkpoint = 0
+                state = self._empty_state(profile_id, session_id, scope_key)
+            else:
+                saved = await asyncio.to_thread(
+                    self._store.load_projection,
+                    projection_name=_PROJECTION_NAME,
+                    profile_id=profile_id,
+                    scope_key=scope_key,
+                )
+                if saved is None:
+                    checkpoint = 0
+                    state = self._empty_state(profile_id, session_id, scope_key)
+                else:
+                    checkpoint, state = saved
+
+            cursor = checkpoint
+            while True:
+                records = await asyncio.to_thread(
+                    self._store.read,
+                    profile_id=profile_id,
+                    session_id=session_id,
+                    after_sequence=cursor,
+                    limit=5000,
+                )
+                if not records:
+                    break
+                for record in records:
+                    self._apply(state, record)
+                cursor = records[-1].sequence
+                if len(records) < 5000:
+                    break
+
+            state["last_sequence"] = cursor
+            await asyncio.to_thread(
+                self._store.save_projection,
+                projection_name=_PROJECTION_NAME,
+                profile_id=profile_id,
+                scope_key=scope_key,
+                last_sequence=cursor,
+                state=state,
+            )
+            return self._present(state)
+
+    @staticmethod
+    def _empty_state(profile_id: str, session_id: str, scope_key: str) -> dict[str, Any]:
+        return {
+            "projection": _PROJECTION_NAME,
+            "profile_id": profile_id,
+            "scope": "session" if session_id else "aggregate",
+            "scope_key": scope_key,
+            "session_id": session_id,
+            "last_sequence": 0,
+            "event_count": 0,
+            "action_count": 0,
+            "failed_action_count": 0,
+            "environment_count": 0,
+            "teacher_failure_count": 0,
+            "no_op_count": 0,
+            "verdict_counts": {action: 0 for action in _VERDICT_ACTIONS},
+            "episodes": {},
+            "proposals": {},
+            "verdicts": [],
+            "knowledge": [],
+            "provider_bindings": [],
+            "proposal_candidates": [],
+            "human_escalations": [],
+            "resolutions": [],
+            "environment": [],
+            "timeline": [],
+        }
+
+    @staticmethod
+    def _apply(state: dict[str, Any], record: EvolutionEventRecord) -> None:
+        event = record.event
+        event_type = event.event_type
+        payload = event.to_dict()["payload"]
+        state["event_count"] = int(state.get("event_count") or 0) + 1
+        state["last_sequence"] = record.sequence
+
+        proposal_state = payload.get("proposal_state")
+        if isinstance(proposal_state, Mapping):
+            proposal = dict(proposal_state)
+            proposal_id = str(proposal.get("proposal_id") or event.context.proposal_id)
+            if proposal_id:
+                state["proposals"][proposal_id] = proposal
+                EvolutionProjectionRunner._append_bounded(
+                    state["timeline"],
+                    {
+                        "sequence": record.sequence,
+                        "title": f"proposal → {proposal.get('status', '').lower()}",
+                        "summary": str(payload.get("reason") or proposal_id),
+                        "severity": "notable"
+                        if proposal.get("status") in {"FAILED", "QUARANTINED", "REJECTED"}
+                        else "info",
+                    },
+                )
+
+        if event_type == EvolutionEventType.ACTION_STARTED:
+            state["action_count"] = int(state.get("action_count") or 0) + 1
+        elif event_type == EvolutionEventType.ACTION_FAILED:
+            state["failed_action_count"] = int(state.get("failed_action_count") or 0) + 1
+        elif event_type == EvolutionEventType.ENVIRONMENT_OBSERVED:
+            state["environment_count"] = int(state.get("environment_count") or 0) + 1
+            EvolutionProjectionRunner._append_bounded(
+                state["environment"],
+                {
+                    "observation_id": event.context.observation_id,
+                    "kind": payload.get("kind", ""),
+                    "app_id": payload.get("app_id", ""),
+                    "summary": EvolutionProjectionRunner._environment_summary(payload),
+                    "observed_at": event.occurred_at,
+                },
+            )
+        elif event_type == EvolutionEventType.SESSION_FINALIZED:
+            episode_id = str(payload.get("episode_id") or event.context.correlation_id)
+            state["episodes"][episode_id] = {
+                "episode_id": episode_id,
+                "opened_at": event.occurred_at,
+                "closed_at": 0.0,
+                "status": "teacher_queued",
+                "driver": "session",
+                "capability": "",
+                "policy_action": "",
+                "mutation_action": "none",
+                "gap_closure": "not_applicable",
+                "verification_tier": "teacher_pending",
+                "artifact_id": "",
+            }
+            EvolutionProjectionRunner._append_bounded(
+                state["timeline"],
+                {
+                    "sequence": record.sequence,
+                    "title": "session → teacher",
+                    "summary": f"{event.context.session_id} finalized",
+                    "severity": "info",
+                },
+            )
+        elif event_type == EvolutionEventType.TEACHER_GRADED:
+            episode = state["episodes"].setdefault(
+                event.context.correlation_id,
+                {"episode_id": event.context.correlation_id, "opened_at": event.occurred_at},
+            )
+            episode.update(
+                {
+                    "closed_at": event.occurred_at,
+                    "status": "graded",
+                    "artifact_id": str(payload.get("artifact_id") or ""),
+                    "verification_tier": "teacher_hindsight",
+                }
+            )
+        elif event_type == EvolutionEventType.TEACHER_VERDICT_RECORDED:
+            action = str(payload.get("action") or "")
+            if action in _VERDICT_ACTIONS:
+                state["verdict_counts"][action] = int(
+                    state["verdict_counts"].get(action) or 0
+                ) + 1
+            verdict = {
+                "verdict_id": str(payload.get("verdict_id") or event.context.decision_id),
+                "episode_id": event.context.correlation_id,
+                "action": action,
+                "capability": str(payload.get("capability") or ""),
+                "knowledge": str(payload.get("knowledge") or ""),
+                "rationale": str(payload.get("rationale") or ""),
+                "confidence": float(payload.get("confidence") or 0.0),
+                "target": str(payload.get("target") or ""),
+                "artifact_id": event.context.artifact_id,
+                "observed_at": event.occurred_at,
+            }
+            EvolutionProjectionRunner._append_bounded(state["verdicts"], verdict)
+            if action == "absorb":
+                EvolutionProjectionRunner._upsert_capability(
+                    state["knowledge"],
+                    {
+                        "verdict_id": verdict["verdict_id"],
+                        "capability": verdict["capability"],
+                        "knowledge": verdict["knowledge"],
+                        "confidence": verdict["confidence"],
+                        "episode_id": verdict["episode_id"],
+                        "created_at": verdict["observed_at"],
+                    },
+                )
+            elif action == "rebind":
+                EvolutionProjectionRunner._upsert_capability(
+                    state["provider_bindings"],
+                    {
+                        "verdict_id": verdict["verdict_id"],
+                        "capability": verdict["capability"],
+                        "plugin_id": verdict["target"],
+                        "knowledge": verdict["knowledge"],
+                        "confidence": verdict["confidence"],
+                        "episode_id": verdict["episode_id"],
+                        "created_at": verdict["observed_at"],
+                    },
+                )
+            elif action == "acquire":
+                EvolutionProjectionRunner._append_bounded(
+                    state["proposal_candidates"],
+                    {
+                        "capability": verdict["capability"],
+                        "confidence": verdict["confidence"],
+                        "episode_id": verdict["episode_id"],
+                    },
+                )
+            elif action == "escalate":
+                EvolutionProjectionRunner._append_bounded(
+                    state["human_escalations"],
+                    {
+                        "capability": verdict["capability"],
+                        "rationale": verdict["rationale"],
+                        "confidence": verdict["confidence"],
+                        "episode_id": verdict["episode_id"],
+                    },
+                )
+            episode = state["episodes"].setdefault(
+                event.context.correlation_id,
+                {"episode_id": event.context.correlation_id, "opened_at": event.occurred_at},
+            )
+            episode.update(
+                {
+                    "closed_at": event.occurred_at,
+                    "status": "committed" if action in {"absorb", "rebind"} else "open",
+                    "driver": "world_model",
+                    "capability": verdict["capability"],
+                    "policy_action": action,
+                    "mutation_action": "none",
+                    "gap_closure": "not_applicable",
+                    "verification_tier": "teacher_hindsight",
+                    "artifact_id": event.context.artifact_id,
+                }
+            )
+            EvolutionProjectionRunner._append_bounded(
+                state["timeline"],
+                {
+                    "sequence": record.sequence,
+                    "title": f"world_model → {action}",
+                    "summary": verdict["capability"] or verdict["knowledge"],
+                    "severity": "notable" if action in {"acquire", "escalate"} else "info",
+                },
+            )
+        elif event_type == EvolutionEventType.KNOWLEDGE_RETRACTED:
+            capability = str(payload.get("capability") or "")
+            state["knowledge"] = [
+                item for item in state["knowledge"] if item.get("capability") != capability
+            ]
+            state["provider_bindings"] = [
+                item
+                for item in state["provider_bindings"]
+                if item.get("capability") != capability
+            ]
+            EvolutionProjectionRunner._append_bounded(
+                state["timeline"],
+                {
+                    "sequence": record.sequence,
+                    "title": "knowledge → retracted",
+                    "summary": capability,
+                    "severity": "info",
+                },
+            )
+        elif event_type == EvolutionEventType.REQUIREMENT_RESOLVED:
+            resolution = {
+                "requirement_id": event.context.requirement_id,
+                "verdict_id": event.context.decision_id,
+                "proposal_id": event.context.proposal_id,
+                "capability": str(
+                    dict(payload.get("requirement") or {}).get("capability") or ""
+                ),
+                "outcome": str(payload.get("outcome") or ""),
+                "reason": str(payload.get("reason") or ""),
+                "selected_plugin_id": str(
+                    dict(payload.get("resolution") or {}).get("selected_plugin_id") or ""
+                ),
+                "selected_tool_name": str(
+                    dict(payload.get("resolution") or {}).get("selected_tool_name") or ""
+                ),
+                "observed_at": event.occurred_at,
+            }
+            EvolutionProjectionRunner._append_bounded(state["resolutions"], resolution)
+            if resolution["outcome"] in {"no_op", "satisfied"}:
+                state["no_op_count"] = int(state.get("no_op_count") or 0) + 1
+            EvolutionProjectionRunner._append_bounded(
+                state["timeline"],
+                {
+                    "sequence": record.sequence,
+                    "title": f"requirement → {resolution['outcome']}",
+                    "summary": resolution["capability"] or resolution["reason"],
+                    "severity": "info",
+                },
+            )
+        elif event_type == EvolutionEventType.TEACHER_JOB_FAILED:
+            state["teacher_failure_count"] = int(state.get("teacher_failure_count") or 0) + 1
+            episode = state["episodes"].setdefault(
+                event.context.correlation_id,
+                {"episode_id": event.context.correlation_id, "opened_at": event.occurred_at},
+            )
+            episode.update(
+                {
+                    "closed_at": event.occurred_at,
+                    "status": "open" if payload.get("retryable") else "aborted",
+                    "verification_tier": "teacher_failed",
+                }
+            )
+            EvolutionProjectionRunner._append_bounded(
+                state["timeline"],
+                {
+                    "sequence": record.sequence,
+                    "title": "teacher → failed",
+                    "summary": str(payload.get("error_type") or "teacher failure"),
+                    "severity": "notable",
+                },
+            )
+
+    @staticmethod
+    def _append_bounded(rows: list[dict[str, Any]], item: dict[str, Any]) -> None:
+        rows.append(item)
+        if len(rows) > _MAX_ROWS:
+            del rows[: len(rows) - _MAX_ROWS]
+
+    @staticmethod
+    def _upsert_capability(rows: list[dict[str, Any]], item: dict[str, Any]) -> None:
+        capability = str(item.get("capability") or "")
+        rows[:] = [row for row in rows if str(row.get("capability") or "") != capability]
+        EvolutionProjectionRunner._append_bounded(rows, item)
+
+    @staticmethod
+    def _environment_summary(payload: Mapping[str, Any]) -> str:
+        kind = str(payload.get("kind") or "environment")
+        app_id = str(payload.get("app_id") or "")
+        removed = list(payload.get("removed_affordances") or ())
+        if removed:
+            return f"{app_id}: removed {', '.join(str(item) for item in removed)}"
+        outcome = str(payload.get("outcome") or "UNKNOWN")
+        if kind == "outcome":
+            return f"{app_id}: {outcome}"
+        return f"{app_id}: {kind}"
+
+    @staticmethod
+    def _present(state: Mapping[str, Any]) -> dict[str, Any]:
+        snapshot = copy.deepcopy(dict(state))
+        episodes = sorted(
+            (dict(item) for item in dict(snapshot.pop("episodes", {})).values()),
+            key=lambda item: float(item.get("opened_at") or 0.0),
+            reverse=True,
+        )
+        verdict_counts = dict(snapshot.get("verdict_counts") or {})
+        verdicts = list(snapshot.get("verdicts") or [])
+        proposals = sorted(
+            (dict(item) for item in dict(snapshot.pop("proposals", {})).values()),
+            key=lambda item: float(item.get("updated_at") or item.get("created_at") or 0.0),
+            reverse=True,
+        )
+        summary = {
+            "episode_count": len(episodes),
+            "proposal_count": len(proposals),
+            "event_count": int(snapshot.get("event_count") or 0),
+            "action_count": int(snapshot.get("action_count") or 0),
+            "failed_action_count": int(snapshot.get("failed_action_count") or 0),
+            "environment_count": int(snapshot.get("environment_count") or 0),
+            "verdict_count": sum(int(value or 0) for value in verdict_counts.values()),
+            "teacher_failure_count": int(snapshot.get("teacher_failure_count") or 0),
+            "no_op_count": int(snapshot.get("no_op_count") or 0),
+            "by_action": verdict_counts,
+        }
+        summary["attention"] = bool(
+            summary["failed_action_count"]
+            or summary["teacher_failure_count"]
+            or verdict_counts.get("escalate")
+        )
+        snapshot.update(
+            {
+                "summary": summary,
+                "episodes": episodes,
+                "proposals": proposals,
+                "verdicts": verdicts,
+                "mutation_matrix": [
+                    {
+                        "driver": "world_model",
+                        "capability": item.get("capability", ""),
+                        "policy_action": item.get("action", ""),
+                        "autonomy_level": "proposal_only",
+                        "mutation_action": "none",
+                        "registry_delta": "0",
+                        "lifecycle_status": "not_started",
+                        "gap_closure": "not_applicable",
+                        "verification_tier": "teacher_hindsight",
+                    }
+                    for item in verdicts
+                ]
+                + [
+                    {
+                        "driver": str(item.get("source") or "proposal"),
+                        "capability": str(
+                            (item.get("requirements") or [{}])[0].get("capability") or ""
+                        ),
+                        "policy_action": str(
+                            dict(item.get("policy_decision") or {}).get("action") or ""
+                        ),
+                        "autonomy_level": str(
+                            dict(item.get("policy_decision") or {}).get("autonomy_level")
+                            or ""
+                        ),
+                        "mutation_action": "install"
+                        if item.get("status") in {"INSTALLED", "PROBATION", "VERIFIED"}
+                        else "none",
+                        "registry_delta": "1"
+                        if item.get("status") in {"INSTALLED", "PROBATION", "VERIFIED"}
+                        else "0",
+                        "lifecycle_status": str(item.get("status") or ""),
+                        "gap_closure": "closed"
+                        if item.get("status") == "VERIFIED"
+                        else "open",
+                        "verification_tier": str(
+                            dict(item.get("trust_state") or {}).get("level") or "DRAFT"
+                        ),
+                    }
+                    for item in proposals
+                ],
+                "degraded": not episodes,
+            }
+        )
+        return snapshot
+
+
+__all__ = ["EvolutionProjectionRunner", "ProjectionMetrics", "ProjectionStore"]
diff --git a/src/leapflow/evolution/session_finalizer.py b/src/leapflow/evolution/session_finalizer.py
new file mode 100644
index 00000000..2667326f
--- /dev/null
+++ b/src/leapflow/evolution/session_finalizer.py
@@ -0,0 +1,194 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Durable session boundaries for cold-path evolution work."""
+from __future__ import annotations
+
+import asyncio
+from dataclasses import asdict, dataclass
+from typing import Any
+
+from leapflow.domain.event_types import EvolutionEventType
+from leapflow.domain.evolution_event import EvolutionEventRecord, EvolutionEventStore
+
+
+@dataclass(frozen=True)
+class SessionFinalization:
+    """Result of sealing one session evidence window."""
+
+    session_id: str
+    from_sequence: int
+    through_sequence: int
+    episode_id: str = ""
+    job_id: str = ""
+    evidence_count: int = 0
+
+    @property
+    def queued(self) -> bool:
+        return bool(self.job_id)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {**asdict(self), "queued": self.queued}
+
+
+class SessionFinalizer:
+    """Flush the hot path, seal a session slice, and enqueue one teacher job."""
+
+    def __init__(self, store: EvolutionEventStore, outbox: Any) -> None:
+        self._store = store
+        self._outbox = outbox
+        self._lock = asyncio.Lock()
+
+    async def finalize(
+        self,
+        *,
+        profile_id: str,
+        workspace_id: str,
+        session_id: str,
+        session_generation: int = 0,
+        reason: str = "manual",
+        goal: str = "",
+        model: str = "",
+    ) -> SessionFinalization:
+        """Atomically queue exactly the evidence not finalized before this call."""
+        if not session_id:
+            raise ValueError("session_id is required")
+        async with self._lock:
+            await self._outbox.flush()
+            from_sequence = await asyncio.to_thread(
+                self._store.last_finalized_sequence,
+                profile_id=profile_id,
+                session_id=session_id,
+                session_generation=session_generation,
+            )
+            through_sequence = await asyncio.to_thread(
+                self._store.latest_evidence_sequence,
+                profile_id=profile_id,
+                session_id=session_id,
+                session_generation=session_generation,
+            )
+            if through_sequence <= from_sequence:
+                return SessionFinalization(
+                    session_id=session_id,
+                    from_sequence=from_sequence,
+                    through_sequence=through_sequence,
+                )
+            evidence = await self._read_window(
+                profile_id=profile_id,
+                session_id=session_id,
+                session_generation=session_generation,
+                after_sequence=from_sequence,
+                through_sequence=through_sequence,
+            )
+            source_types = {
+                EvolutionEventType.ACTION_STARTED,
+                EvolutionEventType.ACTION_COMPLETED,
+                EvolutionEventType.ACTION_FAILED,
+                EvolutionEventType.ENVIRONMENT_OBSERVED,
+            }
+            evidence = [record for record in evidence if record.event.event_type in source_types]
+            if not evidence:
+                return SessionFinalization(
+                    session_id=session_id,
+                    from_sequence=from_sequence,
+                    through_sequence=through_sequence,
+                )
+            observed_workspaces = {
+                record.event.context.workspace_id
+                for record in evidence
+                if record.event.context.workspace_id
+            }
+            if len(observed_workspaces) > 1:
+                raise ValueError(f"session {session_id!r} spans multiple workspaces")
+            if workspace_id and observed_workspaces - {workspace_id}:
+                raise ValueError(
+                    f"session {session_id!r} contains evidence from another workspace"
+                )
+            if not workspace_id and observed_workspaces:
+                workspace_id = next(iter(observed_workspaces))
+            if not goal:
+                goal = self._goal_from_records(evidence)
+            episode_id, job_id = await asyncio.to_thread(
+                self._store.finalize_session,
+                profile_id=profile_id,
+                workspace_id=workspace_id,
+                session_id=session_id,
+                session_generation=session_generation,
+                from_sequence=from_sequence,
+                through_sequence=through_sequence,
+                reason=reason,
+                goal=goal,
+                model=model,
+            )
+            return SessionFinalization(
+                session_id=session_id,
+                from_sequence=from_sequence,
+                through_sequence=through_sequence,
+                episode_id=episode_id,
+                job_id=job_id,
+                evidence_count=len(evidence),
+            )
+
+    async def finalize_pending_sessions(
+        self,
+        *,
+        profile_id: str = "",
+        reason: str = "shutdown",
+        model: str = "",
+    ) -> list[SessionFinalization]:
+        """Seal all sessions with new evidence, used only at daemon shutdown."""
+        sessions = await asyncio.to_thread(
+            self._store.evidence_sessions,
+            profile_id=profile_id,
+        )
+        results: list[SessionFinalization] = []
+        for item in sessions:
+            result = await self.finalize(
+                profile_id=str(item.get("profile_id") or profile_id),
+                workspace_id=str(item.get("workspace_id") or ""),
+                session_id=str(item.get("session_id") or ""),
+                session_generation=int(item.get("session_generation") or 0),
+                reason=reason,
+                model=model,
+            )
+            if result.queued:
+                results.append(result)
+        return results
+
+    async def _read_window(
+        self,
+        *,
+        profile_id: str,
+        session_id: str,
+        session_generation: int,
+        after_sequence: int,
+        through_sequence: int,
+    ) -> list[EvolutionEventRecord]:
+        records: list[EvolutionEventRecord] = []
+        cursor = after_sequence
+        while cursor < through_sequence:
+            page = await asyncio.to_thread(
+                self._store.read,
+                profile_id=profile_id,
+                session_id=session_id,
+                session_generation=session_generation,
+                after_sequence=cursor,
+                through_sequence=through_sequence,
+                limit=5000,
+            )
+            if not page:
+                break
+            records.extend(page)
+            cursor = page[-1].sequence
+        return records
+
+    @staticmethod
+    def _goal_from_records(records: list[EvolutionEventRecord]) -> str:
+        for record in reversed(records):
+            if record.event.event_type != EvolutionEventType.ACTION_STARTED:
+                continue
+            goal = str(record.event.payload.get("goal") or "").strip()
+            if goal:
+                return goal
+        return ""
+
+
+__all__ = ["SessionFinalization", "SessionFinalizer"]
diff --git a/src/leapflow/evolution/sink.py b/src/leapflow/evolution/sink.py
index 196a5f03..9cc6a7c8 100644
--- a/src/leapflow/evolution/sink.py
+++ b/src/leapflow/evolution/sink.py
@@ -3,7 +3,7 @@
 
 The probe's contract is "accept and return", so ``record`` only appends to a bounded
 deque. Persistence happens when someone calls :meth:`flush` -- the daemon's monitor
-cycle, or process exit -- which keeps a file write out of the plugin registry's
+cycle, or process exit -- which keeps an event-store write out of the plugin registry's
 version bump and the trust ledger's level transition.
 
 The buffer is bounded and drops *oldest* on overflow. That is the right direction
@@ -91,6 +91,12 @@ def pending(self) -> tuple[EvolutionTrace, ...]:
         """Buffered traces not yet flushed, for a reader that wants live state."""
         return tuple(self._buffer)
 
+    def list_traces(self, *, limit: int = 200) -> list[dict[str, Any]]:
+        """Read persisted traces through the configured event-store adapter."""
+        if self._store is None or not hasattr(self._store, "list_traces"):
+            return []
+        return [dict(item) for item in self._store.list_traces(limit=limit)]
+
     @property
     def stats(self) -> dict[str, int]:
         return {
diff --git a/src/leapflow/evolution/teacher_worker.py b/src/leapflow/evolution/teacher_worker.py
new file mode 100644
index 00000000..35216ae8
--- /dev/null
+++ b/src/leapflow/evolution/teacher_worker.py
@@ -0,0 +1,698 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Durable daemon worker for one-call hindsight grading."""
+from __future__ import annotations
+
+import asyncio
+import logging
+import uuid
+from dataclasses import asdict, dataclass, replace
+from time import perf_counter
+from typing import Any, Callable, Mapping, Protocol, Sequence, runtime_checkable
+
+from leapflow.domain.event_types import EvolutionEventType
+from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent, EvolutionEventRecord, content_hash
+from leapflow.evolution.artifact_store import ArtifactRef
+from leapflow.performance import LatencySummary, RollingLatency
+from leapflow.security.redact import redact_sensitive_text
+
+logger = logging.getLogger(__name__)
+
+_INTERNAL_DEFECTS = (
+    AttributeError,
+    TypeError,
+    NameError,
+    KeyError,
+    IndexError,
+    ImportError,
+    AssertionError,
+    NotImplementedError,
+)
+
+
+@runtime_checkable
+class Teacher(Protocol):
+    """One-call hindsight evaluator used by the durable worker."""
+
+    async def grade_and_propose(
+        self,
+        trajectory: list[dict[str, Any]],
+        goal: str = "",
+        *,
+        degraded_capabilities: Sequence[Mapping[str, Any]] = (),
+        raise_on_error: bool = False,
+    ) -> Any: ...
+
+
+@runtime_checkable
+class TeacherWorkStore(Protocol):
+    """Persistence operations required by the durable teacher worker."""
+
+    def claim_teacher_job(self, **kwargs: Any) -> dict[str, Any] | None: ...
+
+    def renew_teacher_job(self, job_id: str, **kwargs: Any) -> bool: ...
+
+    def complete_teacher_job(self, job_id: str, **kwargs: Any) -> bool: ...
+
+    def fail_teacher_job(self, job_id: str, error: str, **kwargs: Any) -> bool: ...
+
+    def teacher_job(self, job_id: str) -> dict[str, Any] | None: ...
+
+    def read(self, **kwargs: Any) -> list[EvolutionEventRecord]: ...
+
+
+@runtime_checkable
+class ArtifactWriter(Protocol):
+    """Minimal CAS interface used for teacher outputs."""
+
+    def put_json(
+        self,
+        value: Mapping[str, Any] | list[Any],
+        *,
+        privacy_class: str = "system",
+    ) -> ArtifactRef: ...
+
+
+@dataclass(frozen=True)
+class TeacherWorkerMetrics:
+    claim_latency: LatencySummary
+    job_latency: LatencySummary
+
+
+@dataclass(frozen=True)
+class TeacherJobOutcome:
+    """Observable result of one worker attempt."""
+
+    job_id: str
+    status: str
+    episode_id: str = ""
+    artifact_id: str = ""
+    verdict_count: int = 0
+    grade_count: int = 0
+    error: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class _AcquisitionPlan:
+    verdict_id: str
+    requirement: Any
+    outcome: str
+    reason: str
+    resolution: Mapping[str, Any]
+    proposal_id: str = ""
+    proposal_event: EvolutionEvent | None = None
+
+
+class DurableTeacherWorker:
+    """Lease and grade finalized sessions without blocking daemon RPC handling."""
+
+    def __init__(
+        self,
+        *,
+        store: TeacherWorkStore,
+        artifact_store: ArtifactWriter,
+        teacher: Teacher,
+        profile_id: str = "",
+        producer_version: str = "",
+        poll_interval_s: float = 1.0,
+        lease_seconds: float = 120.0,
+        teacher_timeout_s: float = 180.0,
+        max_attempts: int = 3,
+        retry_backoff_s: float = 5.0,
+        proposal_queue: Any = None,
+        acquisition_resolver: Callable[[Any, Mapping[str, Any]], Mapping[str, Any]] | None = None,
+        authorising_origins: Sequence[str] = (),
+        degraded_capabilities: Callable[[], Sequence[Mapping[str, Any]]] | None = None,
+        knowledge_projection: Any = None,
+    ) -> None:
+        self._store = store
+        self._artifact_store = artifact_store
+        self._teacher = teacher
+        self._profile_id = str(profile_id)
+        self._producer_version = str(producer_version)
+        self._poll_interval_s = max(0.05, float(poll_interval_s))
+        self._lease_seconds = max(3.0, float(lease_seconds))
+        self._teacher_timeout_s = max(0.1, float(teacher_timeout_s))
+        self._max_attempts = max(1, int(max_attempts))
+        self._retry_backoff_s = max(0.0, float(retry_backoff_s))
+        self._proposal_queue = proposal_queue
+        self._acquisition_resolver = acquisition_resolver
+        self._authorising_origins = tuple(
+            str(origin) for origin in authorising_origins if str(origin)
+        )
+        self._degraded_capabilities = degraded_capabilities
+        self._knowledge_projection = knowledge_projection
+        self._lease_owner = f"teacher-{uuid.uuid4().hex}"
+        self._wake = asyncio.Event()
+        self._task: asyncio.Task[None] | None = None
+        self._closed = False
+        self._claim_latency = RollingLatency()
+        self._job_latency = RollingLatency()
+
+    @property
+    def metrics(self) -> TeacherWorkerMetrics:
+        return TeacherWorkerMetrics(
+            claim_latency=self._claim_latency.snapshot(),
+            job_latency=self._job_latency.snapshot(),
+        )
+
+    def start(self) -> None:
+        if self._closed:
+            raise RuntimeError("teacher worker is closed")
+        if self._task is None or self._task.done():
+            self._task = asyncio.create_task(self._run(), name="evolution-teacher-worker")
+
+    def wake(self) -> None:
+        if not self._closed:
+            self._wake.set()
+
+    async def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        self._wake.set()
+        task = self._task
+        self._task = None
+        if task is not None and not task.done():
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+
+    async def wait_for_job(self, job_id: str, *, timeout_s: float = 180.0) -> dict[str, Any]:
+        """Wait for a job terminal state without holding a DuckDB connection."""
+        deadline = asyncio.get_running_loop().time() + max(0.1, float(timeout_s))
+        while True:
+            job = await asyncio.to_thread(self._store.teacher_job, job_id)
+            if job is None:
+                raise KeyError(f"teacher job not found: {job_id}")
+            if str(job.get("status")) in {"COMPLETED", "FAILED_FINAL"}:
+                return job
+            if asyncio.get_running_loop().time() >= deadline:
+                return job
+            self.wake()
+            await asyncio.sleep(min(0.1, self._poll_interval_s))
+
+    async def run_once(self) -> TeacherJobOutcome | None:
+        """Claim and process one due job, returning ``None`` when the queue is idle."""
+        claim_started_at = perf_counter()
+        try:
+            job = await asyncio.to_thread(
+                self._store.claim_teacher_job,
+                lease_owner=self._lease_owner,
+                profile_id=self._profile_id,
+                lease_seconds=self._lease_seconds,
+            )
+        finally:
+            self._claim_latency.observe((perf_counter() - claim_started_at) * 1000.0)
+        if job is None:
+            return None
+
+        job_started_at = perf_counter()
+        heartbeat = asyncio.create_task(
+            self._heartbeat(str(job["job_id"])),
+            name=f"teacher-lease-{job['job_id']}",
+        )
+        try:
+            return await self._process(job)
+        except Exception as exc:
+            attempts = int(job.get("attempts") or 1)
+            retryable = not isinstance(exc, _INTERNAL_DEFECTS) and attempts < self._max_attempts
+            retry_after = self._retry_backoff_s * (2 ** max(0, attempts - 1))
+            error_text = redact_sensitive_text(str(exc), force=True)[:2000]
+            failure_event = EvolutionEvent.create(
+                EvolutionEventType.TEACHER_JOB_FAILED,
+                context=EvolutionContext(
+                    profile_id=str(job.get("profile_id") or ""),
+                    workspace_id=str(job.get("workspace_id") or ""),
+                    session_id=str(job.get("session_id") or ""),
+                    session_generation=int(job.get("session_generation") or 0),
+                    correlation_id=str(job.get("episode_id") or ""),
+                ),
+                payload={
+                    "job_id": str(job["job_id"]),
+                    "attempt": attempts,
+                    "retryable": retryable,
+                    "error_type": type(exc).__name__,
+                    "error": error_text,
+                },
+                producer="world_model.teacher_worker",
+                producer_version=self._producer_version,
+                privacy_class="session",
+                dedup_key=f"teacher.job_failed:{job['job_id']}:{attempts}",
+            )
+            try:
+                await asyncio.to_thread(
+                    self._store.fail_teacher_job,
+                    str(job["job_id"]),
+                    error_text,
+                    lease_owner=self._lease_owner,
+                    retryable=retryable,
+                    retry_after_s=retry_after,
+                    events=(failure_event,),
+                )
+            except Exception:
+                logger.error(
+                    "teacher job failure state could not be persisted job=%s",
+                    job["job_id"],
+                    exc_info=True,
+                )
+            logger.warning(
+                "teacher job failed job=%s retryable=%s",
+                job["job_id"],
+                retryable,
+                exc_info=True,
+            )
+            return TeacherJobOutcome(
+                job_id=str(job["job_id"]),
+                episode_id=str(job.get("episode_id") or ""),
+                status="FAILED_RETRYABLE" if retryable else "FAILED_FINAL",
+                error=str(exc),
+            )
+        finally:
+            heartbeat.cancel()
+            try:
+                await heartbeat
+            except asyncio.CancelledError:
+                pass
+            self._job_latency.observe((perf_counter() - job_started_at) * 1000.0)
+
+    async def _process(self, job: Mapping[str, Any]) -> TeacherJobOutcome:
+        records = await self._read_window(job)
+        trajectory = self._trajectory(records)
+        verdict = await asyncio.wait_for(
+            self._teacher.grade_and_propose(
+                trajectory,
+                str(job.get("goal") or ""),
+                degraded_capabilities=self._collect_degraded_capabilities(),
+                raise_on_error=True,
+            ),
+            timeout=self._teacher_timeout_s,
+        )
+        grades = tuple(getattr(verdict, "grades", ()) or ())
+        verdicts = tuple(getattr(verdict, "verdicts", ()) or ())
+        acquisition_plans = self._plan_acquisitions(verdicts, job)
+        proposal_ids = [plan.proposal_id for plan in acquisition_plans if plan.proposal_id]
+        result_payload = {
+            "job_id": str(job["job_id"]),
+            "episode_id": str(job["episode_id"]),
+            "grades": [
+                {
+                    "experience_id": str(getattr(grade, "experience_id", "")),
+                    "advantage": float(getattr(grade, "advantage", 0.0)),
+                    "is_forking": bool(getattr(grade, "is_forking", False)),
+                    "grade_label": str(getattr(grade, "grade_label", "")),
+                }
+                for grade in grades
+            ],
+            "verdicts": [item.to_dict() for item in verdicts],
+            "proposal_ids": proposal_ids,
+            "acquisition_resolutions": [
+                {
+                    "verdict_id": plan.verdict_id,
+                    "requirement": plan.requirement.to_dict(),
+                    "outcome": plan.outcome,
+                    "reason": plan.reason,
+                    "resolution": dict(plan.resolution),
+                    "proposal_id": plan.proposal_id,
+                }
+                for plan in acquisition_plans
+            ],
+            "raw_payload": dict(getattr(verdict, "raw_payload", {}) or {}),
+        }
+        artifact = await asyncio.to_thread(
+            self._artifact_store.put_json,
+            result_payload,
+            privacy_class="session",
+        )
+        prompt_hash = content_hash(
+            {"goal": str(job.get("goal") or ""), "trajectory": trajectory}
+        )
+        context = EvolutionContext(
+            profile_id=str(job["profile_id"]),
+            workspace_id=str(job.get("workspace_id") or ""),
+            session_id=str(job["session_id"]),
+            session_generation=int(job.get("session_generation") or 0),
+            artifact_id=artifact.artifact_id,
+            correlation_id=str(job["episode_id"]),
+        )
+        finalized = await asyncio.to_thread(
+            self._store.read,
+            profile_id=context.profile_id,
+            session_id=context.session_id,
+            correlation_id=context.correlation_id,
+            event_type=EvolutionEventType.SESSION_FINALIZED,
+            limit=1,
+        )
+        causation_id = finalized[0].event.event_id if finalized else ""
+        graded_event = EvolutionEvent.create(
+            EvolutionEventType.TEACHER_GRADED,
+            context=context.with_ids(causation_id=causation_id),
+            payload={
+                "job_id": str(job["job_id"]),
+                "episode_id": str(job["episode_id"]),
+                "grade_count": len(grades),
+                "verdict_count": len(verdicts),
+                "proposal_ids": proposal_ids,
+                "artifact_id": artifact.artifact_id,
+                "prompt_hash": prompt_hash,
+            },
+            producer="world_model.teacher_worker",
+            producer_version=self._producer_version,
+            privacy_class="session",
+            dedup_key=f"teacher.graded:{job['job_id']}",
+        )
+        events = [graded_event]
+        verdict_events: dict[str, EvolutionEvent] = {}
+        for item in verdicts:
+            verdict_event = EvolutionEvent.create(
+                EvolutionEventType.TEACHER_VERDICT_RECORDED,
+                context=context.with_ids(
+                    decision_id=str(item.verdict_id),
+                    causation_id=graded_event.event_id,
+                ),
+                payload=item.to_dict(),
+                producer="world_model.teacher_worker",
+                producer_version=self._producer_version,
+                privacy_class="session",
+                dedup_key=f"teacher.verdict_recorded:{item.verdict_id}",
+            )
+            verdict_events[str(item.verdict_id)] = verdict_event
+            events.append(verdict_event)
+        for plan in acquisition_plans:
+            verdict_event = verdict_events.get(plan.verdict_id)
+            causation_id = verdict_event.event_id if verdict_event is not None else graded_event.event_id
+            resolution_event = EvolutionEvent.create(
+                EvolutionEventType.REQUIREMENT_RESOLVED,
+                context=context.with_ids(
+                    requirement_id=str(plan.requirement.requirement_id),
+                    decision_id=plan.verdict_id,
+                    proposal_id=plan.proposal_id,
+                    causation_id=causation_id,
+                ),
+                payload={
+                    "requirement": plan.requirement.to_dict(),
+                    "outcome": plan.outcome,
+                    "reason": plan.reason,
+                    "resolution": dict(plan.resolution),
+                    "proposal_id": plan.proposal_id,
+                },
+                producer="world_model.teacher_worker",
+                producer_version=self._producer_version,
+                privacy_class="session",
+                dedup_key=f"requirement.resolved:{job['job_id']}:{plan.verdict_id}",
+            )
+            events.append(resolution_event)
+            if plan.proposal_event is not None:
+                events.append(
+                    replace(
+                        plan.proposal_event,
+                        context=plan.proposal_event.context.with_ids(
+                            causation_id=resolution_event.event_id
+                        ),
+                    )
+                )
+        completed = await asyncio.to_thread(
+            self._store.complete_teacher_job,
+            str(job["job_id"]),
+            lease_owner=self._lease_owner,
+            events=events,
+            prompt_hash=prompt_hash,
+            result_artifact_id=artifact.artifact_id,
+        )
+        if not completed:
+            raise RuntimeError(f"teacher job lease lost: {job['job_id']}")
+        await self._after_commit()
+        return TeacherJobOutcome(
+            job_id=str(job["job_id"]),
+            episode_id=str(job["episode_id"]),
+            status="COMPLETED",
+            artifact_id=artifact.artifact_id,
+            verdict_count=len(verdicts),
+            grade_count=len(grades),
+        )
+
+    def _plan_acquisitions(
+        self,
+        verdicts: Sequence[Any],
+        job: Mapping[str, Any],
+    ) -> tuple[_AcquisitionPlan, ...]:
+        """Resolve each acquisition and prepare any proposal for atomic commit."""
+        from leapflow.domain.evolution_intent import WORLD_MODEL_ORIGIN
+        from leapflow.learning.capability_gap_detector import CapabilityGapDetector
+        from leapflow.learning.outcome_governance_feed import origin_may_authorise
+
+        detector = CapabilityGapDetector()
+        plans: list[_AcquisitionPlan] = []
+        for verdict in verdicts:
+            intent = verdict.to_intent()
+            if intent is None:
+                continue
+            requirement = replace(
+                intent.to_requirement(),
+                requirement_id=f"req-wm-{intent.capability}",
+            )
+            verdict_id = str(verdict.verdict_id)
+            if self._authorising_origins and not origin_may_authorise(
+                WORLD_MODEL_ORIGIN, self._authorising_origins
+            ):
+                plans.append(
+                    _AcquisitionPlan(
+                        verdict_id,
+                        requirement,
+                        "no_op",
+                        "origin_not_authorised",
+                        {},
+                    )
+                )
+                continue
+            if self._proposal_queue is None:
+                plans.append(
+                    _AcquisitionPlan(
+                        verdict_id,
+                        requirement,
+                        "no_op",
+                        "self_evolution_disabled",
+                        {},
+                    )
+                )
+                continue
+            if self._acquisition_resolver is None:
+                plans.append(
+                    _AcquisitionPlan(
+                        verdict_id,
+                        requirement,
+                        "no_op",
+                        "live_resolution_unavailable",
+                        {},
+                    )
+                )
+                continue
+            resolution = dict(self._acquisition_resolver(intent, job) or {})
+            if not bool(resolution.get("resolved", False)):
+                plans.append(
+                    _AcquisitionPlan(
+                        verdict_id,
+                        requirement,
+                        "no_op",
+                        str(resolution.get("reason") or "live_resolution_unavailable"),
+                        resolution,
+                    )
+                )
+                continue
+            if bool(resolution.get("satisfied", False)):
+                plans.append(
+                    _AcquisitionPlan(
+                        verdict_id,
+                        requirement,
+                        "satisfied",
+                        "capability_already_available",
+                        resolution,
+                    )
+                )
+                continue
+            proposal = detector.proposal_from_evolution_intent(intent)
+            evidence = tuple(getattr(proposal, "evidence", ()) or ())
+            metadata = dict(getattr(evidence[0], "metadata", {})) if evidence else {}
+            item, proposal_event = self._proposal_queue.prepare_enqueue(
+                requirements=(requirement,),
+                environment=dict(resolution.get("environment") or {}),
+                source="world_model",
+                observation_ids=tuple(intent.evidence_ids),
+                risk={"max_risk_level": requirement.max_risk_level},
+                metadata={
+                    "plugin_id": str(getattr(proposal, "plugin_id", "")),
+                    "capability_summary": str(
+                        getattr(proposal, "capability_summary", "")
+                    ),
+                    "intent_id": str(metadata.get("intent_id", "")),
+                    "confidence": str(metadata.get("confidence", "")),
+                    "replaces": str(metadata.get("replaces", "")),
+                },
+                occurred_at=float(getattr(verdict, "created_at", 0.0) or 0.0) or None,
+            )
+            plans.append(
+                _AcquisitionPlan(
+                    verdict_id,
+                    requirement,
+                    "unmet",
+                    str(resolution.get("reason") or "no eligible capability provider"),
+                    resolution,
+                    proposal_id=item.proposal_id,
+                    proposal_event=proposal_event,
+                )
+            )
+        return tuple(plans)
+
+    def _collect_degraded_capabilities(self) -> tuple[Mapping[str, Any], ...]:
+        provider = self._degraded_capabilities
+        if provider is None:
+            return ()
+        try:
+            facts = tuple(provider() or ())
+        except Exception:  # noqa: BLE001 - context may degrade; the job remains valid
+            logger.warning("teacher degradation context unavailable", exc_info=True)
+            return ()
+        # Close the D1 feedback edge: show the teacher what it concluded last time for a
+        # still-failing capability, so the same evidence cannot only ever produce the same
+        # answer. Enriched from the durable knowledge projection rather than a second
+        # store, so the fact and its prior verdict share one source.
+        projection = self._knowledge_projection
+        if projection is None:
+            return facts
+        enriched: list[Mapping[str, Any]] = []
+        for fact in facts:
+            capability = str(fact.get("capability") or "")
+            prior = projection.for_capability(capability) if capability else None
+            if prior is None:
+                enriched.append(fact)
+                continue
+            row = dict(fact)
+            row["prior_action"] = prior.action
+            row["prior_knowledge"] = prior.knowledge
+            enriched.append(row)
+        return tuple(enriched)
+
+    async def _after_commit(self) -> None:
+        projection = self._knowledge_projection
+        if projection is not None:
+            try:
+                await asyncio.to_thread(projection.refresh)
+            except Exception:  # noqa: BLE001 - committed facts remain replayable
+                logger.warning("knowledge projection refresh failed", exc_info=True)
+    async def _read_window(
+        self,
+        job: Mapping[str, Any],
+    ) -> list[EvolutionEventRecord]:
+        records: list[EvolutionEventRecord] = []
+        cursor = int(job["from_sequence"])
+        through_sequence = int(job["through_sequence"])
+        while cursor < through_sequence:
+            page = await asyncio.to_thread(
+                self._store.read,
+                profile_id=str(job["profile_id"]),
+                session_id=str(job["session_id"]),
+                session_generation=int(job.get("session_generation") or 0),
+                after_sequence=cursor,
+                through_sequence=through_sequence,
+                limit=5000,
+            )
+            if not page:
+                break
+            records.extend(page)
+            cursor = page[-1].sequence
+        return records
+
+    async def _heartbeat(self, job_id: str) -> None:
+        interval = max(1.0, self._lease_seconds / 3.0)
+        while True:
+            await asyncio.sleep(interval)
+            renewed = await asyncio.to_thread(
+                self._store.renew_teacher_job,
+                job_id,
+                lease_owner=self._lease_owner,
+                lease_seconds=self._lease_seconds,
+            )
+            if not renewed:
+                return
+
+    async def _run(self) -> None:
+        while not self._closed:
+            self._wake.clear()
+            try:
+                outcome = await self.run_once()
+            except Exception:
+                logger.exception("teacher worker polling failed")
+                outcome = None
+            if outcome is not None:
+                continue
+            try:
+                await asyncio.wait_for(self._wake.wait(), timeout=self._poll_interval_s)
+            except asyncio.TimeoutError:
+                pass
+
+    @staticmethod
+    def _trajectory(records: Sequence[EvolutionEventRecord]) -> list[dict[str, Any]]:
+        starts: dict[str, EvolutionEvent] = {}
+        trajectory: list[dict[str, Any]] = []
+        for record in records:
+            event = record.event
+            action_id = event.context.action_id
+            if event.event_type == EvolutionEventType.ACTION_STARTED:
+                starts[action_id] = event
+                continue
+            if event.event_type not in {
+                EvolutionEventType.ACTION_COMPLETED,
+                EvolutionEventType.ACTION_FAILED,
+            }:
+                continue
+            started = starts.pop(action_id, None)
+            start_payload = started.payload if started is not None else {}
+            result = event.payload.get("result")
+            trajectory.append(
+                {
+                    "experience_id": "",
+                    "evidence_ids": [
+                        item
+                        for item in (
+                            started.event_id if started is not None else "",
+                            event.event_id,
+                        )
+                        if item
+                    ],
+                    "action_description": (
+                        f"{start_payload.get('action_type', 'action')}:"
+                        f"{start_payload.get('action_name', action_id or 'unknown')}"
+                    ),
+                    "predicted_effect": str(start_payload.get("goal") or "complete successfully"),
+                    "actual_effect": str(result if result is not None else event.payload),
+                    "delta": 0.0 if bool(event.payload.get("ok", False)) else 1.0,
+                }
+            )
+        for action_id, started in starts.items():
+            trajectory.append(
+                {
+                    "experience_id": "",
+                    "evidence_ids": [started.event_id],
+                    "action_description": (
+                        f"{started.payload.get('action_type', 'action')}:"
+                        f"{started.payload.get('action_name', action_id or 'unknown')}"
+                    ),
+                    "predicted_effect": str(started.payload.get("goal") or "complete successfully"),
+                    "actual_effect": "action did not record a terminal outcome",
+                    "delta": 1.0,
+                }
+            )
+        return trajectory
+
+
+__all__ = [
+    "DurableTeacherWorker",
+    "Teacher",
+    "TeacherJobOutcome",
+    "TeacherWorkerMetrics",
+    "TeacherWorkStore",
+]
diff --git a/src/leapflow/hardware/transports/__init__.py b/src/leapflow/hardware/transports/__init__.py
index 6397b648..c9cbfd9c 100644
--- a/src/leapflow/hardware/transports/__init__.py
+++ b/src/leapflow/hardware/transports/__init__.py
@@ -25,7 +25,7 @@
 
 TransportFactory = Callable[[Mapping[str, Any]], HardwareTransport]
 
-_TRANSPORTS: dict[str, str] = {
+_BUILTIN_TRANSPORTS: dict[str, str] = {
     # kind -> "module:factory", imported lazily so that an optional dependency in
     # one transport cannot break registry loading for the others.
     "mock": "leapflow.hardware.transports.mock:build_transport",
@@ -35,6 +35,7 @@
     "host": "leapflow.hardware.transports.host:build_transport",
     "media": "leapflow.hardware.transports.media:build_transport",
 }
+_TRANSPORTS: dict[str, str] = dict(_BUILTIN_TRANSPORTS)
 
 _EP_GROUP = "leapflow.hardware.transports"
 _ep_scanned: bool = False
@@ -83,11 +84,16 @@ def _discover_entry_points() -> None:
 
 
 def available_transports() -> tuple[str, ...]:
-    """Return the registered transport kinds, sorted for stable reporting."""
+    """Return all registered transport kinds, including discovered extensions."""
     _discover_entry_points()
     return tuple(sorted(_TRANSPORTS))
 
 
+def builtin_transports() -> tuple[str, ...]:
+    """Return core kinds whose conformance is owned by this repository."""
+    return tuple(sorted(_BUILTIN_TRANSPORTS))
+
+
 def register_transport(kind: str, target: str) -> Callable[[], None]:
     """Register a transport factory as ``"module:factory"``.
 
@@ -146,4 +152,9 @@ def build_transport(kind: str, config: Mapping[str, Any] | None = None) -> Hardw
     return factory(config or {})
 
 
-__all__ = ["available_transports", "build_transport", "register_transport"]
+__all__ = [
+    "available_transports",
+    "build_transport",
+    "builtin_transports",
+    "register_transport",
+]
diff --git a/src/leapflow/layout.py b/src/leapflow/layout.py
index 8315d589..d9560639 100644
--- a/src/leapflow/layout.py
+++ b/src/leapflow/layout.py
@@ -411,26 +411,15 @@ def dsh_plugins_dir(self) -> Path:
         return self.plugins_dir / "dsh"
 
     @property
-    def plugin_proposals_path(self) -> Path:
-        # Profile-scoped review queue for capability-gap → plugin proposals.
-        # It is durable user/profile state, not runtime scratch.
-        return self.root / "plugins" / "proposals.json"
+    def plugin_staging_dir(self) -> Path:
+        """Profile-owned quarantine area for plugin candidates under validation."""
+        return self.plugins_dir / ".staging"
 
     @property
     def capability_observations_path(self) -> Path:
         # Profile-scoped durable observation backlog for structured capability gaps.
         return self.root / "plugins" / "capability_observations.json"
 
-    @property
-    def capability_proposal_queue_path(self) -> Path:
-        # Profile-scoped adaptive proposal queue derived from capability observations.
-        return self.root / "plugins" / "proposal_queue.json"
-
-    @property
-    def plugin_outcomes_path(self) -> Path:
-        # Profile-scoped execution outcome audit for adaptive plugin lifecycle governance.
-        return self.root / "plugins" / "outcomes.json"
-
     @property
     def distilled_knowledge_path(self) -> Path:
         # Profile-scoped store for what the teacher distilled about the environment.
@@ -446,12 +435,14 @@ def capability_plans_path(self) -> Path:
         return self.root / "plugins" / "capability_plans.json"
 
     @property
-    def evolution_traces_path(self) -> Path:
-        # Profile-scoped framework self-evolution traces: registry mutations, trust
-        # transitions, world-model proposals, and lifecycle openings. Beside the
-        # capability stores because the causal ledger reads them together; distinct
-        # from them because these are facts no other store retains.
-        return self.root / "plugins" / "evolution_traces.json"
+    def evolution_artifacts_dir(self) -> Path:
+        """Content-addressed artifacts referenced by the evolution event log.
+
+        Large or sensitive payloads never belong in DuckDB event JSON. Generated
+        source, teacher responses, validation reports and replay media are stored by
+        digest here; the event stream carries only bounded metadata and the digest.
+        """
+        return self.root / "artifacts" / "sha256"
 
     @property
     def plugin_versions_dir(self) -> Path:
@@ -534,6 +525,7 @@ def ensure(self) -> None:
             self.skills_dir,
             self.plugins_dir,
             self.dsh_plugins_dir,
+            self.plugin_staging_dir,
             self.audit_dir,
             self.history_dir,
             self.runtime_dir,
diff --git a/src/leapflow/learning/degradation_sink.py b/src/leapflow/learning/degradation_sink.py
index df609e2c..01984263 100644
--- a/src/leapflow/learning/degradation_sink.py
+++ b/src/leapflow/learning/degradation_sink.py
@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, Callable, Mapping, Sequence
+from typing import Any, Callable, Mapping
 
 logger = logging.getLogger(__name__)
 
@@ -120,175 +120,82 @@ def sink(
     return sink
 
 
-def build_proposal_sink(*, queue: Any) -> Callable[..., str]:
-    """Return the sink that turns an accepted acquisition into a queued proposal.
-
-    The last hop of the acquisition chain, and it was missing: the driver derived an
-    ``EvolutionIntent`` from an ``acquire`` verdict, turned it into a requirement, and
-    stopped. Nothing enqueued it, so resolution reported the capability unmet forever and
-    the teacher's most expensive verdict -- the only one that leads to code -- had no
-    effect at all.
-
-    Queueing is not acting. The queue is read by the evolution dashboard and by the
-    ``self_management`` tools, both of which pass through approval before anything is
-    generated, so this hop makes the proposal *visible and actionable* rather than
-    executed. That separation is why the sink can be wired by default while generation
-    stays governed.
-
-    ``observation_ids`` and ``environment`` are threaded from the driver so the queue
-    item carries the evidence and the task environment it was born from. The causal
-    ledger joins a proposal back to its motivating observations by exactly these ids;
-    without them a queued acquisition is an orphan the ledger cannot reconstruct.
-    """
-
-    def sink(
-        proposal: Any,
-        *,
-        observation_ids: Sequence[str] = (),
-        environment: Any = None,
-    ) -> str:
-        requirement = _requirement_from(proposal)
-        if requirement is None:
-            # Without a capability the queue has nothing to deduplicate on and resolution
-            # has nothing to satisfy, so the item could never be closed.
-            logger.debug(
-                "proposal_sink: refused proposal without a capability (%r)",
-                getattr(proposal, "proposal_id", ""),
-            )
-            return ""
-        evidence = tuple(getattr(proposal, "evidence", ()) or ())
-        metadata = dict(getattr(evidence[0], "metadata", {})) if evidence else {}
-        env_payload = _environment_dict(environment)
-        try:
-            item = queue.enqueue(
-                requirements=(requirement,),
-                environment=env_payload,
-                source="world_model",
-                observation_ids=tuple(str(o) for o in observation_ids if str(o)),
-                risk={"max_risk_level": requirement.max_risk_level},
-                metadata={
-                    "plugin_id": str(getattr(proposal, "plugin_id", "")),
-                    "capability_summary": str(getattr(proposal, "capability_summary", "")),
-                    # The world model's own words and identity, carried so the ledger can
-                    # render "why this evolved" and so a reviewer sees the hypothesis.
-                    "intent_id": str(metadata.get("intent_id", "")),
-                    "confidence": str(metadata.get("confidence", "")),
-                    # Carried so a reviewer can see what a challenger is challenging, and
-                    # so a rival stays distinguishable from a gap fill for the same
-                    # capability.
-                    "replaces": str(metadata.get("replaces", "")),
-                },
-            )
-        except Exception:  # noqa: BLE001 - queueing must not fail the session
-            logger.debug("proposal_sink: could not enqueue", exc_info=True)
-            return ""
-        return str(getattr(item, "proposal_id", ""))
-
-    return sink
-
-
-def _environment_dict(environment: Any) -> dict[str, Any]:
-    """Coerce a fingerprint or mapping into the queue's plain-dict environment."""
-    if environment is None:
-        return {}
-    to_dict = getattr(environment, "to_dict", None)
-    if callable(to_dict):
-        try:
-            return dict(to_dict())
-        except Exception:  # noqa: BLE001 - a fingerprint is context, not a gate
-            return {}
-    if isinstance(environment, Mapping):
-        return dict(environment)
-    return {}
-
-
-def _requirement_from(proposal: Any) -> Any:
-    """Rebuild the requirement the queue keys on, from the proposal's own evidence.
-
-    ``max_risk_level`` is passed explicitly because the domain default is ``external`` --
-    the most permissive value there is. Omitting it would let a proposal that was clamped
-    to ``read_only`` enter the queue asking for everything, which is the opposite of what
-    the clamp exists for.
+def build_live_capability_resolver(
+    *,
+    registry_provider: Callable[[], Any],
+    environment_provider: Callable[[], Any],
+) -> Callable[[Any, Mapping[str, Any]], dict[str, Any]]:
+    """Build the mandatory resolution-before-acquisition gate.
 
-    ``requirement_id`` is derived from the capability rather than minted fresh, because the
-    queue deduplicates on a hash of the requirement payload. A new uuid on every rebuild
-    defeated that silently: the same capability enqueued a new proposal every session, so a
-    reviewer would face a growing pile of identical items and the health of the queue would
-    measure how long the process had been running.
+    The result is evidence, not authority. A resolved capability becomes a
+    durable no-op; only an unmet requirement may be turned into a proposal.
+    Resolution failure is reported explicitly so callers can fail closed.
     """
-    from leapflow.domain.capability_requirement import CapabilityRequirement
-
-    evidence = tuple(getattr(proposal, "evidence", ()) or ())
-    metadata = dict(getattr(evidence[0], "metadata", {})) if evidence else {}
-    capability = str(metadata.get("capability") or "").strip()
-    if not capability:
-        return None
-    return CapabilityRequirement.create(
-        capability,
-        "world_model",
-        evidence=str(getattr(proposal, "capability_summary", "") or capability),
-        max_risk_level=str(getattr(proposal, "risk_level", "read_only")),
-        requirement_id=f"req-wm-{capability}",
+    from leapflow.plugins.capability_resolver import (
+        CapabilityResolver,
+        DeclaredMatchScorer,
+        EnvironmentAffordanceScorer,
+        EnvironmentFitScorer,
+        ResolverContext,
+        RiskCostScorer,
+        candidates_from_registry,
     )
 
+    resolver = CapabilityResolver(
+        scorers=(
+            DeclaredMatchScorer(),
+            EnvironmentFitScorer(),
+            EnvironmentAffordanceScorer(),
+            RiskCostScorer(),
+        )
+    )
 
-def build_alternatives_provider(
-    *, registry_provider: Callable[[], Any], affordances_provider: Callable[[], Any] | None = None
-) -> Callable[[str, str], tuple[dict[str, Any], ...]]:
-    """Return a reader for the *other* providers of a capability, and whether each fits.
-
-    Without this the teacher is asked to choose between two actions whose definitions are
-    exactly the fact it was never given:
-
-        rebind  -- "another installed capability already covers the new environment"
-        acquire -- "nothing installed covers this"
-
-    It was shown a flat list of global capability *names* and nothing about how many
-    providers a capability has or whether any of them can run here. Measured on a real
-    model: ``rebind`` on 3 of 3 trials of a unit whose candidate set had one entry, then
-    three different answers in three trials once the catalogue stopped implying that
-    everything listed fits. That is what choosing without the deciding fact looks like.
-
-    Admissibility comes from the same declaration the resolver scores on
-    (``requires_environment_affordances``), so the teacher and the selection layer cannot
-    disagree about what is available. Reported, never enforced: the teacher may still
-    answer ``acquire`` when an alternative exists but is a poor fit, which is a judgement
-    only it can make.
-    """
-
-    def alternatives(capability: str, incumbent: str = "") -> tuple[dict[str, Any], ...]:
-        from leapflow.plugins.capability_resolver import candidates_from_registry
-
+    def resolve(intent: Any, job: Mapping[str, Any]) -> dict[str, Any]:
         try:
-            present = frozenset(str(a) for a in (affordances_provider() or ())) if affordances_provider else frozenset()
-        except Exception:  # noqa: BLE001 - unknown affordances must not hide alternatives
-            present = frozenset()
-        try:
-            candidates = candidates_from_registry(registry_provider())
-        except Exception:  # noqa: BLE001 - context, never a gate
-            logger.debug("alternatives: registry unavailable", exc_info=True)
-            return ()
-        rows: list[dict[str, Any]] = []
-        for candidate in candidates:
-            if capability not in candidate.provides_capabilities:
-                continue
-            if incumbent and candidate.plugin_id == incumbent:
-                continue
-            required = frozenset(candidate.requires_environment_affordances)
-            rows.append(
-                {
-                    "plugin_id": candidate.plugin_id,
-                    "tool_name": candidate.tool_name,
-                    # Unknown affordances read as "fits": claiming a candidate does not fit
-                    # because the environment could not be described would push every
-                    # verdict toward acquire, which is the expensive direction.
-                    "fits_here": (not required) or (not present) or required <= present,
-                    "requires": tuple(sorted(required)),
+            registry = registry_provider()
+            registry.assemble()
+            environment = environment_provider()
+            if environment is None:
+                return {
+                    "resolved": False,
+                    "satisfied": False,
+                    "reason": "environment_unavailable",
+                    "environment": {},
                 }
+            requirement = intent.to_requirement()
+            decision = resolver.resolve_one(
+                requirement,
+                candidates_from_registry(registry),
+                ResolverContext(environment=environment),
             )
-        return tuple(rows)
-
-    return alternatives
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            logger.warning("live capability resolution failed", exc_info=True)
+            return {
+                "resolved": False,
+                "satisfied": False,
+                "reason": "live_resolution_failed",
+                "environment": {},
+            }
+        selected = decision.selected
+        return {
+            "resolved": True,
+            "satisfied": selected is not None,
+            "reason": decision.reason,
+            "selected_plugin_id": (
+                selected.candidate.plugin_id if selected is not None else ""
+            ),
+            "selected_tool_name": (
+                selected.candidate.tool_name if selected is not None else ""
+            ),
+            "candidate_count": len(decision.candidates),
+            "environment": {
+                **environment.to_dict(),
+                "workspace_id": str(job.get("workspace_id") or ""),
+                "session_id": str(job.get("session_id") or ""),
+            },
+        }
+
+    return resolve
 
 
 def _retire(knowledge_store: Any, capabilities: tuple[str, ...], plugin_id: str) -> None:
@@ -307,8 +214,7 @@ def _retire(knowledge_store: Any, capabilities: tuple[str, ...], plugin_id: str)
 
 
 __all__ = [
-    "build_alternatives_provider",
     "build_degradation_sink",
-    "build_proposal_sink",
+    "build_live_capability_resolver",
     "declared_capabilities_by_plugin",
 ]
diff --git a/src/leapflow/learning/world_model_driver.py b/src/leapflow/learning/world_model_driver.py
deleted file mode 100644
index d771a409..00000000
--- a/src/leapflow/learning/world_model_driver.py
+++ /dev/null
@@ -1,716 +0,0 @@
-# Copyright (c) Alibaba, Inc. and its affiliates.
-"""The world model as the first driver of capability self-evolution.
-
-``TrajectoryGrader.grade_and_propose`` can emit an :class:`EvolutionIntent`, and
-the observation pipeline can turn a declared intent into a governed
-``CapabilityRequirement``. Nothing joined the two, so the world model could form a
-capability hypothesis that no part of the system ever received. This driver is
-that join, and it is deliberately the *only* one.
-
-Where it runs, and why that is safe:
-
-* **Cold path, once per episode.** It is invoked at the session-end learning
-  boundary, after a trajectory is flushed -- never inside a turn. The teacher's own
-  ``grading`` budget pool bounds how often it can spend an LLM call, so making the
-  world model the first driver adds no per-turn cost.
-* **Privileged context, not privileged authority.** The teacher sees the whole
-  trajectory with actual outcomes (hindsight the acting policy never had), which is
-  what lets it notice a capability was *missing* rather than merely used badly. It
-  still only proposes: each intent is written as ordinary structured evidence and
-  must pass the classifier, the detector, resolution, risk classification,
-  approval, validation and trust exactly like an ``unknown_tool`` signal.
-* **Opt-in.** Admission is decided by ``CapabilityEvidenceClassifier``. Until an
-  operator adds ``world_model_intent`` to ``accepted_evidence_kinds``, intents are
-  reported as *proposed but not admitted* and change nothing. The driver never
-  writes around that gate.
-* **Clamped.** Every intent is rendered with an explicit ``risk_ceiling``, so a
-  model cannot widen the risk cap of the capability it is asking for.
-"""
-
-from __future__ import annotations
-
-import inspect
-import logging
-from dataclasses import dataclass, field
-from typing import Any, Mapping, Protocol, Sequence, runtime_checkable
-
-from leapflow.domain.capability_requirement import CapabilityRequirement
-from leapflow.domain.evolution_intent import (
-    MODEL_AUTHORED_RISK_CEILING,
-    WORLD_MODEL_ORIGIN,
-    EvolutionIntent,
-)
-from leapflow.domain.plugin_proposal import RiskLevel
-
-logger = logging.getLogger(__name__)
-
-#: Exception types that mean "this call was wired wrongly", not "this datum was bad".
-#: They are separated from the resilient catch-all so a contract break is reported
-#: instead of being absorbed as one more skipped intent.
-_INTERNAL_DEFECTS = (TypeError, AttributeError, NameError)
-
-
-def _accepted_kwargs(target: Any, candidates: Sequence[str]) -> frozenset[str]:
-    """Which of ``candidates`` this callable can actually receive by keyword.
-
-    Optional context must stay optional. A collaborator supplied by a caller keeps
-    whatever signature it was written against, so newer keywords are offered only to
-    the ones that declare them (or accept ``**kwargs``). When the signature cannot be
-    read -- a builtin, a C callable -- nothing extra is passed, which is the safe
-    direction: the original positional contract always works.
-    """
-    if target is None:
-        return frozenset()
-    try:
-        parameters = inspect.signature(target).parameters
-    except (TypeError, ValueError):
-        return frozenset()
-    if any(p.kind is inspect.Parameter.VAR_KEYWORD for p in parameters.values()):
-        return frozenset(candidates)
-    return frozenset(name for name in candidates if name in parameters)
-
-
-@runtime_checkable
-class CapabilityGapTeacher(Protocol):
-    """A hindsight evaluator that can also propose capability gaps.
-
-    Structural rather than a concrete import so the driver does not bind the
-    learning layer to ``world_model``, and so a recorded or stub teacher can be
-    substituted in tests and experiments.
-    """
-
-    async def grade_and_propose(
-        self, trajectory: list[dict], goal: str = "", **kwargs: Any
-    ) -> Any:
-        """Return an object exposing ``grades`` and ``intents``.
-
-        ``**kwargs`` keeps this structural contract open: the driver passes
-        ``degraded_capabilities`` when it has any, and a teacher that predates that
-        context stays conformant by ignoring it.
-        """
-        ...
-
-
-@runtime_checkable
-class EvidenceIntake(Protocol):
-    """The governed intake an intent must pass through."""
-
-    def observe_result(
-        self, result: Mapping[str, Any] | None, **kwargs: Any
-    ) -> dict[str, Any] | None:
-        """Persist admitted evidence; return ``None`` when the gate rejects it."""
-        ...
-
-    def requirements(
-        self, *, min_count: int = 1, limit: int = 50
-    ) -> tuple[CapabilityRequirement, ...]:
-        """Derive requirements from admitted evidence."""
-        ...
-
-
-@dataclass(frozen=True)
-class WorldModelDriveResult:
-    """What one world-model-driven evolution pass produced.
-
-    ``proposed`` counts every intent the teacher formed; ``admitted`` counts those
-    the evidence gate accepted. The two differ whenever the operator has not opted
-    in, which is the normal default -- so a non-zero ``proposed`` with an empty
-    ``admitted`` is a correct, quiet outcome, not a failure.
-
-    Admission is only the first gate. An admitted requirement then passes the
-    authority filter: a hypothesis whose requirement origin the operator has not
-    authorised to drive acquisition is recorded in ``unauthorised`` -- a durable no-op,
-    the record of *why the framework did not change*, not dropped telemetry. Whether an
-    installed provider already covers the capability (rebind vs acquire) is decided
-    upstream by the teacher, which sees the failed-outcome hindsight the resolver never
-    does; re-checking it here by declared fitness would re-introduce the blind spot the
-    world model exists to bypass, so the driver does not.
-    """
-
-    grades: tuple[Any, ...] = ()
-    #: Everything the teacher concluded, across all four actions. ``intents`` below is
-    #: the ``acquire`` subset, so the cheap verdicts stay visible instead of being
-    #: dropped for not writing code -- three of the four change nothing except what the
-    #: acting agent knows, which is the point of asking.
-    verdicts: tuple[Any, ...] = ()
-    #: Capabilities whose knowledge was written to the distilled store this session.
-    #: The C1 channel's receipt: a session that adapted purely by teaching the next one
-    #: something has this non-empty and everything else empty.
-    distilled: tuple[str, ...] = ()
-    intents: tuple[EvolutionIntent, ...] = ()
-    admitted_observation_ids: tuple[str, ...] = ()
-    requirements: tuple[CapabilityRequirement, ...] = field(default_factory=tuple)
-    #: Proposals queued for governed acquisition. Empty when no sink is installed,
-    #: which is the default: an intent then reaches a requirement and stops there.
-    queued_proposal_ids: tuple[str, ...] = ()
-    #: Capabilities whose requirement origin may not authorise an acquisition. A
-    #: durable no-op, retired with its reason, so a rejected authority branch is
-    #: reconstructable rather than invisible.
-    unauthorised: tuple[str, ...] = ()
-
-    @property
-    def proposed(self) -> int:
-        return len(self.intents)
-
-    @property
-    def admitted(self) -> int:
-        return len(self.admitted_observation_ids)
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "graded_actions": len(self.grades),
-            "proposed": self.proposed,
-            "admitted": self.admitted,
-            "queued": len(self.queued_proposal_ids),
-            "unauthorised": list(self.unauthorised),
-            "capabilities": sorted({r.capability for r in self.requirements}),
-            # Counted per action so a session that adapted purely by distilling
-            # knowledge is distinguishable from one that did nothing.
-            "distilled": list(self.distilled),
-            "by_action": {
-                action: sum(1 for v in self.verdicts if getattr(v, "action", "") == action)
-                for action in ("absorb", "rebind", "acquire", "escalate")
-            },
-        }
-
-class WorldModelEvolutionDriver:
-    """Turn hindsight capability hypotheses into governed requirements."""
-
-    def __init__(
-        self,
-        *,
-        teacher: CapabilityGapTeacher,
-        intake: EvidenceIntake,
-        risk_ceiling: RiskLevel = MODEL_AUTHORED_RISK_CEILING,
-        source: str = "world_model",
-        degraded_capabilities: Any = None,
-        proposal_sink: Any = None,
-        knowledge_store: Any = None,
-        alternatives_for: Any = None,
-        authorising_origins: Sequence[str] = (),
-    ) -> None:
-        self._teacher = teacher
-        self._intake = intake
-        self._risk_ceiling = risk_ceiling
-        self._source = source
-        # Facts the teacher needs in order to adjudicate a *replacement*: which
-        # capabilities have a provider that keeps failing while still in service.
-        # Injected as a callable so the driver does not bind to a store, and so a
-        # deployment without governance wiring simply grades without them.
-        self._degraded_capabilities = degraded_capabilities
-        # Where an intent becomes a queued ``PluginProposal``. Without it an intent
-        # reaches a requirement and stops: resolution reports the capability unmet and
-        # nothing turns that into an acquisition. This is the last hop of the chain,
-        # and it stays optional because queueing proposals is a governed, opt-in
-        # capability rather than something grading should do by default.
-        self._proposal_sink = proposal_sink
-        # Which optional context this particular sink accepts. The sink is caller-supplied
-        # and its original contract was ``sink(proposal)``; passing newer keywords
-        # unconditionally raised ``TypeError`` inside the per-intent guard below, which
-        # swallowed it at debug level and silently stopped queueing *every* acquisition
-        # for any sink that had not adopted them. Resolving the signature once keeps the
-        # extra causal context additive instead of breaking the contract.
-        self._sink_kwargs = _accepted_kwargs(
-            proposal_sink, ("observation_ids", "environment")
-        )
-        # Where the cheap verdicts land. Three of the four actions change nothing except
-        # what the acting agent knows, so without this they would be graded, traced, and
-        # then thrown away -- the teacher would have judged correctly and the next
-        # session would repeat the same mistake. Optional so a deployment without the
-        # store still grades and still acquires.
-        self._knowledge_store = knowledge_store
-        # The other providers of a degraded capability, and whether each can run here.
-        # Without it the teacher must choose between ``rebind`` ("another installed
-        # capability covers this") and ``acquire`` ("nothing does") without being told
-        # which is true -- the deciding fact for both.
-        self._alternatives_for = alternatives_for
-        # Requirement origins permitted to drive an acquisition. Empty means
-        # unrestricted (shipped default). Setting it to ``("world_model",)`` is the
-        # executable form of "self-evolution's first driver is the world model": a
-        # requirement of any other origin is retired as a no-op rather than queued.
-        self._authorising_origins = tuple(
-            str(origin) for origin in (authorising_origins or ()) if str(origin)
-        )
-
-    async def drive(
-        self,
-        trajectory: Sequence[Mapping[str, Any]],
-        goal: str = "",
-        *,
-        environment: Any = None,
-        session_id: str = "",
-        turn_id: str = "",
-        workspace_root: str = "",
-    ) -> WorldModelDriveResult:
-        """Grade the episode, then submit any capability gap it revealed.
-
-        Returns an empty result rather than raising: this runs on a learning
-        boundary, and a failure to learn must never fail the session that produced
-        the trajectory.
-        """
-        if not trajectory:
-            return WorldModelDriveResult()
-        degraded = self._collect_degraded()
-        try:
-            verdict = await self._teacher.grade_and_propose(
-                list(trajectory), goal, degraded_capabilities=degraded
-            )
-        except TypeError:
-            # A teacher that does not accept the newer context: grade without it
-            # rather than lose the episode's grading entirely.
-            try:
-                verdict = await self._teacher.grade_and_propose(list(trajectory), goal)
-            except Exception:  # noqa: BLE001 - teacher is advisory
-                logger.debug("world_model_driver: teacher failed", exc_info=True)
-                return WorldModelDriveResult()
-        except Exception:  # noqa: BLE001 - teacher is advisory; never fail the session
-            logger.debug("world_model_driver: teacher failed", exc_info=True)
-            return WorldModelDriveResult()
-
-        grades = tuple(getattr(verdict, "grades", ()) or ())
-        verdicts = tuple(getattr(verdict, "verdicts", ()) or ())
-        # Only ``acquire`` becomes an intent. The other three are conclusions about the
-        # environment, and forwarding them into the acquisition path would turn a
-        # recommendation to rebind into a request to write code.
-        intents = tuple(getattr(verdict, "intents", ()) or ())
-        # Distil before branching on ``intents``: a session whose every verdict was
-        # ``absorb`` adapted the system, and it is the *only* thing that happened.
-        distilled = self._distil(verdicts, environment)
-        if not intents:
-            # Still a real outcome: the teacher may have concluded the change is
-            # absorbable, which is the cheapest and most common correct answer.
-            return WorldModelDriveResult(
-                grades=grades, verdicts=verdicts, distilled=distilled
-            )
-
-        admitted: list[str] = []
-        # The intents the gate actually accepted, kept alongside their observation ids.
-        # Collecting only the ids was enough to *count* admissions and not enough to
-        # act on them: queueing then received every intent whenever any one of them was
-        # admitted, so a rejected hypothesis reached the proposal queue through a side
-        # door -- the exact bypass the opt-in gate exists to prevent.
-        admitted_intents: list[EvolutionIntent] = []
-        # capability -> the observation ids that motivated it, so a queued proposal can
-        # carry the evidence back to the causal ledger instead of minting a fresh id
-        # the ledger cannot join.
-        obs_by_capability: dict[str, list[str]] = {}
-        for intent in intents:
-            try:
-                record = self._intake.observe_result(
-                    intent.to_observation_result(risk_ceiling=self._risk_ceiling),
-                    environment=environment,
-                    source=self._source,
-                    session_id=session_id,
-                    turn_id=turn_id,
-                    workspace_root=workspace_root,
-                )
-            except (OSError, RuntimeError, TypeError, ValueError, AttributeError):
-                logger.debug("world_model_driver: intake rejected an intent", exc_info=True)
-                continue
-            if record is not None:
-                observation_id = str(record.get("observation_id") or "")
-                if observation_id:
-                    admitted.append(observation_id)
-                    admitted_intents.append(intent)
-                    obs_by_capability.setdefault(intent.capability, []).append(
-                        observation_id
-                    )
-
-        requirements: tuple[CapabilityRequirement, ...] = ()
-        if admitted:
-            try:
-                requirements = self._intake.requirements(min_count=1)
-            except (OSError, RuntimeError, TypeError, ValueError, AttributeError):
-                logger.debug("world_model_driver: requirement derivation failed", exc_info=True)
-        if intents and not admitted:
-            logger.debug(
-                "world_model_driver: %d intent(s) proposed but not admitted; add "
-                "'world_model_intent' to accepted_evidence_kinds to enable",
-                len(intents),
-            )
-        queued, unauthorised = self._govern(
-            admitted_intents, requirements, environment, obs_by_capability, degraded
-        )
-        result = WorldModelDriveResult(
-            grades=grades,
-            verdicts=verdicts,
-            distilled=distilled,
-            intents=intents,
-            admitted_observation_ids=tuple(admitted),
-            requirements=requirements,
-            queued_proposal_ids=queued,
-            unauthorised=unauthorised,
-        )
-        self._trace_drive(result)
-        return result
-
-    def _govern(
-        self,
-        admitted_intents: Sequence[EvolutionIntent],
-        requirements: Sequence[CapabilityRequirement],
-        environment: Any,
-        obs_by_capability: Mapping[str, Sequence[str]],
-        degraded: Sequence[Mapping[str, Any]],
-    ) -> tuple[tuple[str, ...], tuple[str, ...]]:
-        """Turn admitted hypotheses into queued proposals, gated by authority.
-
-        One gate stands between an admitted hypothesis and a queued proposal, and it
-        records its rejections rather than dropping them: a requirement whose origin
-        ``authorising_origins`` does not permit is retired with ``origin_not_authorised``
-        -- the executable form of "only the world model may drive acquisition".
-
-        There is deliberately no second, declared-fitness resolution-first gate here.
-        Rebind-vs-acquire -- whether an installed provider already covers the capability
-        in this environment -- is decided upstream by the teacher, which reasons from
-        failed-outcome hindsight and the alternatives it was shown. A declared-fitness
-        re-check would count a behaviourally broken but structurally present incumbent as
-        "satisfied" and suppress exactly the semantic-regression acquire the world model
-        exists to catch, so the acquire verdict is trusted as the resolution result.
-
-        Only what survives authority is queued, and the scope is this session's admitted
-        intents -- they are by construction what this episode produced, so a stale
-        requirement from an earlier episode cannot be re-queued here. The proposal is
-        built from the intent itself (``proposal_from_evolution_intent``), so queueing
-        deliberately does not wait on the store having derived a requirement row: an
-        intersection with the requirement backlog silently made acquisition depend on
-        store thresholds and dropped every proposal when the backlog was empty.
-        """
-        if not admitted_intents:
-            return (), ()
-        capabilities = tuple(
-            sorted({str(getattr(i, "capability", "")) for i in admitted_intents} - {""})
-        )
-        # Everything this driver admits is world-model-authored, so authority is a
-        # single question about that origin rather than a per-requirement lookup.
-        if not self._origin_authorised(WORLD_MODEL_ORIGIN):
-            for capability in capabilities:
-                self._record_no_op(capability, "origin_not_authorised")
-            return (), capabilities
-
-        queued = self._queue_proposals(
-            list(admitted_intents),
-            degraded,
-            obs_by_capability,
-            environment,
-        )
-        return queued, ()
-
-    def _origin_authorised(self, origin: str) -> bool:
-        """Whether ``authorising_origins`` permits this origin to drive acquisition.
-
-        Empty ``authorising_origins`` is unrestricted, so everything is authorised --
-        the shipped default. The check is the same ``origin_may_authorise`` the
-        resolution-first gap gate uses on the observation path, so the driver and the
-        loop cannot disagree about who may authorise an acquisition.
-        """
-        if not self._authorising_origins:
-            return True
-        from leapflow.learning.outcome_governance_feed import origin_may_authorise
-
-        return bool(origin_may_authorise(origin, self._authorising_origins))
-
-    def _record_no_op(self, capability: str, reason: str) -> None:
-        """Retire a capability's evidence as a durable no-op, and trace why.
-
-        A no-op branch is a first-class result: it is *why the framework did not
-        change*. Retiring the observation with a reason makes it reconstructable from
-        the store (the ledger reads observation status), and the trace makes it visible
-        on the board. Contained: bookkeeping a no-op must never fail the session.
-        """
-        resolver = getattr(self._intake, "resolve_capability", None)
-        if callable(resolver):
-            try:
-                resolver(capability, reason=reason)
-            except Exception:  # noqa: BLE001 - retirement is advisory
-                logger.debug(
-                    "world_model_driver: could not retire %s (%s)",
-                    capability, reason, exc_info=True,
-                )
-        self._trace_no_op(capability, reason)
-
-    def _distil(self, verdicts: Any, environment: Any) -> tuple[str, ...]:
-        """Persist what each verdict concluded, returning the capabilities recorded.
-
-        Contained: distillation improves the *next* session's context, so failing to
-        write it must not fail this one. Returns capability names rather than entries
-        because the caller reports counts and the entries live in the store.
-        """
-        if self._knowledge_store is None or not verdicts:
-            return ()
-        env = {}
-        if environment is not None and hasattr(environment, "to_dict"):
-            try:
-                env = dict(environment.to_dict())
-            except Exception:  # noqa: BLE001 - a fingerprint is context, not a gate
-                env = {}
-        try:
-            stored = self._knowledge_store.record_all(verdicts, environment=env)
-            return tuple(entry.capability for entry in stored)
-        except Exception:  # noqa: BLE001 - distillation must never fail a session
-            logger.debug("world_model_driver: distillation failed", exc_info=True)
-            return ()
-
-    def _collect_degraded(self) -> tuple[Mapping[str, Any], ...]:
-        """Degradation facts for the teacher, filtered and environment-tagged.
-
-        Prefers the intake's own reader when it has one, so the two rules that make
-        this evidence usable -- retry-owned classes excluded, environment fingerprint
-        attached -- are applied in one place rather than re-derived here. An explicit
-        provider still wins, which is what lets an experiment substitute its own view.
-        """
-        provider = self._degraded_capabilities
-        if provider is None:
-            provider = getattr(self._intake, "degraded_capabilities", None)
-        if provider is None:
-            return ()
-        try:
-            facts = tuple(provider() or ())
-        except Exception:  # noqa: BLE001 - missing context degrades grading, not the session
-            logger.debug("world_model_driver: degradation facts unavailable", exc_info=True)
-            return ()
-        return self._with_alternatives(self._with_prior_verdicts(facts))
-
-    def _with_prior_verdicts(
-        self, facts: tuple[Mapping[str, Any], ...]
-    ) -> tuple[Mapping[str, Any], ...]:
-        """Attach what was concluded last time about each still-failing capability.
-
-        This is the feedback edge, and without it the loop is open: the teacher would be
-        shown the same degradation every session and could only ever reach the same
-        conclusion, having no way to learn that its previous answer did not work.
-
-        Deliberately stated as *fact*, not as a verdict on the verdict. Knowledge existing
-        while the capability still fails is evidence that the previous adaptation did not
-        resolve it -- not proof the judgement was wrong. The student may never have used
-        the knowledge, or the environment may have moved again, or this may be a different
-        failure. Which of those it is, is exactly what the teacher is for.
-        """
-        if self._knowledge_store is None or not facts:
-            return facts
-        enriched: list[Mapping[str, Any]] = []
-        for fact in facts:
-            capability = str(fact.get("capability") or "")
-            try:
-                prior = self._knowledge_store.for_capability(capability)
-            except Exception:  # noqa: BLE001 - context, never a gate
-                prior = None
-            if prior is None:
-                enriched.append(fact)
-                continue
-            merged = dict(fact)
-            merged["prior_action"] = prior.action
-            merged["prior_knowledge"] = prior.knowledge
-            enriched.append(merged)
-        return tuple(enriched)
-
-    def _with_alternatives(
-        self, facts: tuple[Mapping[str, Any], ...]
-    ) -> tuple[Mapping[str, Any], ...]:
-        """Attach the other providers of each degraded capability.
-
-        Answers the question the action space is defined by. A teacher that cannot see
-        whether an alternative exists is guessing between rebind and acquire, and the
-        measured behaviour was exactly that.
-        """
-        if self._alternatives_for is None or not facts:
-            return facts
-        enriched: list[Mapping[str, Any]] = []
-        for fact in facts:
-            try:
-                rows = tuple(
-                    self._alternatives_for(
-                        str(fact.get("capability") or ""), str(fact.get("plugin_id") or "")
-                    )
-                    or ()
-                )
-            except Exception:  # noqa: BLE001 - context, never a gate
-                logger.debug("world_model_driver: alternatives unavailable", exc_info=True)
-                enriched.append(fact)
-                continue
-            merged = dict(fact)
-            merged["alternatives"] = rows
-            enriched.append(merged)
-        return tuple(enriched)
-
-    def _queue_proposals(
-        self,
-        admitted_intents: Sequence[EvolutionIntent],
-        degraded: Sequence[Mapping[str, Any]] = (),
-        obs_by_capability: Mapping[str, Sequence[str]] | None = None,
-        environment: Any = None,
-    ) -> tuple[str, ...]:
-        """Turn *unmet* intents into queued proposals, if a sink is installed.
-
-        Takes only the intents that survived the authority and resolution-first gates,
-        never the full admitted set: an intent the operator has not opted into, or one
-        the catalog already satisfies, must not become a queued acquisition by a side
-        door. The proposal itself mutates nothing -- generation and installation remain
-        separately approval-gated -- so queueing is the last *observation-only* step.
-
-        The motivating ``observation_ids`` and the task ``environment`` travel with the
-        proposal so the causal ledger can join a queued acquisition back to the evidence
-        that produced it, rather than facing a proposal minted from nowhere.
-
-        An intent whose capability appears in ``degraded`` is queued as a *rival* to the
-        named incumbent rather than as a gap fill. That is a factual lookup against the
-        degradation record, not a reading of the hypothesis: the record exists precisely
-        because a provider is installed and failing. Without the distinction the rival
-        would be named after the capability alone, collide with the incumbent's own
-        generated name, and never be able to coexist with the thing it competes against.
-
-        Each proposal is built with the clamped risk ceiling, so a model cannot widen
-        the risk cap of what it is asking to have built.
-        """
-        if self._proposal_sink is None or not admitted_intents:
-            return ()
-        obs_map = {k: tuple(v) for k, v in dict(obs_by_capability or {}).items()}
-        incumbents = {
-            str(item.get("capability") or ""): str(item.get("plugin_id") or "")
-            for item in degraded or ()
-            if item.get("capability")
-        }
-        queued: list[str] = []
-        try:
-            from leapflow.learning.capability_gap_detector import CapabilityGapDetector
-
-            detector = CapabilityGapDetector()
-        except Exception:  # noqa: BLE001
-            logger.debug("world_model_driver: detector unavailable", exc_info=True)
-            return ()
-        for intent in admitted_intents:
-            try:
-                proposal = detector.proposal_from_evolution_intent(
-                    intent,
-                    risk_ceiling=self._risk_ceiling,
-                    incumbent=incumbents.get(str(getattr(intent, "capability", "")), ""),
-                )
-                extra: dict[str, Any] = {}
-                if "observation_ids" in self._sink_kwargs:
-                    extra["observation_ids"] = obs_map.get(
-                        str(getattr(intent, "capability", "")), ()
-                    )
-                if "environment" in self._sink_kwargs:
-                    extra["environment"] = environment
-                identifier = self._proposal_sink(proposal, **extra)
-            except _INTERNAL_DEFECTS:
-                # A wiring fault, not a bad intent: the sink or the detector was called
-                # wrongly. Logged loudly because the loop continues -- at debug level
-                # this exact case hid a regression that silently disabled queueing.
-                logger.warning(
-                    "world_model_driver: proposal sink rejected the call for %r; "
-                    "acquisition not queued",
-                    getattr(intent, "capability", ""),
-                    exc_info=True,
-                )
-                continue
-            except Exception:  # noqa: BLE001 - one bad intent must not stop the rest
-                logger.debug("world_model_driver: proposal not queued", exc_info=True)
-                continue
-            queued.append(str(identifier or getattr(proposal, "proposal_id", "")))
-        return tuple(q for q in queued if q)
-
-    def _trace_no_op(self, capability: str, reason: str) -> None:
-        """Emit the no-op branch as a first-class evolution fact.
-
-        An unauthorised requirement is *why the framework did not change*, which the
-        co-evolution contract requires to be as visible as why it did. Emitting it here
-        means the board can distinguish "the world model saw a gap it was not permitted
-        to act on" from "the world model saw nothing".
-        """
-        try:
-            from leapflow.domain.evolution_trace import EvolutionStage
-            from leapflow.telemetry.evolution_tap import emit_trace, is_enabled
-
-            if not is_enabled():
-                return
-            emit_trace(
-                EvolutionStage.DECIDE,
-                "world_model_no_op",
-                correlation={"capability": str(capability)},
-                summary=f"{capability}: {reason}",
-                detail={"capability": str(capability), "reason": str(reason)},
-            )
-        except Exception:  # noqa: BLE001 - the teacher is advisory; telemetry more so
-            logger.debug("world_model_driver: no-op trace failed", exc_info=True)
-
-    def _trace_drive(self, result: WorldModelDriveResult) -> None:
-        """Emit what the teacher concluded, admitted or not.
-
-        The highest-value probe in the system, because of the case it is the only
-        record of: an intent that was *proposed and not admitted* writes no
-        observation, so it exists nowhere durable and vanishes with the process. The
-        board would otherwise show a silent, idle pipeline while the world model was
-        in fact proposing on every session -- indistinguishable from a model that had
-        nothing to say.
-
-        Not admitting is a legitimate quiet outcome, not a failure: the evidence kind
-        simply is not in ``accepted_evidence_kinds``. The trace says which it was so
-        a reader can tell "switched off" from "nothing happening".
-        """
-        try:
-            from leapflow.domain.evolution_trace import EvolutionStage
-            from leapflow.telemetry.evolution_tap import emit_trace, is_enabled
-
-            if not is_enabled():
-                return
-            intents = result.intents
-            admitted = result.admitted_observation_ids
-            emit_trace(
-                EvolutionStage.OBSERVE,
-                "world_model_drive",
-                correlation={
-                    "intent_ids": ",".join(
-                        str(getattr(i, "intent_id", "")) for i in intents
-                    ),
-                },
-                summary=(
-                    f"teacher returned {len(result.verdicts)} verdict(s); "
-                    f"{len(intents)} acquire, admitted {len(admitted)}"
-                    if result.verdicts
-                    else "teacher proposed nothing"
-                ),
-                detail={
-                    # The model's own hypothesis, rationale, expected effect and
-                    # confidence -- the only structured answer to "why should this
-                    # evolve" that exists anywhere.
-                    "verdicts": [
-                        dict(v.to_dict()) if hasattr(v, "to_dict") else {}
-                        for v in result.verdicts
-                    ],
-                    "intents": [self._intent_detail(i) for i in intents],
-                    "admitted_observation_ids": list(admitted),
-                    "queued_proposal_ids": list(result.queued_proposal_ids),
-                    "unauthorised": list(result.unauthorised),
-                    "graded": len(result.grades),
-                    "requirements": len(result.requirements),
-                    "not_admitted_reason": (
-                        "world_model_intent is not in accepted_evidence_kinds"
-                        if intents and not admitted
-                        else ""
-                    ),
-                },
-            )
-        except Exception:  # noqa: BLE001 - the teacher is advisory; telemetry more so
-            logger.debug("world_model_driver: evolution trace failed", exc_info=True)
-
-    @staticmethod
-    def _intent_detail(intent: Any) -> dict[str, Any]:
-        """Serialise an intent defensively -- a teacher-authored object may be partial."""
-        to_dict = getattr(intent, "to_dict", None)
-        if callable(to_dict):
-            try:
-                return dict(to_dict())
-            except Exception:  # noqa: BLE001
-                pass
-        return {
-            key: getattr(intent, key, "")
-            for key in ("intent_id", "capability", "hypothesis", "confidence")
-        }
-
-
-__all__ = [
-    "CapabilityGapTeacher",
-    "EvidenceIntake",
-    "WorldModelDriveResult",
-    "WorldModelEvolutionDriver",
-]
diff --git a/src/leapflow/monitor/evolution_producer.py b/src/leapflow/monitor/evolution_producer.py
index 541bfaad..dc512eb7 100644
--- a/src/leapflow/monitor/evolution_producer.py
+++ b/src/leapflow/monitor/evolution_producer.py
@@ -141,7 +141,8 @@ async def observe(self, ctx: ProducerContext) -> Sequence[Finding]:
         with it, and the failure it would report is its own.
         """
         try:
-            payload = self._build_payload(ctx)
+            projection = await self._event_projection(ctx)
+            payload = self._build_payload(ctx, event_projection=projection)
         except Exception:  # noqa: BLE001 - observability must not break the cycle
             # Logged at warning, not debug: every read inside is individually
             # guarded and degrades to an ``unverifiable`` row, so reaching this
@@ -225,19 +226,19 @@ def _fiber_transitions(
             )
         return rows
 
-    def _build_payload(self, ctx: ProducerContext) -> dict[str, Any]:
+    def _build_payload(
+        self,
+        ctx: ProducerContext,
+        *,
+        event_projection: Mapping[str, Any] | None = None,
+    ) -> dict[str, Any]:
         snapshot = self._live_registry_snapshot()
-        rebuilt = self._episodes(ctx)
-        # ``None`` means the history could not be rebuilt; ``()`` means there is
-        # genuinely none. Collapsing the two would report a local defect as an
-        # absence of data -- the same conflation the reachability rows exist to
-        # prevent, and it would be inconsistent for this panel to commit it.
-        episodes: tuple[Any, ...] = rebuilt or ()
+        episodes: tuple[Any, ...] = ()
         # Traces are read before reachability because three of its rows are decided
         # by whether the cold-path sweep left a trace. Deriving them from anything
         # else is how they came to be hardcoded.
         traces = self._recent_traces()
-        reachability = self._reachability(snapshot, traces)
+        reachability = self._reachability(snapshot, traces, event_projection)
         payload: dict[str, Any] = {
             "observed_at": float(getattr(ctx, "now", 0.0) or 0.0),
             "roster": snapshot["roster"],
@@ -279,22 +280,28 @@ def _build_payload(self, ctx: ProducerContext) -> dict[str, Any]:
         payload["trace_feed"] = self._trace_feed(traces)
         payload["unadmitted"] = self._unadmitted(traces)
         payload["reward_bandwidth"] = self._reward_bandwidth(traces, episodes)
-        if rebuilt is None:
+        payload["summary"] = self._summary(snapshot, reachability, episodes, traces)
+        if event_projection is None:
+            payload["degraded"] = True
             payload["degraded_kind"] = UNVERIFIABLE
             payload["degraded_reason"] = (
-                "The causal history could not be rebuilt: the decision or observation "
-                "records could not be read. This is a fault to investigate, not an "
-                "absence of activity. The live snapshot and pipeline reachability below "
-                "are unaffected."
+                "The append-only evolution projection could not be read. This is a "
+                "runtime fault, not an absence of activity."
             )
-        elif not episodes:
+            return payload
+
+        projected = dict(event_projection)
+        projected_summary = dict(projected.pop("summary", {}) or {})
+        payload.update(projected)
+        payload["summary"] = {**payload["summary"], **projected_summary}
+        if payload.get("degraded"):
             payload["degraded_kind"] = NO_EVIDENCE
             payload["degraded_reason"] = (
-                "No capability decision has been recorded yet, so there is no causal "
-                "history to rebuild. The live snapshot and pipeline reachability below "
-                "are unaffected."
+                "No evolution event has been recorded in this scope yet."
             )
-        payload["summary"] = self._summary(snapshot, reachability, episodes, traces)
+        else:
+            payload.pop("degraded_kind", None)
+            payload.pop("degraded_reason", None)
         return payload
 
     # ── live traces (facts no store retains) ─────────────────────────────
@@ -302,37 +309,24 @@ def _build_payload(self, ctx: ProducerContext) -> dict[str, Any]:
     def _recent_traces(self) -> list[dict[str, Any]]:
         """Flush the probe buffer, then read the newest traces back.
 
-        Flushing here rather than on a separate schedule is what keeps the panel and
-        the file consistent: this producer is the only consumer, and it runs on the
-        monitor tick, which is the cold path the tap's contract requires. Probe sites
-        therefore only ever buffer.
-
-        Empty is the normal state -- no sink is installed outside the daemon, and a
-        framework that has not mutated has nothing to report. Distinguished from a
-        read failure only in the log, because unlike the episode history there is no
-        "records exist but are unreadable" case to mistake it for: the store treats a
-        corrupt file as empty by design.
+        Flushing here rather than on a separate schedule keeps the panel aligned
+        with the append-only event stream. Probe sites only buffer; the monitor tick
+        performs the durable write through the daemon-owned event store adapter.
         """
         try:
             from leapflow.telemetry.evolution_tap import current_sink
 
             sink = current_sink()
-            if sink is not None and hasattr(sink, "flush"):
+            if sink is None:
+                return []
+            if hasattr(sink, "flush"):
                 sink.flush()
-        except Exception:  # noqa: BLE001 - a failed flush costs freshness, not the cycle
-            logger.debug("evolution producer: trace flush failed", exc_info=True)
-        store = self._json_store(
-            "evolution_traces_path", "evolution_trace_store", "JsonEvolutionTraceStore"
-        )
-        if store is None:
-            return []
-        try:
             return [
                 dict(row)
-                for row in store.list_traces(limit=_MAX_TRACES)
+                for row in sink.list_traces(limit=_MAX_TRACES)
                 if isinstance(row, Mapping)
             ]
-        except Exception:  # noqa: BLE001
+        except Exception:  # noqa: BLE001 - trace visibility must not break the cycle
             logger.debug("evolution producer: traces unreadable", exc_info=True)
             return []
 
@@ -467,43 +461,20 @@ def _reachability_mix(reachability: Sequence[Mapping[str, Any]]) -> list[dict[st
         order = (WIRED, NO_EVIDENCE, NOT_ADMITTED, UNVERIFIABLE)
         return [{"label": name, "value": counts[name]} for name in order if counts.get(name)]
 
-    def _episodes(self, ctx: ProducerContext) -> tuple[Any, ...] | None:
-        """Rebuild recent episodes from existing records.
-
-        Returns ``None`` when the history could not be rebuilt at all, and ``()``
-        when it was rebuilt and is genuinely empty. The caller depends on that
-        difference: "could not look" and "nothing to see" are different answers,
-        and only one of them is a fault.
-
-        The ledger reads the plan and observation stores, so it is resolved per
-        cycle for the same reason the stores are: the profile layout is bound
-        during deferred daemon initialisation.
-        """
-        plans = self._json_store(
-            "capability_plans_path", "capability_plan_store", "JsonCapabilityPlanStore"
-        )
-        if plans is None:
+    @staticmethod
+    async def _event_projection(ctx: ProducerContext) -> dict[str, Any] | None:
+        """Read the aggregate projection exposed by the daemon service facade."""
+        services = getattr(ctx, "services", None)
+        reader = getattr(services, "evolution_projection_aggregate", None)
+        if not callable(reader):
             return None
-        observations = self._json_store(
-            "capability_observations_path",
-            "capability_observation_store",
-            "JsonCapabilityObservationStore",
-        )
-        trust, _usage = self._trust_and_usage()
         try:
-            from leapflow.evolution import EvolutionLedger
-
-            ledger = EvolutionLedger(
-                plan_store=plans, observation_store=observations, trust_ledger=trust
-            )
-            return tuple(
-                ledger.recent_episodes(
-                    limit=_MAX_EPISODES, now=float(getattr(ctx, "now", 0.0) or 0.0)
-                )
-            )
-        except Exception:  # noqa: BLE001 - a missing timeline degrades the panel, not the cycle
-            logger.debug("evolution producer: ledger unavailable", exc_info=True)
+            result = await reader()
+        except Exception:  # noqa: BLE001 - observability degrades instead of failing
+            logger.debug("evolution producer: event projection unavailable", exc_info=True)
             return None
+        projection = result.get("projection") if isinstance(result, Mapping) else None
+        return dict(projection) if isinstance(projection, Mapping) else None
 
     @staticmethod
     def _timeline(episodes: Sequence[Any]) -> list[dict[str, Any]]:
@@ -843,7 +814,10 @@ def _trust_and_usage() -> tuple[Any, Any]:
     # ── pipeline reachability ─────────────────────────────────────────────
 
     def _reachability(
-        self, snapshot: Mapping[str, Any], traces: Sequence[Mapping[str, Any]]
+        self,
+        snapshot: Mapping[str, Any],
+        traces: Sequence[Mapping[str, Any]],
+        event_projection: Mapping[str, Any] | None,
     ) -> list[dict[str, Any]]:
         """Report the runtime evidence for each pipeline segment.
 
@@ -863,7 +837,7 @@ def _reachability(
             self._segment_evidence_gate(settings),
             self._segment_authorising_origins(settings),
             self._segment_observations(observations),
-            self._segment_lifecycle(),
+            self._segment_lifecycle(event_projection),
             self._segment_plan_records(),
             self._segment_trust(snapshot),
         ]
@@ -999,51 +973,40 @@ def _segment_observations(self, store: Any) -> dict[str, Any]:
             next_step="Nothing to act on: no capability gap has been recorded yet.",
         )
 
-    def _segment_lifecycle(self) -> dict[str, Any]:
-        """Whether the trust/probation/quarantine tier is actually governing.
-
-        A non-empty queue used to be reported ``wired``, which read as the healthy
-        class beside a genuinely healthy ``Trust accrual``. On a real profile that
-        was 212 records, every one of them ``PENDING``, none carrying a policy
-        decision or install result, all of them written by ``plugin_propose`` and
-        nothing draining them: a monotonically growing dead end presented as a
-        working segment.
-
-        So the evidence is a *transition*, not a row count. Records existing prove
-        the queue is writable; a record past ``PENDING`` proves something reads it
-        back and advances it, which is the only thing this segment claims to check.
-        """
-        store = self._json_store("capability_proposal_queue_path", "capability_proposal_queue", "JsonCapabilityProposalQueue")
-        if store is None:
-            return self._row("lifecycle", "Lifecycle records", UNVERIFIABLE, "queue unreadable")
-        try:
-            items = store.list_items(limit=0)
-        except Exception:  # noqa: BLE001
-            logger.debug("evolution producer: lifecycle read failed", exc_info=True)
-            return self._row("lifecycle", "Lifecycle records", UNVERIFIABLE, "queue unreadable")
-        if items:
+    def _segment_lifecycle(
+        self, event_projection: Mapping[str, Any] | None
+    ) -> dict[str, Any]:
+        """Report proposal lifecycle evidence from the append-only projection."""
+        if event_projection is None:
+            return self._row(
+                "lifecycle", "Lifecycle records", UNVERIFIABLE, "projection unreadable"
+            )
+        proposals = [
+            dict(item)
+            for item in event_projection.get("proposals", ())
+            if isinstance(item, Mapping)
+        ]
+        if proposals:
             counts: dict[str, int] = {}
-            for item in items:
-                status = str(getattr(item, "status", "") or "unknown")
+            for item in proposals:
+                status = str(item.get("status") or "unknown")
                 counts[status] = counts.get(status, 0) + 1
-            spread = ", ".join(f"{k}={v}" for k, v in sorted(counts.items()))
+            spread = ", ".join(f"{key}={value}" for key, value in sorted(counts.items()))
             advanced = sum(
-                count for status, count in counts.items()
+                count
+                for status, count in counts.items()
                 if status.upper() not in _LIFECYCLE_ENTRY_STATES
             )
             if advanced:
                 return self._row("lifecycle", "Lifecycle records", WIRED, spread)
-            # Entry state only. The queue is written but never read back, so the
-            # governor is not running -- and the row says which way the count grows.
             return self._row(
                 "lifecycle",
                 "Lifecycle records",
                 NO_EVIDENCE,
                 spread,
                 next_step=(
-                    f"{len(items)} record(s) have never left their entry state, so nothing "
-                    "reads the queue back. The governor advances a record only when the "
-                    "co-evolution sweep runs; until then the queue only grows."
+                    f"{len(proposals)} record(s) have never left their entry state; "
+                    "without the proposal orchestrator the queue only grows."
                 ),
             )
         return self._row(
@@ -1051,10 +1014,7 @@ class beside a genuinely healthy ``Trust accrual``. On a real profile that
             "Lifecycle records",
             NO_EVIDENCE,
             "queue is empty",
-            next_step=(
-                "The governor has nothing to govern. A lifecycle record opens when "
-                "plugin_propose runs."
-            ),
+            next_step="A lifecycle record opens when plugin_propose runs.",
         )
 
     def _segment_plan_records(self) -> dict[str, Any]:
diff --git a/src/leapflow/perception/__init__.py b/src/leapflow/perception/__init__.py
index 70ad4767..fafc2edc 100644
--- a/src/leapflow/perception/__init__.py
+++ b/src/leapflow/perception/__init__.py
@@ -15,6 +15,7 @@
     EmitCallback,
 )
 from leapflow.perception.config import PerceptionConfig, SamplingConfig, ScorerConfig
+from leapflow.perception.environment_source import EnvironmentSource, EnvironmentSourceManager
 from leapflow.perception.session import PerceptionSession
 from leapflow.perception.signal_source import (
     SignalSource,
@@ -38,6 +39,8 @@
     "ActiveSourceManager",
     "DiscordBotSignalSource",
     "EmitCallback",
+    "EnvironmentSource",
+    "EnvironmentSourceManager",
     "FeishuIMSignalSource",
     "FileWatchSignalSource",
     "SlackBotSignalSource",
diff --git a/src/leapflow/perception/environment_source.py b/src/leapflow/perception/environment_source.py
new file mode 100644
index 00000000..5bed3874
--- /dev/null
+++ b/src/leapflow/perception/environment_source.py
@@ -0,0 +1,156 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Daemon-owned lifecycle for structured task-environment sources."""
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Awaitable, Callable, Protocol, runtime_checkable
+
+from leapflow.domain.environment_signal import EnvironmentObservation
+
+logger = logging.getLogger(__name__)
+
+EnvironmentEmit = Callable[[EnvironmentObservation], Awaitable[None]]
+EnvironmentSink = Callable[[EnvironmentObservation], Awaitable[None]]
+
+
+@runtime_checkable
+class EnvironmentSource(Protocol):
+    """Long-lived producer of typed task-environment observations."""
+
+    @property
+    def source_id(self) -> str: ...
+
+    async def start(self, emit: EnvironmentEmit) -> None: ...
+
+    async def stop(self) -> None: ...
+
+
+class EnvironmentSourceManager:
+    """Own environment source tasks and serialize their downstream writes."""
+
+    def __init__(
+        self,
+        sink: EnvironmentSink,
+        *,
+        queue_capacity: int = 256,
+        shutdown_timeout_s: float = 5.0,
+    ) -> None:
+        self._sink = sink
+        self._queue: asyncio.Queue[EnvironmentObservation] = asyncio.Queue(
+            maxsize=max(1, int(queue_capacity))
+        )
+        self._shutdown_timeout_s = max(0.1, float(shutdown_timeout_s))
+        self._sources: dict[str, EnvironmentSource] = {}
+        self._source_tasks: dict[str, asyncio.Task[None]] = {}
+        self._consumer_task: asyncio.Task[None] | None = None
+        self._started = False
+        self._closed = False
+        self._dropped = 0
+
+    def register(self, source: EnvironmentSource) -> None:
+        if self._started:
+            raise RuntimeError("cannot register an environment source after start")
+        if not isinstance(source, EnvironmentSource):
+            raise TypeError(f"not an EnvironmentSource: {type(source).__name__}")
+        if source.source_id in self._sources:
+            raise ValueError(f"duplicate environment source: {source.source_id}")
+        self._sources[source.source_id] = source
+
+    async def start(self) -> None:
+        if self._started:
+            return
+        if self._closed:
+            raise RuntimeError("environment source manager is closed")
+        self._started = True
+        self._consumer_task = asyncio.create_task(
+            self._consume(),
+            name="environment-source-consumer",
+        )
+        for source_id, source in self._sources.items():
+            self._source_tasks[source_id] = asyncio.create_task(
+                self._run_source(source),
+                name=f"environment-source:{source_id}",
+            )
+
+    async def publish(self, observation: EnvironmentObservation) -> None:
+        """Apply bounded backpressure instead of silently dropping causal evidence."""
+        if self._closed:
+            return
+        try:
+            await asyncio.wait_for(
+                self._queue.put(observation),
+                timeout=self._shutdown_timeout_s,
+            )
+        except asyncio.TimeoutError:
+            self._dropped += 1
+            logger.error(
+                "environment source queue saturated; dropped observation=%s",
+                observation.observation_id,
+            )
+
+    async def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        for source in self._sources.values():
+            try:
+                await asyncio.wait_for(source.stop(), timeout=self._shutdown_timeout_s)
+            except (asyncio.TimeoutError, Exception):
+                logger.warning(
+                    "environment source stop failed source=%s",
+                    source.source_id,
+                    exc_info=True,
+                )
+        for task in self._source_tasks.values():
+            task.cancel()
+        for task in self._source_tasks.values():
+            try:
+                await task
+            except (asyncio.CancelledError, Exception):
+                pass
+        self._source_tasks.clear()
+        try:
+            await asyncio.wait_for(self._queue.join(), timeout=self._shutdown_timeout_s)
+        except asyncio.TimeoutError:
+            logger.error("environment observation queue did not drain before shutdown")
+        consumer = self._consumer_task
+        self._consumer_task = None
+        if consumer is not None and not consumer.done():
+            consumer.cancel()
+            try:
+                await consumer
+            except asyncio.CancelledError:
+                pass
+
+    @property
+    def source_ids(self) -> tuple[str, ...]:
+        return tuple(sorted(self._sources))
+
+    @property
+    def dropped_count(self) -> int:
+        return self._dropped
+
+    async def _run_source(self, source: EnvironmentSource) -> None:
+        try:
+            await source.start(self.publish)
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.exception("environment source failed source=%s", source.source_id)
+
+    async def _consume(self) -> None:
+        while True:
+            observation = await self._queue.get()
+            try:
+                await self._sink(observation)
+            except Exception:
+                logger.exception(
+                    "environment observation sink failed observation=%s",
+                    observation.observation_id,
+                )
+            finally:
+                self._queue.task_done()
+
+
+__all__ = ["EnvironmentEmit", "EnvironmentSource", "EnvironmentSourceManager"]
diff --git a/src/leapflow/perception/leapspace_source.py b/src/leapflow/perception/leapspace_source.py
new file mode 100644
index 00000000..af05c4af
--- /dev/null
+++ b/src/leapflow/perception/leapspace_source.py
@@ -0,0 +1,120 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""LeapSpace adapter for daemon-native task-environment observations."""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+from leapflow.domain.environment_signal import EnvironmentObservation, InterfaceSnapshot
+from leapflow.perception.environment_source import EnvironmentEmit
+
+logger = logging.getLogger(__name__)
+
+
+class LeapSpaceEnvironmentSource:
+    """Poll LeapSpace's atomic state envelopes without importing its UI runtime."""
+
+    def __init__(
+        self,
+        state_root: Path | str,
+        *,
+        workspace_id: str = "",
+        session_id: str = "",
+        poll_interval_s: float = 0.5,
+    ) -> None:
+        self._root = Path(state_root).expanduser().resolve()
+        self._workspace_id = str(workspace_id)
+        self._session_id = str(session_id)
+        self._poll_interval_s = max(0.05, float(poll_interval_s))
+        self._snapshots: dict[str, InterfaceSnapshot] = {}
+        self._result_hashes: dict[str, str] = {}
+        self._stopped = asyncio.Event()
+
+    @property
+    def source_id(self) -> str:
+        return "leapspace"
+
+    async def start(self, emit: EnvironmentEmit) -> None:
+        self._stopped.clear()
+        while not self._stopped.is_set():
+            for observation in await asyncio.to_thread(self._scan):
+                await emit(observation)
+            try:
+                await asyncio.wait_for(self._stopped.wait(), timeout=self._poll_interval_s)
+            except asyncio.TimeoutError:
+                pass
+
+    async def stop(self) -> None:
+        self._stopped.set()
+
+    def _scan(self) -> tuple[EnvironmentObservation, ...]:
+        if not self._root.exists():
+            return ()
+        observations: list[EnvironmentObservation] = []
+        for state_path in sorted(self._root.glob("*/state.json")):
+            envelope = self._read_json(state_path)
+            if not envelope:
+                continue
+            app_id = str(envelope.get("app_id") or state_path.parent.name)
+            snapshot = InterfaceSnapshot.create(
+                source_id=self.source_id,
+                app_id=app_id,
+                workspace_id=self._workspace_id,
+                session_id=self._session_id,
+                version=str(envelope.get("version") or ""),
+                affordances=envelope.get("affordances") or (),
+                elements=envelope.get("elements") or (),
+                data=envelope.get("data") or {},
+                observed_at=state_path.stat().st_mtime,
+                provenance={"kind": "leapspace_state", "path": f"{app_id}/state.json"},
+            )
+            previous = self._snapshots.get(app_id)
+            self._snapshots[app_id] = snapshot
+            observation = (
+                EnvironmentObservation.snapshot(snapshot)
+                if previous is None
+                else EnvironmentObservation.between(previous, snapshot)
+            )
+            if observation is not None:
+                observations.append(observation)
+
+        for result_path in sorted(self._root.glob("*/result.json")):
+            payload = self._read_json(result_path)
+            if not payload:
+                continue
+            task_id = str(payload.get("task_id") or result_path.parent.name)
+            digest = json.dumps(payload, ensure_ascii=False, sort_keys=True, default=str)
+            if self._result_hashes.get(task_id) == digest:
+                continue
+            self._result_hashes[task_id] = digest
+            observations.append(
+                EnvironmentObservation.task_outcome(
+                    source_id=self.source_id,
+                    task_id=task_id,
+                    outcome=str(payload.get("outcome") or "UNKNOWN"),
+                    capability=str(payload.get("capability") or ""),
+                    workspace_id=self._workspace_id,
+                    session_id=self._session_id,
+                    observed_at=result_path.stat().st_mtime,
+                    provenance={
+                        "kind": "leapspace_verdict",
+                        "path": f"{task_id}/result.json",
+                        "exit_code": payload.get("exit_code", ""),
+                    },
+                )
+            )
+        return tuple(observations)
+
+    @staticmethod
+    def _read_json(path: Path) -> dict[str, Any]:
+        try:
+            value = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError, TypeError, ValueError):
+            return {}
+        return value if isinstance(value, dict) else {}
+
+
+__all__ = ["LeapSpaceEnvironmentSource"]
diff --git a/src/leapflow/perception/signal_source.py b/src/leapflow/perception/signal_source.py
index a8804425..66292c51 100644
--- a/src/leapflow/perception/signal_source.py
+++ b/src/leapflow/perception/signal_source.py
@@ -14,7 +14,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, FrozenSet, List, Optional, Protocol, runtime_checkable
+from typing import Any, Dict, FrozenSet, Optional, Protocol, runtime_checkable
 
 from leapflow.perception.types import InteractionSignal
 
diff --git a/src/leapflow/perception/signal_sources_builtin.py b/src/leapflow/perception/signal_sources_builtin.py
index 53930c8c..cbaf49d8 100644
--- a/src/leapflow/perception/signal_sources_builtin.py
+++ b/src/leapflow/perception/signal_sources_builtin.py
@@ -13,7 +13,6 @@
 from typing import Any, Dict, FrozenSet, Optional
 
 from leapflow.perception.signal_source import (
-    SignalSource,
     SignalSourceRegistry,
     SignalTransformContext,
 )
diff --git a/src/leapflow/performance.py b/src/leapflow/performance.py
new file mode 100644
index 00000000..f072e92b
--- /dev/null
+++ b/src/leapflow/performance.py
@@ -0,0 +1,67 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Bounded latency measurements for runtime and evolution components."""
+from __future__ import annotations
+
+import math
+import threading
+from collections import deque
+from dataclasses import asdict, dataclass
+
+
+@dataclass(frozen=True)
+class LatencySummary:
+    """Immutable percentile snapshot in milliseconds."""
+
+    count: int = 0
+    minimum_ms: float = 0.0
+    mean_ms: float = 0.0
+    p50_ms: float = 0.0
+    p95_ms: float = 0.0
+    p99_ms: float = 0.0
+    maximum_ms: float = 0.0
+
+    def to_dict(self) -> dict[str, int | float]:
+        return asdict(self)
+
+
+class RollingLatency:
+    """Thread-safe bounded sampler with O(1) writes and cold-path sorting."""
+
+    def __init__(self, *, capacity: int = 2048) -> None:
+        self._samples: deque[float] = deque(maxlen=max(1, int(capacity)))
+        self._lock = threading.Lock()
+
+    def observe(self, duration_ms: float) -> None:
+        with self._lock:
+            self._samples.append(max(0.0, float(duration_ms)))
+
+    def snapshot(self) -> LatencySummary:
+        with self._lock:
+            samples = sorted(self._samples)
+        if not samples:
+            return LatencySummary()
+        count = len(samples)
+        return LatencySummary(
+            count=count,
+            minimum_ms=round(samples[0], 4),
+            mean_ms=round(sum(samples) / count, 4),
+            p50_ms=round(_percentile(samples, 0.50), 4),
+            p95_ms=round(_percentile(samples, 0.95), 4),
+            p99_ms=round(_percentile(samples, 0.99), 4),
+            maximum_ms=round(samples[-1], 4),
+        )
+
+
+def _percentile(sorted_samples: list[float], quantile: float) -> float:
+    if len(sorted_samples) == 1:
+        return sorted_samples[0]
+    position = (len(sorted_samples) - 1) * min(1.0, max(0.0, quantile))
+    lower = math.floor(position)
+    upper = math.ceil(position)
+    if lower == upper:
+        return sorted_samples[lower]
+    weight = position - lower
+    return sorted_samples[lower] * (1.0 - weight) + sorted_samples[upper] * weight
+
+
+__all__ = ["LatencySummary", "RollingLatency"]
diff --git a/src/leapflow/platform/event_bus.py b/src/leapflow/platform/event_bus.py
index 2545559f..363c661f 100644
--- a/src/leapflow/platform/event_bus.py
+++ b/src/leapflow/platform/event_bus.py
@@ -9,7 +9,7 @@
 import asyncio
 import logging
 import time
-from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING
+from typing import Any, Callable, Dict, Optional, TYPE_CHECKING
 
 from leapflow.domain.events import PRE_NORMALIZED_EVENT_PREFIXES, SystemEvent
 from leapflow.memory.providers.episodic import EpisodicMemoryProvider
@@ -19,7 +19,6 @@
 from leapflow.platform.reorder_buffer import EventReorderBuffer
 
 if TYPE_CHECKING:
-    from leapflow.domain.effect_scope import EffectScope
     from leapflow.learning.event_consumer import EventConsumer
     from leapflow.privacy.policy import EventPrivacyFilter
 
diff --git a/src/leapflow/plugins/adaptive_loop.py b/src/leapflow/plugins/adaptive_loop.py
index 16a07ab4..7fdec4e5 100644
--- a/src/leapflow/plugins/adaptive_loop.py
+++ b/src/leapflow/plugins/adaptive_loop.py
@@ -324,68 +324,6 @@ def plan_next_action(
             rollback_available=rollback_available,
         )
 
-    async def apply_policy_decision(
-        self,
-        proposal: Any,
-        decision: Any,
-        *,
-        proposal_queue: Any = None,
-        generated_code: str = "",
-        version_label: str = "",
-    ) -> Mapping[str, Any]:
-        """Apply a policy decision through existing lifecycle boundaries.
-
-        This method only mutates the registry for explicit lifecycle decisions;
-        queue/status-only decisions update durable proposal state and return.
-        """
-        action = str(getattr(decision, "action", "") or "")
-        proposal_id = str(getattr(proposal, "proposal_id", "") or "")
-        plugin_id = _proposal_plugin_id(proposal)
-        decision_payload = (
-            decision.to_dict() if hasattr(decision, "to_dict") else {"action": action}
-        )
-
-        if action in {"observe_only", "propose", "request_approval", "none"}:
-            if proposal_queue is not None:
-                proposal_queue.update(proposal_id, policy_decision=decision_payload)
-            return {"ok": True, "action": action, "proposal_id": proposal_id}
-        if action == "generate":
-            if proposal_queue is not None:
-                proposal_queue.update(
-                    proposal_id, status="GENERATED", policy_decision=decision_payload
-                )
-            return {"ok": True, "action": "generate", "proposal_id": proposal_id}
-        if action == "install":
-            if self._lifecycle_actor is None:
-                return {"ok": False, "error": "lifecycle_actor is required for install"}
-            result = await self._lifecycle_actor.install(
-                plugin_id=plugin_id,
-                code=generated_code,
-                proposal_id=proposal_id,
-                version_label=version_label,
-            )
-            if proposal_queue is not None:
-                proposal_queue.update(
-                    proposal_id,
-                    status="INSTALLED" if result.get("ok") else "FAILED",
-                    policy_decision=decision_payload,
-                    install_result=result,
-                )
-            return result
-        if action in {"disable", "quarantine"}:
-            if self._lifecycle_actor is None:
-                return {"ok": False, "error": "lifecycle_actor is required for disable"}
-            result = await self._lifecycle_actor.disable(plugin_id=plugin_id)
-            if proposal_queue is not None:
-                proposal_queue.update(
-                    proposal_id,
-                    status="QUARANTINED" if result.get("ok") else "FAILED",
-                    policy_decision=decision_payload,
-                    install_result=result,
-                )
-            return result
-        return {"ok": False, "error": f"Unsupported policy action: {action}"}
-
     def _read_preferences(self) -> tuple[tuple[str, str], ...]:
         """The teacher's rebind recommendations, or nothing.
 
@@ -614,22 +552,6 @@ def _selected_delta(
     }
 
 
-def _proposal_plugin_id(proposal: Any) -> str:
-    metadata = dict(getattr(proposal, "metadata", {}) or {})
-    if metadata.get("plugin_id"):
-        return str(metadata["plugin_id"])
-    if getattr(proposal, "install_result", None):
-        result = dict(getattr(proposal, "install_result") or {})
-        if result.get("plugin_id"):
-            return str(result["plugin_id"])
-    if getattr(proposal, "requirements", None):
-        for requirement in getattr(proposal, "requirements") or ():
-            if isinstance(requirement, Mapping):
-                cap = str(requirement.get("capability") or "generated")
-                return cap.replace(".", "_").replace("-", "_") + "_plugin"
-    return str(getattr(proposal, "proposal_id", "adaptive_plugin") or "adaptive_plugin")
-
-
 __all__ = [
     "AdaptiveDecision",
     "AdaptiveLoopMutation",
diff --git a/src/leapflow/plugins/dsh/plugin.py b/src/leapflow/plugins/dsh/plugin.py
index a567cacb..c2abac60 100644
--- a/src/leapflow/plugins/dsh/plugin.py
+++ b/src/leapflow/plugins/dsh/plugin.py
@@ -66,13 +66,20 @@ async def _handler(**kwargs: Any) -> Any:
                 "category": "bridge",
                 "runtime": "node",
                 "bridge": "dsh_ndjson_v1",
-                "risk_level": "external" if self._descriptor.permissions else "medium",
-                "requires_approval": False,
-                "execution_policy": "parallel_safe",
+                "risk_level": "external" if self._descriptor.permissions else "read_only",
+                "requires_approval": bool(self._descriptor.permissions),
+                "effect_scope": "external" if self._descriptor.permissions else "none",
+                "idempotency_scope": "session" if self._descriptor.permissions else "turn",
+                "execution_policy": (
+                    "external_side_effect" if self._descriptor.permissions else "read_only"
+                ),
                 "source_bundle_sha256": self._descriptor.bundle_sha256,
                 "limitations": list(self._descriptor.limitations),
             },
-            mutates_state=False,
+            mutates_state=bool(self._descriptor.permissions),
+            execution_policy=(
+                "external_side_effect" if self._descriptor.permissions else "read_only"
+            ),
         )
 
     async def _invoke(self, tool_name: str, arguments: dict[str, Any]) -> Any:
diff --git a/src/leapflow/plugins/evolution_contracts.py b/src/leapflow/plugins/evolution_contracts.py
index 803e2f2a..d434d08f 100644
--- a/src/leapflow/plugins/evolution_contracts.py
+++ b/src/leapflow/plugins/evolution_contracts.py
@@ -10,16 +10,13 @@
 
 Two distinct vocabularies meet here, and conflating them is the mistake to avoid:
 
-* ``domain.plugin_proposal.ProposalStatus`` -- ``draft | review | approved |
-  rejected`` -- is a **review** state: should a human accept this proposal?
-* ``storage.capability_proposal_queue.ProposalStatus`` -- ``PENDING | GENERATED |
-  APPROVED | INSTALLED | PROBATION | VERIFIED | REJECTED | FAILED | QUARANTINED``
-  -- is an **acquisition lifecycle** state: where is this capability in its
-  journey from hypothesis to trusted?
-
-They are not duplicates and must not be merged into one field. A proposal that a
-human has ``approved`` may still be anywhere in its lifecycle. The lifecycle store
-below owns the second vocabulary.
+* ``domain.plugin_proposal.ProposalStatus`` describes the immutable review content
+  embedded in the lifecycle event.
+* ``storage.capability_proposal_queue.ProposalStatus`` describes the governed
+  acquisition state from hypothesis through probation and verification.
+
+Both now travel in one append-only proposal record, but remain separate fields: a
+review decision is evidence for a lifecycle transition, not the lifecycle itself.
 """
 
 from __future__ import annotations
diff --git a/src/leapflow/plugins/lifecycle_governor.py b/src/leapflow/plugins/lifecycle_governor.py
index e870d30d..7af46924 100644
--- a/src/leapflow/plugins/lifecycle_governor.py
+++ b/src/leapflow/plugins/lifecycle_governor.py
@@ -144,40 +144,51 @@ async def record_outcome(
             side_effect_state=side_effect_state,
             metadata=metadata,
         )
+        internal_defect = hard_failure or str(failure_class) == "internal_defect"
         if ok:
             self._trust_ledger.record_success(plugin_id)
         else:
-            self._trust_ledger.record_failure(plugin_id, hard=hard_failure)
+            self._trust_ledger.record_failure(plugin_id, hard=internal_defect)
 
         trust = self._trust_ledger.level(plugin_id)
         failure_streak = self._outcome_store.failure_streak(plugin_id)
+        trust_state = {
+            "level": trust.name,
+            "failure_streak": failure_streak,
+            "frozen": self._trust_ledger.is_frozen(plugin_id),
+        }
         lifecycle_result: Mapping[str, Any] = {"ok": True}
         action = "probation_execute"
 
-        if hard_failure or failure_streak >= self._quarantine_after:
+        if internal_defect or failure_streak >= self._quarantine_after:
             action = "quarantine"
             if self._lifecycle_actor is not None:
                 lifecycle_result = await self._lifecycle_actor.disable(plugin_id=plugin_id)
-            self._proposal_queue.update(
+            self._transition(
                 proposal_id,
-                status="QUARANTINED" if lifecycle_result.get("ok", True) else "FAILED",
-                trust_state={"level": trust.name, "failure_streak": failure_streak},
+                "QUARANTINED" if lifecycle_result.get("ok", True) else "FAILED",
+                trust_state=trust_state,
                 test_results=[outcome],
                 install_result=lifecycle_result,
+                metadata={
+                    "terminal_reason": "internal_defect"
+                    if internal_defect
+                    else "failure_streak_exceeded"
+                },
             )
         elif trust >= self._verified_at:
             action = "verify"
-            self._proposal_queue.update(
+            self._transition(
                 proposal_id,
-                status="VERIFIED",
-                trust_state={"level": trust.name, "failure_streak": failure_streak},
+                "VERIFIED",
+                trust_state=trust_state,
                 test_results=[outcome],
             )
         else:
-            self._proposal_queue.update(
+            self._transition(
                 proposal_id,
-                status="PROBATION",
-                trust_state={"level": trust.name, "failure_streak": failure_streak},
+                "PROBATION",
+                trust_state=trust_state,
                 test_results=[outcome],
             )
         if action != "quarantine":
@@ -201,5 +212,21 @@ async def record_outcome(
             outcome=outcome,
         )
 
+    def _transition(self, proposal_id: str, status: str, **changes: Any) -> None:
+        """Use the lifecycle state machine when the backing store exposes it."""
+        if not proposal_id:
+            return
+        transition = getattr(self._proposal_queue, "transition", None)
+        if callable(transition):
+            current = self._proposal_queue.get(proposal_id)
+            if current is None:
+                return
+            if current.status == status:
+                self._proposal_queue.update(proposal_id, **changes)
+            else:
+                transition(proposal_id, status, **changes)
+            return
+        self._proposal_queue.update(proposal_id, status=status, **changes)
+
 
 __all__ = ["LifecycleGovernanceResult", "LifecycleGovernor"]
diff --git a/src/leapflow/plugins/proposal_orchestrator.py b/src/leapflow/plugins/proposal_orchestrator.py
new file mode 100644
index 00000000..a8e893c2
--- /dev/null
+++ b/src/leapflow/plugins/proposal_orchestrator.py
@@ -0,0 +1,306 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Durable orchestration for governed capability acquisition proposals."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping, Protocol, runtime_checkable
+
+from leapflow.evolution.artifact_store import ContentAddressedArtifactStore
+from leapflow.learning.plugin_trust import PluginTrustLevel
+from leapflow.plugins.adaptive_policy import AdaptiveEvolutionPolicy
+from leapflow.security.actions import ActionDescriptor
+from leapflow.storage.capability_proposal_queue import CapabilityProposalItem
+
+
+@runtime_checkable
+class ProposalApprovalGate(Protocol):
+    async def evaluate(self, action: ActionDescriptor) -> Any: ...
+
+
+@dataclass(frozen=True)
+class ProposalApproval:
+    """One explicit approval result tied to a durable proposal transition."""
+
+    approved: bool
+    proposal_id: str
+    stage: str
+    approval_id: str = ""
+    denial_message: str = ""
+
+
+class ProposalOrchestrator:
+    """Apply policy and two explicit approvals to one acquisition lifecycle."""
+
+    def __init__(
+        self,
+        *,
+        queue: Any,
+        artifact_store: ContentAddressedArtifactStore,
+        approval_gate: ProposalApprovalGate | None,
+        policy: AdaptiveEvolutionPolicy,
+    ) -> None:
+        self._queue = queue
+        self._artifacts = artifact_store
+        self._approval_gate = approval_gate
+        self._policy = policy
+
+    def register_generated(
+        self,
+        proposal_id: str,
+        code: str,
+        *,
+        validation: Mapping[str, Any],
+    ) -> CapabilityProposalItem:
+        """Persist validated source in CAS and advance PENDING to GENERATED."""
+        proposal = self._required(proposal_id)
+        if proposal.status in {"GENERATED", "APPROVED"} and proposal.generated_code_ref:
+            if self._artifacts.get_text(proposal.generated_code_ref) == code:
+                return proposal
+            raise ValueError(f"proposal {proposal_id} already references a different artifact")
+        if proposal.status != "PENDING":
+            raise ValueError(f"proposal {proposal_id} is not pending")
+        decision = self._policy.decide(proposal, trust_level=PluginTrustLevel.DRAFT)
+        if not decision.allowed or decision.action != "generate":
+            raise PermissionError(decision.reason)
+        validation_payload = dict(validation)
+        if not bool(validation_payload.get("ok", False)) or validation_payload.get(
+            "compatibility_ok"
+        ) is not True:
+            return self._queue.transition(
+                proposal_id,
+                "FAILED",
+                policy_decision=decision.to_dict(),
+                metadata={
+                    "validation": validation_payload,
+                    "terminal_reason": "static or compatibility validation failed",
+                },
+            )
+        artifact = self._artifacts.put_text(
+            code,
+            media_type="text/x-python; charset=utf-8",
+            privacy_class="profile",
+        )
+        return self._queue.transition(
+            proposal_id,
+            "GENERATED",
+            generated_code_ref=artifact.artifact_id,
+            policy_decision=decision.to_dict(),
+            metadata={"validation": validation_payload, "artifact": artifact.to_dict()},
+        )
+
+    async def approve_content(self, proposal_id: str) -> ProposalApproval:
+        """Ask whether the generated implementation is acceptable in principle."""
+        proposal = self._required(proposal_id)
+        if proposal.status == "APPROVED" and proposal.proposal_approval_id:
+            return ProposalApproval(
+                True, proposal_id, "content", approval_id=proposal.proposal_approval_id
+            )
+        if proposal.status != "GENERATED":
+            raise ValueError(f"proposal {proposal_id} has no generated artifact to approve")
+        descriptor = ActionDescriptor.platform_action(
+            "plugin_management",
+            "approve_proposal_content",
+            {
+                "proposal_id": proposal_id,
+                "artifact_id": proposal.generated_code_ref,
+                "requirements": [dict(item) for item in proposal.requirements],
+            },
+            metadata={
+                "effect": "write",
+                "risk_level": "high",
+                "category": "self_modification",
+                "approval_stage": "proposal_content",
+                "proposal_id": proposal_id,
+            },
+        )
+        gate = self._approval_gate
+        if gate is None:
+            return self._reject(
+                proposal_id,
+                stage="content",
+                approval_id=descriptor.action_id,
+                reason="approval_gate_missing",
+                denial_message="proposal approval blocked: no approval gate configured",
+            )
+        try:
+            result = await gate.evaluate(descriptor)
+        except Exception as exc:  # noqa: BLE001 - an unavailable gate must fail closed
+            return self._reject(
+                proposal_id,
+                stage="content",
+                approval_id=descriptor.action_id,
+                reason=f"approval_gate_error:{type(exc).__name__}",
+                denial_message="proposal approval failed closed",
+            )
+        approval_id = str(
+            getattr(getattr(result, "action", None), "action_id", "")
+            or descriptor.action_id
+        )
+        if not bool(getattr(result, "approved", False)):
+            return self._reject(
+                proposal_id,
+                stage="content",
+                approval_id=approval_id,
+                reason=str(getattr(result, "reason", "") or "user_denied"),
+                denial_message=str(getattr(result, "denial_message", "") or "approval denied"),
+            )
+        self._queue.transition(
+            proposal_id,
+            "APPROVED",
+            proposal_approval_id=approval_id,
+            policy_decision={
+                "action": "request_approval",
+                "reason": "generated proposal content approved",
+                "approval_stage": "proposal_content",
+            },
+        )
+        return ProposalApproval(True, proposal_id, "content", approval_id=approval_id)
+
+    async def authorize_mutation(self, proposal_id: str) -> ProposalApproval:
+        """Ask separately for the process-global install mutation."""
+        proposal = self._required(proposal_id)
+        if proposal.status == "APPROVED" and proposal.mutation_approval_id:
+            return ProposalApproval(
+                True, proposal_id, "mutation", approval_id=proposal.mutation_approval_id
+            )
+        if proposal.status != "APPROVED" or not proposal.proposal_approval_id:
+            raise PermissionError("proposal content must be approved before installation")
+        plugin_id = str(dict(proposal.metadata).get("plugin_id") or proposal_id)
+        descriptor = ActionDescriptor.platform_action(
+            "plugin_management",
+            "install",
+            {"proposal_id": proposal_id, "plugin_id": plugin_id},
+            metadata={
+                "effect": "write",
+                "risk_level": "high",
+                "category": "self_modification",
+                "approval_stage": "plugin_mutation",
+                "proposal_id": proposal_id,
+            },
+        )
+        gate = self._approval_gate
+        if gate is None:
+            return self._reject(
+                proposal_id,
+                stage="mutation",
+                approval_id=descriptor.action_id,
+                reason="approval_gate_missing",
+                denial_message="plugin mutation blocked: no approval gate configured",
+            )
+        try:
+            result = await gate.evaluate(descriptor)
+        except Exception as exc:  # noqa: BLE001 - an unavailable gate must fail closed
+            return self._reject(
+                proposal_id,
+                stage="mutation",
+                approval_id=descriptor.action_id,
+                reason=f"approval_gate_error:{type(exc).__name__}",
+                denial_message="plugin mutation approval failed closed",
+            )
+        approval_id = str(
+            getattr(getattr(result, "action", None), "action_id", "")
+            or descriptor.action_id
+        )
+        if not bool(getattr(result, "approved", False)):
+            return self._reject(
+                proposal_id,
+                stage="mutation",
+                approval_id=approval_id,
+                reason=str(getattr(result, "reason", "") or "user_denied"),
+                denial_message=str(getattr(result, "denial_message", "") or "approval denied"),
+            )
+        self._queue.update(proposal_id, mutation_approval_id=approval_id)
+        return ProposalApproval(True, proposal_id, "mutation", approval_id=approval_id)
+
+    def generated_code(self, proposal_id: str) -> str:
+        proposal = self._required(proposal_id)
+        if not proposal.generated_code_ref:
+            raise ValueError(f"proposal {proposal_id} has no generated artifact")
+        return self._artifacts.get_text(proposal.generated_code_ref)
+
+    def record_installed(
+        self,
+        proposal_id: str,
+        install_result: Mapping[str, Any],
+    ) -> CapabilityProposalItem:
+        proposal = self._required(proposal_id)
+        if proposal.status == "INSTALLED":
+            return proposal
+        if proposal.status != "APPROVED" or not proposal.mutation_approval_id:
+            raise PermissionError("plugin mutation approval is required before installation")
+        target = "INSTALLED" if bool(install_result.get("ok")) else "FAILED"
+        reason = "plugin installed" if target == "INSTALLED" else str(
+            install_result.get("error") or "plugin installation failed"
+        )
+        return self._queue.transition(
+            proposal_id,
+            target,  # type: ignore[arg-type]
+            install_result=dict(install_result),
+            metadata={"terminal_reason": reason} if target == "FAILED" else {},
+        )
+
+    def supersede(self, proposal_id: str, *, replacement_id: str, reason: str) -> CapabilityProposalItem:
+        """Close an uninstalled proposal in favor of a newer durable proposal."""
+        return self._queue.transition(
+            proposal_id,
+            "SUPERSEDED",
+            metadata={"terminal_reason": reason, "replacement_proposal_id": replacement_id},
+        )
+
+    def expire(self, proposal_id: str, *, reason: str) -> CapabilityProposalItem:
+        """Close an uninstalled proposal whose review window has elapsed."""
+        return self._queue.transition(
+            proposal_id,
+            "EXPIRED",
+            metadata={"terminal_reason": reason},
+        )
+
+    def record_noop(self, proposal_id: str, *, reason: str) -> CapabilityProposalItem:
+        """Close a proposal resolved without acquiring a new capability."""
+        return self._queue.transition(
+            proposal_id,
+            "NO_OP",
+            metadata={"terminal_reason": reason},
+        )
+
+    def _reject(
+        self,
+        proposal_id: str,
+        *,
+        stage: str,
+        approval_id: str,
+        reason: str,
+        denial_message: str,
+    ) -> ProposalApproval:
+        approval_field = (
+            {"proposal_approval_id": approval_id}
+            if stage == "content"
+            else {"mutation_approval_id": approval_id}
+        )
+        self._queue.transition(
+            proposal_id,
+            "REJECTED",
+            **approval_field,
+            policy_decision={
+                "action": "reject",
+                "reason": reason,
+                "approval_stage": "proposal_content" if stage == "content" else "plugin_mutation",
+            },
+            metadata={"terminal_reason": reason},
+        )
+        return ProposalApproval(
+            False,
+            proposal_id,
+            stage,
+            approval_id=approval_id,
+            denial_message=denial_message,
+        )
+
+    def _required(self, proposal_id: str) -> CapabilityProposalItem:
+        proposal = self._queue.get(proposal_id)
+        if proposal is None:
+            raise KeyError(f"unknown capability proposal: {proposal_id}")
+        return proposal
+
+
+__all__ = ["ProposalApproval", "ProposalApprovalGate", "ProposalOrchestrator"]
diff --git a/src/leapflow/plugins/protocol.py b/src/leapflow/plugins/protocol.py
index f20289c0..e43fa574 100644
--- a/src/leapflow/plugins/protocol.py
+++ b/src/leapflow/plugins/protocol.py
@@ -76,6 +76,7 @@ class ToolMetadata:
     # which supports both generated-plugin **kwargs handlers and older params-dict handlers.
     x_leapflow: dict[str, Any] = field(default_factory=dict)
     mutates_state: bool = False
+    execution_policy: str = ""
     # Declarative capability metadata consumed by the capability resolver and
     # environment-fit scoring. ``provides_capabilities`` are abstract capability
     # tags this tool offers (matched against a requirement). ``requires_capabilities``
@@ -108,6 +109,8 @@ def to_openai_schema(self) -> dict[str, Any]:
         x_leapflow = dict(self.x_leapflow)
         if self.mutates_state:
             x_leapflow.setdefault("mutates_state", True)
+        if self.execution_policy:
+            x_leapflow.setdefault("execution_policy", self.execution_policy)
         if self.provides_capabilities:
             x_leapflow.setdefault("provides_capabilities", list(self.provides_capabilities))
         if self.requires_capabilities:
diff --git a/src/leapflow/plugins/registry.py b/src/leapflow/plugins/registry.py
index 92249ab8..f653ff0b 100644
--- a/src/leapflow/plugins/registry.py
+++ b/src/leapflow/plugins/registry.py
@@ -5,9 +5,11 @@
 
 import logging
 from dataclasses import dataclass
+from time import perf_counter
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
 from leapflow.domain.tool_pipeline import ToolExecutionPipeline
+from leapflow.performance import LatencySummary, RollingLatency
 from leapflow.plugins.protocol import ToolMetadata, ToolPlugin
 
 logger = logging.getLogger(__name__)
@@ -66,6 +68,7 @@ def __init__(self) -> None:
         self._version: int = 0
         self._last_bound_deps: dict[str, Any] = {}  # Track last-injected deps for re-injection on reload
         self._tool_pipeline = ToolExecutionPipeline()
+        self._snapshot_latency = RollingLatency()
 
         # ── Cross-cutting runtime gates ──
         self._file_read_gate: Any = None
@@ -257,22 +260,47 @@ def assemble(self) -> None:
         )
 
     def publish_plugin_tools(self, plugin: ToolPlugin) -> list[str]:
-        """Publish an already-registered plugin's tools into the live catalog.
+        """Publish an already-registered plugin's tools into the live catalog."""
+        return self._publish_plugin_tools(plugin, strict=False)
 
-        assemble() runs once at boot; a plugin that arrives later (install,
-        hot-reload) makes its tools dispatchable through this method, keeping
-        the definitions, metadata, and handler table in one place instead of
-        letting callers write to the registry's internals.
+    def publish_plugin_tools_atomic(self, plugin: ToolPlugin) -> list[str]:
+        """Publish all tools or none, rejecting live-name collisions up front."""
+        return self._publish_plugin_tools(plugin, strict=True)
 
-        Returns the published tool names and bumps the version counter so
-        downstream caches (engine tool registry, PCD catalog) invalidate.
-        """
+    def _publish_plugin_tools(self, plugin: ToolPlugin, *, strict: bool) -> list[str]:
         tool_names = [tool.name for tool in plugin.tools]
+        if strict:
+            duplicates = sorted({name for name in tool_names if tool_names.count(name) > 1})
+            conflicts = sorted(
+                name
+                for name in tool_names
+                if name in self._tool_owner and self._tool_owner[name] != plugin.plugin_id
+            )
+            if duplicates or conflicts:
+                details = []
+                if duplicates:
+                    details.append(f"duplicate declarations: {duplicates}")
+                if conflicts:
+                    details.append(f"live conflicts: {conflicts}")
+                raise ValueError("plugin tool publication rejected: " + "; ".join(details))
         # Before the first assemble() the pending pass will pick these tools up
         # from the plugin itself; publishing now would duplicate every schema.
         if self._assembled:
-            for tool in plugin.tools:
-                self._index_tool(tool, plugin.plugin_id)
+            handlers_before = dict(self._tool_handlers)
+            owners_before = dict(self._tool_owner)
+            definitions_before = list(self._tool_definitions)
+            metadata_before = list(self._all_metadata)
+            conflicts_before = list(self._conflicts)
+            try:
+                for tool in plugin.tools:
+                    self._index_tool(tool, plugin.plugin_id)
+            except Exception:
+                self._tool_handlers = handlers_before
+                self._tool_owner = owners_before
+                self._tool_definitions = definitions_before
+                self._all_metadata = metadata_before
+                self._conflicts = conflicts_before
+                raise
         self._bump_version(
             "tools_published", plugin_id=plugin.plugin_id, tool_names=list(tool_names)
         )
@@ -418,6 +446,18 @@ def tool_handlers(self) -> dict[str, Any]:
             self.assemble()
         return self._tool_handlers
 
+    def snapshot_handlers(self) -> dict[str, Any]:
+        """Return an immutable-by-convention turn snapshot and record copy latency."""
+        started_at = perf_counter()
+        try:
+            return dict(self.tool_handlers)
+        finally:
+            self._snapshot_latency.observe((perf_counter() - started_at) * 1000.0)
+
+    @property
+    def snapshot_latency(self) -> LatencySummary:
+        return self._snapshot_latency.snapshot()
+
     @property
     def all_metadata(self) -> list[ToolMetadata]:
         """All ToolMetadata entries (for PCD, capability manifests, etc.)."""
diff --git a/src/leapflow/plugins/sandbox/sandbox_host.py b/src/leapflow/plugins/sandbox/sandbox_host.py
index 87c6169e..fa6a6bb1 100644
--- a/src/leapflow/plugins/sandbox/sandbox_host.py
+++ b/src/leapflow/plugins/sandbox/sandbox_host.py
@@ -11,9 +11,11 @@
 
 import asyncio
 import logging
+import os
 import sys
 import uuid
-from typing import Any, Dict, List, Optional
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Sequence
 
 from leapflow.plugins.protocol import ToolMetadata
 from leapflow.plugins.sandbox.protocol import SandboxRequest, SandboxResponse
@@ -21,19 +23,56 @@
 logger = logging.getLogger(__name__)
 
 
+@dataclass(frozen=True)
+class SandboxLimits:
+    """Cold-path process and RPC limits for one sandbox worker."""
+
+    invoke_timeout_s: float = 30.0
+    shutdown_timeout_s: float = 3.0
+    cpu_time_s: int = 0
+    max_memory_bytes: int = 0
+
+    def __post_init__(self) -> None:
+        if self.invoke_timeout_s <= 0 or self.shutdown_timeout_s <= 0:
+            raise ValueError("sandbox timeouts must be positive")
+        if self.cpu_time_s < 0 or self.max_memory_bytes < 0:
+            raise ValueError("sandbox resource limits cannot be negative")
+
+
 class SandboxHost:
     """Manages a worker subprocess for one sandboxed plugin."""
 
     def __init__(
-        self, plugin_module_path: str, *, invoke_timeout_s: float = 30.0
+        self,
+        plugin_module_path: str,
+        *,
+        invoke_timeout_s: float = 30.0,
+        shutdown_timeout_s: float = 3.0,
+        cpu_time_s: int = 0,
+        max_memory_bytes: int = 0,
+        python_paths: Sequence[str] = (),
     ) -> None:
         self._module_path = plugin_module_path
-        self._invoke_timeout_s = invoke_timeout_s
+        self._python_paths = tuple(str(path) for path in python_paths if str(path))
+        self._limits = SandboxLimits(
+            invoke_timeout_s=float(invoke_timeout_s),
+            shutdown_timeout_s=float(shutdown_timeout_s),
+            cpu_time_s=int(cpu_time_s),
+            max_memory_bytes=int(max_memory_bytes),
+        )
         self._proc: Optional[asyncio.subprocess.Process] = None
         self._lock = asyncio.Lock()  # serialize stdin/stdout access
 
     async def start(self) -> None:
         """Launch the worker subprocess."""
+        env = dict(os.environ)
+        env["LEAPFLOW_SANDBOX_CPU_TIME_S"] = str(self._limits.cpu_time_s)
+        env["LEAPFLOW_SANDBOX_MAX_MEMORY_BYTES"] = str(self._limits.max_memory_bytes)
+        if self._python_paths:
+            current = env.get("PYTHONPATH", "")
+            env["PYTHONPATH"] = os.pathsep.join(
+                [*self._python_paths, *([current] if current else [])]
+            )
         self._proc = await asyncio.create_subprocess_exec(
             sys.executable,
             "-m",
@@ -42,6 +81,7 @@ async def start(self) -> None:
             stdin=asyncio.subprocess.PIPE,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
+            env=env,
         )
         logger.info(
             "Sandbox worker started for %s (pid %s)",
@@ -91,7 +131,7 @@ async def _send_request(
                 self._proc.stdin.write((req.to_json() + "\n").encode())
                 await self._proc.stdin.drain()
                 line = await asyncio.wait_for(
-                    self._proc.stdout.readline(), timeout=self._invoke_timeout_s
+                    self._proc.stdout.readline(), timeout=self._limits.invoke_timeout_s
                 )
                 if not line:
                     return SandboxResponse(
@@ -101,10 +141,11 @@ async def _send_request(
                     )
                 return SandboxResponse.from_json(line.decode().strip())
             except asyncio.TimeoutError:
+                await self._kill_worker()
                 return SandboxResponse(
                     request_id=req.request_id,
                     ok=False,
-                    error=f"Sandbox invoke timed out after {self._invoke_timeout_s}s",
+                    error=f"Sandbox invoke timed out after {self._limits.invoke_timeout_s}s",
                 )
             except (ConnectionResetError, OSError, ValueError) as exc:
                 return SandboxResponse(
@@ -122,7 +163,9 @@ async def stop(self) -> None:
                 req = SandboxRequest(request_id="shutdown", method="shutdown")
                 self._proc.stdin.write((req.to_json() + "\n").encode())
                 await self._proc.stdin.drain()
-            await asyncio.wait_for(self._proc.wait(), timeout=3.0)
+            await asyncio.wait_for(
+                self._proc.wait(), timeout=self._limits.shutdown_timeout_s
+            )
         except (asyncio.TimeoutError, ConnectionResetError, OSError):
             try:
                 self._proc.kill()
@@ -133,6 +176,18 @@ async def stop(self) -> None:
             self._proc = None
             logger.info("Sandbox worker stopped for %s", self._module_path)
 
+    async def _kill_worker(self) -> None:
+        proc = self._proc
+        if proc is None:
+            return
+        try:
+            proc.kill()
+            await proc.wait()
+        except (ProcessLookupError, OSError):
+            pass
+        finally:
+            self._proc = None
+
 
 class SandboxedToolPlugin:
     """A ToolPlugin whose handlers execute in a sandbox subprocess.
diff --git a/src/leapflow/plugins/sandbox/worker.py b/src/leapflow/plugins/sandbox/worker.py
index 2fdaccba..6997d615 100644
--- a/src/leapflow/plugins/sandbox/worker.py
+++ b/src/leapflow/plugins/sandbox/worker.py
@@ -20,6 +20,7 @@
 import importlib
 import json
 import logging
+import os
 import sys
 from typing import Any, Callable, Dict
 
@@ -28,6 +29,22 @@
 logger = logging.getLogger(__name__)
 
 
+def _apply_resource_limits() -> None:
+    """Apply host-declared OS limits before importing untrusted plugin code."""
+    cpu_time_s = max(0, int(os.getenv("LEAPFLOW_SANDBOX_CPU_TIME_S", "0")))
+    max_memory_bytes = max(0, int(os.getenv("LEAPFLOW_SANDBOX_MAX_MEMORY_BYTES", "0")))
+    if not cpu_time_s and not max_memory_bytes:
+        return
+    try:
+        import resource
+    except ImportError as exc:  # pragma: no cover - non-POSIX safety path
+        raise RuntimeError("sandbox resource limits are unavailable on this platform") from exc
+    if cpu_time_s:
+        resource.setrlimit(resource.RLIMIT_CPU, (cpu_time_s, cpu_time_s))
+    if max_memory_bytes:
+        resource.setrlimit(resource.RLIMIT_AS, (max_memory_bytes, max_memory_bytes))
+
+
 async def _serve(plugin_module_path: str) -> None:
     """Load the plugin and serve requests from stdin."""
     handlers: Dict[str, Callable[..., Any]] = {}
@@ -107,4 +124,5 @@ async def _invoke(
 
 if __name__ == "__main__":
     module_path = sys.argv[1] if len(sys.argv) > 1 else ""
+    _apply_resource_limits()
     asyncio.run(_serve(module_path))
diff --git a/src/leapflow/plugins/scoped_registry.py b/src/leapflow/plugins/scoped_registry.py
index 51873879..75b060b3 100644
--- a/src/leapflow/plugins/scoped_registry.py
+++ b/src/leapflow/plugins/scoped_registry.py
@@ -44,6 +44,7 @@ def __init__(self, registry: Any) -> None:
         """Wrap an existing ToolPluginRegistry instance."""
         self._registry = registry
         self._fibers: dict[str, PluginFiber] = {}
+        self._draft_plugins: dict[str, ToolPlugin] = {}
         self._plugin_modules: dict[str, str] = {}  # plugin_id → module path
         self._plugin_files: dict[str, Path] = {}  # plugin_id → installed source file
 
@@ -54,10 +55,64 @@ def create_fiber(self, plugin_id: str) -> PluginFiber:
         self._fibers[plugin_id] = fiber
         return fiber
 
+    def create_draft_fiber(self, plugin_id: str) -> PluginFiber:
+        """Create an isolated DRAFT fiber that cannot dispatch live tools."""
+        if plugin_id in self._fibers and not self._fibers[plugin_id].is_disposed:
+            raise ValueError(f"Plugin '{plugin_id}' already has a live fiber")
+        fiber = self.create_fiber(plugin_id)
+        fiber.mark_draft()
+        return fiber
+
     def get_fiber(self, plugin_id: str) -> Optional[PluginFiber]:
         """Get an existing fiber by plugin ID."""
         return self._fibers.get(plugin_id)
 
+    def stage_plugin(self, plugin: ToolPlugin, fiber: PluginFiber) -> None:
+        """Attach a plugin to a DRAFT fiber without publishing any handler."""
+        plugin_id = plugin.plugin_id
+        if fiber.plugin_id != plugin_id or fiber.state != FiberState.DRAFT:
+            raise ValueError("draft plugin and fiber identity/state do not match")
+        if self._registry.get_plugin(plugin_id) is not None:
+            raise ValueError(f"Duplicate plugin_id: {plugin_id!r}")
+        self._draft_plugins[plugin_id] = plugin
+        fiber.scope.effect(lambda pid=plugin_id: self._draft_plugins.pop(pid, None))
+        module_name = str(getattr(plugin, "__leapflow_plugin_module__", "") or "")
+        module = sys.modules.get(module_name) if module_name else None
+        if module is not None:
+            fiber.scope.effect(
+                lambda name=module_name, loaded=module: (
+                    sys.modules.pop(name, None)
+                    if sys.modules.get(name) is loaded
+                    else None
+                )
+            )
+
+    def promote_draft(self, plugin_id: str) -> PluginFiber:
+        """Atomically publish a tested DRAFT plugin into the live registry."""
+        fiber = self._fibers.get(plugin_id)
+        plugin = self._draft_plugins.get(plugin_id)
+        if fiber is None or plugin is None or fiber.state != FiberState.DRAFT:
+            raise ValueError(f"Plugin '{plugin_id}' has no staged DRAFT")
+        self.scoped_register(plugin, fiber)
+        try:
+            published = self._registry.publish_plugin_tools_atomic(plugin)
+            fiber.activate()
+        except Exception:
+            if fiber.state != FiberState.DISPOSED:
+                fiber.dispose()
+            self._fibers.pop(plugin_id, None)
+            raise
+        self._draft_plugins.pop(plugin_id, None)
+        logger.info("Promoted DRAFT plugin '%s' with %d tools", plugin_id, len(published))
+        return fiber
+
+    def discard_draft(self, plugin_id: str) -> None:
+        """Dispose an unpublished DRAFT and remove all staging metadata."""
+        fiber = self._fibers.pop(plugin_id, None)
+        self._draft_plugins.pop(plugin_id, None)
+        if fiber is not None and not fiber.is_disposed:
+            fiber.dispose()
+
     def scoped_register(self, plugin: ToolPlugin, fiber: PluginFiber) -> None:
         """Register a plugin with lifecycle tracking.
 
diff --git a/src/leapflow/plugins/tool_plugins/file_ops.py b/src/leapflow/plugins/tool_plugins/file_ops.py
index c89ac621..397c3441 100644
--- a/src/leapflow/plugins/tool_plugins/file_ops.py
+++ b/src/leapflow/plugins/tool_plugins/file_ops.py
@@ -135,6 +135,7 @@ def tools(self) -> list[ToolMetadata]:
                     "requires_approval": True,
                 },
                 mutates_state=True,
+                execution_policy="mutating_once",
                 provides_capabilities=("file.write",),
                 requires_platform_capabilities=("file.ops",),
             ),
@@ -287,6 +288,7 @@ def tools(self) -> list[ToolMetadata]:
                     "requires_approval": True,
                 },
                 mutates_state=True,
+                execution_policy="mutating_idempotent",
                 provides_capabilities=("file.edit",),
                 requires_platform_capabilities=("file.ops",),
             ),
diff --git a/src/leapflow/plugins/tool_plugins/gateway.py b/src/leapflow/plugins/tool_plugins/gateway.py
index a1914f18..e0633856 100644
--- a/src/leapflow/plugins/tool_plugins/gateway.py
+++ b/src/leapflow/plugins/tool_plugins/gateway.py
@@ -71,6 +71,7 @@ def tools(self) -> list[ToolMetadata]:
                     "requires_approval": True,
                 },
                 mutates_state=True,
+                execution_policy="external_side_effect",
                 provides_capabilities=("platform.action",),
                 requires_capabilities=("platform.connect",),
                 requires_platform_capabilities=("file.ops",),
@@ -110,7 +111,10 @@ def tools(self) -> list[ToolMetadata]:
                     "schema_cost": "high",
                     "requires_approval": True,
                 },
+                mutates_state=True,
+                execution_policy="external_side_effect",
                 provides_capabilities=("platform.connect",),
+                requires_platform_capabilities=("file.ops",),
             ),
             ToolMetadata(
                 name="gateway_send",
@@ -148,6 +152,7 @@ def tools(self) -> list[ToolMetadata]:
                     "requires_approval": True,
                 },
                 mutates_state=True,
+                execution_policy="external_side_effect",
                 provides_capabilities=("platform.send_message",),
                 requires_capabilities=("platform.configure",),
                 requires_platform_capabilities=("file.ops",),
@@ -197,7 +202,10 @@ def tools(self) -> list[ToolMetadata]:
                     "schema_cost": "high",
                     "requires_approval": True,
                 },
+                mutates_state=True,
+                execution_policy="external_side_effect",
                 provides_capabilities=("platform.configure",),
+                requires_platform_capabilities=("file.ops",),
             ),
         ]
 
diff --git a/src/leapflow/plugins/tool_plugins/hub.py b/src/leapflow/plugins/tool_plugins/hub.py
index aec8da53..a16bec8f 100644
--- a/src/leapflow/plugins/tool_plugins/hub.py
+++ b/src/leapflow/plugins/tool_plugins/hub.py
@@ -59,6 +59,7 @@ def tools(self) -> list[ToolMetadata]:
                     "requires_approval": True,
                 },
                 mutates_state=True,
+                execution_policy="external_side_effect",
                 provides_capabilities=("hub.push",),
                 requires_platform_capabilities=("file.ops",),
             ),
@@ -87,6 +88,7 @@ def tools(self) -> list[ToolMetadata]:
                     "requires_approval": True,
                 },
                 mutates_state=True,
+                execution_policy="external_side_effect",
                 provides_capabilities=("hub.pull",),
                 requires_platform_capabilities=("file.ops",),
             ),
@@ -137,6 +139,7 @@ def tools(self) -> list[ToolMetadata]:
                     "requires_approval": True,
                 },
                 mutates_state=True,
+                execution_policy="external_side_effect",
                 provides_capabilities=("hub.sync",),
                 requires_platform_capabilities=("file.ops",),
             ),
diff --git a/src/leapflow/plugins/tool_plugins/self_management.py b/src/leapflow/plugins/tool_plugins/self_management.py
index 2a519ce8..005a35bf 100644
--- a/src/leapflow/plugins/tool_plugins/self_management.py
+++ b/src/leapflow/plugins/tool_plugins/self_management.py
@@ -10,10 +10,10 @@
     - plugin_propose  : create a side-effect-free proposal from capability-gap evidence
     - assess_compatibility : assess foreign plugin manifest compatibility with LeapFlow
 
-Generation (no approval needed — produces validated code without installing):
+Governed generation (proposal content approval, no installation yet):
     - plugin_generate : describe a capability need; the LLM produces conformant
-                        plugin code and it is rigorously validated. The validated
-                        code is returned; installation is a separate, gated step.
+                        plugin code, stores it in CAS, validates it, and requests
+                        content approval. Installation is a second gated step.
 
 State-mutating (REQUIRES approval — routed through the plugin_approval_gate):
     - plugin_install  : write validated code (from plugin_generate) or a
@@ -50,7 +50,7 @@
 
 import logging
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Mapping, Optional
 
 from leapflow.plugins.protocol import ToolMetadata
 
@@ -102,6 +102,7 @@ def __init__(self) -> None:
         # lazily from the active profile layout so in-process CLI mode still
         # installs into a profile-scoped path rather than the package dir.
         self._plugin_install_dir: Optional[str] = None
+        self._plugin_staging_dir: Optional[str] = None
         # Optional MarketplaceClient used by the marketplace_name install branch.
         # None when no marketplace is configured; the branch then returns a
         # structured error.
@@ -109,15 +110,14 @@ def __init__(self) -> None:
         # Hex-encoded Ed25519 public keys trusted to sign marketplace plugins.
         # When non-empty, marketplace installs require a valid signature.
         self._trusted_pubkeys: set[str] = set()
-        # Optional persistent store for PluginProposal review queue. When not
-        # injected, it is resolved lazily from ProfileLayout.plugin_proposals_path.
-        self._plugin_proposal_store: Any = None
-        # Acquisition-lifecycle ledger (PENDING -> GENERATED -> INSTALLED ->
-        # PROBATION -> VERIFIED/QUARANTINED). Distinct from the review store above:
-        # that one answers "should a human accept this proposal", this one tracks
-        # where the capability is in its journey, and is what AdaptiveEvolutionPolicy
-        # and LifecycleGovernor operate on.
+        # Sole acquisition-lifecycle ledger (PENDING -> GENERATED -> APPROVED ->
+        # INSTALLED -> PROBATION -> VERIFIED/QUARANTINED). Rich review content is
+        # embedded in the same record; AdaptiveEvolutionPolicy and LifecycleGovernor
+        # both operate on this store.
         self._capability_lifecycle_store: Any = None
+        self._proposal_orchestrator: Any = None
+        self._evolution_outbox: Any = None
+        self._evolution_profile_id: str = ""
         # Optional version store; lazily resolved from ProfileLayout.plugin_versions_dir.
         self._plugin_version_store: Any = None
         # Optional adaptive capability decision store; lazily resolved from
@@ -139,12 +139,15 @@ def dependencies(self) -> list[str]:
             "llm_provider",
             "plugin_generation_enabled",
             "plugin_install_dir",
+            "plugin_staging_dir",
             "marketplace_client",
             "marketplace_trusted_pubkeys",
-            "plugin_proposal_store",
             "plugin_version_store",
             "capability_plan_store",
             "capability_lifecycle_store",
+            "proposal_orchestrator",
+            "evolution_outbox",
+            "evolution_profile_id",
         ]
 
     def bind_runtime(self, **deps: Any) -> None:
@@ -157,19 +160,26 @@ def bind_runtime(self, **deps: Any) -> None:
         if "plugin_install_dir" in deps:
             value = deps["plugin_install_dir"]
             self._plugin_install_dir = str(value) if value else None
+        if "plugin_staging_dir" in deps:
+            value = deps["plugin_staging_dir"]
+            self._plugin_staging_dir = str(value) if value else None
         if "marketplace_client" in deps:
             self._marketplace_client = deps["marketplace_client"]
         if "marketplace_trusted_pubkeys" in deps:
             raw = deps["marketplace_trusted_pubkeys"] or ()
             self._trusted_pubkeys = {str(k).strip() for k in raw if str(k).strip()}
-        if "plugin_proposal_store" in deps:
-            self._plugin_proposal_store = deps["plugin_proposal_store"]
         if "plugin_version_store" in deps:
             self._plugin_version_store = deps["plugin_version_store"]
         if "capability_plan_store" in deps:
             self._capability_plan_store = deps["capability_plan_store"]
         if "capability_lifecycle_store" in deps:
             self._capability_lifecycle_store = deps["capability_lifecycle_store"]
+        if "proposal_orchestrator" in deps:
+            self._proposal_orchestrator = deps["proposal_orchestrator"]
+        if "evolution_outbox" in deps:
+            self._evolution_outbox = deps["evolution_outbox"]
+        if "evolution_profile_id" in deps:
+            self._evolution_profile_id = str(deps["evolution_profile_id"] or "")
 
     # ── Read-only introspection ────────────────────────────
 
@@ -303,9 +313,7 @@ def _build_capability_report(
             "plugin_install_dir": install_dir,
             "marketplace_configured": self._marketplace_client is not None,
             "trusted_marketplace_pubkeys": len(self._trusted_pubkeys),
-            "proposal_store_available": (
-                self._plugin_proposal_store is not None or profile_layout is not None
-            ),
+            "proposal_store_available": self._capability_lifecycle_store is not None,
             "version_store_available": (
                 self._plugin_version_store is not None or profile_layout is not None
             ),
@@ -395,7 +403,7 @@ def _capability_limitations(dependency_state: dict[str, Any]) -> list[str]:
             limitations.append("Marketplace installs require a configured marketplace client.")
         if not dependency_state["proposal_store_available"]:
             limitations.append(
-                "Plugin proposals require a profile layout or injected proposal store."
+                "Plugin proposals require the daemon-injected evolution lifecycle store."
             )
         if not dependency_state["version_store_available"]:
             limitations.append(
@@ -562,17 +570,17 @@ async def _plugin_propose_handler(
             except (TypeError, ValueError) as exc:
                 return {"ok": False, "error": f"Proposal test case parsing failed: {exc}"}
 
-        try:
-            stored = self._proposal_store().save(proposal)
-        except (RuntimeError, OSError, ValueError, AttributeError) as exc:
-            return {"ok": False, "error": f"Proposal persistence failed: {exc}"}
-
-        lifecycle_id = self._open_lifecycle_record(stored, requested_capability)
+        lifecycle_id = self._open_lifecycle_record(proposal, requested_capability)
+        if not lifecycle_id:
+            return {
+                "ok": False,
+                "error": "Proposal persistence failed: lifecycle store unavailable",
+            }
 
         return {
             "ok": True,
             "action": "propose",
-            "proposal": stored.to_dict(),
+            "proposal": proposal.to_dict(),
             "lifecycle_proposal_id": lifecycle_id,
             "next_actions": [
                 "Review proposal fields and risk level.",
@@ -639,78 +647,102 @@ async def _plugin_generate_handler(
             )
             result = await generator.generate_and_validate(request)
             if proposal_id:
+                lifecycle_id = self._lifecycle_proposal_id(source, proposal_id)
                 result["proposal_id"] = proposal_id
-                if result.get("ok"):
-                    self._mark_generation_started(source, proposal_id)
+                result["lifecycle_proposal_id"] = lifecycle_id
+                if result.get("ok") and lifecycle_id and self._proposal_orchestrator is not None:
+                    item = self._proposal_orchestrator.register_generated(
+                        lifecycle_id,
+                        str(result.get("code") or ""),
+                        validation={
+                            "ok": True,
+                            "stage": "passed",
+                            "compatibility_ok": True,
+                            "target_protocol": "ToolPlugin",
+                            "exposed_tools": list(result.get("exposed_tools") or ()),
+                        },
+                    )
+                    content_approval = await self._proposal_orchestrator.approve_content(
+                        lifecycle_id
+                    )
+                    result.update(
+                        {
+                            "generated_code_ref": item.generated_code_ref,
+                            "content_approved": content_approval.approved,
+                            "content_approval_id": content_approval.approval_id,
+                        }
+                    )
+                    if not content_approval.approved:
+                        result.update(
+                            {
+                                "ok": False,
+                                "error": content_approval.denial_message,
+                                "requires_approval": True,
+                            }
+                        )
+                elif result.get("ok"):
+                    result.update(
+                        {
+                            "ok": False,
+                            "error": "proposal orchestration unavailable; content approval cannot be recorded",
+                            "requires_approval": True,
+                        }
+                    )
             return result
-        except (AttributeError, RuntimeError) as exc:
+        except (AttributeError, KeyError, PermissionError, RuntimeError, ValueError) as exc:
             return {"ok": False, "error": f"Generation failed: {exc}"}
 
     def _resolve_generation_source(
         self, proposal_id: str
     ) -> tuple[str, str, str, tuple[str, ...]]:
-        """Resolve a generation request from *either* proposal store.
-
-        Two stores can name a proposal, and both must reach generation:
-
-        * the **review store** (``JsonPluginProposalStore``) holds a rich
-          ``PluginProposal`` created by the manual ``plugin_propose`` UX flow;
-        * the **lifecycle queue** (``JsonCapabilityProposalQueue``) holds the
-          acquisition record the world-model driver enqueues -- a
-          ``prop-<hash>`` id keyed on the requirement, carrying the capability,
-          the ``plugin_id`` the sink stamped, and the hypothesis as its summary.
-
-        Before this, ``plugin_generate`` looked only in the review store, so a
-        world-model proposal could never be generated from its own id: Scene C could
-        not proceed from a real teacher verdict to a validated artifact. Returning a
-        normalised ``(source, plugin_id, description, provides_capabilities)`` unifies
-        the two consumption points without collapsing their distinct lifecycle
-        vocabularies. ``source`` is ``""`` when neither store knows the id.
-        """
-        review = self._proposal_store().get(proposal_id)
-        if review is not None:
+        """Resolve either canonical lifecycle id or review alias from one store."""
+        try:
+            store = self._lifecycle_store()
+            item = store.get(proposal_id)
+            source = "lifecycle"
+            if item is None:
+                item = store.find_by_metadata("review_proposal_id", proposal_id)
+                source = "review"
+        except (RuntimeError, OSError, ValueError, AttributeError):
+            item = None
+            source = ""
+        if item is None:
+            return ("", "", "", ())
+        metadata = dict(item.metadata or {})
+        review_payload = metadata.get("review_proposal")
+        if isinstance(review_payload, Mapping):
+            from leapflow.domain.plugin_proposal import PluginProposal
+
+            review = PluginProposal.from_dict(review_payload)
             return (
-                "review",
+                source,
                 str(review.plugin_id),
                 str(review.capability_summary),
                 _declared_capabilities(review),
             )
-        try:
-            item = self._lifecycle_store().get(proposal_id)
-        except (RuntimeError, OSError, ValueError, AttributeError):
-            item = None
-        if item is not None:
-            requirements = [dict(r) for r in (item.requirements or ())]
-            capability = str((requirements[0].get("capability") if requirements else "") or "")
-            metadata = dict(item.metadata or {})
-            plugin_id = str(metadata.get("plugin_id") or "")
-            description = str(
-                metadata.get("capability_summary")
-                or (requirements[0].get("evidence") if requirements else "")
-                or capability
-            )
-            provides = (capability,) if capability else ()
-            return ("lifecycle", plugin_id, description, provides)
-        return ("", "", "", ())
-
-    def _mark_generation_started(self, source: str, proposal_id: str) -> None:
-        """Advance the proposal's status in whichever store owns it.
-
-        The two stores speak different vocabularies on purpose (see
-        ``evolution_contracts``): the review store moves to ``review`` (a human-accept
-        state), the lifecycle queue to ``GENERATED`` (an acquisition-lifecycle state
-        ``AdaptiveEvolutionPolicy`` reads next). Contained: a status write must not fail
-        a generation that already succeeded.
-        """
-        try:
-            if source == "review":
-                self._proposal_store().update_status(proposal_id, "review")
-            elif source == "lifecycle":
-                self._lifecycle_store().update(proposal_id, status="GENERATED")
-        except (RuntimeError, OSError, ValueError, AttributeError):
-            logger.debug(
-                "plugin_generate: could not advance %s status", proposal_id, exc_info=True
-            )
+        requirements = [dict(requirement) for requirement in (item.requirements or ())]
+        capability = str((requirements[0].get("capability") if requirements else "") or "")
+        plugin_id = str(metadata.get("plugin_id") or "")
+        description = str(
+            metadata.get("capability_summary")
+            or (requirements[0].get("evidence") if requirements else "")
+            or capability
+        )
+        provides = (capability,) if capability else ()
+        return (source, plugin_id, description, provides)
+
+    def _lifecycle_proposal_id(self, source: str, proposal_id: str) -> str:
+        if source == "lifecycle":
+            return proposal_id
+        if source == "review":
+            try:
+                item = self._lifecycle_store().find_by_metadata(
+                    "review_proposal_id", proposal_id
+                )
+            except (RuntimeError, OSError, ValueError, AttributeError):
+                item = None
+            return str(getattr(item, "proposal_id", "") or "")
+        return ""
 
     # ── Compatibility assessment (read-only) ─────────────────
 
@@ -826,12 +858,39 @@ async def _plugin_install_handler(
     ) -> Dict[str, Any]:
         """Install Python code/marketplace content or a real DSH source bundle."""
         proposal = None
+        lifecycle_id = ""
         if proposal_id:
-            proposal = self._proposal_store().get(proposal_id)
-            if proposal is None:
+            try:
+                store = self._lifecycle_store()
+                lifecycle = store.get(proposal_id)
+                if lifecycle is None:
+                    lifecycle = store.find_by_metadata("review_proposal_id", proposal_id)
+            except (RuntimeError, OSError, ValueError, AttributeError):
+                lifecycle = None
+            if lifecycle is None:
                 return {"ok": False, "error": f"Plugin proposal '{proposal_id}' not found"}
-            plugin_id = plugin_id or proposal.plugin_id
+            lifecycle_id = str(lifecycle.proposal_id)
+            metadata = dict(lifecycle.metadata or {})
+            review_payload = metadata.get("review_proposal")
+            if isinstance(review_payload, Mapping):
+                from leapflow.domain.plugin_proposal import PluginProposal
+
+                proposal = PluginProposal.from_dict(review_payload)
+                plugin_id = plugin_id or proposal.plugin_id
+            else:
+                plugin_id = plugin_id or str(metadata.get("plugin_id") or "")
         source_path = str(source_path or kwargs.get("source_path") or "")
+        if (
+            lifecycle_id
+            and not code
+            and not marketplace_name
+            and not source_path
+            and self._proposal_orchestrator is not None
+        ):
+            try:
+                code = self._proposal_orchestrator.generated_code(lifecycle_id)
+            except (KeyError, OSError, RuntimeError, ValueError) as exc:
+                return {"ok": False, "error": str(exc)}
         modes = sum(bool(value) for value in (code, marketplace_name, source_path))
         if modes != 1:
             return {
@@ -888,11 +947,31 @@ async def _plugin_install_handler(
         if not plugin_id:
             return {"ok": False, "error": "plugin_id is required unless source_path or proposal_id is provided"}
 
-        approved, denial = await self._check_approval(
-            "install", plugin_id, proposal_id=proposal_id, metadata=source_metadata,
-        )
-        if not approved:
-            return {"ok": False, "error": denial, "requires_approval": True}
+        if lifecycle_id:
+            if self._proposal_orchestrator is None:
+                return {
+                    "ok": False,
+                    "error": "proposal orchestration unavailable; mutation approval cannot be recorded",
+                    "requires_approval": True,
+                }
+            try:
+                mutation_approval = await self._proposal_orchestrator.authorize_mutation(
+                    lifecycle_id
+                )
+            except (KeyError, PermissionError, ValueError) as exc:
+                return {"ok": False, "error": str(exc), "requires_approval": True}
+            if not mutation_approval.approved:
+                return {
+                    "ok": False,
+                    "error": mutation_approval.denial_message,
+                    "requires_approval": True,
+                }
+        else:
+            approved, denial = await self._check_approval(
+                "install", plugin_id, proposal_id=proposal_id, metadata=source_metadata,
+            )
+            if not approved:
+                return {"ok": False, "error": denial, "requires_approval": True}
 
         from leapflow.plugins import get_registry
 
@@ -929,20 +1008,35 @@ async def _plugin_install_handler(
                 return {"ok": False, "error": "Must provide code, marketplace_name, or source_path"}
             if proposal_id:
                 result["proposal_id"] = proposal_id
-                if result.get("ok"):
-                    self._proposal_store().update_status(proposal_id, "approved")
+            if lifecycle_id and self._proposal_orchestrator is not None:
+                self._proposal_orchestrator.record_installed(lifecycle_id, result)
+                result["lifecycle_proposal_id"] = lifecycle_id
+            elif result.get("ok"):
+                from leapflow.domain.event_types import EvolutionEventType
+
+                persisted = await self._emit_plugin_event(
+                    EvolutionEventType.PLUGIN_INSTALLED,
+                    plugin_id=plugin_id,
+                    version_id=str(result.get("version") or version_label),
+                    payload={
+                        "action": "install",
+                        "installed_tools": list(result.get("installed_tools") or ()),
+                    },
+                    dedup_suffix=str(
+                        result.get("version")
+                        or source_metadata.get("bundle_sha256")
+                        or "installed"
+                    ),
+                )
+                if not persisted:
+                    result["audit_incomplete"] = True
             return result
         except (ImportError, AttributeError, OSError, RuntimeError, ValueError) as exc:
             logger.warning("plugin_install failed for %s: %s", plugin_id, exc, exc_info=True)
             return {"ok": False, "error": f"Install failed: {exc}"}
 
     def _resolve_install_dir(self) -> "Path":
-        """Resolve the profile-scoped directory for installed plugin code.
-
-        Precedence: the injected ``plugin_install_dir`` (from bind_runtime) ->
-        the active ``ProfileLayout.plugins_dir`` -> a plugins dir under the data
-        root. Always profile-scoped; never the Python package directory.
-        """
+        """Resolve the profile-scoped directory for installed plugin code."""
         from pathlib import Path
 
         if self._plugin_install_dir:
@@ -955,35 +1049,49 @@ def _resolve_install_dir(self) -> "Path":
             return profile_layout.plugins_dir
         return Path(settings.layout.root) / "plugins"
 
-    def _proposal_store(self) -> Any:
-        """Resolve the profile-scoped proposal store."""
-        if self._plugin_proposal_store is not None:
-            return self._plugin_proposal_store
+    def _resolve_staging_dir(self) -> "Path":
+        """Resolve the profile-owned quarantine directory for candidate code."""
+        from pathlib import Path
+
+        if self._plugin_staging_dir:
+            return Path(self._plugin_staging_dir)
+        if self._plugin_install_dir:
+            return Path(self._plugin_install_dir) / ".staging"
+        from leapflow.config import get_settings
+
+        profile_layout = getattr(get_settings(), "profile_layout", None)
+        if profile_layout is not None:
+            return profile_layout.plugin_staging_dir
+        return self._resolve_install_dir() / ".staging"
+
+    @staticmethod
+    def _sandbox_settings() -> dict[str, int | float]:
+        """Return bounded sandbox configuration from the effective settings."""
         from leapflow.config import get_settings
-        from leapflow.storage.plugin_proposal_store import JsonPluginProposalStore
 
         settings = get_settings()
-        profile_layout = getattr(settings, "profile_layout", None)
-        if profile_layout is None:
-            raise RuntimeError("profile_layout is required for plugin proposal storage")
-        self._plugin_proposal_store = JsonPluginProposalStore(profile_layout.plugin_proposals_path)
-        return self._plugin_proposal_store
+        return {
+            "invoke_timeout_s": max(
+                0.1, float(getattr(settings, "plugin_sandbox_invoke_timeout_s", 15.0))
+            ),
+            "shutdown_timeout_s": max(
+                0.1, float(getattr(settings, "plugin_sandbox_shutdown_timeout_s", 3.0))
+            ),
+            "cpu_time_s": max(
+                0, int(getattr(settings, "plugin_sandbox_cpu_time_s", 30))
+            ),
+            "max_memory_bytes": max(
+                0, int(getattr(settings, "plugin_sandbox_max_memory_mb", 0))
+            )
+            * 1024
+            * 1024,
+        }
 
     def _lifecycle_store(self) -> Any:
         """Resolve the profile-scoped acquisition-lifecycle ledger."""
         if self._capability_lifecycle_store is not None:
             return self._capability_lifecycle_store
-        from leapflow.config import get_settings
-        from leapflow.storage.capability_proposal_queue import JsonCapabilityProposalQueue
-
-        settings = get_settings()
-        profile_layout = getattr(settings, "profile_layout", None)
-        if profile_layout is None:
-            raise RuntimeError("profile_layout is required for capability lifecycle storage")
-        self._capability_lifecycle_store = JsonCapabilityProposalQueue(
-            profile_layout.capability_proposal_queue_path
-        )
-        return self._capability_lifecycle_store
+        raise RuntimeError("capability lifecycle store was not injected by the runtime")
 
     def _open_lifecycle_record(self, proposal: Any, capability: str) -> str:
         """Open a PENDING lifecycle record correlated with a review proposal.
@@ -1013,6 +1121,7 @@ def _open_lifecycle_record(self, proposal: Any, capability: str) -> str:
                 metadata={
                     "plugin_id": proposal.plugin_id,
                     "review_proposal_id": proposal.proposal_id,
+                    "review_proposal": proposal.to_dict(),
                 },
             )
             self._trace_lifecycle_opened(item, proposal, requirement)
@@ -1091,8 +1200,14 @@ def _capability_plan_store_resolved(self) -> Any:
     async def _install_from_code(
         self, plugin_id: str, code: str, *, proposal: Any = None, version_label: str = ""
     ) -> Dict[str, Any]:
-        """Re-validate, write to the profile dir, smoke test, then load in-process."""
+        """Validate in quarantine, then atomically publish one DRAFT fiber."""
+        import os
+        import shutil
+        import sys
+        import tempfile
+
         from leapflow.learning.plugin_generator import PluginValidator
+        from leapflow.plugins import get_scoped_registry
 
         validator = PluginValidator()
         vresult = await validator.validate(plugin_id, code)
@@ -1103,35 +1218,37 @@ async def _install_from_code(
             }
 
         install_dir = self._resolve_install_dir()
+        staging_root = self._resolve_staging_dir()
         install_dir.mkdir(parents=True, exist_ok=True)
+        staging_root.mkdir(parents=True, exist_ok=True)
+        staging_dir = Path(tempfile.mkdtemp(prefix=f"{plugin_id}-", dir=staging_root))
+        staged_target = staging_dir / f"{plugin_id}.py"
         target = install_dir / f"{plugin_id}.py"
-        target.write_text(code)
-
-        # D3: real subprocess smoke test before the plugin is made live.
-        smoke_ok, smoke_err = await self._sandbox_smoke_test(plugin_id, install_dir)
-        if not smoke_ok:
-            self._safe_unlink(target)
-            return {"ok": False, "error": smoke_err}
-
-        result = self._register_inprocess(plugin_id, plugin_id, target)
-        if not result.get("ok"):
-            return result
-        if proposal is not None and getattr(proposal, "test_cases", ()):
-            ok, error, observations = await self._run_behavior_tests_for_plugin(
-                plugin_id, tuple(getattr(proposal, "test_cases", ()) or ())
+        previous_source = target.read_bytes() if target.exists() else None
+        previous_module = sys.modules.get(plugin_id)
+        scoped = get_scoped_registry()
+        promoted = False
+        try:
+            staged_target.write_text(code, encoding="utf-8")
+            test_cases = tuple(getattr(proposal, "test_cases", ()) or ())
+            ok, error, observations = await self._sandbox_validate_candidate(
+                plugin_id,
+                staging_dir,
+                test_cases=test_cases,
             )
-            result["behavior_tests"] = observations
             if not ok:
-                from leapflow.plugins import get_scoped_registry
+                return {"ok": False, "error": error, "behavior_tests": observations}
+
+            new_plugin, load_err = self._load_from_path(plugin_id, staged_target)
+            if new_plugin is None:
+                return {"ok": False, "error": load_err}
+            fiber = scoped.create_draft_fiber(plugin_id)
+            scoped.stage_plugin(new_plugin, fiber)
+            setattr(new_plugin, "__leapflow_plugin_path__", str(target))
+            os.replace(staged_target, target)
+            fiber = scoped.promote_draft(plugin_id)
+            promoted = True
 
-                scoped = get_scoped_registry()
-                try:
-                    scoped.dispose_plugin(plugin_id, prune_metadata=True)
-                except KeyError:
-                    pass
-                self._safe_unlink(target)
-                return {"ok": False, "error": f"Behavior tests failed: {error}"}
-        try:
             version_info = self._version_store().record_source(
                 plugin_id,
                 target,
@@ -1141,18 +1258,75 @@ async def _install_from_code(
                     "proposal_id": getattr(proposal, "proposal_id", ""),
                 },
             )
-            result["version"] = version_info.get("version", "")
-        except (RuntimeError, OSError, ValueError, AttributeError) as exc:
-            logger.debug(
-                "plugin version recording skipped for %s: %s", plugin_id, exc, exc_info=True
-            )
-            version_info = {}
-        # An artifact this path installed is one self-evolution acquired, so later
-        # sweeps may verify its effect and reclaim it if nothing can ever select it.
-        # A hand-installed plugin is deliberately never recorded here.
-        self._record_acquisition(plugin_id)
-        self._trace_artifact_installed(plugin_id, proposal, version_info, result)
-        return result
+            result: Dict[str, Any] = {
+                "ok": True,
+                "action": "install",
+                "plugin_id": plugin_id,
+                "installed_tools": [tool.name for tool in new_plugin.tools],
+                "state": fiber.state.value,
+                "shadow_validated": True,
+                "behavior_tests": observations,
+                "version": version_info.get("version", ""),
+            }
+            self._record_acquisition(plugin_id)
+            self._trace_artifact_installed(plugin_id, proposal, version_info, result)
+            return result
+        except (AttributeError, OSError, RuntimeError, TypeError, ValueError) as exc:
+            if promoted:
+                try:
+                    scoped.dispose_plugin(plugin_id, prune_metadata=True)
+                except (KeyError, RuntimeError, ValueError):
+                    pass
+            else:
+                scoped.discard_draft(plugin_id)
+            if previous_source is None:
+                self._safe_unlink(target)
+            else:
+                target.write_bytes(previous_source)
+            if previous_module is None:
+                sys.modules.pop(plugin_id, None)
+            else:
+                sys.modules[plugin_id] = previous_module
+            return {"ok": False, "error": f"Install transaction failed: {exc}"}
+        finally:
+            shutil.rmtree(staging_dir, ignore_errors=True)
+
+    async def _emit_plugin_event(
+        self,
+        event_type: str,
+        *,
+        plugin_id: str,
+        proposal_id: str = "",
+        version_id: str = "",
+        payload: Mapping[str, Any] | None = None,
+        dedup_suffix: str,
+    ) -> bool:
+        """Persist a plugin mutation fact through the daemon-owned outbox."""
+        outbox = self._evolution_outbox
+        if outbox is None or not self._evolution_profile_id:
+            return False
+        from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent
+
+        event = EvolutionEvent.create(
+            event_type,
+            context=EvolutionContext(
+                profile_id=self._evolution_profile_id,
+                proposal_id=proposal_id,
+                plugin_id=plugin_id,
+                version_id=version_id,
+                correlation_id=proposal_id or plugin_id,
+            ),
+            payload=dict(payload or {}),
+            producer="plugin.self_management",
+            privacy_class="profile",
+            dedup_key=f"{event_type}:{plugin_id}:{dedup_suffix}",
+        )
+        try:
+            await outbox.publish(event, critical=True)
+            return True
+        except Exception:  # noqa: BLE001 - mutation already happened; report audit gap
+            logger.error("plugin mutation event could not be persisted", exc_info=True)
+            return False
 
     @staticmethod
     def _record_acquisition(plugin_id: str) -> None:
@@ -1504,54 +1678,98 @@ async def _install_from_marketplace(
         return self._register_inprocess(plugin_id, module_name, installed_path)
 
     async def _sandbox_smoke_test(
-        self, module_name: str, install_dir: "Path", *, timeout_s: float = 15.0
+        self, module_name: str, install_dir: "Path", *, timeout_s: float | None = None
     ) -> tuple[bool, str]:
-        """Load the module in a sandbox worker and invoke its first tool once.
-
-        Returns (ok, error). A host-level failure (worker crash/timeout/comm
-        error, signalled by an empty ``error_type``) fails the test. A tool
-        that raises but is caught at the isolation boundary (non-empty
-        ``error_type``) still counts as success: the module loaded and the
-        handler is invocable, which is all the smoke test asserts.
-        """
-        import os
+        """Load a module in the bounded subprocess and invoke its first tool."""
+        limits = self._sandbox_settings()
+        if timeout_s is not None:
+            limits["invoke_timeout_s"] = max(0.1, float(timeout_s))
+        ok, error, _ = await self._sandbox_validate_candidate(
+            module_name,
+            install_dir,
+            test_cases=(),
+            limits=limits,
+        )
+        return ok, error
 
+    async def _sandbox_validate_candidate(
+        self,
+        module_name: str,
+        install_dir: "Path",
+        *,
+        test_cases: tuple[Any, ...],
+        limits: dict[str, int | float] | None = None,
+    ) -> tuple[bool, str, list[dict[str, Any]]]:
+        """Run smoke and proposal behavior tests without publishing host handlers."""
         from leapflow.plugins.sandbox.sandbox_host import SandboxHost
 
-        host = SandboxHost(module_name, invoke_timeout_s=timeout_s)
-        # The worker imports the plugin by module name; make the install dir
-        # importable for the child process during startup only.
-        started = False
-        original_pp = os.environ.get("PYTHONPATH")
-        os.environ["PYTHONPATH"] = os.pathsep.join(
-            [str(install_dir)] + ([original_pp] if original_pp else [])
+        sandbox_limits = dict(limits or self._sandbox_settings())
+        host = SandboxHost(
+            module_name,
+            python_paths=(str(install_dir),),
+            **sandbox_limits,
         )
+        started = False
+        observations: list[dict[str, Any]] = []
         try:
             await host.start()
             started = True
         except (OSError, RuntimeError, ValueError) as exc:
-            return False, f"Sandbox smoke test error: {exc}"
-        finally:
-            if original_pp is None:
-                os.environ.pop("PYTHONPATH", None)
-            else:
-                os.environ["PYTHONPATH"] = original_pp
+            return False, f"Sandbox smoke test error: {exc}", observations
         if not started:
-            return False, "Sandbox smoke test failed: worker did not start"
+            return False, "Sandbox smoke test failed: worker did not start", observations
 
         try:
             if not await host.ping():
-                return False, "Sandbox smoke test failed: worker did not respond"
+                return False, "Sandbox smoke test failed: worker did not respond", observations
             tool_names = await host.list_tools()
             if not tool_names:
-                return False, (
+                return (
+                    False,
                     "Sandbox smoke test failed: plugin exposed no tools "
-                    "(likely failed to import in isolation)"
+                    "(likely failed to import in isolation)",
+                    observations,
+                )
+            smoke = await host.invoke(tool_names[0], {})
+            if not smoke.ok and not smoke.error_type:
+                return False, f"Sandbox smoke test failed: {smoke.error}", observations
+            for index, case in enumerate(test_cases):
+                tool_name = str(getattr(case, "tool_name", "") or "")
+                if tool_name not in tool_names:
+                    return (
+                        False,
+                        f"Behavior tests failed: behavior test {index}: "
+                        f"tool {tool_name!r} not exposed",
+                        observations,
+                    )
+                arguments = dict(getattr(case, "arguments", {}) or {})
+                expected = dict(getattr(case, "expected_subset", {}) or {})
+                response = await host.invoke(tool_name, arguments)
+                if not response.ok:
+                    return (
+                        False,
+                        f"Behavior tests failed: behavior test {index}: "
+                        f"handler raised {response.error_type or 'SandboxError'}: {response.error}",
+                        observations,
+                    )
+                observations.append(
+                    {"tool_name": tool_name, "arguments": arguments, "result": response.result}
                 )
-            resp = await host.invoke(tool_names[0], {})
-            if not resp.ok and not resp.error_type:
-                return False, f"Sandbox smoke test failed: {resp.error}"
-            return True, ""
+                if not isinstance(response.result, dict):
+                    return (
+                        False,
+                        f"Behavior tests failed: behavior test {index}: result is not a dict",
+                        observations,
+                    )
+                for key, expected_value in expected.items():
+                    if response.result.get(key) != expected_value:
+                        return (
+                            False,
+                            f"Behavior tests failed: behavior test {index}: expected "
+                            f"{key}={expected_value!r}, got {response.result.get(key)!r}",
+                            observations,
+                        )
+            return True, "", observations
         finally:
             try:
                 await host.stop()
@@ -1568,22 +1786,21 @@ def _register_inprocess(
         """
         import sys
 
-        from leapflow.plugins import get_registry, get_scoped_registry
+        from leapflow.plugins import get_scoped_registry
 
         new_plugin, load_err = self._load_from_path(module_name, target)
         if new_plugin is None:
             self._safe_unlink(target)
             return {"ok": False, "error": load_err}
 
-        reg = get_registry()
         scoped = get_scoped_registry()
-        fiber = scoped.create_fiber(plugin_id)
+        fiber = scoped.create_draft_fiber(plugin_id)
         try:
-            scoped.scoped_register(new_plugin, fiber)
-            fiber.activate()
-            installed_tools = reg.publish_plugin_tools(new_plugin)
+            scoped.stage_plugin(new_plugin, fiber)
+            fiber = scoped.promote_draft(plugin_id)
+            installed_tools = [tool.name for tool in new_plugin.tools]
         except (RuntimeError, ValueError, AttributeError, TypeError) as exc:
-            self._rollback_fiber(scoped, plugin_id, fiber)
+            scoped.discard_draft(plugin_id)
             sys.modules.pop(module_name, None)
             self._safe_unlink(target)
             return {"ok": False, "error": f"Registration failed: {exc}"}
@@ -1605,29 +1822,22 @@ async def _register_sandboxed(
         the sandbox worker and every handler proxies to it via
         SandboxedToolPlugin. The worker is stopped when the fiber is disposed.
         """
-        import os
-
-        from leapflow.plugins import get_registry, get_scoped_registry
+        from leapflow.plugins import get_scoped_registry
         from leapflow.plugins.protocol import ToolMetadata
         from leapflow.plugins.sandbox.sandbox_host import SandboxHost, SandboxedToolPlugin
 
         install_dir = installed_path.parent
-        host = SandboxHost(module_name)
-        started = False
-        original_pp = os.environ.get("PYTHONPATH")
-        os.environ["PYTHONPATH"] = os.pathsep.join(
-            [str(install_dir)] + ([original_pp] if original_pp else [])
+        host = SandboxHost(
+            module_name,
+            python_paths=(str(install_dir),),
+            **self._sandbox_settings(),
         )
+        started = False
         try:
             await host.start()
             started = True
         except (OSError, RuntimeError, ValueError) as exc:
             return {"ok": False, "error": f"Sandbox start failed: {exc}"}
-        finally:
-            if original_pp is None:
-                os.environ.pop("PYTHONPATH", None)
-            else:
-                os.environ["PYTHONPATH"] = original_pp
         if not started:
             return {"ok": False, "error": "Sandbox start failed"}
 
@@ -1654,17 +1864,15 @@ async def _register_sandboxed(
         ]
         sandboxed = SandboxedToolPlugin(plugin_id, "marketplace", metadatas, host)
 
-        reg = get_registry()
         scoped = get_scoped_registry()
-        fiber = scoped.create_fiber(plugin_id)
+        fiber = scoped.create_draft_fiber(plugin_id)
         try:
-            scoped.scoped_register(sandboxed, fiber)
-            fiber.activate()
-            installed_tools = reg.publish_plugin_tools(sandboxed)
-            # Stop the worker subprocess when the fiber is disposed.
-            fiber.scope.effect(lambda h=host: self._schedule_host_stop(h))
+            scoped.stage_plugin(sandboxed, fiber)
+            fiber.scope.async_effect(host.stop)
+            fiber = scoped.promote_draft(plugin_id)
+            installed_tools = [tool.name for tool in sandboxed.tools]
         except (RuntimeError, ValueError, AttributeError, TypeError) as exc:
-            self._rollback_fiber(scoped, plugin_id, fiber)
+            scoped.discard_draft(plugin_id)
             await host.stop()
             self._safe_unlink(installed_path)
             return {"ok": False, "error": f"Sandboxed registration failed: {exc}"}
@@ -1720,31 +1928,6 @@ def _load_from_path(self, module_name: str, path: "Path") -> "tuple[Any, str]":
             )
         return plugin_obj, ""
 
-    @staticmethod
-    def _rollback_fiber(scoped: Any, plugin_id: str, fiber: Any) -> None:
-        """Dispose a fiber and drop it from the scoped registry (rollback path)."""
-        from leapflow.domain.plugin_fiber import FiberState
-
-        try:
-            if fiber.state == FiberState.ACTIVE:
-                fiber.begin_unload()
-            if fiber.state != FiberState.DISPOSED:
-                fiber.dispose()
-        except (RuntimeError, ValueError, AttributeError):
-            pass
-        scoped._fibers.pop(plugin_id, None)
-
-    @staticmethod
-    def _schedule_host_stop(host: Any) -> None:
-        """Best-effort async shutdown of a sandbox worker on fiber disposal."""
-        import asyncio
-
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            return
-        loop.create_task(host.stop())
-
     @staticmethod
     def _safe_unlink(path: "Path") -> None:
         """Remove a written plugin file, ignoring absence/IO errors."""
@@ -1785,16 +1968,25 @@ def _active_proposal_tests(self, plugin_id: str) -> tuple[str, tuple[Any, ...],
         if not proposal_id:
             return "", (), ""
         try:
-            proposal = self._proposal_store().get(proposal_id)
+            store = self._lifecycle_store()
+            lifecycle = store.get(proposal_id)
+            if lifecycle is None:
+                lifecycle = store.find_by_metadata("review_proposal_id", proposal_id)
         except (RuntimeError, OSError, ValueError, AttributeError) as exc:
             return (
                 proposal_id,
                 (),
                 f"Plugin proposal '{proposal_id}' unavailable for behavior tests: {exc}",
             )
-        if proposal is None:
+        if lifecycle is None:
             return proposal_id, (), f"Plugin proposal '{proposal_id}' not found for behavior tests"
-        return proposal_id, tuple(getattr(proposal, "test_cases", ()) or ()), ""
+        review_payload = dict(lifecycle.metadata or {}).get("review_proposal")
+        if not isinstance(review_payload, Mapping):
+            return proposal_id, (), ""
+        from leapflow.domain.plugin_proposal import PluginProposal
+
+        proposal = PluginProposal.from_dict(review_payload)
+        return proposal_id, tuple(proposal.test_cases), ""
 
     async def _run_behavior_tests_for_plugin(
         self, plugin_id: str, test_cases: tuple[Any, ...]
@@ -1870,13 +2062,16 @@ async def _plugin_rollback_handler(
         approved, denial = await self._check_approval("rollback", plugin_id)
         if not approved:
             return {"ok": False, "error": denial, "requires_approval": True}
-        try:
-            from leapflow.plugins import reload_plugin
+        from leapflow.plugins import reload_plugin
 
-            target = self._resolve_install_dir() / f"{plugin_id}.py"
-            entry = self._version_store().rollback(plugin_id, version, target)
+        target = self._resolve_install_dir() / f"{plugin_id}.py"
+        version_store = self._version_store()
+        metadata_snapshot = version_store.snapshot_state(plugin_id)
+        source_snapshot = target.read_bytes() if target.exists() else None
+        try:
+            entry = version_store.rollback(plugin_id, version, target)
             fiber = reload_plugin(plugin_id)
-            return {
+            response = {
                 "ok": True,
                 "action": "rollback",
                 "plugin_id": plugin_id,
@@ -1884,11 +2079,40 @@ async def _plugin_rollback_handler(
                 "state": fiber.state.value,
                 "new_generation": fiber.generation,
             }
-        except KeyError as exc:
-            return {"ok": False, "error": str(exc)}
-        except (RuntimeError, OSError, AttributeError) as exc:
+            from leapflow.domain.event_types import EvolutionEventType
+
+            persisted = await self._emit_plugin_event(
+                EvolutionEventType.PLUGIN_ROLLED_BACK,
+                plugin_id=plugin_id,
+                version_id=str(entry.get("version") or version),
+                payload=response,
+                dedup_suffix=f"{entry.get('version', version)}:{fiber.generation}",
+            )
+            if not persisted:
+                response["audit_incomplete"] = True
+            return response
+        except (KeyError, RuntimeError, OSError, AttributeError) as exc:
+            restoration_error = ""
+            try:
+                version_store.restore_source(target, source_snapshot)
+                version_store.restore_state(plugin_id, metadata_snapshot)
+                reload_plugin(plugin_id)
+            except (KeyError, RuntimeError, OSError, AttributeError) as restore_exc:
+                restoration_error = str(restore_exc)
+                logger.error(
+                    "plugin_rollback could not restore the previous runtime: %s",
+                    restore_exc,
+                    exc_info=True,
+                )
             logger.warning("plugin_rollback failed: %s", exc, exc_info=True)
-            return {"ok": False, "error": f"Rollback failed: {exc}"}
+            response = {
+                "ok": False,
+                "error": f"Rollback failed: {exc}",
+                "rolled_back": restoration_error == "",
+            }
+            if restoration_error:
+                response["rollback_error"] = restoration_error
+            return response
 
     async def _plugin_enable_handler(self, plugin_id: str, **kwargs: Any) -> Dict[str, Any]:
         """Re-enable a previously disabled plugin. REQUIRES approval.
@@ -2329,9 +2553,9 @@ def tools(self) -> list[ToolMetadata]:
                     "description. The LLM produces code that conforms to the "
                     "ToolPlugin Protocol; it is then rigorously validated "
                     "(syntax, structure, import, protocol conformance). The "
-                    "isolated sandbox smoke test runs later, at install-time. "
-                    "Returns the validated code but DOES NOT install it — "
-                    "installation is a separate approval-gated step via plugin_install."
+                    "generated source is stored in CAS and receives explicit content "
+                    "approval. It DOES NOT install the plugin — installation requires "
+                    "a second, mutation-specific approval via plugin_install."
                 ),
                 parameters_schema={
                     "type": "object",
@@ -2346,7 +2570,7 @@ def tools(self) -> list[ToolMetadata]:
                         },
                         "proposal_id": {
                             "type": "string",
-                            "description": "Optional PluginProposal id to generate from; fills plugin_id/description when omitted.",
+                            "description": "Optional lifecycle proposal id or review alias; fills plugin_id/description when omitted.",
                         },
                     },
                     "required": [],
@@ -2359,7 +2583,7 @@ def tools(self) -> list[ToolMetadata]:
                     "requires_approval": False,
                     "effect_scope": "none",
                     "idempotency_scope": "turn",
-                    "summary": "generate a new plugin (produces code only, no install)",
+                    "summary": "generate, validate, persist, and approve proposal content",
                 },
                 provides_capabilities=("plugin.generate",),
             ),
@@ -2394,7 +2618,7 @@ def tools(self) -> list[ToolMetadata]:
                         },
                         "proposal_id": {
                             "type": "string",
-                            "description": "Optional PluginProposal id to link into approval metadata and mark approved on success.",
+                            "description": "Optional lifecycle proposal id or review alias; requires prior content approval.",
                         },
                         "version_label": {
                             "type": "string",
diff --git a/src/leapflow/plugins/tool_plugins/shell_terminal.py b/src/leapflow/plugins/tool_plugins/shell_terminal.py
index 394640eb..856e5e6f 100644
--- a/src/leapflow/plugins/tool_plugins/shell_terminal.py
+++ b/src/leapflow/plugins/tool_plugins/shell_terminal.py
@@ -70,6 +70,7 @@ def tools(self) -> list[ToolMetadata]:
                     "idempotency_scope": "session",
                 },
                 mutates_state=True,
+                execution_policy="external_side_effect",
                 # Grounded in leapflow.domain.platform.Capability.SHELL_EXEC:
                 # a host without shell execution cannot run this tool, which
                 # environment-fit scoring uses to exclude it rather than fail
@@ -110,6 +111,7 @@ def tools(self) -> list[ToolMetadata]:
                     "effect_scope": "external",
                 },
                 mutates_state=True,
+                execution_policy="external_side_effect",
                 provides_capabilities=("shell.session_create",),
                 requires_platform_capabilities=("shell.exec",),
             ),
@@ -140,6 +142,7 @@ def tools(self) -> list[ToolMetadata]:
                     "effect_scope": "external",
                 },
                 mutates_state=True,
+                execution_policy="external_side_effect",
                 provides_capabilities=("shell.session_input",),
                 requires_platform_capabilities=("shell.exec",),
             ),
@@ -191,6 +194,7 @@ def tools(self) -> list[ToolMetadata]:
                     "requires_approval": False,
                 },
                 mutates_state=True,
+                execution_policy="external_side_effect",
                 provides_capabilities=("shell.session_destroy",),
                 requires_platform_capabilities=("shell.exec",),
             ),
diff --git a/src/leapflow/skills/registry.py b/src/leapflow/skills/registry.py
index 05117e62..3bee7f10 100644
--- a/src/leapflow/skills/registry.py
+++ b/src/leapflow/skills/registry.py
@@ -191,7 +191,8 @@ async def invoke(
             if not pre.passed:
                 return SkillResult(ok=False, error=f"precondition_failed: {pre.reason}")
 
-        # Core execution closure for prediction loop wrapping
+        # The registry validates and invokes only. Cross-cutting evidence belongs to
+        # the runtime ActionExecutor so every entry point follows the same boundary.
         async def _execute_core() -> Any:
             from leapflow.utils.resilience import ResiliencePolicy, execute_with_resilience
             policy = ResiliencePolicy(timeout_s=self._timeout_for(skill))
@@ -199,20 +200,9 @@ async def _execute_core() -> Any:
                 lambda: skill.run(**validated), policy
             )
 
-        # Execute with optional prediction loop
         t0 = time.perf_counter()
-        prediction_outcome = None
         try:
-            if self._prediction_loop is not None:
-                user_goal = str(kwargs.get("user_goal", "") or "")
-                if user_goal and hasattr(self._prediction_loop, "set_goal"):
-                    self._prediction_loop.set_goal(user_goal)
-                action_desc = f"skill:{name}"
-                output, prediction_outcome = await self._prediction_loop.wrap_execution(
-                    action_desc, _execute_core,
-                )
-            else:
-                output = await _execute_core()
+            output = await _execute_core()
             elapsed = time.perf_counter() - t0
         except asyncio.TimeoutError:
             elapsed = time.perf_counter() - t0
diff --git a/src/leapflow/storage/__init__.py b/src/leapflow/storage/__init__.py
index e43e173a..a2c6d80f 100644
--- a/src/leapflow/storage/__init__.py
+++ b/src/leapflow/storage/__init__.py
@@ -11,6 +11,13 @@
 from leapflow.storage.connection import ConnectionHolder, LocalConnectionHolder
 from leapflow.storage.conversation_store import DuckDBConversationStore
 from leapflow.storage.duckdb_connect import DatabaseLockedError, connect, is_lock_error
+from leapflow.storage.capability_proposal_queue import EvolutionCapabilityProposalStore
+from leapflow.storage.distilled_knowledge_store import EvolutionDistilledKnowledgeStore
+from leapflow.storage.evolution_event_store import (
+    DuckDBEvolutionEventStore,
+    EvolutionTraceEventStore,
+)
+from leapflow.storage.plugin_outcome_store import EvolutionPluginOutcomeStore
 from leapflow.storage.session_store import LearningSessionStore
 from leapflow.storage.skill_docs import SkillDocStore
 from leapflow.storage.skill_library import SkillLibraryStore
@@ -21,6 +28,11 @@
     "ConnectionHolder",
     "DatabaseLockedError",
     "DuckDBConversationStore",
+    "DuckDBEvolutionEventStore",
+    "EvolutionCapabilityProposalStore",
+    "EvolutionDistilledKnowledgeStore",
+    "EvolutionPluginOutcomeStore",
+    "EvolutionTraceEventStore",
     "LocalConnectionHolder",
     "LearningSessionStore",
     "SkillDocStore",
diff --git a/src/leapflow/storage/capability_proposal_queue.py b/src/leapflow/storage/capability_proposal_queue.py
index 84648857..b4947d7b 100644
--- a/src/leapflow/storage/capability_proposal_queue.py
+++ b/src/leapflow/storage/capability_proposal_queue.py
@@ -3,13 +3,14 @@
 
 from __future__ import annotations
 
-import json
+import threading
 import time
 from dataclasses import dataclass, field
-from pathlib import Path
 from typing import Any, Literal, Mapping, Sequence
 
 from leapflow.domain.capability_requirement import CapabilityRequirement
+from leapflow.domain.event_types import EvolutionEventType
+from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent, content_hash
 
 ProposalStatus = Literal[
     "PENDING",
@@ -21,9 +22,34 @@
     "REJECTED",
     "FAILED",
     "QUARANTINED",
+    "SUPERSEDED",
+    "EXPIRED",
+    "NO_OP",
 ]
 
-_ACTIVE_STATUSES = {"PENDING", "GENERATED", "APPROVED", "INSTALLED", "PROBATION"}
+_ACTIVE_STATUSES = {
+    "PENDING",
+    "GENERATED",
+    "APPROVED",
+    "INSTALLED",
+    "PROBATION",
+    "VERIFIED",
+}
+_CANCELLATION_STATUSES = frozenset({"REJECTED", "FAILED", "SUPERSEDED", "EXPIRED", "NO_OP"})
+_ALLOWED_TRANSITIONS: dict[str, frozenset[str]] = {
+    "PENDING": frozenset({"GENERATED", *_CANCELLATION_STATUSES}),
+    "GENERATED": frozenset({"APPROVED", *_CANCELLATION_STATUSES}),
+    "APPROVED": frozenset({"INSTALLED", *_CANCELLATION_STATUSES}),
+    "INSTALLED": frozenset({"PROBATION", "QUARANTINED", "FAILED"}),
+    "PROBATION": frozenset({"VERIFIED", "QUARANTINED", "FAILED"}),
+    "VERIFIED": frozenset({"PROBATION", "QUARANTINED", "FAILED"}),
+    "QUARANTINED": frozenset({"FAILED"}),
+    "REJECTED": frozenset(),
+    "FAILED": frozenset(),
+    "SUPERSEDED": frozenset(),
+    "EXPIRED": frozenset(),
+    "NO_OP": frozenset(),
+}
 
 
 @dataclass(frozen=True)
@@ -39,7 +65,8 @@ class CapabilityProposalItem:
     observation_ids: tuple[str, ...] = ()
     policy_decision: Mapping[str, Any] = field(default_factory=dict)
     generated_code_ref: str = ""
-    approval_id: str = ""
+    proposal_approval_id: str = ""
+    mutation_approval_id: str = ""
     install_result: Mapping[str, Any] = field(default_factory=dict)
     test_results: tuple[Mapping[str, Any], ...] = ()
     trust_state: Mapping[str, Any] = field(default_factory=dict)
@@ -58,7 +85,8 @@ def to_dict(self) -> dict[str, Any]:
             "observation_ids": list(self.observation_ids),
             "policy_decision": dict(self.policy_decision),
             "generated_code_ref": self.generated_code_ref,
-            "approval_id": self.approval_id,
+            "proposal_approval_id": self.proposal_approval_id,
+            "mutation_approval_id": self.mutation_approval_id,
             "install_result": dict(self.install_result),
             "test_results": [dict(item) for item in self.test_results],
             "trust_state": dict(self.trust_state),
@@ -81,7 +109,8 @@ def from_dict(cls, data: Mapping[str, Any]) -> "CapabilityProposalItem":
             observation_ids=tuple(str(item) for item in data.get("observation_ids") or ()),
             policy_decision=dict(data.get("policy_decision") or {}),
             generated_code_ref=str(data.get("generated_code_ref") or ""),
-            approval_id=str(data.get("approval_id") or ""),
+            proposal_approval_id=str(data.get("proposal_approval_id") or ""),
+            mutation_approval_id=str(data.get("mutation_approval_id") or ""),
             install_result=dict(data.get("install_result") or {}),
             test_results=tuple(
                 dict(item) for item in data.get("test_results") or () if isinstance(item, Mapping)
@@ -93,15 +122,29 @@ def from_dict(cls, data: Mapping[str, Any]) -> "CapabilityProposalItem":
         )
 
 
-class JsonCapabilityProposalQueue:
-    """Profile-scoped durable queue of adaptive evolution proposals."""
+_STATUS_EVENT_TYPES: dict[str, str] = {
+    "PENDING": EvolutionEventType.PROPOSAL_CREATED,
+    "GENERATED": EvolutionEventType.PROPOSAL_GENERATED,
+    "APPROVED": EvolutionEventType.PROPOSAL_APPROVED,
+    "INSTALLED": EvolutionEventType.PLUGIN_INSTALLED,
+    "PROBATION": EvolutionEventType.PLUGIN_PROBATION_STARTED,
+    "VERIFIED": EvolutionEventType.PLUGIN_VERIFIED,
+    "REJECTED": EvolutionEventType.PROPOSAL_REJECTED,
+    "FAILED": EvolutionEventType.PROPOSAL_FAILED,
+    "QUARANTINED": EvolutionEventType.PLUGIN_QUARANTINED,
+    "SUPERSEDED": EvolutionEventType.PROPOSAL_SUPERSEDED,
+    "EXPIRED": EvolutionEventType.PROPOSAL_EXPIRED,
+    "NO_OP": EvolutionEventType.PROPOSAL_NO_OP,
+}
 
-    def __init__(self, path: Path) -> None:
-        self._path = Path(path)
 
-    @property
-    def path(self) -> Path:
-        return self._path
+class EvolutionCapabilityProposalStore:
+    """Event-sourced capability proposal lifecycle used by production runtime."""
+
+    def __init__(self, event_store: Any, *, profile_id: str) -> None:
+        self._event_store = event_store
+        self._profile_id = str(profile_id)
+        self._lock = threading.RLock()
 
     def enqueue(
         self,
@@ -113,32 +156,68 @@ def enqueue(
         observation_ids: Sequence[str] = (),
         metadata: Mapping[str, Any] | None = None,
     ) -> CapabilityProposalItem:
-        """Create or return an active proposal for the requirement/environment pair."""
+        with self._lock:
+            item, event = self.prepare_enqueue(
+                requirements=requirements,
+                environment=environment,
+                risk=risk,
+                source=source,
+                observation_ids=observation_ids,
+                metadata=metadata,
+            )
+            if event is None:
+                return item
+            self._event_store.append(event)
+            return self.get(item.proposal_id) or item
+
+    def prepare_enqueue(
+        self,
+        *,
+        requirements: Sequence[CapabilityRequirement | Mapping[str, Any]],
+        environment: Mapping[str, Any] | None = None,
+        risk: Mapping[str, Any] | None = None,
+        source: str = "runtime",
+        observation_ids: Sequence[str] = (),
+        metadata: Mapping[str, Any] | None = None,
+        occurred_at: float | None = None,
+    ) -> tuple[CapabilityProposalItem, EvolutionEvent | None]:
+        """Build an idempotent creation event without writing it.
+
+        Durable workers use this seam to commit the proposal in the same
+        transaction as the teacher result. Ordinary callers can keep using
+        :meth:`enqueue`, which appends the prepared event immediately.
+        """
         req_payload = tuple(_requirement_dict(item) for item in requirements)
-        proposal_id = self._proposal_id(req_payload, environment or {})
-        existing = self.get(proposal_id)
-        if existing is not None and existing.status in _ACTIVE_STATUSES:
-            return existing
-        now = time.time()
-        item = CapabilityProposalItem(
-            proposal_id=proposal_id,
-            status="PENDING",
-            requirements=req_payload,
-            environment=dict(environment or {}),
-            risk=dict(risk or {}),
-            source=str(source or "runtime"),
-            observation_ids=tuple(str(item) for item in observation_ids),
-            created_at=now,
-            updated_at=now,
-            metadata=dict(metadata or {}),
-        )
-        self._upsert(item)
-        return item
+        proposal_id = _proposal_identity(req_payload, environment or {})
+        with self._lock:
+            existing = self.get(proposal_id)
+            if existing is not None:
+                return existing, None
+            now = time.time() if occurred_at is None else float(occurred_at)
+            item = CapabilityProposalItem(
+                proposal_id=proposal_id,
+                status="PENDING",
+                requirements=req_payload,
+                environment=dict(environment or {}),
+                risk=dict(risk or {}),
+                source=str(source or "runtime"),
+                observation_ids=tuple(str(item) for item in observation_ids),
+                created_at=now,
+                updated_at=now,
+                metadata=dict(metadata or {}),
+            )
+            return item, self._state_event(item, previous_status="")
 
     def get(self, proposal_id: str) -> CapabilityProposalItem | None:
-        for item in self.list_items(limit=0):
-            if item.proposal_id == proposal_id:
-                return item
+        records = self._event_store.read(
+            profile_id=self._profile_id,
+            proposal_id=str(proposal_id),
+            limit=5000,
+        )
+        for record in reversed(records):
+            payload = record.event.to_dict()["payload"].get("proposal_state")
+            if isinstance(payload, Mapping):
+                return CapabilityProposalItem.from_dict(payload)
         return None
 
     def update(
@@ -148,138 +227,208 @@ def update(
         status: ProposalStatus | None = None,
         policy_decision: Mapping[str, Any] | None = None,
         generated_code_ref: str | None = None,
-        approval_id: str | None = None,
+        proposal_approval_id: str | None = None,
+        mutation_approval_id: str | None = None,
         install_result: Mapping[str, Any] | None = None,
         test_results: Sequence[Mapping[str, Any]] | None = None,
         trust_state: Mapping[str, Any] | None = None,
         metadata: Mapping[str, Any] | None = None,
     ) -> CapabilityProposalItem | None:
-        item = self.get(proposal_id)
-        if item is None:
-            return None
-        updated = CapabilityProposalItem(
-            proposal_id=item.proposal_id,
-            status=_coerce_status(status or item.status),
-            requirements=item.requirements,
-            environment=item.environment,
-            risk=item.risk,
-            source=item.source,
-            observation_ids=item.observation_ids,
-            policy_decision=dict(
-                policy_decision if policy_decision is not None else item.policy_decision
-            ),
-            generated_code_ref=item.generated_code_ref
-            if generated_code_ref is None
-            else str(generated_code_ref),
-            approval_id=item.approval_id if approval_id is None else str(approval_id),
-            install_result=dict(
-                install_result if install_result is not None else item.install_result
-            ),
-            test_results=tuple(
-                dict(result)
-                for result in (test_results if test_results is not None else item.test_results)
-            ),
-            trust_state=dict(trust_state if trust_state is not None else item.trust_state),
-            created_at=item.created_at,
-            updated_at=time.time(),
-            metadata={**dict(item.metadata), **dict(metadata or {})},
-        )
-        self._upsert(updated)
-        return updated
+        with self._lock:
+            item = self.get(proposal_id)
+            if item is None:
+                return None
+            target = _coerce_status(status or item.status)
+            if target != item.status and target not in _ALLOWED_TRANSITIONS.get(
+                item.status, frozenset()
+            ):
+                raise ValueError(
+                    f"illegal proposal transition: {item.status} -> {target}"
+                )
+            updated = CapabilityProposalItem(
+                proposal_id=item.proposal_id,
+                status=target,
+                requirements=item.requirements,
+                environment=item.environment,
+                risk=item.risk,
+                source=item.source,
+                observation_ids=item.observation_ids,
+                policy_decision=dict(
+                    policy_decision if policy_decision is not None else item.policy_decision
+                ),
+                generated_code_ref=(
+                    item.generated_code_ref
+                    if generated_code_ref is None
+                    else str(generated_code_ref)
+                ),
+                proposal_approval_id=(
+                    item.proposal_approval_id
+                    if proposal_approval_id is None
+                    else str(proposal_approval_id)
+                ),
+                mutation_approval_id=(
+                    item.mutation_approval_id
+                    if mutation_approval_id is None
+                    else str(mutation_approval_id)
+                ),
+                install_result=dict(
+                    install_result if install_result is not None else item.install_result
+                ),
+                test_results=tuple(
+                    dict(result)
+                    for result in (
+                        test_results if test_results is not None else item.test_results
+                    )
+                ),
+                trust_state=dict(
+                    trust_state if trust_state is not None else item.trust_state
+                ),
+                created_at=item.created_at,
+                updated_at=time.time(),
+                metadata={**dict(item.metadata), **dict(metadata or {})},
+            )
+            return self._append_state(updated, previous_status=item.status)
+
+    def transition(
+        self,
+        proposal_id: str,
+        status: ProposalStatus,
+        **changes: Any,
+    ) -> CapabilityProposalItem:
+        with self._lock:
+            current = self.get(proposal_id)
+            if current is None:
+                raise KeyError(f"unknown capability proposal: {proposal_id}")
+            target = _coerce_status(status)
+            if target == current.status:
+                updated = self.update(proposal_id, **changes) if changes else current
+                if updated is None:
+                    raise KeyError(f"unknown capability proposal: {proposal_id}")
+                return updated
+            if target not in _ALLOWED_TRANSITIONS.get(current.status, frozenset()):
+                raise ValueError(
+                    f"illegal proposal transition: {current.status} -> {target}"
+                )
+            updated = self.update(proposal_id, status=target, **changes)
+            if updated is None:
+                raise KeyError(f"unknown capability proposal: {proposal_id}")
+            return updated
 
     def list_items(
         self, *, status: ProposalStatus | str = "", limit: int = 50
     ) -> list[CapabilityProposalItem]:
-        payload = self._load_payload()
-        items = [
-            CapabilityProposalItem.from_dict(item)
-            for item in payload.get("proposals", [])
-            if isinstance(item, Mapping)
-        ]
+        latest: dict[str, CapabilityProposalItem] = {}
+        cursor = 0
+        while True:
+            records = self._event_store.read(
+                profile_id=self._profile_id,
+                proposal_events_only=True,
+                after_sequence=cursor,
+                limit=5000,
+            )
+            if not records:
+                break
+            for record in records:
+                payload = record.event.to_dict()["payload"].get("proposal_state")
+                if isinstance(payload, Mapping):
+                    item = CapabilityProposalItem.from_dict(payload)
+                    latest[item.proposal_id] = item
+            cursor = records[-1].sequence
+            if len(records) < 5000:
+                break
+        items = list(latest.values())
         if status:
-            status_value = str(status)
-            items = [item for item in items if item.status == status_value]
+            items = [item for item in items if item.status == str(status)]
         items.sort(key=lambda item: item.updated_at or item.created_at, reverse=True)
         return items if limit <= 0 else items[:limit]
 
+    def find_by_metadata(self, key: str, value: str) -> CapabilityProposalItem | None:
+        target = str(value)
+        for item in self.list_items(limit=0):
+            if str(item.metadata.get(key) or "") == target:
+                return item
+        return None
+
     def active(self, *, limit: int = 50) -> list[CapabilityProposalItem]:
-        # ``limit <= 0`` means "all", matching ``list_items``. Slicing ``[:limit]``
-        # unconditionally made ``active(limit=0)`` return an empty list -- the opposite
-        # of "no cap" -- which silently emptied any caller that asked for the full set.
         items = [item for item in self.list_items(limit=0) if item.status in _ACTIVE_STATUSES]
         return items if limit <= 0 else items[:limit]
 
-    def _upsert(self, item: CapabilityProposalItem) -> None:
-        payload = self._load_payload()
-        proposals = [entry for entry in payload.get("proposals", []) if isinstance(entry, Mapping)]
-        proposals = [entry for entry in proposals if entry.get("proposal_id") != item.proposal_id]
-        proposals.append(item.to_dict())
-        payload["proposals"] = proposals
-        self._write_payload(payload)
-
-    def _proposal_id(
+    def _append_state(
         self,
-        requirements: Sequence[Mapping[str, Any]],
-        environment: Mapping[str, Any],
-    ) -> str:
-        """A content id over *stable identity only*, so dedup survives rewording.
-
-        Hashing the whole requirement payload made the id a function of the free-text
-        ``evidence`` (the world model's hypothesis) and its metadata, so the same
-        capability re-proposed with different wording every session minted a fresh id
-        and the queue filled with duplicates -- the health of the queue then measured
-        how long the process had run rather than how many real gaps existed. Identity is
-        what a requirement *is* (its id, capability, origin, risk ceiling and platform
-        needs) plus the environment fingerprint it was raised in; the prose that
-        justifies it is not identity. ``observation_ids`` are carried on the item for
-        the causal ledger but deliberately excluded here: two profiles observing the
-        same gap mint different observation ids, and folding those into identity would
-        defeat dedup for the very case it exists to collapse.
-        """
-        identity = [
-            {
-                "requirement_id": str(item.get("requirement_id") or ""),
-                "capability": str(item.get("capability") or ""),
-                "origin": str(item.get("origin") or ""),
-                "max_risk_level": str(item.get("max_risk_level") or ""),
-                "required_platform_capabilities": sorted(
-                    str(cap) for cap in (item.get("required_platform_capabilities") or [])
-                ),
-            }
-            for item in requirements
-        ]
-        material = {
-            "identity": identity,
-            "environment": {
-                "fingerprint_id": environment.get("fingerprint_id", ""),
-                "platform_capabilities": environment.get("platform_capabilities", []),
-                "workspace_markers": environment.get("workspace_markers", []),
+        item: CapabilityProposalItem,
+        *,
+        previous_status: str,
+    ) -> CapabilityProposalItem:
+        self._event_store.append(self._state_event(item, previous_status=previous_status))
+        stored = self.get(item.proposal_id)
+        return stored or item
+
+    def _state_event(self, item: CapabilityProposalItem, *, previous_status: str) -> EvolutionEvent:
+        event_type = (
+            _STATUS_EVENT_TYPES[item.status]
+            if item.status != previous_status
+            else EvolutionEventType.PROPOSAL_UPDATED
+        )
+        state = item.to_dict()
+        identity = dict(state)
+        identity.pop("updated_at", None)
+        first_requirement = dict(item.requirements[0]) if item.requirements else {}
+        return EvolutionEvent.create(
+            event_type,
+            context=EvolutionContext(
+                profile_id=self._profile_id,
+                workspace_id=str(item.environment.get("workspace_id") or ""),
+                session_id=str(item.environment.get("session_id") or ""),
+                requirement_id=str(first_requirement.get("requirement_id") or ""),
+                proposal_id=item.proposal_id,
+                artifact_id=item.generated_code_ref,
+                plugin_id=str(item.metadata.get("plugin_id") or ""),
+                correlation_id=item.proposal_id,
+            ),
+            payload={
+                "proposal_state": state,
+                "previous_status": previous_status,
+                "status": item.status,
+                "reason": str(item.metadata.get("terminal_reason") or ""),
             },
-        }
-        text = json.dumps(material, sort_keys=True, ensure_ascii=False, default=str)
-        import hashlib
-
-        return "prop-" + hashlib.sha256(text.encode("utf-8")).hexdigest()[:16]
-
-    def _load_payload(self) -> dict[str, Any]:
-        if not self._path.exists():
-            return {"version": 1, "proposals": []}
-        try:
-            data = json.loads(self._path.read_text(encoding="utf-8"))
-            if isinstance(data, Mapping) and isinstance(data.get("proposals"), list):
-                return {"version": int(data.get("version") or 1), "proposals": data["proposals"]}
-        except (OSError, json.JSONDecodeError, TypeError, ValueError):
-            return {"version": 1, "proposals": []}
-        return {"version": 1, "proposals": []}
-
-    def _write_payload(self, payload: Mapping[str, Any]) -> None:
-        self._path.parent.mkdir(parents=True, exist_ok=True)
-        self._path.write_text(
-            json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True),
-            encoding="utf-8",
+            producer="proposal.orchestrator",
+            privacy_class="profile",
+            occurred_at=item.updated_at,
+            dedup_key=(
+                f"proposal.created:{item.proposal_id}"
+                if not previous_status
+                else f"proposal.state:{item.proposal_id}:{item.status}:{content_hash(identity)}"
+            ),
         )
 
 
+def _proposal_identity(
+    requirements: Sequence[Mapping[str, Any]],
+    environment: Mapping[str, Any],
+) -> str:
+    identity = [
+        {
+            "requirement_id": str(item.get("requirement_id") or ""),
+            "capability": str(item.get("capability") or ""),
+            "origin": str(item.get("origin") or ""),
+            "max_risk_level": str(item.get("max_risk_level") or ""),
+            "required_platform_capabilities": sorted(
+                str(cap) for cap in (item.get("required_platform_capabilities") or [])
+            ),
+        }
+        for item in requirements
+    ]
+    material = {
+        "identity": identity,
+        "environment": {
+            "fingerprint_id": environment.get("fingerprint_id", ""),
+            "platform_capabilities": environment.get("platform_capabilities", []),
+            "workspace_markers": environment.get("workspace_markers", []),
+        },
+    }
+    return "prop-" + content_hash(material)[:16]
+
+
 def _coerce_status(value: Any) -> ProposalStatus:
     raw = str(value or "PENDING").upper()
     allowed = ProposalStatus.__args__  # type: ignore[attr-defined]
@@ -292,4 +441,8 @@ def _requirement_dict(item: CapabilityRequirement | Mapping[str, Any]) -> Mappin
     return dict(item)
 
 
-__all__ = ["CapabilityProposalItem", "JsonCapabilityProposalQueue", "ProposalStatus"]
+__all__ = [
+    "CapabilityProposalItem",
+    "EvolutionCapabilityProposalStore",
+    "ProposalStatus",
+]
diff --git a/src/leapflow/storage/distilled_knowledge_store.py b/src/leapflow/storage/distilled_knowledge_store.py
index 1b041964..0401da6c 100644
--- a/src/leapflow/storage/distilled_knowledge_store.py
+++ b/src/leapflow/storage/distilled_knowledge_store.py
@@ -1,17 +1,20 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
-"""Durable home for what the teacher distilled, and the rules that retire it.
+"""What the teacher distilled, projected from the append-only evolution log.
 
 This is the C1 channel: the cheapest way the system adapts to a changed environment.
 Three of the four adaptation actions change nothing except what the acting agent knows,
 so a statement like "the send control is now labelled Dispatch and lives in the toolbar"
 lets the next session succeed with no code written, no approval, and no trust rebuilt.
 
+The single source of truth is ``evolution_events``: the durable teacher worker commits a
+``TEACHER_VERDICT_RECORDED`` fact per verdict, and this store *projects* those facts into
+the in-memory read model the acting agent consults. There is no second durable store and
+no write-back path; the projection is rebuilt from events on demand.
+
 **Retirement is designed in, not bolted on.** An assertion about a world that keeps
 changing is only true for a while, and stale knowledge does not merely go unused -- it
 actively misleads, because the acting agent has no way to tell a current fact from one
-that expired three upgrades ago. Telling it "the send control is labelled Dispatch" after
-the control was renamed again is worse than telling it nothing. So an entry leaves in
-exactly three ways:
+that expired three upgrades ago. So an entry leaves in exactly three ways:
 
 * **Superseded** -- a newer verdict about the same capability replaces the older one.
   One live entry per capability, because the teacher's latest conclusion is its
@@ -19,52 +22,28 @@
   contradictory past as though every version were current.
 * **Expired** -- entries have a bounded lifetime, configurable rather than fixed.
   Unbounded accumulation would eventually dominate the context it was meant to improve.
-* **Retracted** -- an explicit call, used when a capability is observed working again and
-  the knowledge describing its failure is therefore obsolete.
+* **Retracted** -- an explicit ``KNOWLEDGE_RETRACTED`` fact, used when a capability is
+  observed working again and the knowledge describing its failure is therefore obsolete.
 
 What is deliberately *not* a retirement rule: an environment fingerprint that no longer
 matches the current one. It is recorded and disclosed, never used to filter. Whether an
 OS point release invalidates "the send control is labelled Dispatch" is a judgement about
 meaning, and the storage layer guessing it would be a hard rule with no ability to
-generalise -- precisely the kind that looks safe and quietly discards good knowledge. The
-mismatch is surfaced so the reader can weigh it; the reader is a language model, and this
-is the sort of thing it is better at than a predicate.
+generalise. The mismatch is surfaced so the reader -- a language model -- can weigh it.
 """
 
 from __future__ import annotations
 
-import json
 import logging
+import threading
 import time
 from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Mapping
+from typing import Any
 
-logger = logging.getLogger(__name__)
+from leapflow.domain.event_types import EvolutionEventType
+from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent, EvolutionEventRecord
 
-#: Fields persisted for one entry. An explicit allow-list, matching the observation
-#: store's convention -- and carrying its scar: a field absent from that store's list was
-#: silently dropped, so a fact reached the teacher with ``None`` where an identity should
-#: have been and nothing raised. Adding a field to the record means adding it here.
-#:
-#: Bound to ``DistilledKnowledge.to_dict()`` *exactly*, not loosely, and a test asserts
-#: it. A field the dataclass has and this set lacks is the historical silent drop; an
-#: entry here with no matching field is the mirror image -- it claims to persist something
-#: that never existed, which is how a whitelist stops being trustworthy. ``"environment"``
-#: was exactly that: a leftover from considering whether to store the whole fingerprint.
-_ENTRY_FIELDS: frozenset[str] = frozenset(
-    {
-        "capability",
-        "knowledge",
-        "action",
-        "verdict_id",
-        "confidence",
-        "rationale",
-        "target",
-        "environment_id",
-        "created_at",
-    }
-)
+logger = logging.getLogger(__name__)
 
 
 @dataclass(frozen=True)
@@ -83,170 +62,63 @@ class DistilledKnowledge:
     environment_id: str = ""
     created_at: float = 0.0
 
-    @classmethod
-    def from_verdict(
-        cls, verdict: Any, *, environment: Mapping[str, Any] | None = None
-    ) -> DistilledKnowledge:
-        """Project an ``AdaptationVerdict`` into a storable entry.
-
-        Takes the verdict duck-typed rather than imported, so storage does not depend on
-        the domain module that depends on it.
-        """
-        env = dict(environment or {})
-        return cls(
-            capability=str(getattr(verdict, "capability", "") or ""),
-            knowledge=str(getattr(verdict, "knowledge", "") or ""),
-            action=str(getattr(verdict, "action", "") or ""),
-            verdict_id=str(getattr(verdict, "verdict_id", "") or ""),
-            confidence=float(getattr(verdict, "confidence", 0.0) or 0.0),
-            rationale=str(getattr(verdict, "rationale", "") or ""),
-            target=str(getattr(verdict, "target", "") or ""),
-            environment_id=str(env.get("fingerprint_id") or ""),
-            created_at=float(getattr(verdict, "created_at", 0.0) or time.time()),
-        )
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "capability": self.capability,
-            "knowledge": self.knowledge,
-            "action": self.action,
-            "verdict_id": self.verdict_id,
-            "confidence": self.confidence,
-            "rationale": self.rationale,
-            "target": self.target,
-            "environment_id": self.environment_id,
-            "created_at": self.created_at,
-        }
-
-    @classmethod
-    def from_dict(cls, payload: Mapping[str, Any]) -> DistilledKnowledge:
-        return cls(
-            capability=str(payload.get("capability") or ""),
-            knowledge=str(payload.get("knowledge") or ""),
-            action=str(payload.get("action") or ""),
-            verdict_id=str(payload.get("verdict_id") or ""),
-            confidence=float(payload.get("confidence") or 0.0),
-            rationale=str(payload.get("rationale") or ""),
-            target=str(payload.get("target") or ""),
-            environment_id=str(payload.get("environment_id") or ""),
-            created_at=float(payload.get("created_at") or 0.0),
-        )
-
-
-class JsonDistilledKnowledgeStore:
-    """Profile-scoped store for distilled knowledge, keyed by capability.
 
-    JSON rather than the semantic memory provider, for a reason that decided the design:
-    the reader needs *every* live entry, and semantic memory answers keyword queries. A
-    fact the agent needs is not necessarily a fact whose words appear in the request --
-    "the send control is now Dispatch" is exactly what a request saying "reply to Ana"
-    needs and would never retrieve. Complete enumeration is the requirement, so the store
-    that offers it is the right one.
+class EvolutionDistilledKnowledgeStore:
+    """In-memory knowledge read model derived only from evolution events.
 
-    Reads are hot (every turn that discloses knowledge) and writes are cold (once per
-    session, at grading time), which is why an entry cache is kept and invalidated on
-    write rather than re-reading the file per turn.
+    Hydration and refresh are cold-path operations. ``live`` and
+    ``rebind_preferences`` only read the in-memory snapshot, so adding this
+    always-on context channel does not add a DuckDB query to every turn.
     """
 
-    def __init__(self, path: Path, *, ttl_seconds: float = 0.0) -> None:
-        self._path = Path(path)
+    def __init__(self, event_store: Any, *, profile_id: str, ttl_seconds: float = 0.0) -> None:
+        self._event_store = event_store
+        self._profile_id = str(profile_id)
         self._ttl = max(0.0, float(ttl_seconds))
-        self._cache: tuple[DistilledKnowledge, ...] | None = None
-
-    @property
-    def path(self) -> Path:
-        return self._path
+        self._entries: dict[str, DistilledKnowledge] = {}
+        self._last_sequence = 0
+        self._lock = threading.RLock()
 
     @property
     def ttl_seconds(self) -> float:
         return self._ttl
 
-    # ── writes (cold path) ────────────────────────────────────────────────────
-
-    def record(
-        self, verdict: Any, *, environment: Mapping[str, Any] | None = None
-    ) -> DistilledKnowledge | None:
-        """Store one verdict's knowledge, superseding any earlier entry for it.
-
-        Returns the stored entry, or ``None`` when the verdict carries nothing usable.
-        Refusing silently here would be wrong in the other direction: a verdict without
-        knowledge is a defect in the parser, which already rejects that shape, so
-        reaching this point means something upstream changed.
-        """
-        entry = DistilledKnowledge.from_verdict(verdict, environment=environment)
-        if not entry.capability or not entry.knowledge:
-            logger.debug(
-                "distilled_knowledge: refused entry without capability or knowledge (%r)",
-                entry.verdict_id,
-            )
-            return None
-        # Supersession, not append: the teacher's latest conclusion about a capability is
-        # its conclusion, and keeping the older one live would show the agent a
-        # capability's contradictory past as though every version were current.
-        kept = [e for e in self._load() if e.capability != entry.capability]
-        kept.append(entry)
-        self._write(kept)
-        return entry
-
-    def record_all(
-        self, verdicts: Any, *, environment: Mapping[str, Any] | None = None
-    ) -> tuple[DistilledKnowledge, ...]:
-        """Store a batch, one write for the lot.
-
-        Later verdicts about the same capability win, matching ``record``'s supersession
-        within the batch as well as across batches.
-        """
-        incoming: dict[str, DistilledKnowledge] = {}
-        for verdict in verdicts or ():
-            entry = DistilledKnowledge.from_verdict(verdict, environment=environment)
-            if entry.capability and entry.knowledge:
-                incoming[entry.capability] = entry
-        if not incoming:
-            return ()
-        kept = [e for e in self._load() if e.capability not in incoming]
-        kept.extend(incoming.values())
-        self._write(kept)
-        return tuple(incoming.values())
-
-    def retract(self, capability: str, *, reason: str = "") -> bool:
-        """Drop the entry for one capability. Used when its knowledge is obsolete.
-
-        The third retirement path, and the only one a caller drives: a capability
-        observed working again makes knowledge describing its failure misleading, and
-        nothing about supersession or expiry would remove it -- no newer verdict is
-        coming precisely because there is no longer anything wrong.
-        """
-        name = str(capability or "").strip()
-        if not name:
-            return False
-        entries = self._load()
-        kept = [e for e in entries if e.capability != name]
-        if len(kept) == len(entries):
-            return False
-        logger.debug(
-            "distilled_knowledge: retracted %s (%s)", name, reason or "no reason given"
-        )
-        self._write(kept)
-        return True
-
-    # ── reads (hot path) ──────────────────────────────────────────────────────
+    def refresh(self) -> int:
+        """Apply newly committed facts and return the latest consumed sequence."""
+        with self._lock:
+            cursor = self._last_sequence
+            while True:
+                records = self._event_store.read(
+                    profile_id=self._profile_id,
+                    after_sequence=cursor,
+                    limit=5000,
+                )
+                if not records:
+                    break
+                for record in records:
+                    self._apply(record)
+                cursor = records[-1].sequence
+                if len(records) < 5000:
+                    break
+            self._last_sequence = cursor
+            return cursor
 
     def live(self, *, now: float | None = None) -> tuple[DistilledKnowledge, ...]:
-        """Every entry still considered true, newest first.
+        """Return the current projected knowledge without performing I/O.
 
         Expiry is applied on read rather than by a sweep, so a stale entry cannot be
         disclosed just because no write happened to trigger a cleanup.
         """
-        entries = self._load()
+        with self._lock:
+            entries = list(self._entries.values())
         if self._ttl > 0.0:
             cutoff = (time.time() if now is None else now) - self._ttl
-            entries = [e for e in entries if e.created_at >= cutoff]
-        return tuple(sorted(entries, key=lambda e: e.created_at, reverse=True))
+            entries = [entry for entry in entries if entry.created_at >= cutoff]
+        return tuple(sorted(entries, key=lambda entry: entry.created_at, reverse=True))
 
     def for_capability(self, capability: str) -> DistilledKnowledge | None:
-        """The live entry for one capability, if any."""
         name = str(capability or "").strip()
-        return next((e for e in self.live() if e.capability == name), None)
+        return next((entry for entry in self.live() if entry.capability == name), None)
 
     def rebind_preferences(self) -> tuple[tuple[str, str], ...]:
         """``(capability, preferred provider)`` for every live ``rebind`` entry.
@@ -255,9 +127,6 @@ def rebind_preferences(self) -> tuple[tuple[str, str], ...]:
         An ``escalate`` target names what a *person* must do and an ``absorb`` has no
         target at all, so admitting them would turn an instruction to a human into a
         selection preference.
-
-        Expiry and retraction apply, so a preference stops being read when the knowledge
-        behind it stops being true -- there is nothing to unlearn.
         """
         return tuple(
             (entry.capability, entry.target)
@@ -268,50 +137,64 @@ def rebind_preferences(self) -> tuple[tuple[str, str], ...]:
     def count(self) -> int:
         return len(self.live())
 
-    # ── persistence ───────────────────────────────────────────────────────────
-
-    def _load(self) -> list[DistilledKnowledge]:
-        if self._cache is not None:
-            return list(self._cache)
-        entries: list[DistilledKnowledge] = []
-        if self._path.exists():
-            try:
-                payload = json.loads(self._path.read_text(encoding="utf-8") or "{}")
-                for raw in payload.get("entries", []) or ():
-                    if isinstance(raw, Mapping):
-                        entries.append(DistilledKnowledge.from_dict(raw))
-            except (OSError, ValueError, TypeError):
-                # A corrupt file must not break a turn. Distilled knowledge is an
-                # improvement to context, so its absence degrades quality rather than
-                # correctness -- exactly the case for starting empty over raising.
-                logger.debug(
-                    "distilled_knowledge: unreadable store at %s", self._path, exc_info=True
-                )
-                entries = []
-        self._cache = tuple(entries)
-        return list(entries)
+    def retract(self, capability: str, *, reason: str = "") -> bool:
+        """Record retirement as a fact, then update the local read model.
 
-    def _write(self, entries: list[DistilledKnowledge]) -> None:
-        self._cache = tuple(entries)
-        payload = {
-            "version": 1,
-            "entries": [
-                {k: v for k, v in e.to_dict().items() if k in _ENTRY_FIELDS}
-                for e in entries
-            ],
-        }
-        try:
-            self._path.parent.mkdir(parents=True, exist_ok=True)
-            tmp = self._path.with_suffix(self._path.suffix + ".tmp")
-            tmp.write_text(json.dumps(payload, indent=2), encoding="utf-8")
-            tmp.replace(self._path)
-        except OSError:
-            logger.debug(
-                "distilled_knowledge: could not persist to %s", self._path, exc_info=True
+        The one retirement neither supersession nor expiry covers: no newer verdict is
+        coming precisely because there is no longer anything wrong.
+        """
+        name = str(capability or "").strip()
+        if not name:
+            return False
+        with self._lock:
+            current = self._entries.get(name)
+        if current is None:
+            return False
+        event = EvolutionEvent.create(
+            EvolutionEventType.KNOWLEDGE_RETRACTED,
+            context=EvolutionContext(
+                profile_id=self._profile_id,
+                decision_id=current.verdict_id,
+                correlation_id=current.verdict_id,
+            ),
+            payload={"capability": name, "reason": str(reason or "")},
+            producer="evolution.knowledge_projection",
+            privacy_class="profile",
+            dedup_key=f"knowledge.retracted:{name}:{current.verdict_id}",
+        )
+        inserted = bool(self._event_store.append(event))
+        self.refresh()
+        return inserted
+
+    def _apply(self, record: EvolutionEventRecord) -> None:
+        event = record.event
+        payload = event.to_dict()["payload"]
+        if event.event_type == EvolutionEventType.TEACHER_VERDICT_RECORDED:
+            # Every verdict carries mandatory knowledge, and all four actions are
+            # disclosed to the student: an ``escalate`` tells it a person must act, an
+            # ``acquire`` tells it nothing installed serves the capability, and the two
+            # cheap verdicts describe the environment. ``rebind_preferences`` narrows to
+            # rebind on read, so recording all four here loses nothing.
+            entry = DistilledKnowledge(
+                capability=str(payload.get("capability") or ""),
+                knowledge=str(payload.get("knowledge") or ""),
+                action=str(payload.get("action") or ""),
+                verdict_id=str(payload.get("verdict_id") or event.context.decision_id),
+                confidence=float(payload.get("confidence") or 0.0),
+                rationale=str(payload.get("rationale") or ""),
+                target=str(payload.get("target") or ""),
+                environment_id=str(payload.get("environment_id") or ""),
+                created_at=float(payload.get("created_at") or event.occurred_at),
             )
+            if entry.capability and entry.knowledge:
+                # Supersession, not append: the teacher's latest conclusion about a
+                # capability is its conclusion, keyed by capability.
+                self._entries[entry.capability] = entry
+        elif event.event_type == EvolutionEventType.KNOWLEDGE_RETRACTED:
+            self._entries.pop(str(payload.get("capability") or ""), None)
 
 
 __all__ = [
     "DistilledKnowledge",
-    "JsonDistilledKnowledgeStore",
+    "EvolutionDistilledKnowledgeStore",
 ]
diff --git a/src/leapflow/storage/evolution_event_store.py b/src/leapflow/storage/evolution_event_store.py
new file mode 100644
index 00000000..c7c73cda
--- /dev/null
+++ b/src/leapflow/storage/evolution_event_store.py
@@ -0,0 +1,792 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""DuckDB append-only store for causal self-evolution events.
+
+All instances share the daemon-owned ConnectionHolder.  The process lock protects
+sequence allocation and multi-row transactions across thread-local DuckDB cursors;
+callers must still respect the architectural single-writer rule.
+"""
+from __future__ import annotations
+
+import json
+import threading
+import time
+from pathlib import Path
+from typing import Any, Iterable, Mapping, Sequence, Union
+
+from leapflow.domain.event_types import EvolutionEventType
+from leapflow.domain.evolution_event import (
+    EvolutionContext,
+    EvolutionEvent,
+    EvolutionEventRecord,
+    canonical_json,
+    content_hash,
+)
+from leapflow.storage.connection import ConnectionHolder, LocalConnectionHolder
+from leapflow.storage.schema import ensure_schema
+
+
+_INSERT_SQL = """
+INSERT INTO evolution_events (
+    sequence, event_id, event_type,
+    profile_id, workspace_id, session_id, session_generation,
+    turn_id, frame_id, action_id, observation_id, requirement_id,
+    decision_id, proposal_id, artifact_id, plugin_id, version_id,
+    correlation_id, causation_id, occurred_at, producer, producer_version,
+    privacy_class, schema_version, payload_json, payload_hash, dedup_key
+) VALUES (
+    nextval('evolution_event_sequence'), ?, ?,
+    ?, ?, ?, ?,
+    ?, ?, ?, ?, ?,
+    ?, ?, ?, ?, ?,
+    ?, ?, ?, ?, ?,
+    ?, ?, ?, ?, ?
+)
+ON CONFLICT (profile_id, dedup_key) DO NOTHING
+RETURNING sequence
+"""
+
+
+class DuckDBEvolutionEventStore:
+    """Append and query immutable evolution events."""
+
+    def __init__(self, source: Union[ConnectionHolder, Path, str]) -> None:
+        self._owns_holder = isinstance(source, (str, Path))
+        if self._owns_holder:
+            source = LocalConnectionHolder(Path(source))
+        self._holder: ConnectionHolder = source
+        self._write_lock = threading.Lock()
+        ensure_schema(self._conn)
+
+    @property
+    def _conn(self) -> Any:
+        """Resolve on every call so LocalConnectionHolder preserves thread affinity."""
+        return self._holder.connection
+
+    def append(self, event: EvolutionEvent) -> bool:
+        """Append one event; return ``False`` when its dedup key already exists."""
+        with self._write_lock:
+            row = self._conn.execute(_INSERT_SQL, self._params(event)).fetchone()
+            return row is not None
+
+    def append_many(self, events: Sequence[EvolutionEvent]) -> int:
+        """Atomically append a batch, ignoring idempotent duplicates."""
+        if not events:
+            return 0
+        with self._write_lock:
+            connection = self._conn
+            connection.execute("BEGIN TRANSACTION")
+            inserted = 0
+            try:
+                for event in events:
+                    row = connection.execute(_INSERT_SQL, self._params(event)).fetchone()
+                    if row is not None:
+                        inserted += 1
+                connection.execute("COMMIT")
+            except Exception:
+                connection.execute("ROLLBACK")
+                raise
+            return inserted
+
+    def read(
+        self,
+        *,
+        profile_id: str = "",
+        session_id: str = "",
+        session_generation: int | None = None,
+        correlation_id: str = "",
+        proposal_id: str = "",
+        proposal_events_only: bool = False,
+        event_type: str = "",
+        after_sequence: int = 0,
+        through_sequence: int = 0,
+        limit: int = 500,
+    ) -> list[EvolutionEventRecord]:
+        """Read a bounded event slice with its durable causal cursor."""
+        clauses = ["sequence > ?"]
+        params: list[Any] = [max(0, int(after_sequence))]
+        if through_sequence > 0:
+            clauses.append("sequence <= ?")
+            params.append(int(through_sequence))
+        for column, value in (
+            ("profile_id", profile_id),
+            ("session_id", session_id),
+            ("correlation_id", correlation_id),
+            ("proposal_id", proposal_id),
+            ("event_type", event_type),
+        ):
+            if value:
+                clauses.append(f"{column} = ?")
+                params.append(str(value))
+        if proposal_events_only:
+            clauses.append("proposal_id <> ''")
+        if session_generation is not None:
+            clauses.append("session_generation = ?")
+            params.append(int(session_generation))
+        params.append(min(max(1, int(limit)), 5000))
+        rows = self._conn.execute(
+            f"""
+            SELECT sequence, event_id, event_type,
+                   profile_id, workspace_id, session_id, session_generation,
+                   turn_id, frame_id, action_id, observation_id, requirement_id,
+                   decision_id, proposal_id, artifact_id, plugin_id, version_id,
+                   correlation_id, causation_id, occurred_at, producer,
+                   producer_version, privacy_class, schema_version, payload_json,
+                   payload_hash, dedup_key
+            FROM evolution_events
+            WHERE {' AND '.join(clauses)}
+            ORDER BY sequence ASC
+            LIMIT ?
+            """,
+            params,
+        ).fetchall()
+        return [self._from_row(row) for row in rows]
+
+    def latest_sequence(self, *, profile_id: str = "", session_id: str = "") -> int:
+        clauses = ["1=1"]
+        params: list[Any] = []
+        if profile_id:
+            clauses.append("profile_id = ?")
+            params.append(str(profile_id))
+        if session_id:
+            clauses.append("session_id = ?")
+            params.append(str(session_id))
+        row = self._conn.execute(
+            f"SELECT COALESCE(MAX(sequence), 0) FROM evolution_events WHERE {' AND '.join(clauses)}",
+            params,
+        ).fetchone()
+        return int(row[0] if row else 0)
+
+    def latest_evidence_sequence(
+        self,
+        *,
+        profile_id: str,
+        session_id: str,
+        session_generation: int | None = None,
+    ) -> int:
+        """Return the latest hot-path input cursor eligible for teacher grading."""
+        event_types = (
+            EvolutionEventType.ACTION_STARTED,
+            EvolutionEventType.ACTION_COMPLETED,
+            EvolutionEventType.ACTION_FAILED,
+            EvolutionEventType.ENVIRONMENT_OBSERVED,
+        )
+        placeholders = ", ".join("?" for _ in event_types)
+        generation_clause = ""
+        params: list[Any] = [str(profile_id), str(session_id), *event_types]
+        if session_generation is not None:
+            generation_clause = " AND session_generation=?"
+            params.append(int(session_generation))
+        row = self._conn.execute(
+            f"""
+            SELECT COALESCE(MAX(sequence), 0)
+            FROM evolution_events
+            WHERE profile_id=? AND session_id=? AND event_type IN ({placeholders})
+                  {generation_clause}
+            """,
+            params,
+        ).fetchone()
+        return int(row[0] if row else 0)
+
+    def evidence_sessions(self, *, profile_id: str = "") -> list[dict[str, Any]]:
+        """List session heads that contain finalizable hot-path evidence."""
+        event_types = (
+            EvolutionEventType.ACTION_STARTED,
+            EvolutionEventType.ACTION_COMPLETED,
+            EvolutionEventType.ACTION_FAILED,
+            EvolutionEventType.ENVIRONMENT_OBSERVED,
+        )
+        placeholders = ", ".join("?" for _ in event_types)
+        clauses = ["session_id <> ''", f"event_type IN ({placeholders})"]
+        params: list[Any] = list(event_types)
+        if profile_id:
+            clauses.append("profile_id = ?")
+            params.append(str(profile_id))
+        rows = self._conn.execute(
+            f"""
+            SELECT profile_id, workspace_id, session_id, session_generation,
+                   MAX(sequence) AS through_sequence
+            FROM evolution_events
+            WHERE {' AND '.join(clauses)}
+            GROUP BY profile_id, workspace_id, session_id, session_generation
+            ORDER BY through_sequence ASC
+            """,
+            params,
+        ).fetchall()
+        keys = (
+            "profile_id",
+            "workspace_id",
+            "session_id",
+            "session_generation",
+            "through_sequence",
+        )
+        return [dict(zip(keys, row)) for row in rows]
+
+    def count(self, *, profile_id: str = "", event_type: str = "") -> int:
+        clauses = ["1=1"]
+        params: list[Any] = []
+        if profile_id:
+            clauses.append("profile_id = ?")
+            params.append(str(profile_id))
+        if event_type:
+            clauses.append("event_type = ?")
+            params.append(str(event_type))
+        row = self._conn.execute(
+            f"SELECT COUNT(*) FROM evolution_events WHERE {' AND '.join(clauses)}",
+            params,
+        ).fetchone()
+        return int(row[0] if row else 0)
+
+    def finalize_session(
+        self,
+        *,
+        profile_id: str,
+        workspace_id: str,
+        session_id: str,
+        session_generation: int,
+        from_sequence: int,
+        through_sequence: int,
+        reason: str,
+        goal: str = "",
+        model: str = "",
+    ) -> tuple[str, str]:
+        """Atomically finalize one evidence slice and enqueue its teacher job.
+
+        Returns ``(episode_id, job_id)``. Repeating the same finalization is
+        idempotent because both identities derive from the immutable sequence range.
+        """
+        if not session_id:
+            raise ValueError("session_id is required")
+        if through_sequence <= from_sequence:
+            return "", ""
+        identity = {
+            "profile_id": profile_id,
+            "workspace_id": workspace_id,
+            "session_id": session_id,
+            "session_generation": int(session_generation),
+            "from_sequence": int(from_sequence),
+            "through_sequence": int(through_sequence),
+        }
+        digest = content_hash(identity)
+        episode_id = f"episode-{digest[:24]}"
+        job_id = f"teacher-{digest[:24]}"
+        context = EvolutionContext(
+            profile_id=profile_id,
+            workspace_id=workspace_id,
+            session_id=session_id,
+            session_generation=int(session_generation),
+            correlation_id=episode_id,
+        )
+        finalized = EvolutionEvent.create(
+            EvolutionEventType.SESSION_FINALIZED,
+            context=context,
+            payload={
+                "episode_id": episode_id,
+                "from_sequence": int(from_sequence),
+                "through_sequence": int(through_sequence),
+                "reason": str(reason),
+                "goal": str(goal),
+            },
+            producer="session.finalizer",
+            dedup_key=f"session.finalized:{episode_id}",
+        )
+        queued = EvolutionEvent.create(
+            EvolutionEventType.TEACHER_JOB_QUEUED,
+            context=context.with_ids(causation_id=finalized.event_id),
+            payload={
+                "episode_id": episode_id,
+                "job_id": job_id,
+                "model": str(model),
+                "from_sequence": int(from_sequence),
+                "through_sequence": int(through_sequence),
+            },
+            producer="session.finalizer",
+            dedup_key=f"teacher.job_queued:{job_id}",
+        )
+        now = time.time()
+        with self._write_lock:
+            connection = self._conn
+            connection.execute("BEGIN TRANSACTION")
+            try:
+                connection.execute(_INSERT_SQL, self._params(finalized)).fetchone()
+                connection.execute(_INSERT_SQL, self._params(queued)).fetchone()
+                connection.execute(
+                    """
+                    INSERT INTO evolution_teacher_jobs (
+                        job_id, profile_id, workspace_id, session_id,
+                        session_generation, episode_id, from_sequence,
+                        through_sequence, reason, goal, status, model,
+                        created_at, updated_at
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'PENDING', ?, ?, ?)
+                    ON CONFLICT (profile_id, episode_id) DO NOTHING
+                    """,
+                    [
+                        job_id,
+                        profile_id,
+                        workspace_id,
+                        session_id,
+                        int(session_generation),
+                        episode_id,
+                        int(from_sequence),
+                        int(through_sequence),
+                        str(reason),
+                        str(goal),
+                        str(model),
+                        now,
+                        now,
+                    ],
+                )
+                connection.execute("COMMIT")
+            except Exception:
+                connection.execute("ROLLBACK")
+                raise
+        return episode_id, job_id
+
+    def claim_teacher_job(
+        self,
+        *,
+        lease_owner: str,
+        profile_id: str = "",
+        lease_seconds: float = 120.0,
+        now: float | None = None,
+    ) -> dict[str, Any] | None:
+        """Lease the oldest due teacher job for one worker."""
+        instant = float(now if now is not None else time.time())
+        with self._write_lock:
+            connection = self._conn
+            connection.execute("BEGIN TRANSACTION")
+            try:
+                clauses = [
+                    "((status IN ('PENDING', 'FAILED_RETRYABLE') AND next_attempt_at <= ?) "
+                    "OR (status = 'RUNNING' AND lease_until <= ?))",
+                ]
+                params: list[Any] = [instant, instant]
+                if profile_id:
+                    clauses.append("profile_id = ?")
+                    params.append(str(profile_id))
+                row = connection.execute(
+                    f"""
+                    SELECT job_id, profile_id, workspace_id, session_id,
+                           session_generation, episode_id, from_sequence,
+                           through_sequence, reason, goal, attempts, model,
+                           prompt_hash, created_at
+                    FROM evolution_teacher_jobs
+                    WHERE {' AND '.join(clauses)}
+                    ORDER BY created_at ASC
+                    LIMIT 1
+                    """,
+                    params,
+                ).fetchone()
+                if row is None:
+                    connection.execute("COMMIT")
+                    return None
+                lease_until = instant + max(1.0, float(lease_seconds))
+                connection.execute(
+                    """
+                    UPDATE evolution_teacher_jobs
+                    SET status='RUNNING', lease_owner=?, lease_until=?,
+                        attempts=attempts+1, updated_at=?
+                    WHERE job_id=?
+                    """,
+                    [str(lease_owner), lease_until, instant, row[0]],
+                )
+                connection.execute("COMMIT")
+            except Exception:
+                connection.execute("ROLLBACK")
+                raise
+        keys = (
+            "job_id",
+            "profile_id",
+            "workspace_id",
+            "session_id",
+            "session_generation",
+            "episode_id",
+            "from_sequence",
+            "through_sequence",
+            "reason",
+            "goal",
+            "attempts",
+            "model",
+            "prompt_hash",
+            "created_at",
+        )
+        claimed = dict(zip(keys, row))
+        claimed["attempts"] = int(claimed["attempts"] or 0) + 1
+        claimed["session_generation"] = int(claimed["session_generation"] or 0)
+        claimed["from_sequence"] = int(claimed["from_sequence"] or 0)
+        claimed["through_sequence"] = int(claimed["through_sequence"] or 0)
+        claimed["lease_owner"] = str(lease_owner)
+        claimed["lease_until"] = lease_until
+        return claimed
+
+    def renew_teacher_job(
+        self,
+        job_id: str,
+        *,
+        lease_owner: str,
+        lease_seconds: float,
+        now: float | None = None,
+    ) -> bool:
+        """Extend a running job lease only when the caller still owns it."""
+        instant = float(now if now is not None else time.time())
+        with self._write_lock:
+            row = self._conn.execute(
+                """
+                UPDATE evolution_teacher_jobs
+                SET lease_until=?, updated_at=?
+                WHERE job_id=? AND status='RUNNING' AND lease_owner=?
+                RETURNING job_id
+                """,
+                [
+                    instant + max(1.0, float(lease_seconds)),
+                    instant,
+                    str(job_id),
+                    str(lease_owner),
+                ],
+            ).fetchone()
+        return row is not None
+
+    def complete_teacher_job(
+        self,
+        job_id: str,
+        *,
+        lease_owner: str,
+        events: Sequence[EvolutionEvent] = (),
+        prompt_hash: str = "",
+        result_artifact_id: str = "",
+    ) -> bool:
+        """Append teacher facts and complete a job only for its current lease owner."""
+        with self._write_lock:
+            connection = self._conn
+            connection.execute("BEGIN TRANSACTION")
+            try:
+                owned = connection.execute(
+                    """
+                    SELECT 1 FROM evolution_teacher_jobs
+                    WHERE job_id=? AND status='RUNNING' AND lease_owner=?
+                    """,
+                    [str(job_id), str(lease_owner)],
+                ).fetchone()
+                if owned is None:
+                    connection.execute("ROLLBACK")
+                    return False
+                for event in events:
+                    connection.execute(_INSERT_SQL, self._params(event)).fetchone()
+                updated = connection.execute(
+                    """
+                    UPDATE evolution_teacher_jobs
+                    SET status='COMPLETED', lease_owner='', lease_until=0,
+                        prompt_hash=?, result_artifact_id=?, completed_at=?,
+                        updated_at=?, error=''
+                    WHERE job_id=? AND status='RUNNING' AND lease_owner=?
+                    RETURNING job_id
+                    """,
+                    [
+                        str(prompt_hash),
+                        str(result_artifact_id),
+                        time.time(),
+                        time.time(),
+                        str(job_id),
+                        str(lease_owner),
+                    ],
+                ).fetchone()
+                connection.execute("COMMIT")
+                return updated is not None
+            except Exception:
+                connection.execute("ROLLBACK")
+                raise
+
+    def fail_teacher_job(
+        self,
+        job_id: str,
+        error: str,
+        *,
+        lease_owner: str,
+        retryable: bool,
+        retry_after_s: float = 5.0,
+        events: Sequence[EvolutionEvent] = (),
+    ) -> bool:
+        """Record a teacher failure only while the caller owns the lease."""
+        now = time.time()
+        with self._write_lock:
+            connection = self._conn
+            connection.execute("BEGIN TRANSACTION")
+            try:
+                owned = connection.execute(
+                    """
+                    SELECT 1 FROM evolution_teacher_jobs
+                    WHERE job_id=? AND status='RUNNING' AND lease_owner=?
+                    """,
+                    [str(job_id), str(lease_owner)],
+                ).fetchone()
+                if owned is None:
+                    connection.execute("ROLLBACK")
+                    return False
+                for event in events:
+                    connection.execute(_INSERT_SQL, self._params(event)).fetchone()
+                row = connection.execute(
+                    """
+                    UPDATE evolution_teacher_jobs
+                    SET status=?, lease_owner='', lease_until=0, next_attempt_at=?,
+                        updated_at=?, error=?
+                    WHERE job_id=? AND status='RUNNING' AND lease_owner=?
+                    RETURNING job_id
+                    """,
+                    [
+                        "FAILED_RETRYABLE" if retryable else "FAILED_FINAL",
+                        now + max(0.0, float(retry_after_s)) if retryable else 0.0,
+                        now,
+                        str(error)[:2000],
+                        str(job_id),
+                        str(lease_owner),
+                    ],
+                ).fetchone()
+                connection.execute("COMMIT")
+                return row is not None
+            except Exception:
+                connection.execute("ROLLBACK")
+                raise
+
+    def teacher_job(self, job_id: str) -> dict[str, Any] | None:
+        row = self._conn.execute(
+            """
+            SELECT job_id, profile_id, workspace_id, session_id,
+                   session_generation, episode_id, from_sequence, through_sequence,
+                   reason, goal, status, lease_owner, lease_until, attempts, model,
+                   prompt_hash, result_artifact_id, next_attempt_at, created_at,
+                   updated_at, completed_at, error
+            FROM evolution_teacher_jobs WHERE job_id=?
+            """,
+            [str(job_id)],
+        ).fetchone()
+        if row is None:
+            return None
+        keys = (
+            "job_id", "profile_id", "workspace_id", "session_id",
+            "session_generation", "episode_id", "from_sequence", "through_sequence",
+            "reason", "goal", "status", "lease_owner", "lease_until", "attempts",
+            "model", "prompt_hash", "result_artifact_id", "next_attempt_at",
+            "created_at", "updated_at", "completed_at", "error",
+        )
+        return dict(zip(keys, row))
+
+    def load_projection(
+        self,
+        *,
+        projection_name: str,
+        profile_id: str,
+        scope_key: str,
+    ) -> tuple[int, dict[str, Any]] | None:
+        row = self._conn.execute(
+            """
+            SELECT last_sequence, state_json
+            FROM evolution_projections
+            WHERE projection_name=? AND profile_id=? AND scope_key=?
+            """,
+            [str(projection_name), str(profile_id), str(scope_key)],
+        ).fetchone()
+        if row is None:
+            return None
+        try:
+            state = json.loads(row[1] or "{}")
+        except (json.JSONDecodeError, TypeError):
+            return None
+        return int(row[0] or 0), state if isinstance(state, dict) else {}
+
+    def save_projection(
+        self,
+        *,
+        projection_name: str,
+        profile_id: str,
+        scope_key: str,
+        last_sequence: int,
+        state: dict[str, Any],
+    ) -> None:
+        with self._write_lock:
+            self._conn.execute(
+                """
+                INSERT INTO evolution_projections (
+                    projection_name, profile_id, scope_key, last_sequence,
+                    state_json, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?)
+                ON CONFLICT (projection_name, profile_id, scope_key) DO UPDATE SET
+                    last_sequence=excluded.last_sequence,
+                    state_json=excluded.state_json,
+                    updated_at=excluded.updated_at
+                """,
+                [
+                    str(projection_name),
+                    str(profile_id),
+                    str(scope_key),
+                    int(last_sequence),
+                    canonical_json(state),
+                    time.time(),
+                ],
+            )
+
+    def delete_projection(
+        self,
+        *,
+        projection_name: str,
+        profile_id: str,
+        scope_key: str,
+    ) -> None:
+        with self._write_lock:
+            self._conn.execute(
+                """
+                DELETE FROM evolution_projections
+                WHERE projection_name=? AND profile_id=? AND scope_key=?
+                """,
+                [str(projection_name), str(profile_id), str(scope_key)],
+            )
+
+    def last_finalized_sequence(
+        self,
+        *,
+        profile_id: str,
+        session_id: str,
+        session_generation: int | None = None,
+    ) -> int:
+        """Return the highest evidence cursor finalized for one session generation."""
+        records = self.read(
+            profile_id=profile_id,
+            session_id=session_id,
+            session_generation=session_generation,
+            event_type=EvolutionEventType.SESSION_FINALIZED,
+            limit=5000,
+        )
+        return max(
+            (
+                int(record.event.payload.get("through_sequence") or 0)
+                for record in records
+            ),
+            default=0,
+        )
+
+    def close(self) -> None:
+        if self._owns_holder:
+            self._holder.close()
+
+    @staticmethod
+    def _params(event: EvolutionEvent) -> list[Any]:
+        context = event.context
+        return [
+            event.event_id,
+            event.event_type,
+            context.profile_id,
+            context.workspace_id,
+            context.session_id,
+            context.session_generation,
+            context.turn_id,
+            context.frame_id,
+            context.action_id,
+            context.observation_id,
+            context.requirement_id,
+            context.decision_id,
+            context.proposal_id,
+            context.artifact_id,
+            context.plugin_id,
+            context.version_id,
+            context.correlation_id,
+            context.causation_id,
+            event.occurred_at,
+            event.producer,
+            event.producer_version,
+            event.privacy_class,
+            event.schema_version,
+            canonical_json(dict(event.payload)),
+            event.payload_hash,
+            event.dedup_key,
+        ]
+
+    @staticmethod
+    def _from_row(row: Sequence[Any]) -> EvolutionEventRecord:
+        context = EvolutionContext(
+            profile_id=str(row[3] or ""),
+            workspace_id=str(row[4] or ""),
+            session_id=str(row[5] or ""),
+            session_generation=int(row[6] or 0),
+            turn_id=str(row[7] or ""),
+            frame_id=str(row[8] or ""),
+            action_id=str(row[9] or ""),
+            observation_id=str(row[10] or ""),
+            requirement_id=str(row[11] or ""),
+            decision_id=str(row[12] or ""),
+            proposal_id=str(row[13] or ""),
+            artifact_id=str(row[14] or ""),
+            plugin_id=str(row[15] or ""),
+            version_id=str(row[16] or ""),
+            correlation_id=str(row[17] or ""),
+            causation_id=str(row[18] or ""),
+        )
+        try:
+            payload = json.loads(row[24] or "{}")
+        except (json.JSONDecodeError, TypeError):
+            payload = {}
+        return EvolutionEventRecord(
+            sequence=int(row[0]),
+            event=EvolutionEvent(
+                event_id=str(row[1] or ""),
+                event_type=str(row[2] or ""),
+                context=context,
+                payload=payload if isinstance(payload, dict) else {},
+                occurred_at=float(row[19] or 0.0),
+                producer=str(row[20] or ""),
+                producer_version=str(row[21] or ""),
+                privacy_class=str(row[22] or "system"),
+                schema_version=int(row[23] or 1),
+                payload_hash=str(row[25] or ""),
+                dedup_key=str(row[26] or ""),
+            ),
+        )
+
+
+class EvolutionTraceEventStore:
+    """Adapt framework traces onto the append-only evolution event stream."""
+
+    def __init__(self, store: DuckDBEvolutionEventStore, *, profile_id: str) -> None:
+        self._store = store
+        self._profile_id = str(profile_id)
+
+    def append(self, traces: Iterable[Mapping[str, Any]]) -> int:
+        events: list[EvolutionEvent] = []
+        for trace in traces:
+            payload = dict(trace)
+            trace_id = str(payload.get("trace_id") or content_hash(payload))
+            correlation = dict(payload.get("correlation") or {})
+            context = EvolutionContext(
+                profile_id=self._profile_id,
+                proposal_id=str(correlation.get("proposal_id") or ""),
+                plugin_id=str(correlation.get("plugin_id") or ""),
+                correlation_id=str(
+                    correlation.get("episode_id")
+                    or correlation.get("proposal_id")
+                    or trace_id
+                ),
+            )
+            events.append(
+                EvolutionEvent.create(
+                    EvolutionEventType.FRAMEWORK_TRACE_RECORDED,
+                    context=context,
+                    payload=payload,
+                    producer="framework.evolution_tap",
+                    privacy_class="profile",
+                    occurred_at=float(payload.get("ts") or time.time()),
+                    dedup_key=f"framework.trace_recorded:{trace_id}",
+                )
+            )
+        return self._store.append_many(events)
+
+    def list_traces(self, *, limit: int = 200) -> list[dict[str, Any]]:
+        records = self._store.read(
+            profile_id=self._profile_id,
+            event_type=EvolutionEventType.FRAMEWORK_TRACE_RECORDED,
+            limit=5000,
+        )
+        rows = [dict(record.event.to_dict()["payload"]) for record in reversed(records)]
+        return rows if limit <= 0 else rows[:limit]
+
+    def count(self) -> int:
+        return len(self.list_traces(limit=0))
+
+
+__all__ = ["DuckDBEvolutionEventStore", "EvolutionTraceEventStore"]
diff --git a/src/leapflow/storage/evolution_store.py b/src/leapflow/storage/evolution_store.py
index a06d5125..3282fd3e 100644
--- a/src/leapflow/storage/evolution_store.py
+++ b/src/leapflow/storage/evolution_store.py
@@ -4,8 +4,8 @@
 Design:
 - Write-behind: buffer episodes in-memory, flush to DuckDB periodically or on shutdown
 - Read-through: on initialize, load recent episodes from DuckDB into in-memory provider
-- Schema is simple: one table with JSON-serialized episode data
-- Idempotent schema creation (no migration chains)
+- Schema is managed by the shared ordered migration/bootstrap layer
+- Episode payloads remain JSON-serialized inside typed skill tables
 - Write-retry with jitter for concurrent access
 
 This module does NOT replace EvolutionMemoryProvider — it augments it with persistence.
@@ -20,6 +20,7 @@
 from typing import Any, Dict, List, Optional, Union
 
 from leapflow.storage.connection import ConnectionHolder, LocalConnectionHolder
+from leapflow.storage.schema import ensure_schema
 from leapflow.storage.write_buffer import execute_with_retry
 
 logger = logging.getLogger(__name__)
@@ -37,7 +38,7 @@ def __init__(self, source: Union[ConnectionHolder, Path, str]) -> None:
             source = LocalConnectionHolder(Path(source))
         self._holder = source
         self._db_path = str(self._holder.db_path)
-        self._initialize_schema()
+        ensure_schema(self._conn)
 
     @property
     def _conn(self) -> Any:
@@ -50,33 +51,6 @@ def _conn(self) -> Any:
         """
         return self._holder.connection
 
-    def _initialize_schema(self) -> None:
-        self._conn.execute("""
-            CREATE TABLE IF NOT EXISTS skill_episodes (
-                episode_id VARCHAR PRIMARY KEY,
-                skill_name VARCHAR NOT NULL,
-                actions_json VARCHAR DEFAULT '[]',
-                outcome VARCHAR DEFAULT '',
-                reward DOUBLE DEFAULT 0.0,
-                context_json VARCHAR DEFAULT '{}',
-                created_at DOUBLE DEFAULT 0.0
-            )
-        """)
-        self._conn.execute("""
-            CREATE INDEX IF NOT EXISTS idx_episodes_skill
-            ON skill_episodes (skill_name, created_at DESC)
-        """)
-        self._conn.execute("""
-            CREATE TABLE IF NOT EXISTS skill_patterns (
-                pattern_id VARCHAR PRIMARY KEY,
-                skill_name VARCHAR NOT NULL,
-                pattern_json VARCHAR DEFAULT '{}',
-                confidence DOUBLE DEFAULT 0.0,
-                episode_count INTEGER DEFAULT 0,
-                created_at DOUBLE DEFAULT 0.0
-            )
-        """)
-
     def _execute_write(self, sql: str, params: Any = None) -> None:
         execute_with_retry(self._conn, sql, params)
 
diff --git a/src/leapflow/storage/evolution_trace_store.py b/src/leapflow/storage/evolution_trace_store.py
deleted file mode 100644
index c2396fe3..00000000
--- a/src/leapflow/storage/evolution_trace_store.py
+++ /dev/null
@@ -1,121 +0,0 @@
-# Copyright (c) Alibaba, Inc. and its affiliates.
-"""Durable store for framework-evolution traces.
-
-⚠️ Not to be confused with :mod:`leapflow.storage.evolution_store`, whose
-``DuckDBEvolutionStore.save_episode`` persists *skill learning* episodes. Two
-different meanings of "evolution" live in this package, and both use the word
-"episode": that one means "the agent practised a skill", this one means "the
-framework changed itself". Named for ``EvolutionTrace`` rather than for evolution
-in general precisely so the two cannot be mistaken for each other at a call site.
-
-**JSON rather than DuckDB, deliberately.** The roadmap called for a DuckDB table;
-this is a considered deviation:
-
-* *Volume does not justify it.* Traces are written when the framework mutates --
-  a plugin installs, a trust level moves, the world model proposes. Those are rare
-  by nature, not per-turn. A table sized for time-series volume would carry
-  connection-holder, schema and retry machinery for a file that gains a handful of
-  rows a day.
-* *It matches its neighbours.* The ledger already reads
-  ``capability_plans.json``, ``capability_observations.json`` and
-  ``proposal_queue.json`` from this same directory. One idiom for the causal
-  history means one failure mode, not two.
-* *Inspectable and additively versioned*, for the same reason the sibling
-  capability stores chose JSON: an older record stays readable after the schema
-  grows.
-
-Retention is a hard cap on record count rather than an age, because what matters
-is that the newest traces are always present -- an operator reading the board after
-an incident needs the last mutations, not a complete history.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-from pathlib import Path
-from typing import Any, Iterable, Mapping
-
-logger = logging.getLogger(__name__)
-
-#: Keep the newest N traces. Generous relative to the write rate, and bounded so
-#: the file cannot grow without limit on a long-lived profile.
-DEFAULT_MAX_TRACES = 2000
-
-
-class JsonEvolutionTraceStore:
-    """Append-only, count-bounded JSON store for evolution traces.
-
-    Every method degrades rather than raising: this store backs a transparency
-    panel, and losing the panel is preferable to failing the operation a trace was
-    describing. A corrupt or unreadable file reads as empty and is overwritten by
-    the next append, which is the same choice the sibling capability stores make.
-    """
-
-    def __init__(self, path: Path, *, max_traces: int = DEFAULT_MAX_TRACES) -> None:
-        self._path = Path(path)
-        self._max = max(1, int(max_traces))
-
-    @property
-    def path(self) -> Path:
-        return self._path
-
-    def append(self, traces: Iterable[Mapping[str, Any]]) -> int:
-        """Append serialised traces, trimming to the newest ``max_traces``.
-
-        Takes a batch because the sink buffers: one file rewrite per flush rather
-        than one per trace keeps the cost off whatever produced them.
-        """
-        incoming = [dict(trace) for trace in traces if isinstance(trace, Mapping)]
-        if not incoming:
-            return 0
-        try:
-            payload = self._load()
-            records = payload["traces"]
-            records.extend(incoming)
-            # Order by time so a trim keeps the newest regardless of arrival order.
-            records.sort(key=lambda item: float(item.get("ts") or 0.0))
-            if len(records) > self._max:
-                del records[: len(records) - self._max]
-            self._write(payload)
-            return len(incoming)
-        except (OSError, TypeError, ValueError):
-            logger.debug("evolution trace store: append failed", exc_info=True)
-            return 0
-
-    def list_traces(self, *, limit: int = 200) -> list[dict[str, Any]]:
-        """Return newest traces first."""
-        records = self._load()["traces"]
-        records.sort(key=lambda item: float(item.get("ts") or 0.0), reverse=True)
-        return records if limit <= 0 else records[:limit]
-
-    def count(self) -> int:
-        return len(self._load()["traces"])
-
-    # ── file access ───────────────────────────────────────────────────────
-
-    def _load(self) -> dict[str, Any]:
-        if not self._path.exists():
-            return {"version": 1, "traces": []}
-        try:
-            data = json.loads(self._path.read_text(encoding="utf-8"))
-            if isinstance(data, Mapping):
-                traces = data.get("traces")
-                if isinstance(traces, list):
-                    return {
-                        "version": int(data.get("version") or 1),
-                        "traces": [dict(t) for t in traces if isinstance(t, Mapping)],
-                    }
-        except (OSError, json.JSONDecodeError, TypeError, ValueError):
-            logger.debug("evolution trace store: unreadable, treating as empty", exc_info=True)
-        return {"version": 1, "traces": []}
-
-    def _write(self, payload: Mapping[str, Any]) -> None:
-        self._path.parent.mkdir(parents=True, exist_ok=True)
-        self._path.write_text(
-            json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True),
-            encoding="utf-8",
-        )
-
-
-__all__ = ["DEFAULT_MAX_TRACES", "JsonEvolutionTraceStore"]
diff --git a/src/leapflow/storage/plugin_outcome_store.py b/src/leapflow/storage/plugin_outcome_store.py
index a78e3f07..1f5c7c1a 100644
--- a/src/leapflow/storage/plugin_outcome_store.py
+++ b/src/leapflow/storage/plugin_outcome_store.py
@@ -1,24 +1,22 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
-"""Profile-scoped audit store for adaptive plugin execution outcomes."""
+"""Event-sourced audit store for adaptive plugin execution outcomes."""
 
 from __future__ import annotations
 
-import json
 import time
 import uuid
-from pathlib import Path
 from typing import Any, Mapping
 
+from leapflow.domain.event_types import EvolutionEventType
+from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent
 
-class JsonPluginOutcomeStore:
-    """Append-only outcome timeline used by lifecycle governance."""
 
-    def __init__(self, path: Path) -> None:
-        self._path = Path(path)
+class EvolutionPluginOutcomeStore:
+    """Plugin outcome projection backed by the append-only evolution event stream."""
 
-    @property
-    def path(self) -> Path:
-        return self._path
+    def __init__(self, event_store: Any, *, profile_id: str) -> None:
+        self._event_store = event_store
+        self._profile_id = str(profile_id)
 
     def add_outcome(
         self,
@@ -33,10 +31,11 @@ def add_outcome(
         side_effect_state: str = "none",
         metadata: Mapping[str, Any] | None = None,
     ) -> dict[str, Any]:
-        """Append one execution outcome summary."""
+        outcome_id = f"out-{uuid.uuid4().hex}"
+        created_at = time.time()
         record = {
-            "outcome_id": f"out-{uuid.uuid4().hex}",
-            "created_at": time.time(),
+            "outcome_id": outcome_id,
+            "created_at": created_at,
             "plugin_id": str(plugin_id),
             "tool_name": str(tool_name),
             "ok": bool(ok),
@@ -47,21 +46,38 @@ def add_outcome(
             "side_effect_state": str(side_effect_state or "none"),
             "metadata": dict(metadata or {}),
         }
-        payload = self._load_payload()
-        payload.setdefault("outcomes", []).append(record)
-        self._write_payload(payload)
+        event = EvolutionEvent.create(
+            EvolutionEventType.PLUGIN_OUTCOME_RECORDED,
+            context=EvolutionContext(
+                profile_id=self._profile_id,
+                requirement_id=record["requirement_id"],
+                plugin_id=record["plugin_id"],
+                correlation_id=record["plan_id"] or outcome_id,
+            ),
+            payload=record,
+            producer="plugin.lifecycle_governor",
+            privacy_class="profile",
+            occurred_at=created_at,
+            dedup_key=f"plugin.outcome_recorded:{outcome_id}",
+        )
+        if not self._event_store.append(event):
+            raise RuntimeError(f"duplicate plugin outcome: {outcome_id}")
         return record
 
     def list_outcomes(self, *, plugin_id: str = "", limit: int = 100) -> list[dict[str, Any]]:
-        payload = self._load_payload()
-        records = [dict(item) for item in payload.get("outcomes", []) if isinstance(item, Mapping)]
-        if plugin_id:
-            records = [record for record in records if record.get("plugin_id") == plugin_id]
-        records.sort(key=lambda item: float(item.get("created_at") or 0.0), reverse=True)
-        return records if limit <= 0 else records[:limit]
+        records = self._event_store.read(
+            profile_id=self._profile_id,
+            event_type=EvolutionEventType.PLUGIN_OUTCOME_RECORDED,
+            limit=5000,
+        )
+        outcomes = [
+            dict(record.event.to_dict()["payload"])
+            for record in reversed(records)
+            if not plugin_id or record.event.context.plugin_id == plugin_id
+        ]
+        return outcomes if limit <= 0 else outcomes[:limit]
 
     def failure_streak(self, plugin_id: str) -> int:
-        """Return consecutive latest failures for a plugin."""
         streak = 0
         for record in self.list_outcomes(plugin_id=plugin_id, limit=0):
             if record.get("ok") is True:
@@ -69,23 +85,5 @@ def failure_streak(self, plugin_id: str) -> int:
             streak += 1
         return streak
 
-    def _load_payload(self) -> dict[str, Any]:
-        if not self._path.exists():
-            return {"version": 1, "outcomes": []}
-        try:
-            data = json.loads(self._path.read_text(encoding="utf-8"))
-            if isinstance(data, Mapping) and isinstance(data.get("outcomes"), list):
-                return {"version": int(data.get("version") or 1), "outcomes": data["outcomes"]}
-        except (OSError, json.JSONDecodeError, TypeError, ValueError):
-            return {"version": 1, "outcomes": []}
-        return {"version": 1, "outcomes": []}
-
-    def _write_payload(self, payload: Mapping[str, Any]) -> None:
-        self._path.parent.mkdir(parents=True, exist_ok=True)
-        self._path.write_text(
-            json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True),
-            encoding="utf-8",
-        )
-
 
-__all__ = ["JsonPluginOutcomeStore"]
+__all__ = ["EvolutionPluginOutcomeStore"]
diff --git a/src/leapflow/storage/plugin_proposal_store.py b/src/leapflow/storage/plugin_proposal_store.py
deleted file mode 100644
index e0265b97..00000000
--- a/src/leapflow/storage/plugin_proposal_store.py
+++ /dev/null
@@ -1,126 +0,0 @@
-# Copyright (c) Alibaba, Inc. and its affiliates.
-"""Profile-scoped JSON store for plugin proposals.
-
-The store intentionally uses the path supplied by ProfileLayout
-(``profile_layout.plugin_proposals_path``). It does not infer profile roots or
-assemble managed paths itself.
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any
-
-from leapflow.domain.plugin_proposal import (
-    BehaviorTestCase,
-    GapEvidence,
-    PluginProposal,
-    ProposalStatus,
-    ProposedToolSpec,
-)
-
-
-class JsonPluginProposalStore:
-    """Durable profile-local store for reviewable plugin proposals."""
-
-    def __init__(self, path: Path) -> None:
-        self._path = Path(path)
-
-    @property
-    def path(self) -> Path:
-        return self._path
-
-    def list(self) -> list[PluginProposal]:
-        return [self._proposal_from_dict(item) for item in self._load()]
-
-    def get(self, proposal_id: str) -> PluginProposal | None:
-        target = str(proposal_id or "")
-        for proposal in self.list():
-            if proposal.proposal_id == target:
-                return proposal
-        return None
-
-    def save(self, proposal: PluginProposal) -> PluginProposal:
-        items = [item for item in self._load() if item.get("proposal_id") != proposal.proposal_id]
-        items.append(proposal.to_dict())
-        self._save(items)
-        return proposal
-
-    def update_status(self, proposal_id: str, status: ProposalStatus) -> PluginProposal | None:
-        proposal = self.get(proposal_id)
-        if proposal is None:
-            return None
-        updated = PluginProposal(
-            proposal_id=proposal.proposal_id,
-            plugin_id=proposal.plugin_id,
-            capability_summary=proposal.capability_summary,
-            gap_type=proposal.gap_type,
-            risk_level=proposal.risk_level,
-            status=status,
-            evidence=proposal.evidence,
-            proposed_tools=proposal.proposed_tools,
-            test_cases=proposal.test_cases,
-            created_at=proposal.created_at,
-        )
-        return self.save(updated)
-
-    def _load(self) -> list[dict[str, Any]]:
-        try:
-            raw = json.loads(self._path.read_text(encoding="utf-8"))
-        except FileNotFoundError:
-            return []
-        except (json.JSONDecodeError, OSError, ValueError):
-            return []
-        if not isinstance(raw, list):
-            return []
-        return [item for item in raw if isinstance(item, dict)]
-
-    def _save(self, items: list[dict[str, Any]]) -> None:
-        self._path.parent.mkdir(parents=True, exist_ok=True)
-        self._path.write_text(json.dumps(items, ensure_ascii=False, indent=2), encoding="utf-8")
-
-    @staticmethod
-    def _proposal_from_dict(raw: dict[str, Any]) -> PluginProposal:
-        evidence = tuple(
-            GapEvidence.create(
-                str(item.get("evidence_type") or "unknown"),
-                str(item.get("summary") or ""),
-                confidence=float(item.get("confidence") or 0.0),
-                metadata=dict(item.get("metadata") or {}),
-            )
-            for item in raw.get("evidence", [])
-            if isinstance(item, dict)
-        )
-        tools = tuple(
-            ProposedToolSpec(
-                name=str(item.get("name") or "generated_tool"),
-                description=str(item.get("description") or ""),
-                risk_level=str(item.get("risk_level") or "read_only"),  # type: ignore[arg-type]
-                mutates_state=bool(item.get("mutates_state", False)),
-            )
-            for item in raw.get("proposed_tools", [])
-            if isinstance(item, dict)
-        )
-        tests = tuple(
-            BehaviorTestCase.create(
-                str(item.get("tool_name") or ""),
-                arguments=dict(item.get("arguments") or {}),
-                expected_subset=dict(item.get("expected_subset") or {}),
-                description=str(item.get("description") or ""),
-            )
-            for item in raw.get("test_cases", [])
-            if isinstance(item, dict)
-        )
-        return PluginProposal(
-            proposal_id=str(raw.get("proposal_id") or ""),
-            plugin_id=str(raw.get("plugin_id") or "generated_plugin"),
-            capability_summary=str(raw.get("capability_summary") or ""),
-            gap_type=str(raw.get("gap_type") or "tool_plugin"),  # type: ignore[arg-type]
-            risk_level=str(raw.get("risk_level") or "read_only"),  # type: ignore[arg-type]
-            status=str(raw.get("status") or "draft"),  # type: ignore[arg-type]
-            evidence=evidence,
-            proposed_tools=tools,
-            test_cases=tests,
-            created_at=float(raw.get("created_at") or 0.0),
-        )
diff --git a/src/leapflow/storage/plugin_version_store.py b/src/leapflow/storage/plugin_version_store.py
index 7d37552b..595e7362 100644
--- a/src/leapflow/storage/plugin_version_store.py
+++ b/src/leapflow/storage/plugin_version_store.py
@@ -46,10 +46,12 @@ def record_source(
             "created_at": time.time(),
             "metadata": dict(metadata or {}),
         }
-        self._write_json(plugin_dir / "active.json", entry)
         index = [item for item in self._read_index(plugin_id) if item.get("version") != version_id]
         index.append(entry)
+        # Commit the active pointer last. A failed index write may leave an immutable
+        # snapshot behind, but it cannot make a partially recorded version active.
         self._write_json(plugin_dir / "versions.json", index)
+        self._write_json(plugin_dir / "active.json", entry)
         return entry
 
     def active(self, plugin_id: str) -> dict[str, Any] | None:
@@ -60,6 +62,32 @@ def active(self, plugin_id: str) -> dict[str, Any] | None:
     def versions(self, plugin_id: str) -> list[dict[str, Any]]:
         return self._read_index(plugin_id)
 
+    def snapshot_state(self, plugin_id: str) -> dict[str, Any]:
+        """Capture active pointer and version index for transactional rollback."""
+        return {
+            "active": self.active(plugin_id),
+            "versions": self.versions(plugin_id),
+        }
+
+    def restore_state(self, plugin_id: str, snapshot: dict[str, Any]) -> None:
+        """Restore metadata captured before a failed file/runtime mutation."""
+        plugin_dir = self._plugin_dir(plugin_id)
+        active_path = plugin_dir / "active.json"
+        active = snapshot.get("active")
+        if isinstance(active, dict):
+            self._write_json(active_path, active)
+        else:
+            active_path.unlink(missing_ok=True)
+        self._write_json(plugin_dir / "versions.json", list(snapshot.get("versions") or ()))
+
+    def restore_source(self, target_path: Path, data: bytes | None) -> None:
+        """Atomically restore a source snapshot, or remove a previously absent file."""
+        target = Path(target_path)
+        if data is None:
+            target.unlink(missing_ok=True)
+            return
+        self._write_bytes(target, data)
+
     def source_for(self, plugin_id: str, version: str) -> Path | None:
         for item in self._read_index(plugin_id):
             if str(item.get("version")) == str(version):
diff --git a/src/leapflow/storage/schema.py b/src/leapflow/storage/schema.py
index 3f5e022f..9c3c524f 100644
--- a/src/leapflow/storage/schema.py
+++ b/src/leapflow/storage/schema.py
@@ -9,14 +9,16 @@
 from __future__ import annotations
 
 import logging
+import time
 from dataclasses import dataclass, field
-from typing import List
+from typing import Callable, List
 
 import duckdb
 
 logger = logging.getLogger(__name__)
 
-CURRENT_SCHEMA_VERSION = 1
+BASE_SCHEMA_VERSION = 1
+CURRENT_SCHEMA_VERSION = 6
 
 
 @dataclass(frozen=True)
@@ -288,30 +290,28 @@ class TableDef:
             "CREATE INDEX IF NOT EXISTS idx_cmsg_session ON conv_messages(session_id, created_at)",
         ],
     ),
-    # ── Evolution ──
+    # ── Skill evolution memory ──
     TableDef(
-        name="evo_episodes",
+        name="skill_episodes",
         ddl="""
-        CREATE TABLE IF NOT EXISTS evo_episodes (
+        CREATE TABLE IF NOT EXISTS skill_episodes (
             episode_id VARCHAR PRIMARY KEY,
             skill_name VARCHAR NOT NULL,
             actions_json VARCHAR DEFAULT '[]',
             outcome VARCHAR DEFAULT '',
             reward DOUBLE DEFAULT 0.0,
             context_json VARCHAR DEFAULT '{}',
-            created_at DOUBLE DEFAULT 0.0,
-            workspace_id TEXT DEFAULT '',
-            session_id TEXT DEFAULT ''
+            created_at DOUBLE DEFAULT 0.0
         )
         """,
         indexes=[
-            "CREATE INDEX IF NOT EXISTS idx_evep_skill ON evo_episodes(skill_name, created_at DESC)",
+            "CREATE INDEX IF NOT EXISTS idx_episodes_skill ON skill_episodes(skill_name, created_at DESC)",
         ],
     ),
     TableDef(
-        name="evo_patterns",
+        name="skill_patterns",
         ddl="""
-        CREATE TABLE IF NOT EXISTS evo_patterns (
+        CREATE TABLE IF NOT EXISTS skill_patterns (
             pattern_id VARCHAR PRIMARY KEY,
             skill_name VARCHAR NOT NULL,
             pattern_json VARCHAR DEFAULT '{}',
@@ -362,27 +362,191 @@ class TableDef:
 ]
 
 
-def ensure_schema(conn: duckdb.DuckDBPyConnection) -> int:
-    """Create all tables and indexes if they don't exist.
+@dataclass(frozen=True)
+class MigrationDef:
+    """One ordered, transactional schema migration."""
 
-    Returns the current schema version after applying.
-    """
-    for table_def in TABLES:
-        conn.execute(table_def.ddl)
-        for idx_sql in table_def.indexes:
-            conn.execute(idx_sql)
+    version: int
+    name: str
+    apply: Callable[[duckdb.DuckDBPyConnection], None]
 
-    row = conn.execute(
-        "SELECT MAX(version) FROM _schema_version"
-    ).fetchone()
-    current = row[0] if row and row[0] is not None else 0
 
-    if current < CURRENT_SCHEMA_VERSION:
-        import time
-        conn.execute(
-            "INSERT INTO _schema_version VALUES (?, ?)",
-            [CURRENT_SCHEMA_VERSION, time.time()],
+def _apply_evolution_tables(conn: duckdb.DuckDBPyConnection) -> None:
+    """Create the append-only event stream and durable cold-path work queues."""
+    statements = (
+        """
+        CREATE TABLE evolution_events (
+            sequence BIGINT NOT NULL,
+            event_id VARCHAR PRIMARY KEY,
+            event_type VARCHAR NOT NULL,
+            profile_id VARCHAR NOT NULL DEFAULT '',
+            workspace_id VARCHAR NOT NULL DEFAULT '',
+            session_id VARCHAR NOT NULL DEFAULT '',
+            session_generation INTEGER NOT NULL DEFAULT 0,
+            turn_id VARCHAR NOT NULL DEFAULT '',
+            frame_id VARCHAR NOT NULL DEFAULT '',
+            action_id VARCHAR NOT NULL DEFAULT '',
+            observation_id VARCHAR NOT NULL DEFAULT '',
+            requirement_id VARCHAR NOT NULL DEFAULT '',
+            decision_id VARCHAR NOT NULL DEFAULT '',
+            proposal_id VARCHAR NOT NULL DEFAULT '',
+            artifact_id VARCHAR NOT NULL DEFAULT '',
+            plugin_id VARCHAR NOT NULL DEFAULT '',
+            version_id VARCHAR NOT NULL DEFAULT '',
+            correlation_id VARCHAR NOT NULL DEFAULT '',
+            causation_id VARCHAR NOT NULL DEFAULT '',
+            occurred_at DOUBLE NOT NULL,
+            producer VARCHAR NOT NULL,
+            producer_version VARCHAR NOT NULL DEFAULT '',
+            privacy_class VARCHAR NOT NULL DEFAULT 'system',
+            schema_version INTEGER NOT NULL,
+            payload_json VARCHAR NOT NULL DEFAULT '{}',
+            payload_hash VARCHAR NOT NULL,
+            dedup_key VARCHAR NOT NULL,
+            UNIQUE(profile_id, dedup_key)
         )
-        logger.info("schema: applied version %d", CURRENT_SCHEMA_VERSION)
+        """,
+        """
+        CREATE TABLE evolution_teacher_jobs (
+            job_id VARCHAR PRIMARY KEY,
+            profile_id VARCHAR NOT NULL,
+            workspace_id VARCHAR NOT NULL DEFAULT '',
+            session_id VARCHAR NOT NULL DEFAULT '',
+            session_generation INTEGER NOT NULL DEFAULT 0,
+            episode_id VARCHAR NOT NULL,
+            from_sequence BIGINT NOT NULL DEFAULT 0,
+            through_sequence BIGINT NOT NULL DEFAULT 0,
+            reason VARCHAR NOT NULL DEFAULT '',
+            goal VARCHAR NOT NULL DEFAULT '',
+            status VARCHAR NOT NULL,
+            lease_owner VARCHAR NOT NULL DEFAULT '',
+            lease_until DOUBLE NOT NULL DEFAULT 0.0,
+            attempts INTEGER NOT NULL DEFAULT 0,
+            model VARCHAR NOT NULL DEFAULT '',
+            prompt_hash VARCHAR NOT NULL DEFAULT '',
+            result_artifact_id VARCHAR NOT NULL DEFAULT '',
+            next_attempt_at DOUBLE NOT NULL DEFAULT 0.0,
+            created_at DOUBLE NOT NULL,
+            updated_at DOUBLE NOT NULL,
+            completed_at DOUBLE NOT NULL DEFAULT 0.0,
+            error VARCHAR NOT NULL DEFAULT '',
+            UNIQUE(profile_id, episode_id)
+        )
+        """,
+        "CREATE INDEX idx_evo_event_session ON evolution_events(profile_id, session_id, sequence)",
+        "CREATE INDEX idx_evo_event_correlation ON evolution_events(profile_id, correlation_id, sequence)",
+        "CREATE INDEX idx_evo_event_type ON evolution_events(profile_id, event_type, sequence)",
+        "CREATE INDEX idx_evo_teacher_status ON evolution_teacher_jobs(profile_id, status, next_attempt_at)",
+    )
+    for statement in statements:
+        conn.execute(statement)
+
+
+def _apply_evolution_sequence(conn: duckdb.DuckDBPyConnection) -> None:
+    """Create a database-global cursor after any pre-sequence event rows."""
+    conn.execute(
+        "CREATE UNIQUE INDEX idx_evo_event_sequence ON evolution_events(sequence)"
+    )
+    row = conn.execute("SELECT COALESCE(MAX(sequence), 0) + 1 FROM evolution_events").fetchone()
+    start = max(1, int(row[0] if row else 1))
+    conn.execute(f"CREATE SEQUENCE evolution_event_sequence START {start}")
+
+
+def _apply_teacher_job_context(conn: duckdb.DuckDBPyConnection) -> None:
+    """Make every durable teacher job independently executable and auditable."""
+    statements = (
+        "ALTER TABLE evolution_teacher_jobs ADD COLUMN IF NOT EXISTS workspace_id VARCHAR DEFAULT ''",
+        "ALTER TABLE evolution_teacher_jobs ADD COLUMN IF NOT EXISTS session_id VARCHAR DEFAULT ''",
+        "ALTER TABLE evolution_teacher_jobs ADD COLUMN IF NOT EXISTS session_generation INTEGER DEFAULT 0",
+        "ALTER TABLE evolution_teacher_jobs ADD COLUMN IF NOT EXISTS from_sequence BIGINT DEFAULT 0",
+        "ALTER TABLE evolution_teacher_jobs ADD COLUMN IF NOT EXISTS through_sequence BIGINT DEFAULT 0",
+        "ALTER TABLE evolution_teacher_jobs ADD COLUMN IF NOT EXISTS reason VARCHAR DEFAULT ''",
+        "ALTER TABLE evolution_teacher_jobs ADD COLUMN IF NOT EXISTS goal VARCHAR DEFAULT ''",
+        "ALTER TABLE evolution_teacher_jobs ADD COLUMN IF NOT EXISTS result_artifact_id VARCHAR DEFAULT ''",
+        "ALTER TABLE evolution_teacher_jobs ADD COLUMN IF NOT EXISTS completed_at DOUBLE DEFAULT 0.0",
+    )
+    for statement in statements:
+        conn.execute(statement)
+
+
+def _apply_evolution_projection(conn: duckdb.DuckDBPyConnection) -> None:
+    """Create checkpointed read models derived exclusively from the event stream."""
+    conn.execute(
+        """
+        CREATE TABLE evolution_projections (
+            projection_name VARCHAR NOT NULL,
+            profile_id VARCHAR NOT NULL,
+            scope_key VARCHAR NOT NULL,
+            last_sequence BIGINT NOT NULL DEFAULT 0,
+            state_json VARCHAR NOT NULL DEFAULT '{}',
+            updated_at DOUBLE NOT NULL,
+            PRIMARY KEY (projection_name, profile_id, scope_key)
+        )
+        """
+    )
+
+
+def _apply_proposal_event_index(conn: duckdb.DuckDBPyConnection) -> None:
+    """Retire the unused work table and index event-sourced proposal replay."""
+    conn.execute("DROP TABLE IF EXISTS evolution_proposal_work")
+    conn.execute(
+        "CREATE INDEX idx_evo_event_proposal "
+        "ON evolution_events(profile_id, proposal_id, sequence)"
+    )
+
+
+MIGRATIONS: tuple[MigrationDef, ...] = (
+    MigrationDef(2, "evolution event stream", _apply_evolution_tables),
+    MigrationDef(3, "database-global evolution cursor", _apply_evolution_sequence),
+    MigrationDef(4, "durable teacher job context", _apply_teacher_job_context),
+    MigrationDef(5, "checkpointed evolution projections", _apply_evolution_projection),
+    MigrationDef(6, "event-sourced proposal index", _apply_proposal_event_index),
+)
+
+
+def ensure_schema(conn: duckdb.DuckDBPyConnection) -> int:
+    """Bootstrap the baseline and apply every pending migration atomically."""
+    conn.execute("BEGIN TRANSACTION")
+    try:
+        for table_def in TABLES:
+            conn.execute(table_def.ddl)
+            for idx_sql in table_def.indexes:
+                conn.execute(idx_sql)
+
+        row = conn.execute("SELECT MAX(version) FROM _schema_version").fetchone()
+        current = int(row[0]) if row and row[0] is not None else 0
+        if current > CURRENT_SCHEMA_VERSION:
+            raise RuntimeError(
+                f"database schema {current} is newer than supported {CURRENT_SCHEMA_VERSION}"
+            )
+        if current == 0:
+            conn.execute(
+                "INSERT INTO _schema_version VALUES (?, ?)",
+                [BASE_SCHEMA_VERSION, time.time()],
+            )
+            current = BASE_SCHEMA_VERSION
+
+        for migration in MIGRATIONS:
+            if migration.version <= current:
+                continue
+            if migration.version != current + 1:
+                raise RuntimeError(
+                    f"schema migration gap: current={current}, next={migration.version}"
+                )
+            migration.apply(conn)
+            conn.execute(
+                "INSERT INTO _schema_version VALUES (?, ?)",
+                [migration.version, time.time()],
+            )
+            current = migration.version
+            logger.info("schema: applied version %d (%s)", current, migration.name)
 
-    return CURRENT_SCHEMA_VERSION
+        if current != CURRENT_SCHEMA_VERSION:
+            raise RuntimeError(
+                f"schema migration incomplete: current={current}, expected={CURRENT_SCHEMA_VERSION}"
+            )
+        conn.execute("COMMIT")
+        return current
+    except Exception:
+        conn.execute("ROLLBACK")
+        raise
diff --git a/src/leapflow/tools/name_resolver.py b/src/leapflow/tools/name_resolver.py
index c0ec98d7..508413ae 100644
--- a/src/leapflow/tools/name_resolver.py
+++ b/src/leapflow/tools/name_resolver.py
@@ -28,28 +28,6 @@
 ResolutionConfidence = Literal["high", "medium", "low"]
 RiskLevel = Literal["read_only", "mutating", "external"]
 
-_READ_ONLY_TOOLS = {
-    "file_list",
-    "file_read",
-    "time_get",
-    "env_info",
-    "text_search",
-    "skills_list",
-    "skill_view",
-    "memory_search",
-    # Network reads: a GET has no side effect, so the loop must not treat it as a
-    # mutation. Egress safety is enforced by the tool's own target gate, not by
-    # pretending the call mutates state.
-    "web_fetch",
-    # Verification/inspection tools: read-oriented for the loop even though some
-    # names contain a mutating signal (e.g. test_run) or execute via a gated
-    # underlying tool (test_run/lint_check delegate to the shell_run gate).
-    "test_run",
-    "lint_check",
-    "terminal_read",
-    "terminal_list",
-}
-
 _NO_EFFECT_CLAIMS = frozenset({"read_only", "none"})
 """The only declared ``risk_level`` values that assert a call has no effect.
 
@@ -127,10 +105,11 @@ class ToolSpec:
     description: str = ""
     parameters: frozenset[str] = field(default_factory=frozenset)
     required: frozenset[str] = field(default_factory=frozenset)
-    risk_level: RiskLevel = "read_only"
+    risk_level: RiskLevel = "mutating"
     mutates_state: bool = False
     effect_scope: str = "local"
     idempotency_scope: str = "turn"
+    execution_policy: str = ""
 
 
 @dataclass(frozen=True)
@@ -144,7 +123,7 @@ class ToolResolution:
     reason: str
     suggestions: tuple[str, ...] = ()
     auto_executable: bool = False
-    risk_level: RiskLevel = "read_only"
+    risk_level: RiskLevel = "mutating"
 
     @property
     def is_resolved(self) -> bool:
@@ -212,8 +191,7 @@ def from_definitions(
             metadata = function.get("x_leapflow", {}) or definition.get("x_leapflow", {}) or {}
             mutates_state = bool(metadata.get("mutates_state", False))
             risk_level = _resolve_risk_level(
-                name,
-                bridge_mutates=mutates_state,
+                mutates_state=mutates_state,
                 declared=str(metadata.get("risk_level") or ""),
             )
             specs[name] = ToolSpec(
@@ -224,7 +202,11 @@ def from_definitions(
                 risk_level=risk_level,
                 mutates_state=mutates_state,
                 effect_scope=str(metadata.get("effect_scope") or ("external" if risk_level == "external" else "local")),
-                idempotency_scope=str(metadata.get("idempotency_scope") or ("session" if risk_level == "external" else "turn")),
+                idempotency_scope=str(
+                    metadata.get("idempotency_scope")
+                    or ("session" if risk_level == "external" else "turn")
+                ),
+                execution_policy=str(metadata.get("execution_policy") or ""),
             )
         for name in handlers.keys():
             canonical = str(name).removeprefix("gp_")
@@ -232,13 +214,14 @@ def from_definitions(
                 mutates_state = False
                 # A handler with no schema declares nothing at all, so it gets the
                 # unclaimed default rather than being read as read-only.
-                risk_level = _resolve_risk_level(canonical, bridge_mutates=mutates_state)
+                risk_level = _resolve_risk_level(mutates_state=mutates_state)
                 specs[canonical] = ToolSpec(
                     name=canonical,
                     risk_level=risk_level,
                     mutates_state=mutates_state,
-                    effect_scope="external" if risk_level == "external" else "local",
-                    idempotency_scope="session" if risk_level == "external" else "turn",
+                    effect_scope="external",
+                    idempotency_scope="session",
+                    execution_policy="external_side_effect",
                 )
 
         validated_aliases: dict[str, str] = {}
@@ -360,32 +343,12 @@ def _suggestions(self, tool_name: str, arguments: Mapping[str, Any]) -> tuple[st
         return tuple(shape_matches[:5])
 
 
-def _resolve_risk_level(name: str, *, bridge_mutates: bool, declared: str = "") -> RiskLevel:
-    """Classify a tool's *effect* for the execution policy.
-
-    ``declared`` is ``x_leapflow.risk_level``, and it is consulted rather than
-    honoured wholesale, because that key carries two different vocabularies. The
-    disclosure side (``CapabilityManifest``) grades how much a call needs to be
-    explained and approved -- ``none``/``read_only``/``low``/``medium``/``high`` --
-    while this side answers a narrower question: does the call have an effect, and
-    can it be replayed. "medium" is not an answer to that; copying it into this
-    field would put a value outside ``RiskLevel`` into a typed slot and match none
-    of the comparisons that read it.
-
-    So only the values where the two vocabularies genuinely agree are taken as a
-    claim of no effect. Everything else -- a graded risk, or no declaration at all
-    -- resolves to ``mutating``. Absence of a declaration is not a claim of
-    safety: read as one, a third-party tool with an innocuous name got the
-    ``read_only`` policy, which skips the execution ledger entirely, runs freely
-    in parallel, and is exempt from side-effect gating.
-
-    Order matters. An explicit no-effect claim outranks the name heuristic,
-    because the heuristic is a substring guess: ``test_run`` contains "run" but is
-    an inspection. A mutating *bridge* still wins over both, since a declaration
-    that contradicts the handler's own answer is the stale one.
-    """
-    if name.startswith(("gateway_", "hub_", "platform_")) or declared == "external":
+def _resolve_risk_level(*, mutates_state: bool, declared: str = "") -> RiskLevel:
+    """Classify effect risk from declarations without inspecting the tool name."""
+    if declared == "external":
         return "external"
-    if not bridge_mutates and (declared in _NO_EFFECT_CLAIMS or name in _READ_ONLY_TOOLS):
+    if not mutates_state and declared in _NO_EFFECT_CLAIMS:
         return "read_only"
+    if mutates_state or declared:
+        return "mutating"
     return "mutating"
diff --git a/src/leapflow/world_model/prediction.py b/src/leapflow/world_model/prediction.py
index 3a83805c..54000669 100644
--- a/src/leapflow/world_model/prediction.py
+++ b/src/leapflow/world_model/prediction.py
@@ -18,7 +18,7 @@
 import time
 from collections import deque
 from dataclasses import dataclass, replace
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Callable, Optional
 
 if TYPE_CHECKING:
     from leapflow.world_model.budget import LearningBudgetController
@@ -99,12 +99,10 @@ class PredictionOutcome:
 
 
 class PredictionLoop:
-    """Core on-policy learning engine: Predict → Execute → Compare → Learn.
+    """Legacy prediction and comparison model used by explicit observation flows.
 
-    Wraps action execution to transparently inject prediction and comparison.
-    When disabled or budget-exhausted, passes through execution unchanged.
-
-    Maintains a trajectory buffer for OPD trajectory-level teacher grading.
+    Action execution is owned by ``ActionExecutor``. This component may grade an
+    already-observed transition, but it never wraps or replays an action.
     """
 
     def __init__(
@@ -191,89 +189,6 @@ def record_failure(self, action_desc: str, error: str) -> None:
         except Exception:
             logger.debug("record_failure failed", exc_info=True)
 
-    async def wrap_execution(
-        self,
-        action_desc: str,
-        execute_fn: Callable[..., Awaitable[Any]],
-        *args: Any,
-        fidelity: Optional["SnapshotFidelity"] = None,
-        **kwargs: Any,
-    ) -> Tuple[Any, Optional[PredictionOutcome]]:
-        """Wrap an action execution with the prediction-comparison loop.
-
-        Returns (execution_result, prediction_outcome_or_none).
-        """
-        if not self._enabled or not self._budget.has_tokens("prediction"):
-            result = await execute_fn(*args, **kwargs)
-            return result, None
-
-        try:
-            return await self._run_loop(action_desc, execute_fn, args, kwargs, fidelity)
-        except Exception:
-            logger.debug("prediction_loop.wrap_execution failed; executing raw", exc_info=True)
-            result = await execute_fn(*args, **kwargs)
-            return result, None
-
-    async def _run_loop(
-        self,
-        action_desc: str,
-        execute_fn: Callable[..., Awaitable[Any]],
-        args: tuple,
-        kwargs: dict,
-        fidelity: Optional["SnapshotFidelity"],
-    ) -> Tuple[Any, Optional[PredictionOutcome]]:
-        from leapflow.perception.state_snapshot import SnapshotFidelity
-
-        fid = fidelity or SnapshotFidelity.LIGHT
-
-        # Phase 1: Capture pre-state
-        pre = await self._snapshot.capture(fid)
-
-        # Phase 2: Predict
-        prediction = await self._predict(action_desc, pre)
-
-        # Phase 3: Execute
-        result = await execute_fn(*args, **kwargs)
-
-        # Phase 4: Capture post-state
-        post = await self._snapshot.capture(fid)
-
-        # Phase 5: Compare
-        outcome = await self._compare(prediction, pre, post)
-
-        # Phase 6: Store experience
-        exp_id = self._store.store(
-            action_description=action_desc,
-            app_context=pre.app_bundle_id,
-            predicted_effect=prediction.expected_effect,
-            actual_effect=outcome.actual_effect,
-            delta=outcome.delta,
-            pre_state_summary=pre.to_prompt_context(budget_tokens=100),
-            post_state_summary=post.to_prompt_context(budget_tokens=100),
-        )
-
-        outcome = replace(outcome, experience_id=exp_id)
-
-        # Phase 7: Accumulate trajectory for OPD grading
-        self._trajectory_buffer.append({
-            "experience_id": exp_id,
-            "action_description": action_desc,
-            "app_context": pre.app_bundle_id,
-            "predicted_effect": prediction.expected_effect,
-            "actual_effect": outcome.actual_effect,
-            "delta": outcome.delta,
-        })
-
-        self._budget.spend("prediction")
-
-        if self._on_outcome is not None:
-            try:
-                self._on_outcome(outcome)
-            except Exception:
-                logger.debug("on_prediction_outcome callback failed", exc_info=True)
-
-        return result, outcome
-
     async def _predict(self, action_desc: str, pre: "StateSnapshot") -> Prediction:
         """Generate a prediction using LLM with retrieval-augmented context."""
         similar = self._store.retrieve_similar(
diff --git a/src/leapflow/world_model/trajectory_grader.py b/src/leapflow/world_model/trajectory_grader.py
index b4fc4f55..b55de62c 100644
--- a/src/leapflow/world_model/trajectory_grader.py
+++ b/src/leapflow/world_model/trajectory_grader.py
@@ -14,7 +14,7 @@
 from __future__ import annotations
 
 import logging
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, List, Mapping, Sequence
 
 if TYPE_CHECKING:
@@ -362,6 +362,7 @@ class TeacherVerdict:
 
     grades: tuple[ActionGrade, ...] = ()
     verdicts: tuple[AdaptationVerdict, ...] = ()
+    raw_payload: Mapping[str, Any] = field(default_factory=dict)
 
     @property
     def intents(self) -> tuple[EvolutionIntent, ...]:
@@ -426,6 +427,7 @@ async def grade_and_propose(
         goal: str = "",
         *,
         degraded_capabilities: Sequence[Mapping[str, Any]] = (),
+        raise_on_error: bool = False,
     ) -> "TeacherVerdict":
         """Grade the trajectory *and* propose capability gaps, in one LLM call.
 
@@ -446,8 +448,11 @@ async def grade_and_propose(
 
         traj_text = self._format_trajectory(trajectory)
         payload = await self._call_teacher_raw(
-            traj_text, goal, propose_gaps=True,
+            traj_text,
+            goal,
+            propose_gaps=True,
             degraded_capabilities=degraded_capabilities,
+            raise_on_error=raise_on_error,
         )
         self._budget.spend("grading")
 
@@ -455,6 +460,7 @@ async def grade_and_propose(
         return TeacherVerdict(
             tuple(grades),
             self._parse_verdicts(payload, goal, degraded_capabilities),
+            dict(payload),
         )
 
     async def _call_teacher_raw(
@@ -464,6 +470,7 @@ async def _call_teacher_raw(
         *,
         propose_gaps: bool = False,
         degraded_capabilities: Sequence[Mapping[str, Any]] = (),
+        raise_on_error: bool = False,
     ) -> dict:
         """Single LLM call: teacher evaluates with full hindsight.
 
@@ -493,6 +500,8 @@ async def _call_teacher_raw(
             )
             return extract_json_object(resp.content or "") or {}
         except Exception:
+            if raise_on_error:
+                raise
             logger.debug("trajectory_grader.call_teacher failed", exc_info=True)
             return {}
 
diff --git a/src/leapspace/app_space/harness.py b/src/leapspace/app_space/harness.py
index 8824eb1f..6b3dcf06 100644
--- a/src/leapspace/app_space/harness.py
+++ b/src/leapspace/app_space/harness.py
@@ -293,6 +293,21 @@ async def _run_signal(self, config: AppTaskConfig, actor: LeapAppActor) -> int:
             logger.error(
                 "verdict: task %s failed expect (exit %d)", config.id, result.returncode
             )
+        result_dir = state_root / config.id
+        await actor.fs_mkdir(str(result_dir))
+        await actor.fs_write(
+            str(result_dir / "result.json"),
+            json.dumps(
+                {
+                    "task_id": config.id,
+                    "outcome": "PASS" if result.returncode == 0 else "FAIL",
+                    "exit_code": result.returncode,
+                    "app_ids": list(config.app_ids),
+                    "observed_at": time.time(),
+                },
+                ensure_ascii=False,
+            ),
+        )
         return result.returncode
 
     async def _await_sentinel(
diff --git a/tests/_fixtures/cassettes/r1_conversation/cassette-model-367e09460741491b.cassette.json b/tests/_fixtures/cassettes/r1_conversation/cassette-model-367e09460741491b.cassette.json
new file mode 100644
index 00000000..10dc95cc
--- /dev/null
+++ b/tests/_fixtures/cassettes/r1_conversation/cassette-model-367e09460741491b.cassette.json
@@ -0,0 +1,55 @@
+{
+  "fingerprint": "367e09460741491b1993580005a5bbeed016185dbf1e29b1b44b4ed55fad793f",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Say hello.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Say hello.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Say hello.\nSay hello."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Hello from LeapFlow.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r1_conversation/cassette-model-9b6460bbb9f20b6f.cassette.json b/tests/_fixtures/cassettes/r1_conversation/cassette-model-9b6460bbb9f20b6f.cassette.json
new file mode 100644
index 00000000..60b6de29
--- /dev/null
+++ b/tests/_fixtures/cassettes/r1_conversation/cassette-model-9b6460bbb9f20b6f.cassette.json
@@ -0,0 +1,75 @@
+{
+  "fingerprint": "9b6460bbb9f20b6ff5fc173abb997b32c67a66e625cd42a16bd3cc0a4c35aa15",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Hello from LeapFlow.\n- [user] Use the file_read tool on invoice.txt and report the total.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Use the file_read tool on invoice.txt and report the total.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Hello from LeapFlow."
+      },
+      {
+        "role": "user",
+        "content": "Use the file_read tool on invoice.txt and report the total.\nUse the file_read tool on invoice.txt and report the total."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "file_read"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"kind\": \"file_read_evidence\", \"path\": \"<TMP>\", \"lines\": 2, \"truncated\": false, \"mode\": \"raw\", \"excerpt\": \"Invoice 42\\nTotal: 128.50 USD\", \"start_line\": 1, \"end_line\": 2, \"selected_lines\": 2}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"The invoice total is 128.50 USD.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r1_conversation/cassette-model-bc00bc1c3adb5c03.cassette.json b/tests/_fixtures/cassettes/r1_conversation/cassette-model-bc00bc1c3adb5c03.cassette.json
new file mode 100644
index 00000000..724161a6
--- /dev/null
+++ b/tests/_fixtures/cassettes/r1_conversation/cassette-model-bc00bc1c3adb5c03.cassette.json
@@ -0,0 +1,59 @@
+{
+  "fingerprint": "bc00bc1c3adb5c032a334b6431c7b10b91c539cd0af768196ae358a074aa07ed",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Hello from LeapFlow.\n- [user] Use the file_read tool on invoice.txt and report the total.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Use the file_read tool on invoice.txt and report the total.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Hello from LeapFlow."
+      },
+      {
+        "role": "user",
+        "content": "Use the file_read tool on invoice.txt and report the total.\nUse the file_read tool on invoice.txt and report the total."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"file_read\", \"arguments\": \"{\\\"path\\\": \\\"invoice.txt\\\"}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r1_conversation/cassette-model-d963d1a7c85f827a.cassette.json b/tests/_fixtures/cassettes/r1_conversation/cassette-model-d963d1a7c85f827a.cassette.json
new file mode 100644
index 00000000..a9a69566
--- /dev/null
+++ b/tests/_fixtures/cassettes/r1_conversation/cassette-model-d963d1a7c85f827a.cassette.json
@@ -0,0 +1,59 @@
+{
+  "fingerprint": "d963d1a7c85f827a9ed648bf1bfc955676c4ce2e222e4a3fed7833c7e23b5000",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n## Semantic Focus Plane\nCurrent task focus:\n- Target: invoice.txt\n- Type: file\n- Evidence refs: file_read:invoice.txt\nResolved user reference:\n- file -> invoice.txt (task_semantic, confidence=0.92)\nUse Current task focus for deictic task references such as 'the above paper'; use control-plane events only when the user explicitly asks about runtime settings.\n\n\n## Recent Session Summary\n- [assistant] The invoice total is 128.50 USD.\n- [user] Is that the same invoice?\n\n## Task Contract\n- Task ID: turn-3\n- Original user request: Is that the same invoice?\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "The invoice total is 128.50 USD."
+      },
+      {
+        "role": "user",
+        "content": "Is that the same invoice?\nIs that the same invoice?"
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Yes, that is the same invoice.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r2_isolation/cassette-model-21df7e8e74778e3f.cassette.json b/tests/_fixtures/cassettes/r2_isolation/cassette-model-21df7e8e74778e3f.cassette.json
new file mode 100644
index 00000000..6af38931
--- /dev/null
+++ b/tests/_fixtures/cassettes/r2_isolation/cassette-model-21df7e8e74778e3f.cassette.json
@@ -0,0 +1,55 @@
+{
+  "fingerprint": "21df7e8e74778e3f6aa6866b0923ce2cc98e0072408b928be525bd9aed592ee7",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Hello from B.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Hello from B.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Hello from B.\nHello from B."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Workspace B acknowledged.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r2_isolation/cassette-model-73ddd7ce361986cc.cassette.json b/tests/_fixtures/cassettes/r2_isolation/cassette-model-73ddd7ce361986cc.cassette.json
new file mode 100644
index 00000000..8c28ce3b
--- /dev/null
+++ b/tests/_fixtures/cassettes/r2_isolation/cassette-model-73ddd7ce361986cc.cassette.json
@@ -0,0 +1,59 @@
+{
+  "fingerprint": "73ddd7ce361986cc46ac429df381a3489347c8aebc15b7b35794cc6474c6dc89",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Workspace B acknowledged.\n- [user] Second B turn.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Second B turn.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Workspace B acknowledged."
+      },
+      {
+        "role": "user",
+        "content": "Second B turn.\nSecond B turn."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Still workspace B.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r2_isolation/cassette-model-aff723a22088e665.cassette.json b/tests/_fixtures/cassettes/r2_isolation/cassette-model-aff723a22088e665.cassette.json
new file mode 100644
index 00000000..e517617d
--- /dev/null
+++ b/tests/_fixtures/cassettes/r2_isolation/cassette-model-aff723a22088e665.cassette.json
@@ -0,0 +1,59 @@
+{
+  "fingerprint": "aff723a22088e6657d3e1e44df0572c1ec08913184833d791cee35004532f565",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Workspace A acknowledged.\n- [user] Second A turn.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Second A turn.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Workspace A acknowledged."
+      },
+      {
+        "role": "user",
+        "content": "Second A turn.\nSecond A turn."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Still workspace A.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r2_isolation/cassette-model-ef55f6a7257d5165.cassette.json b/tests/_fixtures/cassettes/r2_isolation/cassette-model-ef55f6a7257d5165.cassette.json
new file mode 100644
index 00000000..3905868e
--- /dev/null
+++ b/tests/_fixtures/cassettes/r2_isolation/cassette-model-ef55f6a7257d5165.cassette.json
@@ -0,0 +1,55 @@
+{
+  "fingerprint": "ef55f6a7257d5165de4af8f42068832348aa86d3cf09b80cf6b9fe5b18e18650",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Hello from A.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Hello from A.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Hello from A.\nHello from A."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Workspace A acknowledged.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r3_control_plane/cassette-model-4ecd277d081b281e.cassette.json b/tests/_fixtures/cassettes/r3_control_plane/cassette-model-4ecd277d081b281e.cassette.json
new file mode 100644
index 00000000..ec587be0
--- /dev/null
+++ b/tests/_fixtures/cassettes/r3_control_plane/cassette-model-4ecd277d081b281e.cassette.json
@@ -0,0 +1,55 @@
+{
+  "fingerprint": "4ecd277d081b281e9a9324cc714092a2ed827389d2082ec3fa905018533df9b0",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Anything to report?\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Anything to report?\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Anything to report?\nAnything to report?"
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Acknowledged.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r4_recovery/cassette-model-114913c6ced49c00.cassette.json b/tests/_fixtures/cassettes/r4_recovery/cassette-model-114913c6ced49c00.cassette.json
new file mode 100644
index 00000000..31646fe8
--- /dev/null
+++ b/tests/_fixtures/cassettes/r4_recovery/cassette-model-114913c6ced49c00.cassette.json
@@ -0,0 +1,60 @@
+{
+  "fingerprint": "114913c6ced49c000271ba14cd9aa443a429df524ac31b9f2bffd1f947be2147",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Summarize the situation.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Summarize the situation.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Summarize the situation.\nSummarize the situation."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 429,
+      "content_type": "application/json",
+      "body": "{\"error\": {\"message\": \"Rate limit reached for requests\", \"type\": \"rate_limit_error\", \"code\": \"rate_limit_exceeded\"}}"
+    },
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Recovered after a rate limit.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r4_recovery/cassette-model-8f4a60fd5352920b.cassette.json b/tests/_fixtures/cassettes/r4_recovery/cassette-model-8f4a60fd5352920b.cassette.json
new file mode 100644
index 00000000..04dc2930
--- /dev/null
+++ b/tests/_fixtures/cassettes/r4_recovery/cassette-model-8f4a60fd5352920b.cassette.json
@@ -0,0 +1,64 @@
+{
+  "fingerprint": "8f4a60fd5352920b7c500e4d1b16a5ccb41659017b540716c3f607f93d8f7a24",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Recovered after a rate limit.\n- [user] And now?\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: And now?\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Recovered after a rate limit."
+      },
+      {
+        "role": "user",
+        "content": "And now?\nAnd now?"
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 500,
+      "content_type": "application/json",
+      "body": "{\"error\": {\"message\": \"The server had an error\", \"type\": \"server_error\", \"code\": \"internal_error\"}}"
+    },
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Recovered after a server error.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r4_recovery/cassette-model-bd1578d59776ef42.cassette.json b/tests/_fixtures/cassettes/r4_recovery/cassette-model-bd1578d59776ef42.cassette.json
new file mode 100644
index 00000000..2103e12a
--- /dev/null
+++ b/tests/_fixtures/cassettes/r4_recovery/cassette-model-bd1578d59776ef42.cassette.json
@@ -0,0 +1,64 @@
+{
+  "fingerprint": "bd1578d59776ef4247e95de673cbb23ba80ebc3301c6a6388d06c79d2ca5d8bd",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Recovered after a server error.\n- [user] Keep going with more context.\n\n## Task Contract\n- Task ID: turn-3\n- Original user request: Keep going with more context.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Recovered after a server error."
+      },
+      {
+        "role": "user",
+        "content": "Keep going with more context.\nKeep going with more context."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 400,
+      "content_type": "application/json",
+      "body": "{\"error\": {\"message\": \"This model's maximum context length is 8192 tokens. However, your messages resulted in 9001 tokens.\", \"type\": \"invalid_request_error\", \"code\": \"context_length_exceeded\"}}"
+    },
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Recovered after compressing context.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r4_recovery/cassette-model-f4840e1191c49c9c.cassette.json b/tests/_fixtures/cassettes/r4_recovery/cassette-model-f4840e1191c49c9c.cassette.json
new file mode 100644
index 00000000..6f19d24f
--- /dev/null
+++ b/tests/_fixtures/cassettes/r4_recovery/cassette-model-f4840e1191c49c9c.cassette.json
@@ -0,0 +1,64 @@
+{
+  "fingerprint": "f4840e1191c49c9c300c0c2aaf5e5a4cb9255ca92b83498d50cbebe65acb05b6",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Recovered after compressing context.\n- [user] Do the impossible thing.\n\n## Task Contract\n- Task ID: turn-4\n- Original user request: Do the impossible thing.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Recovered after compressing context."
+      },
+      {
+        "role": "user",
+        "content": "Do the impossible thing.\nDo the impossible thing."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 400,
+      "content_type": "application/json",
+      "body": "{\"error\": {\"message\": \"The requested configuration is not supported by this model\", \"type\": \"invalid_request_error\", \"code\": \"unsupported_value\"}}"
+    },
+    {
+      "status": 400,
+      "content_type": "application/json",
+      "body": "{\"error\": {\"message\": \"The requested configuration is not supported by this model\", \"type\": \"invalid_request_error\", \"code\": \"unsupported_value\"}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r5_learning/cassette-model-06eeece3f570a148.cassette.json b/tests/_fixtures/cassettes/r5_learning/cassette-model-06eeece3f570a148.cassette.json
new file mode 100644
index 00000000..317b4baf
--- /dev/null
+++ b/tests/_fixtures/cassettes/r5_learning/cassette-model-06eeece3f570a148.cassette.json
@@ -0,0 +1,55 @@
+{
+  "fingerprint": "06eeece3f570a148c58d9c26be673787a9124142d2b711b8c7c959e6102125d1",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Let me show you something.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Let me show you something.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Let me show you something.\nLet me show you something."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Noted the first step.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r5_learning/cassette-model-077a17b141c44fb6.cassette.json b/tests/_fixtures/cassettes/r5_learning/cassette-model-077a17b141c44fb6.cassette.json
new file mode 100644
index 00000000..78c01e0f
--- /dev/null
+++ b/tests/_fixtures/cassettes/r5_learning/cassette-model-077a17b141c44fb6.cassette.json
@@ -0,0 +1,59 @@
+{
+  "fingerprint": "077a17b141c44fb6392901e4f453a63e34d75dbc6665390246901b4cef07f80a",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Noted the first step.\n- [user] Now sort them by month.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Now sort them by month.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Noted the first step."
+      },
+      {
+        "role": "user",
+        "content": "Now sort them by month.\nNow sort them by month."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Noted the second step.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r5_learning/cassette-model-31d350ae8f4ff81e.cassette.json b/tests/_fixtures/cassettes/r5_learning/cassette-model-31d350ae8f4ff81e.cassette.json
new file mode 100644
index 00000000..d4a4ac8c
--- /dev/null
+++ b/tests/_fixtures/cassettes/r5_learning/cassette-model-31d350ae8f4ff81e.cassette.json
@@ -0,0 +1,67 @@
+{
+  "fingerprint": "31d350ae8f4ff81eb9cbb900be46a0a74f7494e1babb49d2c7797c7265f093a9",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Noted the second step.\n- [user] Thanks, that is all.\n\n## Task Contract\n- Task ID: turn-3\n- Original user request: Thanks, that is all.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Noted the second step."
+      },
+      {
+        "role": "user",
+        "content": "Thanks, that is all.\nThanks, that is all."
+      },
+      {
+        "role": "assistant",
+        "content": "{\"title\": \"Tidy invoices\", \"trigger_phrases\": [\"tidy invoices\", \"sort invoices\"], \"steps\": [\"List the invoice folder\", \"Classify by month\", \"Move into folders\"], \"parameters\": [{\"name\": \"path\", \"description\": \"invoice folder\"}], \"pre_conditions\": [], \"confidence\": 0.7}"
+      },
+      {
+        "role": "user",
+        "content": "Tool result (path):\n{\"ok\": false, \"error\": \"Unknown tool: path\", \"error_type\": \"unknown_tool\", \"retryable\": true}\nSYSTEM: The previous tool call used an unavailable tool name. Original tool: path. Resolution: unknown (no exact canonical tool name match). Suggested canonical tools: assess_compatibility, capability_expand, code_intel, code_search, config_get. Available tools include: assess_compatibility, capability_expand, code_intel, code_search, config_get, config_list, config_set, delegate_task, edit_file, env_info, file_find, file_list. Retry once using an exact canonical tool name from the available list and valid arguments. Do not invent tool names, use aliases, or infer a tool from argument shape; answer without a tool if no exact tool fits."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Done \\u2014 nothing further needed.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r5_learning/cassette-model-8bfb5eaeaf86d401.cassette.json b/tests/_fixtures/cassettes/r5_learning/cassette-model-8bfb5eaeaf86d401.cassette.json
new file mode 100644
index 00000000..9f6f9bbc
--- /dev/null
+++ b/tests/_fixtures/cassettes/r5_learning/cassette-model-8bfb5eaeaf86d401.cassette.json
@@ -0,0 +1,59 @@
+{
+  "fingerprint": "8bfb5eaeaf86d4015d3a48f80b3e528471c432d6721b728b4716c7620ae36c13",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Noted the second step.\n- [user] Thanks, that is all.\n\n## Task Contract\n- Task ID: turn-3\n- Original user request: Thanks, that is all.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Noted the second step."
+      },
+      {
+        "role": "user",
+        "content": "Thanks, that is all.\nThanks, that is all."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"{\\\"title\\\": \\\"Tidy invoices\\\", \\\"trigger_phrases\\\": [\\\"tidy invoices\\\", \\\"sort invoices\\\"], \\\"steps\\\": [\\\"List the invoice folder\\\", \\\"Classify by month\\\", \\\"Move into folders\\\"], \\\"parameters\\\": [{\\\"name\\\": \\\"path\\\", \\\"description\\\": \\\"invoice folder\\\"}], \\\"pre_conditions\\\": [], \\\"confidence\\\": 0.7}\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-158ec6b3661786da.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-158ec6b3661786da.cassette.json
new file mode 100644
index 00000000..18796824
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-158ec6b3661786da.cassette.json
@@ -0,0 +1,76 @@
+{
+  "fingerprint": "158ec6b3661786daf7c8db8a18fb1a41cf63db2821d13a6ee697312a6117bfaa",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **fixture_echo**(text): Return the supplied text from a pre-built DSH package.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Installed the hermetic DSH plugin.\n- [user] Invoke fixture_echo with the text before restart.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Invoke fixture_echo with the text before restart.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Installed the hermetic DSH plugin."
+      },
+      {
+        "role": "user",
+        "content": "Invoke fixture_echo with the text before restart.\nInvoke fixture_echo with the text before restart."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "fixture_echo"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"echo\": \"before restart\", \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"read_only\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "fixture_echo",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"The DSH tool ran before restart.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-17557e9ee9842679.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-17557e9ee9842679.cassette.json
new file mode 100644
index 00000000..88f582be
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-17557e9ee9842679.cassette.json
@@ -0,0 +1,72 @@
+{
+  "fingerprint": "17557e9ee9842679a73ce2909cf1934bea3a4725b28aaa65af1c672779c5b98a",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **fixture_echo**(text): Return the supplied text from a pre-built DSH package.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Invoke fixture_echo with the text after restart.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Invoke fixture_echo with the text after restart.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Invoke fixture_echo with the text after restart.\nInvoke fixture_echo with the text after restart."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "fixture_echo"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"echo\": \"after restart\", \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"read_only\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "fixture_echo",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"The DSH tool ran after restart.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-1e18a0da1790b11f.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-1e18a0da1790b11f.cassette.json
new file mode 100644
index 00000000..7757747e
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-1e18a0da1790b11f.cassette.json
@@ -0,0 +1,60 @@
+{
+  "fingerprint": "1e18a0da1790b11fd0b5ce2ba238b549c29b83cb800be8d85e67261a8d35b4a4",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **fixture_echo**(text): Return the supplied text from a pre-built DSH package.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Installed the hermetic DSH plugin.\n- [user] Invoke fixture_echo with the text before restart.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Invoke fixture_echo with the text before restart.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Installed the hermetic DSH plugin."
+      },
+      {
+        "role": "user",
+        "content": "Invoke fixture_echo with the text before restart.\nInvoke fixture_echo with the text before restart."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "fixture_echo",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"fixture_echo\", \"arguments\": \"{\\\"text\\\": \\\"before restart\\\"}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-30b7ab3ad4a5a107.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-30b7ab3ad4a5a107.cassette.json
new file mode 100644
index 00000000..cdf005e6
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-30b7ab3ad4a5a107.cassette.json
@@ -0,0 +1,60 @@
+{
+  "fingerprint": "30b7ab3ad4a5a1071809626dd70071cb5a3a8216ed7ba5ba0f391cf58e05179f",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The isolated sandbox smoke test runs later, at install-time. Returns the validated code but DOES NOT install it — installation is a separate approval-gated step via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **fixture_echo**(text): Return the supplied text from a pre-built DSH package.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Installed the hermetic DSH plugin.\n- [user] Invoke fixture_echo with the text before restart.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Invoke fixture_echo with the text before restart.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Installed the hermetic DSH plugin."
+      },
+      {
+        "role": "user",
+        "content": "Invoke fixture_echo with the text before restart.\nInvoke fixture_echo with the text before restart."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "fixture_echo",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"fixture_echo\", \"arguments\": \"{\\\"text\\\": \\\"before restart\\\"}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-3798e4163d6b2128.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-3798e4163d6b2128.cassette.json
new file mode 100644
index 00000000..fe4d2818
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-3798e4163d6b2128.cassette.json
@@ -0,0 +1,56 @@
+{
+  "fingerprint": "3798e4163d6b21284618d883782d25a4605f6f7ee2d54c047bb71ea3635db16f",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The isolated sandbox smoke test runs later, at install-time. Returns the validated code but DOES NOT install it — installation is a separate approval-gated step via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **fixture_echo**(text): Return the supplied text from a pre-built DSH package.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Invoke fixture_echo with the text after restart.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Invoke fixture_echo with the text after restart.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Invoke fixture_echo with the text after restart.\nInvoke fixture_echo with the text after restart."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "fixture_echo",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"fixture_echo\", \"arguments\": \"{\\\"text\\\": \\\"after restart\\\"}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-4d1f12200292b229.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-4d1f12200292b229.cassette.json
new file mode 100644
index 00000000..bf20443a
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-4d1f12200292b229.cassette.json
@@ -0,0 +1,60 @@
+{
+  "fingerprint": "4d1f12200292b229783742bfd980e4922919dfd94be402a09fe76bc80f243899",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **fixture_echo**(text): Return the supplied text from a pre-built DSH package.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] The DSH tool ran after restart.\n- [user] Remove the hermetic DSH echo plugin completely.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Remove the hermetic DSH echo plugin completely.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "The DSH tool ran after restart."
+      },
+      {
+        "role": "user",
+        "content": "Remove the hermetic DSH echo plugin completely.\nRemove the hermetic DSH echo plugin completely."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "fixture_echo",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"plugin_remove\", \"arguments\": \"{\\\"plugin_id\\\": \\\"r6_dsh_echo\\\", \\\"delete_source\\\": true}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-898001f1b5122a8a.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-898001f1b5122a8a.cassette.json
new file mode 100644
index 00000000..be863115
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-898001f1b5122a8a.cassette.json
@@ -0,0 +1,71 @@
+{
+  "fingerprint": "898001f1b5122a8aefedd1329646046f49a652cea721d87b6fa9fe1d5e106eee",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Install the hermetic DSH echo plugin from this workspace.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Install the hermetic DSH echo plugin from this workspace.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Install the hermetic DSH echo plugin from this workspace.\nInstall the hermetic DSH echo plugin from this workspace."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "plugin_install"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"action\": \"install\", \"plugin_id\": \"r6_dsh_echo\", \"installed_tools\": [\"fixture_echo\"], \"state\": \"active\", \"version\": \"r6\", \"source_kind\": \"dsh_package\", \"bundle_sha256\": \"<HEX>\", \"descriptor_path\": \"<TMP>\", \"verdict\": \"adaptable\", \"limitations\": [], \"client_components\": [], \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"mutating_once\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Installed the hermetic DSH plugin.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-a7782cf136290032.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-a7782cf136290032.cassette.json
new file mode 100644
index 00000000..34d6a6a3
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-a7782cf136290032.cassette.json
@@ -0,0 +1,55 @@
+{
+  "fingerprint": "a7782cf1362900327b43e19b0f1193e2e3ea915c3b60ba84b5607896e87afeaa",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Install the hermetic DSH echo plugin from this workspace.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Install the hermetic DSH echo plugin from this workspace.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Install the hermetic DSH echo plugin from this workspace.\nInstall the hermetic DSH echo plugin from this workspace."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"plugin_install\", \"arguments\": \"{\\\"plugin_id\\\": \\\"r6_dsh_echo\\\", \\\"source_path\\\": \\\"/tmp/lfj-r6_lifecycle/workspaces/life/dsh-echo\\\", \\\"version_label\\\": \\\"r6\\\"}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-ada1fc7ddc57492e.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-ada1fc7ddc57492e.cassette.json
new file mode 100644
index 00000000..7cb99854
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-ada1fc7ddc57492e.cassette.json
@@ -0,0 +1,76 @@
+{
+  "fingerprint": "ada1fc7ddc57492ea2c39ad8617214214852c9cc6d84ab011e74a57aa6c823d2",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The isolated sandbox smoke test runs later, at install-time. Returns the validated code but DOES NOT install it — installation is a separate approval-gated step via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **fixture_echo**(text): Return the supplied text from a pre-built DSH package.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] The DSH tool ran after restart.\n- [user] Remove the hermetic DSH echo plugin completely.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Remove the hermetic DSH echo plugin completely.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "The DSH tool ran after restart."
+      },
+      {
+        "role": "user",
+        "content": "Remove the hermetic DSH echo plugin completely.\nRemove the hermetic DSH echo plugin completely."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "plugin_remove"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"action\": \"remove\", \"plugin_id\": \"r6_dsh_echo\", \"state\": \"disposed\", \"source_path\": \"<TMP>\", \"source_deleted\": true, \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"mutating_once\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "fixture_echo",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Removed the hermetic DSH plugin.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-b5a61ebb6aabdcfb.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-b5a61ebb6aabdcfb.cassette.json
new file mode 100644
index 00000000..78d9c197
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-b5a61ebb6aabdcfb.cassette.json
@@ -0,0 +1,76 @@
+{
+  "fingerprint": "b5a61ebb6aabdcfb41ddc9528feeae96325bba26f0b828ddfd0cccc0bc2e63ef",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The isolated sandbox smoke test runs later, at install-time. Returns the validated code but DOES NOT install it — installation is a separate approval-gated step via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **fixture_echo**(text): Return the supplied text from a pre-built DSH package.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Installed the hermetic DSH plugin.\n- [user] Invoke fixture_echo with the text before restart.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Invoke fixture_echo with the text before restart.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Installed the hermetic DSH plugin."
+      },
+      {
+        "role": "user",
+        "content": "Invoke fixture_echo with the text before restart.\nInvoke fixture_echo with the text before restart."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "fixture_echo"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"echo\": \"before restart\", \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"read_only\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "fixture_echo",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"The DSH tool ran before restart.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-b9831df577183d53.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-b9831df577183d53.cassette.json
new file mode 100644
index 00000000..0e261b35
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-b9831df577183d53.cassette.json
@@ -0,0 +1,60 @@
+{
+  "fingerprint": "b9831df577183d531ff66444d95913bb830d92fb027bd4d21de3dbae41a80cbd",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The isolated sandbox smoke test runs later, at install-time. Returns the validated code but DOES NOT install it — installation is a separate approval-gated step via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **fixture_echo**(text): Return the supplied text from a pre-built DSH package.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] The DSH tool ran after restart.\n- [user] Remove the hermetic DSH echo plugin completely.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Remove the hermetic DSH echo plugin completely.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "The DSH tool ran after restart."
+      },
+      {
+        "role": "user",
+        "content": "Remove the hermetic DSH echo plugin completely.\nRemove the hermetic DSH echo plugin completely."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "fixture_echo",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"plugin_remove\", \"arguments\": \"{\\\"plugin_id\\\": \\\"r6_dsh_echo\\\", \\\"delete_source\\\": true}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-c0ef153884a21ac7.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-c0ef153884a21ac7.cassette.json
new file mode 100644
index 00000000..bbde7feb
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-c0ef153884a21ac7.cassette.json
@@ -0,0 +1,72 @@
+{
+  "fingerprint": "c0ef153884a21ac7026067d0d3307b85a005005173f88a3a4b6ae77cab3adcb1",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The isolated sandbox smoke test runs later, at install-time. Returns the validated code but DOES NOT install it — installation is a separate approval-gated step via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **fixture_echo**(text): Return the supplied text from a pre-built DSH package.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Invoke fixture_echo with the text after restart.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Invoke fixture_echo with the text after restart.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Invoke fixture_echo with the text after restart.\nInvoke fixture_echo with the text after restart."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "fixture_echo"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"echo\": \"after restart\", \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"read_only\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "fixture_echo",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"The DSH tool ran after restart.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-d352b6f5b033a2d7.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-d352b6f5b033a2d7.cassette.json
new file mode 100644
index 00000000..550f597b
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-d352b6f5b033a2d7.cassette.json
@@ -0,0 +1,56 @@
+{
+  "fingerprint": "d352b6f5b033a2d7103824567c0db6ead185ec01ec155a5da8032ccb4745794d",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **fixture_echo**(text): Return the supplied text from a pre-built DSH package.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Invoke fixture_echo with the text after restart.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Invoke fixture_echo with the text after restart.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Invoke fixture_echo with the text after restart.\nInvoke fixture_echo with the text after restart."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "fixture_echo",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"fixture_echo\", \"arguments\": \"{\\\"text\\\": \\\"after restart\\\"}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-e6109a845a1dd79f.cassette.json b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-e6109a845a1dd79f.cassette.json
new file mode 100644
index 00000000..08992daf
--- /dev/null
+++ b/tests/_fixtures/cassettes/r6_lifecycle/cassette-model-e6109a845a1dd79f.cassette.json
@@ -0,0 +1,76 @@
+{
+  "fingerprint": "e6109a845a1dd79fc8f5b1d5b3518fdbecccbad0b7a860e3e5758ea99acb0b88",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **fixture_echo**(text): Return the supplied text from a pre-built DSH package.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] The DSH tool ran after restart.\n- [user] Remove the hermetic DSH echo plugin completely.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Remove the hermetic DSH echo plugin completely.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "The DSH tool ran after restart."
+      },
+      {
+        "role": "user",
+        "content": "Remove the hermetic DSH echo plugin completely.\nRemove the hermetic DSH echo plugin completely."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "plugin_remove"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"action\": \"remove\", \"plugin_id\": \"r6_dsh_echo\", \"state\": \"disposed\", \"source_path\": \"<TMP>\", \"source_deleted\": true, \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"mutating_once\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "fixture_echo",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Removed the hermetic DSH plugin.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-33afdab4bc90b747.cassette.json b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-33afdab4bc90b747.cassette.json
new file mode 100644
index 00000000..ef7f7438
--- /dev/null
+++ b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-33afdab4bc90b747.cassette.json
@@ -0,0 +1,119 @@
+{
+  "fingerprint": "33afdab4bc90b747d65e3a9cf85c72291d0d6d0ec51f30ae861d76cf7c557696",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Try the missing_json_pretty_e2e tool so LeapFlow records a capability gap.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Try the missing_json_pretty_e2e tool so LeapFlow records a capability gap.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Try the missing_json_pretty_e2e tool so LeapFlow records a capability gap.\nTry the missing_json_pretty_e2e tool so LeapFlow records a capability gap."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "missing_json_pretty_e2e"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": false, \"error\": \"Unknown tool: missing_json_pretty_e2e\", \"error_type\": \"unknown_tool\", \"retryable\": true}",
+        "tool_result": true
+      },
+      {
+        "role": "user",
+        "content": "SYSTEM: The previous tool call used an unavailable tool name. Original tool: missing_json_pretty_e2e. Resolution: unknown (no exact canonical tool name match). Suggested canonical tools: text_search, text_replace, research_note, gateway_send. Available tools include: assess_compatibility, capability_expand, code_intel, code_search, config_get, config_list, config_set, delegate_task, edit_file, env_info, file_find, file_list. Retry once using an exact canonical tool name from the available list and valid arguments. Do not invent tool names, use aliases, or infer a tool from argument shape; answer without a tool if no exact tool fits."
+      }
+    ],
+    "tools": [
+      "assess_compatibility",
+      "capability_expand",
+      "click",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "config_set",
+      "delegate_task",
+      "edit_file",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "file_write",
+      "gateway_connect",
+      "gateway_send",
+      "get_clipboard",
+      "git_query",
+      "git_write",
+      "hub_pull",
+      "hub_push",
+      "hub_search",
+      "hub_sync",
+      "lint_check",
+      "list_apps",
+      "list_windows",
+      "memory_add",
+      "memory_search",
+      "observe_ui",
+      "open_url",
+      "platform_action",
+      "platform_connect",
+      "plugin_disable",
+      "plugin_enable",
+      "plugin_generate",
+      "plugin_install",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_reload",
+      "plugin_remove",
+      "plugin_rollback",
+      "plugin_status",
+      "plugin_versions",
+      "read_text",
+      "repo_map",
+      "research_note",
+      "right_click",
+      "schedule_reentry",
+      "scm_sync",
+      "screenshot",
+      "scroll",
+      "select_text",
+      "session_detail",
+      "session_list",
+      "session_search",
+      "set_clipboard",
+      "shell_run",
+      "shortcut",
+      "skill_view",
+      "skills_list",
+      "switch_app",
+      "terminal_close",
+      "terminal_list",
+      "terminal_open",
+      "terminal_read",
+      "terminal_send",
+      "test_run",
+      "text_replace",
+      "text_search",
+      "time_get",
+      "type_text",
+      "wait",
+      "wait_until",
+      "wait_until_stable",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Observed the missing JSON pretty tool.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-3705093e647723c3.cassette.json b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-3705093e647723c3.cassette.json
new file mode 100644
index 00000000..ad530977
--- /dev/null
+++ b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-3705093e647723c3.cassette.json
@@ -0,0 +1,55 @@
+{
+  "fingerprint": "3705093e647723c34866ef3db598960e617f8d1b97f0474419b2cddd5893ea97",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] Try the missing_json_pretty_e2e tool so LeapFlow records a capability gap.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: Try the missing_json_pretty_e2e tool so LeapFlow records a capability gap.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "Try the missing_json_pretty_e2e tool so LeapFlow records a capability gap.\nTry the missing_json_pretty_e2e tool so LeapFlow records a capability gap."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"missing_json_pretty_e2e\", \"arguments\": \"{\\\"text\\\": \\\"{\\\\\\\"b\\\\\\\":2,\\\\\\\"a\\\\\\\":1}\\\"}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-38aa0b5a67f18052.cassette.json b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-38aa0b5a67f18052.cassette.json
new file mode 100644
index 00000000..391d357b
--- /dev/null
+++ b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-38aa0b5a67f18052.cassette.json
@@ -0,0 +1,75 @@
+{
+  "fingerprint": "38aa0b5a67f18052205e955bbcc792a94b07393d88c87abe9f0c441f42a61360",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The isolated sandbox smoke test runs later, at install-time. Returns the validated code but DOES NOT install it — installation is a separate approval-gated step via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Observed the missing JSON pretty tool.\n- [user] Install the prepared adaptive JSON pretty plugin.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Install the prepared adaptive JSON pretty plugin.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Observed the missing JSON pretty tool."
+      },
+      {
+        "role": "user",
+        "content": "Install the prepared adaptive JSON pretty plugin.\nInstall the prepared adaptive JSON pretty plugin."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "plugin_install"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"action\": \"install\", \"plugin_id\": \"json_pretty_loop_e2e\", \"installed_tools\": [\"json_pretty_loop_e2e\"], \"state\": \"active\", \"shadow_validated\": true, \"behavior_tests\": [], \"version\": \"r7\", \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"mutating_once\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Installed json pretty plugin.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-6dccb60364d7af34.cassette.json b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-6dccb60364d7af34.cassette.json
new file mode 100644
index 00000000..102d0b0e
--- /dev/null
+++ b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-6dccb60364d7af34.cassette.json
@@ -0,0 +1,75 @@
+{
+  "fingerprint": "6dccb60364d7af34bb7860a3b8b520d3a9a6c918d52005f88c07d652d4cdae19",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Formatted JSON with the new plugin.\n- [user] Remove the adaptive JSON pretty plugin completely.\n\n## Task Contract\n- Task ID: turn-4\n- Original user request: Remove the adaptive JSON pretty plugin completely.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Formatted JSON with the new plugin."
+      },
+      {
+        "role": "user",
+        "content": "Remove the adaptive JSON pretty plugin completely.\nRemove the adaptive JSON pretty plugin completely."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "plugin_remove"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"action\": \"remove\", \"plugin_id\": \"json_pretty_loop_e2e\", \"state\": \"disposed\", \"source_path\": \"<TMP>\", \"source_deleted\": true, \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"mutating_once\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Removed json pretty plugin.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-7ad0336ee1e5a800.cassette.json b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-7ad0336ee1e5a800.cassette.json
new file mode 100644
index 00000000..7c08e74f
--- /dev/null
+++ b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-7ad0336ee1e5a800.cassette.json
@@ -0,0 +1,75 @@
+{
+  "fingerprint": "7ad0336ee1e5a8003620f0862acb4ad3e2080ed88a25b12d0e658669822dde01",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Observed the missing JSON pretty tool.\n- [user] Install the prepared adaptive JSON pretty plugin.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Install the prepared adaptive JSON pretty plugin.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Observed the missing JSON pretty tool."
+      },
+      {
+        "role": "user",
+        "content": "Install the prepared adaptive JSON pretty plugin.\nInstall the prepared adaptive JSON pretty plugin."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "plugin_install"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"action\": \"install\", \"plugin_id\": \"json_pretty_loop_e2e\", \"installed_tools\": [\"json_pretty_loop_e2e\"], \"state\": \"active\", \"shadow_validated\": true, \"behavior_tests\": [], \"version\": \"r7\", \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"mutating_once\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Installed json pretty plugin.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-a690658cc3ac97da.cassette.json b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-a690658cc3ac97da.cassette.json
new file mode 100644
index 00000000..60c39411
--- /dev/null
+++ b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-a690658cc3ac97da.cassette.json
@@ -0,0 +1,59 @@
+{
+  "fingerprint": "a690658cc3ac97da7919ffdc944599034488b86701694741d7a6c7855c41c3f1",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Formatted JSON with the new plugin.\n- [user] Remove the adaptive JSON pretty plugin completely.\n\n## Task Contract\n- Task ID: turn-4\n- Original user request: Remove the adaptive JSON pretty plugin completely.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Formatted JSON with the new plugin."
+      },
+      {
+        "role": "user",
+        "content": "Remove the adaptive JSON pretty plugin completely.\nRemove the adaptive JSON pretty plugin completely."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"plugin_remove\", \"arguments\": \"{\\\"plugin_id\\\": \\\"json_pretty_loop_e2e\\\", \\\"delete_source\\\": true}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-b5283e275ca539f0.cassette.json b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-b5283e275ca539f0.cassette.json
new file mode 100644
index 00000000..a69f52a1
--- /dev/null
+++ b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-b5283e275ca539f0.cassette.json
@@ -0,0 +1,59 @@
+{
+  "fingerprint": "b5283e275ca539f0b4e6123b04912d1a3dba5d6cc246f302418596379c115978",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Observed the missing JSON pretty tool.\n- [user] Install the prepared adaptive JSON pretty plugin.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Install the prepared adaptive JSON pretty plugin.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Observed the missing JSON pretty tool."
+      },
+      {
+        "role": "user",
+        "content": "Install the prepared adaptive JSON pretty plugin.\nInstall the prepared adaptive JSON pretty plugin."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"plugin_install\", \"arguments\": \"{\\\"plugin_id\\\": \\\"json_pretty_loop_e2e\\\", \\\"code\\\": \\\"from __future__ import annotations\\\\n\\\\nimport json\\\\nfrom typing import Any\\\\n\\\\nfrom leapflow.plugins.protocol import ToolMetadata\\\\n\\\\n\\\\nasync def json_pretty_loop_e2e(text: str = \\\\\\\"\\\\\\\", **kwargs: Any) -> dict[str, Any]:\\\\n    payload = text or kwargs.get(\\\\\\\"payload\\\\\\\") or \\\\\\\"{}\\\\\\\"\\\\n    try:\\\\n        parsed = json.loads(str(payload))\\\\n    except json.JSONDecodeError as exc:\\\\n        return {\\\\\\\"ok\\\\\\\": False, \\\\\\\"error\\\\\\\": str(exc)}\\\\n    return {\\\\\\\"ok\\\\\\\": True, \\\\\\\"content\\\\\\\": json.dumps(parsed, ensure_ascii=False, indent=2, sort_keys=True)}\\\\n\\\\n\\\\nclass JsonPrettyLoopE2EPlugin:\\\\n    @property\\\\n    def plugin_id(self) -> str:\\\\n        return \\\\\\\"json_pretty_loop_e2e\\\\\\\"\\\\n\\\\n    @property\\\\n    def category(self) -> str:\\\\n        return \\\\\\\"formatting\\\\\\\"\\\\n\\\\n    @property\\\\n    def dependencies(self) -> list[str]:\\\\n        return []\\\\n\\\\n    @property\\\\n    def tools(self) -> list[ToolMetadata]:\\\\n        return [\\\\n            ToolMetadata(\\\\n                name=\\\\\\\"json_pretty_loop_e2e\\\\\\\",\\\\n                description=\\\\\\\"Pretty-print JSON for the adaptive closed-loop journey.\\\\\\\",\\\\n                parameters_schema={\\\\n                    \\\\\\\"type\\\\\\\": \\\\\\\"object\\\\\\\",\\\\n                    \\\\\\\"properties\\\\\\\": {\\\\n                        \\\\\\\"text\\\\\\\": {\\\\\\\"type\\\\\\\": \\\\\\\"string\\\\\\\", \\\\\\\"description\\\\\\\": \\\\\\\"JSON text to format\\\\\\\"}\\\\n                    },\\\\n                },\\\\n                handler=json_pretty_loop_e2e,\\\\n                x_leapflow={\\\\n                    \\\\\\\"category\\\\\\\": \\\\\\\"formatting\\\\\\\",\\\\n                    \\\\\\\"risk_level\\\\\\\": \\\\\\\"read_only\\\\\\\",\\\\n                    \\\\\\\"schema_cost\\\\\\\": \\\\\\\"low\\\\\\\",\\\\n                    \\\\\\\"requires_approval\\\\\\\": False,\\\\n                },\\\\n                provides_capabilities=(\\\\\\\"json.pretty\\\\\\\",),\\\\n                requires_platform_capabilities=(\\\\\\\"file.ops\\\\\\\",),\\\\n            )\\\\n        ]\\\\n\\\\n    def bind_runtime(self, **deps: Any) -> None:\\\\n        return None\\\\n\\\\n\\\\nplugin = JsonPrettyLoopE2EPlugin()\\\\n\\\", \\\"version_label\\\": \\\"r7\\\"}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-cc5cd4f23919fe0b.cassette.json b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-cc5cd4f23919fe0b.cassette.json
new file mode 100644
index 00000000..14bdfec1
--- /dev/null
+++ b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-cc5cd4f23919fe0b.cassette.json
@@ -0,0 +1,76 @@
+{
+  "fingerprint": "cc5cd4f23919fe0beddc3a44d9f40eb55a54c02f0c5522000c18230d1d69ade0",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **json_pretty_loop_e2e**(text): Pretty-print JSON for the adaptive closed-loop journey.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Installed json pretty plugin.\n- [user] Use the json_pretty_loop_e2e tool to format the sample JSON.\n\n## Task Contract\n- Task ID: turn-3\n- Original user request: Use the json_pretty_loop_e2e tool to format the sample JSON.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Installed json pretty plugin."
+      },
+      {
+        "role": "user",
+        "content": "Use the json_pretty_loop_e2e tool to format the sample JSON.\nUse the json_pretty_loop_e2e tool to format the sample JSON."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "json_pretty_loop_e2e"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"content\": \"{\\n  \\\"a\\\": 1,\\n  \\\"b\\\": 2\\n}\", \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"read_only\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "json_pretty_loop_e2e",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Formatted JSON with the new plugin.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-d6eb6c82ef17961b.cassette.json b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-d6eb6c82ef17961b.cassette.json
new file mode 100644
index 00000000..91c49003
--- /dev/null
+++ b/tests/_fixtures/cassettes/r7_adaptive_plugin_loop/cassette-model-d6eb6c82ef17961b.cassette.json
@@ -0,0 +1,60 @@
+{
+  "fingerprint": "d6eb6c82ef17961be90a9e34b95aaf82889ba27326e7f7579d3db13773ba700b",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **json_pretty_loop_e2e**(text): Pretty-print JSON for the adaptive closed-loop journey.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [assistant] Installed json pretty plugin.\n- [user] Use the json_pretty_loop_e2e tool to format the sample JSON.\n\n## Task Contract\n- Task ID: turn-3\n- Original user request: Use the json_pretty_loop_e2e tool to format the sample JSON.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Installed json pretty plugin."
+      },
+      {
+        "role": "user",
+        "content": "Use the json_pretty_loop_e2e tool to format the sample JSON.\nUse the json_pretty_loop_e2e tool to format the sample JSON."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "json_pretty_loop_e2e",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"json_pretty_loop_e2e\", \"arguments\": \"{\\\"text\\\": \\\"{\\\\\\\"b\\\\\\\":2,\\\\\\\"a\\\\\\\":1}\\\"}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r8_hardware/cassette-model-14785ee2b98ad8a2.cassette.json b/tests/_fixtures/cassettes/r8_hardware/cassette-model-14785ee2b98ad8a2.cassette.json
new file mode 100644
index 00000000..191fc3d5
--- /dev/null
+++ b/tests/_fixtures/cassettes/r8_hardware/cassette-model-14785ee2b98ad8a2.cassette.json
@@ -0,0 +1,59 @@
+{
+  "fingerprint": "14785ee2b98ad8a23306b054cfb4fc576b713824f5a5e33c9bd201ac7d8cf191",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **hw_list**(): List connected hardware devices with their channel counts and measured quantities. Start here; it does not include operating limits.\n- **hw_describe**(device_id): Return the full reference for one device: every channel, its unit, its operating envelope, rate limit, reversibility, and required interlocks, plus any prior outcomes recorded for its writable channels. Required before commanding a device.\n- **hw_read**(device_id, channel_id): Read the current value of one device channel. Has no physical effect.\n- **hw_status**(device_id): Report connection health, halt capability, and recent notable events (threshold excursions, lost samples, stalled channels) for one device.\n- **hw_configure**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Set a configuration value or setpoint on a channel declaring effect=configure. Setpoints often have inertia: the value may need time to stabilise.\n- **hw_actuate**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Command motion or output on a channel declaring effect=actuate. This moves physical hardware; a repeat from an unknown state is not a safe retry.\n- **hw_dispense**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Consume an irreversible resource on a channel declaring effect=dispense. Running this twice dispenses twice; never repeat it after a failure without first verifying what already happened.\n- **hw_estop**(device_id) [capability_expand category: hardware]: Stop all motion and output on a device immediately. Never requires approval; use it whenever device behaviour is unexpected.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] List the connected hardware devices, then describe bench_r8 in full.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: List the connected hardware devices, then describe bench_r8 in full.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "List the connected hardware devices, then describe bench_r8 in full.\nList the connected hardware devices, then describe bench_r8 in full."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "hw_describe",
+      "hw_list",
+      "hw_read",
+      "hw_status",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"hw_list\", \"arguments\": \"{}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r8_hardware/cassette-model-2ecead8ad64bd2b2.cassette.json b/tests/_fixtures/cassettes/r8_hardware/cassette-model-2ecead8ad64bd2b2.cassette.json
new file mode 100644
index 00000000..a5fcfd03
--- /dev/null
+++ b/tests/_fixtures/cassettes/r8_hardware/cassette-model-2ecead8ad64bd2b2.cassette.json
@@ -0,0 +1,75 @@
+{
+  "fingerprint": "2ecead8ad64bd2b26def688b4f518f774c0016919e61b42b957c5eda506196c9",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **hw_list**(): List connected hardware devices with their channel counts and measured quantities. Start here; it does not include operating limits.\n- **hw_describe**(device_id): Return the full reference for one device: every channel, its unit, its operating envelope, rate limit, reversibility, and required interlocks, plus any prior outcomes recorded for its writable channels. Required before commanding a device.\n- **hw_read**(device_id, channel_id): Read the current value of one device channel. Has no physical effect.\n- **hw_status**(device_id): Report connection health, halt capability, and recent notable events (threshold excursions, lost samples, stalled channels) for one device.\n- **hw_configure**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Set a configuration value or setpoint on a channel declaring effect=configure. Setpoints often have inertia: the value may need time to stabilise.\n- **hw_actuate**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Command motion or output on a channel declaring effect=actuate. This moves physical hardware; a repeat from an unknown state is not a safe retry.\n- **hw_dispense**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Consume an irreversible resource on a channel declaring effect=dispense. Running this twice dispenses twice; never repeat it after a failure without first verifying what already happened.\n- **hw_estop**(device_id) [capability_expand category: hardware]: Stop all motion and output on a device immediately. Never requires approval; use it whenever device behaviour is unexpected.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n## Task Contract\n- Task ID: turn-4\n- Original user request: Configure the bench_r8 homed channel to true to complete homing.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Discovered the simulated bench and read its channel limits."
+      },
+      {
+        "role": "user",
+        "content": "Read the current value of the setpoint channel on bench_r8."
+      },
+      {
+        "role": "assistant",
+        "content": "[Called: hw_read]\nRead the setpoint channel."
+      },
+      {
+        "role": "user",
+        "content": "Actuate the bench_r8 setpoint to 60.\nConfigure the bench_r8 homed channel to true to complete homing.\nConfigure the bench_r8 homed channel to true to complete homing."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "hw_actuate",
+      "hw_configure",
+      "hw_describe",
+      "hw_dispense",
+      "hw_estop",
+      "hw_list",
+      "hw_read",
+      "hw_status",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"hw_configure\", \"arguments\": \"{\\\"device_id\\\": \\\"bench_r8\\\", \\\"channel_id\\\": \\\"homed\\\", \\\"value\\\": true}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r8_hardware/cassette-model-3253e1220413e5f3.cassette.json b/tests/_fixtures/cassettes/r8_hardware/cassette-model-3253e1220413e5f3.cassette.json
new file mode 100644
index 00000000..9a321fe3
--- /dev/null
+++ b/tests/_fixtures/cassettes/r8_hardware/cassette-model-3253e1220413e5f3.cassette.json
@@ -0,0 +1,75 @@
+{
+  "fingerprint": "3253e1220413e5f3bd0ab56097dc4972da20136aaeb691fd7a305a79f3687c6b",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **hw_list**(): List connected hardware devices with their channel counts and measured quantities. Start here; it does not include operating limits.\n- **hw_describe**(device_id): Return the full reference for one device: every channel, its unit, its operating envelope, rate limit, reversibility, and required interlocks, plus any prior outcomes recorded for its writable channels. Required before commanding a device.\n- **hw_read**(device_id, channel_id): Read the current value of one device channel. Has no physical effect.\n- **hw_status**(device_id): Report connection health, halt capability, and recent notable events (threshold excursions, lost samples, stalled channels) for one device.\n- **hw_configure**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Set a configuration value or setpoint on a channel declaring effect=configure. Setpoints often have inertia: the value may need time to stabilise.\n- **hw_actuate**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Command motion or output on a channel declaring effect=actuate. This moves physical hardware; a repeat from an unknown state is not a safe retry.\n- **hw_dispense**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Consume an irreversible resource on a channel declaring effect=dispense. Running this twice dispenses twice; never repeat it after a failure without first verifying what already happened.\n- **hw_estop**(device_id) [capability_expand category: hardware]: Stop all motion and output on a device immediately. Never requires approval; use it whenever device behaviour is unexpected.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n## Task Contract\n- Task ID: turn-5\n- Original user request: Preview an actuate of bench_r8 setpoint to 55, dry run only.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Read the setpoint channel."
+      },
+      {
+        "role": "user",
+        "content": "Actuate the bench_r8 setpoint to 60.\nConfigure the bench_r8 homed channel to true to complete homing."
+      },
+      {
+        "role": "assistant",
+        "content": "[Called: hw_configure]\nHomed the device; the readiness gate is now satisfied."
+      },
+      {
+        "role": "user",
+        "content": "Preview an actuate of bench_r8 setpoint to 55, dry run only.\nPreview an actuate of bench_r8 setpoint to 55, dry run only."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "hw_actuate",
+      "hw_configure",
+      "hw_describe",
+      "hw_dispense",
+      "hw_estop",
+      "hw_list",
+      "hw_read",
+      "hw_status",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"hw_actuate\", \"arguments\": \"{\\\"device_id\\\": \\\"bench_r8\\\", \\\"channel_id\\\": \\\"setpoint\\\", \\\"value\\\": 55.0, \\\"dry_run\\\": true}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r8_hardware/cassette-model-3dc49087c1103fb6.cassette.json b/tests/_fixtures/cassettes/r8_hardware/cassette-model-3dc49087c1103fb6.cassette.json
new file mode 100644
index 00000000..1336bfc2
--- /dev/null
+++ b/tests/_fixtures/cassettes/r8_hardware/cassette-model-3dc49087c1103fb6.cassette.json
@@ -0,0 +1,87 @@
+{
+  "fingerprint": "3dc49087c1103fb60c64d4ae4800585a6bbf6f061370bcc4481e42695aa0473b",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **hw_list**(): List connected hardware devices with their channel counts and measured quantities. Start here; it does not include operating limits.\n- **hw_describe**(device_id): Return the full reference for one device: every channel, its unit, its operating envelope, rate limit, reversibility, and required interlocks, plus any prior outcomes recorded for its writable channels. Required before commanding a device.\n- **hw_read**(device_id, channel_id): Read the current value of one device channel. Has no physical effect.\n- **hw_status**(device_id): Report connection health, halt capability, and recent notable events (threshold excursions, lost samples, stalled channels) for one device.\n- **hw_configure**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Set a configuration value or setpoint on a channel declaring effect=configure. Setpoints often have inertia: the value may need time to stabilise.\n- **hw_actuate**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Command motion or output on a channel declaring effect=actuate. This moves physical hardware; a repeat from an unknown state is not a safe retry.\n- **hw_dispense**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Consume an irreversible resource on a channel declaring effect=dispense. Running this twice dispenses twice; never repeat it after a failure without first verifying what already happened.\n- **hw_estop**(device_id) [capability_expand category: hardware]: Stop all motion and output on a device immediately. Never requires approval; use it whenever device behaviour is unexpected.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] List the connected hardware devices, then describe bench_r8 in full.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: List the connected hardware devices, then describe bench_r8 in full.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "List the connected hardware devices, then describe bench_r8 in full.\nList the connected hardware devices, then describe bench_r8 in full."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "hw_list"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"devices\": [{\"device_id\": \"bench_r8\", \"display_name\": \"R8 Simulated Bench\", \"location\": \"journey-lab\", \"channels\": 3, \"writable\": 2, \"streaming\": 1, \"quantities\": [\"state.homed\", \"temperature\"], \"verified\": true, \"halt_supported\": true}], \"count\": 1, \"hint\": \"Call hw_describe(device_id) for channel limits before commanding a device.\", \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"read_only\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "hw_describe"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"kind\": \"\", \"truncated\": true, \"original_chars\": 846, \"budget_chars\": 819}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "hw_describe",
+      "hw_list",
+      "hw_read",
+      "hw_status",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Discovered the simulated bench and read its channel limits.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r8_hardware/cassette-model-5be074139ef16c9a.cassette.json b/tests/_fixtures/cassettes/r8_hardware/cassette-model-5be074139ef16c9a.cassette.json
new file mode 100644
index 00000000..f2953ea5
--- /dev/null
+++ b/tests/_fixtures/cassettes/r8_hardware/cassette-model-5be074139ef16c9a.cassette.json
@@ -0,0 +1,75 @@
+{
+  "fingerprint": "5be074139ef16c9ada53b1bf68e92e1961f1b37badb7ec65f1cb7ffb6e4dc98c",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **hw_list**(): List connected hardware devices with their channel counts and measured quantities. Start here; it does not include operating limits.\n- **hw_describe**(device_id): Return the full reference for one device: every channel, its unit, its operating envelope, rate limit, reversibility, and required interlocks, plus any prior outcomes recorded for its writable channels. Required before commanding a device.\n- **hw_read**(device_id, channel_id): Read the current value of one device channel. Has no physical effect.\n- **hw_status**(device_id): Report connection health, halt capability, and recent notable events (threshold excursions, lost samples, stalled channels) for one device.\n- **hw_configure**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Set a configuration value or setpoint on a channel declaring effect=configure. Setpoints often have inertia: the value may need time to stabilise.\n- **hw_actuate**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Command motion or output on a channel declaring effect=actuate. This moves physical hardware; a repeat from an unknown state is not a safe retry.\n- **hw_dispense**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Consume an irreversible resource on a channel declaring effect=dispense. Running this twice dispenses twice; never repeat it after a failure without first verifying what already happened.\n- **hw_estop**(device_id) [capability_expand category: hardware]: Stop all motion and output on a device immediately. Never requires approval; use it whenever device behaviour is unexpected.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n## Task Contract\n- Task ID: turn-6\n- Original user request: Actuate the bench_r8 setpoint to 65.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "[Called: hw_configure]\nHomed the device; the readiness gate is now satisfied."
+      },
+      {
+        "role": "user",
+        "content": "Preview an actuate of bench_r8 setpoint to 55, dry run only."
+      },
+      {
+        "role": "assistant",
+        "content": "[Called: hw_actuate]\nDry run confirmed the setpoint command is feasible after homing."
+      },
+      {
+        "role": "user",
+        "content": "Actuate the bench_r8 setpoint to 65.\nActuate the bench_r8 setpoint to 65."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "hw_actuate",
+      "hw_configure",
+      "hw_describe",
+      "hw_dispense",
+      "hw_estop",
+      "hw_list",
+      "hw_read",
+      "hw_status",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"hw_actuate\", \"arguments\": \"{\\\"device_id\\\": \\\"bench_r8\\\", \\\"channel_id\\\": \\\"setpoint\\\", \\\"value\\\": 65.0}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r8_hardware/cassette-model-5fa148b50481fec6.cassette.json b/tests/_fixtures/cassettes/r8_hardware/cassette-model-5fa148b50481fec6.cassette.json
new file mode 100644
index 00000000..0873c5db
--- /dev/null
+++ b/tests/_fixtures/cassettes/r8_hardware/cassette-model-5fa148b50481fec6.cassette.json
@@ -0,0 +1,75 @@
+{
+  "fingerprint": "5fa148b50481fec6028d1ae0e8ed1ca7486accd1d30936d11e537af1df2cb6fe",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **hw_list**(): List connected hardware devices with their channel counts and measured quantities. Start here; it does not include operating limits.\n- **hw_describe**(device_id): Return the full reference for one device: every channel, its unit, its operating envelope, rate limit, reversibility, and required interlocks, plus any prior outcomes recorded for its writable channels. Required before commanding a device.\n- **hw_read**(device_id, channel_id): Read the current value of one device channel. Has no physical effect.\n- **hw_status**(device_id): Report connection health, halt capability, and recent notable events (threshold excursions, lost samples, stalled channels) for one device.\n- **hw_configure**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Set a configuration value or setpoint on a channel declaring effect=configure. Setpoints often have inertia: the value may need time to stabilise.\n- **hw_actuate**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Command motion or output on a channel declaring effect=actuate. This moves physical hardware; a repeat from an unknown state is not a safe retry.\n- **hw_dispense**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Consume an irreversible resource on a channel declaring effect=dispense. Running this twice dispenses twice; never repeat it after a failure without first verifying what already happened.\n- **hw_estop**(device_id) [capability_expand category: hardware]: Stop all motion and output on a device immediately. Never requires approval; use it whenever device behaviour is unexpected.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n## Task Contract\n- Task ID: turn-3\n- Original user request: Actuate the bench_r8 setpoint to 60.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "[Called: hw_describe]\nDiscovered the simulated bench and read its channel limits."
+      },
+      {
+        "role": "user",
+        "content": "Read the current value of the setpoint channel on bench_r8."
+      },
+      {
+        "role": "assistant",
+        "content": "[Called: hw_read]\nRead the setpoint channel."
+      },
+      {
+        "role": "user",
+        "content": "Actuate the bench_r8 setpoint to 60.\nActuate the bench_r8 setpoint to 60."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "hw_actuate",
+      "hw_configure",
+      "hw_describe",
+      "hw_dispense",
+      "hw_estop",
+      "hw_list",
+      "hw_read",
+      "hw_status",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"hw_actuate\", \"arguments\": \"{\\\"device_id\\\": \\\"bench_r8\\\", \\\"channel_id\\\": \\\"setpoint\\\", \\\"value\\\": 60.0}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r8_hardware/cassette-model-63f72b6ae055dd95.cassette.json b/tests/_fixtures/cassettes/r8_hardware/cassette-model-63f72b6ae055dd95.cassette.json
new file mode 100644
index 00000000..b05195ac
--- /dev/null
+++ b/tests/_fixtures/cassettes/r8_hardware/cassette-model-63f72b6ae055dd95.cassette.json
@@ -0,0 +1,91 @@
+{
+  "fingerprint": "63f72b6ae055dd95c893468b4ffefd6388390f8b2149164290529e357fb830e2",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **hw_list**(): List connected hardware devices with their channel counts and measured quantities. Start here; it does not include operating limits.\n- **hw_describe**(device_id): Return the full reference for one device: every channel, its unit, its operating envelope, rate limit, reversibility, and required interlocks, plus any prior outcomes recorded for its writable channels. Required before commanding a device.\n- **hw_read**(device_id, channel_id): Read the current value of one device channel. Has no physical effect.\n- **hw_status**(device_id): Report connection health, halt capability, and recent notable events (threshold excursions, lost samples, stalled channels) for one device.\n- **hw_configure**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Set a configuration value or setpoint on a channel declaring effect=configure. Setpoints often have inertia: the value may need time to stabilise.\n- **hw_actuate**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Command motion or output on a channel declaring effect=actuate. This moves physical hardware; a repeat from an unknown state is not a safe retry.\n- **hw_dispense**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Consume an irreversible resource on a channel declaring effect=dispense. Running this twice dispenses twice; never repeat it after a failure without first verifying what already happened.\n- **hw_estop**(device_id) [capability_expand category: hardware]: Stop all motion and output on a device immediately. Never requires approval; use it whenever device behaviour is unexpected.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n## Task Contract\n- Task ID: turn-6\n- Original user request: Actuate the bench_r8 setpoint to 65.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "[Called: hw_configure]\nHomed the device; the readiness gate is now satisfied."
+      },
+      {
+        "role": "user",
+        "content": "Preview an actuate of bench_r8 setpoint to 55, dry run only."
+      },
+      {
+        "role": "assistant",
+        "content": "[Called: hw_actuate]\nDry run confirmed the setpoint command is feasible after homing."
+      },
+      {
+        "role": "user",
+        "content": "Actuate the bench_r8 setpoint to 65.\nActuate the bench_r8 setpoint to 65."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "hw_actuate"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"device_id\": \"bench_r8\", \"channel_id\": \"setpoint\", \"side_effect_state\": \"committed\", \"settled\": true, \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"external_side_effect\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "hw_actuate",
+      "hw_configure",
+      "hw_describe",
+      "hw_dispense",
+      "hw_estop",
+      "hw_list",
+      "hw_read",
+      "hw_status",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Commanded the setpoint through the approval path.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r8_hardware/cassette-model-6d0e8558c8ee265e.cassette.json b/tests/_fixtures/cassettes/r8_hardware/cassette-model-6d0e8558c8ee265e.cassette.json
new file mode 100644
index 00000000..85484540
--- /dev/null
+++ b/tests/_fixtures/cassettes/r8_hardware/cassette-model-6d0e8558c8ee265e.cassette.json
@@ -0,0 +1,71 @@
+{
+  "fingerprint": "6d0e8558c8ee265e8c0cb711015135a4af257d7c9888afde9d307bef7a3437e0",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **hw_list**(): List connected hardware devices with their channel counts and measured quantities. Start here; it does not include operating limits.\n- **hw_describe**(device_id): Return the full reference for one device: every channel, its unit, its operating envelope, rate limit, reversibility, and required interlocks, plus any prior outcomes recorded for its writable channels. Required before commanding a device.\n- **hw_read**(device_id, channel_id): Read the current value of one device channel. Has no physical effect.\n- **hw_status**(device_id): Report connection health, halt capability, and recent notable events (threshold excursions, lost samples, stalled channels) for one device.\n- **hw_configure**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Set a configuration value or setpoint on a channel declaring effect=configure. Setpoints often have inertia: the value may need time to stabilise.\n- **hw_actuate**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Command motion or output on a channel declaring effect=actuate. This moves physical hardware; a repeat from an unknown state is not a safe retry.\n- **hw_dispense**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Consume an irreversible resource on a channel declaring effect=dispense. Running this twice dispenses twice; never repeat it after a failure without first verifying what already happened.\n- **hw_estop**(device_id) [capability_expand category: hardware]: Stop all motion and output on a device immediately. Never requires approval; use it whenever device behaviour is unexpected.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Read the current value of the setpoint channel on bench_r8.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "List the connected hardware devices, then describe bench_r8 in full."
+      },
+      {
+        "role": "assistant",
+        "content": "[Called: hw_list]\n[Called: hw_describe]\nDiscovered the simulated bench and read its channel limits."
+      },
+      {
+        "role": "user",
+        "content": "Read the current value of the setpoint channel on bench_r8.\nRead the current value of the setpoint channel on bench_r8."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "hw_actuate",
+      "hw_configure",
+      "hw_describe",
+      "hw_dispense",
+      "hw_estop",
+      "hw_list",
+      "hw_read",
+      "hw_status",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"hw_read\", \"arguments\": \"{\\\"device_id\\\": \\\"bench_r8\\\", \\\"channel_id\\\": \\\"setpoint\\\"}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r8_hardware/cassette-model-81c3f24286673f15.cassette.json b/tests/_fixtures/cassettes/r8_hardware/cassette-model-81c3f24286673f15.cassette.json
new file mode 100644
index 00000000..549cb76e
--- /dev/null
+++ b/tests/_fixtures/cassettes/r8_hardware/cassette-model-81c3f24286673f15.cassette.json
@@ -0,0 +1,87 @@
+{
+  "fingerprint": "81c3f24286673f15c72d08fc203902ad75433208c60d3bf272ee606f5d8debed",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **hw_list**(): List connected hardware devices with their channel counts and measured quantities. Start here; it does not include operating limits.\n- **hw_describe**(device_id): Return the full reference for one device: every channel, its unit, its operating envelope, rate limit, reversibility, and required interlocks, plus any prior outcomes recorded for its writable channels. Required before commanding a device.\n- **hw_read**(device_id, channel_id): Read the current value of one device channel. Has no physical effect.\n- **hw_status**(device_id): Report connection health, halt capability, and recent notable events (threshold excursions, lost samples, stalled channels) for one device.\n- **hw_configure**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Set a configuration value or setpoint on a channel declaring effect=configure. Setpoints often have inertia: the value may need time to stabilise.\n- **hw_actuate**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Command motion or output on a channel declaring effect=actuate. This moves physical hardware; a repeat from an unknown state is not a safe retry.\n- **hw_dispense**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Consume an irreversible resource on a channel declaring effect=dispense. Running this twice dispenses twice; never repeat it after a failure without first verifying what already happened.\n- **hw_estop**(device_id) [capability_expand category: hardware]: Stop all motion and output on a device immediately. Never requires approval; use it whenever device behaviour is unexpected.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n## Task Contract\n- Task ID: turn-2\n- Original user request: Read the current value of the setpoint channel on bench_r8.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "List the connected hardware devices, then describe bench_r8 in full."
+      },
+      {
+        "role": "assistant",
+        "content": "[Called: hw_list]\n[Called: hw_describe]\nDiscovered the simulated bench and read its channel limits."
+      },
+      {
+        "role": "user",
+        "content": "Read the current value of the setpoint channel on bench_r8.\nRead the current value of the setpoint channel on bench_r8."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "hw_read"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"reading\": {\"device_id\": \"bench_r8\", \"channel_id\": \"setpoint\", \"value\": 50.0, \"quantity\": \"temperature\", \"unit\": \"C\", \"observed_at\": <TS>, \"sequence\": 1, \"quality\": \"ok\"}, \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"read_only\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "hw_actuate",
+      "hw_configure",
+      "hw_describe",
+      "hw_dispense",
+      "hw_estop",
+      "hw_list",
+      "hw_read",
+      "hw_status",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Read the setpoint channel.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r8_hardware/cassette-model-bb795810fcb3b193.cassette.json b/tests/_fixtures/cassettes/r8_hardware/cassette-model-bb795810fcb3b193.cassette.json
new file mode 100644
index 00000000..57fd14e0
--- /dev/null
+++ b/tests/_fixtures/cassettes/r8_hardware/cassette-model-bb795810fcb3b193.cassette.json
@@ -0,0 +1,91 @@
+{
+  "fingerprint": "bb795810fcb3b193ada6131d7c8ef89723d9973ce1fe1f38c0e24aaa0297beee",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **hw_list**(): List connected hardware devices with their channel counts and measured quantities. Start here; it does not include operating limits.\n- **hw_describe**(device_id): Return the full reference for one device: every channel, its unit, its operating envelope, rate limit, reversibility, and required interlocks, plus any prior outcomes recorded for its writable channels. Required before commanding a device.\n- **hw_read**(device_id, channel_id): Read the current value of one device channel. Has no physical effect.\n- **hw_status**(device_id): Report connection health, halt capability, and recent notable events (threshold excursions, lost samples, stalled channels) for one device.\n- **hw_configure**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Set a configuration value or setpoint on a channel declaring effect=configure. Setpoints often have inertia: the value may need time to stabilise.\n- **hw_actuate**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Command motion or output on a channel declaring effect=actuate. This moves physical hardware; a repeat from an unknown state is not a safe retry.\n- **hw_dispense**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Consume an irreversible resource on a channel declaring effect=dispense. Running this twice dispenses twice; never repeat it after a failure without first verifying what already happened.\n- **hw_estop**(device_id) [capability_expand category: hardware]: Stop all motion and output on a device immediately. Never requires approval; use it whenever device behaviour is unexpected.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n## Task Contract\n- Task ID: turn-5\n- Original user request: Preview an actuate of bench_r8 setpoint to 55, dry run only.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Read the setpoint channel."
+      },
+      {
+        "role": "user",
+        "content": "Actuate the bench_r8 setpoint to 60.\nConfigure the bench_r8 homed channel to true to complete homing."
+      },
+      {
+        "role": "assistant",
+        "content": "[Called: hw_configure]\nHomed the device; the readiness gate is now satisfied."
+      },
+      {
+        "role": "user",
+        "content": "Preview an actuate of bench_r8 setpoint to 55, dry run only.\nPreview an actuate of bench_r8 setpoint to 55, dry run only."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "hw_actuate"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"kind\": \"\", \"truncated\": true, \"original_chars\": 888, \"budget_chars\": 819}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "hw_actuate",
+      "hw_configure",
+      "hw_describe",
+      "hw_dispense",
+      "hw_estop",
+      "hw_list",
+      "hw_read",
+      "hw_status",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Dry run confirmed the setpoint command is feasible after homing.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r8_hardware/cassette-model-d70fc70163a8902a.cassette.json b/tests/_fixtures/cassettes/r8_hardware/cassette-model-d70fc70163a8902a.cassette.json
new file mode 100644
index 00000000..c164fd62
--- /dev/null
+++ b/tests/_fixtures/cassettes/r8_hardware/cassette-model-d70fc70163a8902a.cassette.json
@@ -0,0 +1,75 @@
+{
+  "fingerprint": "d70fc70163a8902ae54831dd553c73b3970cadd33af82d7bc2e1782f2447cc30",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **hw_list**(): List connected hardware devices with their channel counts and measured quantities. Start here; it does not include operating limits.\n- **hw_describe**(device_id): Return the full reference for one device: every channel, its unit, its operating envelope, rate limit, reversibility, and required interlocks, plus any prior outcomes recorded for its writable channels. Required before commanding a device.\n- **hw_read**(device_id, channel_id): Read the current value of one device channel. Has no physical effect.\n- **hw_status**(device_id): Report connection health, halt capability, and recent notable events (threshold excursions, lost samples, stalled channels) for one device.\n- **hw_configure**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Set a configuration value or setpoint on a channel declaring effect=configure. Setpoints often have inertia: the value may need time to stabilise.\n- **hw_actuate**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Command motion or output on a channel declaring effect=actuate. This moves physical hardware; a repeat from an unknown state is not a safe retry.\n- **hw_dispense**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Consume an irreversible resource on a channel declaring effect=dispense. Running this twice dispenses twice; never repeat it after a failure without first verifying what already happened.\n- **hw_estop**(device_id) [capability_expand category: hardware]: Stop all motion and output on a device immediately. Never requires approval; use it whenever device behaviour is unexpected.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n\n## Recent Session Summary\n- [user] List the connected hardware devices, then describe bench_r8 in full.\n\n## Task Contract\n- Task ID: turn-1\n- Original user request: List the connected hardware devices, then describe bench_r8 in full.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "user",
+        "content": "List the connected hardware devices, then describe bench_r8 in full.\nList the connected hardware devices, then describe bench_r8 in full."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "hw_list"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"devices\": [{\"device_id\": \"bench_r8\", \"display_name\": \"R8 Simulated Bench\", \"location\": \"journey-lab\", \"channels\": 3, \"writable\": 2, \"streaming\": 1, \"quantities\": [\"state.homed\", \"temperature\"], \"verified\": true, \"halt_supported\": true}], \"count\": 1, \"hint\": \"Call hw_describe(device_id) for channel limits before commanding a device.\", \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"read_only\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "hw_describe",
+      "hw_list",
+      "hw_read",
+      "hw_status",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"\", \"tool_calls\": [{\"id\": \"call_1\", \"type\": \"function\", \"function\": {\"name\": \"hw_describe\", \"arguments\": \"{\\\"device_id\\\": \\\"bench_r8\\\"}\"}}]}, \"finish_reason\": \"tool_calls\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/_fixtures/cassettes/r8_hardware/cassette-model-ef8c4f88764ca616.cassette.json b/tests/_fixtures/cassettes/r8_hardware/cassette-model-ef8c4f88764ca616.cassette.json
new file mode 100644
index 00000000..4e2b06b7
--- /dev/null
+++ b/tests/_fixtures/cassettes/r8_hardware/cassette-model-ef8c4f88764ca616.cassette.json
@@ -0,0 +1,91 @@
+{
+  "fingerprint": "ef8c4f88764ca616e03f2ddca60cf85a4ab00a8393d0a23158ca56e4b6c17348",
+  "note": "captured in seed mode",
+  "request": {
+    "model": "cassette-model",
+    "stream": false,
+    "messages": [
+      {
+        "role": "system",
+        "content": "You are LeapFlow, an intelligent assistant that can both converse naturally and take real actions on the user's computer.\n\n## Capabilities\nThe tool index below lists **every** registered tool by name and a one-line summary — this is the complete\ncapability contract; nothing else exists. Only a subset is directly callable this turn (via native tool calling,\nnot a JSON block in your reply). If you need a tool from the index that is not yet callable, call\n`capability_expand` with its category name first — the matching tools become callable immediately after.\nWhen the user asks what LeapFlow itself supports, whether it supports plugins, or which runtime capabilities\nare available, use the live capability evidence exposed by `plugin_list` before making capability claims; report\nconfiguration-dependent or unavailable capabilities as limitations instead of inferring from documentation.\n- **text_search**(text, pattern): Search for a regex pattern in text.\n- **text_replace**(text, old, new, count) [capability_expand category: write]: Replace occurrences of a substring in text.\n- **time_get**(): Get current date and time.\n- **env_info**(): Get system environment information (OS, Python version, cwd).\n- **skills_list**(query, category, source): List available learned skills. Use when user asks about capabilities or you need a specific skill.\n- **skill_view**(name): View the full content of a specific skill document.\n- **code_intel**(path, operation): Precise document symbols (outline) for a source file: classes, functions, and methods with line ranges. Python uses an exact AST parse; other languages use a keyword-prefix scan. Prefer over file_read mode=symbols for accurate navigation before editing. Read-only.\n- **repo_map**(path): Compact project orientation for a repository root: languages, detected test/lint commands, top-level structure, entry points, manifest, and VCS branch. Call this first when entering an unfamiliar codebase. Read-only.\n- **scm_sync**(action, cwd, remote, pull_ref, push_ref, timeout) [capability_expand category: scm]: Run a typed git SCM action. Use this instead of shell_run for git pull/push/status. For 'pull origin main then push', set action='pull_then_push', remote='origin', pull_ref='main', and omit push_ref so LeapFlow pushes the current local branch.\n- **git_query**(action, cwd, ref, path, staged, max_count, stat): Read-only structured git inspection: action=diff|log|status|branch|show. Prefer over shell_run for reading repo state — output is clipped, redacted, and log/branch are parsed into structured fields. Use scm_sync for pull/push.\n- **git_write**(action, cwd, message, stage_all, name, ref, create) [capability_expand category: scm]: Mutating git actions: action=commit (message, stage_all), branch (create+switch), checkout (switch; create=true for -b). Approval-gated. Use scm_sync for pull/push and git_query for reads.\n- **test_run**(command, cwd, timeout): Run the project's test suite and return structured results (framework, passed/failed counts, failing tests). Auto-detects the runner (pytest/npm/go/cargo) or uses a configured/explicit command; executes via the governed shell. ok=true means the runner executed — see 'success' for pass/fail.\n- **lint_check**(command, cwd, timeout): Run the project's linter and return a structured clean/issue result. Auto-detects the linter (ruff/eslint/go vet/clippy) or uses a configured/explicit command; executes via the governed shell. ok=true means the linter ran — see 'clean'.\n- **file_list**(path, pattern, depth): List files and directories at a given path. Use depth=1 or depth=2 to get a recursive tree in one call instead of listing each sub-directory separately.\n- **file_read**(path, max_lines, start_line, max_chars, mode): Read text file content with adaptive context governance. For large or unfamiliar files, prefer mode='outline' or mode='symbols' first, then use mode='raw' with start_line/max_lines for the specific range you actually need. For LeapFlow's own settings, use config_list / config_get / config_set — its config files are outside the workspace and not readable here.\n- **file_write**(path, content, mode) [capability_expand category: write]: Write content to a file (overwrite or append).\n- **code_search**(pattern, patterns, path, glob, ignore_case, multiline, max_results, context_lines): Search file CONTENTS by regex pattern across a directory tree (ripgrep-backed). Requires a regex pattern. NOT for listing or browsing directory contents — use file_list for that. Prefer this over shell_run grep: faster, skips VCS/dependency/build dirs, and returns structured path:line:column matches. Batch related lookups into ONE call via `patterns` (OR-combined, single pass) instead of issuing several separate searches. Use file_read for the surrounding context of a hit.\n- **file_find**(glob, path, max_results): Find files by a recursive glob pattern under a base path (e.g. '**/test_*.py' or '*.md'). Prefer this over shell_run find; skips VCS/dependency/build dirs.\n- **edit_file**(path, edits, dry_run, diff) [capability_expand category: write]: Apply targeted, anchored search-replace edits to an EXISTING text file (use file_write to create/overwrite). Each edit is {original_text, new_text, replace_all?}; original_text must match exactly and uniquely (or set replace_all) — a non-unique or missing anchor is rejected so files are never corrupted. Set dry_run to preview. Alternatively pass a unified 'diff' to apply its hunks as anchored edits. Far cheaper and safer than rewriting a whole file.\n- **shell_run**(command, cwd, timeout) [capability_expand category: shell]: Execute a one-shot shell command with timeout protection. Runs in the active workspace; paths resolving outside it are refused. Reach for a structured tool first when one fits — web_fetch for anything over HTTP(S), git_query/scm_sync for git, code_search/file_find/file_read for the repo, config_get/config_set for LeapFlow's own settings — because those report typed results, while a failed shell command can only be diagnosed from its exit code and stderr. Every shell run counts as an external side effect, so a failure stops the rest of the batch and is not retried automatically.\n- **terminal_open**(command, cwd, shell) [capability_expand category: terminal]: Open a PERSISTENT shell session (REPL/dev server/watch), returning a session_id for terminal_send/read/close. Disabled unless tools.terminal_session_enabled is set. For one-shot commands use shell_run instead.\n- **terminal_send**(session_id, input, wait) [capability_expand category: terminal]: Send a line of input to a persistent terminal session and return output captured shortly after.\n- **terminal_read**(session_id, wait): Drain buffered output from a persistent terminal session (optionally waiting briefly first).\n- **terminal_close**(session_id) [capability_expand category: terminal]: Terminate a persistent terminal session and release its process group.\n- **terminal_list**(): List active persistent terminal sessions.\n- **config_list**(category, limit): List LeapFlow's own writable settings (model, provider, daemon, memory, perception, gateway, …) with current values. Use this to discover the exact key before changing anything. Optionally narrow by `category`. This is the only correct way to inspect LeapFlow configuration — never read config files from disk.\n- **config_get**(key): Read one LeapFlow setting by key (e.g. 'llm.model', 'daemon.log_level'), returning its current value, type, scopes, and whether a change needs a daemon restart. Never read LeapFlow config files from disk — use this.\n- **config_set**(key, value, scope) [capability_expand category: config]: Change one LeapFlow setting by key, e.g. switch the model with key='llm.model'. Values are validated and coerced; credentials are stored in the vault automatically. Call config_list or config_get first if unsure of the key. The result states whether a `leap daemon restart` is required. Never edit LeapFlow config files directly.\n- **web_fetch**(url, select, timeout, max_bytes): Read a URL over HTTP(S) and get back extracted, context-sized content: parsed JSON for API endpoints, readable text plus links for web pages. Use this for anything on the internet — prices, docs, releases, articles — instead of running curl through shell_run: it reports real HTTP status codes, retries rate limits on its own, and is a plain read so a retry is always safe. For JSON APIs pass `select` with a dotted path (e.g. 'chart.result.0.meta') to return just that part instead of the whole payload.\n- **memory_search**(query, limit): Search agent memory for relevant past experiences, observations, and facts.\n- **memory_add**(content, kind) [capability_expand category: write]: Store a new observation or insight in memory for future reference.\n- **research_note**(kind, text): Record a compact, structured note about the current task's state so it survives context compression on long / multi-step tasks. Use for durable findings, open questions still to resolve, decisions / excluded paths, and the immediate next step. One concise sentence per note.\n- **capability_expand**(category): Fetch the full callable schema for every tool in a capability category (e.g. 'hub', 'gateway', 'desktop', 'delegate', 'file', 'memory', 'skill'). The compact tool index always lists every registered tool by name and a one-line summary, but only a static low-risk subset is directly callable each turn. If you need a tool from the index that is not yet callable, call capability_expand with its category first; the matching tools become callable in this turn. Never invent a tool name — expand the category instead.\n- **delegate_task**(goal, context) [capability_expand category: delegate]: Delegate a complex sub-task to an isolated subagent. The subagent gets a fresh context and restricted tool access. Use when a task is self-contained and can be solved independently.\n- **schedule_reentry**(kind, reason, delay_seconds, event_match, max_reentries, deadline_seconds): Register a re-entry so this task can resume later from its current orientation (findings / open questions / next step). Use when work must pause and continue after a delay (kind=time) or when a matching platform event arrives (kind=event), instead of finishing now. The research-ledger state is carried over automatically.\n- **hub_push**(skill_name, visibility, version) [capability_expand category: hub]: Push a local skill to the ModelScope Hub for sharing or backup.\n- **hub_pull**(repo_id, version) [capability_expand category: hub]: Pull a skill from the ModelScope Hub to install locally.\n- **hub_search**(query) [capability_expand category: hub]: Search for skills on the Hub by keyword or description.\n- **hub_sync**(mode, dry_run) [capability_expand category: hub]: Preview or execute sync between local skills and Hub.\n- **platform_action**(platform, action, payload, backend_kind) [capability_expand category: gateway]: Execute an exact registered business action on an external platform through LeapFlow's App Connector layer. Actions must be copied from the App Connector Capability Index and are addressed as domain.operation, e.g. im.send_message or docs.create_markdown. All business fields (chat_id, text, query, etc.) MUST be placed inside `payload`, never at the top level. Example: {\"platform\":\"feishu\",\"action\":\"im.send_message\",\"payload\":{\"chat_id\":\"oc_xxx\",\"text\":\"hello\"}}. Do not invent action names, do not use management actions such as list/guide/connect/status here.\n- **platform_connect**(action, platform, credentials, options, checkpoint) [capability_expand category: gateway]: List, guide, connect, disconnect, remove, or check status for external platforms using the App Connector management namespace. Supports REST and CLI backends. Use this for management actions such as list/guide/preflight/connect/status; use platform_action only for exact registered business actions.\n- **gateway_send**(platform, chat_id, text, thread_id) [capability_expand category: gateway]: Send a message to a connected external platform (Feishu group, Telegram chat, DingTalk conversation, etc.).  Requires the platform to be connected via gateway_connect first.  Use gateway_connect with action='list' to see connected platforms and available chat IDs.\n- **gateway_connect**(action, platform, credentials, options) [capability_expand category: gateway]: Connect, configure, or manage external platform integrations (Feishu, DingTalk, Telegram, Slack, Discord, etc.).  Conversational flow: 1) call 'guide' to get setup steps + required fields, 2) present the steps to the user and ask for ALL required credentials in a single message, 3) call 'connect' with the credentials.  Goal: complete in 1–2 user turns.  NEVER include credential values in your text response.\n- **plugin_list**(): List the live plugin registry and cross-subsystem capability evidence. Use this before answering questions about whether LeapFlow supports plugins, self-evolution, plugin installation, hot reload, versioning, or other runtime capabilities.\n- **plugin_status**(plugin_id): Get detailed status of a specific plugin: its declared category, runtime dependencies, contributed tools, and fiber lifecycle state.\n- **plugin_versions**(plugin_id): List recorded source versions and active pointer for a profile-scoped plugin.\n- **plugin_propose**(requested_capability, plugin_id, proposed_tools, test_cases, risk_level, evidence): Create a side-effect-free PluginProposal from explicit capability-gap evidence. Use this before plugin_generate when a missing capability should be reviewed. Does not call an LLM, write files, or install anything.\n- **assess_compatibility**(manifest, source_path) [capability_expand category: plugin_management]: Assess whether a foreign plugin manifest or real DSH source bundle is compatible with LeapFlow. A source bundle assessment is static: runtime_ready stays false until restricted Node discovery during plugin_install. Returns component-level verdicts and limitations.\n- **plugin_generate**(plugin_id, description, proposal_id) [capability_expand category: system]: Generate a new ToolPlugin from a natural-language capability description. The LLM produces code that conforms to the ToolPlugin Protocol; it is then rigorously validated (syntax, structure, import, protocol conformance). The generated source is stored in CAS and receives explicit content approval. It DOES NOT install the plugin — installation requires a second, mutation-specific approval via plugin_install.\n- **plugin_install**(plugin_id, code, marketplace_name, source_path, proposal_id, version_label) [capability_expand category: system]: Install a plugin from exactly one source: validated Python code, the configured Python marketplace, or a real DSH source bundle. DSH bundles run restricted Node discovery before registration; only public host tools are installed and client UI limitations are reported. Writes profile-scoped state and mutates the process-global registry. REQUIRES APPROVAL.\n- **plugin_rollback**(plugin_id, version) [capability_expand category: system]: Rollback a profile-scoped plugin to a recorded source version and reload it. REQUIRES APPROVAL.\n- **plugin_reload**(plugin_id, version_label) [capability_expand category: system]: Hot-reload a plugin at runtime. Disposes the old plugin fiber, re-imports its module, and registers a fresh instance. Existing in-flight turns are unaffected (snapshot isolation). REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_disable**(plugin_id) [capability_expand category: system]: Disable a plugin by disposing its fiber, removing its tools from the runtime registry. Cannot disable self_management itself. REQUIRES APPROVAL — this is a self-modification action.\n- **plugin_remove**(plugin_id, delete_source) [capability_expand category: system]: Terminally remove a plugin: dispose its fiber, unregister its tools, remove reload metadata, and optionally delete its profile-scoped source file. Cannot remove self_management itself. REQUIRES APPROVAL.\n- **plugin_enable**(plugin_id) [capability_expand category: system]: Re-enable a previously disabled plugin by reloading its module and registering a fresh instance. REQUIRES APPROVAL.\n- **hw_list**(): List connected hardware devices with their channel counts and measured quantities. Start here; it does not include operating limits.\n- **hw_describe**(device_id): Return the full reference for one device: every channel, its unit, its operating envelope, rate limit, reversibility, and required interlocks, plus any prior outcomes recorded for its writable channels. Required before commanding a device.\n- **hw_read**(device_id, channel_id): Read the current value of one device channel. Has no physical effect.\n- **hw_status**(device_id): Report connection health, halt capability, and recent notable events (threshold excursions, lost samples, stalled channels) for one device.\n- **hw_configure**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Set a configuration value or setpoint on a channel declaring effect=configure. Setpoints often have inertia: the value may need time to stabilise.\n- **hw_actuate**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Command motion or output on a channel declaring effect=actuate. This moves physical hardware; a repeat from an unknown state is not a safe retry.\n- **hw_dispense**(device_id, channel_id, value, conditions, dry_run) [capability_expand category: hardware]: Consume an irreversible resource on a channel declaring effect=dispense. Running this twice dispenses twice; never repeat it after a failure without first verifying what already happened.\n- **hw_estop**(device_id) [capability_expand category: hardware]: Stop all motion and output on a device immediately. Never requires approval; use it whenever device behaviour is unexpected.\n- **session_search**(query, limit) [capability_expand category: unclassified]: Search past conversation sessions in the current workspace for relevant context.\n- **session_list**(limit): List recent conversation sessions in the current workspace with stable ids, titles, dates, and summaries. Use for browsing past tasks or when user asks to see history without specific search terms. No keywords needed — returns chronological list.\n- **session_detail**(session_id, limit, offset, include_inactive) [capability_expand category: unclassified]: Read a paginated persisted transcript for one past conversation session in the current workspace. Use after session_list or session_search returns a session_id.\n- **click**(element_index) [capability_expand category: desktop]: Click a UI element by its element_index (from the latest observe_ui snapshot)\n- **get_clipboard**() [capability_expand category: desktop]: Read current clipboard text content\n- **list_apps**(filter, running_only) [capability_expand category: desktop]: List available applications on this system. Use to discover correct bundle_id before switch_app.\n- **list_windows**() [capability_expand category: desktop]: List all top-level windows with pid, window_id, title, and per-window state (minimized, on-screen). Call this first to pick the pid and window_id that observe_ui and other window tools require.\n- **observe_ui**(pid, window_id, query) [capability_expand category: desktop]: Snapshot one window's actionable UI elements, each tagged with an element_index for click/right_click/read_text. Re-observe after actions — indices belong to one snapshot. Requires the window's pid and window_id from list_windows.\n- **open_url**(url, app_id) [capability_expand category: desktop]: Open a URL in the default or specified browser\n- **read_text**(element_index) [capability_expand category: desktop]: Read the text content of a specific UI element from the latest snapshot\n- **right_click**(element_index) [capability_expand category: desktop]: Right-click a UI element to open its context menu. Returns visible menu items.\n- **screenshot**(pid, window_id) [capability_expand category: desktop]: Capture a screenshot for visual verification. With pid + window_id captures that window (works across all displays); defaults to the last observed window, or the full desktop when no window has been observed.\n- **scroll**(element_index, direction, amount, pid, window_id) [capability_expand category: desktop]: Scroll a scrollable area of a window. Omit element_index to scroll the window's focused/page scroller; pass one to scroll an exact element from the latest snapshot.\n- **select_text**(element_index) [capability_expand category: desktop]: Select all text in a UI element (focus + select-all, for subsequent copy)\n- **set_clipboard**(text) [capability_expand category: desktop]: Write text to the clipboard\n- **shortcut**(keys) [capability_expand category: desktop]: Execute a keyboard shortcut\n- **switch_app**(app_id) [capability_expand category: desktop]: Switch to an app (launch if needed, activate, verify)\n- **type_text**(text) [capability_expand category: desktop]: Type text into the currently focused element\n- **wait**(seconds) [capability_expand category: desktop]: Wait for a specified duration before continuing\n- **wait_until**(condition, pid, window_id, timeout, poll_interval) [capability_expand category: desktop]: Wait until a UI condition is met (polls UI tree). Returns elements when found or on timeout.\n- **wait_until_stable**(timeout, poll_interval, pid, window_id) [capability_expand category: desktop]: Wait until the UI stops changing (element set stabilizes across polls).\n\n## App Connector Capability Index\nLeapFlow can onboard and manage external apps through `platform_connect` and execute exact registered business actions through `platform_action`.\nFor requests about connecting, setting up, configuring, enabling, or managing a supported app, use `platform_connect` first instead of generating SDK/Webhook sample code.\n`platform_connect.action` is the management namespace: list, guide, preflight, connect, disconnect, remove, status, events_start, events_stop, events_status.\n`platform_action.action` is only for exact registered platform business actions listed below, such as `im.send_message`; never use management actions like `list` or `guide` there.\nAll business fields MUST go inside `payload`; top-level keys are only `platform`, `action`, and `payload`.\nDo not invent platform IDs or platform action names. If the needed action is not listed, ask for discovery/clarification instead of guessing.\nUse `platform_connect` with `action='guide'` and the matching `platform` to start onboarding; use `action='list'` when the app is unclear.\nWhen a pending onboarding state is present, continue from that state with `platform_connect` instead of asking the user to restate the app.\nSupported apps:\n- `api_server`: API Server (OpenAI Compatible) (category=api; backend=adapter; platform_action actions=none registered)\n- `dingtalk`: 钉钉 (DingTalk) (category=im; backend=adapter; platform_action actions=none registered)\n- `feishu`: 飞书 (Feishu/Lark) (category=im; backend=cli)\n  - `calendar.create_event` payload={summary*, start_time*, end_time*, attendees} [write/high]\n  - `docs.create_markdown` payload={title*, markdown*, folder_token} [write/medium]\n  - `drive.search` payload={query*, limit} [read/medium]\n  - `im.add_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.download_resource` payload={message_id*, file_key*, type*} [read/low]\n  - `im.get_messages` payload={message_ids*} [read/low]\n  - `im.list_chats` payload={page_size} [read/low]\n  - `im.list_messages` payload={chat_id*} [read/low]\n  - `im.list_thread_messages` payload={thread*} [read/low]\n  - `im.remove_reaction` payload={message_id*, emoji_type*} [write/low]\n  - `im.reply_message` payload={message_id*, text*} [send/high]\n  - `im.search_chats` payload={query*, page_size} [read/low]\n  - `im.search_messages` payload={query*} [read/medium]\n  - `im.send_message` payload={chat_id*, text*, thread_id} [send/high]\n  - `im.update_card` payload={token*, card*} [write/medium]\n  - `im.update_message` payload={message_id*, text*} [write/medium]\n  - `mail.search_unread` payload={query, limit} [read/high]\n  - `sheets.append_row` payload={spreadsheet_token*, sheet_id*, values*} [write/medium]\n  - `task.create` payload={title*, description, due_time} [write/medium]\n- `telegram`: Telegram (category=social; backend=adapter; platform_action actions=none registered)\n- `webhook`: Webhook (Generic) (category=webhook; backend=adapter; platform_action actions=none registered)\n\n## Tool Usage\nTools are normally invoked through the native function-calling mechanism, not by writing JSON in your reply\ntext. Only if the provider signals that native function calling is unavailable for this turn, fall back to a\nsingle JSON code block: `{\"name\": \"tool_name\", \"arguments\": {\"key\": \"value\"}}` — use this fallback format\nonly, never both. Only call a tool whose exact name appears in the tool index above and is currently callable\n(or reachable via `capability_expand`). Never invent, rename, alias, or guess a tool name, platform ID, or\nplatform action from argument shape or wording — if the index does not list it, it does not exist.\n`platform_connect.action` (list/guide/preflight/connect/disconnect/remove/status/events_start/events_stop/\nevents_status) is the App Connector management namespace; `platform_action.action` only accepts exact\nregistered business actions such as `im.send_message` shown in the App Connector Capability Index — never mix\nthe two namespaces. If a tool call returns an unknown/unavailable result, use the returned suggestions or\navailable names for a single retry instead of trying further variations of the same guess.\n\n**Side-effect action rule** (`platform_action` with effect=send/write/execute):\n- Call each unique action+payload **exactly once**. Never include duplicates in the same turn.\n- Once the result returns `\"completed\": true`, that action is DONE for this task. Do NOT call it again\n  in any subsequent turn — immediately summarize the result for the user instead.\n- The system enforces idempotency: duplicate calls are blocked and will not execute.\n- If the user explicitly requests sending/writing multiple times, use distinct payloads per call.\n\n**Resource identifier provenance rule**:\n- NEVER fabricate, guess, or infer resource identifiers (chat_id, message_id, file_key, user_id, etc.).\n  Every resource ID used in a side-effect action MUST come from a successful API response in this session.\n- If a read/list action fails (e.g. authorization error), you do NOT have valid resource IDs.\n  Report the failure to the user — do NOT attempt the dependent write/send action with a guessed ID.\n- When a tool result contains `\"llm_instruction\"`, follow it exactly.\n\n## Guidelines\n1. **Direct answers first**: If you already know the answer, respond directly without tools.\n2. **Avoid redundant tool calls**: Do not call the same tool with the same arguments more than once in the same user turn. When an existing tool result already answers the user's request, stop calling tools and answer directly.\n3. **Use tools proactively**: When the user asks about files, time, system state, or needs actions performed, use the appropriate tool.\n4. **Chain tools when needed**: You can call multiple tools in sequence (e.g., list files → read file → summarize).\n5. **Handle failures gracefully**: If a tool fails, explain what went wrong and suggest alternatives. If it failed because of an unknown tool/platform/action name, retry once with an exact name from the returned suggestions, then explain rather than keep guessing.\n6. **Summarize results naturally**: After tool execution, synthesize the results into a helpful answer rather than dumping raw output.\n7. **Stay conversational**: Maintain a natural, helpful tone. Acknowledge context from earlier in the conversation.\n8. **Recall past work**:\n   - Broad queries (\"之前做了什么\", \"列出任务\"): answer from the \"Recent Task History\" section already in your context. If insufficient, call session_list.\n   - Specific lookups (\"上次那个配置怎么改的\"): call session_search with relevant phrases (NOT single characters).\n   - Do NOT call search tools repeatedly with keyword fragments. One well-phrased call is better than ten fragmented ones.\n\n## Coding & Verification\nWhen working with code, prefer the precise built-in tools over ad-hoc shell: use `repo_map` to orient in an\nunfamiliar project, `code_search`/`file_find` to locate and `code_intel` for symbols, `edit_file` (anchored\nsearch-replace, or a unified `diff`) to change files — never rewrite a whole file to change a few lines — and\n`git_query` to inspect diffs/log. After edits, check `syntax_ok` in the result and run `test_run`/`lint_check`\nbefore declaring the work done. Batch independent read-only calls (search/read/query) into a single turn — they\nrun in parallel.\n\n## Presentation Style\n1. **Polished Markdown only**: Format user-facing answers with clean Markdown headings, short paragraphs, and concise bullets. Use tables only when they improve comparison or scanning.\n2. **Terminal-friendly layout**: Keep lines readable in a TUI; avoid dense walls of text, deeply nested lists, oversized ASCII art, or heavy visual blocks.\n3. **Elegant emphasis**: Use bold text sparingly for key terms and conclusions. Avoid excessive emojis, decorative symbols, repeated separators, or visual noise.\n4. **Theme-safe colors**: Do not emit ANSI escape codes, HTML color tags, Rich markup, or hardcoded color names. Rely on the TUI theme to render Markdown professionally.\n5. **No leaked tool protocol**: Never show tool-call JSON, internal schemas, raw observations, tool result payloads, or hidden reasoning in the final answer unless the user explicitly asks for raw/debug output. Treat any prior `{\"name\": ..., \"arguments\": ...}` blocks and `Tool result (...)` messages as internal execution context only.\n6. **Professional closure**: End with a concise conclusion or next step when helpful; avoid rambling after the useful answer is complete.\n\nWhen finished with all tool calls, respond normally without a JSON block, tool-call transcript, or process log.\n\n## Task Contract\n- Task ID: turn-4\n- Original user request: Configure the bench_r8 homed channel to true to complete homing.\n- Workspace root: <TMP>\n- Allowed roots: <TMP>\n- Treat relative project paths as relative to the workspace root; never infer `.` as the project root when a workspace root is provided.\n- Workspace boundary is enforced by tools: do not read, search, edit, or run commands against paths outside the allowed roots unless the user explicitly requests an external path and the tool/approval policy permits it.\n- LeapFlow workspace config is optional at `<workspace>/.leapflow/config.yaml`; runtime config is loaded from `~/.leapflow/config/user.yaml` and `~/.leapflow/profiles/<profile>/config/*.yaml`.\n- Preserve this task contract across summarization, compression, tool loops, and memory retrieval.\n"
+      },
+      {
+        "role": "assistant",
+        "content": "Discovered the simulated bench and read its channel limits."
+      },
+      {
+        "role": "user",
+        "content": "Read the current value of the setpoint channel on bench_r8."
+      },
+      {
+        "role": "assistant",
+        "content": "[Called: hw_read]\nRead the setpoint channel."
+      },
+      {
+        "role": "user",
+        "content": "Actuate the bench_r8 setpoint to 60.\nConfigure the bench_r8 homed channel to true to complete homing.\nConfigure the bench_r8 homed channel to true to complete homing."
+      },
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [
+          "hw_configure"
+        ]
+      },
+      {
+        "role": "tool",
+        "content": "{\"ok\": true, \"device_id\": \"bench_r8\", \"channel_id\": \"homed\", \"side_effect_state\": \"committed\", \"settled\": true, \"execution_id\": \"<HEX>\", \"idempotency_key\": \"<HEX>\", \"execution_policy\": \"external_side_effect\", \"tool_call_id\": \"call_1\", \"execution_status\": \"completed\"}",
+        "tool_result": true
+      },
+      {
+        "role": "assistant",
+        "content": "Operation interrupted. Continuing..."
+      }
+    ],
+    "tools": [
+      "capability_expand",
+      "code_intel",
+      "code_search",
+      "config_get",
+      "config_list",
+      "env_info",
+      "file_find",
+      "file_list",
+      "file_read",
+      "git_query",
+      "hw_actuate",
+      "hw_configure",
+      "hw_describe",
+      "hw_dispense",
+      "hw_estop",
+      "hw_list",
+      "hw_read",
+      "hw_status",
+      "lint_check",
+      "memory_search",
+      "plugin_list",
+      "plugin_propose",
+      "plugin_status",
+      "plugin_versions",
+      "repo_map",
+      "research_note",
+      "schedule_reentry",
+      "session_list",
+      "skill_view",
+      "skills_list",
+      "terminal_list",
+      "terminal_read",
+      "test_run",
+      "text_search",
+      "time_get",
+      "web_fetch"
+    ]
+  },
+  "responses": [
+    {
+      "status": 200,
+      "content_type": "application/json",
+      "body": "{\"id\": \"chatcmpl-cassette\", \"object\": \"chat.completion\", \"model\": \"cassette-model\", \"choices\": [{\"index\": 0, \"message\": {\"role\": \"assistant\", \"content\": \"Homed the device; the readiness gate is now satisfied.\"}, \"finish_reason\": \"stop\"}], \"usage\": {\"prompt_tokens\": 64, \"completion_tokens\": 16, \"total_tokens\": 80}}"
+    }
+  ]
+}
diff --git a/tests/test_action_recorder_wiring.py b/tests/test_action_recorder_wiring.py
new file mode 100644
index 00000000..ca7bb04f
--- /dev/null
+++ b/tests/test_action_recorder_wiring.py
@@ -0,0 +1,209 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Execution-boundary tests for the no-LLM ActionExecutor wiring."""
+from __future__ import annotations
+
+import tempfile
+
+import pytest
+
+from conftest import StubLLM, make_settings
+from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent
+from leapflow.engine.action_executor import ActionInvocation, RecordedActionExecutor
+from leapflow.engine.engine import AgentEngine, build_default_registry
+from leapflow.engine.intent_classifier import Intent
+from leapflow.evolution.action_recorder import ActionEvidenceUnavailable
+from leapflow.memory import EpisodicMemoryProvider, SemanticMemoryProvider, WorkingMemoryProvider
+from leapflow.platform.mock import MockBridge
+
+
+class _Recorder:
+    def __init__(self, *, fail_start: bool = False, fail_complete: bool = False) -> None:
+        self.fail_start = fail_start
+        self.fail_complete = fail_complete
+        self.started_calls: list[dict] = []
+        self.completed_calls: list[dict] = []
+        self.failed_calls: list[dict] = []
+
+    async def started(self, **kwargs):
+        self.started_calls.append(kwargs)
+        if self.fail_start:
+            raise OSError("writer unavailable")
+        return EvolutionEvent.create(
+            "action.started",
+            context=kwargs["context"],
+            payload={},
+            producer="test",
+        )
+
+    async def completed(self, **kwargs):
+        self.completed_calls.append(kwargs)
+        if self.fail_complete:
+            raise OSError("writer unavailable")
+        return EvolutionEvent.create(
+            "action.completed",
+            context=kwargs["context"],
+            payload={},
+            producer="test",
+        )
+
+    async def failed_exception(self, **kwargs):
+        self.failed_calls.append(kwargs)
+        return EvolutionEvent.create(
+            "action.failed",
+            context=kwargs["context"],
+            payload={},
+            producer="test",
+        )
+
+
+def _invocation(policy: str = "read_only") -> ActionInvocation:
+    return ActionInvocation(
+        action_type="tool",
+        action_name="file_read",
+        arguments={"path": "x"},
+        execution_id="exec-1",
+        execution_policy=policy,  # type: ignore[arg-type]
+        context=EvolutionContext.create(
+            profile_id="profile-a",
+            workspace_id="workspace-a",
+            session_id="session-a",
+            turn_id="turn-a",
+            frame_id="command-a",
+            action_id="exec-1",
+        ),
+        goal="read x",
+    )
+
+
+class _FixedClassifier:
+    def __init__(self) -> None:
+        self._intent = Intent(label="complex", reason="test")
+
+    async def classify(self, user_text: str) -> Intent:
+        return self._intent
+
+
+async def _return(value):
+    return value
+
+
+@pytest.mark.asyncio
+async def test_executor_records_identity_and_completion() -> None:
+    recorder = _Recorder()
+    executor = RecordedActionExecutor(recorder)
+
+    result = await executor.execute(
+        _invocation(),
+        lambda: _return({"ok": True, "value": 1}),
+    )
+
+    assert result["ok"] is True
+    assert len(recorder.started_calls) == 1
+    assert len(recorder.completed_calls) == 1
+    context = recorder.started_calls[0]["context"]
+    assert context.profile_id == "profile-a"
+    assert context.session_id == "session-a"
+    assert context.action_id == "exec-1"
+    assert recorder.started_calls[0]["critical"] is False
+
+
+@pytest.mark.asyncio
+async def test_mutating_action_fails_closed_when_start_fact_cannot_persist() -> None:
+    recorder = _Recorder(fail_start=True)
+    executor = RecordedActionExecutor(recorder)
+    executed = False
+
+    async def execute():
+        nonlocal executed
+        executed = True
+        return {"ok": True}
+
+    with pytest.raises(ActionEvidenceUnavailable, match="audit start"):
+        await executor.execute(_invocation("mutating_idempotent"), execute)
+    assert executed is False
+
+
+@pytest.mark.asyncio
+async def test_read_only_action_degrades_when_recorder_is_unavailable() -> None:
+    executor = RecordedActionExecutor(_Recorder(fail_start=True))
+    result = await executor.execute(_invocation(), lambda: _return({"ok": True}))
+    assert result == {"ok": True}
+
+
+@pytest.mark.asyncio
+async def test_execution_exception_is_recorded_then_reraised() -> None:
+    recorder = _Recorder()
+    executor = RecordedActionExecutor(recorder)
+
+    async def execute():
+        raise ValueError("boom")
+
+    with pytest.raises(ValueError, match="boom"):
+        await executor.execute(_invocation("external_side_effect"), execute)
+    assert len(recorder.failed_calls) == 1
+    assert recorder.failed_calls[0]["critical"] is True
+
+
+@pytest.mark.asyncio
+async def test_mutating_completion_record_failure_marks_effect_uncertain() -> None:
+    executor = RecordedActionExecutor(_Recorder(fail_complete=True))
+    result = await executor.execute(
+        _invocation("mutating_once"),
+        lambda: _return({"ok": True}),
+    )
+    assert result["audit_incomplete"] is True
+    assert result["side_effect_uncertain"] is True
+
+
+@pytest.mark.asyncio
+async def test_no_recorder_preserves_execution_result() -> None:
+    executor = RecordedActionExecutor(None)
+    result = await executor.execute(_invocation(), lambda: _return({"ok": True, "value": 2}))
+    assert result == {"ok": True, "value": 2}
+
+
+@pytest.mark.asyncio
+async def test_real_agent_engine_routes_tool_through_action_executor() -> None:
+    with tempfile.TemporaryDirectory() as directory:
+        settings = make_settings(directory)
+        rpc = MockBridge()
+        llm = StubLLM([])
+        working = WorkingMemoryProvider(max_tokens=1024)
+        semantic = SemanticMemoryProvider(source=settings.duckdb_path)
+        episodic = EpisodicMemoryProvider()
+        recorder = _Recorder()
+        calls: list[dict] = []
+
+        async def file_list_handler(args):
+            calls.append(dict(args))
+            return {"ok": True, "entries": []}
+
+        try:
+            registry = build_default_registry(rpc, llm, working, semantic)
+            engine = AgentEngine(
+                settings,
+                rpc,
+                llm,
+                working,
+                semantic,
+                episodic,
+                registry,
+                _FixedClassifier(),
+                action_executor=RecordedActionExecutor(recorder),
+            )
+            engine._current_session_id = "session-a"
+            engine._session_turn_count = 1
+            engine._begin_turn_context("list files")
+
+            result = await engine._execute_tool_with_ledger(
+                {"name": "file_list", "arguments": {"path": "."}},
+                {"file_list": file_list_handler},
+                tool_call_id="tool-call-a",
+            )
+
+            assert result["ok"] is True
+            assert calls == [{"path": "."}]
+            assert recorder.started_calls[0]["context"].session_id == "session-a"
+            assert recorder.started_calls[0]["execution_policy"] == "read_only"
+        finally:
+            semantic.close()
diff --git a/tests/test_active_signal_source.py b/tests/test_active_signal_source.py
index d9d874d5..edb98548 100644
--- a/tests/test_active_signal_source.py
+++ b/tests/test_active_signal_source.py
@@ -9,8 +9,8 @@
 
 import asyncio
 import time
-from typing import Any, Callable, List
-from unittest.mock import AsyncMock, MagicMock, patch
+from typing import Any, List
+from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
@@ -597,7 +597,6 @@ class TestPerceptionSessionIntegration:
 
     def _make_session(self, active_source_manager=None):
         """Build a minimal PerceptionSession for testing active source hooks."""
-        from unittest.mock import MagicMock
         from leapflow.perception.config import PerceptionConfig
         from leapflow.perception.session import PerceptionSession
 
@@ -651,7 +650,6 @@ async def test_session_teardown_respects_shutdown_timeout(
         self,
     ) -> None:
         """PerceptionSession.stop() completes bounded by shutdown_timeout_s even with hung sources."""
-        from unittest.mock import MagicMock
         from leapflow.perception.config import PerceptionConfig
         from leapflow.perception.session import PerceptionSession
         from leapflow.domain.trajectory import RecordingMode
diff --git a/tests/test_adaptation_verdict.py b/tests/test_adaptation_verdict.py
index 7d51eabb..b08bed36 100644
--- a/tests/test_adaptation_verdict.py
+++ b/tests/test_adaptation_verdict.py
@@ -15,7 +15,6 @@
 
 from __future__ import annotations
 
-import asyncio
 from typing import Any
 
 import pytest
@@ -25,7 +24,6 @@
     ADAPTATION_ACTIONS,
     AdaptationVerdict,
 )
-from leapflow.learning.world_model_driver import WorldModelEvolutionDriver
 from leapflow.world_model.trajectory_grader import TeacherVerdict, TrajectoryGrader
 
 
@@ -179,109 +177,24 @@ def test_a_goal_restatement_is_still_rejected():
     assert grader._parse_verdicts(payload, goal="chat cosmetic example") == ()
 
 
-# ── the driver dispatches by action ────────────────────────────────────────────
+# ── the teacher verdict carries all four actions ────────────────────────────────────────
 
 
-class _Teacher:
-    def __init__(self, verdict: TeacherVerdict) -> None:
-        self._verdict = verdict
-
-    async def grade_and_propose(self, trajectory, goal="", **kwargs):
-        return self._verdict
-
-
-class _Intake:
-    """Stands in for ``CapabilityObservationService``.
-
-    ``requirements`` derives a need for whatever was just observed, because that is what
-    a real store does: the driver asks at ``min_count=1``, so the observation written a
-    moment earlier already clears the threshold. A stub that returned nothing here would
-    quietly assert the opposite of the shipped contract -- that the driver queues an
-    acquisition the detector never turned into a requirement -- and the driver now
-    records that case as a ``requirement_not_derived`` no-op instead of acting on it.
-    """
-
-    def __init__(self) -> None:
-        self.observed: list[str] = []
-
-    def observe_result(self, result, **kwargs):
-        capability = str((result or {}).get("capability") or "")
-        if capability:
-            self.observed.append(capability)
-        return {"observation_id": "o1"}
-
-    def requirements(self, *, min_count: int = 1, limit: int = 50):
-        from leapflow.domain.capability_requirement import CapabilityRequirement
-
-        return tuple(
-            CapabilityRequirement.create(
-                capability,
-                "world_model",
-                max_risk_level="read_only",
-                requirement_id=f"req-{capability}",
-            )
-            for capability in dict.fromkeys(self.observed)
-        )
-
-
-def _drive(verdicts, sink=None):
-    queued: list[Any] = []
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher(TeacherVerdict(grades=(), verdicts=tuple(verdicts))),
-        intake=_Intake(),
-        proposal_sink=sink or (lambda p: queued.append(p) or p.proposal_id),
-    )
-    return asyncio.run(driver.drive([{"action": "a"}], "reply in the thread")), queued
-
-
-def test_only_the_acquire_verdict_reaches_the_proposal_queue():
-    result, queued = _drive(
-        [
-            _verdict("absorb", "chat.react"),
-            _verdict("rebind", "chat.reply", target="chat_reply_v3"),
-            _verdict(ACQUIRE, "mail.send"),
-            _verdict("escalate", "drive.upload", target="grant drive.file"),
-        ]
-    )
-
-    assert result.to_dict()["by_action"] == {
-        "absorb": 1, "rebind": 1, "acquire": 1, "escalate": 1
-    }
-    assert len(queued) == 1
-    assert dict(queued[0].evidence[0].metadata)["capability"] == "mail.send"
-
-
-def test_the_cheap_verdicts_survive_on_the_result():
+def test_the_cheap_verdicts_survive_on_a_teacher_verdict():
     """Dropping them for not writing code would discard the common correct answer."""
-    result, _ = _drive(
-        [
+    teacher_verdict = TeacherVerdict(
+        grades=(),
+        verdicts=(
             _verdict("absorb", "chat.react"),
             _verdict("rebind", "chat.reply", target="chat_reply_v3"),
             _verdict("escalate", "drive.upload"),
-        ]
+        ),
     )
 
-    cheap = tuple(v for v in result.verdicts if not v.writes_code)
+    cheap = tuple(v for v in teacher_verdict.verdicts if not v.writes_code)
     assert {v.action for v in cheap} == {"absorb", "rebind", "escalate"}
     assert all(v.knowledge for v in cheap)
-
-
-def test_a_session_that_only_absorbed_is_not_reported_as_idle():
-    """The cheapest answer must be visible, or adapting well looks like doing nothing."""
-    result, queued = _drive([_verdict("absorb", "chat.react")])
-
-    assert queued == [], "absorb writes no code"
-    assert result.to_dict()["by_action"]["absorb"] == 1
-    assert len(result.verdicts) == 1
-    assert result.proposed == 0, "absorb is not a proposal"
-
-
-def test_a_teacher_with_nothing_to_say_stays_empty():
-    result, queued = _drive([])
-    assert result.verdicts == () and queued == []
-    assert result.to_dict()["by_action"] == {
-        "absorb": 0, "rebind": 0, "acquire": 0, "escalate": 0
-    }
+    assert teacher_verdict.intents == (), "none of the three cheap verdicts writes code"
 
 
 # ── review findings: the derivation must be pure and the rule single ───────────
diff --git a/tests/test_agent_execution.py b/tests/test_agent_execution.py
index c38b04b0..34de1bd0 100644
--- a/tests/test_agent_execution.py
+++ b/tests/test_agent_execution.py
@@ -293,6 +293,8 @@ def test_engine_recalibrate_difficulty_applies_and_resets(tmp_path) -> None:
     """
     import dataclasses
 
+    from leapflow.domain.event_types import EvolutionEventType
+    from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
     from leapflow.storage.evolution_store import DuckDBEvolutionStore
 
     settings = dataclasses.replace(make_settings(str(tmp_path)), agent_calibration_enabled=True)
@@ -304,10 +306,12 @@ def test_engine_recalibrate_difficulty_applies_and_resets(tmp_path) -> None:
     lt = SemanticMemoryProvider(source=settings.duckdb_path)
     imm = EpisodicMemoryProvider()
     store = DuckDBEvolutionStore(str(tmp_path / "evo.duckdb"))
+    audit_store = DuckDBEvolutionEventStore(tmp_path / "audit.duckdb")
     try:
         reg = build_default_registry(rpc, llm, wm, lt)
         classifier = _FixedClassifier("complex")
         engine = AgentEngine(settings, rpc, llm, wm, lt, imm, reg, classifier)
+        engine.set_calibration_event_store(audit_store)
         baseline = engine._budget_config.scale_k
 
         # 20 over-predicted turns: high difficulty costs *less* effort than low.
@@ -324,10 +328,17 @@ def test_engine_recalibrate_difficulty_applies_and_resets(tmp_path) -> None:
         assert result.applied is True
         assert engine._budget_config.scale_k < baseline          # over-predicted -> reduce
         assert 0.25 <= engine._budget_config.scale_k <= 3.0       # clamped
+        events = audit_store.read(
+            profile_id=settings.profile,
+            event_type=EvolutionEventType.CALIBRATION_UPDATED,
+        )
+        assert len(events) == 1
+        assert events[0].event.payload["parameter"] == "difficulty_scale"
 
         engine.reset_calibration()
         assert engine._budget_config.scale_k == baseline          # exact revert
     finally:
+        audit_store.close()
         store.close()
         lt.close()
 
diff --git a/tests/test_capability_proposal_policy.py b/tests/test_capability_proposal_policy.py
index e40367c4..bff4ae84 100644
--- a/tests/test_capability_proposal_policy.py
+++ b/tests/test_capability_proposal_policy.py
@@ -6,11 +6,11 @@
 import pytest
 
 from leapflow.domain.capability_requirement import CapabilityRequirement
+from leapflow.evolution.projection import EvolutionProjectionRunner
 from leapflow.learning.plugin_trust import PluginTrustLevel
-from leapflow.plugins.adaptive_loop import AdaptivePluginLoop
 from leapflow.plugins.adaptive_policy import AdaptiveEvolutionPolicy
-from leapflow.storage.capability_plan_store import JsonCapabilityPlanStore
-from leapflow.storage.capability_proposal_queue import JsonCapabilityProposalQueue
+from leapflow.storage.capability_proposal_queue import EvolutionCapabilityProposalStore
+from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
 
 
 def _req(risk: str = "external") -> CapabilityRequirement:
@@ -23,7 +23,9 @@ def _req(risk: str = "external") -> CapabilityRequirement:
 
 
 def test_proposal_queue_enqueues_and_updates_status(tmp_path) -> None:
-    queue = JsonCapabilityProposalQueue(tmp_path / "proposals.json")
+    queue = EvolutionCapabilityProposalStore(
+        DuckDBEvolutionEventStore(tmp_path / "events.duckdb"), profile_id="profile-1"
+    )
 
     item = queue.enqueue(
         requirements=(_req("read_only"),),
@@ -45,59 +47,70 @@ def test_proposal_queue_enqueues_and_updates_status(tmp_path) -> None:
     assert queue.active()[0].proposal_id == item.proposal_id
 
 
-def test_adaptive_policy_requires_approval_for_generated_high_risk(tmp_path) -> None:
-    queue = JsonCapabilityProposalQueue(tmp_path / "proposals.json")
-    proposal = queue.enqueue(
-        requirements=(_req("external"),),
-        risk={"risk_level": "external"},
-    )
-    proposal = queue.update(proposal.proposal_id, status="GENERATED")
+def test_prepare_enqueue_does_not_publish_before_atomic_owner_commit(tmp_path) -> None:
+    events = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    queue = EvolutionCapabilityProposalStore(events, profile_id="profile-1")
 
-    decision = AdaptiveEvolutionPolicy(autonomy_level="trusted_autonomous").decide(
-        proposal,
-        trust_level=PluginTrustLevel.DRAFT,
-        sandbox_validated=True,
+    item, event = queue.prepare_enqueue(
+        requirements=(_req("read_only"),),
+        environment={"fingerprint_id": "env-a"},
+        occurred_at=10.0,
     )
 
-    assert decision.action == "request_approval"
-    assert decision.requires_approval is True
+    assert event is not None
+    assert queue.get(item.proposal_id) is None
+    events.append(event)
+    assert queue.get(item.proposal_id) == item
+    events.close()
 
 
 @pytest.mark.asyncio
-async def test_loop_applies_policy_install_through_actor(tmp_path) -> None:
-    class Actor:
-        async def install(self, **kwargs):
-            return {"ok": True, "plugin_id": kwargs["plugin_id"], "action": "install"}
+async def test_event_sourced_proposal_store_replays_the_latest_lifecycle_state(tmp_path) -> None:
+    events = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    queue = EvolutionCapabilityProposalStore(events, profile_id="profile-1")
+    item = queue.enqueue(
+        requirements=(_req("read_only"),),
+        environment={"fingerprint_id": "env-a", "session_id": "session-a"},
+        metadata={"plugin_id": "json_pretty_plugin"},
+    )
+    queue.transition(item.proposal_id, "GENERATED", generated_code_ref="sha256:test")
+    queue.transition(
+        item.proposal_id,
+        "APPROVED",
+        proposal_approval_id="approval-content",
+        mutation_approval_id="approval-mutation",
+    )
 
-        async def disable(self, **kwargs):
-            return {"ok": True}
+    replayed = EvolutionCapabilityProposalStore(events, profile_id="profile-1")
+    restored = replayed.get(item.proposal_id)
 
-        async def remove(self, **kwargs):
-            return {"ok": True}
+    assert restored is not None and restored.status == "APPROVED"
+    assert restored.generated_code_ref == "sha256:test"
+    assert replayed.active(limit=0) == [restored]
+    assert len(events.read(profile_id="profile-1", proposal_id=item.proposal_id)) == 3
+    projection = await EvolutionProjectionRunner(events).project_aggregate(
+        profile_id="profile-1"
+    )
+    assert projection["proposals"][0]["status"] == "APPROVED"
+    assert projection["mutation_matrix"][0]["lifecycle_status"] == "APPROVED"
+    events.close()
 
-    queue = JsonCapabilityProposalQueue(tmp_path / "proposals.json")
+
+def test_adaptive_policy_requires_approval_for_generated_high_risk(tmp_path) -> None:
+    queue = EvolutionCapabilityProposalStore(
+        DuckDBEvolutionEventStore(tmp_path / "events.duckdb"), profile_id="profile-1"
+    )
     proposal = queue.enqueue(
-        requirements=(_req("read_only"),),
-        risk={"risk_level": "read_only"},
-        metadata={"plugin_id": "json_pretty_plugin"},
+        requirements=(_req("external"),),
+        risk={"risk_level": "external"},
     )
     proposal = queue.update(proposal.proposal_id, status="GENERATED")
+
     decision = AdaptiveEvolutionPolicy(autonomy_level="trusted_autonomous").decide(
         proposal,
+        trust_level=PluginTrustLevel.DRAFT,
         sandbox_validated=True,
     )
-    loop = AdaptivePluginLoop(
-        registry=object(),
-        plan_store=JsonCapabilityPlanStore(tmp_path / "plans.json"),
-        lifecycle_actor=Actor(),
-    )
 
-    result = await loop.apply_policy_decision(
-        proposal,
-        decision,
-        proposal_queue=queue,
-        generated_code="# code",
-    )
-
-    assert result["ok"] is True
-    assert queue.get(proposal.proposal_id).status == "INSTALLED"
+    assert decision.action == "request_approval"
+    assert decision.requires_approval is True
diff --git a/tests/test_capability_replacement_trigger.py b/tests/test_capability_replacement_trigger.py
index d8c14ec7..a86d0d05 100644
--- a/tests/test_capability_replacement_trigger.py
+++ b/tests/test_capability_replacement_trigger.py
@@ -8,20 +8,21 @@
 providers admissible at once, and the question "is the replacement actually better?"
 never being asked, because the incumbent is gone by the time the rival arrives.
 
-These tests cover the three pieces that make the other ordering possible:
+These tests cover the pieces that make the other ordering possible:
 
 * **T1** governance reports a failure that left the plugin *in service* -- the state
   between healthy and quarantined, which had no expression at all.
 * **T2** the teacher is shown those facts and adjudicates. A failure count cannot tell
   a wrong implementation from a moved environment; both produce the same streak and
   want opposite actions.
-* **T3** an admitted intent becomes a queued proposal, with an identity that lets a
-  rival coexist with the incumbent it competes against.
+* **T3** an admitted intent becomes a proposal whose identity lets a rival coexist with
+  the incumbent it competes against. The end-to-end queueing now runs in the durable
+  teacher worker (see ``test_durable_teacher.py``); here we hold the proposal-identity
+  contract that makes coexistence possible.
 """
 
 from __future__ import annotations
 
-from types import SimpleNamespace
 from typing import Any
 
 import pytest
@@ -34,10 +35,6 @@
     CapabilityEvidenceClassifier,
     CapabilityObservationService,
 )
-from leapflow.learning.world_model_driver import (
-    CapabilityGapTeacher,
-    WorldModelEvolutionDriver,
-)
 from leapflow.plugins.lifecycle_governor import LifecycleGovernor
 from leapflow.storage.capability_observation_store import JsonCapabilityObservationStore
 
@@ -227,86 +224,7 @@ def test_a_healthy_session_adds_nothing_to_the_prompt():
     assert _degraded_capability_section([{"capability": ""}]) == ""
 
 
-class _Teacher:
-    """Records the context it was handed."""
-
-    def __init__(self, intents: tuple[EvolutionIntent, ...] = ()) -> None:
-        self.intents = intents
-        self.saw_degraded: Any = None
-
-    async def grade_and_propose(self, trajectory, goal="", **kwargs):
-        self.saw_degraded = kwargs.get("degraded_capabilities")
-        return type("V", (), {"grades": (), "intents": self.intents})()
-
-
-class _OldTeacher:
-    """A teacher predating the extra context, to prove the contract stays open."""
-
-    def __init__(self) -> None:
-        self.called = False
-
-    async def grade_and_propose(self, trajectory, goal=""):
-        self.called = True
-        return type("V", (), {"grades": (), "intents": ()})()
-
-
-class _Intake:
-    def __init__(self, admit: bool = True) -> None:
-        self.admit = admit
-        self.results: list[Any] = []
-
-    def observe_result(self, result, **kwargs):
-        self.results.append(result)
-        return {"observation_id": "o1"} if self.admit else None
-
-    def requirements(self, *, min_count: int = 1, limit: int = 50):
-        return ()
-
-
-@pytest.mark.asyncio
-async def test_the_driver_passes_degradation_facts_to_the_teacher():
-    teacher = _Teacher()
-    facts = ({"capability": "chat.reply", "plugin_id": "chat_reply_v1", "failure_streak": 2},)
-    driver = WorldModelEvolutionDriver(
-        teacher=teacher, intake=_Intake(), degraded_capabilities=lambda: facts
-    )
-
-    await driver.drive([{"action": "reply"}], "reply in the thread")
-
-    assert teacher.saw_degraded == facts
-
-
-@pytest.mark.asyncio
-async def test_a_teacher_that_predates_the_context_still_grades():
-    """Losing the episode's grading over an unknown keyword would be a bad trade."""
-    teacher = _OldTeacher()
-    driver = WorldModelEvolutionDriver(
-        teacher=teacher, intake=_Intake(), degraded_capabilities=lambda: ({"capability": "x"},)
-    )
-
-    await driver.drive([{"action": "a"}])
-
-    assert teacher.called is True
-    assert isinstance(teacher, CapabilityGapTeacher)
-
-
-@pytest.mark.asyncio
-async def test_unavailable_degradation_facts_degrade_grading_not_the_session():
-    def explode():
-        raise RuntimeError("store down")
-
-    teacher = _Teacher()
-    driver = WorldModelEvolutionDriver(
-        teacher=teacher, intake=_Intake(), degraded_capabilities=explode
-    )
-
-    result = await driver.drive([{"action": "a"}])
-
-    assert teacher.saw_degraded == ()
-    assert result.proposed == 0
-
-
-# ── T3: an admitted intent becomes a queued proposal ──────────────────────────
+# ── T3: rival identity: the collision that would stop competition ─────────────
 
 
 def _intent(capability: str = "chat.reply") -> EvolutionIntent:
@@ -318,76 +236,6 @@ def _intent(capability: str = "chat.reply") -> EvolutionIntent:
     )
 
 
-@pytest.mark.asyncio
-async def test_an_admitted_intent_reaches_the_proposal_queue():
-    """The last hop: without it an intent becomes a requirement and stops there.
-
-    Resolution reports the capability unmet and nothing turns that into an acquisition,
-    which is why ``proposal_from_evolution_intent`` had no caller at all.
-    """
-    queued: list[Any] = []
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher((_intent(),)),
-        intake=_Intake(admit=True),
-        proposal_sink=lambda proposal: queued.append(proposal) or proposal.proposal_id,
-    )
-
-    result = await driver.drive([{"action": "a"}])
-
-    assert len(queued) == 1
-    assert result.queued_proposal_ids == (queued[0].proposal_id,)
-    assert result.to_dict()["queued"] == 1
-
-
-@pytest.mark.asyncio
-async def test_an_unadmitted_intent_is_never_queued():
-    """The opt-in gate must not be bypassable through the proposal path."""
-    queued: list[Any] = []
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher((_intent(),)),
-        intake=_Intake(admit=False),
-        proposal_sink=lambda proposal: queued.append(proposal),
-    )
-
-    result = await driver.drive([{"action": "a"}])
-
-    assert result.proposed == 1, "the teacher still proposed"
-    assert result.admitted == 0
-    assert queued == [], "not admitted must mean not queued"
-
-
-@pytest.mark.asyncio
-async def test_no_sink_means_no_proposals_and_no_error():
-    driver = WorldModelEvolutionDriver(teacher=_Teacher((_intent(),)), intake=_Intake())
-    result = await driver.drive([{"action": "a"}])
-    assert result.queued_proposal_ids == ()
-
-
-@pytest.mark.asyncio
-async def test_one_failing_sink_call_does_not_stop_the_others():
-    calls: list[str] = []
-
-    def sink(proposal):
-        calls.append(proposal.plugin_id)
-        if len(calls) == 1:
-            raise RuntimeError("queue full")
-        return proposal.proposal_id
-
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher((_intent("chat.reply"), _intent("chat.react"))),
-        intake=_Intake(admit=True),
-        proposal_sink=sink,
-    )
-
-    result = await driver.drive([{"action": "a"}])
-
-    assert len(calls) == 2, "the second intent must still be attempted"
-    assert len(result.queued_proposal_ids) == 1
-
-
-# ── rival identity: the collision that would stop competition ─────────────────
-
-
 def test_a_rival_gets_an_identity_that_can_coexist_with_the_incumbent():
     """A plugin id derived from the capability alone cannot compete with itself.
 
@@ -425,29 +273,6 @@ def test_successive_rivals_for_one_capability_stay_distinct():
     assert first.plugin_id != second.plugin_id
 
 
-@pytest.mark.asyncio
-async def test_the_driver_marks_a_rival_only_when_the_capability_is_degraded():
-    """Rival versus gap fill is a registry fact, never a reading of the hypothesis."""
-    queued: list[Any] = []
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher((_intent("chat.reply"), _intent("chat.react"))),
-        intake=_Intake(admit=True),
-        degraded_capabilities=lambda: (
-            {"capability": "chat.reply", "plugin_id": "chat_reply_v1", "failure_streak": 2},
-        ),
-        proposal_sink=lambda proposal: queued.append(proposal) or proposal.proposal_id,
-    )
-
-    await driver.drive([{"action": "a"}])
-
-    by_capability = {
-        dict(p.evidence[0].metadata)["capability"]: dict(p.evidence[0].metadata)
-        for p in queued
-    }
-    assert by_capability["chat.reply"]["replaces"] == "chat_reply_v1"
-    assert "replaces" not in by_capability["chat.react"], "an absent provider is a gap"
-
-
 def test_a_rival_cannot_widen_the_risk_ceiling():
     """More autonomy than filling a gap, so the clamp must still hold."""
     intent = EvolutionIntent.create(
@@ -463,125 +288,6 @@ def test_a_rival_cannot_widen_the_risk_ceiling():
     assert dict(rival.evidence[0].metadata)["requested_max_risk_level"] == "external"
 
 
-# ── the whole chain, against the real store ───────────────────────────────────
-
-
-@pytest.mark.asyncio
-async def test_the_trigger_chain_survives_the_real_observation_store(tmp_path):
-    """T1 to T3 with the durable store in the middle, which is where it broke.
-
-    Every unit above passes with a fake intake. The real store persists only an
-    allow-listed set of payload keys, and ``plugin_id``/``failure_streak`` were not on
-    it -- so the degradation facts arrived carrying ``None`` for both. The teacher then
-    could not tell what would be replaced, and proposal identity fell back to the
-    capability-derived name that collides with the incumbent. Nothing raised.
-    """
-    from leapflow.domain.evolution_intent import WORLD_MODEL_INTENT
-
-    store = JsonCapabilityObservationStore(tmp_path / "obs.json")
-    service = CapabilityObservationService(
-        store,
-        classifier=CapabilityEvidenceClassifier.from_kinds(
-            ["unknown_tool", CAPABILITY_DEGRADED, WORLD_MODEL_INTENT]
-        ),
-    )
-    declared = {"chat_reply_v1": ("chat.reply",)}
-
-    def sink(
-        *, plugin_id: str, failure_streak: int, trust_level: str, failure_class: str = ""
-    ) -> None:
-        for capability in declared.get(plugin_id, ()):
-            service.observe_result(
-                {
-                    "error_type": CAPABILITY_DEGRADED,
-                    "capability": capability,
-                    "plugin_id": plugin_id,
-                    "failure_streak": failure_streak,
-                    "trust_level": trust_level,
-                    "failure_class": failure_class,
-                }
-            )
-
-    governor = LifecycleGovernor(
-        proposal_queue=_Queue(), outcome_store=_Outcomes(2), degradation_sink=sink
-    )
-    await _record(governor, ok=False)
-
-    # The service's own reader, so the filter and the environment tag are applied
-    # once rather than re-derived by every consumer.
-    degraded = service.degraded_capabilities
-
-    # The incumbent must survive the round trip through the store.
-    facts = degraded()
-    assert facts and facts[0]["plugin_id"] == "chat_reply_v1", facts
-    assert str(facts[0]["failure_streak"]) == "2", facts
-
-    teacher = _Teacher((_intent("chat.reply"),))
-    queued: list[Any] = []
-    driver = WorldModelEvolutionDriver(
-        teacher=teacher,
-        intake=service,
-        degraded_capabilities=degraded,
-        proposal_sink=lambda proposal: queued.append(proposal) or proposal.proposal_id,
-    )
-
-    result = await driver.drive([{"action": "reply"}], "reply in the thread")
-
-    assert result.admitted == 1 and len(result.queued_proposal_ids) == 1
-    rival = queued[0]
-    assert dict(rival.evidence[0].metadata)["replaces"] == "chat_reply_v1"
-
-    # And it can coexist with what a gap fill for the same capability would be named.
-    gap_fill = CapabilityGapDetector().proposal_from_evolution_intent(_intent("chat.reply"))
-    assert rival.plugin_id != gap_fill.plugin_id
-
-    # The degradation record is not erased by the incumbent still being found.
-    service.resolve_capability("chat.reply", reason="incumbent serves it")
-    assert degraded(), "degradation evidence must outlive a met resolution"
-
-
-@pytest.mark.asyncio
-async def test_a_partially_admitted_batch_queues_only_what_was_admitted():
-    """The side door the opt-in gate exists to prevent.
-
-    Collecting only the admitted observation *ids* was enough to count admissions and
-    not enough to act on them: queueing then received every intent whenever any one of
-    them was admitted, so a rejected hypothesis reached the proposal queue anyway. It is
-    invisible today because the shipped intake accepts a kind wholesale, and becomes a
-    real bypass the moment admission is decided per intent.
-    """
-
-    class _Selective:
-        """Admits only the capability it was told to."""
-
-        def __init__(self, allow: str) -> None:
-            self.allow = allow
-            self.seen: list[str] = []
-
-        def observe_result(self, result, **kwargs):
-            capability = str((result or {}).get("capability") or "")
-            self.seen.append(capability)
-            return {"observation_id": f"o-{capability}"} if capability == self.allow else None
-
-        def requirements(self, *, min_count: int = 1, limit: int = 50):
-            return ()
-
-    intake = _Selective("chat.reply")
-    queued: list[Any] = []
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher((_intent("chat.reply"), _intent("chat.react"))),
-        intake=intake,
-        proposal_sink=lambda proposal: queued.append(proposal) or proposal.proposal_id,
-    )
-
-    result = await driver.drive([{"action": "a"}])
-
-    assert intake.seen == ["chat.reply", "chat.react"], "both were offered to the gate"
-    assert result.proposed == 2 and result.admitted == 1
-    assert len(queued) == 1, "only the admitted intent may be queued"
-    assert dict(queued[0].evidence[0].metadata)["capability"] == "chat.reply"
-
-
 # ── A4-A6: the facts must be classified, filtered and environment-tagged ──────
 
 
@@ -773,63 +479,3 @@ def test_one_degradation_is_not_told_it_might_be_several():
         ]
     )
     assert "one change rather than several" in two
-
-
-def test_an_unknown_environment_does_not_mark_every_alternative_unusable():
-    """Undescribed must read as "cannot judge", not "nothing is available".
-
-    The other reading would mark every alternative a misfit and push every verdict toward
-    acquire -- the most expensive branch -- for the sole reason that the environment could
-    not be described.
-    """
-    from leapflow.learning.degradation_sink import build_alternatives_provider
-    from leapflow.plugins.protocol import ToolMetadata
-
-    tool = ToolMetadata(
-        name="chat_reply_v2",
-        description="reply",
-        parameters_schema={"type": "object", "properties": {}},
-        handler=lambda **kwargs: None,
-        x_leapflow={"category": "chat", "risk_level": "read_only"},
-        provides_capabilities=("chat.reply",),
-        requires_environment_affordances=("app.chat.v2",),
-    )
-    registry = SimpleNamespace(
-        plugins={"v2": SimpleNamespace(tools=[tool])},
-        tool_owners={"chat_reply_v2": "v2"},
-        tool_handlers={"chat_reply_v2": tool.handler},
-    )
-
-    unknown = build_alternatives_provider(
-        registry_provider=lambda: registry, affordances_provider=lambda: ()
-    )("chat.reply", "v1")
-    assert unknown and unknown[0]["fits_here"] is True
-
-    absent = build_alternatives_provider(
-        registry_provider=lambda: registry, affordances_provider=lambda: ("app.chat.v1",)
-    )("chat.reply", "v1")
-    assert absent and absent[0]["fits_here"] is False
-
-
-def test_the_incumbent_is_not_offered_as_its_own_alternative():
-    """Rebinding to the thing that is failing is not an option."""
-    from leapflow.learning.degradation_sink import build_alternatives_provider
-    from leapflow.plugins.protocol import ToolMetadata
-
-    tool = ToolMetadata(
-        name="chat_reply_v1",
-        description="reply",
-        parameters_schema={"type": "object", "properties": {}},
-        handler=lambda **kwargs: None,
-        x_leapflow={"category": "chat", "risk_level": "read_only"},
-        provides_capabilities=("chat.reply",),
-    )
-    registry = SimpleNamespace(
-        plugins={"v1": SimpleNamespace(tools=[tool])},
-        tool_owners={"chat_reply_v1": "v1"},
-        tool_handlers={"chat_reply_v1": tool.handler},
-    )
-    provider = build_alternatives_provider(registry_provider=lambda: registry)
-
-    assert provider("chat.reply", "v1") == ()
-    assert len(provider("chat.reply", "")) == 1
diff --git a/tests/test_capability_resolver.py b/tests/test_capability_resolver.py
index 40c98b8c..26fda270 100644
--- a/tests/test_capability_resolver.py
+++ b/tests/test_capability_resolver.py
@@ -4,13 +4,16 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from types import SimpleNamespace
 from typing import Any, Sequence
 
 import pytest
 
+from leapflow.domain.adaptation_verdict import AdaptationVerdict
 from leapflow.domain.capability_requirement import CapabilityRequirement
 from leapflow.domain.environment_fingerprint import EnvironmentFingerprint
 from leapflow.domain.platform import Capability, PlatformID, PlatformManifest
+from leapflow.learning.degradation_sink import build_live_capability_resolver
 from leapflow.learning.plugin_stats import PluginUsageTracker
 from leapflow.learning.plugin_trust import PluginTrustLedger
 from leapflow.plugins.capability_resolver import (
@@ -90,6 +93,42 @@ def bind_runtime(self, **deps: Any) -> None:
         return None
 
 
+def test_live_acquisition_gate_resolves_against_current_registry() -> None:
+    tool = ToolMetadata(
+        name="repo_read",
+        description="Read repository files",
+        parameters_schema={"type": "object", "properties": {}},
+        handler=_handler,
+        x_leapflow={"risk_level": "read_only", "category": "test"},
+        provides_capabilities=("repository.inspect",),
+    )
+    registry = SimpleNamespace(
+        plugins={"repository_builtin": _Plugin("repository_builtin", [tool])},
+        tool_owners={"repo_read": "repository_builtin"},
+        tool_handlers={"repo_read": _handler},
+        assemble=lambda: None,
+    )
+    resolve = build_live_capability_resolver(
+        registry_provider=lambda: registry,
+        environment_provider=lambda: _env(Capability.FILE_OPS),
+    )
+    available = AdaptationVerdict.create(
+        "acquire", "repository.inspect", "Repository inspection is required."
+    ).to_intent()
+    missing = AdaptationVerdict.create(
+        "acquire", "mail.send", "Mail delivery is required."
+    ).to_intent()
+
+    available_result = resolve(available, {"session_id": "s1", "workspace_id": "w1"})
+    missing_result = resolve(missing, {"session_id": "s1", "workspace_id": "w1"})
+
+    assert available_result["resolved"] is True
+    assert available_result["satisfied"] is True
+    assert available_result["selected_plugin_id"] == "repository_builtin"
+    assert missing_result["resolved"] is True
+    assert missing_result["satisfied"] is False
+
+
 def test_resolver_selects_highest_scoring_declared_candidate() -> None:
     req = _req("json.pretty")
     env = _env(Capability.FILE_OPS)
diff --git a/tests/test_coevolution_sweep_wiring.py b/tests/test_coevolution_sweep_wiring.py
index 7f21aa93..b2e94f04 100644
--- a/tests/test_coevolution_sweep_wiring.py
+++ b/tests/test_coevolution_sweep_wiring.py
@@ -330,11 +330,14 @@ def test_active_proposal_ids_targets_the_newest_record_for_a_plugin(tmp_path):
     from leapflow.cli.context import Context
     from leapflow.domain.capability_requirement import CapabilityRequirement
     from leapflow.layout import ProfileLayout
-    from leapflow.storage.capability_proposal_queue import JsonCapabilityProposalQueue
+    from leapflow.storage.capability_proposal_queue import EvolutionCapabilityProposalStore
+    from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
 
     layout = ProfileLayout(root=tmp_path / "profile", profile_id="p")
     layout.root.mkdir(parents=True, exist_ok=True)
-    queue = JsonCapabilityProposalQueue(layout.capability_proposal_queue_path)
+    queue = EvolutionCapabilityProposalStore(
+        DuckDBEvolutionEventStore(tmp_path / "events.duckdb"), profile_id="p"
+    )
     queue.enqueue(
         requirements=(
             CapabilityRequirement.create("chat.reply", "world_model", requirement_id="req-a"),
@@ -350,7 +353,10 @@ def test_active_proposal_ids_targets_the_newest_record_for_a_plugin(tmp_path):
     # Bump the second record so it is unambiguously the most recently touched.
     queue.update(newer.proposal_id, status="GENERATED")
 
-    ctx = _Ctx(settings=SimpleNamespace(profile_layout=layout))
+    ctx = _Ctx(
+        settings=SimpleNamespace(profile_layout=layout),
+        _capability_proposal_queue=queue,
+    )
     mapping = Context._active_proposal_ids(ctx)
     assert mapping["shared_plugin"] == newer.proposal_id
 
diff --git a/tests/test_dashboard_view.py b/tests/test_dashboard_view.py
index 268b854d..1ff4eaa1 100644
--- a/tests/test_dashboard_view.py
+++ b/tests/test_dashboard_view.py
@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import asyncio
 from typing import Any
 
 from leapflow.dashboard import (
@@ -20,10 +21,12 @@ def __init__(
         watches: list[dict],
         findings: list[dict],
         signal_result: dict[str, Any] | None = None,
+        evolution_projection: dict[str, Any] | None = None,
     ) -> None:
         self._watches = watches
         self._findings = findings
         self._signal_result = signal_result or {"metrics": {}, "signal_stream": []}
+        self._evolution_projection = evolution_projection or {}
 
     async def watches(self) -> list[dict[str, Any]]:
         return list(self._watches)
@@ -35,6 +38,15 @@ async def findings(self, *, watch_id: str = "", limit: int = 50) -> list[dict[st
     async def signal_metrics(self) -> dict[str, Any]:
         return dict(self._signal_result)
 
+    async def evolution_projection(self, *, session_id: str) -> dict[str, Any]:
+        result = dict(self._evolution_projection)
+        result["session_id"] = session_id
+        result["scope"] = "session"
+        return {"ok": True, "projection": result}
+
+    async def evolution_projection_aggregate(self) -> dict[str, Any]:
+        return {"ok": True, "projection": dict(self._evolution_projection)}
+
 
 def _flatten(spec: dict) -> list[dict]:
     flat: list[dict] = []
@@ -506,12 +518,36 @@ def _evolution_provider(*, live_has_findings: bool = False) -> _FakeProvider:
 
 
 def _build(provider: _FakeProvider, template: str = "evolution") -> dict:
-    import asyncio
-
     builder = DashboardViewBuilder(TemplateLibrary())
     return asyncio.run(builder.build(DashboardIntent(template=template), provider))
 
 
+def test_evolution_view_overlays_the_event_projection_for_an_explicit_session():
+    provider = _evolution_provider()
+    provider._evolution_projection = {
+        "summary": {"episode_count": 2, "by_action": {"absorb": 1}},
+        "timeline": [{"title": "world_model → absorb", "summary": "repo.inspect"}],
+        "episodes": [{"episode_id": "ep-1", "status": "committed"}],
+        "mutation_matrix": [],
+        "degraded": False,
+    }
+    builder = DashboardViewBuilder(TemplateLibrary())
+    spec = asyncio.run(
+        builder.build(DashboardIntent(template="evolution", session_id="session-a"), provider)
+    )
+
+    stats = {
+        node["props"].get("label"): node["props"].get("value")
+        for node in _flatten(spec)
+        if node.get("type") == "Stat"
+    }
+    assert stats["Recent episodes"] == 2
+    assert stats["Plugins"] == 17
+    assert spec["meta"]["evolution_projection"]["session_id"] == "session-a"
+    timeline = next(node for node in _flatten(spec) if node.get("type") == "Timeline")
+    assert timeline["props"]["data"][0]["summary"] == "repo.inspect"
+
+
 def test_a_second_watch_on_a_domain_cannot_blank_the_board():
     """The data existed under a sibling watch, and the page rendered em dashes.
 
diff --git a/tests/test_degradation_feedback_loop.py b/tests/test_degradation_feedback_loop.py
index 59d36ef7..895d1fd4 100644
--- a/tests/test_degradation_feedback_loop.py
+++ b/tests/test_degradation_feedback_loop.py
@@ -23,7 +23,9 @@
 import pytest
 
 from leapflow.domain.adaptation_verdict import AdaptationVerdict
-from leapflow.engine.engine import AgentEngine
+from leapflow.domain.event_types import EvolutionEventType
+from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent
+from leapflow.evolution.teacher_worker import DurableTeacherWorker
 from leapflow.learning.capability_observation import (
     CAPABILITY_DEGRADED,
     CapabilityEvidenceClassifier,
@@ -33,15 +35,25 @@
     build_degradation_sink,
     declared_capabilities_by_plugin,
 )
-from leapflow.learning.world_model_driver import WorldModelEvolutionDriver
 from leapflow.plugins.lifecycle_governor import LifecycleGovernor
 from leapflow.plugins.protocol import ToolMetadata
 from leapflow.storage.capability_observation_store import JsonCapabilityObservationStore
-from leapflow.storage.distilled_knowledge_store import JsonDistilledKnowledgeStore
-from leapflow.world_model.trajectory_grader import (
-    TeacherVerdict,
-    _degraded_capability_section,
-)
+from leapflow.storage.distilled_knowledge_store import EvolutionDistilledKnowledgeStore
+from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+from leapflow.world_model.trajectory_grader import _degraded_capability_section
+
+
+def _seed_verdict(events: DuckDBEvolutionEventStore, verdict: AdaptationVerdict) -> None:
+    """Commit one verdict as a durable fact, as the teacher worker would."""
+    events.append(
+        EvolutionEvent.create(
+            EvolutionEventType.TEACHER_VERDICT_RECORDED,
+            context=EvolutionContext(profile_id="p", decision_id=verdict.verdict_id),
+            payload=verdict.to_dict(),
+            producer="test",
+            dedup_key=f"teacher.verdict_recorded:{verdict.verdict_id}",
+        )
+    )
 
 
 def _tool(name: str, *capabilities: str) -> ToolMetadata:
@@ -96,7 +108,9 @@ def wired(tmp_path):
             ["unknown_tool", CAPABILITY_DEGRADED]
         ),
     )
-    knowledge = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
+    knowledge_events = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    knowledge = EvolutionDistilledKnowledgeStore(knowledge_events, profile_id="p")
+    knowledge.refresh()
     registry = _registry(chat_reply_v1=(_tool("chat_reply", "chat.reply"),))
     outcomes = _Outcomes()
     governor = LifecycleGovernor(
@@ -109,7 +123,22 @@ def wired(tmp_path):
         ),
     )
     return SimpleNamespace(
-        service=service, knowledge=knowledge, governor=governor, outcomes=outcomes
+        service=service,
+        knowledge=knowledge,
+        events=knowledge_events,
+        governor=governor,
+        outcomes=outcomes,
+    )
+
+
+def _worker(wired: Any) -> DurableTeacherWorker:
+    """A worker built only far enough to exercise degradation enrichment."""
+    return DurableTeacherWorker(
+        store=SimpleNamespace(),
+        artifact_store=SimpleNamespace(),
+        teacher=SimpleNamespace(),
+        degraded_capabilities=wired.service.degraded_capabilities,
+        knowledge_projection=wired.knowledge,
     )
 
 
@@ -209,25 +238,16 @@ def test_the_teacher_is_shown_what_it_concluded_last_time(wired):
     """Without this the loop is open: the same evidence can only produce the same answer."""
     wired.outcomes.streak = 2
     _record(wired.governor, ok=False, failure_class="affordance_removed")
-    wired.knowledge.record(
+    _seed_verdict(
+        wired.events,
         AdaptationVerdict.create(
             "absorb", "chat.reply", "the send control moved to the toolbar"
-        )
+        ),
     )
+    wired.knowledge.refresh()
 
-    seen: list[Any] = []
-
-    class _Teacher:
-        async def grade_and_propose(self, trajectory, goal="", **kwargs):
-            seen.append(kwargs.get("degraded_capabilities"))
-            return TeacherVerdict()
-
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher(), intake=wired.service, knowledge_store=wired.knowledge
-    )
-    asyncio.run(driver.drive([{"action": "a"}], "reply"))
+    facts = _worker(wired)._collect_degraded_capabilities()
 
-    facts = seen[0]
     assert facts[0]["prior_action"] == "absorb"
     assert "moved to the toolbar" in facts[0]["prior_knowledge"]
 
@@ -240,10 +260,7 @@ def test_a_capability_with_no_prior_verdict_is_unchanged(wired):
     wired.outcomes.streak = 2
     _record(wired.governor, ok=False)
 
-    driver = WorldModelEvolutionDriver(
-        teacher=SimpleNamespace(), intake=wired.service, knowledge_store=wired.knowledge
-    )
-    facts = driver._collect_degraded()
+    facts = _worker(wired)._collect_degraded_capabilities()
     assert facts and "prior_action" not in facts[0]
 
 
@@ -284,9 +301,12 @@ def test_recovery_retires_the_knowledge_that_described_the_failure(wired):
     No newer verdict is coming precisely because there is no longer anything wrong, so
     without this the knowledge outlives the failure and misleads every later session.
     """
-    wired.knowledge.record(
-        AdaptationVerdict.create("absorb", "chat.reply", "the control is missing")
+    wired.knowledge.count()  # projection is live
+    _seed_verdict(
+        wired.events,
+        AdaptationVerdict.create("absorb", "chat.reply", "the control is missing"),
     )
+    wired.knowledge.refresh()
     assert wired.knowledge.count() == 1
 
     wired.outcomes.streak = 0
@@ -296,9 +316,11 @@ def test_recovery_retires_the_knowledge_that_described_the_failure(wired):
 
 
 def test_a_still_failing_capability_keeps_its_knowledge(wired):
-    wired.knowledge.record(
-        AdaptationVerdict.create("absorb", "chat.reply", "the control is missing")
+    _seed_verdict(
+        wired.events,
+        AdaptationVerdict.create("absorb", "chat.reply", "the control is missing"),
     )
+    wired.knowledge.refresh()
     wired.outcomes.streak = 2
     _record(wired.governor, ok=False)
 
@@ -317,58 +339,6 @@ def test_retirement_without_a_knowledge_store_is_harmless(tmp_path):
     sink(plugin_id="v1", failure_streak=0, trust_level="DRAFT")  # must not raise
 
 
-# ── D3: the recommendation reaches the student ─────────────────────────────────
-
-
-def _reader(store: Any) -> AgentEngine:
-    engine = AgentEngine.__new__(AgentEngine)
-    engine._knowledge_store = store
-    engine._environment_fingerprint_id = ""
-    engine._settings = SimpleNamespace(distilled_knowledge_limit=12)
-    return engine
-
-
-def test_a_rebind_target_tells_the_student_what_to_prefer(tmp_path):
-    """Stored and never read by anyone is the failure mode this closes.
-
-    The student would be told a problem exists without being told the answer that was
-    already worked out.
-    """
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    store.record(
-        AdaptationVerdict.create(
-            "rebind", "chat.reply", "the app is now v3", target="chat_reply_v3"
-        )
-    )
-
-    block = _reader(store)._distilled_knowledge_context()
-    assert "Prefer chat_reply_v3." in block
-
-
-def test_an_escalation_target_names_what_a_person_must_do(tmp_path):
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    store.record(
-        AdaptationVerdict.create(
-            "escalate",
-            "drive.upload",
-            "uploading is refused",
-            target="grant the drive.file scope",
-        )
-    )
-
-    block = _reader(store)._distilled_knowledge_context()
-    assert "This needs a person to: grant the drive.file scope." in block
-
-
-def test_a_verdict_without_a_target_adds_no_hint(tmp_path):
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    store.record(AdaptationVerdict.create("absorb", "chat.react", "it moved"))
-
-    block = _reader(store)._distilled_knowledge_context()
-    assert "- chat.react: it moved" in block
-    assert "Prefer" not in block and "needs a person" not in block
-
-
 # ── the whole loop, over two sessions ──────────────────────────────────────────
 
 
@@ -379,37 +349,25 @@ def test_two_sessions_close_the_loop(wired):
     governor was never constructed, so no evidence was produced, so no verdict was
     reachable, so nothing was distilled and nothing could be reconsidered.
     """
-    # Session one: the capability degrades and the teacher absorbs it.
+    worker = _worker(wired)
+
+    # Session one: the capability degrades and nothing is known yet.
     wired.outcomes.streak = 2
     _record(wired.governor, ok=False, failure_class="affordance_removed")
+    first = worker._collect_degraded_capabilities()
+    assert first and "prior_action" not in first[0], "nothing was known yet"
 
-    verdicts = (
+    # The teacher absorbs it -- committed as a durable verdict fact.
+    _seed_verdict(
+        wired.events,
         AdaptationVerdict.create("absorb", "chat.reply", "the control moved to the toolbar"),
     )
-    seen: list[Any] = []
-
-    class _Teacher:
-        def __init__(self, out) -> None:
-            self.out = out
-
-        async def grade_and_propose(self, trajectory, goal="", **kwargs):
-            seen.append(kwargs.get("degraded_capabilities"))
-            return TeacherVerdict(grades=(), verdicts=self.out)
-
-    first = WorldModelEvolutionDriver(
-        teacher=_Teacher(verdicts), intake=wired.service, knowledge_store=wired.knowledge
-    )
-    result = asyncio.run(first.drive([{"action": "a"}], "reply"))
-    assert result.distilled == ("chat.reply",)
-    assert seen[0] and "prior_action" not in seen[0][0], "nothing was known yet"
+    wired.knowledge.refresh()
 
     # Session two: it still fails, and now the teacher sees its own previous answer.
     _record(wired.governor, ok=False, failure_class="affordance_removed")
-    second = WorldModelEvolutionDriver(
-        teacher=_Teacher(()), intake=wired.service, knowledge_store=wired.knowledge
-    )
-    asyncio.run(second.drive([{"action": "a"}], "reply"))
-    assert seen[1][0]["prior_action"] == "absorb"
+    second = worker._collect_degraded_capabilities()
+    assert second[0]["prior_action"] == "absorb"
 
     # Session three: it works again, and the knowledge retires itself.
     wired.outcomes.streak = 0
@@ -433,20 +391,35 @@ def test_the_production_path_actually_builds_a_governor(tmp_path):
     layout = SimpleNamespace(
         distilled_knowledge_path=tmp_path / "dk.json",
         capability_observations_path=tmp_path / "obs.json",
-        capability_proposal_queue_path=tmp_path / "queue.json",
-        plugin_outcomes_path=tmp_path / "outcomes.json",
     )
+    from leapflow.storage.capability_proposal_queue import EvolutionCapabilityProposalStore
+    from leapflow.storage.distilled_knowledge_store import EvolutionDistilledKnowledgeStore
+    from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+    from leapflow.storage.plugin_outcome_store import EvolutionPluginOutcomeStore
+
     context = Context.__new__(Context)
     context.settings = SimpleNamespace(
+        profile="test",
         profile_layout=layout,
         distilled_knowledge_ttl_s=0.0,
         accepted_evidence_kinds=("capability_degraded",),
         workspace_root=str(tmp_path),
     )
+    event_store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    context._capability_proposal_queue = EvolutionCapabilityProposalStore(
+        event_store, profile_id="test"
+    )
+    context._plugin_outcome_store = EvolutionPluginOutcomeStore(
+        event_store, profile_id="test"
+    )
+    context._evolution_knowledge_store = EvolutionDistilledKnowledgeStore(
+        event_store, profile_id="test"
+    )
 
     governor = context._resolve_lifecycle_governor()
 
     assert governor is not None, "the sweep would run with governor=None"
+    event_store.close()
     assert context._resolve_lifecycle_governor() is governor, "built once, not per sweep"
     # And the sink must be attached, or the chain is wired but silent.
     assert governor._degradation_sink is not None
diff --git a/tests/test_distilled_knowledge.py b/tests/test_distilled_knowledge.py
index 762f7aed..ce73d04e 100644
--- a/tests/test_distilled_knowledge.py
+++ b/tests/test_distilled_knowledge.py
@@ -1,10 +1,10 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
-"""C1-C3: the distillation channel, from teacher's conclusion to student's context.
+"""C1: the distillation channel, from the teacher's committed verdict to the student.
 
-This is the cheapest way the system adapts, and until now the only edge from teacher to
-student was a single bit -- which tools are visible. Everything the teacher concluded
-about *why* the environment behaved as it did was graded, traced, and thrown away, so a
-correct judgement bought nothing and the next session repeated the same mistake.
+This is the cheapest way the system adapts. The durable teacher worker commits a
+``TEACHER_VERDICT_RECORDED`` fact per verdict; ``EvolutionDistilledKnowledgeStore``
+projects those facts into the read model the acting agent consults. There is no second
+durable store — the projection is the single source, rebuilt from events.
 
 Retirement is tested as heavily as recording, because stale knowledge does not merely go
 unused: the acting agent cannot tell a current fact from one that expired three upgrades
@@ -14,43 +14,54 @@
 
 from __future__ import annotations
 
-import asyncio
 import time
 from types import SimpleNamespace
 from typing import Any
 
 from leapflow.domain.adaptation_verdict import AdaptationVerdict
-from leapflow.domain.environment_fingerprint import EnvironmentFingerprint
-from leapflow.domain.platform import Capability, PlatformID, PlatformManifest
+from leapflow.domain.event_types import EvolutionEventType
+from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent
 from leapflow.engine.engine import AgentEngine
-from leapflow.learning.world_model_driver import WorldModelEvolutionDriver
 from leapflow.storage.distilled_knowledge_store import (
     DistilledKnowledge,
-    JsonDistilledKnowledgeStore,
+    EvolutionDistilledKnowledgeStore,
 )
-from leapflow.world_model.trajectory_grader import TeacherVerdict
+from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
 
 
-def _env(os_version: str = "15.0", extra: bool = False) -> EnvironmentFingerprint:
-    names = sorted(c.name for c in Capability)
-    caps = {Capability[names[0]]}
-    if extra:
-        caps.add(Capability[names[1]])
-    return EnvironmentFingerprint.from_platform_manifest(
-        PlatformManifest(PlatformID.DARWIN_15, os_version, frozenset(caps))
+def _verdict(action: str, capability: str, knowledge: str, **kw: Any) -> AdaptationVerdict:
+    return AdaptationVerdict.create(action, capability, knowledge, **kw)
+
+
+def _events(tmp_path) -> DuckDBEvolutionEventStore:
+    return DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+
+
+def _seed(store: DuckDBEvolutionEventStore, verdict: AdaptationVerdict, *, seq: int = 0) -> None:
+    """Commit one verdict as a durable fact, exactly as the teacher worker would."""
+    payload = verdict.to_dict()
+    store.append(
+        EvolutionEvent.create(
+            EvolutionEventType.TEACHER_VERDICT_RECORDED,
+            context=EvolutionContext(profile_id="p", decision_id=verdict.verdict_id),
+            payload=payload,
+            producer="test",
+            dedup_key=f"teacher.verdict_recorded:{verdict.verdict_id}:{seq}",
+        )
     )
 
 
-def _verdict(action: str, capability: str, knowledge: str, **kw: Any) -> AdaptationVerdict:
-    return AdaptationVerdict.create(action, capability, knowledge, **kw)
+def _knowledge(tmp_path, *verdicts: AdaptationVerdict, ttl_seconds: float = 0.0):
+    events = _events(tmp_path)
+    for index, verdict in enumerate(verdicts):
+        _seed(events, verdict, seq=index)
+    store = EvolutionDistilledKnowledgeStore(events, profile_id="p", ttl_seconds=ttl_seconds)
+    store.refresh()
+    return events, store
 
 
 def _reader(store: Any, *, fingerprint: str = "", limit: int = 12) -> AgentEngine:
-    """An engine with only what this context layer reads, bound directly.
-
-    Bound rather than resolved, so the test exercises the rendering rather than the lazy
-    lookup -- which has its own test below.
-    """
+    """An engine with only what this context layer reads, bound directly."""
     engine = AgentEngine.__new__(AgentEngine)
     engine._knowledge_store = store
     engine._knowledge_store_unavailable = False
@@ -59,44 +70,42 @@ def _reader(store: Any, *, fingerprint: str = "", limit: int = 12) -> AgentEngin
     return engine
 
 
-# ── recording ─────────────────────────────────────────────────────────────────
+# ── recording: a committed verdict becomes durable, replayable knowledge ────────
 
 
-def test_a_verdict_becomes_a_durable_fact(tmp_path):
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    entry = store.record(
-        _verdict("rebind", "chat.reply", "the send control is now labelled Dispatch"),
-        environment=_env().to_dict(),
+def test_a_committed_verdict_becomes_durable_knowledge(tmp_path):
+    events, store = _knowledge(
+        tmp_path,
+        _verdict("rebind", "chat.reply", "the send control is now labelled Dispatch",
+                 target="chat_v2"),
     )
 
+    entry = store.for_capability("chat.reply")
     assert isinstance(entry, DistilledKnowledge)
     assert entry.capability == "chat.reply"
-    assert entry.environment_id == _env().fingerprint_id
-
-    # And it survives a fresh reader, which is the whole point of persisting it.
-    assert JsonDistilledKnowledgeStore(tmp_path / "dk.json").count() == 1
-
-
-def test_a_verdict_without_knowledge_is_refused(tmp_path):
-    """The parser already rejects this shape, so reaching here means something changed."""
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    assert store.record(SimpleNamespace(capability="chat.reply", knowledge="")) is None
-    assert store.record(SimpleNamespace(capability="", knowledge="something")) is None
-    assert store.count() == 0
-
+    assert store.count() == 1
 
-def test_a_batch_is_one_write_and_the_last_word_wins(tmp_path):
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    stored = store.record_all(
-        [
-            _verdict("absorb", "chat.reply", "first conclusion"),
-            _verdict("rebind", "chat.reply", "second conclusion"),
-            _verdict("absorb", "chat.react", "unrelated"),
-        ]
+    # A fresh projection over the same events reconstructs the entry: the events are
+    # the source, not any in-memory state.
+    replayed = EvolutionDistilledKnowledgeStore(events, profile_id="p")
+    replayed.refresh()
+    assert replayed.count() == 1
+    events.close()
+
+
+def test_all_four_actions_are_disclosed_as_knowledge(tmp_path):
+    """Every verdict carries mandatory knowledge; the student sees all four actions."""
+    _events_store, store = _knowledge(
+        tmp_path,
+        _verdict("absorb", "chat.react", "the control moved to the overflow menu"),
+        _verdict("rebind", "chat.reply", "the app is v3", target="chat_reply_v3"),
+        _verdict("acquire", "mail.send", "nothing installed sends mail"),
+        _verdict("escalate", "drive.upload", "a person must grant the drive scope",
+                 target="grant drive.file"),
     )
 
-    assert len(stored) == 2, "one entry per capability, even within a batch"
-    assert store.for_capability("chat.reply").knowledge == "second conclusion"
+    assert store.count() == 4
+    _events_store.close()
 
 
 # ── retirement: three ways out, and only three ─────────────────────────────────
@@ -104,70 +113,58 @@ def test_a_batch_is_one_write_and_the_last_word_wins(tmp_path):
 
 def test_a_newer_verdict_supersedes_the_older_one(tmp_path):
     """Keeping both live would show the agent a capability's contradictory past."""
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    store.record(_verdict("rebind", "chat.reply", "v3: the control is Dispatch"))
-    store.record(_verdict("absorb", "chat.reply", "v4: the control is Send again"))
+    events, store = _knowledge(
+        tmp_path,
+        _verdict("rebind", "chat.reply", "v3: the control is Dispatch"),
+    )
+    later = AdaptationVerdict.create(
+        "absorb", "chat.reply", "v4: the control is Send again",
+        created_at=time.time() + 10,
+    )
+    _seed(events, later, seq=1)
+    store.refresh()
 
     assert store.count() == 1
     assert store.for_capability("chat.reply").knowledge.startswith("v4")
+    events.close()
 
 
 def test_knowledge_expires_and_expiry_is_applied_on_read(tmp_path):
     """A sweep would leave stale facts disclosed until some unrelated write happened."""
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json", ttl_seconds=1.0)
-    store.record(_verdict("absorb", "mail.send", "the sent folder was renamed"))
+    _events_store, store = _knowledge(
+        tmp_path,
+        _verdict("absorb", "mail.send", "the sent folder was renamed"),
+        ttl_seconds=1.0,
+    )
 
     assert store.count() == 1
     assert store.live(now=time.time() + 5) == ()
+    _events_store.close()
 
 
 def test_ttl_zero_disables_expiry(tmp_path):
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json", ttl_seconds=0.0)
-    store.record(_verdict("absorb", "mail.send", "still true"))
+    _events_store, store = _knowledge(
+        tmp_path,
+        _verdict("absorb", "mail.send", "still true"),
+        ttl_seconds=0.0,
+    )
     assert len(store.live(now=time.time() + 10_000_000)) == 1
+    _events_store.close()
 
 
 def test_knowledge_can_be_retracted_when_it_is_obsolete(tmp_path):
-    """The only retirement a caller drives, and the only one that covers recovery.
-
-    A capability observed working again makes knowledge describing its failure
-    misleading, and neither supersession nor expiry removes it -- no newer verdict is
-    coming precisely because there is no longer anything wrong.
-    """
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    store.record(_verdict("absorb", "chat.react", "the control is missing"))
-    store.record(_verdict("absorb", "chat.reply", "unrelated"))
+    """The only retirement a caller drives, and the only one that covers recovery."""
+    events, store = _knowledge(
+        tmp_path,
+        _verdict("absorb", "chat.react", "the control is missing"),
+        _verdict("absorb", "chat.reply", "unrelated"),
+    )
 
     assert store.retract("chat.react", reason="observed working") is True
     assert [e.capability for e in store.live()] == ["chat.reply"]
     assert store.retract("chat.react") is False, "retracting twice is a no-op"
     assert store.retract("") is False
-
-
-# ── the environment is disclosed, never used to filter ─────────────────────────
-
-
-def test_a_fact_from_another_environment_is_disclosed_as_such(tmp_path):
-    """Filtering on fingerprint mismatch would discard good knowledge on any upgrade.
-
-    Whether an OS point release invalidates "the send control is labelled Dispatch" is a
-    judgement about meaning. A predicate here would be a hard rule with no ability to
-    generalise, so the mismatch is surfaced and the reader weighs it.
-    """
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    store.record(
-        _verdict("rebind", "chat.reply", "the control is Dispatch"),
-        environment=_env().to_dict(),
-    )
-
-    same = _reader(store, fingerprint=_env().fingerprint_id)._distilled_knowledge_context()
-    other = _reader(
-        store, fingerprint=_env("15.7", extra=True).fingerprint_id
-    )._distilled_knowledge_context()
-
-    assert "different environment" not in same
-    assert "chat.reply" in other, "knowledge is not dropped for a changed environment"
-    assert "learned in a different environment" in other
+    events.close()
 
 
 # ── the student's context ──────────────────────────────────────────────────────
@@ -175,21 +172,55 @@ def test_a_fact_from_another_environment_is_disclosed_as_such(tmp_path):
 
 def test_the_student_sees_distilled_knowledge_as_observations(tmp_path):
     """The C1 payload, rendered. Framed as observations because it is not an order."""
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    store.record(_verdict("rebind", "chat.reply", "the control is now Dispatch"))
+    _events_store, store = _knowledge(
+        tmp_path,
+        _verdict("rebind", "chat.reply", "the control is now Dispatch", target="chat_v2"),
+    )
 
     block = _reader(store)._distilled_knowledge_context()
 
     assert "What is known about this environment" in block
     assert "- chat.reply: the control is now Dispatch" in block
     assert "not instructions" in block, "it must not read as a command to the framework"
+    _events_store.close()
+
+
+def test_a_rebind_target_tells_the_student_what_to_prefer(tmp_path):
+    _events_store, store = _knowledge(
+        tmp_path,
+        _verdict("rebind", "chat.reply", "the app is now v3", target="chat_reply_v3"),
+    )
+    block = _reader(store)._distilled_knowledge_context()
+    assert "Prefer chat_reply_v3." in block
+    _events_store.close()
+
+
+def test_an_escalation_target_names_what_a_person_must_do(tmp_path):
+    _events_store, store = _knowledge(
+        tmp_path,
+        _verdict("escalate", "drive.upload", "the scope was revoked",
+                 target="grant the drive.file scope"),
+    )
+    block = _reader(store)._distilled_knowledge_context()
+    assert "This needs a person to: grant the drive.file scope." in block
+    _events_store.close()
+
+
+def test_a_verdict_without_a_target_adds_no_hint(tmp_path):
+    _events_store, store = _knowledge(
+        tmp_path,
+        _verdict("absorb", "chat.react", "it moved"),
+    )
+    block = _reader(store)._distilled_knowledge_context()
+    assert "- chat.react: it moved" in block
+    assert "Prefer" not in block and "needs a person" not in block
+    _events_store.close()
 
 
 def test_the_disclosed_set_is_bounded(tmp_path):
     """The channel meant to improve context must not come to dominate it."""
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    for i in range(20):
-        store.record(_verdict("absorb", f"cap{i:02d}.thing", f"fact {i}"))
+    verdicts = [_verdict("absorb", f"cap{i:02d}.thing", f"fact {i}") for i in range(20)]
+    _events_store, store = _knowledge(tmp_path, *verdicts)
 
     lines = [
         line
@@ -197,221 +228,68 @@ def test_the_disclosed_set_is_bounded(tmp_path):
         if line.startswith("- ")
     ]
     assert len(lines) == 3
+    _events_store.close()
 
 
 def test_an_empty_or_absent_store_produces_no_block(tmp_path):
-    assert _reader(JsonDistilledKnowledgeStore(tmp_path / "e.json"))._distilled_knowledge_context() == ""
+    _events_store, store = _knowledge(tmp_path)
+    assert _reader(store)._distilled_knowledge_context() == ""
 
     bare = AgentEngine.__new__(AgentEngine)
     bare._knowledge_store = None
-    bare._knowledge_store_unavailable = False
+    bare._knowledge_store_unavailable = True
     bare._environment_fingerprint_id = ""
-    bare._settings = SimpleNamespace(distilled_knowledge_limit=12, profile_layout=None)
-    assert bare._distilled_knowledge_context() == "", "no profile layout must degrade, not fail"
-
+    bare._settings = SimpleNamespace(distilled_knowledge_limit=12)
+    assert bare._distilled_knowledge_context() == "", "no store must degrade, not fail"
+    _events_store.close()
 
-def test_a_corrupt_store_degrades_context_rather_than_failing_a_turn(tmp_path):
-    """Distilled knowledge is an improvement to context, so absence costs quality only."""
-    path = tmp_path / "bad.json"
-    path.write_text("{not json", encoding="utf-8")
-    store = JsonDistilledKnowledgeStore(path)
 
-    assert store.count() == 0
-    assert _reader(store)._distilled_knowledge_context() == ""
-
-
-def test_the_reader_binds_itself_rather_than_depending_on_another_path(tmp_path):
-    """The adaptive loop builds an equivalent store, but only when resolving a capability.
-
-    Relying on it would make knowledge appear or vanish for reasons unrelated to
-    knowledge -- so this layer resolves its own reader.
-    """
+def test_the_reader_uses_the_injected_event_projection(tmp_path):
+    """The hot path reads a shared projection and never opens a parallel JSON store."""
+    _events_store, store = _knowledge(
+        tmp_path,
+        _verdict("rebind", "chat.reply", "the control is Dispatch", target="chat_v2"),
+    )
     engine = AgentEngine.__new__(AgentEngine)
     engine._knowledge_store = None
     engine._knowledge_store_unavailable = False
     engine._environment_fingerprint_id = ""
     engine._settings = SimpleNamespace(
         distilled_knowledge_limit=12,
-        distilled_knowledge_ttl_s=0.0,
         workspace_root=str(tmp_path),
-        profile_layout=SimpleNamespace(distilled_knowledge_path=tmp_path / "dk.json"),
-    )
-
-    store = engine._resolve_knowledge_store()
-    assert store is not None
-    assert engine._environment_fingerprint_id, "the current environment must be known"
-    assert engine._resolve_knowledge_store() is store, "bound once, not per turn"
-
-
-# ── the driver writes it, and writes it whatever else happened ──────────────────
-
-
-class _Teacher:
-    def __init__(self, verdicts) -> None:
-        self._verdict = TeacherVerdict(grades=(), verdicts=tuple(verdicts))
-
-    async def grade_and_propose(self, trajectory, goal="", **kwargs):
-        return self._verdict
-
-
-class _Intake:
-    def observe_result(self, result, **kwargs):
-        return None
-
-    def requirements(self, *, min_count: int = 1, limit: int = 50):
-        return ()
-
-
-def test_a_session_that_only_absorbed_still_taught_the_next_one(tmp_path):
-    """The cheapest adaptation, and the one that used to leave no trace at all."""
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher(
-            [
-                _verdict("absorb", "chat.react", "the control moved to the overflow menu"),
-                _verdict("rebind", "chat.reply", "the app is v3", target="chat_reply_v3"),
-            ]
-        ),
-        intake=_Intake(),
-        knowledge_store=store,
-    )
-
-    result = asyncio.run(driver.drive([{"action": "a"}], "reply", environment=_env()))
-
-    assert set(result.distilled) == {"chat.react", "chat.reply"}
-    assert result.queued_proposal_ids == (), "no code was written"
-    assert store.count() == 2
-    assert result.to_dict()["distilled"] == list(result.distilled)
-    # The environment travelled with it, so a later session can see where it came from.
-    assert store.for_capability("chat.reply").environment_id == _env().fingerprint_id
-
-
-def test_a_failing_store_does_not_fail_the_session(tmp_path):
-    """Distillation improves the next session; it must never break this one."""
-
-    class _Broken:
-        def record_all(self, verdicts, **kwargs):
-            raise OSError("disk full")
-
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher([_verdict("absorb", "chat.react", "moved")]),
-        intake=_Intake(),
-        knowledge_store=_Broken(),
-    )
-
-    result = asyncio.run(driver.drive([{"action": "a"}], "reply"))
-    assert result.distilled == ()
-    assert len(result.verdicts) == 1, "the verdict is still reported"
-
-
-def test_a_driver_without_a_store_still_grades(tmp_path):
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher([_verdict("absorb", "chat.react", "moved")]), intake=_Intake()
-    )
-    result = asyncio.run(driver.drive([{"action": "a"}], "reply"))
-    assert result.distilled == () and len(result.verdicts) == 1
-
-
-# ── review findings: the invariants that keep the whitelist and the set honest ─
-
-
-def test_the_persisted_fields_and_the_record_agree_exactly(tmp_path):
-    """Bound in both directions, because each direction has its own failure.
-
-    A field the dataclass has and the whitelist lacks is the historical silent drop: the
-    value is written nowhere and reads back as a default, with nothing raised. An entry in
-    the whitelist with no matching field is the mirror image -- it claims to persist
-    something that never existed, which is how a whitelist stops being trustworthy.
-    ``"environment"`` was exactly that, left over from considering whether to store the
-    whole fingerprint.
-    """
-    from leapflow.storage.distilled_knowledge_store import _ENTRY_FIELDS
-
-    assert set(DistilledKnowledge("chat.reply", "k").to_dict()) == _ENTRY_FIELDS
-
-    # And the binding has to hold through a real round trip, not just in the abstract.
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    store.record(
-        _verdict("rebind", "chat.reply", "the control is Dispatch", target="v3"),
-        environment=_env().to_dict(),
     )
-    reloaded = JsonDistilledKnowledgeStore(tmp_path / "dk.json").for_capability("chat.reply")
-    assert reloaded.target == "v3"
-    assert reloaded.environment_id == _env().fingerprint_id
-    assert reloaded.action == "rebind"
-
-
-def test_supersession_bounds_the_store_by_the_capability_count(tmp_path):
-    """The answer to "does this grow unbounded on the hot path": it cannot.
-
-    One live entry per capability, so the ceiling is the number of capabilities the
-    system has -- not the number of sessions it has run. Measured at 200 entries,
-    ``live()`` costs single-digit microseconds, which is why no sweep or index is needed.
-    """
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    for round_number in range(50):
-        store.record(_verdict("absorb", "chat.reply", f"conclusion {round_number}"))
-
-    assert store.count() == 1
-    assert store.for_capability("chat.reply").knowledge == "conclusion 49"
-
-
-def test_every_retry_owned_class_is_one_a_classifier_emits():
-    """A member with no producer claims to filter something never seen.
-
-    ``"rate_limit"`` was in the set with no producer anywhere in the engine. Harmless in
-    effect, and corrosive in meaning: the set is supposed to read as a statement about
-    which failures the retry layer owns, and an invented member makes it fiction.
-    """
-    import re
-    from pathlib import Path as _Path
 
-    from leapflow.learning.capability_observation import RETRY_OWNED_FAILURE_CLASSES
+    engine.set_distilled_knowledge_store(store)
 
-    engine_dir = _Path(__file__).resolve().parent.parent / "src" / "leapflow" / "engine"
-    emitted = set()
-    for path in engine_dir.rglob("*.py"):
-        emitted.update(re.findall(r'"([a-z_]+)"', path.read_text(encoding="utf-8")))
-
-    missing = RETRY_OWNED_FAILURE_CLASSES - emitted
-    assert not missing, f"no classifier emits: {sorted(missing)}"
+    assert engine._resolve_knowledge_store() is store
+    assert "chat.reply" in engine._distilled_knowledge_context()
+    assert engine._rebind_preferences() == (("chat.reply", "chat_v2"),)
+    _events_store.close()
 
 
 def test_an_unknown_action_still_discloses_its_recommendation(tmp_path):
     """A phrase table, so a fifth action loses nothing while its phrase is missing."""
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    store.record(
-        SimpleNamespace(
-            capability="chat.reply",
-            knowledge="something changed",
-            action="a_future_action",
-            verdict_id="adv-x",
-            confidence=0.5,
-            rationale="",
-            target="do the thing",
-            created_at=1.0,
+    events = _events(tmp_path)
+    events.append(
+        EvolutionEvent.create(
+            EvolutionEventType.TEACHER_VERDICT_RECORDED,
+            context=EvolutionContext(profile_id="p", decision_id="adv-x"),
+            payload={
+                "capability": "chat.reply",
+                "knowledge": "something changed",
+                "action": "a_future_action",
+                "verdict_id": "adv-x",
+                "confidence": 0.5,
+                "target": "do the thing",
+                "created_at": 1.0,
+            },
+            producer="test",
+            dedup_key="teacher.verdict_recorded:adv-x",
         )
     )
+    store = EvolutionDistilledKnowledgeStore(events, profile_id="p")
+    store.refresh()
 
     block = _reader(store)._distilled_knowledge_context()
     assert "do the thing" in block, "an unmapped action must not drop its target"
-
-
-def test_a_persistent_lookup_failure_costs_one_attempt_not_one_per_turn(tmp_path):
-    """The context layer runs every turn, so a failing lookup must not retry every turn."""
-    engine = AgentEngine.__new__(AgentEngine)
-    engine._knowledge_store = None
-    engine._knowledge_store_unavailable = False
-    engine._environment_fingerprint_id = ""
-    engine._settings = SimpleNamespace(
-        distilled_knowledge_limit=12,
-        distilled_knowledge_ttl_s=0.0,
-        workspace_root=str(tmp_path),
-        profile_layout=SimpleNamespace(
-            distilled_knowledge_path=property(lambda self: 1 / 0)  # raises on access
-        ),
-    )
-
-    assert engine._resolve_knowledge_store() is None
-    assert engine._knowledge_store_unavailable is True
-    assert engine._distilled_knowledge_context() == ""
+    events.close()
diff --git a/tests/test_distilled_preference.py b/tests/test_distilled_preference.py
index fd7c6afd..537d79d1 100644
--- a/tests/test_distilled_preference.py
+++ b/tests/test_distilled_preference.py
@@ -21,6 +21,8 @@
 from leapflow.domain.adaptation_verdict import AdaptationVerdict
 from leapflow.domain.capability_requirement import CapabilityRequirement
 from leapflow.domain.environment_fingerprint import EnvironmentFingerprint
+from leapflow.domain.event_types import EvolutionEventType
+from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent
 from leapflow.domain.platform import Capability, PlatformID, PlatformManifest
 from leapflow.plugins.capability_resolver import (
     _DEFAULT_SCORERS,
@@ -30,7 +32,29 @@
     EnvironmentAffordanceScorer,
     ResolverContext,
 )
-from leapflow.storage.distilled_knowledge_store import JsonDistilledKnowledgeStore
+from leapflow.storage.distilled_knowledge_store import EvolutionDistilledKnowledgeStore
+from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+
+
+def _seed(events: DuckDBEvolutionEventStore, verdict: AdaptationVerdict, seq: int = 0) -> None:
+    events.append(
+        EvolutionEvent.create(
+            EvolutionEventType.TEACHER_VERDICT_RECORDED,
+            context=EvolutionContext(profile_id="p", decision_id=verdict.verdict_id),
+            payload=verdict.to_dict(),
+            producer="test",
+            dedup_key=f"teacher.verdict_recorded:{verdict.verdict_id}:{seq}",
+        )
+    )
+
+
+def _knowledge(tmp_path, *verdicts: AdaptationVerdict):
+    events = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    for index, verdict in enumerate(verdicts):
+        _seed(events, verdict, index)
+    store = EvolutionDistilledKnowledgeStore(events, profile_id="p")
+    store.refresh()
+    return events, store
 
 
 def _env(*affordances: str) -> EnvironmentFingerprint:
@@ -73,49 +97,56 @@ def test_only_rebind_verdicts_become_selection_preferences(tmp_path):
     Admitting either would turn an instruction to a human into a machine's selection
     preference, which is the one direction this channel must never go.
     """
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    store.record(
+    events, store = _knowledge(
+        tmp_path,
         AdaptationVerdict.create(
             "rebind", "chat.reply", "the app is now v2", target="chat_reply_v2_native"
-        )
-    )
-    store.record(AdaptationVerdict.create("absorb", "chat.react", "the control moved"))
-    store.record(
+        ),
+        AdaptationVerdict.create("absorb", "chat.react", "the control moved"),
         AdaptationVerdict.create(
             "escalate", "drive.upload", "refused", target="grant the drive.file scope"
-        )
+        ),
     )
 
     assert store.rebind_preferences() == (("chat.reply", "chat_reply_v2_native"),)
+    events.close()
 
 
 def test_a_rebind_without_a_target_is_not_a_preference(tmp_path):
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    store.record(AdaptationVerdict.create("rebind", "chat.reply", "something moved"))
+    events, store = _knowledge(
+        tmp_path,
+        AdaptationVerdict.create("rebind", "chat.reply", "something moved"),
+    )
     assert store.rebind_preferences() == ()
+    events.close()
 
 
 def test_a_preference_retires_with_the_knowledge_behind_it(tmp_path):
     """Nothing to unlearn: the entry stops being read when it stops being true."""
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    store.record(
-        AdaptationVerdict.create("rebind", "chat.reply", "v2 now", target="chat_reply_v2")
+    events, store = _knowledge(
+        tmp_path,
+        AdaptationVerdict.create("rebind", "chat.reply", "v2 now", target="chat_reply_v2"),
     )
     assert store.rebind_preferences()
 
     store.retract("chat.reply", reason="observed working again")
     assert store.rebind_preferences() == ()
+    events.close()
 
 
 def test_a_newer_verdict_supersedes_the_preference(tmp_path):
-    store = JsonDistilledKnowledgeStore(tmp_path / "dk.json")
-    store.record(
-        AdaptationVerdict.create("rebind", "chat.reply", "v2 now", target="chat_reply_v2")
-    )
-    store.record(
-        AdaptationVerdict.create("rebind", "chat.reply", "v3 now", target="chat_reply_v3")
+    import time
+
+    events, store = _knowledge(
+        tmp_path,
+        AdaptationVerdict.create("rebind", "chat.reply", "v2 now", target="chat_reply_v2"),
+        AdaptationVerdict.create(
+            "rebind", "chat.reply", "v3 now", target="chat_reply_v3",
+            created_at=time.time() + 10,
+        ),
     )
     assert store.rebind_preferences() == (("chat.reply", "chat_reply_v3"),)
+    events.close()
 
 
 # ── preference, not gate ──────────────────────────────────────────────────────
@@ -190,8 +221,9 @@ def test_the_engine_reads_preferences_per_resolution_not_once():
     """
     from leapflow.engine.engine import AgentEngine
 
-    tmp = Path(tempfile.mkdtemp())
-    store = JsonDistilledKnowledgeStore(tmp / "dk.json")
+    events = DuckDBEvolutionEventStore(Path(tempfile.mkdtemp()) / "events.duckdb")
+    store = EvolutionDistilledKnowledgeStore(events, profile_id="p")
+    store.refresh()
     engine = AgentEngine.__new__(AgentEngine)
     engine._knowledge_store = store
     engine._knowledge_store_unavailable = False
@@ -199,12 +231,15 @@ def test_the_engine_reads_preferences_per_resolution_not_once():
     engine._settings = SimpleNamespace(distilled_knowledge_limit=12)
 
     assert engine._rebind_preferences() == ()
-    store.record(
-        AdaptationVerdict.create("rebind", "chat.reply", "v2 now", target="chat_reply_v2")
+    _seed(
+        events,
+        AdaptationVerdict.create("rebind", "chat.reply", "v2 now", target="chat_reply_v2"),
     )
+    store.refresh()
     assert engine._rebind_preferences() == (("chat.reply", "chat_reply_v2"),)
     store.retract("chat.reply")
     assert engine._rebind_preferences() == ()
+    events.close()
 
 
 def test_a_failing_store_costs_a_preference_not_a_resolution():
diff --git a/tests/test_durable_teacher.py b/tests/test_durable_teacher.py
new file mode 100644
index 00000000..d9755cd4
--- /dev/null
+++ b/tests/test_durable_teacher.py
@@ -0,0 +1,427 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Durability and isolation contracts for session-finalized teacher work."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from leapflow.domain.adaptation_verdict import AdaptationVerdict
+from leapflow.domain.event_types import EvolutionEventType
+from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent
+from leapflow.evolution.artifact_store import ContentAddressedArtifactStore
+from leapflow.evolution.outbox import EvolutionEventOutbox
+from leapflow.evolution.session_finalizer import SessionFinalizer
+from leapflow.evolution.teacher_worker import DurableTeacherWorker
+from leapflow.storage.capability_proposal_queue import EvolutionCapabilityProposalStore
+from leapflow.storage.distilled_knowledge_store import EvolutionDistilledKnowledgeStore
+from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+from leapflow.world_model.trajectory_grader import ActionGrade, TeacherVerdict
+
+
+def _action_events(session_id: str, action_id: str, *, workspace_id: str = "ws-1"):
+    context = EvolutionContext.create(
+        profile_id="profile-1",
+        workspace_id=workspace_id,
+        session_id=session_id,
+        action_id=action_id,
+        turn_id="turn-1",
+        frame_id="frame-1",
+    )
+    started = EvolutionEvent.create(
+        EvolutionEventType.ACTION_STARTED,
+        context=context,
+        payload={
+            "action_type": "tool",
+            "action_name": "file_read",
+            "goal": "inspect the repository",
+        },
+        producer="test",
+        dedup_key=f"action.started:{action_id}",
+    )
+    completed = EvolutionEvent.create(
+        EvolutionEventType.ACTION_COMPLETED,
+        context=context.with_ids(causation_id=started.event_id),
+        payload={"ok": True, "result": {"files": 2}},
+        producer="test",
+        dedup_key=f"action.completed:{action_id}",
+    )
+    return started, completed
+
+
+class _Teacher:
+    def __init__(
+        self,
+        error: BaseException | None = None,
+        *,
+        action: str = "absorb",
+    ) -> None:
+        self.error = error
+        self.action = action
+        self.calls: list[tuple[list[dict], str]] = []
+
+    async def grade_and_propose(
+        self,
+        trajectory,
+        goal="",
+        *,
+        degraded_capabilities=(),
+        raise_on_error=False,
+    ):
+        self.calls.append((list(trajectory), str(goal)))
+        if self.error is not None:
+            raise self.error
+        return TeacherVerdict(
+            grades=(ActionGrade("", 0.8, False, "helpful"),),
+            verdicts=(
+                AdaptationVerdict.create(
+                    self.action,
+                    "repository.inspect",
+                    "The environment requires repository inspection adaptation.",
+                    confidence=0.9,
+                ),
+            ),
+            raw_payload={"source": "teacher-test"},
+        )
+
+
+@pytest.mark.asyncio
+async def test_finalizer_is_idempotent_and_session_scoped(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    outbox = EvolutionEventOutbox(store, flush_interval_s=0.001)
+    first = _action_events("session-a", "action-a")
+    second = _action_events("session-b", "action-b", workspace_id="ws-2")
+    await outbox.publish(first[0])
+    await outbox.publish(first[1])
+    await outbox.publish(second[0])
+    await outbox.publish(second[1])
+    finalizer = SessionFinalizer(store, outbox)
+
+    result = await finalizer.finalize(
+        profile_id="profile-1",
+        workspace_id="ws-1",
+        session_id="session-a",
+        reason="manual",
+    )
+    repeated = await finalizer.finalize(
+        profile_id="profile-1",
+        workspace_id="ws-1",
+        session_id="session-a",
+        reason="manual",
+    )
+
+    assert result.queued is True
+    assert result.evidence_count == 2
+    assert repeated.queued is False
+    job = store.teacher_job(result.job_id)
+    assert job is not None
+    assert job["session_id"] == "session-a"
+    assert job["workspace_id"] == "ws-1"
+    assert store.latest_evidence_sequence(
+        profile_id="profile-1", session_id="session-b"
+    ) > 0
+    await outbox.close()
+    store.close()
+
+
+@pytest.mark.asyncio
+async def test_teacher_worker_persists_one_call_result_and_verdict(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    outbox = EvolutionEventOutbox(store, flush_interval_s=0.001)
+    started, completed = _action_events("session-a", "action-a")
+    await outbox.publish(started)
+    await outbox.publish(completed)
+    finalization = await SessionFinalizer(store, outbox).finalize(
+        profile_id="profile-1",
+        workspace_id="ws-1",
+        session_id="session-a",
+    )
+    teacher = _Teacher()
+    artifacts = ContentAddressedArtifactStore(tmp_path / "artifacts")
+    knowledge = EvolutionDistilledKnowledgeStore(store, profile_id="profile-1")
+    worker = DurableTeacherWorker(
+        store=store,
+        artifact_store=artifacts,
+        teacher=teacher,
+        profile_id="profile-1",
+        retry_backoff_s=0,
+        knowledge_projection=knowledge,
+    )
+
+    outcome = await worker.run_once()
+
+    assert outcome is not None and outcome.status == "COMPLETED"
+    assert len(teacher.calls) == 1
+    assert teacher.calls[0][1] == "inspect the repository"
+    job = store.teacher_job(finalization.job_id)
+    assert job is not None and job["status"] == "COMPLETED"
+    assert artifacts.get_bytes(job["result_artifact_id"])
+    event_types = [
+        record.event.event_type
+        for record in store.read(
+            profile_id="profile-1",
+            correlation_id=finalization.episode_id,
+        )
+    ]
+    assert EvolutionEventType.TEACHER_GRADED in event_types
+    assert EvolutionEventType.TEACHER_VERDICT_RECORDED in event_types
+    assert knowledge.for_capability("repository.inspect") is not None
+    assert worker.metrics.claim_latency.count == 1
+    assert worker.metrics.job_latency.count == 1
+    await outbox.close()
+    store.close()
+
+
+def test_expired_teacher_lease_is_reclaimed_and_stale_owner_cannot_complete(
+    tmp_path: Path,
+) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    store.append_many(_action_events("session-a", "action-a"))
+    episode_id, job_id = store.finalize_session(
+        profile_id="profile-1",
+        workspace_id="ws-1",
+        session_id="session-a",
+        session_generation=0,
+        from_sequence=0,
+        through_sequence=2,
+        reason="test",
+    )
+
+    first = store.claim_teacher_job(lease_owner="worker-1", lease_seconds=5, now=10)
+    assert first is not None and first["episode_id"] == episode_id
+    assert first["attempts"] == 1
+    assert store.claim_teacher_job(lease_owner="worker-2", lease_seconds=5, now=14) is None
+    second = store.claim_teacher_job(lease_owner="worker-2", lease_seconds=5, now=16)
+    assert second is not None and second["attempts"] == 2
+    assert store.complete_teacher_job(job_id, lease_owner="worker-1") is False
+    assert store.complete_teacher_job(job_id, lease_owner="worker-2") is True
+    store.close()
+
+
+@pytest.mark.asyncio
+async def test_internal_teacher_defect_is_not_retried(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    store.append_many(_action_events("session-a", "action-a"))
+    _, job_id = store.finalize_session(
+        profile_id="profile-1",
+        workspace_id="ws-1",
+        session_id="session-a",
+        session_generation=0,
+        from_sequence=0,
+        through_sequence=2,
+        reason="test",
+    )
+    worker = DurableTeacherWorker(
+        store=store,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        teacher=_Teacher(TypeError("local bug")),
+        profile_id="profile-1",
+        retry_backoff_s=0,
+    )
+
+    outcome = await worker.run_once()
+
+    assert outcome is not None and outcome.status == "FAILED_FINAL"
+    assert store.teacher_job(job_id)["status"] == "FAILED_FINAL"
+    failures = store.read(
+        profile_id="profile-1",
+        event_type=EvolutionEventType.TEACHER_JOB_FAILED,
+    )
+    assert len(failures) == 1
+    assert failures[0].event.payload["error_type"] == "TypeError"
+    store.close()
+
+
+@pytest.mark.asyncio
+async def test_background_worker_wakes_and_completes_queued_job(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    outbox = EvolutionEventOutbox(store, flush_interval_s=0.001)
+    store.append_many(_action_events("session-a", "action-a"))
+    finalization = await SessionFinalizer(store, outbox).finalize(
+        profile_id="profile-1",
+        workspace_id="ws-1",
+        session_id="session-a",
+    )
+    teacher = _Teacher()
+    worker = DurableTeacherWorker(
+        store=store,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        teacher=teacher,
+        profile_id="profile-1",
+        poll_interval_s=10,
+    )
+    worker.start()
+    worker.wake()
+
+    job = await worker.wait_for_job(finalization.job_id, timeout_s=2)
+
+    assert job["status"] == "COMPLETED"
+    assert len(teacher.calls) == 1
+    await worker.close()
+    await outbox.close()
+    store.close()
+
+
+@pytest.mark.asyncio
+async def test_acquire_verdict_queues_one_visible_proposal(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    store.append_many(_action_events("session-a", "action-a"))
+    _, job_id = store.finalize_session(
+        profile_id="profile-1",
+        workspace_id="ws-1",
+        session_id="session-a",
+        session_generation=0,
+        from_sequence=0,
+        through_sequence=2,
+        reason="test",
+    )
+    queue = EvolutionCapabilityProposalStore(store, profile_id="profile-1")
+    worker = DurableTeacherWorker(
+        store=store,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        teacher=_Teacher(action="acquire"),
+        profile_id="profile-1",
+        proposal_queue=queue,
+        acquisition_resolver=lambda intent, job: {
+            "resolved": True,
+            "satisfied": False,
+            "reason": "no eligible capability provider",
+            "environment": {
+                "workspace_id": job["workspace_id"],
+                "session_id": job["session_id"],
+            },
+        },
+    )
+
+    outcome = await worker.run_once()
+
+    assert outcome is not None and outcome.status == "COMPLETED"
+    proposals = queue.list_items()
+    assert len(proposals) == 1
+    assert proposals[0].requirements[0]["capability"] == "repository.inspect"
+    assert proposals[0].requirements[0]["requirement_id"] == "req-wm-repository.inspect"
+    resolutions = store.read(
+        profile_id="profile-1",
+        event_type=EvolutionEventType.REQUIREMENT_RESOLVED,
+    )
+    assert len(resolutions) == 1
+    assert resolutions[0].event.payload["outcome"] == "unmet"
+    assert resolutions[0].event.context.proposal_id == proposals[0].proposal_id
+    job = store.teacher_job(job_id)
+    assert job is not None and job["status"] == "COMPLETED"
+    store.close()
+
+
+@pytest.mark.asyncio
+async def test_acquire_verdict_is_no_op_when_live_capability_resolves(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    store.append_many(_action_events("session-a", "action-a"))
+    store.finalize_session(
+        profile_id="profile-1",
+        workspace_id="ws-1",
+        session_id="session-a",
+        session_generation=0,
+        from_sequence=0,
+        through_sequence=2,
+        reason="test",
+    )
+    queue = EvolutionCapabilityProposalStore(store, profile_id="profile-1")
+    worker = DurableTeacherWorker(
+        store=store,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        teacher=_Teacher(action="acquire"),
+        profile_id="profile-1",
+        proposal_queue=queue,
+        acquisition_resolver=lambda intent, job: {
+            "resolved": True,
+            "satisfied": True,
+            "reason": "selected existing provider",
+            "selected_plugin_id": "repository_builtin",
+            "selected_tool_name": "file_read",
+            "environment": {},
+        },
+    )
+
+    outcome = await worker.run_once()
+
+    assert outcome is not None and outcome.status == "COMPLETED"
+    assert queue.list_items() == []
+    resolutions = store.read(
+        profile_id="profile-1",
+        event_type=EvolutionEventType.REQUIREMENT_RESOLVED,
+    )
+    assert len(resolutions) == 1
+    assert resolutions[0].event.payload["outcome"] == "satisfied"
+    assert resolutions[0].event.payload["reason"] == "capability_already_available"
+    store.close()
+
+
+@pytest.mark.asyncio
+async def test_acquire_verdict_fails_closed_without_live_resolution(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    store.append_many(_action_events("session-a", "action-a"))
+    store.finalize_session(
+        profile_id="profile-1",
+        workspace_id="ws-1",
+        session_id="session-a",
+        session_generation=0,
+        from_sequence=0,
+        through_sequence=2,
+        reason="test",
+    )
+    queue = EvolutionCapabilityProposalStore(store, profile_id="profile-1")
+    worker = DurableTeacherWorker(
+        store=store,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        teacher=_Teacher(action="acquire"),
+        profile_id="profile-1",
+        proposal_queue=queue,
+    )
+
+    await worker.run_once()
+
+    assert queue.list_items() == []
+    resolution = store.read(
+        profile_id="profile-1",
+        event_type=EvolutionEventType.REQUIREMENT_RESOLVED,
+    )[0].event
+    assert resolution.payload["outcome"] == "no_op"
+    assert resolution.payload["reason"] == "live_resolution_unavailable"
+    store.close()
+
+
+@pytest.mark.asyncio
+async def test_retryable_teacher_failure_exhausts_configured_attempts(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    store.append_many(_action_events("session-a", "action-a"))
+    _, job_id = store.finalize_session(
+        profile_id="profile-1",
+        workspace_id="ws-1",
+        session_id="session-a",
+        session_generation=0,
+        from_sequence=0,
+        through_sequence=2,
+        reason="test",
+    )
+    worker = DurableTeacherWorker(
+        store=store,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        teacher=_Teacher(OSError("provider unavailable")),
+        profile_id="profile-1",
+        max_attempts=2,
+        retry_backoff_s=0,
+    )
+
+    first = await worker.run_once()
+    second = await worker.run_once()
+
+    assert first is not None and first.status == "FAILED_RETRYABLE"
+    assert second is not None and second.status == "FAILED_FINAL"
+    assert store.teacher_job(job_id)["attempts"] == 2
+    assert len(
+        store.read(
+            profile_id="profile-1",
+            event_type=EvolutionEventType.TEACHER_JOB_FAILED,
+        )
+    ) == 2
+    store.close()
diff --git a/tests/test_effect_scope.py b/tests/test_effect_scope.py
index c964b0bd..441af8e0 100644
--- a/tests/test_effect_scope.py
+++ b/tests/test_effect_scope.py
@@ -390,7 +390,9 @@ def test_subscribe_with_scope_auto_unsubscribes_on_dispose(self) -> None:
 
         scope = EffectScope("sub_scope")
         called: list = []
-        cb = lambda event: called.append(event)
+
+        def cb(event):
+            called.append(event)
 
         bus.subscribe(cb, scope=scope)
         assert id(cb) in bus._subscribers
@@ -405,7 +407,9 @@ def test_subscribe_without_scope_survives_unrelated_dispose(self) -> None:
         bus._subscribers = {}
 
         scope = EffectScope("unrelated")
-        cb = lambda event: None
+
+        def cb(event):
+            return None
 
         bus.subscribe(cb)  # no scope
         scope.dispose()
@@ -418,9 +422,15 @@ def test_multiple_scope_bound_subs_cleaned_together(self) -> None:
         bus._subscribers = {}
 
         scope = EffectScope("shared")
-        cb1 = lambda e: None
-        cb2 = lambda e: None
-        cb3 = lambda e: None  # unbound
+
+        def cb1(event):
+            return None
+
+        def cb2(event):
+            return None
+
+        def cb3(event):  # unbound
+            return None
 
         bus.subscribe(cb1, scope=scope)
         bus.subscribe(cb2, scope=scope)
diff --git a/tests/test_environment_source.py b/tests/test_environment_source.py
new file mode 100644
index 00000000..1fff9695
--- /dev/null
+++ b/tests/test_environment_source.py
@@ -0,0 +1,128 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Contracts for daemon-native task-environment observation."""
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+
+import pytest
+
+from leapflow.domain.environment_signal import EnvironmentObservation, InterfaceSnapshot
+from leapflow.perception.environment_source import EnvironmentSourceManager
+from leapflow.perception.leapspace_source import LeapSpaceEnvironmentSource
+
+
+def _write_state(root: Path, *, version: str, affordances: list[str], enabled: bool = True) -> None:
+    app_dir = root / "chat"
+    app_dir.mkdir(parents=True, exist_ok=True)
+    (app_dir / "state.json").write_text(
+        json.dumps(
+            {
+                "app_id": "chat",
+                "version": version,
+                "affordances": affordances,
+                "elements": [{"name": "send", "role": "QPushButton", "enabled": enabled}],
+                "data": {"draft": "value that must not define structural drift"},
+            }
+        )
+    )
+
+
+def test_interface_delta_uses_structure_not_mutable_app_data() -> None:
+    before = InterfaceSnapshot.create(
+        source_id="leapspace",
+        app_id="chat",
+        affordances=("chat.send.v1",),
+        elements=({"name": "send", "role": "button", "enabled": True},),
+        data={"draft": "one"},
+    )
+    data_only = InterfaceSnapshot.create(
+        source_id="leapspace",
+        app_id="chat",
+        affordances=("chat.send.v1",),
+        elements=({"name": "send", "role": "button", "enabled": True},),
+        data={"draft": "two"},
+    )
+    changed = InterfaceSnapshot.create(
+        source_id="leapspace",
+        app_id="chat",
+        version="2",
+        affordances=("chat.send.v2",),
+        elements=({"name": "submit", "role": "button", "enabled": True},),
+    )
+
+    assert EnvironmentObservation.between(before, data_only) is None
+    delta = EnvironmentObservation.between(before, changed)
+    assert delta is not None and delta.is_structural
+    assert delta.removed_affordances == ("chat.send.v1",)
+    assert delta.capability_results()[0]["capability"] == "chat.send.v1"
+
+
+def test_leapspace_source_emits_snapshot_delta_and_ground_truth_once(tmp_path: Path) -> None:
+    _write_state(tmp_path, version="1", affordances=["chat.send.v1"])
+    source = LeapSpaceEnvironmentSource(
+        tmp_path,
+        workspace_id="ws-1",
+        session_id="session-1",
+    )
+
+    initial = source._scan()
+    assert len(initial) == 1 and initial[0].kind == "snapshot"
+
+    _write_state(tmp_path, version="2", affordances=["chat.send.v2"])
+    delta = source._scan()
+    assert len(delta) == 1 and delta[0].kind == "delta"
+    assert delta[0].session_id == "session-1"
+
+    result_dir = tmp_path / "task-1"
+    result_dir.mkdir()
+    (result_dir / "result.json").write_text(
+        json.dumps({"task_id": "task-1", "outcome": "FAIL", "capability": "chat.send.v2"})
+    )
+    outcome = source._scan()
+    assert len(outcome) == 1 and outcome[0].outcome == "FAIL"
+    assert outcome[0].capability_results()[0]["error_type"] == "task_outcome_failed"
+    assert source._scan() == ()
+
+
+@pytest.mark.asyncio
+async def test_environment_source_manager_owns_source_lifecycle() -> None:
+    received: list[EnvironmentObservation] = []
+
+    class _Source:
+        source_id = "test-source"
+
+        def __init__(self) -> None:
+            self.stopped = asyncio.Event()
+
+        async def start(self, emit) -> None:
+            await emit(
+                EnvironmentObservation.task_outcome(
+                    source_id=self.source_id,
+                    task_id="task-1",
+                    outcome="PASS",
+                    session_id="session-1",
+                )
+            )
+            await self.stopped.wait()
+
+        async def stop(self) -> None:
+            self.stopped.set()
+
+    async def sink(observation: EnvironmentObservation) -> None:
+        received.append(observation)
+
+    source = _Source()
+    manager = EnvironmentSourceManager(sink, shutdown_timeout_s=1)
+    manager.register(source)
+    await manager.start()
+    for _ in range(20):
+        if received:
+            break
+        await asyncio.sleep(0.01)
+    await manager.close()
+
+    assert manager.source_ids == ("test-source",)
+    assert [item.outcome for item in received] == ["PASS"]
+    assert source.stopped.is_set()
diff --git a/tests/test_evolution_event_store.py b/tests/test_evolution_event_store.py
new file mode 100644
index 00000000..73a9ceb8
--- /dev/null
+++ b/tests/test_evolution_event_store.py
@@ -0,0 +1,378 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Contract tests for the append-only evolution evidence foundation."""
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+import duckdb
+import pytest
+
+from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent
+from leapflow.evolution.action_recorder import ActionRecorder, sanitize_evidence
+from leapflow.evolution.artifact_store import ArtifactIntegrityError, ContentAddressedArtifactStore
+from leapflow.evolution.outbox import (
+    EvolutionEventOutbox,
+    EvolutionOutboxClosed,
+    EvolutionOutboxWriteError,
+)
+from leapflow.layout import ProfileLayout
+from leapflow.storage.connection import LocalConnectionHolder
+from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+from leapflow.storage.schema import CURRENT_SCHEMA_VERSION, ensure_schema
+
+
+def _context(*, session: str = "s1", action: str = "a1") -> EvolutionContext:
+    return EvolutionContext.create(
+        profile_id="p1",
+        workspace_id="w1",
+        session_id=session,
+        turn_id="t1",
+        frame_id="f1",
+        action_id=action,
+    )
+
+
+def _event(kind: str = "action.started", *, session: str = "s1", action: str = "a1"):
+    return EvolutionEvent.create(
+        kind,
+        context=_context(session=session, action=action),
+        payload={"ok": True},
+        producer="test",
+        dedup_key=f"{kind}:{session}:{action}",
+    )
+
+
+def test_context_mints_one_correlation_id_and_preserves_it_on_updates() -> None:
+    context = _context()
+    changed = context.with_ids(causation_id="evt-parent", proposal_id="prop-1")
+
+    assert context.correlation_id.startswith("evo-")
+    assert changed.correlation_id == context.correlation_id
+    assert changed.causation_id == "evt-parent"
+    assert changed.proposal_id == "prop-1"
+    assert context.causation_id == ""
+
+
+def test_event_payload_hash_and_dedup_are_deterministic() -> None:
+    context = EvolutionContext(profile_id="p", session_id="s", correlation_id="c")
+    first = EvolutionEvent.create(
+        "environment.observed", context=context, payload={"b": 2, "a": 1}, producer="test"
+    )
+    second = EvolutionEvent.create(
+        "environment.observed", context=context, payload={"a": 1, "b": 2}, producer="test"
+    )
+
+    assert first.payload_hash == second.payload_hash
+    assert first.dedup_key == second.dedup_key
+    assert first.event_id != second.event_id
+
+
+def test_event_round_trip_preserves_context_and_payload() -> None:
+    event = _event()
+    restored = EvolutionEvent.from_dict(event.to_dict())
+    assert restored == event
+
+
+def test_store_appends_and_deduplicates(tmp_path: Path) -> None:
+    holder = LocalConnectionHolder(tmp_path / "events.duckdb")
+    store = DuckDBEvolutionEventStore(holder)
+    event = _event()
+
+    assert store.append(event) is True
+    assert store.append(event) is False
+    assert store.count(profile_id="p1") == 1
+    assert store.latest_sequence(profile_id="p1") == 1
+    records = store.read(profile_id="p1")
+    assert [record.sequence for record in records] == [1]
+    assert [record.event for record in records] == [event]
+    holder.close()
+
+
+def test_store_batches_atomically_and_keeps_causal_order(tmp_path: Path) -> None:
+    holder = LocalConnectionHolder(tmp_path / "events.duckdb")
+    store = DuckDBEvolutionEventStore(holder)
+    events = [
+        _event("action.started", action="a1"),
+        _event("action.completed", action="a1"),
+        _event("action.started", session="s2", action="a2"),
+    ]
+
+    assert store.append_many(events) == 3
+    assert store.append_many(events) == 0
+    assert [
+        record.event.event_type
+        for record in store.read(profile_id="p1", session_id="s1")
+    ] == ["action.started", "action.completed"]
+    assert store.latest_sequence(profile_id="p1") == 3
+    holder.close()
+
+
+def test_store_filters_by_correlation_and_type(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    first = _event("action.started")
+    second = EvolutionEvent.create(
+        "teacher.verdict_recorded",
+        context=first.context,
+        payload={"action": "absorb"},
+        producer="teacher",
+    )
+    store.append_many([first, second])
+
+    assert [
+        record.event for record in store.read(correlation_id=first.context.correlation_id)
+    ] == [first, second]
+    assert [
+        record.event for record in store.read(event_type="teacher.verdict_recorded")
+    ] == [second]
+    store.close()
+
+
+def test_artifact_store_is_immutable_and_content_addressed(tmp_path: Path) -> None:
+    store = ContentAddressedArtifactStore(tmp_path / "artifacts")
+    first = store.put_text("same", privacy_class="session")
+    second = store.put_text("same", privacy_class="session")
+    other = store.put_text("different", privacy_class="session")
+
+    assert first.digest == second.digest
+    assert first.digest != other.digest
+    assert store.get_text(first) == "same"
+    assert first.relative_path.startswith(first.digest[:2] + "/")
+
+
+def test_artifact_store_rejects_paths_disguised_as_refs(tmp_path: Path) -> None:
+    store = ContentAddressedArtifactStore(tmp_path / "artifacts")
+    with pytest.raises(ValueError, match="SHA-256"):
+        store.resolve("../../secret")
+
+
+def test_artifact_store_rejects_corrupted_content(tmp_path: Path) -> None:
+    store = ContentAddressedArtifactStore(tmp_path / "artifacts")
+    ref = store.put_text("trusted")
+    store.resolve(ref).write_text("tampered")
+
+    with pytest.raises(ArtifactIntegrityError, match="digest mismatch"):
+        store.get_bytes(ref)
+    with pytest.raises(ArtifactIntegrityError, match="digest mismatch"):
+        store.put_text("trusted")
+
+
+def test_profile_layout_owns_the_evolution_cas_path(tmp_path: Path) -> None:
+    layout = ProfileLayout(root=tmp_path / "profile", profile_id="p1")
+    assert layout.evolution_artifacts_dir == layout.root / "artifacts" / "sha256"
+
+
+def test_sanitizer_redacts_secrets_and_is_structurally_bounded() -> None:
+    value = {
+        "api_key": "sk-secret-value",
+        "nested": {"password": "hunter2", "safe": "visible"},
+        "items": list(range(40)),
+        "long": "x" * 1200,
+    }
+    sanitized = sanitize_evidence(value)
+
+    assert sanitized["api_key"] == "[REDACTED]"
+    assert sanitized["nested"]["password"] == "[REDACTED]"
+    assert sanitized["nested"]["safe"] == "visible"
+    assert sanitized["items"][-1] == {"items_omitted": 8}
+    assert len(sanitized["long"]) == 1001
+
+
+@pytest.mark.asyncio
+async def test_action_recorder_emits_linked_start_and_completion(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    outbox = EvolutionEventOutbox(store, flush_interval_s=0.001)
+    recorder = ActionRecorder(outbox, producer_version="test")
+    context = _context()
+
+    started = await recorder.started(
+        context=context,
+        action_type="tool",
+        action_name="file.read",
+        arguments={"file_path": "/tmp/x", "token": "secret"},
+        execution_policy="read_only",
+        critical=False,
+    )
+    await recorder.completed(
+        context=context,
+        started_event=started,
+        action_type="tool",
+        action_name="file.read",
+        result={"ok": True, "content": "hello"},
+        duration_ms=1.5,
+    )
+    await outbox.flush()
+
+    events = [record.event for record in store.read(session_id="s1")]
+    assert [event.event_type for event in events] == ["action.started", "action.completed"]
+    assert events[0].payload["arguments"]["token"] == "[REDACTED]"
+    assert events[1].context.causation_id == events[0].event_id
+    assert events[1].payload["ok"] is True
+    assert recorder.metrics.started_latency.count == 1
+    assert recorder.metrics.completed_latency.count == 1
+    assert outbox.metrics.publish_latency.count == 2
+    assert outbox.metrics.write_latency.count >= 1
+    await outbox.close()
+    store.close()
+
+
+@pytest.mark.asyncio
+async def test_critical_event_is_durable_before_publish_returns(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    outbox = EvolutionEventOutbox(store, critical_timeout_s=1.0)
+    event = _event()
+
+    await outbox.publish(event, critical=True)
+
+    assert store.count(profile_id="p1") == 1
+    assert outbox.metrics.queued == 0
+    await outbox.close()
+    store.close()
+
+
+@pytest.mark.asyncio
+async def test_outbox_rejects_publication_after_close(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    outbox = EvolutionEventOutbox(store)
+    await outbox.close()
+
+    with pytest.raises(EvolutionOutboxClosed):
+        await outbox.publish(_event())
+    store.close()
+
+
+def test_schema_contains_long_running_evolution_tables(tmp_path: Path) -> None:
+    holder = LocalConnectionHolder(tmp_path / "schema.duckdb")
+    DuckDBEvolutionEventStore(holder)
+    tables = {row[0] for row in holder.connection.execute("SHOW TABLES").fetchall()}
+    assert {
+        "evolution_events",
+        "evolution_teacher_jobs",
+        "evolution_projections",
+    } <= tables
+    assert "evolution_proposal_work" not in tables
+    versions = [
+        row[0]
+        for row in holder.connection.execute(
+            "SELECT version FROM _schema_version ORDER BY version"
+        ).fetchall()
+    ]
+    assert versions == list(range(1, CURRENT_SCHEMA_VERSION + 1))
+    holder.close()
+
+
+def test_schema_upgrades_a_v1_database_in_order(tmp_path: Path) -> None:
+    connection = duckdb.connect(str(tmp_path / "old.duckdb"))
+    connection.execute(
+        "CREATE TABLE _schema_version (version INTEGER NOT NULL, applied_at DOUBLE NOT NULL)"
+    )
+    connection.execute("INSERT INTO _schema_version VALUES (1, 1.0)")
+
+    assert ensure_schema(connection) == CURRENT_SCHEMA_VERSION
+    assert [
+        row[0]
+        for row in connection.execute(
+            "SELECT version FROM _schema_version ORDER BY version"
+        ).fetchall()
+    ] == list(range(1, CURRENT_SCHEMA_VERSION + 1))
+    assert connection.execute("SELECT nextval('evolution_event_sequence')").fetchone() == (1,)
+    connection.close()
+
+
+def test_event_payload_is_deeply_immutable_and_hash_checked() -> None:
+    source = {"nested": {"items": [1, 2]}}
+    event = EvolutionEvent.create(
+        "environment.observed",
+        context=_context(),
+        payload=source,
+        producer="test",
+    )
+    source["nested"]["items"].append(3)
+
+    assert event.to_dict()["payload"] == {"nested": {"items": [1, 2]}}
+    with pytest.raises(TypeError):
+        event.payload["new"] = True
+    with pytest.raises(AttributeError):
+        event.payload["nested"]["items"].append(3)
+    with pytest.raises(ValueError, match="payload_hash"):
+        EvolutionEvent(
+            event_id="evt-bad",
+            event_type="environment.observed",
+            context=_context(),
+            payload={"ok": True},
+            occurred_at=1.0,
+            producer="test",
+            dedup_key="bad",
+            payload_hash="incorrect",
+        )
+
+
+def test_database_sequence_is_unique_across_store_instances(tmp_path: Path) -> None:
+    holder = LocalConnectionHolder(tmp_path / "events.duckdb")
+    first = DuckDBEvolutionEventStore(holder)
+    second = DuckDBEvolutionEventStore(holder)
+
+    def append_one(index: int) -> None:
+        store = first if index % 2 else second
+        assert store.append(_event(action=f"parallel-{index}")) is True
+
+    with ThreadPoolExecutor(max_workers=4) as pool:
+        list(pool.map(append_one, range(40)))
+
+    records = first.read(profile_id="p1", limit=100)
+    sequences = [record.sequence for record in records]
+    assert len(sequences) == 40
+    assert len(set(sequences)) == 40
+    assert sequences == sorted(sequences)
+    holder.close()
+
+
+@pytest.mark.asyncio
+async def test_outbox_saturation_uses_direct_fallback_without_loss() -> None:
+    class _Store:
+        def __init__(self) -> None:
+            self.events = []
+
+        def append(self, event: EvolutionEvent) -> bool:
+            self.events.append(event)
+            return True
+
+        def append_many(self, events) -> int:
+            self.events.extend(events)
+            return len(events)
+
+    store = _Store()
+    outbox = EvolutionEventOutbox(store, max_events=1, flush_interval_s=0.001)
+
+    await outbox.publish(_event(action="queued"))
+    await outbox.publish(_event(action="fallback"))
+    await outbox.flush()
+
+    assert outbox.metrics.direct_fallbacks == 1
+    assert outbox.metrics.published == 2
+    await outbox.close()
+
+
+@pytest.mark.asyncio
+async def test_outbox_write_failure_is_bounded_and_visible() -> None:
+    class _FailingStore:
+        def append(self, event: EvolutionEvent) -> bool:
+            raise OSError("disk unavailable")
+
+        def append_many(self, events) -> int:
+            raise OSError("disk unavailable")
+
+    outbox = EvolutionEventOutbox(
+        _FailingStore(),
+        max_write_attempts=2,
+        retry_backoff_s=0.001,
+        write_timeout_s=0.05,
+        flush_timeout_s=0.5,
+    )
+    await outbox.publish(_event())
+
+    with pytest.raises(EvolutionOutboxWriteError, match="failed to persist"):
+        await outbox.flush()
+    assert outbox.metrics.failures == 1
+    with pytest.raises(EvolutionOutboxWriteError):
+        await outbox.close()
diff --git a/tests/test_evolution_governance_reachable.py b/tests/test_evolution_governance_reachable.py
index 5a1a5581..7ed78d80 100644
--- a/tests/test_evolution_governance_reachable.py
+++ b/tests/test_evolution_governance_reachable.py
@@ -2,10 +2,9 @@
 """P2(a): the evolution governance tier becomes reachable.
 
 `AdaptiveEvolutionPolicy` and `LifecycleGovernor` implement trust, probation and
-quarantine. Everything they need was built and path-declared -- and orphaned:
-`JsonCapabilityProposalQueue`, `JsonPluginOutcomeStore`, and both
-`ProfileLayout` paths had no references outside their own modules, so nothing in
-production could ever reach the machinery.
+quarantine. These tests guard the production wiring after proposal and outcome
+persistence moved onto the append-only evolution event stream; no profile-local
+JSON queue may be required for the governance cycle.
 
 These tests cover the two halves of the fix:
 
@@ -35,13 +34,15 @@
 from leapflow.plugins.lifecycle_governor import LifecycleGovernor
 from leapflow.storage.capability_proposal_queue import (
     CapabilityProposalItem,
-    JsonCapabilityProposalQueue,
+    EvolutionCapabilityProposalStore,
 )
-from leapflow.storage.plugin_outcome_store import JsonPluginOutcomeStore
+from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+from leapflow.storage.plugin_outcome_store import EvolutionPluginOutcomeStore
 
 
-def _queue(tmp_path) -> JsonCapabilityProposalQueue:
-    return JsonCapabilityProposalQueue(tmp_path / "lifecycle.json")
+def _queue(tmp_path) -> EvolutionCapabilityProposalStore:
+    events = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    return EvolutionCapabilityProposalStore(events, profile_id="profile-1")
 
 
 def _requirement() -> CapabilityRequirement:
@@ -56,8 +57,12 @@ def _requirement() -> CapabilityRequirement:
 def test_shipped_types_satisfy_the_new_protocols(tmp_path):
     item = CapabilityProposalItem(proposal_id="p1", status="PENDING", requirements=())
     assert isinstance(item, EvolutionProposalView)
-    assert isinstance(_queue(tmp_path), EvolutionLifecycleStore)
-    assert isinstance(JsonPluginOutcomeStore(tmp_path / "o.json"), OutcomeStore)
+    queue = _queue(tmp_path)
+    assert isinstance(queue, EvolutionLifecycleStore)
+    assert isinstance(
+        EvolutionPluginOutcomeStore(queue._event_store, profile_id="profile-1"),
+        OutcomeStore,
+    )
 
 
 def test_policy_accepts_any_conforming_view():
@@ -132,7 +137,9 @@ def test_review_and_lifecycle_vocabularies_are_distinct():
 def test_full_governance_cycle_on_the_shipped_stores(tmp_path):
     """PENDING -> generate decision -> outcomes -> quarantine, all real components."""
     queue = _queue(tmp_path)
-    outcomes = JsonPluginOutcomeStore(tmp_path / "outcomes.json")
+    outcomes = EvolutionPluginOutcomeStore(
+        queue._event_store, profile_id="profile-1"
+    )
     trust = PluginTrustLedger()
     item = queue.enqueue(
         requirements=[_requirement()],
@@ -147,8 +154,16 @@ def test_full_governance_cycle_on_the_shipped_stores(tmp_path):
         item, trust_level=PluginTrustLevel.DRAFT
     )
     assert decision.action == "generate"
+    queue.transition(item.proposal_id, "GENERATED", generated_code_ref="sha256:test")
+    queue.transition(
+        item.proposal_id,
+        "APPROVED",
+        proposal_approval_id="approval-content",
+        mutation_approval_id="approval-mutation",
+    )
+    queue.transition(item.proposal_id, "INSTALLED", install_result={"ok": True})
 
-    # The governor transitions that same record from execution outcomes.
+    # The governor transitions that same installed record from execution outcomes.
     disabled: list[str] = []
 
     class _Actor:
@@ -176,28 +191,34 @@ async def disable(self, *, plugin_id):
     assert queue.get(item.proposal_id).status == "QUARANTINED"
 
 
-def test_requarantined_record_is_reset_in_place_but_memory_survives_elsewhere(tmp_path):
-    """Re-proposing after quarantine resets the record; the safety memory does not live there.
+def test_requarantined_record_remains_terminal_and_safety_memory_survives(tmp_path):
+    """Re-proposing the same identity cannot erase a quarantine fact.
 
-    ``proposal_id`` is a content hash of the requirement payload, so re-proposing
-    the same capability reuses the id and resets it to ``PENDING`` -- the
-    quarantine history is *overwritten* at the proposal layer rather than a second
-    record being created. That is safe only because the trigger the governor
-    actually consults lives elsewhere: the outcome store's ``failure_streak`` and
-    the trust ledger's freeze both persist independently, so a re-proposed plugin
-    does not get a clean slate where it matters.
+    ``proposal_id`` is a content hash of stable requirement identity. The event-sourced
+    store returns the terminal record instead of resetting it to ``PENDING``; a genuinely
+    new attempt must carry a new requirement identity and therefore preserves audit history.
     """
     queue = _queue(tmp_path)
     first = queue.enqueue(requirements=[_requirement()], source="plugin_propose")
-    queue.update(first.proposal_id, status="QUARANTINED")
+    queue.transition(first.proposal_id, "GENERATED", generated_code_ref="sha256:test")
+    queue.transition(
+        first.proposal_id,
+        "APPROVED",
+        proposal_approval_id="approval-content",
+        mutation_approval_id="approval-mutation",
+    )
+    queue.transition(first.proposal_id, "INSTALLED", install_result={"ok": True})
+    queue.transition(first.proposal_id, "QUARANTINED")
     second = queue.enqueue(requirements=[_requirement()], source="plugin_propose")
 
     assert second.proposal_id == first.proposal_id      # content-addressed
-    assert second.status == "PENDING"                    # reset, ready to retry
-    assert len(queue.list_items(limit=0)) == 1           # replaced, not appended
+    assert second.status == "QUARANTINED"                # terminal fact is preserved
+    assert len(queue.list_items(limit=0)) == 1
 
-    # The memory that gates a retry survives the reset.
-    outcomes = JsonPluginOutcomeStore(tmp_path / "outcomes.json")
+    # Independent safety evidence remains queryable with the terminal proposal.
+    outcomes = EvolutionPluginOutcomeStore(
+        queue._event_store, profile_id="profile-1"
+    )
     for _ in range(3):
         outcomes.add_outcome(plugin_id="p", tool_name="t", ok=False)
     assert outcomes.failure_streak("p") == 3
@@ -212,14 +233,10 @@ def test_requarantined_record_is_reset_in_place_but_memory_survives_elsewhere(tm
 
 def _plugin_with_stores(tmp_path):
     from leapflow.plugins.tool_plugins.self_management import SelfManagementPlugin
-    from leapflow.storage.plugin_proposal_store import JsonPluginProposalStore
 
     plugin = SelfManagementPlugin()
     queue = _queue(tmp_path)
-    plugin.bind_runtime(
-        plugin_proposal_store=JsonPluginProposalStore(tmp_path / "review.json"),
-        capability_lifecycle_store=queue,
-    )
+    plugin.bind_runtime(capability_lifecycle_store=queue)
     return plugin, queue
 
 
@@ -255,23 +272,19 @@ def test_plugin_propose_opens_a_correlated_lifecycle_record(tmp_path):
     assert decision.action == "generate"
 
 
-def test_propose_still_succeeds_when_the_lifecycle_ledger_fails(tmp_path):
-    """Bookkeeping must never fail the proposal the caller asked for."""
+def test_propose_fails_closed_when_the_lifecycle_ledger_fails(tmp_path):
+    """A proposal without its sole durable lifecycle record must not escape."""
     from leapflow.plugins.tool_plugins.self_management import SelfManagementPlugin
-    from leapflow.storage.plugin_proposal_store import JsonPluginProposalStore
 
     class _Broken:
         def enqueue(self, **kwargs):
             raise OSError("disk on fire")
 
     plugin = SelfManagementPlugin()
-    plugin.bind_runtime(
-        plugin_proposal_store=JsonPluginProposalStore(tmp_path / "review.json"),
-        capability_lifecycle_store=_Broken(),
-    )
+    plugin.bind_runtime(capability_lifecycle_store=_Broken())
     result = _propose(plugin, requested_capability="chat.reply", risk_level="read_only")
-    assert result["ok"] is True                 # the proposal survived
-    assert result["lifecycle_proposal_id"] == ""  # ...and the failure is visible
+    assert result["ok"] is False
+    assert "persistence failed" in result["error"].lower()
 
 
 def test_lifecycle_record_carries_the_declared_risk_ceiling(tmp_path):
@@ -284,18 +297,11 @@ def test_lifecycle_record_carries_the_declared_risk_ceiling(tmp_path):
     assert dict(record.requirements[0])["max_risk_level"] == "medium"
 
 
-# ── plugin_generate bridges *both* proposal stores (G3) ───────────────────────
+# ── plugin_generate resolves canonical ids and review aliases (G3) ────────────
 
 
 def test_generate_resolves_a_world_model_lifecycle_proposal(tmp_path):
-    """A world-model queue id must reach generation, not only a review-store id.
-
-    The world-model driver enqueues into the lifecycle queue (``prop-<hash>``); before
-    the bridge, ``plugin_generate`` looked only in the review store, so Scene C could
-    never proceed from a real teacher verdict. This drives the resolver that closes
-    that gap -- no LLM needed, because it is the resolution, not the generation, under
-    test.
-    """
+    """Both a canonical lifecycle id and its review alias resolve from one store."""
     from leapflow.domain.capability_requirement import CapabilityRequirement
 
     plugin, queue = _plugin_with_stores(tmp_path)
@@ -318,11 +324,11 @@ def test_generate_resolves_a_world_model_lifecycle_proposal(tmp_path):
     assert provides == ("chat.reply",)          # capability preserved for generation
     assert description                          # non-empty description derived
 
-    # A review-store id still resolves as its own source, unchanged.
+    # A review alias resolves through metadata on the same lifecycle record.
     review = _propose(plugin, requested_capability="chat.send", risk_level="read_only")
     assert plugin._resolve_generation_source(
         review["proposal"]["proposal_id"]
     )[0] == "review"
 
-    # An id neither store knows resolves to nothing, so generate returns not-found.
+    # An unknown id resolves to nothing, so generation returns not-found.
     assert plugin._resolve_generation_source("prop-does-not-exist")[0] == ""
diff --git a/tests/test_evolution_producer.py b/tests/test_evolution_producer.py
index d122eb34..a7910331 100644
--- a/tests/test_evolution_producer.py
+++ b/tests/test_evolution_producer.py
@@ -116,8 +116,10 @@ def _install_registry(monkeypatch, registry, *, trust=None, usage=None, fibers=N
     """
     import leapflow.plugins as plugins_pkg
     from leapflow.monitor import evolution_producer as mod
+    from leapflow.telemetry import evolution_tap
 
     monkeypatch.setattr(plugins_pkg, "get_registry", lambda: registry, raising=False)
+    monkeypatch.setattr(evolution_tap, "current_sink", lambda: None)
     monkeypatch.setattr(
         mod.EvolutionProducer, "_trust_and_usage", staticmethod(lambda: (trust, usage))
     )
@@ -377,9 +379,12 @@ class _Obs:
         def unresolved(self, **_kw):
             return [{"observation_id": "o1"}, {"observation_id": "o2"}]
 
-    class _Queue:
-        def list_items(self, **_kw):
-            return [SimpleNamespace(status="PENDING"), SimpleNamespace(status="PROBATION")]
+    class _Projected(EvolutionProducer):
+        async def _event_projection(self, ctx):
+            return {
+                "proposals": [{"status": "PENDING"}, {"status": "PROBATION"}],
+                "degraded": False,
+            }
 
     class _Plans:
         def latest(self):
@@ -387,7 +392,6 @@ def latest(self):
 
     stores = {
         "capability_observations_path": _Obs(),
-        "capability_proposal_queue_path": _Queue(),
         "capability_plans_path": _Plans(),
     }
     _install_registry(monkeypatch, _Registry({}))
@@ -397,7 +401,7 @@ def latest(self):
         staticmethod(lambda layout_attr, *a, **k: stores.get(layout_attr)),
     )
 
-    rows = _rows(_observe()[0])
+    rows = _rows(_observe(_Projected())[0])
     assert rows["observations"]["status"] == WIRED
     assert "2 open" in rows["observations"]["evidence"]
     assert rows["lifecycle"]["status"] == WIRED
@@ -697,12 +701,12 @@ def test_unrebuildable_history_is_not_reported_as_no_activity(monkeypatch):
     _install_registry(monkeypatch, _Registry({}))
 
     class _Broken(EvolutionProducer):
-        def _episodes(self, ctx):
+        async def _event_projection(self, ctx):
             return None
 
     class _Empty(EvolutionProducer):
-        def _episodes(self, ctx):
-            return ()
+        async def _event_projection(self, ctx):
+            return {}
 
     broken = asyncio.run(_Broken().observe(_ctx()))[0].payload
     empty = asyncio.run(_Empty().observe(_ctx()))[0].payload
diff --git a/tests/test_evolution_projection.py b/tests/test_evolution_projection.py
new file mode 100644
index 00000000..86925295
--- /dev/null
+++ b/tests/test_evolution_projection.py
@@ -0,0 +1,215 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Replay and checkpoint contracts for the evolution read model."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from leapflow.domain.event_types import EvolutionEventType
+from leapflow.domain.evolution_event import EvolutionContext, EvolutionEvent
+from leapflow.evolution.projection import EvolutionProjectionRunner
+from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+
+
+def _event(
+    event_type: str,
+    *,
+    session_id: str,
+    action_id: str = "",
+    correlation_id: str = "",
+    payload: dict | None = None,
+) -> EvolutionEvent:
+    return EvolutionEvent.create(
+        event_type,
+        context=EvolutionContext.create(
+            profile_id="profile-1",
+            workspace_id=f"workspace-{session_id}",
+            session_id=session_id,
+            action_id=action_id,
+            correlation_id=correlation_id,
+        ),
+        payload=payload or {},
+        producer="test",
+        dedup_key=f"{event_type}:{session_id}:{action_id}:{correlation_id}",
+    )
+
+
+@pytest.mark.asyncio
+async def test_full_rebuild_equals_incremental_projection(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    store.append_many(
+        (
+            _event(EvolutionEventType.ACTION_STARTED, session_id="s1", action_id="a1"),
+            _event(
+                EvolutionEventType.ACTION_COMPLETED,
+                session_id="s1",
+                action_id="a1",
+                payload={"ok": True},
+            ),
+        )
+    )
+    episode_id, _ = store.finalize_session(
+        profile_id="profile-1",
+        workspace_id="workspace-s1",
+        session_id="s1",
+        session_generation=0,
+        from_sequence=0,
+        through_sequence=2,
+        reason="test",
+    )
+    runner = EvolutionProjectionRunner(store)
+    first = await runner.project_session(profile_id="profile-1", session_id="s1")
+
+    store.append(
+        _event(
+            EvolutionEventType.TEACHER_VERDICT_RECORDED,
+            session_id="s1",
+            correlation_id=episode_id,
+            payload={
+                "verdict_id": "v1",
+                "action": "absorb",
+                "capability": "repo.inspect",
+                "knowledge": "The existing reader is sufficient.",
+                "confidence": 0.9,
+            },
+        )
+    )
+    incremental = await runner.project_session(profile_id="profile-1", session_id="s1")
+    rebuilt = await runner.project_session(
+        profile_id="profile-1",
+        session_id="s1",
+        rebuild=True,
+    )
+
+    assert first["summary"]["action_count"] == 1
+    assert incremental == rebuilt
+    assert rebuilt["summary"]["by_action"]["absorb"] == 1
+    assert rebuilt["episodes"][0]["capability"] == "repo.inspect"
+    assert runner.metrics.run_latency.count == 3
+    assert runner.metrics.run_latency.p99_ms >= 0
+    store.close()
+
+
+@pytest.mark.asyncio
+async def test_four_verdicts_materialize_their_distinct_read_models(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    for index, action in enumerate(("absorb", "rebind", "acquire", "escalate")):
+        store.append(
+            _event(
+                EvolutionEventType.TEACHER_VERDICT_RECORDED,
+                session_id="s1",
+                correlation_id=f"episode-{index}",
+                payload={
+                    "verdict_id": f"v-{index}",
+                    "action": action,
+                    "capability": f"capability.{action}",
+                    "knowledge": "retain this fact",
+                    "rationale": "human decision required",
+                    "confidence": 0.8,
+                    "target": "existing_plugin",
+                },
+            )
+        )
+
+    projection = await EvolutionProjectionRunner(store).project_session(
+        profile_id="profile-1", session_id="s1"
+    )
+
+    assert projection["knowledge"][0]["capability"] == "capability.absorb"
+    assert projection["provider_bindings"][0]["plugin_id"] == "existing_plugin"
+    assert projection["proposal_candidates"][0]["capability"] == "capability.acquire"
+    assert projection["human_escalations"][0]["capability"] == "capability.escalate"
+    store.close()
+
+
+@pytest.mark.asyncio
+async def test_resolution_no_op_and_knowledge_retraction_are_projected(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    store.append_many(
+        (
+            _event(
+                EvolutionEventType.TEACHER_VERDICT_RECORDED,
+                session_id="s1",
+                correlation_id="episode-1",
+                payload={
+                    "verdict_id": "v-1",
+                    "action": "absorb",
+                    "capability": "repo.inspect",
+                    "knowledge": "Use the repository reader.",
+                    "confidence": 0.9,
+                },
+            ),
+            _event(
+                EvolutionEventType.REQUIREMENT_RESOLVED,
+                session_id="s1",
+                correlation_id="episode-1",
+                payload={
+                    "requirement": {"capability": "repo.inspect"},
+                    "outcome": "satisfied",
+                    "reason": "capability_already_available",
+                    "resolution": {"selected_plugin_id": "repo_builtin"},
+                },
+            ),
+            _event(
+                EvolutionEventType.KNOWLEDGE_RETRACTED,
+                session_id="s1",
+                correlation_id="episode-1",
+                payload={"capability": "repo.inspect", "reason": "observed working"},
+            ),
+        )
+    )
+
+    projection = await EvolutionProjectionRunner(store).project_session(
+        profile_id="profile-1", session_id="s1"
+    )
+
+    assert projection["knowledge"] == []
+    assert projection["summary"]["no_op_count"] == 1
+    assert projection["resolutions"][0]["outcome"] == "satisfied"
+    assert projection["resolutions"][0]["selected_plugin_id"] == "repo_builtin"
+    store.close()
+
+
+@pytest.mark.asyncio
+async def test_session_projection_never_leaks_another_session(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    store.append_many(
+        (
+            _event(EvolutionEventType.ACTION_STARTED, session_id="s1", action_id="a1"),
+            _event(EvolutionEventType.ACTION_STARTED, session_id="s2", action_id="a2"),
+            _event(
+                EvolutionEventType.ENVIRONMENT_OBSERVED,
+                session_id="s2",
+                payload={"kind": "delta", "app_id": "chat"},
+            ),
+        )
+    )
+    runner = EvolutionProjectionRunner(store)
+
+    session = await runner.project_session(profile_id="profile-1", session_id="s1")
+    aggregate = await runner.project_aggregate(profile_id="profile-1")
+
+    assert session["scope"] == "session"
+    assert session["session_id"] == "s1"
+    assert session["summary"]["action_count"] == 1
+    assert session["summary"]["environment_count"] == 0
+    assert aggregate["scope"] == "aggregate"
+    assert aggregate["summary"]["action_count"] == 2
+    assert aggregate["summary"]["environment_count"] == 1
+    store.close()
+
+
+@pytest.mark.asyncio
+async def test_projection_checkpoint_survives_runner_recreation(tmp_path: Path) -> None:
+    store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    store.append(_event(EvolutionEventType.ACTION_STARTED, session_id="s1", action_id="a1"))
+    first = await EvolutionProjectionRunner(store).project_aggregate(profile_id="profile-1")
+    store.append(_event(EvolutionEventType.ACTION_STARTED, session_id="s1", action_id="a2"))
+
+    resumed = await EvolutionProjectionRunner(store).project_aggregate(profile_id="profile-1")
+
+    assert first["summary"]["event_count"] == 1
+    assert resumed["summary"]["event_count"] == 2
+    assert resumed["summary"]["action_count"] == 2
+    store.close()
diff --git a/tests/test_evolution_tap.py b/tests/test_evolution_tap.py
index f6f86354..8ad86412 100644
--- a/tests/test_evolution_tap.py
+++ b/tests/test_evolution_tap.py
@@ -25,7 +25,10 @@
 
 from leapflow.domain.evolution_trace import EvolutionStage, EvolutionTrace
 from leapflow.evolution import LedgerEvolutionSink
-from leapflow.storage.evolution_trace_store import JsonEvolutionTraceStore
+from leapflow.storage.evolution_event_store import (
+    DuckDBEvolutionEventStore,
+    EvolutionTraceEventStore,
+)
 from leapflow.telemetry import evolution_tap
 
 
@@ -132,28 +135,33 @@ def append(self, traces):
 # ── the store ────────────────────────────────────────────────────────────────
 
 
-def test_store_round_trip_is_newest_first(tmp_path):
-    store = JsonEvolutionTraceStore(tmp_path / "t.json")
+def test_store_round_trip_is_newest_sequence_first(tmp_path):
+    events = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    store = EvolutionTraceEventStore(events, profile_id="profile-1")
     store.append([{"trace_id": "a", "ts": 1.0}, {"trace_id": "b", "ts": 3.0}])
     store.append([{"trace_id": "c", "ts": 2.0}])
-    assert [r["trace_id"] for r in store.list_traces()] == ["b", "c", "a"]
+    assert [r["trace_id"] for r in store.list_traces()] == ["c", "b", "a"]
+    events.close()
 
 
-def test_store_trims_to_the_newest(tmp_path):
-    """Retention is a count, because the newest traces are what an incident needs."""
-    store = JsonEvolutionTraceStore(tmp_path / "t.json", max_traces=3)
+def test_store_limits_reads_without_trimming_event_history(tmp_path):
+    events = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    store = EvolutionTraceEventStore(events, profile_id="profile-1")
     store.append([{"trace_id": f"t{i}", "ts": float(i)} for i in range(10)])
-    kept = [r["trace_id"] for r in store.list_traces()]
+    kept = [r["trace_id"] for r in store.list_traces(limit=3)]
     assert kept == ["t9", "t8", "t7"]
-    assert store.count() == 3
+    assert store.count() == 10
+    events.close()
 
 
-def test_corrupt_store_reads_as_empty_rather_than_raising(tmp_path):
-    path = tmp_path / "t.json"
-    path.write_text("{ not json", encoding="utf-8")
-    store = JsonEvolutionTraceStore(path)
-    assert store.list_traces() == []
-    assert store.append([{"trace_id": "a", "ts": 1.0}]) == 1
+def test_store_deduplicates_replayed_trace_ids(tmp_path):
+    events = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    store = EvolutionTraceEventStore(events, profile_id="profile-1")
+    trace = {"trace_id": "a", "ts": 1.0}
+    assert store.append([trace]) == 1
+    assert store.append([trace]) == 0
+    assert store.count() == 1
+    events.close()
 
 
 # ── probe: registry version bump ─────────────────────────────────────────────
@@ -270,62 +278,6 @@ def test_the_pure_trust_ledger_gains_no_telemetry_dependency():
 # ── probe: the world model's unadmitted proposals ────────────────────────────
 
 
-def test_unadmitted_intents_are_recorded_because_nothing_else_records_them():
-    """The single most valuable trace: a proposal that entered no pipeline.
-
-    It writes no observation, so without this the board shows an idle pipeline
-    while the world model proposes on every session.
-    """
-    import asyncio
-    from dataclasses import dataclass
-
-    from leapflow.learning.world_model_driver import WorldModelEvolutionDriver
-
-    @dataclass
-    class _Intent:
-        intent_id: str = "wmi-1"
-        capability: str = "ui.chat.send"
-        hypothesis: str = "no way to send a chat message"
-        confidence: float = 0.8
-
-        def to_dict(self):
-            return {
-                "intent_id": self.intent_id,
-                "capability": self.capability,
-                "hypothesis": self.hypothesis,
-                "confidence": self.confidence,
-            }
-
-        def to_observation_result(self, **_kw):
-            return {"error_type": "world_model_intent", "capability": self.capability}
-
-    class _Teacher:
-        async def grade_and_propose(self, trajectory, goal):
-            return type("V", (), {"grades": (), "intents": (_Intent(),)})()
-
-    class _RejectingIntake:
-        """Mirrors a profile where ``world_model_intent`` is not an accepted kind."""
-
-        def observe_result(self, *_a, **_kw):
-            return None
-
-        def requirements(self, **_kw):
-            return ()
-
-    collector = _Collector()
-    evolution_tap.install_sink(collector)
-
-    driver = WorldModelEvolutionDriver(teacher=_Teacher(), intake=_RejectingIntake())
-    result = asyncio.run(driver.drive(trajectory=[{"step": 1}], goal="g"))
-
-    assert result.admitted_observation_ids == ()
-    assert _kinds(collector) == ["world_model_drive"]
-    detail = collector.traces[0].detail
-    assert detail["not_admitted_reason"]
-    assert detail["intents"][0]["hypothesis"] == "no way to send a chat message"
-    assert detail["admitted_observation_ids"] == []
-
-
 def test_producer_surfaces_unadmitted_proposals_from_traces():
     """The payload must carry the model's reasoning, not just a count."""
     from leapflow.monitor.evolution_producer import EvolutionProducer
diff --git a/tests/test_evolution_trigger_boundary.py b/tests/test_evolution_trigger_boundary.py
index 374c2cfc..a07e8067 100644
--- a/tests/test_evolution_trigger_boundary.py
+++ b/tests/test_evolution_trigger_boundary.py
@@ -35,28 +35,21 @@
 # ════════════════════════════════════════════════════════════════
 
 
-def _learning_phase_body() -> ast.AST:
-    """Return the AST of ``_on_session_end_learning``'s trajectory-grading phase."""
+def _learning_boundary_body() -> ast.AST:
+    """Return the AST of the durable semantic session boundary."""
     tree = ast.parse(_CONTEXT_PY.read_text(encoding="utf-8"))
     for node in ast.walk(tree):
-        if isinstance(node, ast.AsyncFunctionDef) and node.name == "_on_session_end_learning":
+        if isinstance(node, ast.AsyncFunctionDef) and node.name == "run_learning_boundary":
             return node
-    raise AssertionError("_on_session_end_learning not found")
+    raise AssertionError("run_learning_boundary not found")
 
 
-def test_the_governance_sweep_is_not_nested_in_the_trajectory_branch() -> None:
-    """The defect, asserted structurally so a refactor cannot quietly re-nest it.
-
-    ``_run_coevolution_sweep`` documents that it "runs whether or not the teacher
-    proposed anything, so its no-op traces distinguish a quiet session from a sweep
-    that never ran". Nested inside ``if trajectory:`` it did neither, and three
-    reachability segments read "no sweep trace observed" on a live board for that
-    reason alone.
-    """
-    phase = _learning_phase_body()
-
+def test_the_governance_sweep_is_not_nested_in_the_teacher_job_branch() -> None:
+    """A boundary with no teacher job must still leave governance evidence."""
+    boundary = _learning_boundary_body()
     sweep_calls = [
-        node for node in ast.walk(phase)
+        node
+        for node in ast.walk(boundary)
         if isinstance(node, ast.Call)
         and isinstance(node.func, ast.Attribute)
         and node.func.attr == "_run_coevolution_sweep"
@@ -64,12 +57,11 @@ def test_the_governance_sweep_is_not_nested_in_the_trajectory_branch() -> None:
     assert len(sweep_calls) == 1, "the sweep must be driven from exactly one place"
     sweep_line = sweep_calls[0].lineno
 
-    # Any `if` whose test mentions the trajectory must not contain the sweep call.
-    for node in ast.walk(phase):
+    for node in ast.walk(boundary):
         if not isinstance(node, ast.If):
             continue
         test_names = {n.id for n in ast.walk(node.test) if isinstance(n, ast.Name)}
-        if "trajectory" not in test_names:
+        if not ({"jobs", "finalizations"} & test_names):
             continue
         guarded = [
             child.lineno
@@ -78,15 +70,16 @@ def test_the_governance_sweep_is_not_nested_in_the_trajectory_branch() -> None:
             if hasattr(child, "lineno")
         ]
         assert sweep_line not in guarded, (
-            "the sweep is nested inside a trajectory guard again; an empty trajectory "
-            "would skip it and the board would report 'no sweep trace observed'"
+            "the sweep is nested inside teacher-work availability; a quiet boundary "
+            "would be indistinguishable from a sweep that never ran"
         )
 
 
-def test_an_empty_trajectory_still_reports_its_phase() -> None:
-    """The quiet path must remain observable, not silent."""
+def test_the_legacy_shutdown_only_learning_path_is_absent() -> None:
+    """Teacher work must be driven only by durable session finalization."""
     source = _CONTEXT_PY.read_text(encoding="utf-8")
-    assert '"note": "empty_trajectory"' in source
+    assert "_on_session_end_learning" not in source
+    assert "_drive_world_model_evolution" not in source
 
 
 # ════════════════════════════════════════════════════════════════
@@ -117,16 +110,21 @@ def test_cleanup_drives_the_boundary_through_the_public_entry_point() -> None:
 
 
 def test_the_daemon_exposes_the_boundary_as_an_rpc() -> None:
-    """It has to run in the daemon: that is the process holding the trajectory."""
-    from leapflow.daemon.protocol import METHOD_REGISTRY
+    """It has to run in the daemon: that process owns the durable event stream."""
+    from leapflow.daemon.protocol import LeapService, METHOD_REGISTRY
 
     assert METHOD_REGISTRY.get("evolution.run") == "evolution_run"
+    signature = inspect.signature(LeapService.evolution_run)
+    assert signature.parameters["session_id"].default is inspect.Parameter.empty
 
 
 def test_the_cli_can_run_the_boundary_without_stopping_the_daemon() -> None:
     from leapflow.cli.commands.evolve import cmd_evolve
 
     assert callable(cmd_evolve)
+    source = (Path(__file__).parents[1] / "src" / "leapflow" / "cli" / "cli.py").read_text()
+    assert '"--session"' in source
+    assert "required=True" in source
 
 
 def test_the_trajectory_buffer_is_bounded() -> None:
@@ -167,13 +165,15 @@ def producer() -> EvolutionProducer:
 
 
 def _run(producer: EvolutionProducer, queue: object) -> dict:
-    """Call the segment with a stubbed store, since the store lookup reads settings."""
-    original = producer._json_store
-    producer._json_store = lambda *args, **kwargs: queue  # type: ignore[assignment]
+    """Call the segment with a projection shaped from the supplied lifecycle rows."""
     try:
-        return producer._segment_lifecycle()
-    finally:
-        producer._json_store = original  # type: ignore[assignment]
+        proposals = [
+            {"status": item.status}
+            for item in queue.list_items(limit=0)  # type: ignore[attr-defined]
+        ]
+    except (AttributeError, OSError):
+        return producer._segment_lifecycle(None)
+    return producer._segment_lifecycle({"proposals": proposals})
 
 
 def test_a_queue_that_never_advances_is_not_wired(producer: EvolutionProducer) -> None:
diff --git a/tests/test_evolution_verify_and_govern.py b/tests/test_evolution_verify_and_govern.py
index b093a04b..4ee71aea 100644
--- a/tests/test_evolution_verify_and_govern.py
+++ b/tests/test_evolution_verify_and_govern.py
@@ -125,8 +125,9 @@ def test_verdict_feeds_the_governor_and_quarantines_a_useless_artifact(tmp_path)
     """WM-6 + LF-10: repeated verification failure reclaims the artifact."""
     from leapflow.learning.plugin_trust import PluginTrustLedger
     from leapflow.plugins.lifecycle_governor import LifecycleGovernor
-    from leapflow.storage.capability_proposal_queue import JsonCapabilityProposalQueue
-    from leapflow.storage.plugin_outcome_store import JsonPluginOutcomeStore
+    from leapflow.storage.capability_proposal_queue import EvolutionCapabilityProposalStore
+    from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+    from leapflow.storage.plugin_outcome_store import EvolutionPluginOutcomeStore
 
     disabled: list[str] = []
 
@@ -135,11 +136,20 @@ async def disable(self, *, plugin_id):
             disabled.append(plugin_id)
             return {"ok": True}
 
-    queue = JsonCapabilityProposalQueue(tmp_path / "q.json")
+    event_store = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    queue = EvolutionCapabilityProposalStore(event_store, profile_id="profile-1")
     item = queue.enqueue(requirements=[_requirement()], source="test")
+    queue.transition(item.proposal_id, "GENERATED", generated_code_ref="sha256:test")
+    queue.transition(
+        item.proposal_id,
+        "APPROVED",
+        proposal_approval_id="approval-content",
+        mutation_approval_id="approval-mutation",
+    )
+    queue.transition(item.proposal_id, "INSTALLED", install_result={"ok": True})
     governor = LifecycleGovernor(
         proposal_queue=queue,
-        outcome_store=JsonPluginOutcomeStore(tmp_path / "o.json"),
+        outcome_store=EvolutionPluginOutcomeStore(event_store, profile_id="profile-1"),
         lifecycle_actor=_Actor(),
         trust_ledger=PluginTrustLedger(),
         quarantine_after=3,
@@ -162,6 +172,7 @@ async def disable(self, *, plugin_id):
 
     assert actions[-1] == "quarantine"
     assert disabled == ["gen_useless"]      # the useless artifact was reclaimed
+    event_store.close()
 
 
 # ── LF-10: the residual case the governor cannot reach ────────────────────────
diff --git a/tests/test_gateway_adapter_registry.py b/tests/test_gateway_adapter_registry.py
index d6c271ca..6bb82d6c 100644
--- a/tests/test_gateway_adapter_registry.py
+++ b/tests/test_gateway_adapter_registry.py
@@ -11,11 +11,11 @@
 
 import sys
 import types
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 import pytest
 
-from leapflow.gateway.adapter_registry import GatewayAdapterRegistry, BuiltinAdapterPlugin
+from leapflow.gateway.adapter_registry import GatewayAdapterRegistry
 from leapflow.gateway.scoped_adapter_registry import ScopedGatewayAdapterRegistry
 from leapflow.gateway.protocol import PlatformAdapter
 
diff --git a/tests/test_hardware_transport_contract.py b/tests/test_hardware_transport_contract.py
index 1f6b1278..14950a1e 100644
--- a/tests/test_hardware_transport_contract.py
+++ b/tests/test_hardware_transport_contract.py
@@ -36,7 +36,7 @@
     TransportStatus,
     WriteOutcome,
 )
-from leapflow.hardware.transports import available_transports, build_transport
+from leapflow.hardware.transports import build_transport, builtin_transports
 
 
 def _conformance_context(transport_kind: str, config: dict[str, Any]) -> HardwareContext:
@@ -253,7 +253,7 @@ def test_every_registered_transport_is_covered_or_declared_external() -> None:
     notices later.
     """
     covered = {case.kind for case in _TRANSPORT_CASES} | _EXTERNAL_ONLY_TRANSPORTS
-    missing = set(available_transports()) - covered
+    missing = set(builtin_transports()) - covered
     assert not missing, (
         f"transports {sorted(missing)} are registered but not conformance-tested; "
         "add a case to _TRANSPORT_CASES or justify it in _EXTERNAL_ONLY_TRANSPORTS"
diff --git a/tests/test_inert_wiring_audit.py b/tests/test_inert_wiring_audit.py
index d9d654c3..ce14143c 100644
--- a/tests/test_inert_wiring_audit.py
+++ b/tests/test_inert_wiring_audit.py
@@ -18,9 +18,46 @@
 from typing import Any
 
 from leapflow.domain.adaptation_verdict import AdaptationVerdict
+from leapflow.domain.capability_requirement import CapabilityRequirement
 from leapflow.learning.capability_gap_detector import CapabilityGapDetector
-from leapflow.learning.degradation_sink import build_proposal_sink
-from leapflow.storage.capability_proposal_queue import JsonCapabilityProposalQueue
+from leapflow.storage.capability_proposal_queue import EvolutionCapabilityProposalStore
+from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+
+
+def _enqueue(queue: Any, proposal: Any) -> str:
+    """The acquisition chain's last hop, inlined: intent -> requirement -> queue.
+
+    Mirrors ``DurableTeacherWorker._plan_acquisitions`` exactly -- a requirement keyed
+    on the capability, clamped risk, ``world_model`` source -- so the queue's dedup and
+    risk-clamp contract stays under test without the deleted proposal sink.
+    """
+    evidence = tuple(getattr(proposal, "evidence", ()) or ())
+    metadata = dict(getattr(evidence[0], "metadata", {})) if evidence else {}
+    capability = str(metadata.get("capability") or "").strip()
+    if not capability:
+        return ""
+    requirement = CapabilityRequirement.create(
+        capability,
+        "world_model",
+        evidence=str(getattr(proposal, "capability_summary", "") or capability),
+        max_risk_level=str(getattr(proposal, "risk_level", "read_only")),
+        requirement_id=f"req-wm-{capability}",
+    )
+    try:
+        item = queue.enqueue(
+            requirements=(requirement,),
+            source="world_model",
+            risk={"max_risk_level": requirement.max_risk_level},
+        )
+    except Exception:  # noqa: BLE001 - queueing must not fail the session
+        return ""
+    return str(getattr(item, "proposal_id", ""))
+
+
+def _queue(tmp_path: Path) -> EvolutionCapabilityProposalStore:
+    return EvolutionCapabilityProposalStore(
+        DuckDBEvolutionEventStore(tmp_path / "events.duckdb"), profile_id="profile-1"
+    )
 
 
 def _proposal(capability: str, *, risk: str = "read_only") -> Any:
@@ -39,8 +76,8 @@ def test_an_acquire_verdict_reaches_the_proposal_queue(tmp_path):
     Resolution would report the capability unmet forever, so the teacher's most expensive
     verdict -- the only one that leads to code -- had no effect whatsoever.
     """
-    queue = JsonCapabilityProposalQueue(tmp_path / "q.json")
-    identifier = build_proposal_sink(queue=queue)(_proposal("mail.send"))
+    queue = _queue(tmp_path)
+    identifier = _enqueue(queue, _proposal("mail.send"))
 
     assert identifier
     items = queue.list_items()
@@ -57,12 +94,11 @@ def test_the_same_capability_does_not_pile_up_across_sessions(tmp_path):
     would face a growing pile of identical items, and the queue's depth would measure how
     long the process had been running rather than how much was outstanding.
     """
-    queue = JsonCapabilityProposalQueue(tmp_path / "q.json")
-    sink = build_proposal_sink(queue=queue)
+    queue = _queue(tmp_path)
 
-    first = sink(_proposal("mail.send"))
-    second = sink(_proposal("mail.send"))
-    other = sink(_proposal("chat.reply"))
+    first = _enqueue(queue, _proposal("mail.send"))
+    second = _enqueue(queue, _proposal("mail.send"))
+    other = _enqueue(queue, _proposal("chat.reply"))
 
     assert first == second, "the same capability must resolve to the same proposal"
     assert other != first
@@ -76,8 +112,8 @@ def test_the_queued_requirement_keeps_the_clamped_risk(tmp_path):
     to ``read_only`` enter the queue asking for everything -- the exact opposite of what
     the clamp exists for.
     """
-    queue = JsonCapabilityProposalQueue(tmp_path / "q.json")
-    build_proposal_sink(queue=queue)(_proposal("shell.run", risk="external"))
+    queue = _queue(tmp_path)
+    _enqueue(queue, _proposal("shell.run", risk="external"))
 
     requirement = queue.list_items()[0].requirements[0]
     assert requirement["max_risk_level"] == "read_only", "the model cannot widen its own ask"
@@ -85,10 +121,9 @@ def test_the_queued_requirement_keeps_the_clamped_risk(tmp_path):
 
 def test_a_proposal_without_a_capability_is_refused(tmp_path):
     """The queue has nothing to deduplicate on and resolution nothing to satisfy."""
-    queue = JsonCapabilityProposalQueue(tmp_path / "q.json")
-    sink = build_proposal_sink(queue=queue)
+    queue = _queue(tmp_path)
 
-    assert sink(SimpleNamespace(evidence=(), proposal_id="p1")) == ""
+    assert _enqueue(queue, SimpleNamespace(evidence=(), proposal_id="p1")) == ""
     assert queue.list_items() == []
 
 
@@ -99,7 +134,7 @@ class _Broken:
         def enqueue(self, **kwargs):
             raise OSError("disk full")
 
-    assert build_proposal_sink(queue=_Broken())(_proposal("mail.send")) == ""
+    assert _enqueue(_Broken(), _proposal("mail.send")) == ""
 
 
 # ── the audit itself, kept honest ─────────────────────────────────────────────
diff --git a/tests/test_lifecycle_governor.py b/tests/test_lifecycle_governor.py
index 3f1a7f13..92458dd5 100644
--- a/tests/test_lifecycle_governor.py
+++ b/tests/test_lifecycle_governor.py
@@ -8,8 +8,9 @@
 from leapflow.domain.capability_requirement import CapabilityRequirement
 from leapflow.learning.plugin_trust import PluginTrustLedger, PluginTrustLevel
 from leapflow.plugins.lifecycle_governor import LifecycleGovernor
-from leapflow.storage.capability_proposal_queue import JsonCapabilityProposalQueue
-from leapflow.storage.plugin_outcome_store import JsonPluginOutcomeStore
+from leapflow.storage.capability_proposal_queue import EvolutionCapabilityProposalStore
+from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+from leapflow.storage.plugin_outcome_store import EvolutionPluginOutcomeStore
 
 
 class _Actor:
@@ -21,7 +22,7 @@ async def disable(self, *, plugin_id: str):
         return {"ok": True, "action": "disable", "plugin_id": plugin_id}
 
 
-def _proposal(queue: JsonCapabilityProposalQueue):
+def _proposal(queue: EvolutionCapabilityProposalStore):
     requirement = CapabilityRequirement.create(
         "json.pretty",
         "explicit_request",
@@ -33,16 +34,24 @@ def _proposal(queue: JsonCapabilityProposalQueue):
         risk={"risk_level": "read_only"},
         metadata={"plugin_id": "json_pretty_plugin"},
     )
-    return queue.update(item.proposal_id, status="INSTALLED")
+    queue.transition(item.proposal_id, "GENERATED", generated_code_ref="sha256:test")
+    queue.transition(
+        item.proposal_id,
+        "APPROVED",
+        proposal_approval_id="approval-content",
+        mutation_approval_id="approval-mutation",
+    )
+    return queue.transition(item.proposal_id, "INSTALLED", install_result={"ok": True})
 
 
 @pytest.mark.asyncio
 async def test_lifecycle_governor_promotes_verified_after_successes(tmp_path) -> None:
-    queue = JsonCapabilityProposalQueue(tmp_path / "proposals.json")
+    events = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    queue = EvolutionCapabilityProposalStore(events, profile_id="profile-1")
     proposal = _proposal(queue)
     governor = LifecycleGovernor(
         proposal_queue=queue,
-        outcome_store=JsonPluginOutcomeStore(tmp_path / "outcomes.json"),
+        outcome_store=EvolutionPluginOutcomeStore(events, profile_id="profile-1"),
         trust_ledger=PluginTrustLedger(candidate_at=1, verified_at=2, production_at=3),
         verified_at=PluginTrustLevel.VERIFIED,
     )
@@ -66,12 +75,13 @@ async def test_lifecycle_governor_promotes_verified_after_successes(tmp_path) ->
 
 @pytest.mark.asyncio
 async def test_lifecycle_governor_quarantines_after_failure_streak(tmp_path) -> None:
-    queue = JsonCapabilityProposalQueue(tmp_path / "proposals.json")
+    events = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    queue = EvolutionCapabilityProposalStore(events, profile_id="profile-1")
     proposal = _proposal(queue)
     actor = _Actor()
     governor = LifecycleGovernor(
         proposal_queue=queue,
-        outcome_store=JsonPluginOutcomeStore(tmp_path / "outcomes.json"),
+        outcome_store=EvolutionPluginOutcomeStore(events, profile_id="profile-1"),
         lifecycle_actor=actor,
         quarantine_after=2,
     )
@@ -92,3 +102,34 @@ async def test_lifecycle_governor_quarantines_after_failure_streak(tmp_path) ->
     assert result.action == "quarantine"
     assert actor.disabled == ["json_pretty_plugin"]
     assert queue.get(proposal.proposal_id).status == "QUARANTINED"
+
+
+@pytest.mark.asyncio
+async def test_internal_defect_immediately_freezes_and_quarantines(tmp_path) -> None:
+    events = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    queue = EvolutionCapabilityProposalStore(events, profile_id="profile-1")
+    proposal = _proposal(queue)
+    actor = _Actor()
+    trust = PluginTrustLedger(candidate_at=1, verified_at=2, production_at=3)
+    governor = LifecycleGovernor(
+        proposal_queue=queue,
+        outcome_store=EvolutionPluginOutcomeStore(events, profile_id="profile-1"),
+        lifecycle_actor=actor,
+        trust_ledger=trust,
+        quarantine_after=99,
+    )
+
+    result = await governor.record_outcome(
+        proposal_id=proposal.proposal_id,
+        plugin_id="json_pretty_plugin",
+        tool_name="json_pretty",
+        ok=False,
+        failure_class="internal_defect",
+    )
+
+    assert result.action == "quarantine"
+    assert trust.is_frozen("json_pretty_plugin") is True
+    item = queue.get(proposal.proposal_id)
+    assert item.status == "QUARANTINED"
+    assert item.trust_state["frozen"] is True
+    assert item.metadata["terminal_reason"] == "internal_defect"
diff --git a/tests/test_llm_coevolution_e2e.py b/tests/test_llm_coevolution_e2e.py
index 0bc004f2..9791c823 100644
--- a/tests/test_llm_coevolution_e2e.py
+++ b/tests/test_llm_coevolution_e2e.py
@@ -11,9 +11,6 @@
 This is the ultimate self-evolution capability demonstration.
 """
 
-import asyncio
-from pathlib import Path
-from typing import Any
 
 import pytest
 
diff --git a/tests/test_llm_provider_registry.py b/tests/test_llm_provider_registry.py
index bfbde5f9..c351b8ec 100644
--- a/tests/test_llm_provider_registry.py
+++ b/tests/test_llm_provider_registry.py
@@ -12,7 +12,7 @@
 
 import sys
 import types
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
 import pytest
 
diff --git a/tests/test_marketplace_server.py b/tests/test_marketplace_server.py
index 2b7dffc0..3ccd7f73 100644
--- a/tests/test_marketplace_server.py
+++ b/tests/test_marketplace_server.py
@@ -5,15 +5,12 @@
 plugin manifests and code files, matching the API expected by HttpMarketplaceSource.
 """
 
-import asyncio
 import json
 from pathlib import Path
-from typing import List
 
 import pytest
 import httpx
 
-from leapflow.plugins.marketplace.manifest import PluginManifest
 from leapflow.plugins.marketplace.server import MarketplaceServer
 
 
diff --git a/tests/test_performance_metrics.py b/tests/test_performance_metrics.py
new file mode 100644
index 00000000..692c6da8
--- /dev/null
+++ b/tests/test_performance_metrics.py
@@ -0,0 +1,33 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Tests for bounded runtime latency summaries."""
+from __future__ import annotations
+
+from leapflow.performance import RollingLatency
+
+
+def test_rolling_latency_reports_interpolated_percentiles() -> None:
+    latency = RollingLatency(capacity=5)
+    for value in (1, 2, 3, 4, 5):
+        latency.observe(value)
+
+    snapshot = latency.snapshot()
+
+    assert snapshot.count == 5
+    assert snapshot.minimum_ms == 1
+    assert snapshot.mean_ms == 3
+    assert snapshot.p50_ms == 3
+    assert snapshot.p95_ms == 4.8
+    assert snapshot.p99_ms == 4.96
+    assert snapshot.maximum_ms == 5
+
+
+def test_rolling_latency_is_bounded() -> None:
+    latency = RollingLatency(capacity=3)
+    for value in (1, 2, 3, 4):
+        latency.observe(value)
+
+    snapshot = latency.snapshot()
+
+    assert snapshot.count == 3
+    assert snapshot.minimum_ms == 2
+    assert snapshot.maximum_ms == 4
diff --git a/tests/test_phase3_learning_autonomy.py b/tests/test_phase3_learning_autonomy.py
index f0544159..96650b95 100644
--- a/tests/test_phase3_learning_autonomy.py
+++ b/tests/test_phase3_learning_autonomy.py
@@ -592,7 +592,7 @@ class FakeSpec:
         policy = execution_policy_for("some_mcp_tool", spec)
         assert policy == "read_only"
 
-    def test_non_mcp_tool_without_metadata_stays_idempotent(self) -> None:
+    def test_any_tool_without_metadata_fails_safe_as_external(self) -> None:
         from leapflow.engine.tool_execution import execution_policy_for
 
         @dataclass
@@ -604,8 +604,8 @@ class FakeSpec:
             category: str = "general"
 
         spec = FakeSpec()
-        policy = execution_policy_for("some_tool", spec)
-        assert policy == "mutating_idempotent"
+        assert execution_policy_for("file_read", spec) == "external_side_effect"
+        assert execution_policy_for("gateway_send", spec) == "external_side_effect"
 
 
 # ════════════════════════════════════════════════════════════════
diff --git a/tests/test_plugin_learning.py b/tests/test_plugin_learning.py
index c545ec30..707ccae6 100644
--- a/tests/test_plugin_learning.py
+++ b/tests/test_plugin_learning.py
@@ -12,14 +12,11 @@
 
 import pytest
 from typing import Any
-from unittest.mock import patch, MagicMock
 
 from leapflow.learning.plugin_trust import PluginTrustLedger, PluginTrustLevel
-from leapflow.learning.plugin_stats import PluginUsageTracker, PluginStats
+from leapflow.learning.plugin_stats import PluginUsageTracker
 from leapflow.learning.plugin_advisor import (
     PluginAdvisor,
-    PluginRecommendation,
-    get_default_advisor,
     set_default_advisor,
 )
 
diff --git a/tests/test_plugin_proposal_store.py b/tests/test_plugin_proposal_store.py
deleted file mode 100644
index e33c7de6..00000000
--- a/tests/test_plugin_proposal_store.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# Copyright (c) Alibaba, Inc. and its affiliates.
-"""Tests for profile-scoped plugin proposal persistence."""
-from __future__ import annotations
-
-from leapflow.domain.plugin_proposal import BehaviorTestCase, GapEvidence, PluginProposal, ProposedToolSpec
-from leapflow.storage.plugin_proposal_store import JsonPluginProposalStore
-
-
-def test_json_plugin_proposal_store_round_trip(tmp_path) -> None:
-    store = JsonPluginProposalStore(tmp_path / "proposals.json")
-    proposal = PluginProposal.create(
-        plugin_id="json_tools",
-        capability_summary="Validate JSON",
-        evidence=(GapEvidence.create("explicit", "Need JSON validation", confidence=0.8),),
-        proposed_tools=(ProposedToolSpec(name="json_validate", description="Validate JSON"),),
-        test_cases=(BehaviorTestCase.create("json_validate", arguments={"text": "{}"}, expected_subset={"ok": True}),),
-    )
-
-    store.save(proposal)
-    loaded = store.get(proposal.proposal_id)
-
-    assert loaded == proposal
-    assert store.path.exists()
-    assert store.list() == [proposal]
-    assert loaded.test_cases[0].tool_name == "json_validate"
-
-
-def test_json_plugin_proposal_store_update_status(tmp_path) -> None:
-    store = JsonPluginProposalStore(tmp_path / "proposals.json")
-    proposal = store.save(
-        PluginProposal.create(plugin_id="p", capability_summary="capability")
-    )
-
-    updated = store.update_status(proposal.proposal_id, "approved")
-
-    assert updated is not None
-    assert updated.status == "approved"
-    assert store.get(proposal.proposal_id).status == "approved"
diff --git a/tests/test_plugin_sandbox.py b/tests/test_plugin_sandbox.py
index 16c18b48..991c5465 100644
--- a/tests/test_plugin_sandbox.py
+++ b/tests/test_plugin_sandbox.py
@@ -5,7 +5,6 @@
 
 import asyncio
 import sys
-from typing import Any
 
 import pytest
 
@@ -20,6 +19,21 @@
 class TestSandboxProtocol:
     """SandboxRequest/Response serialization roundtrips."""
 
+    def test_resource_limits_validate_configuration(self) -> None:
+        from leapflow.plugins.sandbox.sandbox_host import SandboxLimits
+
+        limits = SandboxLimits(
+            invoke_timeout_s=1.5,
+            shutdown_timeout_s=0.5,
+            cpu_time_s=7,
+            max_memory_bytes=128 * 1024 * 1024,
+        )
+        assert limits.cpu_time_s == 7
+        with pytest.raises(ValueError, match="timeouts"):
+            SandboxLimits(invoke_timeout_s=0)
+        with pytest.raises(ValueError, match="resource limits"):
+            SandboxLimits(max_memory_bytes=-1)
+
     def test_request_roundtrip_basic(self) -> None:
         req = SandboxRequest(
             request_id="abc-123",
@@ -183,6 +197,7 @@ def bind_runtime(self, **deps): pass
         resp = await host.invoke("hang_tool", {"params": {}})
         assert resp.ok is False
         assert "timed out" in resp.error
+        assert host._proc is None, "a timed-out worker must be terminated"
     finally:
         await host.stop()
 
diff --git a/tests/test_plugin_stats_persistence.py b/tests/test_plugin_stats_persistence.py
index 4e609bc9..1d4448ff 100644
--- a/tests/test_plugin_stats_persistence.py
+++ b/tests/test_plugin_stats_persistence.py
@@ -21,7 +21,6 @@
     _default_stats_db_path,
     _load_or_new_trust_ledger,
     _resolve_stats_store,
-    _wire_plugin_stats_sink,
     persist_plugin_trust_state,
 )
 from leapflow.engine.turn_usage import TurnUsageTracker
diff --git a/tests/test_proposal_orchestrator.py b/tests/test_proposal_orchestrator.py
new file mode 100644
index 00000000..70c58bab
--- /dev/null
+++ b/tests/test_proposal_orchestrator.py
@@ -0,0 +1,303 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Contracts for the durable proposal policy and double-approval boundary."""
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from leapflow.daemon.approval_coordinator import ApprovalCoordinator, _DaemonApprovalGate
+from leapflow.daemon.approval_route import approval_route
+from leapflow.domain.capability_requirement import CapabilityRequirement
+from leapflow.evolution.artifact_store import ContentAddressedArtifactStore
+from leapflow.plugins.adaptive_policy import AdaptiveEvolutionPolicy
+from leapflow.plugins.proposal_orchestrator import ProposalOrchestrator
+from leapflow.security.approval import ApprovalDecision, SessionAwareGate
+from leapflow.security.orchestrator import ApprovalOrchestrator
+from leapflow.storage.capability_proposal_queue import EvolutionCapabilityProposalStore
+from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+
+
+class _Gate:
+    def __init__(self, decisions: list[bool | BaseException]) -> None:
+        self._decisions = list(decisions)
+        self.actions = []
+
+    async def evaluate(self, action):
+        self.actions.append(action)
+        approved = self._decisions.pop(0)
+        if isinstance(approved, BaseException):
+            raise approved
+        return SimpleNamespace(
+            approved=approved,
+            action=action,
+            reason="user_approved" if approved else "user_denied",
+            denial_message="denied" if not approved else "",
+        )
+
+
+class _RequestGate:
+    def __init__(self, decisions: list[ApprovalDecision]) -> None:
+        self._decisions = list(decisions)
+        self.requests = []
+
+    async def request_approval(self, request):
+        self.requests.append(request)
+        return self._decisions.pop(0)
+
+
+def _queue(tmp_path: Path) -> tuple[EvolutionCapabilityProposalStore, str]:
+    events = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    queue = EvolutionCapabilityProposalStore(events, profile_id="profile-1")
+    item = queue.enqueue(
+        requirements=(
+            CapabilityRequirement.create(
+                "chat.reply",
+                "world_model",
+                requirement_id="req-chat-reply",
+                max_risk_level="read_only",
+            ),
+        ),
+        risk={"risk_level": "read_only"},
+        metadata={"plugin_id": "chat_reply_plugin"},
+    )
+    return queue, item.proposal_id
+
+
+@pytest.mark.asyncio
+async def test_generated_proposal_requires_two_distinct_approvals(tmp_path: Path) -> None:
+    queue, proposal_id = _queue(tmp_path)
+    gate = _Gate([True, True])
+    orchestrator = ProposalOrchestrator(
+        queue=queue,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        approval_gate=gate,
+        policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+    )
+
+    generated = orchestrator.register_generated(
+        proposal_id,
+        "plugin = object()\n",
+        validation={"ok": True, "stage": "passed", "compatibility_ok": True},
+    )
+    content = await orchestrator.approve_content(proposal_id)
+    mutation = await orchestrator.authorize_mutation(proposal_id)
+    installed = orchestrator.record_installed(proposal_id, {"ok": True})
+
+    assert generated.status == "GENERATED"
+    assert content.approved and mutation.approved
+    assert content.approval_id != mutation.approval_id
+    assert installed.status == "INSTALLED"
+    assert installed.proposal_approval_id == content.approval_id
+    assert installed.mutation_approval_id == mutation.approval_id
+    assert [action.metadata["approval_stage"] for action in gate.actions] == [
+        "proposal_content",
+        "plugin_mutation",
+    ]
+    assert orchestrator.generated_code(proposal_id) == "plugin = object()\n"
+
+
+def test_missing_compatibility_evidence_fails_before_cas_admission(tmp_path: Path) -> None:
+    queue, proposal_id = _queue(tmp_path)
+    orchestrator = ProposalOrchestrator(
+        queue=queue,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        approval_gate=None,
+        policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+    )
+
+    failed = orchestrator.register_generated(
+        proposal_id,
+        "plugin = object()\n",
+        validation={"ok": True},
+    )
+
+    assert failed.status == "FAILED"
+    assert failed.generated_code_ref == ""
+    assert failed.metadata["terminal_reason"] == "static or compatibility validation failed"
+
+
+@pytest.mark.asyncio
+async def test_content_denial_is_terminal_and_blocks_mutation(tmp_path: Path) -> None:
+    queue, proposal_id = _queue(tmp_path)
+    orchestrator = ProposalOrchestrator(
+        queue=queue,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        approval_gate=_Gate([False]),
+        policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+    )
+    orchestrator.register_generated(
+        proposal_id,
+        "plugin = object()\n",
+        validation={"ok": True, "compatibility_ok": True}
+    )
+
+    approval = await orchestrator.approve_content(proposal_id)
+
+    assert approval.approved is False
+    assert queue.get(proposal_id).status == "REJECTED"
+    with pytest.raises(PermissionError):
+        await orchestrator.authorize_mutation(proposal_id)
+
+
+@pytest.mark.asyncio
+async def test_missing_gate_fails_closed_with_terminal_rejection(tmp_path: Path) -> None:
+    queue, proposal_id = _queue(tmp_path)
+    orchestrator = ProposalOrchestrator(
+        queue=queue,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        approval_gate=None,
+        policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+    )
+    orchestrator.register_generated(
+        proposal_id,
+        "plugin = object()\n",
+        validation={"ok": True, "compatibility_ok": True}
+    )
+
+    approval = await orchestrator.approve_content(proposal_id)
+
+    assert approval.approved is False
+    rejected = queue.get(proposal_id)
+    assert rejected.status == "REJECTED"
+    assert rejected.metadata["terminal_reason"] == "approval_gate_missing"
+
+
+@pytest.mark.asyncio
+async def test_mutation_denial_is_terminal(tmp_path: Path) -> None:
+    queue, proposal_id = _queue(tmp_path)
+    orchestrator = ProposalOrchestrator(
+        queue=queue,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        approval_gate=_Gate([True, False]),
+        policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+    )
+    orchestrator.register_generated(proposal_id, "plugin = object()\n", validation={"ok": True, "compatibility_ok": True})
+    await orchestrator.approve_content(proposal_id)
+
+    approval = await orchestrator.authorize_mutation(proposal_id)
+
+    assert approval.approved is False
+    rejected = queue.get(proposal_id)
+    assert rejected.status == "REJECTED"
+    assert rejected.mutation_approval_id
+    assert rejected.metadata["terminal_reason"] == "user_denied"
+
+
+@pytest.mark.asyncio
+async def test_gate_exception_fails_closed_and_records_reason(tmp_path: Path) -> None:
+    queue, proposal_id = _queue(tmp_path)
+    orchestrator = ProposalOrchestrator(
+        queue=queue,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        approval_gate=_Gate([RuntimeError("route unavailable")]),
+        policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+    )
+    orchestrator.register_generated(proposal_id, "plugin = object()\n", validation={"ok": True, "compatibility_ok": True})
+
+    approval = await orchestrator.approve_content(proposal_id)
+
+    assert approval.approved is False
+    rejected = queue.get(proposal_id)
+    assert rejected.status == "REJECTED"
+    assert rejected.metadata["terminal_reason"] == "approval_gate_error:RuntimeError"
+
+
+@pytest.mark.asyncio
+async def test_production_approval_orchestrator_supports_both_stages(tmp_path: Path) -> None:
+    queue, proposal_id = _queue(tmp_path)
+    request_gate = _RequestGate([ApprovalDecision.ALLOW_ONCE, ApprovalDecision.ALLOW_ONCE])
+    orchestrator = ProposalOrchestrator(
+        queue=queue,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        approval_gate=ApprovalOrchestrator(request_gate),
+        policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+    )
+    orchestrator.register_generated(proposal_id, "plugin = object()\n", validation={"ok": True, "compatibility_ok": True})
+
+    content = await orchestrator.approve_content(proposal_id)
+    mutation = await orchestrator.authorize_mutation(proposal_id)
+
+    assert content.approved and mutation.approved
+    assert content.approval_id != mutation.approval_id
+    assert [
+        request.action.metadata["approval_stage"] for request in request_gate.requests
+    ] == ["proposal_content", "plugin_mutation"]
+
+
+@pytest.mark.asyncio
+async def test_daemon_route_emits_two_separate_approval_requests(tmp_path: Path) -> None:
+    queue, proposal_id = _queue(tmp_path)
+    coordinator = ApprovalCoordinator()
+    chunks: asyncio.Queue = asyncio.Queue()
+    gate = SessionAwareGate(_DaemonApprovalGate(coordinator))
+    orchestrator = ProposalOrchestrator(
+        queue=queue,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        approval_gate=ApprovalOrchestrator(gate),
+        policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+    )
+    orchestrator.register_generated(
+        proposal_id,
+        "plugin = object()\n",
+        validation={"ok": True, "compatibility_ok": True},
+    )
+    token = approval_route.set((chunks, "request-1"))
+    coordinator.register_route("request-1")
+    stages: list[str] = []
+    try:
+        for operation in (
+            orchestrator.approve_content(proposal_id),
+            orchestrator.authorize_mutation(proposal_id),
+        ):
+            pending = asyncio.create_task(operation)
+            chunk = await asyncio.wait_for(chunks.get(), timeout=1.0)
+            approval = chunk.metadata["approval"]
+            stages.append(approval["action"]["metadata"]["approval_stage"])
+            resolved = await coordinator.resolve(
+                approval["pending_id"], "allow_once", reason="journey approval"
+            )
+            assert resolved["ok"] is True
+            assert (await pending).approved is True
+    finally:
+        coordinator.unregister_route("request-1")
+        approval_route.reset(token)
+
+    assert stages == ["proposal_content", "plugin_mutation"]
+    item = queue.get(proposal_id)
+    assert item is not None
+    assert item.proposal_approval_id
+    assert item.mutation_approval_id
+    assert item.proposal_approval_id != item.mutation_approval_id
+
+
+def test_terminal_resolution_states_record_reasons(tmp_path: Path) -> None:
+    for target in ("SUPERSEDED", "EXPIRED", "NO_OP"):
+        queue, proposal_id = _queue(tmp_path / target.lower())
+        orchestrator = ProposalOrchestrator(
+            queue=queue,
+            artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts" / target.lower()),
+            approval_gate=None,
+            policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+        )
+        if target == "SUPERSEDED":
+            item = orchestrator.supersede(
+                proposal_id, replacement_id="prop-new", reason="new evidence"
+            )
+            assert item.metadata["replacement_proposal_id"] == "prop-new"
+        elif target == "EXPIRED":
+            item = orchestrator.expire(proposal_id, reason="review window elapsed")
+        else:
+            item = orchestrator.record_noop(proposal_id, reason="capability already available")
+        assert item.status == target
+        assert item.metadata["terminal_reason"]
+        assert queue.active(limit=0) == []
+
+
+def test_queue_rejects_lifecycle_shortcuts(tmp_path: Path) -> None:
+    queue, proposal_id = _queue(tmp_path)
+
+    with pytest.raises(ValueError, match="PENDING -> INSTALLED"):
+        queue.transition(proposal_id, "INSTALLED")
diff --git a/tests/test_scoped_registry.py b/tests/test_scoped_registry.py
index 0648d8c0..cbcdb3a0 100644
--- a/tests/test_scoped_registry.py
+++ b/tests/test_scoped_registry.py
@@ -131,6 +131,56 @@ def llm_registry() -> FakeLLMRegistry:
 class TestScopedToolRegistryFullLifecycle:
     """Full lifecycle: create fiber → register → assemble → dispose → tools gone."""
 
+    def test_draft_plugin_is_invisible_until_atomic_promotion(
+        self, fresh_tool_registry: ToolPluginRegistry
+    ) -> None:
+        from leapflow.domain.plugin_fiber import FiberState
+
+        fresh_tool_registry.assemble()
+        scoped = ScopedToolRegistry(fresh_tool_registry)
+        plugin = FakeToolPlugin(
+            _plugin_id="draft-plugin",
+            _tools=[_make_tool_metadata("draft_tool")],
+        )
+        fiber = scoped.create_draft_fiber(plugin.plugin_id)
+        scoped.stage_plugin(plugin, fiber)
+
+        assert fiber.state == FiberState.DRAFT
+        assert fresh_tool_registry.get_plugin(plugin.plugin_id) is None
+        assert "draft_tool" not in fresh_tool_registry.tool_handlers
+
+        promoted = scoped.promote_draft(plugin.plugin_id)
+
+        assert promoted.state == FiberState.ACTIVE
+        assert fresh_tool_registry.get_plugin(plugin.plugin_id) is plugin
+        assert "draft_tool" in fresh_tool_registry.snapshot_handlers()
+        assert fresh_tool_registry.snapshot_latency.count == 1
+
+    def test_atomic_promotion_rejects_collision_without_partial_publish(
+        self, fresh_tool_registry: ToolPluginRegistry
+    ) -> None:
+        incumbent = FakeToolPlugin(
+            _plugin_id="incumbent",
+            _tools=[_make_tool_metadata("shared_tool")],
+        )
+        fresh_tool_registry.register(incumbent)
+        fresh_tool_registry.assemble()
+        handlers_before = dict(fresh_tool_registry.tool_handlers)
+        scoped = ScopedToolRegistry(fresh_tool_registry)
+        candidate = FakeToolPlugin(
+            _plugin_id="candidate",
+            _tools=[_make_tool_metadata("candidate_tool"), _make_tool_metadata("shared_tool")],
+        )
+        fiber = scoped.create_draft_fiber(candidate.plugin_id)
+        scoped.stage_plugin(candidate, fiber)
+
+        with pytest.raises(ValueError, match="live conflicts"):
+            scoped.promote_draft(candidate.plugin_id)
+
+        assert fresh_tool_registry.tool_handlers == handlers_before
+        assert fresh_tool_registry.get_plugin(candidate.plugin_id) is None
+        assert scoped.get_fiber(candidate.plugin_id) is None
+
     def test_scoped_tool_registry_full_lifecycle(self, fresh_tool_registry: ToolPluginRegistry) -> None:
         plugin = FakeToolPlugin(
             _plugin_id="test-plugin",
diff --git a/tests/test_self_evolution_switch.py b/tests/test_self_evolution_switch.py
index 44ae0d13..43bcbefe 100644
--- a/tests/test_self_evolution_switch.py
+++ b/tests/test_self_evolution_switch.py
@@ -34,9 +34,9 @@ def _settings(**overrides: Any) -> SimpleNamespace:
 
 def test_self_evolution_is_off_by_default():
     """Acquiring a capability is the least reversible thing the system decides."""
-    from leapflow.config import get_settings
+    from leapflow.config import Settings
 
-    assert get_settings().evolution_enabled is False
+    assert Settings.__dataclass_fields__["evolution_enabled"].default is False
 
 
 def test_the_switch_is_discoverable_through_the_config_control_plane():
diff --git a/tests/test_self_management.py b/tests/test_self_management.py
index 470a699c..b756bd61 100644
--- a/tests/test_self_management.py
+++ b/tests/test_self_management.py
@@ -15,6 +15,9 @@
 import pytest
 from typing import Any
 
+from leapflow.storage.capability_proposal_queue import EvolutionCapabilityProposalStore
+from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+
 
 # ════════════════════════════════════════════════════════════════
 # Testing infrastructure
@@ -90,13 +93,13 @@ def self_mgmt_plugin():
     reg.assemble()
     plugin = reg.get_plugin("self_management")
     
-    # Reset gate to None so tests start from fail-closed state
-    plugin._plugin_approval_gate = None
-    
+    # Reset every mutable runtime dependency on the module-level plugin singleton.
+    _reset_install_deps(plugin)
+
     yield plugin
-    
-    # Cleanup: ensure gate and process-global registry state are reset after test
-    plugin._plugin_approval_gate = None
+
+    # Cleanup: ensure runtime deps and process-global registry state are reset after test.
+    _reset_install_deps(plugin)
     _reset_tool_registry_state()
 
 
@@ -881,9 +884,11 @@ class TestP1Features:
 
     @pytest.mark.asyncio
     async def test_plugin_propose_from_explicit_request(self, self_mgmt_plugin: Any, tmp_path: Any) -> None:
-        from leapflow.storage.plugin_proposal_store import JsonPluginProposalStore
-        store = JsonPluginProposalStore(tmp_path / "proposals.json")
-        self_mgmt_plugin.bind_runtime(plugin_proposal_store=store)
+        store = EvolutionCapabilityProposalStore(
+            DuckDBEvolutionEventStore(tmp_path / "proposals.duckdb"),
+            profile_id="profile-1",
+        )
+        self_mgmt_plugin.bind_runtime(capability_lifecycle_store=store)
 
         result = await self_mgmt_plugin._plugin_propose_handler(
             requested_capability="Validate JSON and pretty-print it",
@@ -900,12 +905,16 @@ async def test_plugin_propose_from_explicit_request(self, self_mgmt_plugin: Any,
             "json_pretty_print",
         ]
         assert result["next_actions"]
-        assert store.get(proposal["proposal_id"]) is not None
+        assert store.find_by_metadata("review_proposal_id", proposal["proposal_id"]) is not None
 
     @pytest.mark.asyncio
     async def test_plugin_propose_from_unknown_tool_evidence(self, self_mgmt_plugin: Any, tmp_path: Any) -> None:
-        from leapflow.storage.plugin_proposal_store import JsonPluginProposalStore
-        self_mgmt_plugin.bind_runtime(plugin_proposal_store=JsonPluginProposalStore(tmp_path / "proposals.json"))
+        self_mgmt_plugin.bind_runtime(
+            capability_lifecycle_store=EvolutionCapabilityProposalStore(
+                DuckDBEvolutionEventStore(tmp_path / "proposals.duckdb"),
+                profile_id="profile-1",
+            )
+        )
 
         evidence = {
             "error_type": "unknown_tool",
@@ -927,9 +936,6 @@ async def test_plugin_propose_from_unknown_tool_evidence(self, self_mgmt_plugin:
 
     @pytest.mark.asyncio
     async def test_plugin_propose_rejects_empty_request(self, self_mgmt_plugin: Any, tmp_path: Any) -> None:
-        from leapflow.storage.plugin_proposal_store import JsonPluginProposalStore
-        self_mgmt_plugin.bind_runtime(plugin_proposal_store=JsonPluginProposalStore(tmp_path / "proposals.json"))
-
         result = await self_mgmt_plugin._plugin_propose_handler(requested_capability="")
 
         assert result["ok"] is False
@@ -939,21 +945,34 @@ async def test_plugin_propose_rejects_empty_request(self, self_mgmt_plugin: Any,
     async def test_proposal_governed_generate_and_install(
         self, self_mgmt_plugin: Any, tmp_path: Any
     ) -> None:
+        from leapflow.evolution.artifact_store import ContentAddressedArtifactStore
         from leapflow.plugins import get_registry
-        from leapflow.storage.plugin_proposal_store import JsonPluginProposalStore
+        from leapflow.plugins.adaptive_policy import AdaptiveEvolutionPolicy
+        from leapflow.plugins.proposal_orchestrator import ProposalOrchestrator
 
         class _FakeLLM:
             async def achat(self, messages):  # type: ignore[no-untyped-def]
                 return _valid_plugin_src("proposal_echo", "proposal_echo_tool")
 
-        store = JsonPluginProposalStore(tmp_path / "proposals.json")
+        lifecycle = EvolutionCapabilityProposalStore(
+            DuckDBEvolutionEventStore(tmp_path / "lifecycle.duckdb"),
+            profile_id="profile-1",
+        )
+        approval_gate = FakeApprovalGate(approved=True)
+        orchestrator = ProposalOrchestrator(
+            queue=lifecycle,
+            artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+            approval_gate=approval_gate,
+            policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+        )
         self_mgmt_plugin.bind_runtime(
-            plugin_proposal_store=store,
+            capability_lifecycle_store=lifecycle,
+            proposal_orchestrator=orchestrator,
             llm_provider=_FakeLLM(),
             plugin_generation_enabled=True,
             plugin_install_dir=str(tmp_path / "plugins"),
         )
-        self_mgmt_plugin._plugin_approval_gate = FakeApprovalGate(approved=True)
+        self_mgmt_plugin._plugin_approval_gate = approval_gate
 
         proposed = await self_mgmt_plugin._plugin_propose_handler(
             requested_capability="Echo a message from a generated plugin",
@@ -972,7 +991,8 @@ async def achat(self, messages):  # type: ignore[no-untyped-def]
         generated = await self_mgmt_plugin._plugin_generate_handler(proposal_id=proposal_id)
         assert generated["ok"], generated
         assert generated["proposal_id"] == proposal_id
-        assert store.get(proposal_id).status == "review"
+        lifecycle_id = generated["lifecycle_proposal_id"]
+        assert lifecycle.get(lifecycle_id).status == "APPROVED"
 
         installed = await self_mgmt_plugin._plugin_install_handler(
             proposal_id=proposal_id,
@@ -981,7 +1001,7 @@ async def achat(self, messages):  # type: ignore[no-untyped-def]
         assert installed["ok"], installed
         assert installed["proposal_id"] == proposal_id
         assert installed["behavior_tests"][0]["result"] == {"ok": True, "echoed": "hi"}
-        assert store.get(proposal_id).status == "approved"
+        assert lifecycle.get(lifecycle_id).status == "INSTALLED"
         assert "proposal_echo_tool" in get_registry().tool_handlers
         try:
             result = await get_registry().tool_handlers["proposal_echo_tool"](message="hi")
@@ -1325,10 +1345,14 @@ def _reset_install_deps(plugin: Any) -> None:
     """Reset install-related runtime deps a fixture does not clear."""
     plugin._plugin_approval_gate = None
     plugin._plugin_install_dir = None
+    plugin._plugin_staging_dir = None
     plugin._marketplace_client = None
     plugin._trusted_pubkeys = set()
-    plugin._plugin_proposal_store = None
     plugin._plugin_version_store = None
+    plugin._capability_lifecycle_store = None
+    plugin._proposal_orchestrator = None
+    plugin._evolution_outbox = None
+    plugin._evolution_profile_id = ""
 
 
 class TestPluginInstallPath:
@@ -1369,6 +1393,77 @@ async def test_install_writes_to_injected_profile_dir_not_package(
             _cleanup_installed(plugin_id)
             _reset_install_deps(self_mgmt_plugin)
 
+    @pytest.mark.asyncio
+    async def test_install_behavior_failure_never_publishes_or_commits_source(
+        self, self_mgmt_plugin: Any, tmp_path: Any
+    ) -> None:
+        from leapflow.domain.plugin_proposal import BehaviorTestCase, PluginProposal
+        from leapflow.evolution.artifact_store import ContentAddressedArtifactStore
+        from leapflow.plugins import get_registry, get_scoped_registry
+        from leapflow.plugins.adaptive_policy import AdaptiveEvolutionPolicy
+        from leapflow.plugins.proposal_orchestrator import ProposalOrchestrator
+        from leapflow.storage.plugin_version_store import PluginVersionStore
+
+        plugin_id = "tst_shadow_failure"
+        tool_name = "tst_shadow_failure_tool"
+        install_dir = tmp_path / "plugins"
+        staging_dir = tmp_path / "staging"
+        version_store = PluginVersionStore(tmp_path / "versions")
+        proposal = PluginProposal.create(
+            plugin_id=plugin_id,
+            capability_summary="Must fail before publication",
+            proposed_tools=(),
+            test_cases=(
+                BehaviorTestCase.create(
+                    tool_name,
+                    arguments={"message": "x"},
+                    expected_subset={"echoed": "different"},
+                ),
+            ),
+        )
+        lifecycle = EvolutionCapabilityProposalStore(
+            DuckDBEvolutionEventStore(tmp_path / "lifecycle.duckdb"),
+            profile_id="profile-1",
+        )
+        approval_gate = FakeApprovalGate(approved=True)
+        orchestrator = ProposalOrchestrator(
+            queue=lifecycle,
+            artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+            approval_gate=approval_gate,
+            policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+        )
+        self_mgmt_plugin._plugin_approval_gate = approval_gate
+        self_mgmt_plugin.bind_runtime(
+            plugin_install_dir=str(install_dir),
+            plugin_staging_dir=str(staging_dir),
+            plugin_version_store=version_store,
+            capability_lifecycle_store=lifecycle,
+            proposal_orchestrator=orchestrator,
+        )
+        lifecycle_id = self_mgmt_plugin._open_lifecycle_record(
+            proposal, "Must fail before publication"
+        )
+        code = _valid_plugin_src(plugin_id, tool_name)
+        orchestrator.register_generated(lifecycle_id, code, validation={"ok": True, "compatibility_ok": True})
+        await orchestrator.approve_content(lifecycle_id)
+        try:
+            result = await self_mgmt_plugin._plugin_install_handler(
+                proposal_id=proposal.proposal_id,
+                code=code,
+            )
+
+            assert result["ok"] is False
+            assert "Behavior tests failed" in result["error"]
+            assert get_registry().get_plugin(plugin_id) is None
+            assert get_scoped_registry().get_fiber(plugin_id) is None
+            assert tool_name not in get_registry().tool_handlers
+            assert not (install_dir / f"{plugin_id}.py").exists()
+            assert list(staging_dir.iterdir()) == []
+            assert version_store.active(plugin_id) is None
+        finally:
+            _cleanup_installed(plugin_id)
+            _reset_install_deps(self_mgmt_plugin)
+
     @pytest.mark.asyncio
     async def test_plugin_remove_disposes_fiber_and_deletes_source(
         self, self_mgmt_plugin: Any, tmp_path: Any
@@ -1415,10 +1510,21 @@ async def test_plugin_versions_and_rollback(
         tool_name = "tst_versioned_tool"
         install_dir = tmp_path / "plugins"
         version_store = PluginVersionStore(tmp_path / "versions")
+
+        class _Outbox:
+            def __init__(self) -> None:
+                self.events = []
+
+            async def publish(self, event, *, critical=False):
+                self.events.append((event, critical))
+
+        outbox = _Outbox()
         self_mgmt_plugin._plugin_approval_gate = FakeApprovalGate(approved=True)
         self_mgmt_plugin.bind_runtime(
             plugin_install_dir=str(install_dir),
             plugin_version_store=version_store,
+            evolution_outbox=outbox,
+            evolution_profile_id="profile-1",
         )
 
         def source(label: str) -> str:
@@ -1453,6 +1559,8 @@ def source(label: str) -> str:
             assert rollback["ok"], rollback
             assert rollback["version"] == "v0"
             assert (await get_registry().tool_handlers[tool_name](message="x"))["version"] == "v0"
+            assert outbox.events[-1][0].event_type == "plugin.rolled_back"
+            assert outbox.events[-1][1] is True
         finally:
             _cleanup_installed(plugin_id)
             _reset_install_deps(self_mgmt_plugin)
@@ -1462,34 +1570,45 @@ async def test_plugin_reload_restores_previous_version_when_behavior_tests_fail(
         self, self_mgmt_plugin: Any, tmp_path: Any
     ) -> None:
         from leapflow.domain.plugin_proposal import BehaviorTestCase, PluginProposal
+        from leapflow.evolution.artifact_store import ContentAddressedArtifactStore
         from leapflow.plugins import get_registry
-        from leapflow.storage.plugin_proposal_store import JsonPluginProposalStore
+        from leapflow.plugins.adaptive_policy import AdaptiveEvolutionPolicy
+        from leapflow.plugins.proposal_orchestrator import ProposalOrchestrator
         from leapflow.storage.plugin_version_store import PluginVersionStore
 
         plugin_id = "tst_behavior_reload_plug"
         tool_name = "tst_behavior_reload_tool"
         install_dir = tmp_path / "plugins"
-        proposal_store = JsonPluginProposalStore(tmp_path / "proposals.json")
         version_store = PluginVersionStore(tmp_path / "versions")
-        proposal = proposal_store.save(
-            PluginProposal.create(
-                plugin_id=plugin_id,
-                capability_summary="Echo a message and preserve the expected behavior marker",
-                proposed_tools=(),
-                test_cases=(
-                    BehaviorTestCase.create(
-                        tool_name,
-                        arguments={"message": "x"},
-                        expected_subset={"ok": True, "echoed": "x", "version": "good"},
-                    ),
+        proposal = PluginProposal.create(
+            plugin_id=plugin_id,
+            capability_summary="Echo a message and preserve the expected behavior marker",
+            proposed_tools=(),
+            test_cases=(
+                BehaviorTestCase.create(
+                    tool_name,
+                    arguments={"message": "x"},
+                    expected_subset={"ok": True, "echoed": "x", "version": "good"},
                 ),
-            )
+            ),
         )
-        self_mgmt_plugin._plugin_approval_gate = FakeApprovalGate(approved=True)
+        lifecycle = EvolutionCapabilityProposalStore(
+            DuckDBEvolutionEventStore(tmp_path / "lifecycle.duckdb"),
+            profile_id="profile-1",
+        )
+        approval_gate = FakeApprovalGate(approved=True)
+        orchestrator = ProposalOrchestrator(
+            queue=lifecycle,
+            artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+            approval_gate=approval_gate,
+            policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+        )
+        self_mgmt_plugin._plugin_approval_gate = approval_gate
         self_mgmt_plugin.bind_runtime(
             plugin_install_dir=str(install_dir),
-            plugin_proposal_store=proposal_store,
             plugin_version_store=version_store,
+            capability_lifecycle_store=lifecycle,
+            proposal_orchestrator=orchestrator,
         )
 
         def source(label: str) -> str:
@@ -1498,10 +1617,17 @@ def source(label: str) -> str:
                 f"return {{'ok': True, 'echoed': message, 'version': {label!r}}}",
             )
 
+        lifecycle_id = self_mgmt_plugin._open_lifecycle_record(
+            proposal, "Echo a message and preserve the expected behavior marker"
+        )
+        good_source = source("good")
+        orchestrator.register_generated(lifecycle_id, good_source, validation={"ok": True, "compatibility_ok": True})
+        await orchestrator.approve_content(lifecycle_id)
+
         try:
             install = await self_mgmt_plugin._plugin_install_handler(
                 proposal_id=proposal.proposal_id,
-                code=source("good"),
+                code=good_source,
                 version_label="good",
             )
             assert install["ok"], install
diff --git a/tests/test_signal_source.py b/tests/test_signal_source.py
index f620cd36..fd5a5dca 100644
--- a/tests/test_signal_source.py
+++ b/tests/test_signal_source.py
@@ -7,7 +7,6 @@
 
 from __future__ import annotations
 
-import pytest
 
 from leapflow.perception.signal_source import (
     SignalSourceRegistry,
@@ -437,7 +436,6 @@ def test_custom_registry_injection(self) -> None:
         from unittest.mock import MagicMock
         from leapflow.perception.config import PerceptionConfig
         from leapflow.perception.session import PerceptionSession
-        from leapflow.perception.signal_source import SignalSourceRegistry
 
         config = PerceptionConfig(
             signal_channels=frozenset({"custom"}),
diff --git a/tests/test_telegram_signal_source.py b/tests/test_telegram_signal_source.py
index 5ab35d6c..413fe743 100644
--- a/tests/test_telegram_signal_source.py
+++ b/tests/test_telegram_signal_source.py
@@ -15,7 +15,7 @@
 
 import pytest
 
-from leapflow.perception.active_signal_source import ActiveSignalSource, EmitCallback
+from leapflow.perception.active_signal_source import ActiveSignalSource
 from leapflow.perception.active_sources.telegram_bot import TelegramBotSignalSource
 from leapflow.perception.types import InteractionSignal
 
diff --git a/tests/test_tool_concurrency.py b/tests/test_tool_concurrency.py
index 776a846b..e320bb62 100644
--- a/tests/test_tool_concurrency.py
+++ b/tests/test_tool_concurrency.py
@@ -54,7 +54,14 @@ def test_mutating_once_session_scoped_tool_runs_sequentially() -> None:
 
 
 def test_path_scoped_writes_parallel_iff_non_overlapping() -> None:
-    specs = {"file_write": ToolSpec(name="file_write", risk_level="mutating", mutates_state=True)}
+    specs = {
+        "file_write": ToolSpec(
+            name="file_write",
+            risk_level="mutating",
+            mutates_state=True,
+            execution_policy="mutating_idempotent",
+        )
+    }
     policy = _policy(specs)
 
     concurrent, sequential = policy.partition(
@@ -71,7 +78,12 @@ def test_path_scoped_writes_parallel_iff_non_overlapping() -> None:
 
 def test_mutating_idempotent_without_path_is_sequential() -> None:
     specs = {
-        "file_write": ToolSpec(name="file_write", risk_level="mutating", mutates_state=True),
+        "file_write": ToolSpec(
+            name="file_write",
+            risk_level="mutating",
+            mutates_state=True,
+            execution_policy="mutating_idempotent",
+        ),
         "file_read": ToolSpec(name="file_read", risk_level="read_only"),
     }
     concurrent, sequential = _policy(specs).partition([_tc("file_read", path="a"), _tc("file_write")])
diff --git a/tests/test_world_model_driver.py b/tests/test_world_model_driver.py
deleted file mode 100644
index 7ff353f7..00000000
--- a/tests/test_world_model_driver.py
+++ /dev/null
@@ -1,335 +0,0 @@
-# Copyright (c) Alibaba, Inc. and its affiliates.
-"""WM-B: the world model is now the first driver of capability evolution.
-
-`grade_and_propose` could form a capability hypothesis and the observation pipeline
-could consume one, but nothing joined them -- so the world model's conclusions
-reached no part of the system. `WorldModelEvolutionDriver` is that join.
-
-The tests that matter most here are the negative ones: the driver must not be able
-to bypass the opt-in evidence gate, must not widen a risk ceiling, and must never
-fail the session that produced the trajectory.
-"""
-
-from __future__ import annotations
-
-import asyncio
-from types import SimpleNamespace
-
-from leapflow.domain.evolution_intent import WORLD_MODEL_INTENT, EvolutionIntent
-from leapflow.learning.capability_observation import (
-    CapabilityEvidenceClassifier,
-    CapabilityObservationService,
-)
-from leapflow.learning.world_model_driver import (
-    CapabilityGapTeacher,
-    EvidenceIntake,
-    WorldModelDriveResult,
-    WorldModelEvolutionDriver,
-)
-from leapflow.storage.capability_observation_store import JsonCapabilityObservationStore
-from leapflow.world_model.trajectory_grader import TeacherVerdict
-
-_TRAJECTORY = [
-    {"experience_id": "e1", "action_description": "click send_button",
-     "predicted_effect": "sent", "actual_effect": "silently no-op", "delta": "1.0"},
-    {"experience_id": "e2", "action_description": "retry",
-     "predicted_effect": "sent", "actual_effect": "silently no-op", "delta": "1.0"},
-]
-
-
-
-def _acquire_verdict(intent):
-    """Express an intent as the acquire verdict that would have produced it."""
-    from leapflow.domain.adaptation_verdict import AdaptationVerdict
-
-    return AdaptationVerdict.create(
-        "acquire",
-        intent.capability,
-        intent.hypothesis or f"nothing installed provides {intent.capability}",
-        rationale=intent.rationale or intent.hypothesis,
-        confidence=intent.confidence,
-        target_affordance=intent.target_affordance,
-        expected_effect=intent.expected_effect,
-        max_risk_level=intent.max_risk_level,
-    )
-
-
-class _Teacher:
-    """Stand-in for TrajectoryGrader with a fixed hindsight verdict."""
-
-    def __init__(self, intents=(), grades=("g1", "g2"), raises=False) -> None:
-        # Intents are now *derived* from acquire verdicts rather than carried beside
-        # them, so a teacher stub expressing "I want this capability" says it the way
-        # the real teacher does: an acquire verdict, which the verdict object turns
-        # into the intent. Constructing intents directly would test a path production
-        # no longer has.
-        self._verdict = TeacherVerdict(
-            tuple(grades),
-            tuple(_acquire_verdict(intent) for intent in intents),
-        )
-        self._raises = raises
-        self.calls = 0
-
-    async def grade_and_propose(self, trajectory, goal=""):
-        self.calls += 1
-        if self._raises:
-            raise RuntimeError("teacher exploded")
-        return self._verdict
-
-
-def _intent(**kw):
-    base = dict(
-        confidence=0.8, target_affordance="app.chat.v2",
-        expected_effect="message appears in the thread",
-    )
-    base.update(kw)
-    return EvolutionIntent.create("chat.reply", "the send path silently no-ops", **base)
-
-
-def _service(tmp_path, *, opted_in: bool):
-    store = JsonCapabilityObservationStore(tmp_path / "observations.json")
-    kinds = [WORLD_MODEL_INTENT] if opted_in else None
-    classifier = CapabilityEvidenceClassifier.from_kinds(kinds) if kinds else None
-    return store, CapabilityObservationService(store, classifier=classifier)
-
-
-def _drive(teacher, service, trajectory=_TRAJECTORY, **kw):
-    driver = WorldModelEvolutionDriver(teacher=teacher, intake=service, **kw)
-    return asyncio.run(driver.drive(trajectory, "reply in chat"))
-
-
-# ── the join works ────────────────────────────────────────────────────────────
-
-
-def test_protocols_are_satisfied_by_the_real_components(tmp_path):
-    _, service = _service(tmp_path, opted_in=True)
-    assert isinstance(service, EvidenceIntake)
-    assert isinstance(_Teacher(), CapabilityGapTeacher)
-
-
-def test_teacher_hypothesis_becomes_a_governed_requirement(tmp_path):
-    """The whole point: hindsight -> intent -> admitted evidence -> requirement."""
-    store, service = _service(tmp_path, opted_in=True)
-    result = _drive(_Teacher(intents=[_intent()]), service)
-
-    assert isinstance(result, WorldModelDriveResult)
-    assert result.proposed == 1
-    assert result.admitted == 1
-    assert len(store.unresolved()) == 1
-
-    requirement = result.requirements[0]
-    assert requirement.origin == "world_model"       # the world model drove this
-    assert requirement.capability == "chat.reply"
-    assert requirement.max_risk_level == "read_only"
-    assert dict(requirement.metadata)["target_affordance"] == "app.chat.v2"
-
-
-def test_grades_are_returned_so_no_second_llm_call_is_needed(tmp_path):
-    _, service = _service(tmp_path, opted_in=True)
-    teacher = _Teacher(intents=[_intent()])
-    result = _drive(teacher, service)
-    assert len(result.grades) == 2
-    assert teacher.calls == 1          # one hindsight call for grading AND proposing
-
-
-def test_multiple_gaps_all_reach_the_pipeline(tmp_path):
-    _, service = _service(tmp_path, opted_in=True)
-    other = EvolutionIntent.create("chat.attach", "no attachment capability exists")
-    result = _drive(_Teacher(intents=[_intent(), other]), service)
-    assert result.proposed == 2 and result.admitted == 2
-    assert {r.capability for r in result.requirements} == {"chat.reply", "chat.attach"}
-
-
-# ── the driver must not be able to bypass the gate ────────────────────────────
-
-
-def test_driver_cannot_bypass_the_opt_in_gate(tmp_path):
-    """Default configuration: proposals are formed but change nothing."""
-    store, service = _service(tmp_path, opted_in=False)
-    result = _drive(_Teacher(intents=[_intent()]), service)
-
-    assert result.proposed == 1        # the world model did form a hypothesis
-    assert result.admitted == 0        # ...and the gate refused it
-    assert result.requirements == ()
-    assert store.unresolved() == []    # nothing durable was written
-
-
-def test_driver_cannot_widen_the_risk_ceiling(tmp_path):
-    _, service = _service(tmp_path, opted_in=True)
-    greedy = _intent(max_risk_level="external")
-    result = _drive(_Teacher(intents=[greedy]), service)
-    requirement = result.requirements[0]
-    assert requirement.max_risk_level == "read_only"
-    assert dict(requirement.metadata)["requested_max_risk_level"] == "external"
-
-
-def test_caller_may_tighten_the_ceiling_further(tmp_path):
-    _, service = _service(tmp_path, opted_in=True)
-    result = _drive(
-        _Teacher(intents=[_intent(max_risk_level="medium")]), service,
-        risk_ceiling="read_only",
-    )
-    assert result.requirements[0].max_risk_level == "read_only"
-
-
-# ── learning must never break the session ─────────────────────────────────────
-
-
-def test_teacher_failure_is_contained(tmp_path):
-    _, service = _service(tmp_path, opted_in=True)
-    result = _drive(_Teacher(raises=True), service)
-    assert result == WorldModelDriveResult()      # empty, not an exception
-
-
-def test_intake_failure_is_contained(tmp_path):
-    class _BrokenIntake:
-        def observe_result(self, result, **kwargs):
-            raise OSError("disk on fire")
-
-        def requirements(self, *, min_count=1, limit=50):
-            return ()
-
-    driver = WorldModelEvolutionDriver(teacher=_Teacher(intents=[_intent()]), intake=_BrokenIntake())
-    result = asyncio.run(driver.drive(_TRAJECTORY, "goal"))
-    assert result.proposed == 1 and result.admitted == 0
-
-
-def test_empty_trajectory_spends_nothing(tmp_path):
-    _, service = _service(tmp_path, opted_in=True)
-    teacher = _Teacher(intents=[_intent()])
-    result = _drive(teacher, service, trajectory=[])
-    assert result == WorldModelDriveResult()
-    assert teacher.calls == 0          # no LLM spend without an episode
-
-
-def test_no_gaps_still_returns_grades(tmp_path):
-    _, service = _service(tmp_path, opted_in=True)
-    result = _drive(_Teacher(intents=[]), service)
-    assert len(result.grades) == 2
-    assert result.proposed == 0 and result.requirements == ()
-
-
-def test_drive_result_is_reportable(tmp_path):
-    _, service = _service(tmp_path, opted_in=True)
-    payload = _drive(_Teacher(intents=[_intent()]), service).to_dict()
-    assert payload["proposed"] == 1
-    assert payload["admitted"] == 1
-    assert payload["capabilities"] == ["chat.reply"]
-
-
-# ── authority gate (P5 in the driver) ──────────────────────────────────
-
-
-def test_admitted_hypothesis_is_queued_with_evidence_linkage(tmp_path):
-    """An admitted, authorised hypothesis is queued, carrying its observation ids.
-
-    The linkage is what lets the causal ledger join a queued acquisition back to the
-    evidence that produced it; a proposal minted with no observation ids is an orphan.
-    """
-    _, service = _service(tmp_path, opted_in=True)
-    captured: dict = {}
-
-    def sink(proposal, *, observation_ids=(), environment=None):
-        captured["observation_ids"] = tuple(observation_ids)
-        captured["environment"] = environment
-        return "prop-unmet"
-
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher(intents=[_intent()]),
-        intake=service,
-        proposal_sink=sink,
-    )
-    result = asyncio.run(driver.drive(_TRAJECTORY, "reply in chat"))
-
-    assert result.unauthorised == ()
-    assert result.queued_proposal_ids == ("prop-unmet",)
-    assert len(captured["observation_ids"]) == 1
-    assert captured["observation_ids"][0].startswith("obs-")
-
-
-def test_unauthorised_origin_is_a_durable_no_op(tmp_path):
-    """With authority restricted away from world_model, the hypothesis cannot acquire."""
-    store, service = _service(tmp_path, opted_in=True)
-    queued: list = []
-
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher(intents=[_intent()]),
-        intake=service,
-        proposal_sink=lambda p, **k: queued.append(p) or "prop-x",
-        # A drive-the-wiring assertion of P5: the world model's own origin is refused
-        # authority, so even an admitted hypothesis is retired rather than queued.
-        authorising_origins=("some_other_origin",),
-    )
-    result = asyncio.run(driver.drive(_TRAJECTORY, "reply in chat"))
-
-    assert result.unauthorised == ("chat.reply",)
-    assert result.queued_proposal_ids == ()
-    assert queued == []
-    # Durable no-op: the observation is retired with a recorded reason.
-    assert store.unresolved() == []
-
-
-def test_world_model_origin_is_authorised_when_named(tmp_path):
-    """Naming world_model in authorising_origins lets its hypothesis through."""
-    _, service = _service(tmp_path, opted_in=True)
-    queued: list = []
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher(intents=[_intent()]),
-        intake=service,
-        proposal_sink=lambda p, **k: queued.append(p) or "prop-x",
-        authorising_origins=("world_model",),
-    )
-    result = asyncio.run(driver.drive(_TRAJECTORY, "reply in chat"))
-    assert result.unauthorised == ()
-    assert result.queued_proposal_ids == ("prop-x",)
-
-
-# ── the real grader satisfies the teacher contract ────────────────────────────
-
-
-def test_real_trajectory_grader_can_drive_evolution(tmp_path):
-    """End to end with the REAL TrajectoryGrader, only the LLM substituted."""
-    import json
-
-    from leapflow.world_model.budget import LearningBudgetController
-    from leapflow.world_model.trajectory_grader import TrajectoryGrader
-
-    payload = json.dumps({
-        "grades": [
-            {"step": 1, "advantage": -0.9, "is_forking": True, "grade_label": "harmful"},
-            {"step": 2, "advantage": -0.9, "is_forking": False, "grade_label": "harmful"},
-            {"step": 3, "advantage": -0.5, "is_forking": False, "grade_label": "suboptimal"},
-        ],
-        "adaptation_verdicts": [{
-            "action": "acquire",
-            "capability": "chat.reply",
-            "knowledge": "the send control exists but no longer delivers the message",
-            "confidence": 0.77,
-            "target_affordance": "app.chat.v2",
-            "expected_effect": "the message appears in the thread",
-        }],
-    })
-
-    class _FakeLLM:
-        async def achat(self, messages, **kwargs):
-            return SimpleNamespace(content=payload)
-
-    class _Store:
-        def __getattr__(self, name):
-            return lambda *a, **k: None
-
-    grader = TrajectoryGrader(_FakeLLM(), _Store(), LearningBudgetController(grading_budget=2))
-    assert isinstance(grader, CapabilityGapTeacher)
-
-    _, service = _service(tmp_path, opted_in=True)
-    trajectory = _TRAJECTORY + [
-        {"experience_id": "e3", "action_description": "verify thread",
-         "predicted_effect": "message present", "actual_effect": "absent", "delta": "1.0"},
-    ]
-    driver = WorldModelEvolutionDriver(teacher=grader, intake=service)
-    result = asyncio.run(driver.drive(trajectory, "reply in chat"))
-
-    assert result.proposed == 1
-    assert result.admitted == 1
-    assert result.requirements[0].origin == "world_model"
-    assert result.requirements[0].capability == "chat.reply"
diff --git a/tests/test_world_model_proposal_sink_contract.py b/tests/test_world_model_proposal_sink_contract.py
deleted file mode 100644
index 2177068d..00000000
--- a/tests/test_world_model_proposal_sink_contract.py
+++ /dev/null
@@ -1,133 +0,0 @@
-# Copyright (c) Alibaba, Inc. and its affiliates.
-"""A caller-supplied proposal sink keeps its own signature.
-
-Measured regression: the driver began passing ``observation_ids`` and ``environment``
-to ``proposal_sink`` so the causal ledger could join a proposal to the observations
-that caused it. The sink is supplied by the caller and its contract was
-``sink(proposal)``, so every sink that had not adopted the new keywords raised
-``TypeError`` -- inside a per-intent ``except Exception`` that logged at debug level
-and continued. The visible effect was that **no acquisition was ever queued**, with a
-green targeted test suite and no warning in the log.
-
-Two contracts are pinned here, because either alone would have let it through:
-
-* optional context is offered only to sinks that declare it (or take ``**kwargs``),
-  so extending the causal payload can never break an existing sink;
-* a wiring fault is logged as a warning rather than absorbed, so if this ever breaks
-  again it says so instead of going quiet.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Any
-
-from leapflow.domain.adaptation_verdict import ACQUIRE, AdaptationVerdict
-from leapflow.learning.world_model_driver import WorldModelEvolutionDriver
-from leapflow.world_model.trajectory_grader import TeacherVerdict
-
-
-class _Teacher:
-    def __init__(self, verdict: TeacherVerdict) -> None:
-        self._verdict = verdict
-
-    async def grade_and_propose(self, *args: Any, **kwargs: Any) -> TeacherVerdict:
-        return self._verdict
-
-
-class _Intake:
-    """Minimal stand-in that derives a need for what it just observed."""
-
-    def __init__(self) -> None:
-        self.observed: list[str] = []
-
-    def observe_result(self, result, **kwargs):
-        capability = str((result or {}).get("capability") or "")
-        if capability:
-            self.observed.append(capability)
-        return {"observation_id": f"o{len(self.observed)}"}
-
-    def requirements(self, *, min_count: int = 1, limit: int = 50):
-        from leapflow.domain.capability_requirement import CapabilityRequirement
-
-        return tuple(
-            CapabilityRequirement.create(
-                capability, "world_model", max_risk_level="read_only",
-                requirement_id=f"req-{capability}",
-            )
-            for capability in dict.fromkeys(self.observed)
-        )
-
-
-def _drive(sink) -> Any:
-    driver = WorldModelEvolutionDriver(
-        teacher=_Teacher(
-            TeacherVerdict(
-                grades=(),
-                verdicts=(
-                    AdaptationVerdict.create(ACQUIRE, "mail.send", "the app is now v3"),
-                ),
-            )
-        ),
-        intake=_Intake(),
-        proposal_sink=sink,
-    )
-    return asyncio.run(driver.drive([{"action": "a"}], "reply in the thread"))
-
-
-def test_legacy_single_argument_sink_still_receives_proposals():
-    """The original contract: ``sink(proposal)`` and nothing else."""
-    seen: list[Any] = []
-
-    def sink(proposal):
-        seen.append(proposal)
-        return proposal.proposal_id
-
-    result = _drive(sink)
-    assert len(seen) == 1, "a one-argument sink must still be called"
-    assert result.to_dict()["queued"] == 1
-
-
-def test_sink_declaring_the_extras_receives_them():
-    """A sink that opts in gets the causal context, so the ledger can join it."""
-    captured: dict[str, Any] = {}
-
-    def sink(proposal, *, observation_ids=(), environment=None):
-        captured["observation_ids"] = tuple(observation_ids)
-        captured["environment"] = environment
-        return proposal.proposal_id
-
-    result = _drive(sink)
-    assert result.to_dict()["queued"] == 1
-    assert captured["observation_ids"], "observation ids must reach an opted-in sink"
-
-
-def test_var_keyword_sink_receives_the_extras():
-    """``**kwargs`` counts as opting in; nothing needs to be listed explicitly."""
-    captured: dict[str, Any] = {}
-
-    def sink(proposal, **kwargs):
-        captured.update(kwargs)
-        return proposal.proposal_id
-
-    assert _drive(sink).to_dict()["queued"] == 1
-    assert "observation_ids" in captured
-
-
-def test_a_sink_that_raises_a_wiring_fault_is_reported_not_swallowed(caplog):
-    """A TypeError from inside the sink must be visible, not debug-only.
-
-    The loop still continues -- one bad intent may not stop the rest -- but silence is
-    what turned the original defect into an invisible outage.
-    """
-    def sink(proposal, *, observation_ids=(), environment=None):
-        raise TypeError("sink is misconfigured")
-
-    with caplog.at_level(logging.WARNING, logger="leapflow.learning.world_model_driver"):
-        result = _drive(sink)
-
-    assert result.to_dict()["queued"] == 0
-    assert any(
-        "acquisition not queued" in record.message for record in caplog.records
-    ), "a wiring fault must be logged at warning level"

From 6dcd920364c2182d0d7af169e6782ff595d84af1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8F=AD=E6=89=AC?= <xingjun.wxj@alibaba-inc.com>
Date: Sat, 19 Sep 2026 15:06:39 +0800
Subject: [PATCH 04/10] update ignore

---
 .gitignore | 22 ++--------------------
 1 file changed, 2 insertions(+), 20 deletions(-)

diff --git a/.gitignore b/.gitignore
index b762e5b9..2b41683c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -234,25 +234,7 @@ Package.resolved
 # OSHost socket path (runtime)
 leapflow.sock
 
-temp
-# The AAAI demo tooling is a reproducible artifact, not disposable scratch data.
-# Re-ignore every other temporary artifact after reopening each parent directory.
-!temp/
-temp/*
-!temp/papers/
-temp/papers/*
-!temp/papers/aaai27_demo/
-temp/papers/aaai27_demo/*
-!temp/papers/aaai27_demo/aaai_demo/
-!temp/papers/aaai27_demo/aaai_demo/*.py
-!temp/papers/aaai27_demo/demo_fixtures/
-!temp/papers/aaai27_demo/demo_fixtures/task-001-structural-drifts.json
-!temp/papers/aaai27_demo/demo_fixtures/headless-chat-probe-drifts.json
-!temp/papers/aaai27_demo/plan/
-temp/papers/aaai27_demo/plan/*
-!temp/papers/aaai27_demo/plan/AAAI-27_Demo_论文写作计划.md
-!temp/papers/aaai27_demo/reproduction.md
-!temp/papers/aaai27_demo/tests/
-!temp/papers/aaai27_demo/tests/test_demo_artifacts.py
+# Entire temp directory is ignored (scratch / transient artifacts only).
+temp/
 .DS_Store
 AGENTS.md

From 2c46bd2b3daf30cf1e3c4776ebaf647958cd3dd0 Mon Sep 17 00:00:00 2001
From: Cheney Zhang <chen.zhang@zilliz.com>
Date: Sat, 19 Sep 2026 16:35:39 +0800
Subject: [PATCH 05/10] feat: close evolution pipeline gaps, LeapBoard polish,
 and README evolution section
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Evolution pipeline gap closure (5 phases):
- Proposal expiration/supersession sweep with TTL and CoevolutionSweep stage
- Quarantine recovery path (QUARANTINED->PROBATION, trust unfreeze, plugin_unquarantine tool)
- DSH bundle rollback via directory-level tar.gz snapshots with SHA-256 verification
- Trust change time series in DuckDB (cold-path writes on level transition)
- E2E evolution lifecycle integration test covering full 7-phase pipeline

LeapBoard:
- Rename trust level to maturity across all locales
- Fix bar-chart label overlap (max-content label column, nowrap)

Documentation:
- Add World-Model-Driven Self-Evolution section to README
- Add docs/world_model_plugin_harness_evolution.md reference

Signed-off-by: 班扬 <xingjun.wxj@alibaba-inc.com>
---
 README.md                                     |  46 ++
 docs/world_model_plugin_harness_evolution.md  | 324 ++++++++++
 src/leapflow/config.py                        |   5 +
 src/leapflow/dashboard/static/app.js          |  10 +-
 src/leapflow/dashboard/static/styles.css      |   3 +-
 .../dashboard/templates/capability.yaml       |   2 +-
 .../dashboard/templates/evolution.yaml        |  10 +-
 src/leapflow/domain/event_types.py            |   1 +
 src/leapflow/engine/session_factory.py        |  34 +-
 src/leapflow/evolution/sweep.py               | 107 +++-
 src/leapflow/learning/plugin_stats_store.py   |  49 ++
 src/leapflow/learning/plugin_trust.py         |  99 ++-
 src/leapflow/plugins/proposal_orchestrator.py |  23 +-
 .../plugins/tool_plugins/self_management.py   | 214 ++++++-
 .../storage/capability_proposal_queue.py      |  30 +-
 src/leapflow/storage/plugin_version_store.py  | 141 +++++
 src/leapflow/storage/schema.py                |  30 +-
 tests/test_coevolution_sweep_wiring.py        | 162 ++++-
 tests/test_dsh_bundle_rollback.py             | 156 +++++
 tests/test_evolution_event_store.py           |  52 ++
 tests/test_evolution_lifecycle_e2e.py         | 578 ++++++++++++++++++
 tests/test_plugin_stats_persistence.py        |  58 +-
 tests/test_proposal_orchestrator.py           |  49 ++
 tests/test_quarantine_recovery.py             |  65 ++
 24 files changed, 2199 insertions(+), 49 deletions(-)
 create mode 100644 docs/world_model_plugin_harness_evolution.md
 create mode 100644 tests/test_dsh_bundle_rollback.py
 create mode 100644 tests/test_evolution_lifecycle_e2e.py
 create mode 100644 tests/test_quarantine_recovery.py

diff --git a/README.md b/README.md
index be0e778c..53bac637 100644
--- a/README.md
+++ b/README.md
@@ -904,6 +904,52 @@ Full authoring walkthrough: see the [Plugin Developer Guide](temp/deepseek_harne
 
 ---
 
+## World-Model-Driven Self-Evolution
+
+LeapFlow's Harness can **autonomously evolve its plugin composition** in response to dynamic environment changes. A world-model trajectory grader retrospectively evaluates execution evidence and produces a four-value **adaptation verdict** — `absorb` (update knowledge), `rebind` (select a better installed capability), `acquire` (generate a new plugin), or `escalate` (defer to a human) — so most adaptation happens without writing any code at all.
+
+When a genuine capability gap is detected, the evolution pipeline governs the entire journey from observation to production:
+
+```
+environment observation
+    → adaptation verdict (absorb / rebind / acquire / escalate)
+    → capability gap detection
+    → resolution-first check (existing catalog)
+    → proposal
+    → LLM code generation
+    → multi-stage validation (syntax → import → Protocol conformance → sandbox smoke)
+    → dual approval (content + plugin mutation)
+    → install at DRAFT trust
+    → progressive trust accrual (DRAFT → CANDIDATE → VERIFIED → PRODUCTION)
+    → governance (quarantine, rollback, proposal sweep)
+```
+
+### Enabling Self-Evolution
+
+Self-evolution is **disabled by default** as a safety constraint — the agent must be explicitly granted the ability to acquire new capabilities:
+
+```bash
+leap config set evolution.enabled true
+```
+
+When disabled, the world model still produces adaptation verdicts and distils knowledge (absorb/rebind paths remain active), but the `acquire` path that generates and installs new plugins is gated off.
+
+### Key Features
+
+- **Resolution-first** — before proposing a new plugin, the pipeline checks whether an existing capability already satisfies the requirement; duplicates are never created
+- **Dual approval gate** — generated content is reviewed for correctness, and the plugin mutation itself requires a separate HIGH-risk approval (no permanent grants)
+- **Progressive trust lifecycle** — new plugins start at DRAFT and promote through CANDIDATE → VERIFIED → PRODUCTION on consecutive successes; repeated failures trigger automatic demotion
+- **Sandbox isolation** — untrusted plugins run in a subprocess over JSON-RPC with bounded invocation timeouts
+- **Append-only causal audit trail** — 22 event types record the full causal chain from environment observation through install, validation, approval, trust transitions, and terminal outcomes
+- **Cold-path governance** — all evolution machinery (trust ledgers, proposal queues, sweep) runs on boot/reload/dispose paths with zero per-turn overhead
+- **Quarantine with recovery** — a plugin that fails hard is frozen at DRAFT with a quarantine record; it can be investigated and restored or removed
+- **DSH bundle rollback** — profile plugins maintain versioned source snapshots; `plugin_rollback` restores a previous version and hot-reloads it
+- **Proposal TTL and automated sweep** — stale proposals expire after a configurable TTL and are cleaned up by a periodic sweep
+
+For the formal specification — including system roles, architectural thesis, validation stages, and governance contracts — see [World-Model Plugin & Harness Evolution](docs/world_model_plugin_harness_evolution.md).
+
+---
+
 ## LeapBoard — Monitoring Dashboard
 
 > **Signals into insight.**
diff --git a/docs/world_model_plugin_harness_evolution.md b/docs/world_model_plugin_harness_evolution.md
new file mode 100644
index 00000000..dc71404f
--- /dev/null
+++ b/docs/world_model_plugin_harness_evolution.md
@@ -0,0 +1,324 @@
+# World-Model-Driven Harness Self-Evolution Through a Plugin System
+
+> **Status:** Architecture and implementation reference. This document describes the current LeapFlow design and its intended operational boundaries; it is not a claim that every experimental integration is production-complete.
+
+## Abstract
+
+LeapFlow treats environmental change as evidence about a capability gap, rather than as authorization to rewrite the agent runtime. Its self-evolution architecture therefore separates three concerns: (i) a world model that retrospectively interprets execution evidence and distils environmental knowledge, (ii) a plugin system that makes capabilities discoverable, governable, and reversible, and (iii) a stable Harness that supplies the cross-cutting contracts under which capabilities may operate. LeapSpace supplies controlled application environments and observable signals; LeapBoard renders the resulting causal process for human inspection.
+
+The central claim is deliberately narrow. Most adaptation should occur without writing code: the agent can absorb a change through updated knowledge, rebind a requirement to an installed capability, or escalate a decision to a human. Code generation is reserved for an unmet, task-relevant capability requirement and is introduced as a governed plugin rather than as an arbitrary modification of Harness source code. This division preserves extensibility while retaining lifecycle control, risk gating, auditability, and rollback.
+
+## 1. Motivation and Scope
+
+An agent operating in an open and changing environment faces a recurrent problem: an observed failure may indicate an execution error, an obsolete environmental assumption, a missing integration, a policy boundary, or an unavailable credential. Treating every failure as a request to modify framework code is unsafe and analytically unsound. Conversely, treating all change as a prompt-only problem leaves the agent unable to acquire genuinely absent operational capabilities.
+
+LeapFlow addresses this problem by making adaptation an evidence-driven, layered process. The system is concerned with **capability evolution**, not unrestricted self-modification. A model-generated recommendation is a hypothesis; it must be checked against typed evidence, the active capability catalog, governance policy, approval requirements, sandbox constraints, and observed outcomes before it can change the deployed capability set.
+
+This document focuses on the relation among four elements:
+
+1. **World model:** retrospective assessment and knowledge distillation.
+2. **Plugin system:** managed acquisition, selection, execution, and retirement of capabilities.
+3. **Harness:** stable runtime contracts for safety, isolation, lifecycle, and observability.
+4. **LeapSpace and LeapBoard:** respectively, the experimental/environmental surface and the human-observable presentation surface.
+
+The term *Harness self-evolution* is used in this restricted sense: the Harness can improve its effective composition and learned operating policy through governed capability evolution. It does **not** mean that an LLM receives unrestricted authority to edit the core runtime online.
+
+## 2. Architectural Thesis
+
+The architecture follows the principle that a capability should be composed rather than built into the core runtime. Tools, platform adapters, signal sources, and other extensions are specified through runtime-checkable protocols and managed by common discovery and lifecycle machinery. The Harness owns the rules of composition; plugins own concrete capability implementations.
+
+```text
+       Environment and execution evidence
+                       │
+                       ▼
+             Observe / filter / persist
+                       │
+                       ├───────────────┐
+                       ▼               │
+              World-model teacher      │
+       grade trajectory + infer verdict│
+                       │               │
+                       ▼               │
+       distilled knowledge / preference│
+                       │               │
+                       ▼               │
+             student execution loop ◄──┘
+                       │
+          unmet requirement only
+                       ▼
+     proposal → validation → approval → sandbox
+                       │
+                       ▼
+             governed plugin lifecycle
+                       │
+                       ▼
+          outcome, trust, quarantine, rollback
+                       │
+              ┌────────┴────────┐
+              ▼                 ▼
+       LeapSpace signals   LeapBoard presentation
+```
+
+This organization makes two distinctions explicit.
+
+First, **learning is not mutation**. A world model may improve future selection by recording what the environment now affords, or by preferring one already installed capability over another. Neither operation changes the capability set.
+
+Second, **capability acquisition is not core rewriting**. A missing integration is normally supplied as a plugin that conforms to the Harness contracts. If a capability cannot be expressed through an existing protocol, the architectural response is to design a general protocol extension, not to inject a vendor-specific special case into the core.
+
+## 3. System Roles
+
+### 3.1 The Harness: Stable Constraints, Not a Mutable Script
+
+The Harness provides the common runtime substrate: protocol boundaries, session isolation, tool dispatch, context governance, side-effect gating, recovery semantics, approval integration, persistent evidence, and plugin lifecycle control. These responsibilities are cross-cutting: an inconsistent implementation in one integration can otherwise affect unrelated tools, sessions, or clients.
+
+A stable Harness creates a common operational language. A capability can declare its metadata, dependencies, risk, expected environment affordances, and lifecycle effects in a form that the runtime can reason about uniformly. This supports general mechanisms such as dependency injection, explicit cleanup, per-turn handler snapshots during reload, capability conflict recording, and policy-controlled mutation.
+
+Thus, the primary benefit of Harness-level evolution is not frequent code generation inside the core. It is the incremental strengthening of reusable **contracts** when repeated evidence reveals a true abstraction gap—for example, a missing general recovery semantic or a capability descriptor that no current plugin can express. Such changes are release-level architectural work and should remain subject to normal engineering review and regression verification.
+
+### 3.2 Tools and Skills: Behavior and Reusable Procedures
+
+A tool is a concrete operation exposed to the agent. A skill is a reusable, parameterized procedure that organizes one or more operations around triggers, conditions, and execution knowledge. They are the appropriate adaptation surface when the agent already has the required operational primitives.
+
+Typical examples include:
+
+- changing tool arguments or semantic locators after a benign interface change;
+- combining existing tools into a revised workflow;
+- applying a learned fallback, validation step, or task decomposition;
+- preferring a currently installed capability that is better suited to an observed environment.
+
+Tools and skills alone are insufficient when the environment requires a new long-lived event source, an uninstalled platform adapter, new dependency binding, process isolation, versioning, managed cleanup, or a new externally visible side-effect boundary. These are lifecycle and governance problems, not merely procedural ones.
+
+### 3.3 Plugins: Governed Capability Units
+
+Plugins package concrete capabilities behind the Harness extension contract. The plugin layer supplies the mechanism needed to make a generated or newly acquired capability safe to operate over time:
+
+- capability declaration and deterministic resolution;
+- dependency binding and graceful refusal when dependencies are unavailable;
+- fiber-based lifecycle transitions and effect-scope cleanup;
+- conflict arbitration in the global tool namespace;
+- controlled reload, disablement, retirement, and rollback;
+- sandboxing and bounded invocation for untrusted code;
+- approval, audit, usage evidence, progressive trust, and quarantine.
+
+In this sense, a tool may be the *behavior* of a capability, while a plugin is the *managed unit through which that behavior enters and exits the running system*. The distinction prevents each individual tool or skill from reimplementing its own incomplete safety and lifecycle framework.
+
+### 3.4 LeapSpace: Environment and Experiment Surface
+
+LeapSpace provides a separated application-environment surface for observing and exercising environment-sensitive behavior. Its application harness can start sandboxed applications, coordinate reference actions and hooks, and collect `LeapSignal` records. The `LeapSpaceEnvironmentSource` adapter reads environment state and converts it into observations that LeapFlow can process.
+
+LeapSpace therefore has two roles:
+
+1. **Evidence production:** it exposes structured environmental state and task outcomes instead of requiring the world model to infer change from opaque failure text alone.
+2. **Experiment control:** it permits controlled investigation of adaptation hypotheses without treating the experiment controller as an authority to mutate production capability state.
+
+The separation is important. An environmental delta is an observation, not a command. It becomes relevant to evolution only if it is typed, task-relevant, supported by admissible evidence, and unresolved by the live capability catalog.
+
+### 3.5 LeapBoard: Human-Observable Causal Presentation
+
+LeapBoard is the presentation and inspection surface for runtime and evolution state. Its server-driven UI compiles templates into a fixed view model and distributes updates to clients through the dashboard server and watch mechanisms. This makes the evolution process inspectable without giving the dashboard authority over evolution decisions.
+
+For self-evolution, LeapBoard is significant because it can render the causal chain that would otherwise be hidden behind asynchronous workers and persistent events: observations, requirements, resolution outcomes, proposals, validation, approval, lifecycle state, trust changes, and terminal outcomes. The appropriate role of LeapBoard is **explainability and operational oversight**, not autonomous governance.
+
+## 4. World-Model Adaptation Loop
+
+### 4.1 Teacher–Student Separation
+
+LeapFlow separates retrospective evaluation from online task execution. The acting agent executes the current task using the smallest sufficient context and available capabilities. At a session boundary, a durable teacher worker processes recorded evidence and invokes the trajectory grader. The teacher produces action grades and adaptation verdicts; derived knowledge is stored as evidence-backed state for later use by the student.
+
+This separation has practical benefits:
+
+- normal turns are not blocked by expensive retrospective reasoning;
+- teacher output can be checked, persisted, expired, and audited independently;
+- the online agent receives concise, task-relevant knowledge rather than an unbounded trajectory history;
+- model advice remains evidence rather than executable authority.
+
+### 4.2 The Four-Valued Adaptation Verdict
+
+The adaptation action space is deliberately closed:
+
+| Verdict | Interpretation | Capability-set consequence |
+|---|---|---|
+| `absorb` | Existing retry, semantic-addressing, or execution mechanisms already cover the change. | No change. |
+| `rebind` | Another installed plugin or tool already satisfies the requirement in the observed environment. | No new code; selection preference may change. |
+| `acquire` | No available capability satisfies the typed, task-relevant requirement. | Candidate code may be proposed, subject to governance. |
+| `escalate` | A human decision, credential, scope, or policy action is required. | No autonomous mutation. |
+
+The ordering is intentional: `absorb` and `rebind` are cheaper and safer than `acquire`. Every verdict includes knowledge that informs future execution. Only `acquire` may lead to code generation, and even then it remains a recommendation rather than authorization.
+
+This design counters a common failure mode in agentic systems: interpreting a changed environment as proof that the incumbent implementation is defective. An incumbent can be correct for a previous application version while an alternate adapter is now more appropriate. The verdict asks what action is supported by evidence, not which component is to blame.
+
+### 4.3 Event-Sourced Knowledge and Selection
+
+Evolution evidence is persisted through an append-only event store. Read models, including distilled knowledge and rebind preferences, are projections over that evidence rather than independent sources of truth. A preference extracted from a `rebind` verdict can influence selection, but it is intentionally weaker than structural constraints such as declared capability fit and environment affordances.
+
+The capability resolver operationalizes this distinction. It scores live candidates from declared matching, environmental compatibility, risk cost, trust, reliability, and—when present—distilled preference. A teacher recommendation cannot make an incompatible capability eligible; it is evidence that informs a deterministic resolution process, not a hidden control channel.
+
+## 5. From Evidence to Plugin Acquisition
+
+### 5.1 Resolution Before Acquisition
+
+Before generating new code, LeapFlow resolves the requirement against the live catalog. An already satisfiable requirement becomes an explicit no-op or rebind result rather than a duplicate proposal. This avoids capability proliferation and ensures that new code is the exception rather than the default response to change.
+
+The acquisition branch is gated by the user-visible `evolution.enabled` setting, which is disabled by default. The setting controls whether an `acquire` verdict may enter the capability-proposal path. It does not disable world-model grading, knowledge distillation, or read-only selection guidance. Consequently, the system can learn from an environment even while capability mutation remains disabled.
+
+### 5.2 Governed Acquisition Pipeline
+
+An eligible acquisition follows a staged path:
+
+```text
+classified evidence
+  → typed capability requirement
+  → live-catalog resolution
+  → proposal
+  → generation
+  → syntax / structure / protocol validation
+  → compatibility assessment
+  → approval
+  → artifact write
+  → sandbox smoke test
+  → register at DRAFT
+  → behavior tests and probation
+  → trust accrual, verification, or quarantine
+```
+
+The pipeline is intentionally more restrictive than “LLM writes a file and imports it.” It provides an accountable answer to four questions that an unconstrained script cannot answer reliably:
+
+1. **Why was this capability needed?** The requirement is linked to source evidence and resolution results.
+2. **Why is this implementation admissible?** Validation, compatibility assessment, and approval must precede activation.
+3. **What happens if it fails?** Outcomes drive demotion, quarantine, disablement, or rollback.
+4. **Can the decision be reconstructed?** Causal records include no-op, rejected, and failed branches, not only successful installation.
+
+### 5.3 Progressive Trust and Reversibility
+
+New plugins start with limited trust. Trust can advance through observed success and can be reduced by consecutive failures; an internal defect can permanently freeze a capability. Plugins can also be isolated in a subprocess, invoked over bounded JSON-RPC, and removed from service through lifecycle governance.
+
+This mechanism makes adaptation reversible. It also makes the system more conservative precisely where a model-generated artifact is most uncertain: before the capability has accumulated operational evidence.
+
+## 6. Why a Plugin System Is Necessary
+
+It is reasonable to ask whether tools and skills alone could perform self-evolution. For many changes, they can and should. The plugin system is necessary only because some adaptations have properties that cannot be safely represented as a local procedure.
+
+| Requirement | Tool/skill-only approach | Plugin-governed approach |
+|---|---|---|
+| Revised procedure using existing operations | Sufficient. | Optional wrapper only. |
+| New vendor adapter or native API integration | Ad hoc import and registration risk. | Declared capability, dependency binding, validation, and lifecycle. |
+| Long-lived stream, subscription, or polling source | Cleanup and reload ownership are easy to leak. | Fiber and effect scope define ownership and disposal. |
+| Untrusted generated code | In-process execution expands blast radius. | Sandbox, timeout, and restricted dependency surface. |
+| Capability conflict or version replacement | Local code may silently shadow an incumbent. | First-wins arbitration, conflict record, and managed rollback. |
+| Mutation with external side effects | Each implementation may invent inconsistent policy. | Shared risk, approval, audit, and recovery contracts. |
+| Multi-session daemon runtime | Local changes can cause nondeterministic shared-state behavior. | Per-turn snapshots and process-global lifecycle discipline. |
+
+The plugin system is thus not an alternative to tools and skills. It is the governance and operational substrate that allows certain tools, skills, adapters, and signal sources to exist safely as dynamically managed capabilities.
+
+## 7. When Harness-Level Evolution Is Justified
+
+Harness-level changes should be exceptional. They are justified when evidence reveals a general deficiency in the extension contract or in a cross-cutting invariant that cannot be solved by a conforming plugin. Examples include a missing neutral protocol for a class of external effects, a session-isolation flaw, or a generic recovery semantic absent from the runtime.
+
+The expected benefits are system-wide:
+
+- one corrected contract can improve every current and future plugin;
+- common safety invariants become enforceable at a single boundary;
+- duplicated vendor-specific work can be replaced by a reusable abstraction;
+- observability and rollback remain coherent across all capabilities.
+
+The expected costs are likewise system-wide: core defects can affect all sessions and all plugins. For this reason, Harness changes require conventional engineering controls—design review, compatibility analysis, targeted and broad regression testing, and deliberate release management. They are not an online action selected directly by a world-model verdict.
+
+A practical decision rule follows:
+
+> Prefer knowledge adaptation, then rebind, then a governed plugin. Consider a Harness change only when multiple independently evidenced needs expose a stable, general contract gap.
+
+## 8. LeapSpace–LeapFlow–LeapBoard Causal Plane
+
+The three systems form complementary surfaces rather than a monolithic control loop.
+
+```text
+LeapSpace                         LeapFlow                         LeapBoard
+─────────                         ────────                         ─────────
+application state                 typed observation                causal views
+reference actions       ─────►    signal filtering                  watch updates
+LeapSignal records                world-model verdicts     ─────►  evolution lens
+sandboxed experiments             capability resolution             operator inspection
+                                  plugin governance                 notifications
+```
+
+1. **LeapSpace observes and stages:** it makes environmental conditions and outcomes available through controlled application environments, signals, and an environment-source adapter.
+2. **LeapFlow reasons and governs:** it converts admissible observations into knowledge, resolutions, and—only where justified—governed proposals and lifecycle transitions.
+3. **LeapBoard exposes and explains:** it presents state and causal outcomes to the operator without bypassing the policy and approval chain.
+
+This decomposition preserves a critical separation of powers. LeapSpace does not directly register production capabilities; LeapBoard does not approve or execute mutations; the world model does not directly install code. Each component contributes evidence, reasoning, governance, or visibility within its own boundary.
+
+## 9. Safety and Scientific Integrity Properties
+
+The architecture is intended to support the following properties.
+
+### 9.1 Evidence-Bounded Mutation
+
+An environmental observation or model suggestion is insufficient by itself. Mutation requires a typed, task-relevant, unresolved capability requirement and subsequent governance gates.
+
+### 9.2 Resolution Completeness
+
+A requirement already satisfied by the live catalog should produce a recorded no-op or rebind, rather than a new capability artifact. This property controls unnecessary growth and makes non-mutation a visible outcome.
+
+### 9.3 Causal Traceability
+
+The causal record should connect environmental evidence, requirement formation, catalog resolution, policy and approval decisions, artifact identity, validation, lifecycle and trust outcomes, and any retirement or rollback. Rejections and no-ops are first-class observations, not missing data.
+
+### 9.4 Bounded Autonomy
+
+The agent may improve its knowledge and selection policy without the authority to rewrite its capability set. The capability-writing branch is opt-in and constrained by validation, approval, sandboxing, and post-deployment trust evidence.
+
+### 9.5 Cold-Path Governance
+
+Retrospective grading, proposal processing, telemetry, and broad co-evolution sweeps should remain off the ordinary turn-critical path. Learning must not impose material latency or fragility on normal task execution.
+
+## 10. Limitations and Non-Claims
+
+The current architecture should be interpreted with the following limitations.
+
+- `evolution.enabled` is off by default; an `acquire` verdict does not imply that a new capability will be generated or installed.
+- LeapSpace's `e2e` application-harness mode is explicitly incomplete; the existence of LeapSpace components should not be read as proof of a complete end-to-end production environment-adaptation path.
+- Some telemetry is intentionally optional and depends on sink installation. The absence of a presentation event is not proof that no internal event occurred.
+- World-model output is fallible. It is treated as evidence and recommendation, not as a source of authorization or a replacement for declared constraints.
+- Plugin mutation is process-global even though session state is isolated. Any change to the active capability set must therefore be evaluated against concurrent-client behavior.
+- This document does not claim autonomous architectural redesign of the Harness. Stable core-contract evolution remains an engineering activity, not an automatic side effect of a single trajectory.
+
+## 11. Evaluation Implications
+
+A rigorous evaluation should distinguish adaptation quality from mere code-generation frequency. At minimum, experiments should report:
+
+- the number and provenance of environmental deltas;
+- outcomes by verdict class: `absorb`, `rebind`, `acquire`, and `escalate`;
+- resolution no-ops versus true unmet requirements;
+- proposal acceptance, rejection, expiration, installation, rollback, and quarantine outcomes;
+- reliability, latency, and safety effects before and after adaptation;
+- evidence coverage and the presence of complete causal records;
+- counterfactual baselines, including unchanged environments and irrelevant deltas correctly rejected.
+
+An evaluation that measures only successful installations risks rewarding unnecessary mutation. A mature system should often demonstrate adaptation through knowledge, re-selection, or deliberate non-action.
+
+## 12. Conclusion
+
+World-model-driven self-evolution is most useful when it is framed as **governed capability adaptation** rather than autonomous core rewriting. The world model identifies and distils what changed; the capability resolver determines whether the live system already has a valid response; the plugin system admits, tests, governs, and—when necessary—retires new operational capability; the Harness maintains the common safety and lifecycle invariants; LeapSpace provides controlled environmental evidence; and LeapBoard makes the chain observable to human operators.
+
+The resulting system favors the least invasive valid response. It learns first, reuses second, acquires cautiously, and escalates when authority or evidence is insufficient. This is the essential rationale for a plugin-based self-evolution architecture: it makes adaptation extensible without converting every environmental change into an unbounded modification of the agent runtime.
+
+## Appendix A. Primary Implementation Map
+
+| Concern | Primary implementation references |
+|---|---|
+| Adaptation action model | [`src/leapflow/domain/adaptation_verdict.py`](../src/leapflow/domain/adaptation_verdict.py) |
+| Teacher grading and verdict generation | [`src/leapflow/world_model/trajectory_grader.py`](../src/leapflow/world_model/trajectory_grader.py) |
+| Durable retrospective worker | [`src/leapflow/evolution/teacher_worker.py`](../src/leapflow/evolution/teacher_worker.py) |
+| Co-evolution cold path | [`src/leapflow/evolution/sweep.py`](../src/leapflow/evolution/sweep.py) |
+| Event-backed distilled knowledge | [`src/leapflow/storage/distilled_knowledge_store.py`](../src/leapflow/storage/distilled_knowledge_store.py) |
+| Capability resolution | [`src/leapflow/plugins/capability_resolver.py`](../src/leapflow/plugins/capability_resolver.py) |
+| Plugin lifecycle governance | [`src/leapflow/plugins/lifecycle_governor.py`](../src/leapflow/plugins/lifecycle_governor.py) |
+| Plugin contracts and metadata | [`src/leapflow/plugins/protocol.py`](../src/leapflow/plugins/protocol.py) |
+| Plugin lifecycle specification | [`docs/plugins/plugin_lifecycle_management.md`](plugins/plugin_lifecycle_management.md) |
+| LeapSpace application harness | [`src/leapspace/app_space/harness.py`](../src/leapspace/app_space/harness.py) |
+| LeapSpace signals | [`src/leapspace/app_space/signal.py`](../src/leapspace/app_space/signal.py) |
+| LeapSpace-to-LeapFlow adapter | [`src/leapflow/perception/leapspace_source.py`](../src/leapflow/perception/leapspace_source.py) |
+| LeapBoard server | [`src/leapflow/dashboard/server.py`](../src/leapflow/dashboard/server.py) |
+| LeapBoard templates | [`src/leapflow/dashboard/templates.py`](../src/leapflow/dashboard/templates.py) |
+| Configuration and evolution gate | [`src/leapflow/config.py`](../src/leapflow/config.py) |
+| Engineering constraints | [`AGENTS.md`](../AGENTS.md) |
diff --git a/src/leapflow/config.py b/src/leapflow/config.py
index e87643ae..26159ebd 100644
--- a/src/leapflow/config.py
+++ b/src/leapflow/config.py
@@ -402,6 +402,9 @@ class Settings:
     evolution_teacher_max_attempts: int = 3
     evolution_teacher_retry_backoff_s: float = 5.0
     evolution_autonomy_level: str = "generate_only"
+    # How many hours a capability proposal stays active before the cold-path
+    # sweep expires it. 0 disables TTL-based expiry entirely.
+    proposal_ttl_hours: int = 72
     environment_mode: str = "production"
     environment_leapspace_enabled: bool = False
     environment_leapspace_state_root: str = ""
@@ -1019,6 +1022,7 @@ def _build_settings_from_env(
     evolution_autonomy_level = os.getenv(
         "LEAPFLOW_EVOLUTION_AUTONOMY_LEVEL", "generate_only"
     ).strip()
+    proposal_ttl_hours = int(os.getenv("LEAPFLOW_PROPOSAL_TTL_HOURS", "72"))
     environment_mode = os.getenv("LEAPFLOW_ENVIRONMENT_MODE", "production").strip().lower()
     environment_leapspace_enabled = _bool(
         "LEAPFLOW_ENVIRONMENT_LEAPSPACE_ENABLED", "false"
@@ -1491,6 +1495,7 @@ def _tuple_env(key: str, default: tuple) -> tuple:
         evolution_teacher_max_attempts=evolution_teacher_max_attempts,
         evolution_teacher_retry_backoff_s=evolution_teacher_retry_backoff_s,
         evolution_autonomy_level=evolution_autonomy_level,
+        proposal_ttl_hours=proposal_ttl_hours,
         environment_mode=environment_mode,
         environment_leapspace_enabled=environment_leapspace_enabled,
         environment_leapspace_state_root=environment_leapspace_state_root,
diff --git a/src/leapflow/dashboard/static/app.js b/src/leapflow/dashboard/static/app.js
index 29473de5..60a53dee 100644
--- a/src/leapflow/dashboard/static/app.js
+++ b/src/leapflow/dashboard/static/app.js
@@ -316,11 +316,11 @@
     // extended: five of seven templates shipped untranslated in every language, and
     // the i18n test only checked signal keys, so nothing failed. Keyed by the English
     // source string, so an untranslated key still renders readable English.
-    zh: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **尚未记录任何效果判定**，因此没有可度量的奖励信号。上面的比率有意留空而非显示 0%。只有当需求声明了预期效果才可能验证，而目前只有世界模型撰写的需求带有预期效果。", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **回归：已闭合的缺口再次复发。** 一次看起来成功的演进并未站住。这是本看板上唯一需要立即处理的发现。", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **仅快照。** 目前尚无可重建的因果历史，因此时间线是「缺席」而非「空白」。原因由管道贯通度中的 `策略决策` 一行说明；实时快照与贯通度表本身不受影响。", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **部分插件因内部缺陷被冻结。** 冻结的插件仍报告 `DRAFT`，而信任维度只做「打分」，因此若未同时注销，它仍可被选中——请查看 `可被选中` 列。", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **验证层级：L2（声明式适配）。** 观测被退役，只意味着某个候选**声明**自己提供该能力，并不意味着该能力被观测到确实生效。效果验证（L3）尚未接线，因此本看板上的任何闭合都不应被读作「已证实」。", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> 需要至少完成一个观测周期才会有内容。若持续为空，请检查调度器是否启用、`framework-evolution` watch 是否已 armed 且未静音。", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> 当一次环境观测导向一次能力决策时，才会写下一条剧集。目前尚无记录——这既可能是系统本就安静，也可能是管道更早就断了：**管道**页签会指出它断在哪一段，以及什么能解除阻塞。", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> 目前没有任何机制自动回收它们。每一个都占着一个工具名、出现在能力列表里，却不可被选中——注册表朝着没有任何需求能用的方向增长。", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> 这些提议未进入任何管道，因此不会出现在任何决策记录或观测中。是否准入是一项配置选择。", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "比值低于 1.0 表示采样循环未能维持其声明的节奏。", "Abstained": "弃权", "Acquisition authority": "获取授权", "Acquisition lifecycle": "获取生命周期", "Action": "动作", "After": "变更后", "An unverified declaration has its writable channels demoted to read-only.": "未核验的声明，其可写通道会被降级为只读。", "Approval": "审批", "Autonomous governance": "自主治理", "Autonomy": "自主级别", "Before": "变更前", "CANDIDATE": "候选级", "Calibrated at": "校准时间", "Calibration health": "校准健康度", "Calls": "调用次数", "Calls (decisions)": "观点（决策）", "Candlestick": "K 线", "Capability": "能力", "Capability adaptation": "能力适配", "Capability observations": "能力观测", "Capability ownership": "能力归属", "Capability topology": "能力拓扑", "Change": "变化", "Channel": "通道", "Channels": "通道数", "Channels that have never been calibrated or whose calibration has expired are shown first.": "从未校准或校准已过期的通道排在最前。", "Command": "命令", "Commanded versus observed, best tracking first": "命令值与实测值对比，跟随最好者在前", "Composition": "组成", "Concerns (open questions)": "关切（待答问题）", "Confidence": "置信度", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "统计所有绘制通道。“接近”指处于声明边界的 5% 以内。", "Cycles run": "已运行周期", "DRAFT": "草稿级", "Days since": "距今天数", "Decision": "决策", "Decisions read as calls; action items as the execution checklist.": "决策即观点，行动项即执行清单。", "Declared Hz": "声明频率 (Hz)", "Desk brief": "交易台简报", "Device": "设备", "Dropped samples": "丢弃的样本", "Each row names one blocked segment and the change that would unblock it.": "每一行指出一个受阻环节，以及能解除阻塞的那项变更。", "Effect verification (L3)": "效果验证（L3）", "Effects declared": "已声明效果", "Entities as references, and recommended next prompts to advance the work.": "实体作为参考，并给出推进工作的后续追问。", "Entities in play and the open risks still to resolve.": "涉及的实体，以及尚未解决的敞口风险。", "Envelope, rate, staleness and quality observations · newest first": "包络、速率、失联与质量观测 · 最新在前", "Environment": "环境", "Environment to framework": "环境 → 框架", "Environment, selected plugin tools, and orchestration order.": "环境、已选插件工具及编排顺序。", "Error rate": "错误率", "Events paced out": "被配速抑制的事件", "Ever used": "是否用过", "Evidence": "证据", "Evidence admission": "证据准入", "Evolution": "演进", "Evolution timeline": "演进时间线", "Executable": "可执行", "Execution checklist": "执行清单", "Extracted from this session's tool/file output (not model-generated).": "数据来自本次会话的工具/文件产物（非模型生成）。", "Failures": "失败次数", "Fiber": "Fiber 状态", "Fiber state changes since the previous cycle, including load retries.": "自上一周期以来的 Fiber 状态变化，含加载重试。", "Finance lens": "金融视图", "Follow-ups": "后续事项", "Framework change": "框架变更", "Framework changes as they happened, from runtime probes.": "来自运行时探针的框架变更实况。", "Framework evolution": "框架演进", "Framework size and how much of the evolution pipeline shows runtime evidence.": "框架规模，以及演进管道中有多少环节呈现运行时证据。", "From": "从", "Frozen plugins": "已冻结插件", "Gap closure": "缺口闭合", "Halt": "可急停", "How closures are verified": "闭合是如何验证的", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "效果信号中有多少可真正用作反馈。这决定了是否值得构建学习策略。", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "框架中有多少是它自己长出来的，以及演进管道中有多少环节呈现运行时证据。", "How often each window sat inside, near, or outside its declared limits": "各窗口处于声明限值内、接近边界或越界的频次", "Inquiry brief": "研究简报", "Insights carded as evidence, capped for fast review.": "洞察以证据卡呈现，数量受限以便快速浏览。", "Instruments & counterparties": "标的与交易对手", "Kept": "保留", "Latest capability decision": "最新能力决策", "Lifecycle records": "生命周期记录", "Lifecycle timeline": "生命周期时间线", "Lifecycle transitions": "生命周期迁移", "Line of inquiry": "研究主线", "Live activity": "实时动态", "Location": "位置", "Loop phase": "循环阶段", "Mean of each downsample window. Declared limits are listed per channel below.": "每个降采样窗口的均值。各通道的声明限值见下方。", "Model's reasoning": "模型的推理", "Mutation": "变更", "Narrative": "叙事", "Narrative pulse": "叙事脉搏", "Needs attention": "需要关注", "Next recal due": "下次校准期限", "Next step": "下一步", "No causal history yet": "尚无因果历史", "Normalized error": "归一化误差", "Normalized error is the residual as a share of the channel's declared span.": "归一化误差是残差占该通道声明量程的比例。", "Not yet observed": "尚未观测", "Nothing has driven a framework change, so there is no episode to narrate.": "尚无任何事驱动过框架变更，因此没有可讲述的剧集。", "OHLC extracted from captured session market data.": "OHLC 提取自本次会话捕获的行情数据。", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "观测待办、提案状态、策略决策与生命周期结果。", "Observations": "观测数", "Observed Hz": "实测频率 (Hz)", "Observed rate against declared rate": "实测速率与声明速率对比", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "单一全局命名空间，先注册者胜。挑战者会被记录，绝不静默丢弃。", "Open": "已连接", "Open risks": "敞口风险", "Open/high/low/close from captured tool output.": "开/高/低/收，来自捕获的工具输出。", "Origin": "来源", "Outcome": "结果", "PRODUCTION": "生产级", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "逐条剧集：触发源、决策、变更，以及缺口是否闭合。", "Per-channel calibration state, freshness, and residual correction": "各通道的校准状态、时效性与残差校正", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "逐段运行时证据。模块存在并不等于有任何代码调用它。", "Pipeline": "管道", "Pipeline evidence": "管道证据", "Pipeline reachability": "管道贯通度", "Plan": "计划", "Plan steps": "计划步骤", "Plugin": "插件", "Plugin roster and trust": "插件名册与信任", "Plugins": "插件数", "Plugins by origin": "按来源分布的插件", "Plugins by trust class": "按信任等级分布的插件", "Policy": "策略", "Policy decisions": "策略决策", "Positions & actions": "持仓与操作", "Posture": "态势", "Price action": "价格行为", "Proposal": "提案", "Proposal status": "提案状态", "Proposed, not admitted": "已提议，未准入", "Pulse": "脉搏", "Quarantine feed": "隔离进料", "Ratio": "比值", "Read live from the registry and trust ledger every cycle.": "每个周期从注册表与信任账本实时读取。", "Recent episodes": "近期剧集", "Reclaim candidates": "可回收候选", "Reclaimable": "可回收", "References & follow-ups": "参考与后续", "References (entities)": "参考（实体）", "Registry": "注册表", "Registry delta": "注册表变化", "Registry version": "注册表版本", "Regressions": "回归", "Rejected": "被拒", "Representative observations, capped for quick scanning.": "代表性观察，数量受限以便快速浏览。", "Requirements": "能力需求", "Research lens": "研究视图", "Residual": "残差", "Reward signal bandwidth": "奖励信号带宽", "Runtime evidence": "运行时证据", "Sampled history per channel, newest on the right": "按通道的采样历史，最新在右侧", "Segment": "管道段", "Segments by status": "按状态分布的管道段", "Selectable": "可被选中", "Selection delta": "选择变化", "Self-acquired": "自获取", "Self-acquired plugins that are registered but unselectable or never once used.": "已注册但不可被选中、或从未被使用过的自获取插件。", "Sentiment lens": "情绪视图", "Series": "序列", "Session analysis": "会话分析", "Signal strength": "信号强度", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "表明某处长错了、或被扣下未放行的信号。无论打开哪个页签都会显示。", "Skipped slots": "跳过的采样点", "State": "状态", "Storyline and signal strength before drilling into positions and actions.": "先看叙事与信号强度，再深入持仓与操作。", "Streaming": "采样中", "Suggested next steps": "建议的下一步", "The line of investigation and where the open questions concentrate.": "研究主线，以及待答问题的集中之处。", "The narrative arc and how strongly themes are trending.": "叙事走向，以及主题的趋势强度。", "The world model asked for these capabilities and nothing took them up.": "世界模型请求了这些能力，但无人受理。", "Theme intensity": "主题强度", "Themes": "主题", "This board reports how the framework changes itself. Nothing has been recorded yet.": "本看板报告框架如何改变自身。目前尚无任何记录。", "To": "到", "Tool": "工具", "Tool-name conflicts": "工具名冲突", "Tools": "工具数", "Transport": "传输方式", "Transport, provenance and channel counts": "传输方式、来源与通道数量", "Trust": "信任级别", "Trust accrual": "信任累积", "Trust class": "信任语义", "Unselectable reclamation": "不可选回收", "Usable": "可用", "VERIFIED": "已验证级", "Verdicts": "判定数", "Verdicts by reason": "按原因分布的判定", "Verified": "已核验", "Verified by": "验证依据", "Voices & concerns": "声音与关切", "Watchlist": "关注列表", "What changed in the environment, and what the framework did about it.": "环境发生了什么变化，框架又为此做了什么。", "Which plugin owns which tool, and which capability that tool provides.": "哪个插件拥有哪个工具，以及该工具提供什么能力。", "Who/what is in the conversation, and the concerns still open.": "谁/什么在被讨论，以及尚未解决的关切。", "Why": "原因", "Why not admitted": "未准入原因", "Why this page is empty": "这个页面为何是空的", "World-model driver": "世界模型驱动器", "Writable": "可写", "aborted": "已中断", "accruing": "正在累积", "active": "运行中", "appeared": "新出现", "armed": "已就绪", "assess_compatibility": "评估兼容性", "built_in": "内置", "capability_expand": "扩展能力", "committed": "已定论", "conformance": "合规", "declared_fitness": "声明式适配", "disable": "停用", "disposed": "已释放", "effect_observed": "效果已观测", "environment_probe": "环境探测", "execution_failed": "执行失败", "expected_effect_absent": "预期效果未出现", "failed": "已失败", "frozen": "已冻结", "gone": "已消失", "idle": "空闲无变化", "install": "安装", "loading": "加载中", "manual": "人工", "moved": "已迁移", "new_unproven": "新，未验证", "no": "否", "no_evidence": "无证据", "no_expected_effect_declared": "未声明预期效果", "no_outcome_observed": "未观测到结果", "none": "无", "not_admitted": "未准入", "not_applicable": "不适用", "observe_only": "仅观察", "observed_effect": "观测效果", "open": "进行中", "pending": "待启", "reload": "重载", "remove": "移除", "reopened": "已复发", "resolved": "已闭合", "rollback": "回滚", "runtime": "运行时", "self_acquired": "自获取", "still_open": "仍未闭合", "tool_reported_no_effect": "工具未报告效果", "trusted": "已信任", "unknown": "未知", "unknown_tool": "未知工具", "unloading": "卸载中", "unscheduled": "未调度", "unverifiable": "无法核实", "unverified": "未验证", "waiting": "等待首个周期", "watching": "监视中", "wired": "已贯通", "world_model": "世界模型", "yes": "是", "Causal trace": "因果追踪", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "单个框架演进快照的只读环境到治理证据。", "Evidence boundary": "证据边界", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "因果追踪展示已记录的事实；不推断缺失的审批或已观测效果。", "Episodes": "剧集", "Declared-fitness closures": "声明式适配闭合", "Counterfactual / mutation matrix": "反事实 / 变更矩阵", "Each row preserves the driver, decision, registry delta, and verification tier.": "每一行保留驱动因素、决策、注册表变化和验证层级。", "Trigger": "触发源", "Evidence tier": "证据层级", "Episode timeline": "剧集时间线", "Rebuilt from existing decision and observation records.": "从现有决策和观测记录重建。", "Durable trace feed": "持久追踪流", "Rejected and no-op decisions remain visible when their trace sink is installed.": "安装追踪接收器后，被拒绝和无操作决策仍保持可见。", "Lifecycle": "生命周期", "Pipeline evidence over time": "管道证据随时间变化", "One point per recorded change in framework state, oldest first.": "每一个点对应一次已记录的框架状态变化，最旧在左。", "Samples": "样本数", "Net change": "净变化"},
-    fr: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **Aucun verdict d'effet n'a encore été enregistré**, il n'y a donc aucun signal de récompense à mesurer. Les taux ci-dessus sont volontairement vides plutôt que nuls. Un effet ne peut être vérifié que si l'exigence en a déclaré un, et seules les exigences rédigées par le modèle du monde en portent aujourd'hui.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **Régression : un écart comblé s'est reproduit.** Une évolution qui semblait réussie n'a pas tenu. C'est le seul constat de ce tableau qui exige une attention immédiate.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **Instantané seulement.** Aucun historique causal à reconstruire pour l'instant : la chronologie est absente, non vide. La raison est indiquée par la ligne `Décisions de politique` sous la couverture du pipeline ; l'instantané et le tableau de couverture ne sont pas affectés.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **Certains plugins sont gelés par un défaut interne.** Un plugin gelé signale toujours `DRAFT`, et la dimension de confiance ne fait que *noter*, donc il reste sélectionnable tant qu'il n'est pas également désenregistré — voir la colonne `Sélectionnable`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **Niveau de vérification : L2 (aptitude déclarée).** Une observation retirée signifie qu'un candidat a *déclaré* fournir la capacité, non que la capacité a été observée en fonctionnement. La vérification d'effet (L3) n'est pas câblée, donc aucune clôture de ce tableau ne doit être lue comme prouvée.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> Un cycle d'observation doit s'achever avant qu'il y ait quoi que ce soit à montrer. Si cela persiste, vérifiez que le planificateur est actif et que la surveillance `framework-evolution` est armée et non silencée.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> Un épisode est écrit lorsqu'une observation de l'environnement conduit à une décision de capacité. Aucun n'a été enregistré : soit le système est calme, soit le pipeline s'arrête plus tôt — l'onglet **Pipeline** nomme le segment où il s'arrête et ce qui le débloquerait.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> Rien ne les récupère automatiquement. Chacun occupe un nom d'outil et figure dans la liste des capacités sans être sélectionnable : le registre grandit dans une direction qu'aucune exigence ne peut utiliser.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> Ces propositions n'ont intégré aucun pipeline : elles n'apparaissent donc dans aucun enregistrement de décision ni observation. Les admettre est un choix de configuration.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "Un ratio inférieur à 1,0 signifie que la boucle d’échantillonnage ne tient pas sa cadence déclarée.", "Abstained": "Abstention", "Acquisition authority": "Autorité d'acquisition", "Acquisition lifecycle": "Cycle de vie d'acquisition", "Action": "Action", "After": "Après", "An unverified declaration has its writable channels demoted to read-only.": "Une déclaration non vérifiée voit ses canaux inscriptibles rétrogradés en lecture seule.", "Approval": "Approbation", "Autonomous governance": "Gouvernance autonome", "Autonomy": "Autonomie", "Before": "Avant", "CANDIDATE": "Candidat", "Calibrated at": "Calibré le", "Calibration health": "État de calibration", "Calls": "Appels", "Calls (decisions)": "Recommandations (décisions)", "Candlestick": "Chandeliers", "Capability": "Capacité", "Capability adaptation": "Adaptation des capacités", "Capability observations": "Observations de capacités", "Capability ownership": "Propriété des capacités", "Capability topology": "Topologie des capacités", "Change": "Changement", "Channel": "Canal", "Channels": "Canaux", "Channels that have never been calibrated or whose calibration has expired are shown first.": "Les canaux jamais calibrés ou dont la calibration a expiré apparaissent en premier.", "Command": "Commande", "Commanded versus observed, best tracking first": "Commandé contre observé, meilleur suivi d’abord", "Composition": "Composition", "Concerns (open questions)": "Préoccupations (questions ouvertes)", "Confidence": "Confiance", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "Compté sur tous les canaux tracés. « près » signifie à moins de 5 % d’une borne déclarée.", "Cycles run": "Cycles exécutés", "DRAFT": "Brouillon", "Days since": "Jours écoulés", "Decision": "Décision", "Decisions read as calls; action items as the execution checklist.": "Les décisions se lisent comme des recommandations ; les actions comme la liste d’exécution.", "Declared Hz": "Hz déclarés", "Desk brief": "Note de desk", "Device": "Appareil", "Dropped samples": "Échantillons perdus", "Each row names one blocked segment and the change that would unblock it.": "Chaque ligne nomme un segment bloqué et le changement qui le débloquerait.", "Effect verification (L3)": "Vérification d'effet (L3)", "Effects declared": "Effets déclarés", "Entities as references, and recommended next prompts to advance the work.": "Entités comme références, et invites suivantes recommandées pour avancer.", "Entities in play and the open risks still to resolve.": "Entités concernées et risques ouverts à résoudre.", "Envelope, rate, staleness and quality observations · newest first": "Observations d’enveloppe, de débit, d’obsolescence et de qualité · les plus récentes d’abord", "Environment": "Environnement", "Environment to framework": "De l'environnement au framework", "Environment, selected plugin tools, and orchestration order.": "Environnement, outils de plugin sélectionnés et ordre d’orchestration.", "Error rate": "Taux d'erreur", "Events paced out": "Événements limités", "Ever used": "Déjà utilisé", "Evidence": "Preuve", "Evidence admission": "Admission des preuves", "Evolution": "Évolution", "Evolution timeline": "Chronologie de l'évolution", "Executable": "Exécutable", "Execution checklist": "Liste d’exécution", "Extracted from this session's tool/file output (not model-generated).": "Extrait des sorties d’outils/fichiers de cette session (non généré par le modèle).", "Failures": "Échecs", "Fiber": "Fibre", "Fiber state changes since the previous cycle, including load retries.": "Changements d'état de fiber depuis le cycle précédent, y compris les tentatives de chargement.", "Finance lens": "Vue finance", "Follow-ups": "Suivis", "Framework change": "Changement du framework", "Framework changes as they happened, from runtime probes.": "Changements du framework en temps réel, via les sondes d'exécution.", "Framework evolution": "Évolution du framework", "Framework size and how much of the evolution pipeline shows runtime evidence.": "Taille du framework et part du pipeline d'évolution qui présente des preuves d'exécution.", "From": "De", "Frozen plugins": "Plugins gelés", "Gap closure": "Clôture de l'écart", "Halt": "Arrêt", "How closures are verified": "Comment les clôtures sont vérifiées", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "Quelle part du signal d'effet est exploitable comme rétroaction. C'est ce qui détermine s'il vaut la peine de construire une politique d'apprentissage.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "Quelle part du framework il a fait croître lui-même, et quelle part du pipeline présente des preuves d'exécution.", "How often each window sat inside, near, or outside its declared limits": "Fréquence à laquelle chaque fenêtre était dans, près de, ou hors de ses limites déclarées", "Inquiry brief": "Note d’enquête", "Insights carded as evidence, capped for fast review.": "Analyses présentées comme preuves, limitées pour une revue rapide.", "Instruments & counterparties": "Instruments et contreparties", "Kept": "Conservé", "Latest capability decision": "Dernière décision de capacité", "Lifecycle records": "Enregistrements de cycle de vie", "Lifecycle timeline": "Chronologie du cycle de vie", "Lifecycle transitions": "Transitions de cycle de vie", "Line of inquiry": "Ligne d’enquête", "Live activity": "Activité en direct", "Location": "Emplacement", "Loop phase": "Phase de boucle", "Mean of each downsample window. Declared limits are listed per channel below.": "Moyenne de chaque fenêtre de sous-échantillonnage. Les limites déclarées figurent par canal ci-dessous.", "Model's reasoning": "Raisonnement du modèle", "Mutation": "Mutation", "Narrative": "Récit", "Narrative pulse": "Pouls narratif", "Needs attention": "Requiert attention", "Next recal due": "Prochaine recalibration", "Next step": "Étape suivante", "No causal history yet": "Pas encore d'historique causal", "Normalized error": "Erreur normalisée", "Normalized error is the residual as a share of the channel's declared span.": "L’erreur normalisée est le résidu en proportion de l’étendue déclarée du canal.", "Not yet observed": "Pas encore observé", "Nothing has driven a framework change, so there is no episode to narrate.": "Rien n'a encore déclenché de changement du framework : il n'y a donc aucun épisode à raconter.", "OHLC extracted from captured session market data.": "OHLC extrait des données de marché capturées durant la session.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "File d’observations, état des propositions, décisions de politique et résultats du cycle de vie.", "Observations": "Observations", "Observed Hz": "Hz observés", "Observed rate against declared rate": "Débit observé par rapport au débit déclaré", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "Un espace de noms global unique, arbitré au premier arrivé. Le concurrent est enregistré, jamais supprimé en silence.", "Open": "Ouvert", "Open risks": "Risques ouverts", "Open/high/low/close from captured tool output.": "Ouverture/haut/bas/clôture issus des sorties d’outils capturées.", "Origin": "Origine", "Outcome": "Résultat", "PRODUCTION": "Production", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "Par épisode : le déclencheur, la décision, le changement, et si l'écart a été comblé.", "Per-channel calibration state, freshness, and residual correction": "État de calibration, fraîcheur et correction résiduelle par canal", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "Preuves d'exécution par segment. L'existence d'un module ne prouve pas qu'il soit appelé.", "Pipeline": "Pipeline", "Pipeline evidence": "Preuves du pipeline", "Pipeline reachability": "Accessibilité du pipeline", "Plan": "Plan", "Plan steps": "Étapes du plan", "Plugin": "Plugin", "Plugin roster and trust": "Registre des plugins et confiance", "Plugins": "Plugins", "Plugins by origin": "Plugins par origine", "Plugins by trust class": "Plugins par classe de confiance", "Policy": "Politique", "Policy decisions": "Décisions de politique", "Positions & actions": "Positions et actions", "Posture": "Posture", "Price action": "Action des prix", "Proposal": "Proposition", "Proposal status": "Statut de la proposition", "Proposed, not admitted": "Proposé, non admis", "Pulse": "Pouls", "Quarantine feed": "Flux de quarantaine", "Ratio": "Ratio", "Read live from the registry and trust ledger every cycle.": "Lu en direct depuis le registre et le registre de confiance à chaque cycle.", "Recent episodes": "Épisodes récents", "Reclaim candidates": "Candidats à la récupération", "Reclaimable": "Récupérable", "References & follow-ups": "Références et suivis", "References (entities)": "Références (entités)", "Registry": "Registre", "Registry delta": "Delta du registre", "Registry version": "Version du registre", "Regressions": "Régressions", "Rejected": "Rejeté", "Representative observations, capped for quick scanning.": "Observations représentatives, limitées pour une lecture rapide.", "Requirements": "Exigences", "Research lens": "Vue recherche", "Residual": "Résidu", "Reward signal bandwidth": "Bande passante du signal de récompense", "Runtime evidence": "Preuve d'exécution", "Sampled history per channel, newest on the right": "Historique échantillonné par canal, le plus récent à droite", "Segment": "Segment", "Segments by status": "Segments par statut", "Selectable": "Sélectionnable", "Selection delta": "Delta de sélection", "Self-acquired": "Auto-acquis", "Self-acquired plugins that are registered but unselectable or never once used.": "Plugins auto-acquis qui sont enregistrés mais non sélectionnables, ou jamais utilisés une seule fois.", "Sentiment lens": "Vue sentiment", "Series": "Série", "Session analysis": "Analyse de session", "Signal strength": "Force du signal", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "Signaux indiquant qu'une évolution a mal tourné ou a été retenue. Affichés quel que soit l'onglet ouvert.", "Skipped slots": "Créneaux manqués", "State": "État", "Storyline and signal strength before drilling into positions and actions.": "Récit et force du signal avant d’examiner positions et actions.", "Streaming": "Diffusion", "Suggested next steps": "Prochaines étapes suggérées", "The line of investigation and where the open questions concentrate.": "La ligne d’investigation et où se concentrent les questions ouvertes.", "The narrative arc and how strongly themes are trending.": "L’arc narratif et l’intensité des tendances thématiques.", "The world model asked for these capabilities and nothing took them up.": "Le modèle du monde a demandé ces capacités et personne ne les a prises en charge.", "Theme intensity": "Intensité des thèmes", "Themes": "Thèmes", "This board reports how the framework changes itself. Nothing has been recorded yet.": "Ce tableau rend compte de la façon dont le framework se modifie lui-même. Rien n'a encore été enregistré.", "To": "Vers", "Tool": "Outil", "Tool-name conflicts": "Conflits de noms d'outils", "Tools": "Outils", "Transport": "Transport", "Transport, provenance and channel counts": "Transport, provenance et nombre de canaux", "Trust": "Confiance", "Trust accrual": "Accumulation de confiance", "Trust class": "Classe de confiance", "Unselectable reclamation": "Récupération non sélectionnable", "Usable": "Exploitable", "VERIFIED": "Vérifié", "Verdicts": "Verdicts", "Verdicts by reason": "Verdicts par motif", "Verified": "Vérifié", "Verified by": "Vérifié par", "Voices & concerns": "Voix et préoccupations", "Watchlist": "Liste de suivi", "What changed in the environment, and what the framework did about it.": "Ce qui a changé dans l'environnement, et ce que le framework a fait en réponse.", "Which plugin owns which tool, and which capability that tool provides.": "Quel plugin possède quel outil, et quelle capacité cet outil fournit.", "Who/what is in the conversation, and the concerns still open.": "Qui/quoi est dans la conversation, et les préoccupations encore ouvertes.", "Why": "Pourquoi", "Why not admitted": "Motif de non-admission", "Why this page is empty": "Pourquoi cette page est vide", "World-model driver": "Pilote du modèle du monde", "Writable": "Inscriptible", "aborted": "Abandonné", "accruing": "En accumulation", "active": "Actif", "appeared": "Apparu", "armed": "Armé", "assess_compatibility": "Évaluer la compatibilité", "built_in": "Intégré", "capability_expand": "Étendre les capacités", "committed": "Conclu", "conformance": "Conformité", "declared_fitness": "Aptitude déclarée", "disable": "Désactiver", "disposed": "Libéré", "effect_observed": "Effet observé", "environment_probe": "Sonde d'environnement", "execution_failed": "Échec d'exécution", "expected_effect_absent": "Effet attendu absent", "failed": "Échoué", "frozen": "Gelé", "gone": "Disparu", "idle": "Au repos", "install": "Installer", "loading": "Chargement", "manual": "Manuel", "moved": "Déplacé", "new_unproven": "Nouveau, non éprouvé", "no": "Non", "no_evidence": "Aucune preuve", "no_expected_effect_declared": "Aucun effet attendu déclaré", "no_outcome_observed": "Aucun résultat observé", "none": "Aucun", "not_admitted": "Non admis", "not_applicable": "Sans objet", "observe_only": "Observer seulement", "observed_effect": "Effet observé", "open": "Ouvert", "pending": "En attente", "reload": "Recharger", "remove": "Supprimer", "reopened": "Réouvert", "resolved": "Résolu", "rollback": "Annuler", "runtime": "Exécution", "self_acquired": "Auto-acquis", "still_open": "Toujours ouvert", "tool_reported_no_effect": "L'outil n'a signalé aucun effet", "trusted": "De confiance", "unknown": "Inconnu", "unknown_tool": "Outil inconnu", "unloading": "Déchargement", "unscheduled": "Non planifié", "unverifiable": "Invérifiable", "unverified": "Non vérifié", "waiting": "En attente", "watching": "En surveillance", "wired": "Câblé", "world_model": "Modèle du monde", "yes": "Oui", "Causal trace": "Trace causale", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "Preuves en lecture seule reliant l’environnement à la gouvernance pour un instantané d’évolution du framework.", "Evidence boundary": "Limite des preuves", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "Une trace causale montre les faits enregistrés ; elle n’infère ni approbation manquante ni effet observé.", "Episodes": "Épisodes", "Declared-fitness closures": "Clôtures par aptitude déclarée", "Counterfactual / mutation matrix": "Matrice contrefactuelle / mutations", "Each row preserves the driver, decision, registry delta, and verification tier.": "Chaque ligne conserve le déclencheur, la décision, le delta du registre et le niveau de vérification.", "Trigger": "Déclencheur", "Evidence tier": "Niveau de preuve", "Episode timeline": "Chronologie des épisodes", "Rebuilt from existing decision and observation records.": "Reconstruite à partir des enregistrements existants de décision et d’observation.", "Durable trace feed": "Flux de traces durables", "Rejected and no-op decisions remain visible when their trace sink is installed.": "Les décisions rejetées et sans action restent visibles lorsque leur récepteur de traces est installé.", "Lifecycle": "Cycle de vie", "Pipeline evidence over time": "Évolution des preuves du convéoyeur", "One point per recorded change in framework state, oldest first.": "Un point par changement enregistré de l’état du framework, du plus ancien au plus récent.", "Samples": "Échantillons", "Net change": "Variation nette"},
-    es: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **Aún no se ha registrado ningún veredicto de efecto**, por lo que no hay señal de recompensa que medir. Las tasas anteriores están en blanco a propósito, no en cero. Un efecto solo puede verificarse si el requisito declaró uno, y hoy solo los requisitos redactados por el modelo del mundo lo llevan.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **Regresión: una brecha cerrada ha vuelto a aparecer.** Una evolución que parecía exitosa no se sostuvo. Es el único hallazgo de este panel que exige atención inmediata.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **Solo instantánea.** Todavía no hay historia causal que reconstruir, por lo que la cronología está ausente, no vacía. El motivo lo indica la fila `Decisiones de política` bajo la cobertura del pipeline; la instantánea y la tabla de cobertura no se ven afectadas.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **Algunos plugins están congelados por un defecto interno.** Un plugin congelado sigue informando `DRAFT`, y la dimensión de confianza solo *puntúa*, por lo que permanece seleccionable a menos que también se desregistre — consulte la columna `Seleccionable`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **Nivel de verificación: L2 (aptitud declarada).** Una observación retirada significa que un candidato *declaró* que proporciona la capacidad, no que se observara funcionando. La verificación de efecto (L3) no está conectada, así que ningún cierre de este panel debe leerse como probado.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> Debe completarse un ciclo de observación antes de que haya algo que mostrar. Si persiste, compruebe que el planificador está activo y que la vigilancia `framework-evolution` está armada y no silenciada.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> Un episodio se escribe cuando una observación del entorno conduce a una decisión de capacidad. No se ha registrado ninguno: o el sistema está tranquilo o el pipeline se detiene antes — la pestaña **Pipeline** nombra el segmento donde se detiene y qué lo desbloquearía.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> Nada los recupera automáticamente. Cada uno ocupa un nombre de herramienta y aparece en la lista de capacidades sin ser seleccionable: el registro crece en una dirección que ningún requisito puede usar.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> Estas propuestas no entraron en ningún pipeline, por lo que no aparecen en ningún registro de decisión ni observación. Admitirlas es una elección de configuración.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "Una relación inferior a 1,0 significa que el bucle de muestreo no mantiene su cadencia declarada.", "Abstained": "Abstenido", "Acquisition authority": "Autoridad de adquisición", "Acquisition lifecycle": "Ciclo de vida de adquisición", "Action": "Acción", "After": "Después", "An unverified declaration has its writable channels demoted to read-only.": "Una declaración no verificada degrada sus canales escribibles a solo lectura.", "Approval": "Aprobación", "Autonomous governance": "Gobernanza autónoma", "Autonomy": "Autonomía", "Before": "Antes", "CANDIDATE": "Candidato", "Calibrated at": "Calibrado el", "Calibration health": "Estado de calibración", "Calls": "Llamadas", "Calls (decisions)": "Recomendaciones (decisiones)", "Candlestick": "Velas", "Capability": "Capacidad", "Capability adaptation": "Adaptación de capacidades", "Capability observations": "Observaciones de capacidad", "Capability ownership": "Propiedad de capacidades", "Capability topology": "Topología de capacidades", "Change": "Cambio", "Channel": "Canal", "Channels": "Canales", "Channels that have never been calibrated or whose calibration has expired are shown first.": "Los canales nunca calibrados o con calibración vencida se muestran primero.", "Command": "Comando", "Commanded versus observed, best tracking first": "Comandado frente a observado, mejor seguimiento primero", "Composition": "Composición", "Concerns (open questions)": "Inquietudes (preguntas abiertas)", "Confidence": "Confianza", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "Contado en todos los canales graficados. «cerca» significa dentro del 5 % de un límite declarado.", "Cycles run": "Ciclos ejecutados", "DRAFT": "Borrador", "Days since": "Días desde", "Decision": "Decisión", "Decisions read as calls; action items as the execution checklist.": "Las decisiones se leen como recomendaciones; las acciones como la lista de ejecución.", "Declared Hz": "Hz declarados", "Desk brief": "Informe de mesa", "Device": "Dispositivo", "Dropped samples": "Muestras descartadas", "Each row names one blocked segment and the change that would unblock it.": "Cada fila nombra un segmento bloqueado y el cambio que lo desbloquearía.", "Effect verification (L3)": "Verificación de efecto (L3)", "Effects declared": "Efectos declarados", "Entities as references, and recommended next prompts to advance the work.": "Entidades como referencias y siguientes preguntas recomendadas para avanzar.", "Entities in play and the open risks still to resolve.": "Entidades implicadas y riesgos abiertos por resolver.", "Envelope, rate, staleness and quality observations · newest first": "Observaciones de envolvente, tasa, obsolescencia y calidad · las más recientes primero", "Environment": "Entorno", "Environment to framework": "Del entorno al framework", "Environment, selected plugin tools, and orchestration order.": "Entorno, herramientas de plugin seleccionadas y orden de orquestación.", "Error rate": "Tasa de error", "Events paced out": "Eventos limitados", "Ever used": "Alguna vez usado", "Evidence": "Evidencia", "Evidence admission": "Admisión de evidencia", "Evolution": "Evolución", "Evolution timeline": "Cronología de la evolución", "Executable": "Ejecutable", "Execution checklist": "Lista de ejecución", "Extracted from this session's tool/file output (not model-generated).": "Extraído de la salida de herramientas/archivos de esta sesión (no generado por el modelo).", "Failures": "Fallos", "Fiber": "Fibra", "Fiber state changes since the previous cycle, including load retries.": "Cambios de estado de fiber desde el ciclo anterior, incluidos los reintentos de carga.", "Finance lens": "Vista financiera", "Follow-ups": "Seguimientos", "Framework change": "Cambio del framework", "Framework changes as they happened, from runtime probes.": "Cambios del framework en tiempo real, desde sondas de ejecución.", "Framework evolution": "Evolución del framework", "Framework size and how much of the evolution pipeline shows runtime evidence.": "Tamaño del framework y qué parte del pipeline de evolución muestra evidencia en ejecución.", "From": "Desde", "Frozen plugins": "Plugins congelados", "Gap closure": "Cierre de la brecha", "Halt": "Parada", "How closures are verified": "Cómo se verifican los cierres", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "Cuánto de la señal de efecto es utilizable como retroalimentación. Esto decide si vale la pena construir una política de aprendizaje.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "Cuánto del framework hizo crecer por sí mismo y cuánto del pipeline muestra evidencia de ejecución.", "How often each window sat inside, near, or outside its declared limits": "Con qué frecuencia cada ventana estuvo dentro, cerca o fuera de sus límites declarados", "Inquiry brief": "Informe de indagación", "Insights carded as evidence, capped for fast review.": "Hallazgos presentados como evidencia, limitados para revisión rápida.", "Instruments & counterparties": "Instrumentos y contrapartes", "Kept": "Conservado", "Latest capability decision": "Última decisión de capacidad", "Lifecycle records": "Registros de ciclo de vida", "Lifecycle timeline": "Cronología del ciclo de vida", "Lifecycle transitions": "Transiciones de ciclo de vida", "Line of inquiry": "Línea de indagación", "Live activity": "Actividad en vivo", "Location": "Ubicación", "Loop phase": "Fase del bucle", "Mean of each downsample window. Declared limits are listed per channel below.": "Media de cada ventana de submuestreo. Los límites declarados se listan por canal abajo.", "Model's reasoning": "Razonamiento del modelo", "Mutation": "Mutación", "Narrative": "Narrativa", "Narrative pulse": "Pulso narrativo", "Needs attention": "Requiere atención", "Next recal due": "Próxima recalibración", "Next step": "Siguiente paso", "No causal history yet": "Aún no hay historia causal", "Normalized error": "Error normalizado", "Normalized error is the residual as a share of the channel's declared span.": "El error normalizado es el residuo como fracción del rango declarado del canal.", "Not yet observed": "Aún no observado", "Nothing has driven a framework change, so there is no episode to narrate.": "Nada ha impulsado todavía un cambio del framework, por lo que no hay ningún episodio que narrar.", "OHLC extracted from captured session market data.": "OHLC extraído de los datos de mercado capturados en la sesión.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "Cola de observaciones, estado de propuestas, decisiones de política y resultados del ciclo de vida.", "Observations": "Observaciones", "Observed Hz": "Hz observados", "Observed rate against declared rate": "Tasa observada frente a la tasa declarada", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "Un único espacio de nombres global, arbitrado por orden de llegada. El aspirante queda registrado, nunca se descarta en silencio.", "Open": "Abierto", "Open risks": "Riesgos abiertos", "Open/high/low/close from captured tool output.": "Apertura/máximo/mínimo/cierre desde la salida de herramientas capturada.", "Origin": "Origen", "Outcome": "Resultado", "PRODUCTION": "Producción", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "Por episodio: el desencadenante, la decisión, el cambio y si la brecha se cerró.", "Per-channel calibration state, freshness, and residual correction": "Estado de calibración, vigencia y corrección residual por canal", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "Evidencia en ejecución por segmento. Que un módulo exista no prueba que algo lo invoque.", "Pipeline": "Pipeline", "Pipeline evidence": "Evidencia del pipeline", "Pipeline reachability": "Alcanzabilidad del pipeline", "Plan": "Plan", "Plan steps": "Pasos del plan", "Plugin": "Plugin", "Plugin roster and trust": "Registro de plugins y confianza", "Plugins": "Plugins", "Plugins by origin": "Plugins por origen", "Plugins by trust class": "Plugins por clase de confianza", "Policy": "Política", "Policy decisions": "Decisiones de política", "Positions & actions": "Posiciones y acciones", "Posture": "Postura", "Price action": "Acción del precio", "Proposal": "Propuesta", "Proposal status": "Estado de la propuesta", "Proposed, not admitted": "Propuesto, no admitido", "Pulse": "Pulso", "Quarantine feed": "Entrada de cuarentena", "Ratio": "Relación", "Read live from the registry and trust ledger every cycle.": "Leído en vivo del registro y del libro de confianza en cada ciclo.", "Recent episodes": "Episodios recientes", "Reclaim candidates": "Candidatos a recuperación", "Reclaimable": "Recuperable", "References & follow-ups": "Referencias y seguimientos", "References (entities)": "Referencias (entidades)", "Registry": "Registro", "Registry delta": "Delta del registro", "Registry version": "Versión del registro", "Regressions": "Regresiones", "Rejected": "Rechazado", "Representative observations, capped for quick scanning.": "Observaciones representativas, limitadas para lectura rápida.", "Requirements": "Requisitos", "Research lens": "Vista de investigación", "Residual": "Residuo", "Reward signal bandwidth": "Ancho de banda de la señal de recompensa", "Runtime evidence": "Evidencia en ejecución", "Sampled history per channel, newest on the right": "Historial muestreado por canal, el más reciente a la derecha", "Segment": "Segmento", "Segments by status": "Segmentos por estado", "Selectable": "Seleccionable", "Selection delta": "Delta de selección", "Self-acquired": "Autoadquirido", "Self-acquired plugins that are registered but unselectable or never once used.": "Plugins autoadquiridos que están registrados pero no son seleccionables, o nunca se han usado.", "Sentiment lens": "Vista de sentimiento", "Series": "Serie", "Session analysis": "Análisis de sesión", "Signal strength": "Fuerza de la señal", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "Señales de que algo creció mal o fue retenido. Se muestran independientemente de la pestaña abierta.", "Skipped slots": "Ranuras omitidas", "State": "Estado", "Storyline and signal strength before drilling into positions and actions.": "Narrativa y fuerza de la señal antes de entrar en posiciones y acciones.", "Streaming": "Transmisión", "Suggested next steps": "Próximos pasos sugeridos", "The line of investigation and where the open questions concentrate.": "La línea de investigación y dónde se concentran las preguntas abiertas.", "The narrative arc and how strongly themes are trending.": "El arco narrativo y con qué fuerza se mueven los temas.", "The world model asked for these capabilities and nothing took them up.": "El modelo del mundo pidió estas capacidades y nada las asumió.", "Theme intensity": "Intensidad temática", "Themes": "Temas", "This board reports how the framework changes itself. Nothing has been recorded yet.": "Este panel informa de cómo el framework se modifica a sí mismo. Todavía no se ha registrado nada.", "To": "Hasta", "Tool": "Herramienta", "Tool-name conflicts": "Conflictos de nombres de herramientas", "Tools": "Herramientas", "Transport": "Transporte", "Transport, provenance and channel counts": "Transporte, procedencia y número de canales", "Trust": "Confianza", "Trust accrual": "Acumulación de confianza", "Trust class": "Clase de confianza", "Unselectable reclamation": "Recuperación no seleccionable", "Usable": "Utilizable", "VERIFIED": "Verificado", "Verdicts": "Veredictos", "Verdicts by reason": "Veredictos por motivo", "Verified": "Verificado", "Verified by": "Verificado por", "Voices & concerns": "Voces e inquietudes", "Watchlist": "Lista de seguimiento", "What changed in the environment, and what the framework did about it.": "Qué cambió en el entorno y qué hizo el framework al respecto.", "Which plugin owns which tool, and which capability that tool provides.": "Qué plugin posee qué herramienta y qué capacidad proporciona esa herramienta.", "Who/what is in the conversation, and the concerns still open.": "Quién/qué está en la conversación y las inquietudes aún abiertas.", "Why": "Por qué", "Why not admitted": "Motivo de no admisión", "Why this page is empty": "Por qué esta página está vacía", "World-model driver": "Controlador del modelo del mundo", "Writable": "Escribible", "aborted": "Abortado", "accruing": "Acumulando", "active": "Activo", "appeared": "Apareció", "armed": "Armado", "assess_compatibility": "Evaluar compatibilidad", "built_in": "Integrado", "capability_expand": "Ampliar capacidad", "committed": "Concluido", "conformance": "Conformidad", "declared_fitness": "Aptitud declarada", "disable": "Desactivar", "disposed": "Liberado", "effect_observed": "Efecto observado", "environment_probe": "Sonda de entorno", "execution_failed": "Ejecución fallida", "expected_effect_absent": "Efecto esperado ausente", "failed": "Fallido", "frozen": "Congelado", "gone": "Desapareció", "idle": "Inactivo", "install": "Instalar", "loading": "Cargando", "manual": "Manual", "moved": "Se movió", "new_unproven": "Nuevo, no probado", "no": "No", "no_evidence": "Sin evidencia", "no_expected_effect_declared": "Sin efecto esperado declarado", "no_outcome_observed": "Sin resultado observado", "none": "Ninguno", "not_admitted": "No admitido", "not_applicable": "No aplicable", "observe_only": "Solo observar", "observed_effect": "Efecto observado", "open": "Abierto", "pending": "Pendiente", "reload": "Recargar", "remove": "Eliminar", "reopened": "Reabierto", "resolved": "Resuelto", "rollback": "Revertir", "runtime": "Tiempo de ejecución", "self_acquired": "Autoadquirido", "still_open": "Aún abierto", "tool_reported_no_effect": "La herramienta no informó efecto", "trusted": "De confianza", "unknown": "Desconocido", "unknown_tool": "Herramienta desconocida", "unloading": "Descargando", "unscheduled": "No planificado", "unverifiable": "No verificable", "unverified": "No verificado", "waiting": "En espera", "watching": "Vigilando", "wired": "Conectado", "world_model": "Modelo del mundo", "yes": "Sí", "Causal trace": "Traza causal", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "Evidencia de solo lectura del entorno a la gobernanza para una instantánea de evolución del framework.", "Evidence boundary": "Límite de evidencia", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "Una traza causal muestra hechos registrados; no infiere aprobación ausente ni efecto observado.", "Episodes": "Episodios", "Declared-fitness closures": "Cierres por aptitud declarada", "Counterfactual / mutation matrix": "Matriz contrafactual / de mutaciones", "Each row preserves the driver, decision, registry delta, and verification tier.": "Cada fila conserva el desencadenante, la decisión, el delta del registro y el nivel de verificación.", "Trigger": "Desencadenante", "Evidence tier": "Nivel de evidencia", "Episode timeline": "Cronología de episodios", "Rebuilt from existing decision and observation records.": "Reconstruida a partir de registros existentes de decisión y observación.", "Durable trace feed": "Flujo de trazas durables", "Rejected and no-op decisions remain visible when their trace sink is installed.": "Las decisiones rechazadas y sin acción permanecen visibles cuando se instala su receptor de trazas.", "Lifecycle": "Ciclo de vida", "Pipeline evidence over time": "Evidencia del canal a lo largo del tiempo", "One point per recorded change in framework state, oldest first.": "Un punto por cada cambio registrado del estado del framework, del más antiguo al más reciente.", "Samples": "Muestras", "Net change": "Cambio neto"},
-    ar: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **لم يُسجَّل أي حكم على الأثر بعد**، لذا لا توجد إشارة مكافأة لقياسها. النسب أعلاه فارغة عن قصد وليست صفرًا. لا يمكن التحقق من الأثر إلا إذا أعلنه المطلب، واليوم لا تحمل الأثر المتوقع سوى المطالب التي كتبها نموذج العالم.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **انحدار: فجوة أُغلقت عادت للظهور.** تطوّر بدا ناجحًا لم يصمد. هذا هو الاكتشاف الوحيد في هذه اللوحة الذي يستدعي انتباهًا فوريًا.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **لقطة فقط.** لا يوجد بعد تاريخ سببي لإعادة بنائه، لذا فالخط الزمني غائب وليس فارغًا. السبب مبيَّن في صف `قرارات السياسة` تحت تغطية المسار؛ اللقطة الحيّة وجدول التغطية غير متأثرين.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **بعض الإضافات مُجمَّدة بسبب خلل داخلي.** الإضافة المُجمَّدة لا تزال تُبلِّغ `DRAFT`، وبُعد الثقة يقوم بالتقييم فقط، لذا تبقى قابلة للاختيار إلا إذا أُلغي تسجيلها أيضًا — راجع عمود `قابل للاختيار`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **مستوى التحقق: L2 (الملاءمة المُعلنة).** سحب الرصد يعني أن مرشّحًا *أعلن* أنه يوفّر القدرة، لا أن القدرة رُصدت وهي تعمل. التحقق من الأثر (L3) غير موصول، لذا لا ينبغي قراءة أي إغلاق في هذه اللوحة كأمر مُثبَت.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> يجب أن تكتمل دورة مراقبة واحدة قبل ظهور أي محتوى. إذا استمر ذلك، تحقّق من تمكين المُجدول وأن مراقبة `framework-evolution` مُسلّحة وغير مكتومة.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> تُكتب الحلقة عندما يؤدي رصد للبيئة إلى قرار بشأن قدرة. لم يُسجَّل أي منها، وهذا يعني إمّا نظامًا هادئًا أو مسارًا يتوقف قبل ذلك — تبويب **المسار** يحدّد الجزء الذي يتوقف عنده وما الذي يزيل التعطيل.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> لا شيء يستعيدها تلقائيًا. كل واحدة تحتجز اسم أداة وتظهر في قائمة القدرات دون أن تكون قابلة للاختيار، فينمو السجل في اتجاه لا يمكن لأي مطلب استخدامه.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> لم تدخل هذه المقترحات أي مسار، لذا لا تظهر في أي سجل قرار أو رصد. قبولها خيار في الإعدادات.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "نسبة أقل من 1.0 تعني أن حلقة أخذ العينات لا تحافظ على وتيرتها المعلنة.", "Abstained": "امتناع", "Acquisition authority": "سلطة الاكتساب", "Acquisition lifecycle": "دورة حياة الاكتساب", "Action": "الإجراء", "After": "بعد", "An unverified declaration has its writable channels demoted to read-only.": "الإعلان غير المُتحقَّق منه تُخفَّض قنواته القابلة للكتابة إلى القراءة فقط.", "Approval": "الموافقة", "Autonomous governance": "الحكم الذاتي", "Autonomy": "الاستقلالية", "Before": "قبل", "CANDIDATE": "مرشّح", "Calibrated at": "تاريخ المعايرة", "Calibration health": "سلامة المعايرة", "Calls": "الاستدعاءات", "Calls (decisions)": "التوصيات (القرارات)", "Candlestick": "الشموع", "Capability": "القدرة", "Capability adaptation": "تكييف القدرات", "Capability observations": "رصد القدرات", "Capability ownership": "ملكية القدرات", "Capability topology": "طوبولوجيا القدرات", "Change": "التغيير", "Channel": "القناة", "Channels": "القنوات", "Channels that have never been calibrated or whose calibration has expired are shown first.": "تظهر أولاً القنوات التي لم تُعاير قط أو التي انتهت صلاحية معايرتها.", "Command": "الأمر", "Commanded versus observed, best tracking first": "المأمور مقابل المرصود، الأفضل تتبعاً أولاً", "Composition": "التركيب", "Concerns (open questions)": "المخاوف (أسئلة مفتوحة)", "Confidence": "الثقة", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "محسوب على كل قناة مرسومة. \"قريب\" تعني داخل 5% من حد معلن.", "Cycles run": "الدورات المنفَّذة", "DRAFT": "مسوّدة", "Days since": "الأيام المنقضية", "Decision": "القرار", "Decisions read as calls; action items as the execution checklist.": "القرارات تُقرأ كتوصيات؛ والإجراءات كقائمة تنفيذ.", "Declared Hz": "الهرتز المعلن", "Desk brief": "موجز المكتب", "Device": "الجهاز", "Dropped samples": "العينات المفقودة", "Each row names one blocked segment and the change that would unblock it.": "كل صف يحدّد جزءًا معطَّلًا والتغيير الذي يزيل التعطيل.", "Effect verification (L3)": "التحقق من الأثر (L3)", "Effects declared": "الآثار المُعلنة", "Entities as references, and recommended next prompts to advance the work.": "الكيانات كمراجع، والمطالبات التالية الموصى بها لدفع العمل.", "Entities in play and the open risks still to resolve.": "الكيانات المعنية والمخاطر المفتوحة التي لم تُحل.", "Envelope, rate, staleness and quality observations · newest first": "رصدات المغلف والمعدل والتقادم والجودة · الأحدث أولاً", "Environment": "البيئة", "Environment to framework": "من البيئة إلى الإطار", "Environment, selected plugin tools, and orchestration order.": "البيئة والأدوات المختارة وترتيب التنسيق.", "Error rate": "معدل الأخطاء", "Events paced out": "الأحداث المُقيَّدة", "Ever used": "استُخدم سابقًا", "Evidence": "الدليل", "Evidence admission": "قبول الأدلة", "Evolution": "التطور", "Evolution timeline": "الخط الزمني للتطور", "Executable": "قابل للتنفيذ", "Execution checklist": "قائمة التنفيذ", "Extracted from this session's tool/file output (not model-generated).": "مستخرج من مخرجات الأدوات/الملفات في هذه الجلسة (ليس من إنشاء النموذج).", "Failures": "الأعطال", "Fiber": "الخيط", "Fiber state changes since the previous cycle, including load retries.": "تغييرات حالة الـ fiber منذ الدورة السابقة، بما في ذلك محاولات التحميل.", "Finance lens": "منظور مالي", "Follow-ups": "المتابعات", "Framework change": "تغيير الإطار", "Framework changes as they happened, from runtime probes.": "تغييرات الإطار لحظة حدوثها، من مجسّات وقت التشغيل.", "Framework evolution": "تطور الإطار", "Framework size and how much of the evolution pipeline shows runtime evidence.": "حجم الإطار ومقدار ما يُظهره مسار التطور من أدلة وقت التشغيل.", "From": "من", "Frozen plugins": "الإضافات المُجمَّدة", "Gap closure": "إغلاق الفجوة", "Halt": "إيقاف", "How closures are verified": "كيف يُتحقَّق من الإغلاقات", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "ما مقدار إشارة الأثر القابل للاستخدام كتغذية راجعة. هذا يحدّد ما إذا كان بناء سياسة تعلّم يستحق العناء.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "ما مقدار ما نمّاه الإطار بنفسه، وما مقدار المسار الذي يُظهر أدلة وقت التشغيل.", "How often each window sat inside, near, or outside its declared limits": "عدد المرات التي كانت فيها كل نافذة داخل حدودها المعلنة أو قريبة منها أو خارجها", "Inquiry brief": "موجز الاستقصاء", "Insights carded as evidence, capped for fast review.": "الرؤى معروضة كأدلة، ومحدودة العدد للمراجعة السريعة.", "Instruments & counterparties": "الأدوات والأطراف المقابلة", "Kept": "المحتفظ به", "Latest capability decision": "أحدث قرار للقدرات", "Lifecycle records": "سجلات دورة الحياة", "Lifecycle timeline": "الخط الزمني لدورة الحياة", "Lifecycle transitions": "انتقالات دورة الحياة", "Line of inquiry": "خط الاستقصاء", "Live activity": "النشاط المباشر", "Location": "الموقع", "Loop phase": "مرحلة الحلقة", "Mean of each downsample window. Declared limits are listed per channel below.": "متوسط كل نافذة تخفيض للعينات. الحدود المعلنة مدرجة لكل قناة أدناه.", "Model's reasoning": "استدلال النموذج", "Mutation": "التغيير", "Narrative": "السرد", "Narrative pulse": "نبض السرد", "Needs attention": "يستدعي الانتباه", "Next recal due": "موعد إعادة المعايرة", "Next step": "الخطوة التالية", "No causal history yet": "لا يوجد تاريخ سببي بعد", "Normalized error": "الخطأ المعياري", "Normalized error is the residual as a share of the channel's declared span.": "الخطأ المعياري هو المتبقي كنسبة من المدى المعلن للقناة.", "Not yet observed": "لم يُرصد بعد", "Nothing has driven a framework change, so there is no episode to narrate.": "لم يدفع أي شيء بعد إلى تغيير في الإطار، لذا لا توجد حلقة لسردها.", "OHLC extracted from captured session market data.": "OHLC مستخرج من بيانات السوق المسجلة في الجلسة.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "قائمة الرصد وحالة المقترحات وقرارات السياسة ونتائج دورة الحياة.", "Observations": "الرصدات", "Observed Hz": "الهرتز المرصود", "Observed rate against declared rate": "المعدل المرصود مقابل المعدل المعلن", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "مساحة أسماء عالمية واحدة، تُحكَّم بأسبقية التسجيل. يُسجَّل المتنافس ولا يُهمَل بصمت.", "Open": "مفتوح", "Open risks": "المخاطر المفتوحة", "Open/high/low/close from captured tool output.": "الافتتاح/الأعلى/الأدنى/الإغلاق من مخرجات الأدوات المسجلة.", "Origin": "المصدر", "Outcome": "النتيجة", "PRODUCTION": "إنتاج", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "لكل حلقة: المُحفِّز والقرار والتغيير وما إذا أُغلقت الفجوة.", "Per-channel calibration state, freshness, and residual correction": "حالة المعايرة وحداثتها وتصحيح المتبقي لكل قناة", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "أدلة وقت التشغيل لكل مقطع. وجود وحدة لا يعني أن شيئًا يستدعيها.", "Pipeline": "المسار", "Pipeline evidence": "أدلة المسار", "Pipeline reachability": "إمكانية الوصول إلى المسار", "Plan": "الخطة", "Plan steps": "خطوات الخطة", "Plugin": "الملحق", "Plugin roster and trust": "قائمة الملحقات والثقة", "Plugins": "الملحقات", "Plugins by origin": "الإضافات حسب المصدر", "Plugins by trust class": "الإضافات حسب فئة الثقة", "Policy": "السياسة", "Policy decisions": "قرارات السياسة", "Positions & actions": "المراكز والإجراءات", "Posture": "الوضع", "Price action": "حركة السعر", "Proposal": "المقترح", "Proposal status": "حالة المقترح", "Proposed, not admitted": "مُقترح وغير مقبول", "Pulse": "النبض", "Quarantine feed": "تغذية الحجر", "Ratio": "النسبة", "Read live from the registry and trust ledger every cycle.": "يُقرأ مباشرة من السجل ودفتر الثقة في كل دورة.", "Recent episodes": "الحلقات الأخيرة", "Reclaim candidates": "مرشّحو الاسترجاع", "Reclaimable": "قابل للاسترجاع", "References & follow-ups": "المراجع والمتابعات", "References (entities)": "المراجع (الكيانات)", "Registry": "السجل", "Registry delta": "فرق السجل", "Registry version": "إصدار السجل", "Regressions": "الانحدارات", "Rejected": "المرفوض", "Representative observations, capped for quick scanning.": "رصدات تمثيلية، محدودة العدد للقراءة السريعة.", "Requirements": "المتطلبات", "Research lens": "منظور بحثي", "Residual": "المتبقي", "Reward signal bandwidth": "نطاق إشارة المكافأة", "Runtime evidence": "دليل وقت التشغيل", "Sampled history per channel, newest on the right": "سجل العينات لكل قناة، الأحدث على اليمين", "Segment": "المقطع", "Segments by status": "الأجزاء حسب الحالة", "Selectable": "قابل للاختيار", "Selection delta": "فرق الاختيار", "Self-acquired": "مُكتسَب ذاتيًا", "Self-acquired plugins that are registered but unselectable or never once used.": "إضافات مُكتسَبة ذاتيًا مُسجَّلة لكنها غير قابلة للاختيار أو لم تُستخدم قطّ.", "Sentiment lens": "منظور المشاعر", "Series": "السلسلة", "Session analysis": "تحليل الجلسة", "Signal strength": "قوة الإشارة", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "إشارات على أن شيئًا نما بشكل خاطئ أو تم حجبه. تظهر أيًا كان التبويب المفتوح.", "Skipped slots": "الفتحات المتخطاة", "State": "الحالة", "Storyline and signal strength before drilling into positions and actions.": "السرد وقوة الإشارة قبل التوسع في المراكز والإجراءات.", "Streaming": "بث", "Suggested next steps": "الخطوات التالية المقترحة", "The line of investigation and where the open questions concentrate.": "خط البحث وأين تتركز الأسئلة المفتوحة.", "The narrative arc and how strongly themes are trending.": "قوس السرد ومدى قوة اتجاه الموضوعات.", "The world model asked for these capabilities and nothing took them up.": "طلب نموذج العالم هذه القدرات ولم يتبنّها شيء.", "Theme intensity": "شدة الموضوعات", "Themes": "الموضوعات", "This board reports how the framework changes itself. Nothing has been recorded yet.": "تُبلِّغ هذه اللوحة عن كيفية تغيير الإطار لنفسه. لم يُسجَّل أي شيء بعد.", "To": "إلى", "Tool": "الأداة", "Tool-name conflicts": "تعارضات أسماء الأدوات", "Tools": "الأدوات", "Transport": "النقل", "Transport, provenance and channel counts": "النقل والمنشأ وعدد القنوات", "Trust": "الثقة", "Trust accrual": "تراكم الثقة", "Trust class": "فئة الثقة", "Unselectable reclamation": "استرجاع غير القابل للاختيار", "Usable": "قابل للاستخدام", "VERIFIED": "مُتحقَّق", "Verdicts": "الأحكام", "Verdicts by reason": "الأحكام حسب السبب", "Verified": "مُتحقَّق", "Verified by": "تم التحقق بواسطة", "Voices & concerns": "الأصوات والمخاوف", "Watchlist": "قائمة المتابعة", "What changed in the environment, and what the framework did about it.": "ما تغيّر في البيئة، وما فعله الإطار حيال ذلك.", "Which plugin owns which tool, and which capability that tool provides.": "أي ملحق يملك أي أداة، وأي قدرة توفرها تلك الأداة.", "Who/what is in the conversation, and the concerns still open.": "من/ما هو في المحادثة، والمخاوف التي لا تزال مفتوحة.", "Why": "السبب", "Why not admitted": "سبب عدم القبول", "Why this page is empty": "لماذا هذه الصفحة فارغة", "World-model driver": "مُشغِّل نموذج العالم", "Writable": "قابل للكتابة", "aborted": "مُلغى", "accruing": "قيد التراكم", "active": "نشط", "appeared": "ظهر", "armed": "مُسلّح", "assess_compatibility": "تقييم التوافق", "built_in": "مدمج", "capability_expand": "توسيع القدرة", "committed": "مُنجَز", "conformance": "المطابقة", "declared_fitness": "الملاءمة المُعلنة", "disable": "تعطيل", "disposed": "تم التخلص منه", "effect_observed": "تم رصد الأثر", "environment_probe": "مِجَس البيئة", "execution_failed": "فشل التنفيذ", "expected_effect_absent": "الأثر المتوقع غائب", "failed": "فشل", "frozen": "مُجمَّد", "gone": "اختفى", "idle": "خامل", "install": "تثبيت", "loading": "قيد التحميل", "manual": "يدوي", "moved": "انتقل", "new_unproven": "جديد وغير مُثبَت", "no": "لا", "no_evidence": "لا يوجد دليل", "no_expected_effect_declared": "لم يُعلَن أثر متوقع", "no_outcome_observed": "لم يُرصد أي ناتج", "none": "لا شيء", "not_admitted": "غير مقبول", "not_applicable": "غير منطبق", "observe_only": "المراقبة فقط", "observed_effect": "الأثر المرصود", "open": "مفتوح", "pending": "معلّق", "reload": "إعادة تحميل", "remove": "إزالة", "reopened": "أُعيد فتحه", "resolved": "تم الحل", "rollback": "تراجع", "runtime": "وقت التشغيل", "self_acquired": "مُكتسَب ذاتيًا", "still_open": "لا يزال مفتوحًا", "tool_reported_no_effect": "الأداة لم تُبلِّغ عن أثر", "trusted": "موثوق", "unknown": "غير معروف", "unknown_tool": "أداة غير معروفة", "unloading": "قيد الإلغاء", "unscheduled": "غير مُجدول", "unverifiable": "غير قابل للتحقق", "unverified": "غير مُتحقَّق", "waiting": "في الانتظار", "watching": "يراقب", "wired": "موصول", "world_model": "نموذج العالم", "yes": "نعم", "Causal trace": "الأثر السببي", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "دليل للقراءة فقط يربط البيئة بالحوكمة للّقطة واحدة من تطور الإطار.", "Evidence boundary": "حدود الدليل", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "يعرض الأثر السببي الحقائق المسجلة ولا يستنتج موافقة مفقودة أو أثرًا مرصودًا.", "Episodes": "الحلقات", "Declared-fitness closures": "إغلاقات الملاءمة المعلنة", "Counterfactual / mutation matrix": "مصفوفة الافتراضات المضادة / التغييرات", "Each row preserves the driver, decision, registry delta, and verification tier.": "يحفظ كل صف المحفز والقرار وفرق السجل ومستوى التحقق.", "Trigger": "المحفز", "Evidence tier": "طبقة الدليل", "Episode timeline": "الخط الزمني للحلقات", "Rebuilt from existing decision and observation records.": "أُعيد بناؤه من سجلات القرار والرصد الموجودة.", "Durable trace feed": "تدفق آثار دائم", "Rejected and no-op decisions remain visible when their trace sink is installed.": "تبقى القرارات المرفوضة والتي بلا إجراء مرئية عند تثبيت مستقبل آثارها.", "Lifecycle": "دورة الحياة", "Pipeline evidence over time": "أدلة المسار عبر الزمن", "One point per recorded change in framework state, oldest first.": "نقطة واحدة لكل تغيير مسجّل في حالة الإطار، الأقدم أولًا.", "Samples": "العينات", "Net change": "التغير الصافي"},
-    ru: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **Ни одного заключения об эффекте пока не записано**, поэтому измерять нечего. Показатели выше намеренно пусты, а не равны нулю. Эффект можно проверить только если требование его заявило, а сегодня заявленный эффект несут лишь требования, составленные моделью мира.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **Регрессия: закрытый пробел возобновился.** Эволюция, казавшаяся успешной, не удержалась. Это единственный вывод на этой панели, требующий немедленного внимания.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **Только снимок.** Причинной истории для восстановления пока нет, поэтому хронология отсутствует, а не пуста. Причина указана в строке `Решения политики` под покрытием конвейера; снимок и таблица покрытия не затронуты.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **Некоторые плагины заморожены из-за внутреннего дефекта.** Замороженный плагин по-прежнему сообщает `DRAFT`, а измерение доверия только *оценивает*, поэтому он остаётся выбираемым, пока не будет также снят с регистрации — см. столбец `Выбираемо`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **Уровень проверки: L2 (заявленная пригодность).** Снятое наблюдение означает, что кандидат *заявил* о предоставлении возможности, а не что возможность наблюдалась в работе. Проверка эффекта (L3) не подключена, поэтому ни одно закрытие на этой панели не следует считать доказанным.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> Прежде чем появятся данные, должен завершиться хотя бы один цикл наблюдения. Если это сохраняется, проверьте, включён ли планировщик и что наблюдение `framework-evolution` активно и не отключено.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> Эпизод записывается, когда наблюдение окружения приводит к решению о возможности. Ни одного не зафиксировано: либо система спокойна, либо конвейер останавливается раньше — вкладка **Конвейер** называет сегмент остановки и то, что его разблокирует.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> Ничто не утилизирует их автоматически. Каждый занимает имя инструмента и присутствует в списке возможностей, не будучи выбираемым: реестр растёт в направлении, непригодном ни для одного требования.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> Эти предложения не вошли ни в один конвейер, поэтому не отражены ни в одной записи решения или наблюдения. Их приём — вопрос конфигурации.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "Отношение ниже 1,0 означает, что цикл выборки не выдерживает объявленный ритм.", "Abstained": "Воздержалось", "Acquisition authority": "Право на получение", "Acquisition lifecycle": "Жизненный цикл получения", "Action": "Действие", "After": "После", "An unverified declaration has its writable channels demoted to read-only.": "У непроверенного объявления записываемые каналы понижаются до только чтения.", "Approval": "Согласование", "Autonomous governance": "Автономное управление", "Autonomy": "Автономность", "Before": "До", "CANDIDATE": "Кандидат", "Calibrated at": "Калиброван", "Calibration health": "Состояние калибровки", "Calls": "Вызовы", "Calls (decisions)": "Рекомендации (решения)", "Candlestick": "Свечи", "Capability": "Возможность", "Capability adaptation": "Адаптация возможностей", "Capability observations": "Наблюдения возможностей", "Capability ownership": "Владение возможностями", "Capability topology": "Топология возможностей", "Change": "Изменение", "Channel": "Канал", "Channels": "Каналы", "Channels that have never been calibrated or whose calibration has expired are shown first.": "Каналы, которые никогда не калибровались или чья калибровка истекла, показаны первыми.", "Command": "Команда", "Commanded versus observed, best tracking first": "Заданное против наблюдаемого, лучшее отслеживание первым", "Composition": "Состав", "Concerns (open questions)": "Опасения (открытые вопросы)", "Confidence": "Уверенность", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "Подсчитано по всем отображаемым каналам. «У границы» — в пределах 5% от объявленного предела.", "Cycles run": "Выполнено циклов", "DRAFT": "Черновик", "Days since": "Дней с тех пор", "Decision": "Решение", "Decisions read as calls; action items as the execution checklist.": "Решения читаются как рекомендации; действия — как чек-лист исполнения.", "Declared Hz": "Объявл. Гц", "Desk brief": "Сводка деска", "Device": "Устройство", "Dropped samples": "Отброшенные образцы", "Each row names one blocked segment and the change that would unblock it.": "Каждая строка называет заблокированный сегмент и изменение, которое его разблокирует.", "Effect verification (L3)": "Проверка эффекта (L3)", "Effects declared": "Заявлено эффектов", "Entities as references, and recommended next prompts to advance the work.": "Сущности как ссылки и рекомендуемые следующие запросы.", "Entities in play and the open risks still to resolve.": "Задействованные сущности и нерешённые риски.", "Envelope, rate, staleness and quality observations · newest first": "Наблюдения по огибающей, частоте, устареванию и качеству · сначала новые", "Environment": "Окружение", "Environment to framework": "От окружения к фреймворку", "Environment, selected plugin tools, and orchestration order.": "Окружение, выбранные инструменты плагинов и порядок оркестрации.", "Error rate": "Частота ошибок", "Events paced out": "Событий подавлено", "Ever used": "Использовался", "Evidence": "Обоснование", "Evidence admission": "Приём данных", "Evolution": "Эволюция", "Evolution timeline": "Хронология эволюции", "Executable": "Исполнимо", "Execution checklist": "Чек-лист исполнения", "Extracted from this session's tool/file output (not model-generated).": "Извлечено из вывода инструментов/файлов этой сессии (не сгенерировано моделью).", "Failures": "Сбои", "Fiber": "Файбер", "Fiber state changes since the previous cycle, including load retries.": "Изменения состояния fiber с предыдущего цикла, включая повторные загрузки.", "Finance lens": "Финансовый ракурс", "Follow-ups": "Продолжения", "Framework change": "Изменение фреймворка", "Framework changes as they happened, from runtime probes.": "Изменения фреймворка в момент их появления, от рантайм-зондов.", "Framework evolution": "Эволюция фреймворка", "Framework size and how much of the evolution pipeline shows runtime evidence.": "Размер фреймворка и какая часть конвейера эволюции показывает свидетельства времени выполнения.", "From": "Из", "Frozen plugins": "Замороженные плагины", "Gap closure": "Закрытие пробела", "Halt": "Останов", "How closures are verified": "Как проверяются закрытия", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "Какая часть сигнала об эффекте пригодна как обратная связь. Это определяет, стоит ли строить обучающую политику.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "Какую часть фреймворка он вырастил сам и какая часть конвейера показывает данные времени выполнения.", "How often each window sat inside, near, or outside its declared limits": "Как часто каждое окно было внутри, у границы или вне объявленных пределов", "Inquiry brief": "Сводка исследования", "Insights carded as evidence, capped for fast review.": "Инсайты как карточки-обоснования, ограничены для быстрого просмотра.", "Instruments & counterparties": "Инструменты и контрагенты", "Kept": "Оставлен", "Latest capability decision": "Последнее решение о возможностях", "Lifecycle records": "Записи жизненного цикла", "Lifecycle timeline": "Хронология жизненного цикла", "Lifecycle transitions": "Переходы жизненного цикла", "Line of inquiry": "Линия исследования", "Live activity": "Текущая активность", "Location": "Расположение", "Loop phase": "Фаза цикла", "Mean of each downsample window. Declared limits are listed per channel below.": "Среднее по каждому окну прореживания. Объявленные пределы указаны по каналам ниже.", "Model's reasoning": "Обоснование модели", "Mutation": "Изменение", "Narrative": "Сюжет", "Narrative pulse": "Нарративный пульс", "Needs attention": "Требует внимания", "Next recal due": "Следующая рекалибровка", "Next step": "Следующий шаг", "No causal history yet": "Причинной истории пока нет", "Normalized error": "Нормированная ошибка", "Normalized error is the residual as a share of the channel's declared span.": "Нормированная ошибка — остаток как доля объявленного диапазона канала.", "Not yet observed": "Ещё не наблюдалось", "Nothing has driven a framework change, so there is no episode to narrate.": "Ничто пока не вызвало изменения фреймворка, поэтому рассказывать не о чем.", "OHLC extracted from captured session market data.": "OHLC извлечён из рыночных данных, записанных в сессии.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "Очередь наблюдений, состояние предложений, решения политики и итоги жизненного цикла.", "Observations": "Наблюдения", "Observed Hz": "Наблюд. Гц", "Observed rate against declared rate": "Наблюдаемая частота против объявленной", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "Единое глобальное пространство имён, арбитраж по первому пришедшему. Претендент записывается, а не отбрасывается молча.", "Open": "Открыт", "Open risks": "Открытые риски", "Open/high/low/close from captured tool output.": "Открытие/максимум/минимум/закрытие из записанного вывода инструментов.", "Origin": "Источник", "Outcome": "Результат", "PRODUCTION": "Продакшн", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "По эпизодам: триггер, решение, изменение и закрылся ли пробел.", "Per-channel calibration state, freshness, and residual correction": "Состояние калибровки, актуальность и остаточная поправка по каналам", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "Свидетельства времени выполнения по сегментам. Наличие модуля не доказывает, что его кто-то вызывает.", "Pipeline": "Конвейер", "Pipeline evidence": "Свидетельства конвейера", "Pipeline reachability": "Достижимость конвейера", "Plan": "План", "Plan steps": "Шаги плана", "Plugin": "Плагин", "Plugin roster and trust": "Реестр плагинов и доверие", "Plugins": "Плагины", "Plugins by origin": "Плагины по происхождению", "Plugins by trust class": "Плагины по классу доверия", "Policy": "Политика", "Policy decisions": "Решения политики", "Positions & actions": "Позиции и действия", "Posture": "Состояние", "Price action": "Ценовое движение", "Proposal": "Предложение", "Proposal status": "Статус предложения", "Proposed, not admitted": "Предложено, не принято", "Pulse": "Пульс", "Quarantine feed": "Поток карантина", "Ratio": "Отношение", "Read live from the registry and trust ledger every cycle.": "Читается напрямую из реестра и журнала доверия каждый цикл.", "Recent episodes": "Недавние эпизоды", "Reclaim candidates": "Кандидаты на утилизацию", "Reclaimable": "Утилизируемо", "References & follow-ups": "Ссылки и продолжения", "References (entities)": "Ссылки (сущности)", "Registry": "Реестр", "Registry delta": "Изменение реестра", "Registry version": "Версия реестра", "Regressions": "Регрессии", "Rejected": "Отклонён", "Representative observations, capped for quick scanning.": "Показательные наблюдения, ограничены для быстрого просмотра.", "Requirements": "Требования", "Research lens": "Исследовательский ракурс", "Residual": "Остаток", "Reward signal bandwidth": "Пропускная способность сигнала вознаграждения", "Runtime evidence": "Свидетельство времени выполнения", "Sampled history per channel, newest on the right": "История выборок по каналам, самое новое справа", "Segment": "Сегмент", "Segments by status": "Сегменты по статусу", "Selectable": "Выбираемый", "Selection delta": "Изменение выбора", "Self-acquired": "Самостоятельно получено", "Self-acquired plugins that are registered but unselectable or never once used.": "Самостоятельно полученные плагины, которые зарегистрированы, но невыбираемы или ни разу не использовались.", "Sentiment lens": "Ракурс тональности", "Series": "Серия", "Session analysis": "Анализ сессии", "Signal strength": "Сила сигнала", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "Признаки того, что что-то выросло неверно или было задержано. Показываются независимо от открытой вкладки.", "Skipped slots": "Пропущенные слоты", "State": "Состояние", "Storyline and signal strength before drilling into positions and actions.": "Сюжет и сила сигнала до перехода к позициям и действиям.", "Streaming": "Потоковая передача", "Suggested next steps": "Рекомендуемые следующие шаги", "The line of investigation and where the open questions concentrate.": "Линия исследования и где сосредоточены открытые вопросы.", "The narrative arc and how strongly themes are trending.": "Нарративная дуга и насколько сильно растут темы.", "The world model asked for these capabilities and nothing took them up.": "Модель мира запросила эти возможности, и никто их не принял.", "Theme intensity": "Интенсивность тем", "Themes": "Темы", "This board reports how the framework changes itself. Nothing has been recorded yet.": "Эта панель сообщает, как фреймворк изменяет сам себя. Пока ничего не записано.", "To": "В", "Tool": "Инструмент", "Tool-name conflicts": "Конфликты имён инструментов", "Tools": "Инструменты", "Transport": "Транспорт", "Transport, provenance and channel counts": "Транспорт, происхождение и число каналов", "Trust": "Доверие", "Trust accrual": "Накопление доверия", "Trust class": "Класс доверия", "Unselectable reclamation": "Утилизация невыбираемого", "Usable": "Пригодно", "VERIFIED": "Проверено", "Verdicts": "Заключений", "Verdicts by reason": "Заключения по причине", "Verified": "Проверено", "Verified by": "Подтверждено", "Voices & concerns": "Голоса и опасения", "Watchlist": "Список наблюдения", "What changed in the environment, and what the framework did about it.": "Что изменилось в окружении и что фреймворк с этим сделал.", "Which plugin owns which tool, and which capability that tool provides.": "Какой плагин владеет каким инструментом и какую возможность этот инструмент предоставляет.", "Who/what is in the conversation, and the concerns still open.": "Кто/что в разговоре и какие опасения остаются.", "Why": "Почему", "Why not admitted": "Причина отклонения", "Why this page is empty": "Почему эта страница пуста", "World-model driver": "Драйвер модели мира", "Writable": "Записываемый", "aborted": "Прервано", "accruing": "Накапливается", "active": "Активно", "appeared": "Появился", "armed": "Активно", "assess_compatibility": "Оценка совместимости", "built_in": "Встроенный", "capability_expand": "Расширение возможностей", "committed": "Завершено", "conformance": "Соответствие", "declared_fitness": "Заявленная пригодность", "disable": "Отключение", "disposed": "Освобождено", "effect_observed": "Эффект наблюдался", "environment_probe": "Зонд окружения", "execution_failed": "Сбой выполнения", "expected_effect_absent": "Ожидаемый эффект отсутствует", "failed": "Сбой", "frozen": "Заморожено", "gone": "Исчез", "idle": "Простой", "install": "Установка", "loading": "Загрузка", "manual": "Вручную", "moved": "Перешёл", "new_unproven": "Новое, непроверенное", "no": "Нет", "no_evidence": "Нет данных", "no_expected_effect_declared": "Ожидаемый эффект не заявлен", "no_outcome_observed": "Результат не наблюдался", "none": "Нет", "not_admitted": "Не принято", "not_applicable": "Неприменимо", "observe_only": "Только наблюдение", "observed_effect": "Наблюдаемый эффект", "open": "Открыто", "pending": "Ожидает", "reload": "Перезагрузка", "remove": "Удаление", "reopened": "Возобновлено", "resolved": "Закрыто", "rollback": "Откат", "runtime": "Среда выполнения", "self_acquired": "Самостоятельно получено", "still_open": "Всё ещё открыто", "tool_reported_no_effect": "Инструмент не сообщил об эффекте", "trusted": "Доверенное", "unknown": "Неизвестно", "unknown_tool": "Неизвестный инструмент", "unloading": "Выгрузка", "unscheduled": "Не запланировано", "unverifiable": "Не проверяемо", "unverified": "Непроверенное", "waiting": "Ожидание", "watching": "Наблюдает", "wired": "Подключено", "world_model": "Модель мира", "yes": "Да", "Causal trace": "Причинная трасса", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "Доказательства только для чтения от окружения к управлению для одного снимка эволюции фреймворка.", "Evidence boundary": "Граница доказательств", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "Причинная трасса показывает записанные факты и не выводит отсутствующее согласование или наблюдаемый эффект.", "Episodes": "Эпизоды", "Declared-fitness closures": "Закрытия по заявленной пригодности", "Counterfactual / mutation matrix": "Контрфактическая матрица / мутации", "Each row preserves the driver, decision, registry delta, and verification tier.": "Каждая строка сохраняет триггер, решение, изменение реестра и уровень проверки.", "Trigger": "Триггер", "Evidence tier": "Уровень доказательств", "Episode timeline": "Хронология эпизодов", "Rebuilt from existing decision and observation records.": "Восстановлена из существующих записей решений и наблюдений.", "Durable trace feed": "Поток долговечных трасс", "Rejected and no-op decisions remain visible when their trace sink is installed.": "Отклонённые решения и решения без действия остаются видимыми, когда установлен их приёмник трасс.", "Lifecycle": "Жизненный цикл", "Pipeline evidence over time": "Свидетельства конвейера во времени", "One point per recorded change in framework state, oldest first.": "Одна точка на каждое зафиксированное изменение состояния фреймворка, старшие слева.", "Samples": "Выборки", "Net change": "Итоговое изменение"}
+    zh: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **尚未记录任何效果判定**，因此没有可度量的奖励信号。上面的比率有意留空而非显示 0%。只有当需求声明了预期效果才可能验证，而目前只有世界模型撰写的需求带有预期效果。", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **回归：已闭合的缺口再次复发。** 一次看起来成功的演进并未站住。这是本看板上唯一需要立即处理的发现。", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **仅快照。** 目前尚无可重建的因果历史，因此时间线是「缺席」而非「空白」。原因由管道贯通度中的 `策略决策` 一行说明；实时快照与贯通度表本身不受影响。", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **部分插件因内部缺陷被冻结。** 冻结的插件仍报告 `DRAFT`，而信任维度只做「打分」，因此若未同时注销，它仍可被选中——请查看 `可被选中` 列。", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **验证层级：L2（声明式适配）。** 观测被退役，只意味着某个候选**声明**自己提供该能力，并不意味着该能力被观测到确实生效。效果验证（L3）尚未接线，因此本看板上的任何闭合都不应被读作「已证实」。", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> 需要至少完成一个观测周期才会有内容。若持续为空，请检查调度器是否启用、`framework-evolution` watch 是否已 armed 且未静音。", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> 当一次环境观测导向一次能力决策时，才会写下一条剧集。目前尚无记录——这既可能是系统本就安静，也可能是管道更早就断了：**管道**页签会指出它断在哪一段，以及什么能解除阻塞。", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> 目前没有任何机制自动回收它们。每一个都占着一个工具名、出现在能力列表里，却不可被选中——注册表朝着没有任何需求能用的方向增长。", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> 这些提议未进入任何管道，因此不会出现在任何决策记录或观测中。是否准入是一项配置选择。", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "比值低于 1.0 表示采样循环未能维持其声明的节奏。", "Abstained": "弃权", "Acquisition authority": "获取授权", "Acquisition lifecycle": "获取生命周期", "Action": "动作", "After": "变更后", "An unverified declaration has its writable channels demoted to read-only.": "未核验的声明，其可写通道会被降级为只读。", "Approval": "审批", "Autonomous governance": "自主治理", "Autonomy": "自主级别", "Before": "变更前", "CANDIDATE": "候选级", "Calibrated at": "校准时间", "Calibration health": "校准健康度", "Calls": "调用次数", "Calls (decisions)": "观点（决策）", "Candlestick": "K 线", "Capability": "能力", "Capability adaptation": "能力适配", "Capability observations": "能力观测", "Capability ownership": "能力归属", "Capability topology": "能力拓扑", "Change": "变化", "Channel": "通道", "Channels": "通道数", "Channels that have never been calibrated or whose calibration has expired are shown first.": "从未校准或校准已过期的通道排在最前。", "Command": "命令", "Commanded versus observed, best tracking first": "命令值与实测值对比，跟随最好者在前", "Composition": "组成", "Concerns (open questions)": "关切（待答问题）", "Confidence": "置信度", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "统计所有绘制通道。“接近”指处于声明边界的 5% 以内。", "Cycles run": "已运行周期", "DRAFT": "草稿级", "Days since": "距今天数", "Decision": "决策", "Decisions read as calls; action items as the execution checklist.": "决策即观点，行动项即执行清单。", "Declared Hz": "声明频率 (Hz)", "Desk brief": "交易台简报", "Device": "设备", "Dropped samples": "丢弃的样本", "Each row names one blocked segment and the change that would unblock it.": "每一行指出一个受阻环节，以及能解除阻塞的那项变更。", "Effect verification (L3)": "效果验证（L3）", "Effects declared": "已声明效果", "Entities as references, and recommended next prompts to advance the work.": "实体作为参考，并给出推进工作的后续追问。", "Entities in play and the open risks still to resolve.": "涉及的实体，以及尚未解决的敞口风险。", "Envelope, rate, staleness and quality observations · newest first": "包络、速率、失联与质量观测 · 最新在前", "Environment": "环境", "Environment to framework": "环境 → 框架", "Environment, selected plugin tools, and orchestration order.": "环境、已选插件工具及编排顺序。", "Error rate": "错误率", "Events paced out": "被配速抑制的事件", "Ever used": "是否用过", "Evidence": "证据", "Evidence admission": "证据准入", "Evolution": "演进", "Evolution timeline": "演进时间线", "Executable": "可执行", "Execution checklist": "执行清单", "Extracted from this session's tool/file output (not model-generated).": "数据来自本次会话的工具/文件产物（非模型生成）。", "Failures": "失败次数", "Fiber": "Fiber 状态", "Fiber state changes since the previous cycle, including load retries.": "自上一周期以来的 Fiber 状态变化，含加载重试。", "Finance lens": "金融视图", "Follow-ups": "后续事项", "Framework change": "框架变更", "Framework changes as they happened, from runtime probes.": "来自运行时探针的框架变更实况。", "Framework evolution": "框架演进", "Framework size and how much of the evolution pipeline shows runtime evidence.": "框架规模，以及演进管道中有多少环节呈现运行时证据。", "From": "从", "Frozen plugins": "已冻结插件", "Gap closure": "缺口闭合", "Halt": "可急停", "How closures are verified": "闭合是如何验证的", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "效果信号中有多少可真正用作反馈。这决定了是否值得构建学习策略。", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "框架中有多少是它自己长出来的，以及演进管道中有多少环节呈现运行时证据。", "How often each window sat inside, near, or outside its declared limits": "各窗口处于声明限值内、接近边界或越界的频次", "Inquiry brief": "研究简报", "Insights carded as evidence, capped for fast review.": "洞察以证据卡呈现，数量受限以便快速浏览。", "Instruments & counterparties": "标的与交易对手", "Kept": "保留", "Latest capability decision": "最新能力决策", "Lifecycle records": "生命周期记录", "Lifecycle timeline": "生命周期时间线", "Lifecycle transitions": "生命周期迁移", "Line of inquiry": "研究主线", "Live activity": "实时动态", "Location": "位置", "Loop phase": "循环阶段", "Mean of each downsample window. Declared limits are listed per channel below.": "每个降采样窗口的均值。各通道的声明限值见下方。", "Model's reasoning": "模型的推理", "Mutation": "变更", "Narrative": "叙事", "Narrative pulse": "叙事脉搏", "Needs attention": "需要关注", "Next recal due": "下次校准期限", "Next step": "下一步", "No causal history yet": "尚无因果历史", "Normalized error": "归一化误差", "Normalized error is the residual as a share of the channel's declared span.": "归一化误差是残差占该通道声明量程的比例。", "Not yet observed": "尚未观测", "Nothing has driven a framework change, so there is no episode to narrate.": "尚无任何事驱动过框架变更，因此没有可讲述的剧集。", "OHLC extracted from captured session market data.": "OHLC 提取自本次会话捕获的行情数据。", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "观测待办、提案状态、策略决策与生命周期结果。", "Observations": "观测数", "Observed Hz": "实测频率 (Hz)", "Observed rate against declared rate": "实测速率与声明速率对比", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "单一全局命名空间，先注册者胜。挑战者会被记录，绝不静默丢弃。", "Open": "已连接", "Open risks": "敞口风险", "Open/high/low/close from captured tool output.": "开/高/低/收，来自捕获的工具输出。", "Origin": "来源", "Outcome": "结果", "PRODUCTION": "生产级", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "逐条剧集：触发源、决策、变更，以及缺口是否闭合。", "Per-channel calibration state, freshness, and residual correction": "各通道的校准状态、时效性与残差校正", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "逐段运行时证据。模块存在并不等于有任何代码调用它。", "Pipeline": "管道", "Pipeline evidence": "管道证据", "Pipeline reachability": "管道贯通度", "Plan": "计划", "Plan steps": "计划步骤", "Plugin": "插件", "Plugin roster and maturity": "插件名册与成熟度", "Plugins": "插件数", "Plugins by origin": "按来源分布的插件", "Plugins by maturity": "按成熟度分布的插件", "Policy": "策略", "Policy decisions": "策略决策", "Positions & actions": "持仓与操作", "Posture": "态势", "Price action": "价格行为", "Proposal": "提案", "Proposal status": "提案状态", "Proposed, not admitted": "已提议，未准入", "Pulse": "脉搏", "Quarantine feed": "隔离进料", "Ratio": "比值", "Read live from the registry and maturity ledger every cycle.": "每个周期从注册表与成熟度账本实时读取。", "Recent episodes": "近期剧集", "Reclaim candidates": "可回收候选", "Reclaimable": "可回收", "References & follow-ups": "参考与后续", "References (entities)": "参考（实体）", "Registry": "注册表", "Registry delta": "注册表变化", "Registry version": "注册表版本", "Regressions": "回归", "Rejected": "被拒", "Representative observations, capped for quick scanning.": "代表性观察，数量受限以便快速浏览。", "Requirements": "能力需求", "Research lens": "研究视图", "Residual": "残差", "Reward signal bandwidth": "奖励信号带宽", "Runtime evidence": "运行时证据", "Sampled history per channel, newest on the right": "按通道的采样历史，最新在右侧", "Segment": "管道段", "Segments by status": "按状态分布的管道段", "Selectable": "可被选中", "Selection delta": "选择变化", "Self-acquired": "自获取", "Self-acquired plugins that are registered but unselectable or never once used.": "已注册但不可被选中、或从未被使用过的自获取插件。", "Sentiment lens": "情绪视图", "Series": "序列", "Session analysis": "会话分析", "Signal strength": "信号强度", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "表明某处长错了、或被扣下未放行的信号。无论打开哪个页签都会显示。", "Skipped slots": "跳过的采样点", "State": "状态", "Storyline and signal strength before drilling into positions and actions.": "先看叙事与信号强度，再深入持仓与操作。", "Streaming": "采样中", "Suggested next steps": "建议的下一步", "The line of investigation and where the open questions concentrate.": "研究主线，以及待答问题的集中之处。", "The narrative arc and how strongly themes are trending.": "叙事走向，以及主题的趋势强度。", "The world model asked for these capabilities and nothing took them up.": "世界模型请求了这些能力，但无人受理。", "Theme intensity": "主题强度", "Themes": "主题", "This board reports how the framework changes itself. Nothing has been recorded yet.": "本看板报告框架如何改变自身。目前尚无任何记录。", "To": "到", "Tool": "工具", "Tool-name conflicts": "工具名冲突", "Tools": "工具数", "Transport": "传输方式", "Transport, provenance and channel counts": "传输方式、来源与通道数量", "Maturity": "成熟度", "Maturity accrual": "成熟度累积", "Maturity class": "成熟度", "Unselectable reclamation": "不可选回收", "Usable": "可用", "VERIFIED": "已验证级", "Verdicts": "判定数", "Verdicts by reason": "按原因分布的判定", "Verified": "已核验", "Verified by": "验证依据", "Voices & concerns": "声音与关切", "Watchlist": "关注列表", "What changed in the environment, and what the framework did about it.": "环境发生了什么变化，框架又为此做了什么。", "Which plugin owns which tool, and which capability that tool provides.": "哪个插件拥有哪个工具，以及该工具提供什么能力。", "Who/what is in the conversation, and the concerns still open.": "谁/什么在被讨论，以及尚未解决的关切。", "Why": "原因", "Why not admitted": "未准入原因", "Why this page is empty": "这个页面为何是空的", "World-model driver": "世界模型驱动器", "Writable": "可写", "aborted": "已中断", "accruing": "正在累积", "active": "运行中", "appeared": "新出现", "armed": "已就绪", "assess_compatibility": "评估兼容性", "built_in": "内置", "capability_expand": "扩展能力", "committed": "已定论", "conformance": "合规", "declared_fitness": "声明式适配", "disable": "停用", "disposed": "已释放", "effect_observed": "效果已观测", "environment_probe": "环境探测", "execution_failed": "执行失败", "expected_effect_absent": "预期效果未出现", "failed": "已失败", "frozen": "已冻结", "gone": "已消失", "idle": "空闲无变化", "install": "安装", "loading": "加载中", "manual": "人工", "moved": "已迁移", "new_unproven": "新，未验证", "no": "否", "no_evidence": "无证据", "no_expected_effect_declared": "未声明预期效果", "no_outcome_observed": "未观测到结果", "none": "无", "not_admitted": "未准入", "not_applicable": "不适用", "observe_only": "仅观察", "observed_effect": "观测效果", "open": "进行中", "pending": "待启", "reload": "重载", "remove": "移除", "reopened": "已复发", "resolved": "已闭合", "rollback": "回滚", "runtime": "运行时", "self_acquired": "自获取", "still_open": "仍未闭合", "tool_reported_no_effect": "工具未报告效果", "trusted": "已信任", "unknown": "未知", "unknown_tool": "未知工具", "unloading": "卸载中", "unscheduled": "未调度", "unverifiable": "无法核实", "unverified": "未验证", "waiting": "等待首个周期", "watching": "监视中", "wired": "已贯通", "world_model": "世界模型", "yes": "是", "Causal trace": "因果追踪", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "单个框架演进快照的只读环境到治理证据。", "Evidence boundary": "证据边界", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "因果追踪展示已记录的事实；不推断缺失的审批或已观测效果。", "Episodes": "剧集", "Declared-fitness closures": "声明式适配闭合", "Counterfactual / mutation matrix": "反事实 / 变更矩阵", "Each row preserves the driver, decision, registry delta, and verification tier.": "每一行保留驱动因素、决策、注册表变化和验证层级。", "Trigger": "触发源", "Evidence tier": "证据层级", "Episode timeline": "剧集时间线", "Rebuilt from existing decision and observation records.": "从现有决策和观测记录重建。", "Durable trace feed": "持久追踪流", "Rejected and no-op decisions remain visible when their trace sink is installed.": "安装追踪接收器后，被拒绝和无操作决策仍保持可见。", "Lifecycle": "生命周期", "Pipeline evidence over time": "管道证据随时间变化", "One point per recorded change in framework state, oldest first.": "每一个点对应一次已记录的框架状态变化，最旧在左。", "Samples": "样本数", "Net change": "净变化"},
+    fr: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **Aucun verdict d'effet n'a encore été enregistré**, il n'y a donc aucun signal de récompense à mesurer. Les taux ci-dessus sont volontairement vides plutôt que nuls. Un effet ne peut être vérifié que si l'exigence en a déclaré un, et seules les exigences rédigées par le modèle du monde en portent aujourd'hui.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **Régression : un écart comblé s'est reproduit.** Une évolution qui semblait réussie n'a pas tenu. C'est le seul constat de ce tableau qui exige une attention immédiate.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **Instantané seulement.** Aucun historique causal à reconstruire pour l'instant : la chronologie est absente, non vide. La raison est indiquée par la ligne `Décisions de politique` sous la couverture du pipeline ; l'instantané et le tableau de couverture ne sont pas affectés.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **Certains plugins sont gelés par un défaut interne.** Un plugin gelé signale toujours `DRAFT`, et la dimension de confiance ne fait que *noter*, donc il reste sélectionnable tant qu'il n'est pas également désenregistré — voir la colonne `Sélectionnable`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **Niveau de vérification : L2 (aptitude déclarée).** Une observation retirée signifie qu'un candidat a *déclaré* fournir la capacité, non que la capacité a été observée en fonctionnement. La vérification d'effet (L3) n'est pas câblée, donc aucune clôture de ce tableau ne doit être lue comme prouvée.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> Un cycle d'observation doit s'achever avant qu'il y ait quoi que ce soit à montrer. Si cela persiste, vérifiez que le planificateur est actif et que la surveillance `framework-evolution` est armée et non silencée.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> Un épisode est écrit lorsqu'une observation de l'environnement conduit à une décision de capacité. Aucun n'a été enregistré : soit le système est calme, soit le pipeline s'arrête plus tôt — l'onglet **Pipeline** nomme le segment où il s'arrête et ce qui le débloquerait.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> Rien ne les récupère automatiquement. Chacun occupe un nom d'outil et figure dans la liste des capacités sans être sélectionnable : le registre grandit dans une direction qu'aucune exigence ne peut utiliser.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> Ces propositions n'ont intégré aucun pipeline : elles n'apparaissent donc dans aucun enregistrement de décision ni observation. Les admettre est un choix de configuration.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "Un ratio inférieur à 1,0 signifie que la boucle d’échantillonnage ne tient pas sa cadence déclarée.", "Abstained": "Abstention", "Acquisition authority": "Autorité d'acquisition", "Acquisition lifecycle": "Cycle de vie d'acquisition", "Action": "Action", "After": "Après", "An unverified declaration has its writable channels demoted to read-only.": "Une déclaration non vérifiée voit ses canaux inscriptibles rétrogradés en lecture seule.", "Approval": "Approbation", "Autonomous governance": "Gouvernance autonome", "Autonomy": "Autonomie", "Before": "Avant", "CANDIDATE": "Candidat", "Calibrated at": "Calibré le", "Calibration health": "État de calibration", "Calls": "Appels", "Calls (decisions)": "Recommandations (décisions)", "Candlestick": "Chandeliers", "Capability": "Capacité", "Capability adaptation": "Adaptation des capacités", "Capability observations": "Observations de capacités", "Capability ownership": "Propriété des capacités", "Capability topology": "Topologie des capacités", "Change": "Changement", "Channel": "Canal", "Channels": "Canaux", "Channels that have never been calibrated or whose calibration has expired are shown first.": "Les canaux jamais calibrés ou dont la calibration a expiré apparaissent en premier.", "Command": "Commande", "Commanded versus observed, best tracking first": "Commandé contre observé, meilleur suivi d’abord", "Composition": "Composition", "Concerns (open questions)": "Préoccupations (questions ouvertes)", "Confidence": "Confiance", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "Compté sur tous les canaux tracés. « près » signifie à moins de 5 % d’une borne déclarée.", "Cycles run": "Cycles exécutés", "DRAFT": "Brouillon", "Days since": "Jours écoulés", "Decision": "Décision", "Decisions read as calls; action items as the execution checklist.": "Les décisions se lisent comme des recommandations ; les actions comme la liste d’exécution.", "Declared Hz": "Hz déclarés", "Desk brief": "Note de desk", "Device": "Appareil", "Dropped samples": "Échantillons perdus", "Each row names one blocked segment and the change that would unblock it.": "Chaque ligne nomme un segment bloqué et le changement qui le débloquerait.", "Effect verification (L3)": "Vérification d'effet (L3)", "Effects declared": "Effets déclarés", "Entities as references, and recommended next prompts to advance the work.": "Entités comme références, et invites suivantes recommandées pour avancer.", "Entities in play and the open risks still to resolve.": "Entités concernées et risques ouverts à résoudre.", "Envelope, rate, staleness and quality observations · newest first": "Observations d’enveloppe, de débit, d’obsolescence et de qualité · les plus récentes d’abord", "Environment": "Environnement", "Environment to framework": "De l'environnement au framework", "Environment, selected plugin tools, and orchestration order.": "Environnement, outils de plugin sélectionnés et ordre d’orchestration.", "Error rate": "Taux d'erreur", "Events paced out": "Événements limités", "Ever used": "Déjà utilisé", "Evidence": "Preuve", "Evidence admission": "Admission des preuves", "Evolution": "Évolution", "Evolution timeline": "Chronologie de l'évolution", "Executable": "Exécutable", "Execution checklist": "Liste d’exécution", "Extracted from this session's tool/file output (not model-generated).": "Extrait des sorties d’outils/fichiers de cette session (non généré par le modèle).", "Failures": "Échecs", "Fiber": "Fibre", "Fiber state changes since the previous cycle, including load retries.": "Changements d'état de fiber depuis le cycle précédent, y compris les tentatives de chargement.", "Finance lens": "Vue finance", "Follow-ups": "Suivis", "Framework change": "Changement du framework", "Framework changes as they happened, from runtime probes.": "Changements du framework en temps réel, via les sondes d'exécution.", "Framework evolution": "Évolution du framework", "Framework size and how much of the evolution pipeline shows runtime evidence.": "Taille du framework et part du pipeline d'évolution qui présente des preuves d'exécution.", "From": "De", "Frozen plugins": "Plugins gelés", "Gap closure": "Clôture de l'écart", "Halt": "Arrêt", "How closures are verified": "Comment les clôtures sont vérifiées", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "Quelle part du signal d'effet est exploitable comme rétroaction. C'est ce qui détermine s'il vaut la peine de construire une politique d'apprentissage.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "Quelle part du framework il a fait croître lui-même, et quelle part du pipeline présente des preuves d'exécution.", "How often each window sat inside, near, or outside its declared limits": "Fréquence à laquelle chaque fenêtre était dans, près de, ou hors de ses limites déclarées", "Inquiry brief": "Note d’enquête", "Insights carded as evidence, capped for fast review.": "Analyses présentées comme preuves, limitées pour une revue rapide.", "Instruments & counterparties": "Instruments et contreparties", "Kept": "Conservé", "Latest capability decision": "Dernière décision de capacité", "Lifecycle records": "Enregistrements de cycle de vie", "Lifecycle timeline": "Chronologie du cycle de vie", "Lifecycle transitions": "Transitions de cycle de vie", "Line of inquiry": "Ligne d’enquête", "Live activity": "Activité en direct", "Location": "Emplacement", "Loop phase": "Phase de boucle", "Mean of each downsample window. Declared limits are listed per channel below.": "Moyenne de chaque fenêtre de sous-échantillonnage. Les limites déclarées figurent par canal ci-dessous.", "Model's reasoning": "Raisonnement du modèle", "Mutation": "Mutation", "Narrative": "Récit", "Narrative pulse": "Pouls narratif", "Needs attention": "Requiert attention", "Next recal due": "Prochaine recalibration", "Next step": "Étape suivante", "No causal history yet": "Pas encore d'historique causal", "Normalized error": "Erreur normalisée", "Normalized error is the residual as a share of the channel's declared span.": "L’erreur normalisée est le résidu en proportion de l’étendue déclarée du canal.", "Not yet observed": "Pas encore observé", "Nothing has driven a framework change, so there is no episode to narrate.": "Rien n'a encore déclenché de changement du framework : il n'y a donc aucun épisode à raconter.", "OHLC extracted from captured session market data.": "OHLC extrait des données de marché capturées durant la session.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "File d’observations, état des propositions, décisions de politique et résultats du cycle de vie.", "Observations": "Observations", "Observed Hz": "Hz observés", "Observed rate against declared rate": "Débit observé par rapport au débit déclaré", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "Un espace de noms global unique, arbitré au premier arrivé. Le concurrent est enregistré, jamais supprimé en silence.", "Open": "Ouvert", "Open risks": "Risques ouverts", "Open/high/low/close from captured tool output.": "Ouverture/haut/bas/clôture issus des sorties d’outils capturées.", "Origin": "Origine", "Outcome": "Résultat", "PRODUCTION": "Production", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "Par épisode : le déclencheur, la décision, le changement, et si l'écart a été comblé.", "Per-channel calibration state, freshness, and residual correction": "État de calibration, fraîcheur et correction résiduelle par canal", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "Preuves d'exécution par segment. L'existence d'un module ne prouve pas qu'il soit appelé.", "Pipeline": "Pipeline", "Pipeline evidence": "Preuves du pipeline", "Pipeline reachability": "Accessibilité du pipeline", "Plan": "Plan", "Plan steps": "Étapes du plan", "Plugin": "Plugin", "Plugin roster and maturity": "Registre des plugins et maturité", "Plugins": "Plugins", "Plugins by origin": "Plugins par origine", "Plugins by maturity": "Plugins par maturité", "Policy": "Politique", "Policy decisions": "Décisions de politique", "Positions & actions": "Positions et actions", "Posture": "Posture", "Price action": "Action des prix", "Proposal": "Proposition", "Proposal status": "Statut de la proposition", "Proposed, not admitted": "Proposé, non admis", "Pulse": "Pouls", "Quarantine feed": "Flux de quarantaine", "Ratio": "Ratio", "Read live from the registry and maturity ledger every cycle.": "Lu en direct depuis le registre et le registre de maturité à chaque cycle.", "Recent episodes": "Épisodes récents", "Reclaim candidates": "Candidats à la récupération", "Reclaimable": "Récupérable", "References & follow-ups": "Références et suivis", "References (entities)": "Références (entités)", "Registry": "Registre", "Registry delta": "Delta du registre", "Registry version": "Version du registre", "Regressions": "Régressions", "Rejected": "Rejeté", "Representative observations, capped for quick scanning.": "Observations représentatives, limitées pour une lecture rapide.", "Requirements": "Exigences", "Research lens": "Vue recherche", "Residual": "Résidu", "Reward signal bandwidth": "Bande passante du signal de récompense", "Runtime evidence": "Preuve d'exécution", "Sampled history per channel, newest on the right": "Historique échantillonné par canal, le plus récent à droite", "Segment": "Segment", "Segments by status": "Segments par statut", "Selectable": "Sélectionnable", "Selection delta": "Delta de sélection", "Self-acquired": "Auto-acquis", "Self-acquired plugins that are registered but unselectable or never once used.": "Plugins auto-acquis qui sont enregistrés mais non sélectionnables, ou jamais utilisés une seule fois.", "Sentiment lens": "Vue sentiment", "Series": "Série", "Session analysis": "Analyse de session", "Signal strength": "Force du signal", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "Signaux indiquant qu'une évolution a mal tourné ou a été retenue. Affichés quel que soit l'onglet ouvert.", "Skipped slots": "Créneaux manqués", "State": "État", "Storyline and signal strength before drilling into positions and actions.": "Récit et force du signal avant d’examiner positions et actions.", "Streaming": "Diffusion", "Suggested next steps": "Prochaines étapes suggérées", "The line of investigation and where the open questions concentrate.": "La ligne d’investigation et où se concentrent les questions ouvertes.", "The narrative arc and how strongly themes are trending.": "L’arc narratif et l’intensité des tendances thématiques.", "The world model asked for these capabilities and nothing took them up.": "Le modèle du monde a demandé ces capacités et personne ne les a prises en charge.", "Theme intensity": "Intensité des thèmes", "Themes": "Thèmes", "This board reports how the framework changes itself. Nothing has been recorded yet.": "Ce tableau rend compte de la façon dont le framework se modifie lui-même. Rien n'a encore été enregistré.", "To": "Vers", "Tool": "Outil", "Tool-name conflicts": "Conflits de noms d'outils", "Tools": "Outils", "Transport": "Transport", "Transport, provenance and channel counts": "Transport, provenance et nombre de canaux", "Maturity": "Maturité", "Maturity accrual": "Accumulation de maturité", "Maturity class": "Classe de maturité", "Unselectable reclamation": "Récupération non sélectionnable", "Usable": "Exploitable", "VERIFIED": "Vérifié", "Verdicts": "Verdicts", "Verdicts by reason": "Verdicts par motif", "Verified": "Vérifié", "Verified by": "Vérifié par", "Voices & concerns": "Voix et préoccupations", "Watchlist": "Liste de suivi", "What changed in the environment, and what the framework did about it.": "Ce qui a changé dans l'environnement, et ce que le framework a fait en réponse.", "Which plugin owns which tool, and which capability that tool provides.": "Quel plugin possède quel outil, et quelle capacité cet outil fournit.", "Who/what is in the conversation, and the concerns still open.": "Qui/quoi est dans la conversation, et les préoccupations encore ouvertes.", "Why": "Pourquoi", "Why not admitted": "Motif de non-admission", "Why this page is empty": "Pourquoi cette page est vide", "World-model driver": "Pilote du modèle du monde", "Writable": "Inscriptible", "aborted": "Abandonné", "accruing": "En accumulation", "active": "Actif", "appeared": "Apparu", "armed": "Armé", "assess_compatibility": "Évaluer la compatibilité", "built_in": "Intégré", "capability_expand": "Étendre les capacités", "committed": "Conclu", "conformance": "Conformité", "declared_fitness": "Aptitude déclarée", "disable": "Désactiver", "disposed": "Libéré", "effect_observed": "Effet observé", "environment_probe": "Sonde d'environnement", "execution_failed": "Échec d'exécution", "expected_effect_absent": "Effet attendu absent", "failed": "Échoué", "frozen": "Gelé", "gone": "Disparu", "idle": "Au repos", "install": "Installer", "loading": "Chargement", "manual": "Manuel", "moved": "Déplacé", "new_unproven": "Nouveau, non éprouvé", "no": "Non", "no_evidence": "Aucune preuve", "no_expected_effect_declared": "Aucun effet attendu déclaré", "no_outcome_observed": "Aucun résultat observé", "none": "Aucun", "not_admitted": "Non admis", "not_applicable": "Sans objet", "observe_only": "Observer seulement", "observed_effect": "Effet observé", "open": "Ouvert", "pending": "En attente", "reload": "Recharger", "remove": "Supprimer", "reopened": "Réouvert", "resolved": "Résolu", "rollback": "Annuler", "runtime": "Exécution", "self_acquired": "Auto-acquis", "still_open": "Toujours ouvert", "tool_reported_no_effect": "L'outil n'a signalé aucun effet", "trusted": "De confiance", "unknown": "Inconnu", "unknown_tool": "Outil inconnu", "unloading": "Déchargement", "unscheduled": "Non planifié", "unverifiable": "Invérifiable", "unverified": "Non vérifié", "waiting": "En attente", "watching": "En surveillance", "wired": "Câblé", "world_model": "Modèle du monde", "yes": "Oui", "Causal trace": "Trace causale", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "Preuves en lecture seule reliant l’environnement à la gouvernance pour un instantané d’évolution du framework.", "Evidence boundary": "Limite des preuves", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "Une trace causale montre les faits enregistrés ; elle n’infère ni approbation manquante ni effet observé.", "Episodes": "Épisodes", "Declared-fitness closures": "Clôtures par aptitude déclarée", "Counterfactual / mutation matrix": "Matrice contrefactuelle / mutations", "Each row preserves the driver, decision, registry delta, and verification tier.": "Chaque ligne conserve le déclencheur, la décision, le delta du registre et le niveau de vérification.", "Trigger": "Déclencheur", "Evidence tier": "Niveau de preuve", "Episode timeline": "Chronologie des épisodes", "Rebuilt from existing decision and observation records.": "Reconstruite à partir des enregistrements existants de décision et d’observation.", "Durable trace feed": "Flux de traces durables", "Rejected and no-op decisions remain visible when their trace sink is installed.": "Les décisions rejetées et sans action restent visibles lorsque leur récepteur de traces est installé.", "Lifecycle": "Cycle de vie", "Pipeline evidence over time": "Évolution des preuves du convéoyeur", "One point per recorded change in framework state, oldest first.": "Un point par changement enregistré de l’état du framework, du plus ancien au plus récent.", "Samples": "Échantillons", "Net change": "Variation nette"},
+    es: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **Aún no se ha registrado ningún veredicto de efecto**, por lo que no hay señal de recompensa que medir. Las tasas anteriores están en blanco a propósito, no en cero. Un efecto solo puede verificarse si el requisito declaró uno, y hoy solo los requisitos redactados por el modelo del mundo lo llevan.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **Regresión: una brecha cerrada ha vuelto a aparecer.** Una evolución que parecía exitosa no se sostuvo. Es el único hallazgo de este panel que exige atención inmediata.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **Solo instantánea.** Todavía no hay historia causal que reconstruir, por lo que la cronología está ausente, no vacía. El motivo lo indica la fila `Decisiones de política` bajo la cobertura del pipeline; la instantánea y la tabla de cobertura no se ven afectadas.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **Algunos plugins están congelados por un defecto interno.** Un plugin congelado sigue informando `DRAFT`, y la dimensión de confianza solo *puntúa*, por lo que permanece seleccionable a menos que también se desregistre — consulte la columna `Seleccionable`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **Nivel de verificación: L2 (aptitud declarada).** Una observación retirada significa que un candidato *declaró* que proporciona la capacidad, no que se observara funcionando. La verificación de efecto (L3) no está conectada, así que ningún cierre de este panel debe leerse como probado.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> Debe completarse un ciclo de observación antes de que haya algo que mostrar. Si persiste, compruebe que el planificador está activo y que la vigilancia `framework-evolution` está armada y no silenciada.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> Un episodio se escribe cuando una observación del entorno conduce a una decisión de capacidad. No se ha registrado ninguno: o el sistema está tranquilo o el pipeline se detiene antes — la pestaña **Pipeline** nombra el segmento donde se detiene y qué lo desbloquearía.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> Nada los recupera automáticamente. Cada uno ocupa un nombre de herramienta y aparece en la lista de capacidades sin ser seleccionable: el registro crece en una dirección que ningún requisito puede usar.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> Estas propuestas no entraron en ningún pipeline, por lo que no aparecen en ningún registro de decisión ni observación. Admitirlas es una elección de configuración.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "Una relación inferior a 1,0 significa que el bucle de muestreo no mantiene su cadencia declarada.", "Abstained": "Abstenido", "Acquisition authority": "Autoridad de adquisición", "Acquisition lifecycle": "Ciclo de vida de adquisición", "Action": "Acción", "After": "Después", "An unverified declaration has its writable channels demoted to read-only.": "Una declaración no verificada degrada sus canales escribibles a solo lectura.", "Approval": "Aprobación", "Autonomous governance": "Gobernanza autónoma", "Autonomy": "Autonomía", "Before": "Antes", "CANDIDATE": "Candidato", "Calibrated at": "Calibrado el", "Calibration health": "Estado de calibración", "Calls": "Llamadas", "Calls (decisions)": "Recomendaciones (decisiones)", "Candlestick": "Velas", "Capability": "Capacidad", "Capability adaptation": "Adaptación de capacidades", "Capability observations": "Observaciones de capacidad", "Capability ownership": "Propiedad de capacidades", "Capability topology": "Topología de capacidades", "Change": "Cambio", "Channel": "Canal", "Channels": "Canales", "Channels that have never been calibrated or whose calibration has expired are shown first.": "Los canales nunca calibrados o con calibración vencida se muestran primero.", "Command": "Comando", "Commanded versus observed, best tracking first": "Comandado frente a observado, mejor seguimiento primero", "Composition": "Composición", "Concerns (open questions)": "Inquietudes (preguntas abiertas)", "Confidence": "Confianza", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "Contado en todos los canales graficados. «cerca» significa dentro del 5 % de un límite declarado.", "Cycles run": "Ciclos ejecutados", "DRAFT": "Borrador", "Days since": "Días desde", "Decision": "Decisión", "Decisions read as calls; action items as the execution checklist.": "Las decisiones se leen como recomendaciones; las acciones como la lista de ejecución.", "Declared Hz": "Hz declarados", "Desk brief": "Informe de mesa", "Device": "Dispositivo", "Dropped samples": "Muestras descartadas", "Each row names one blocked segment and the change that would unblock it.": "Cada fila nombra un segmento bloqueado y el cambio que lo desbloquearía.", "Effect verification (L3)": "Verificación de efecto (L3)", "Effects declared": "Efectos declarados", "Entities as references, and recommended next prompts to advance the work.": "Entidades como referencias y siguientes preguntas recomendadas para avanzar.", "Entities in play and the open risks still to resolve.": "Entidades implicadas y riesgos abiertos por resolver.", "Envelope, rate, staleness and quality observations · newest first": "Observaciones de envolvente, tasa, obsolescencia y calidad · las más recientes primero", "Environment": "Entorno", "Environment to framework": "Del entorno al framework", "Environment, selected plugin tools, and orchestration order.": "Entorno, herramientas de plugin seleccionadas y orden de orquestación.", "Error rate": "Tasa de error", "Events paced out": "Eventos limitados", "Ever used": "Alguna vez usado", "Evidence": "Evidencia", "Evidence admission": "Admisión de evidencia", "Evolution": "Evolución", "Evolution timeline": "Cronología de la evolución", "Executable": "Ejecutable", "Execution checklist": "Lista de ejecución", "Extracted from this session's tool/file output (not model-generated).": "Extraído de la salida de herramientas/archivos de esta sesión (no generado por el modelo).", "Failures": "Fallos", "Fiber": "Fibra", "Fiber state changes since the previous cycle, including load retries.": "Cambios de estado de fiber desde el ciclo anterior, incluidos los reintentos de carga.", "Finance lens": "Vista financiera", "Follow-ups": "Seguimientos", "Framework change": "Cambio del framework", "Framework changes as they happened, from runtime probes.": "Cambios del framework en tiempo real, desde sondas de ejecución.", "Framework evolution": "Evolución del framework", "Framework size and how much of the evolution pipeline shows runtime evidence.": "Tamaño del framework y qué parte del pipeline de evolución muestra evidencia en ejecución.", "From": "Desde", "Frozen plugins": "Plugins congelados", "Gap closure": "Cierre de la brecha", "Halt": "Parada", "How closures are verified": "Cómo se verifican los cierres", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "Cuánto de la señal de efecto es utilizable como retroalimentación. Esto decide si vale la pena construir una política de aprendizaje.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "Cuánto del framework hizo crecer por sí mismo y cuánto del pipeline muestra evidencia de ejecución.", "How often each window sat inside, near, or outside its declared limits": "Con qué frecuencia cada ventana estuvo dentro, cerca o fuera de sus límites declarados", "Inquiry brief": "Informe de indagación", "Insights carded as evidence, capped for fast review.": "Hallazgos presentados como evidencia, limitados para revisión rápida.", "Instruments & counterparties": "Instrumentos y contrapartes", "Kept": "Conservado", "Latest capability decision": "Última decisión de capacidad", "Lifecycle records": "Registros de ciclo de vida", "Lifecycle timeline": "Cronología del ciclo de vida", "Lifecycle transitions": "Transiciones de ciclo de vida", "Line of inquiry": "Línea de indagación", "Live activity": "Actividad en vivo", "Location": "Ubicación", "Loop phase": "Fase del bucle", "Mean of each downsample window. Declared limits are listed per channel below.": "Media de cada ventana de submuestreo. Los límites declarados se listan por canal abajo.", "Model's reasoning": "Razonamiento del modelo", "Mutation": "Mutación", "Narrative": "Narrativa", "Narrative pulse": "Pulso narrativo", "Needs attention": "Requiere atención", "Next recal due": "Próxima recalibración", "Next step": "Siguiente paso", "No causal history yet": "Aún no hay historia causal", "Normalized error": "Error normalizado", "Normalized error is the residual as a share of the channel's declared span.": "El error normalizado es el residuo como fracción del rango declarado del canal.", "Not yet observed": "Aún no observado", "Nothing has driven a framework change, so there is no episode to narrate.": "Nada ha impulsado todavía un cambio del framework, por lo que no hay ningún episodio que narrar.", "OHLC extracted from captured session market data.": "OHLC extraído de los datos de mercado capturados en la sesión.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "Cola de observaciones, estado de propuestas, decisiones de política y resultados del ciclo de vida.", "Observations": "Observaciones", "Observed Hz": "Hz observados", "Observed rate against declared rate": "Tasa observada frente a la tasa declarada", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "Un único espacio de nombres global, arbitrado por orden de llegada. El aspirante queda registrado, nunca se descarta en silencio.", "Open": "Abierto", "Open risks": "Riesgos abiertos", "Open/high/low/close from captured tool output.": "Apertura/máximo/mínimo/cierre desde la salida de herramientas capturada.", "Origin": "Origen", "Outcome": "Resultado", "PRODUCTION": "Producción", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "Por episodio: el desencadenante, la decisión, el cambio y si la brecha se cerró.", "Per-channel calibration state, freshness, and residual correction": "Estado de calibración, vigencia y corrección residual por canal", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "Evidencia en ejecución por segmento. Que un módulo exista no prueba que algo lo invoque.", "Pipeline": "Pipeline", "Pipeline evidence": "Evidencia del pipeline", "Pipeline reachability": "Alcanzabilidad del pipeline", "Plan": "Plan", "Plan steps": "Pasos del plan", "Plugin": "Plugin", "Plugin roster and maturity": "Registro de plugins y madurez", "Plugins": "Plugins", "Plugins by origin": "Plugins por origen", "Plugins by maturity": "Plugins por madurez", "Policy": "Política", "Policy decisions": "Decisiones de política", "Positions & actions": "Posiciones y acciones", "Posture": "Postura", "Price action": "Acción del precio", "Proposal": "Propuesta", "Proposal status": "Estado de la propuesta", "Proposed, not admitted": "Propuesto, no admitido", "Pulse": "Pulso", "Quarantine feed": "Entrada de cuarentena", "Ratio": "Relación", "Read live from the registry and maturity ledger every cycle.": "Leído en vivo del registro y del libro de madurez en cada ciclo.", "Recent episodes": "Episodios recientes", "Reclaim candidates": "Candidatos a recuperación", "Reclaimable": "Recuperable", "References & follow-ups": "Referencias y seguimientos", "References (entities)": "Referencias (entidades)", "Registry": "Registro", "Registry delta": "Delta del registro", "Registry version": "Versión del registro", "Regressions": "Regresiones", "Rejected": "Rechazado", "Representative observations, capped for quick scanning.": "Observaciones representativas, limitadas para lectura rápida.", "Requirements": "Requisitos", "Research lens": "Vista de investigación", "Residual": "Residuo", "Reward signal bandwidth": "Ancho de banda de la señal de recompensa", "Runtime evidence": "Evidencia en ejecución", "Sampled history per channel, newest on the right": "Historial muestreado por canal, el más reciente a la derecha", "Segment": "Segmento", "Segments by status": "Segmentos por estado", "Selectable": "Seleccionable", "Selection delta": "Delta de selección", "Self-acquired": "Autoadquirido", "Self-acquired plugins that are registered but unselectable or never once used.": "Plugins autoadquiridos que están registrados pero no son seleccionables, o nunca se han usado.", "Sentiment lens": "Vista de sentimiento", "Series": "Serie", "Session analysis": "Análisis de sesión", "Signal strength": "Fuerza de la señal", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "Señales de que algo creció mal o fue retenido. Se muestran independientemente de la pestaña abierta.", "Skipped slots": "Ranuras omitidas", "State": "Estado", "Storyline and signal strength before drilling into positions and actions.": "Narrativa y fuerza de la señal antes de entrar en posiciones y acciones.", "Streaming": "Transmisión", "Suggested next steps": "Próximos pasos sugeridos", "The line of investigation and where the open questions concentrate.": "La línea de investigación y dónde se concentran las preguntas abiertas.", "The narrative arc and how strongly themes are trending.": "El arco narrativo y con qué fuerza se mueven los temas.", "The world model asked for these capabilities and nothing took them up.": "El modelo del mundo pidió estas capacidades y nada las asumió.", "Theme intensity": "Intensidad temática", "Themes": "Temas", "This board reports how the framework changes itself. Nothing has been recorded yet.": "Este panel informa de cómo el framework se modifica a sí mismo. Todavía no se ha registrado nada.", "To": "Hasta", "Tool": "Herramienta", "Tool-name conflicts": "Conflictos de nombres de herramientas", "Tools": "Herramientas", "Transport": "Transporte", "Transport, provenance and channel counts": "Transporte, procedencia y número de canales", "Maturity": "Madurez", "Maturity accrual": "Acumulación de madurez", "Maturity class": "Clase de madurez", "Unselectable reclamation": "Recuperación no seleccionable", "Usable": "Utilizable", "VERIFIED": "Verificado", "Verdicts": "Veredictos", "Verdicts by reason": "Veredictos por motivo", "Verified": "Verificado", "Verified by": "Verificado por", "Voices & concerns": "Voces e inquietudes", "Watchlist": "Lista de seguimiento", "What changed in the environment, and what the framework did about it.": "Qué cambió en el entorno y qué hizo el framework al respecto.", "Which plugin owns which tool, and which capability that tool provides.": "Qué plugin posee qué herramienta y qué capacidad proporciona esa herramienta.", "Who/what is in the conversation, and the concerns still open.": "Quién/qué está en la conversación y las inquietudes aún abiertas.", "Why": "Por qué", "Why not admitted": "Motivo de no admisión", "Why this page is empty": "Por qué esta página está vacía", "World-model driver": "Controlador del modelo del mundo", "Writable": "Escribible", "aborted": "Abortado", "accruing": "Acumulando", "active": "Activo", "appeared": "Apareció", "armed": "Armado", "assess_compatibility": "Evaluar compatibilidad", "built_in": "Integrado", "capability_expand": "Ampliar capacidad", "committed": "Concluido", "conformance": "Conformidad", "declared_fitness": "Aptitud declarada", "disable": "Desactivar", "disposed": "Liberado", "effect_observed": "Efecto observado", "environment_probe": "Sonda de entorno", "execution_failed": "Ejecución fallida", "expected_effect_absent": "Efecto esperado ausente", "failed": "Fallido", "frozen": "Congelado", "gone": "Desapareció", "idle": "Inactivo", "install": "Instalar", "loading": "Cargando", "manual": "Manual", "moved": "Se movió", "new_unproven": "Nuevo, no probado", "no": "No", "no_evidence": "Sin evidencia", "no_expected_effect_declared": "Sin efecto esperado declarado", "no_outcome_observed": "Sin resultado observado", "none": "Ninguno", "not_admitted": "No admitido", "not_applicable": "No aplicable", "observe_only": "Solo observar", "observed_effect": "Efecto observado", "open": "Abierto", "pending": "Pendiente", "reload": "Recargar", "remove": "Eliminar", "reopened": "Reabierto", "resolved": "Resuelto", "rollback": "Revertir", "runtime": "Tiempo de ejecución", "self_acquired": "Autoadquirido", "still_open": "Aún abierto", "tool_reported_no_effect": "La herramienta no informó efecto", "trusted": "De confianza", "unknown": "Desconocido", "unknown_tool": "Herramienta desconocida", "unloading": "Descargando", "unscheduled": "No planificado", "unverifiable": "No verificable", "unverified": "No verificado", "waiting": "En espera", "watching": "Vigilando", "wired": "Conectado", "world_model": "Modelo del mundo", "yes": "Sí", "Causal trace": "Traza causal", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "Evidencia de solo lectura del entorno a la gobernanza para una instantánea de evolución del framework.", "Evidence boundary": "Límite de evidencia", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "Una traza causal muestra hechos registrados; no infiere aprobación ausente ni efecto observado.", "Episodes": "Episodios", "Declared-fitness closures": "Cierres por aptitud declarada", "Counterfactual / mutation matrix": "Matriz contrafactual / de mutaciones", "Each row preserves the driver, decision, registry delta, and verification tier.": "Cada fila conserva el desencadenante, la decisión, el delta del registro y el nivel de verificación.", "Trigger": "Desencadenante", "Evidence tier": "Nivel de evidencia", "Episode timeline": "Cronología de episodios", "Rebuilt from existing decision and observation records.": "Reconstruida a partir de registros existentes de decisión y observación.", "Durable trace feed": "Flujo de trazas durables", "Rejected and no-op decisions remain visible when their trace sink is installed.": "Las decisiones rechazadas y sin acción permanecen visibles cuando se instala su receptor de trazas.", "Lifecycle": "Ciclo de vida", "Pipeline evidence over time": "Evidencia del canal a lo largo del tiempo", "One point per recorded change in framework state, oldest first.": "Un punto por cada cambio registrado del estado del framework, del más antiguo al más reciente.", "Samples": "Muestras", "Net change": "Cambio neto"},
+    ar: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **لم يُسجَّل أي حكم على الأثر بعد**، لذا لا توجد إشارة مكافأة لقياسها. النسب أعلاه فارغة عن قصد وليست صفرًا. لا يمكن التحقق من الأثر إلا إذا أعلنه المطلب، واليوم لا تحمل الأثر المتوقع سوى المطالب التي كتبها نموذج العالم.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **انحدار: فجوة أُغلقت عادت للظهور.** تطوّر بدا ناجحًا لم يصمد. هذا هو الاكتشاف الوحيد في هذه اللوحة الذي يستدعي انتباهًا فوريًا.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **لقطة فقط.** لا يوجد بعد تاريخ سببي لإعادة بنائه، لذا فالخط الزمني غائب وليس فارغًا. السبب مبيَّن في صف `قرارات السياسة` تحت تغطية المسار؛ اللقطة الحيّة وجدول التغطية غير متأثرين.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **بعض الإضافات مُجمَّدة بسبب خلل داخلي.** الإضافة المُجمَّدة لا تزال تُبلِّغ `DRAFT`، وبُعد الثقة يقوم بالتقييم فقط، لذا تبقى قابلة للاختيار إلا إذا أُلغي تسجيلها أيضًا — راجع عمود `قابل للاختيار`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **مستوى التحقق: L2 (الملاءمة المُعلنة).** سحب الرصد يعني أن مرشّحًا *أعلن* أنه يوفّر القدرة، لا أن القدرة رُصدت وهي تعمل. التحقق من الأثر (L3) غير موصول، لذا لا ينبغي قراءة أي إغلاق في هذه اللوحة كأمر مُثبَت.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> يجب أن تكتمل دورة مراقبة واحدة قبل ظهور أي محتوى. إذا استمر ذلك، تحقّق من تمكين المُجدول وأن مراقبة `framework-evolution` مُسلّحة وغير مكتومة.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> تُكتب الحلقة عندما يؤدي رصد للبيئة إلى قرار بشأن قدرة. لم يُسجَّل أي منها، وهذا يعني إمّا نظامًا هادئًا أو مسارًا يتوقف قبل ذلك — تبويب **المسار** يحدّد الجزء الذي يتوقف عنده وما الذي يزيل التعطيل.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> لا شيء يستعيدها تلقائيًا. كل واحدة تحتجز اسم أداة وتظهر في قائمة القدرات دون أن تكون قابلة للاختيار، فينمو السجل في اتجاه لا يمكن لأي مطلب استخدامه.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> لم تدخل هذه المقترحات أي مسار، لذا لا تظهر في أي سجل قرار أو رصد. قبولها خيار في الإعدادات.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "نسبة أقل من 1.0 تعني أن حلقة أخذ العينات لا تحافظ على وتيرتها المعلنة.", "Abstained": "امتناع", "Acquisition authority": "سلطة الاكتساب", "Acquisition lifecycle": "دورة حياة الاكتساب", "Action": "الإجراء", "After": "بعد", "An unverified declaration has its writable channels demoted to read-only.": "الإعلان غير المُتحقَّق منه تُخفَّض قنواته القابلة للكتابة إلى القراءة فقط.", "Approval": "الموافقة", "Autonomous governance": "الحكم الذاتي", "Autonomy": "الاستقلالية", "Before": "قبل", "CANDIDATE": "مرشّح", "Calibrated at": "تاريخ المعايرة", "Calibration health": "سلامة المعايرة", "Calls": "الاستدعاءات", "Calls (decisions)": "التوصيات (القرارات)", "Candlestick": "الشموع", "Capability": "القدرة", "Capability adaptation": "تكييف القدرات", "Capability observations": "رصد القدرات", "Capability ownership": "ملكية القدرات", "Capability topology": "طوبولوجيا القدرات", "Change": "التغيير", "Channel": "القناة", "Channels": "القنوات", "Channels that have never been calibrated or whose calibration has expired are shown first.": "تظهر أولاً القنوات التي لم تُعاير قط أو التي انتهت صلاحية معايرتها.", "Command": "الأمر", "Commanded versus observed, best tracking first": "المأمور مقابل المرصود، الأفضل تتبعاً أولاً", "Composition": "التركيب", "Concerns (open questions)": "المخاوف (أسئلة مفتوحة)", "Confidence": "الثقة", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "محسوب على كل قناة مرسومة. \"قريب\" تعني داخل 5% من حد معلن.", "Cycles run": "الدورات المنفَّذة", "DRAFT": "مسوّدة", "Days since": "الأيام المنقضية", "Decision": "القرار", "Decisions read as calls; action items as the execution checklist.": "القرارات تُقرأ كتوصيات؛ والإجراءات كقائمة تنفيذ.", "Declared Hz": "الهرتز المعلن", "Desk brief": "موجز المكتب", "Device": "الجهاز", "Dropped samples": "العينات المفقودة", "Each row names one blocked segment and the change that would unblock it.": "كل صف يحدّد جزءًا معطَّلًا والتغيير الذي يزيل التعطيل.", "Effect verification (L3)": "التحقق من الأثر (L3)", "Effects declared": "الآثار المُعلنة", "Entities as references, and recommended next prompts to advance the work.": "الكيانات كمراجع، والمطالبات التالية الموصى بها لدفع العمل.", "Entities in play and the open risks still to resolve.": "الكيانات المعنية والمخاطر المفتوحة التي لم تُحل.", "Envelope, rate, staleness and quality observations · newest first": "رصدات المغلف والمعدل والتقادم والجودة · الأحدث أولاً", "Environment": "البيئة", "Environment to framework": "من البيئة إلى الإطار", "Environment, selected plugin tools, and orchestration order.": "البيئة والأدوات المختارة وترتيب التنسيق.", "Error rate": "معدل الأخطاء", "Events paced out": "الأحداث المُقيَّدة", "Ever used": "استُخدم سابقًا", "Evidence": "الدليل", "Evidence admission": "قبول الأدلة", "Evolution": "التطور", "Evolution timeline": "الخط الزمني للتطور", "Executable": "قابل للتنفيذ", "Execution checklist": "قائمة التنفيذ", "Extracted from this session's tool/file output (not model-generated).": "مستخرج من مخرجات الأدوات/الملفات في هذه الجلسة (ليس من إنشاء النموذج).", "Failures": "الأعطال", "Fiber": "الخيط", "Fiber state changes since the previous cycle, including load retries.": "تغييرات حالة الـ fiber منذ الدورة السابقة، بما في ذلك محاولات التحميل.", "Finance lens": "منظور مالي", "Follow-ups": "المتابعات", "Framework change": "تغيير الإطار", "Framework changes as they happened, from runtime probes.": "تغييرات الإطار لحظة حدوثها، من مجسّات وقت التشغيل.", "Framework evolution": "تطور الإطار", "Framework size and how much of the evolution pipeline shows runtime evidence.": "حجم الإطار ومقدار ما يُظهره مسار التطور من أدلة وقت التشغيل.", "From": "من", "Frozen plugins": "الإضافات المُجمَّدة", "Gap closure": "إغلاق الفجوة", "Halt": "إيقاف", "How closures are verified": "كيف يُتحقَّق من الإغلاقات", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "ما مقدار إشارة الأثر القابل للاستخدام كتغذية راجعة. هذا يحدّد ما إذا كان بناء سياسة تعلّم يستحق العناء.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "ما مقدار ما نمّاه الإطار بنفسه، وما مقدار المسار الذي يُظهر أدلة وقت التشغيل.", "How often each window sat inside, near, or outside its declared limits": "عدد المرات التي كانت فيها كل نافذة داخل حدودها المعلنة أو قريبة منها أو خارجها", "Inquiry brief": "موجز الاستقصاء", "Insights carded as evidence, capped for fast review.": "الرؤى معروضة كأدلة، ومحدودة العدد للمراجعة السريعة.", "Instruments & counterparties": "الأدوات والأطراف المقابلة", "Kept": "المحتفظ به", "Latest capability decision": "أحدث قرار للقدرات", "Lifecycle records": "سجلات دورة الحياة", "Lifecycle timeline": "الخط الزمني لدورة الحياة", "Lifecycle transitions": "انتقالات دورة الحياة", "Line of inquiry": "خط الاستقصاء", "Live activity": "النشاط المباشر", "Location": "الموقع", "Loop phase": "مرحلة الحلقة", "Mean of each downsample window. Declared limits are listed per channel below.": "متوسط كل نافذة تخفيض للعينات. الحدود المعلنة مدرجة لكل قناة أدناه.", "Model's reasoning": "استدلال النموذج", "Mutation": "التغيير", "Narrative": "السرد", "Narrative pulse": "نبض السرد", "Needs attention": "يستدعي الانتباه", "Next recal due": "موعد إعادة المعايرة", "Next step": "الخطوة التالية", "No causal history yet": "لا يوجد تاريخ سببي بعد", "Normalized error": "الخطأ المعياري", "Normalized error is the residual as a share of the channel's declared span.": "الخطأ المعياري هو المتبقي كنسبة من المدى المعلن للقناة.", "Not yet observed": "لم يُرصد بعد", "Nothing has driven a framework change, so there is no episode to narrate.": "لم يدفع أي شيء بعد إلى تغيير في الإطار، لذا لا توجد حلقة لسردها.", "OHLC extracted from captured session market data.": "OHLC مستخرج من بيانات السوق المسجلة في الجلسة.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "قائمة الرصد وحالة المقترحات وقرارات السياسة ونتائج دورة الحياة.", "Observations": "الرصدات", "Observed Hz": "الهرتز المرصود", "Observed rate against declared rate": "المعدل المرصود مقابل المعدل المعلن", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "مساحة أسماء عالمية واحدة، تُحكَّم بأسبقية التسجيل. يُسجَّل المتنافس ولا يُهمَل بصمت.", "Open": "مفتوح", "Open risks": "المخاطر المفتوحة", "Open/high/low/close from captured tool output.": "الافتتاح/الأعلى/الأدنى/الإغلاق من مخرجات الأدوات المسجلة.", "Origin": "المصدر", "Outcome": "النتيجة", "PRODUCTION": "إنتاج", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "لكل حلقة: المُحفِّز والقرار والتغيير وما إذا أُغلقت الفجوة.", "Per-channel calibration state, freshness, and residual correction": "حالة المعايرة وحداثتها وتصحيح المتبقي لكل قناة", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "أدلة وقت التشغيل لكل مقطع. وجود وحدة لا يعني أن شيئًا يستدعيها.", "Pipeline": "المسار", "Pipeline evidence": "أدلة المسار", "Pipeline reachability": "إمكانية الوصول إلى المسار", "Plan": "الخطة", "Plan steps": "خطوات الخطة", "Plugin": "الملحق", "Plugin roster and maturity": "قائمة الملحقات والنضج", "Plugins": "الملحقات", "Plugins by origin": "الإضافات حسب المصدر", "Plugins by maturity": "الإضافات حسب النضج", "Policy": "السياسة", "Policy decisions": "قرارات السياسة", "Positions & actions": "المراكز والإجراءات", "Posture": "الوضع", "Price action": "حركة السعر", "Proposal": "المقترح", "Proposal status": "حالة المقترح", "Proposed, not admitted": "مُقترح وغير مقبول", "Pulse": "النبض", "Quarantine feed": "تغذية الحجر", "Ratio": "النسبة", "Read live from the registry and maturity ledger every cycle.": "يُقرأ مباشرة من السجل ودفتر النضج في كل دورة.", "Recent episodes": "الحلقات الأخيرة", "Reclaim candidates": "مرشّحو الاسترجاع", "Reclaimable": "قابل للاسترجاع", "References & follow-ups": "المراجع والمتابعات", "References (entities)": "المراجع (الكيانات)", "Registry": "السجل", "Registry delta": "فرق السجل", "Registry version": "إصدار السجل", "Regressions": "الانحدارات", "Rejected": "المرفوض", "Representative observations, capped for quick scanning.": "رصدات تمثيلية، محدودة العدد للقراءة السريعة.", "Requirements": "المتطلبات", "Research lens": "منظور بحثي", "Residual": "المتبقي", "Reward signal bandwidth": "نطاق إشارة المكافأة", "Runtime evidence": "دليل وقت التشغيل", "Sampled history per channel, newest on the right": "سجل العينات لكل قناة، الأحدث على اليمين", "Segment": "المقطع", "Segments by status": "الأجزاء حسب الحالة", "Selectable": "قابل للاختيار", "Selection delta": "فرق الاختيار", "Self-acquired": "مُكتسَب ذاتيًا", "Self-acquired plugins that are registered but unselectable or never once used.": "إضافات مُكتسَبة ذاتيًا مُسجَّلة لكنها غير قابلة للاختيار أو لم تُستخدم قطّ.", "Sentiment lens": "منظور المشاعر", "Series": "السلسلة", "Session analysis": "تحليل الجلسة", "Signal strength": "قوة الإشارة", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "إشارات على أن شيئًا نما بشكل خاطئ أو تم حجبه. تظهر أيًا كان التبويب المفتوح.", "Skipped slots": "الفتحات المتخطاة", "State": "الحالة", "Storyline and signal strength before drilling into positions and actions.": "السرد وقوة الإشارة قبل التوسع في المراكز والإجراءات.", "Streaming": "بث", "Suggested next steps": "الخطوات التالية المقترحة", "The line of investigation and where the open questions concentrate.": "خط البحث وأين تتركز الأسئلة المفتوحة.", "The narrative arc and how strongly themes are trending.": "قوس السرد ومدى قوة اتجاه الموضوعات.", "The world model asked for these capabilities and nothing took them up.": "طلب نموذج العالم هذه القدرات ولم يتبنّها شيء.", "Theme intensity": "شدة الموضوعات", "Themes": "الموضوعات", "This board reports how the framework changes itself. Nothing has been recorded yet.": "تُبلِّغ هذه اللوحة عن كيفية تغيير الإطار لنفسه. لم يُسجَّل أي شيء بعد.", "To": "إلى", "Tool": "الأداة", "Tool-name conflicts": "تعارضات أسماء الأدوات", "Tools": "الأدوات", "Transport": "النقل", "Transport, provenance and channel counts": "النقل والمنشأ وعدد القنوات", "Maturity": "النضج", "Maturity accrual": "تراكم النضج", "Maturity class": "فئة النضج", "Unselectable reclamation": "استرجاع غير القابل للاختيار", "Usable": "قابل للاستخدام", "VERIFIED": "مُتحقَّق", "Verdicts": "الأحكام", "Verdicts by reason": "الأحكام حسب السبب", "Verified": "مُتحقَّق", "Verified by": "تم التحقق بواسطة", "Voices & concerns": "الأصوات والمخاوف", "Watchlist": "قائمة المتابعة", "What changed in the environment, and what the framework did about it.": "ما تغيّر في البيئة، وما فعله الإطار حيال ذلك.", "Which plugin owns which tool, and which capability that tool provides.": "أي ملحق يملك أي أداة، وأي قدرة توفرها تلك الأداة.", "Who/what is in the conversation, and the concerns still open.": "من/ما هو في المحادثة، والمخاوف التي لا تزال مفتوحة.", "Why": "السبب", "Why not admitted": "سبب عدم القبول", "Why this page is empty": "لماذا هذه الصفحة فارغة", "World-model driver": "مُشغِّل نموذج العالم", "Writable": "قابل للكتابة", "aborted": "مُلغى", "accruing": "قيد التراكم", "active": "نشط", "appeared": "ظهر", "armed": "مُسلّح", "assess_compatibility": "تقييم التوافق", "built_in": "مدمج", "capability_expand": "توسيع القدرة", "committed": "مُنجَز", "conformance": "المطابقة", "declared_fitness": "الملاءمة المُعلنة", "disable": "تعطيل", "disposed": "تم التخلص منه", "effect_observed": "تم رصد الأثر", "environment_probe": "مِجَس البيئة", "execution_failed": "فشل التنفيذ", "expected_effect_absent": "الأثر المتوقع غائب", "failed": "فشل", "frozen": "مُجمَّد", "gone": "اختفى", "idle": "خامل", "install": "تثبيت", "loading": "قيد التحميل", "manual": "يدوي", "moved": "انتقل", "new_unproven": "جديد وغير مُثبَت", "no": "لا", "no_evidence": "لا يوجد دليل", "no_expected_effect_declared": "لم يُعلَن أثر متوقع", "no_outcome_observed": "لم يُرصد أي ناتج", "none": "لا شيء", "not_admitted": "غير مقبول", "not_applicable": "غير منطبق", "observe_only": "المراقبة فقط", "observed_effect": "الأثر المرصود", "open": "مفتوح", "pending": "معلّق", "reload": "إعادة تحميل", "remove": "إزالة", "reopened": "أُعيد فتحه", "resolved": "تم الحل", "rollback": "تراجع", "runtime": "وقت التشغيل", "self_acquired": "مُكتسَب ذاتيًا", "still_open": "لا يزال مفتوحًا", "tool_reported_no_effect": "الأداة لم تُبلِّغ عن أثر", "trusted": "موثوق", "unknown": "غير معروف", "unknown_tool": "أداة غير معروفة", "unloading": "قيد الإلغاء", "unscheduled": "غير مُجدول", "unverifiable": "غير قابل للتحقق", "unverified": "غير مُتحقَّق", "waiting": "في الانتظار", "watching": "يراقب", "wired": "موصول", "world_model": "نموذج العالم", "yes": "نعم", "Causal trace": "الأثر السببي", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "دليل للقراءة فقط يربط البيئة بالحوكمة للّقطة واحدة من تطور الإطار.", "Evidence boundary": "حدود الدليل", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "يعرض الأثر السببي الحقائق المسجلة ولا يستنتج موافقة مفقودة أو أثرًا مرصودًا.", "Episodes": "الحلقات", "Declared-fitness closures": "إغلاقات الملاءمة المعلنة", "Counterfactual / mutation matrix": "مصفوفة الافتراضات المضادة / التغييرات", "Each row preserves the driver, decision, registry delta, and verification tier.": "يحفظ كل صف المحفز والقرار وفرق السجل ومستوى التحقق.", "Trigger": "المحفز", "Evidence tier": "طبقة الدليل", "Episode timeline": "الخط الزمني للحلقات", "Rebuilt from existing decision and observation records.": "أُعيد بناؤه من سجلات القرار والرصد الموجودة.", "Durable trace feed": "تدفق آثار دائم", "Rejected and no-op decisions remain visible when their trace sink is installed.": "تبقى القرارات المرفوضة والتي بلا إجراء مرئية عند تثبيت مستقبل آثارها.", "Lifecycle": "دورة الحياة", "Pipeline evidence over time": "أدلة المسار عبر الزمن", "One point per recorded change in framework state, oldest first.": "نقطة واحدة لكل تغيير مسجّل في حالة الإطار، الأقدم أولًا.", "Samples": "العينات", "Net change": "التغير الصافي"},
+    ru: {"> **No effect verdict has been recorded yet**, so there is no reward signal to measure. The rates above are blank rather than zero on purpose. An effect can only be verified when the requirement declared one, and only world-model-authored requirements carry an expected effect today.": "> **Ни одного заключения об эффекте пока не записано**, поэтому измерять нечего. Показатели выше намеренно пусты, а не равны нулю. Эффект можно проверить только если требование его заявило, а сегодня заявленный эффект несут лишь требования, составленные моделью мира.", "> **Regression: a closed gap has recurred.** An evolution that looked successful did not hold. This is the one finding on this board that warrants immediate attention.": "> **Регрессия: закрытый пробел возобновился.** Эволюция, казавшаяся успешной, не удержалась. Это единственный вывод на этой панели, требующий немедленного внимания.", "> **Snapshot only.** There is no causal history to rebuild yet, so the timeline is absent rather than empty. Why is stated by the `Policy decisions` row under pipeline reachability; the live snapshot and the reachability table itself are unaffected.": "> **Только снимок.** Причинной истории для восстановления пока нет, поэтому хронология отсутствует, а не пуста. Причина указана в строке `Решения политики` под покрытием конвейера; снимок и таблица покрытия не затронуты.", "> **Some plugins are frozen by an internal defect.** A frozen plugin still reports `DRAFT`, and the trust dimension only *scores*, so it stays selectable unless it is also unregistered — check the `Selectable` column.": "> **Некоторые плагины заморожены из-за внутреннего дефекта.** Замороженный плагин по-прежнему сообщает `DRAFT`, а измерение доверия только *оценивает*, поэтому он остаётся выбираемым, пока не будет также снят с регистрации — см. столбец `Выбираемо`.", "> **Verification tier: L2 (declared fitness).** A retired observation means a candidate *declared* it provides the capability, not that the capability was observed to work. Effect verification (L3) is not wired yet, so no closure on this board should be read as proven.": "> **Уровень проверки: L2 (заявленная пригодность).** Снятое наблюдение означает, что кандидат *заявил* о предоставлении возможности, а не что возможность наблюдалась в работе. Проверка эффекта (L3) не подключена, поэтому ни одно закрытие на этой панели не следует считать доказанным.", "> A watch has to complete one cycle before there is anything to show. If this persists, check that the scheduler is enabled and that the `framework-evolution` watch is armed and not muted.": "> Прежде чем появятся данные, должен завершиться хотя бы один цикл наблюдения. Если это сохраняется, проверьте, включён ли планировщик и что наблюдение `framework-evolution` активно и не отключено.", "> An episode is written when an environment observation leads to a capability decision. None has been recorded, which is either a quiet system or a pipeline that stops earlier — the **Pipeline** tab names the segment where it stops, and what would unblock it.": "> Эпизод записывается, когда наблюдение окружения приводит к решению о возможности. Ни одного не зафиксировано: либо система спокойна, либо конвейер останавливается раньше — вкладка **Конвейер** называет сегмент остановки и то, что его разблокирует.", "> Nothing reclaims these automatically. Each holds a tool name and appears in the capability list without being selectable, so the registry grows in a direction no requirement can use.": "> Ничто не утилизирует их автоматически. Каждый занимает имя инструмента и присутствует в списке возможностей, не будучи выбираемым: реестр растёт в направлении, непригодном ни для одного требования.", "> These proposals entered no pipeline, so they appear in no decision record and no observation. Admitting them is a configuration choice.": "> Эти предложения не вошли ни в один конвейер, поэтому не отражены ни в одной записи решения или наблюдения. Их приём — вопрос конфигурации.", "A ratio below 1.0 means the sampling loop is not keeping its declared cadence.": "Отношение ниже 1,0 означает, что цикл выборки не выдерживает объявленный ритм.", "Abstained": "Воздержалось", "Acquisition authority": "Право на получение", "Acquisition lifecycle": "Жизненный цикл получения", "Action": "Действие", "After": "После", "An unverified declaration has its writable channels demoted to read-only.": "У непроверенного объявления записываемые каналы понижаются до только чтения.", "Approval": "Согласование", "Autonomous governance": "Автономное управление", "Autonomy": "Автономность", "Before": "До", "CANDIDATE": "Кандидат", "Calibrated at": "Калиброван", "Calibration health": "Состояние калибровки", "Calls": "Вызовы", "Calls (decisions)": "Рекомендации (решения)", "Candlestick": "Свечи", "Capability": "Возможность", "Capability adaptation": "Адаптация возможностей", "Capability observations": "Наблюдения возможностей", "Capability ownership": "Владение возможностями", "Capability topology": "Топология возможностей", "Change": "Изменение", "Channel": "Канал", "Channels": "Каналы", "Channels that have never been calibrated or whose calibration has expired are shown first.": "Каналы, которые никогда не калибровались или чья калибровка истекла, показаны первыми.", "Command": "Команда", "Commanded versus observed, best tracking first": "Заданное против наблюдаемого, лучшее отслеживание первым", "Composition": "Состав", "Concerns (open questions)": "Опасения (открытые вопросы)", "Confidence": "Уверенность", "Counted across every charted channel. 'near' means within 5% of a declared bound.": "Подсчитано по всем отображаемым каналам. «У границы» — в пределах 5% от объявленного предела.", "Cycles run": "Выполнено циклов", "DRAFT": "Черновик", "Days since": "Дней с тех пор", "Decision": "Решение", "Decisions read as calls; action items as the execution checklist.": "Решения читаются как рекомендации; действия — как чек-лист исполнения.", "Declared Hz": "Объявл. Гц", "Desk brief": "Сводка деска", "Device": "Устройство", "Dropped samples": "Отброшенные образцы", "Each row names one blocked segment and the change that would unblock it.": "Каждая строка называет заблокированный сегмент и изменение, которое его разблокирует.", "Effect verification (L3)": "Проверка эффекта (L3)", "Effects declared": "Заявлено эффектов", "Entities as references, and recommended next prompts to advance the work.": "Сущности как ссылки и рекомендуемые следующие запросы.", "Entities in play and the open risks still to resolve.": "Задействованные сущности и нерешённые риски.", "Envelope, rate, staleness and quality observations · newest first": "Наблюдения по огибающей, частоте, устареванию и качеству · сначала новые", "Environment": "Окружение", "Environment to framework": "От окружения к фреймворку", "Environment, selected plugin tools, and orchestration order.": "Окружение, выбранные инструменты плагинов и порядок оркестрации.", "Error rate": "Частота ошибок", "Events paced out": "Событий подавлено", "Ever used": "Использовался", "Evidence": "Обоснование", "Evidence admission": "Приём данных", "Evolution": "Эволюция", "Evolution timeline": "Хронология эволюции", "Executable": "Исполнимо", "Execution checklist": "Чек-лист исполнения", "Extracted from this session's tool/file output (not model-generated).": "Извлечено из вывода инструментов/файлов этой сессии (не сгенерировано моделью).", "Failures": "Сбои", "Fiber": "Файбер", "Fiber state changes since the previous cycle, including load retries.": "Изменения состояния fiber с предыдущего цикла, включая повторные загрузки.", "Finance lens": "Финансовый ракурс", "Follow-ups": "Продолжения", "Framework change": "Изменение фреймворка", "Framework changes as they happened, from runtime probes.": "Изменения фреймворка в момент их появления, от рантайм-зондов.", "Framework evolution": "Эволюция фреймворка", "Framework size and how much of the evolution pipeline shows runtime evidence.": "Размер фреймворка и какая часть конвейера эволюции показывает свидетельства времени выполнения.", "From": "Из", "Frozen plugins": "Замороженные плагины", "Gap closure": "Закрытие пробела", "Halt": "Останов", "How closures are verified": "Как проверяются закрытия", "How much of the effect signal is usable as feedback. This decides whether a learning policy is worth building.": "Какая часть сигнала об эффекте пригодна как обратная связь. Это определяет, стоит ли строить обучающую политику.", "How much of the framework it grew itself, and how much of the pipeline shows runtime evidence.": "Какую часть фреймворка он вырастил сам и какая часть конвейера показывает данные времени выполнения.", "How often each window sat inside, near, or outside its declared limits": "Как часто каждое окно было внутри, у границы или вне объявленных пределов", "Inquiry brief": "Сводка исследования", "Insights carded as evidence, capped for fast review.": "Инсайты как карточки-обоснования, ограничены для быстрого просмотра.", "Instruments & counterparties": "Инструменты и контрагенты", "Kept": "Оставлен", "Latest capability decision": "Последнее решение о возможностях", "Lifecycle records": "Записи жизненного цикла", "Lifecycle timeline": "Хронология жизненного цикла", "Lifecycle transitions": "Переходы жизненного цикла", "Line of inquiry": "Линия исследования", "Live activity": "Текущая активность", "Location": "Расположение", "Loop phase": "Фаза цикла", "Mean of each downsample window. Declared limits are listed per channel below.": "Среднее по каждому окну прореживания. Объявленные пределы указаны по каналам ниже.", "Model's reasoning": "Обоснование модели", "Mutation": "Изменение", "Narrative": "Сюжет", "Narrative pulse": "Нарративный пульс", "Needs attention": "Требует внимания", "Next recal due": "Следующая рекалибровка", "Next step": "Следующий шаг", "No causal history yet": "Причинной истории пока нет", "Normalized error": "Нормированная ошибка", "Normalized error is the residual as a share of the channel's declared span.": "Нормированная ошибка — остаток как доля объявленного диапазона канала.", "Not yet observed": "Ещё не наблюдалось", "Nothing has driven a framework change, so there is no episode to narrate.": "Ничто пока не вызвало изменения фреймворка, поэтому рассказывать не о чем.", "OHLC extracted from captured session market data.": "OHLC извлечён из рыночных данных, записанных в сессии.", "Observation backlog, proposal state, policy decisions, and lifecycle outcomes.": "Очередь наблюдений, состояние предложений, решения политики и итоги жизненного цикла.", "Observations": "Наблюдения", "Observed Hz": "Наблюд. Гц", "Observed rate against declared rate": "Наблюдаемая частота против объявленной", "One global namespace, arbitrated first-wins. The challenger is recorded, never silently dropped.": "Единое глобальное пространство имён, арбитраж по первому пришедшему. Претендент записывается, а не отбрасывается молча.", "Open": "Открыт", "Open risks": "Открытые риски", "Open/high/low/close from captured tool output.": "Открытие/максимум/минимум/закрытие из записанного вывода инструментов.", "Origin": "Источник", "Outcome": "Результат", "PRODUCTION": "Продакшн", "Per episode: the trigger, the decision, the change, and whether the gap closed.": "По эпизодам: триггер, решение, изменение и закрылся ли пробел.", "Per-channel calibration state, freshness, and residual correction": "Состояние калибровки, актуальность и остаточная поправка по каналам", "Per-segment runtime evidence. A module existing is not evidence that anything calls it.": "Свидетельства времени выполнения по сегментам. Наличие модуля не доказывает, что его кто-то вызывает.", "Pipeline": "Конвейер", "Pipeline evidence": "Свидетельства конвейера", "Pipeline reachability": "Достижимость конвейера", "Plan": "План", "Plan steps": "Шаги плана", "Plugin": "Плагин", "Plugin roster and maturity": "Реестр плагинов и зрелость", "Plugins": "Плагины", "Plugins by origin": "Плагины по происхождению", "Plugins by maturity": "Плагины по зрелости", "Policy": "Политика", "Policy decisions": "Решения политики", "Positions & actions": "Позиции и действия", "Posture": "Состояние", "Price action": "Ценовое движение", "Proposal": "Предложение", "Proposal status": "Статус предложения", "Proposed, not admitted": "Предложено, не принято", "Pulse": "Пульс", "Quarantine feed": "Поток карантина", "Ratio": "Отношение", "Read live from the registry and maturity ledger every cycle.": "Читается напрямую из реестра и журнала зрелости каждый цикл.", "Recent episodes": "Недавние эпизоды", "Reclaim candidates": "Кандидаты на утилизацию", "Reclaimable": "Утилизируемо", "References & follow-ups": "Ссылки и продолжения", "References (entities)": "Ссылки (сущности)", "Registry": "Реестр", "Registry delta": "Изменение реестра", "Registry version": "Версия реестра", "Regressions": "Регрессии", "Rejected": "Отклонён", "Representative observations, capped for quick scanning.": "Показательные наблюдения, ограничены для быстрого просмотра.", "Requirements": "Требования", "Research lens": "Исследовательский ракурс", "Residual": "Остаток", "Reward signal bandwidth": "Пропускная способность сигнала вознаграждения", "Runtime evidence": "Свидетельство времени выполнения", "Sampled history per channel, newest on the right": "История выборок по каналам, самое новое справа", "Segment": "Сегмент", "Segments by status": "Сегменты по статусу", "Selectable": "Выбираемый", "Selection delta": "Изменение выбора", "Self-acquired": "Самостоятельно получено", "Self-acquired plugins that are registered but unselectable or never once used.": "Самостоятельно полученные плагины, которые зарегистрированы, но невыбираемы или ни разу не использовались.", "Sentiment lens": "Ракурс тональности", "Series": "Серия", "Session analysis": "Анализ сессии", "Signal strength": "Сила сигнала", "Signals that something grew wrong, or was withheld. Shown regardless of the open tab.": "Признаки того, что что-то выросло неверно или было задержано. Показываются независимо от открытой вкладки.", "Skipped slots": "Пропущенные слоты", "State": "Состояние", "Storyline and signal strength before drilling into positions and actions.": "Сюжет и сила сигнала до перехода к позициям и действиям.", "Streaming": "Потоковая передача", "Suggested next steps": "Рекомендуемые следующие шаги", "The line of investigation and where the open questions concentrate.": "Линия исследования и где сосредоточены открытые вопросы.", "The narrative arc and how strongly themes are trending.": "Нарративная дуга и насколько сильно растут темы.", "The world model asked for these capabilities and nothing took them up.": "Модель мира запросила эти возможности, и никто их не принял.", "Theme intensity": "Интенсивность тем", "Themes": "Темы", "This board reports how the framework changes itself. Nothing has been recorded yet.": "Эта панель сообщает, как фреймворк изменяет сам себя. Пока ничего не записано.", "To": "В", "Tool": "Инструмент", "Tool-name conflicts": "Конфликты имён инструментов", "Tools": "Инструменты", "Transport": "Транспорт", "Transport, provenance and channel counts": "Транспорт, происхождение и число каналов", "Maturity": "Зрелость", "Maturity accrual": "Накопление зрелости", "Maturity class": "Класс зрелости", "Unselectable reclamation": "Утилизация невыбираемого", "Usable": "Пригодно", "VERIFIED": "Проверено", "Verdicts": "Заключений", "Verdicts by reason": "Заключения по причине", "Verified": "Проверено", "Verified by": "Подтверждено", "Voices & concerns": "Голоса и опасения", "Watchlist": "Список наблюдения", "What changed in the environment, and what the framework did about it.": "Что изменилось в окружении и что фреймворк с этим сделал.", "Which plugin owns which tool, and which capability that tool provides.": "Какой плагин владеет каким инструментом и какую возможность этот инструмент предоставляет.", "Who/what is in the conversation, and the concerns still open.": "Кто/что в разговоре и какие опасения остаются.", "Why": "Почему", "Why not admitted": "Причина отклонения", "Why this page is empty": "Почему эта страница пуста", "World-model driver": "Драйвер модели мира", "Writable": "Записываемый", "aborted": "Прервано", "accruing": "Накапливается", "active": "Активно", "appeared": "Появился", "armed": "Активно", "assess_compatibility": "Оценка совместимости", "built_in": "Встроенный", "capability_expand": "Расширение возможностей", "committed": "Завершено", "conformance": "Соответствие", "declared_fitness": "Заявленная пригодность", "disable": "Отключение", "disposed": "Освобождено", "effect_observed": "Эффект наблюдался", "environment_probe": "Зонд окружения", "execution_failed": "Сбой выполнения", "expected_effect_absent": "Ожидаемый эффект отсутствует", "failed": "Сбой", "frozen": "Заморожено", "gone": "Исчез", "idle": "Простой", "install": "Установка", "loading": "Загрузка", "manual": "Вручную", "moved": "Перешёл", "new_unproven": "Новое, непроверенное", "no": "Нет", "no_evidence": "Нет данных", "no_expected_effect_declared": "Ожидаемый эффект не заявлен", "no_outcome_observed": "Результат не наблюдался", "none": "Нет", "not_admitted": "Не принято", "not_applicable": "Неприменимо", "observe_only": "Только наблюдение", "observed_effect": "Наблюдаемый эффект", "open": "Открыто", "pending": "Ожидает", "reload": "Перезагрузка", "remove": "Удаление", "reopened": "Возобновлено", "resolved": "Закрыто", "rollback": "Откат", "runtime": "Среда выполнения", "self_acquired": "Самостоятельно получено", "still_open": "Всё ещё открыто", "tool_reported_no_effect": "Инструмент не сообщил об эффекте", "trusted": "Доверенное", "unknown": "Неизвестно", "unknown_tool": "Неизвестный инструмент", "unloading": "Выгрузка", "unscheduled": "Не запланировано", "unverifiable": "Не проверяемо", "unverified": "Непроверенное", "waiting": "Ожидание", "watching": "Наблюдает", "wired": "Подключено", "world_model": "Модель мира", "yes": "Да", "Causal trace": "Причинная трасса", "Read-only environment-to-governance evidence for one framework-evolution snapshot.": "Доказательства только для чтения от окружения к управлению для одного снимка эволюции фреймворка.", "Evidence boundary": "Граница доказательств", "A causal trace shows recorded facts; it does not infer missing approval or observed effect.": "Причинная трасса показывает записанные факты и не выводит отсутствующее согласование или наблюдаемый эффект.", "Episodes": "Эпизоды", "Declared-fitness closures": "Закрытия по заявленной пригодности", "Counterfactual / mutation matrix": "Контрфактическая матрица / мутации", "Each row preserves the driver, decision, registry delta, and verification tier.": "Каждая строка сохраняет триггер, решение, изменение реестра и уровень проверки.", "Trigger": "Триггер", "Evidence tier": "Уровень доказательств", "Episode timeline": "Хронология эпизодов", "Rebuilt from existing decision and observation records.": "Восстановлена из существующих записей решений и наблюдений.", "Durable trace feed": "Поток долговечных трасс", "Rejected and no-op decisions remain visible when their trace sink is installed.": "Отклонённые решения и решения без действия остаются видимыми, когда установлен их приёмник трасс.", "Lifecycle": "Жизненный цикл", "Pipeline evidence over time": "Свидетельства конвейера во времени", "One point per recorded change in framework state, oldest first.": "Одна точка на каждое зафиксированное изменение состояния фреймворка, старшие слева.", "Samples": "Выборки", "Net change": "Итоговое изменение"}
   };
   // Page-chrome freshness strings. A table of their own because the provenance bar
   // is not a lens: it renders above every board, so keying it off any one lens's
diff --git a/src/leapflow/dashboard/static/styles.css b/src/leapflow/dashboard/static/styles.css
index 9d4869b4..521ebc43 100644
--- a/src/leapflow/dashboard/static/styles.css
+++ b/src/leapflow/dashboard/static/styles.css
@@ -161,8 +161,9 @@ body {
 .figcaption .fignum { color: var(--accent); font-weight: 700; margin-inline-end: 5px; }
 
 /* ── Bars / sparkline / pie (flat, single-hue accents) ───────────────────── */
-.bar-row { display: grid; grid-template-columns: 74px 1fr 30px; align-items: center; gap: 8px; margin: 7px 0; }
+.bar-row { display: grid; grid-template-columns: max-content 1fr 36px; align-items: center; gap: 8px; margin: 7px 0; }
 .bar-label, .bar-value { color: var(--muted); font-size: 0.85rem; font-variant-numeric: tabular-nums; }
+.bar-label { white-space: nowrap; }
 .bar-track { height: 8px; background: var(--track); border-radius: 0; overflow: hidden; }
 .bar-fill { display: block; height: 100%; border-radius: 0; background: var(--info); }
 .bar-fill.sev-alert { background: var(--alert); }
diff --git a/src/leapflow/dashboard/templates/capability.yaml b/src/leapflow/dashboard/templates/capability.yaml
index 67edbbb7..fe75fb3c 100644
--- a/src/leapflow/dashboard/templates/capability.yaml
+++ b/src/leapflow/dashboard/templates/capability.yaml
@@ -117,7 +117,7 @@ layout:
                 - key: plugin_id
                   label: "Plugin"
                 - key: trust_level
-                  label: "Trust"
+                  label: "Maturity"
                 - key: failure_streak
                   label: "Failures"
               bind: capability_plan.governance_results
diff --git a/src/leapflow/dashboard/templates/evolution.yaml b/src/leapflow/dashboard/templates/evolution.yaml
index 43ee3a92..01763868 100644
--- a/src/leapflow/dashboard/templates/evolution.yaml
+++ b/src/leapflow/dashboard/templates/evolution.yaml
@@ -445,8 +445,8 @@ layout:
               - type: Section
                 when: evolution.roster
                 props:
-                  title: "Plugin roster and trust"
-                  subtitle: "Read live from the registry and trust ledger every cycle."
+                  title: "Plugin roster and maturity"
+                  subtitle: "Read live from the registry and maturity ledger every cycle."
                 children:
                   - type: BarChart
                     when: evolution.provenance_mix
@@ -456,7 +456,7 @@ layout:
                   - type: BarChart
                     when: evolution.trust_mix
                     props:
-                      title: "Plugins by trust class"
+                      title: "Plugins by maturity"
                       bind: evolution.trust_mix
                   # Deliberately no live counters here. This finding dedups on a
                   # content fingerprint, so a rendered metric that changes every tick
@@ -473,7 +473,7 @@ layout:
                         - key: fiber_state
                           label: "Fiber"
                         - key: trust_level
-                          label: "Trust"
+                          label: "Maturity"
                         - key: selectable
                           label: "Selectable"
                         - key: ever_used
@@ -503,7 +503,7 @@ layout:
                         - key: plugin_id
                           label: "Plugin"
                         - key: trust_level
-                          label: "Trust"
+                          label: "Maturity"
                         - key: selectable
                           label: "Selectable"
                         - key: ever_used
diff --git a/src/leapflow/domain/event_types.py b/src/leapflow/domain/event_types.py
index 3a3f4669..7b1d55e1 100644
--- a/src/leapflow/domain/event_types.py
+++ b/src/leapflow/domain/event_types.py
@@ -103,6 +103,7 @@ class EvolutionEventType:
     PLUGIN_PROBATION_STARTED = "plugin.probation_started"
     PLUGIN_VERIFIED = "plugin.verified"
     PLUGIN_QUARANTINED = "plugin.quarantined"
+    PLUGIN_UNQUARANTINED = "plugin.unquarantined"
     PLUGIN_ROLLED_BACK = "plugin.rolled_back"
     FRAMEWORK_TRACE_RECORDED = "framework.trace_recorded"
     PLUGIN_OUTCOME_RECORDED = "plugin.outcome_recorded"
diff --git a/src/leapflow/engine/session_factory.py b/src/leapflow/engine/session_factory.py
index e6cedb08..16877e84 100644
--- a/src/leapflow/engine/session_factory.py
+++ b/src/leapflow/engine/session_factory.py
@@ -77,8 +77,17 @@ def record_failure(self, plugin_id: str, *, hard: bool = False) -> None:
             self._flush()
             self._trace_transition(plugin_id, before, after, hard=hard)
 
+    def unfreeze(self, plugin_id: str) -> bool:
+        before = self.level(plugin_id)
+        result = super().unfreeze(plugin_id)
+        if result:
+            after = self.level(plugin_id)
+            self._flush()
+            self._trace_transition(plugin_id, before, after, hard=False, trigger="unfreeze")
+        return result
+
     def _trace_transition(
-        self, plugin_id: str, before: Any, after: Any, *, hard: bool
+        self, plugin_id: str, before: Any, after: Any, *, hard: bool, trigger: str = ""
     ) -> None:
         """Emit the trust transition, which nothing else records durably.
 
@@ -93,6 +102,29 @@ def _trace_transition(
         PRODUCTION or a freeze on an internal defect cannot be reconstructed after
         the fact from the trust state alone.
         """
+        # ── DuckDB trust transition history (cold-path, best-effort) ──
+        try:
+            store = self._store
+            if store is not None:
+                before_int = int(before) if hasattr(before, '__int__') else int(before)
+                after_int = int(after) if hasattr(after, '__int__') else int(after)
+                if trigger:
+                    pass  # Caller-supplied trigger (e.g. "unfreeze")
+                elif hard:
+                    trigger = "hard_failure"
+                elif after_int > before_int:
+                    trigger = "success"
+                else:
+                    trigger = "failure"
+                ok_count = self._consecutive_ok.get(plugin_id, 0)
+                fail_count = self._consecutive_fail.get(plugin_id, 0)
+                store.record_trust_transition(
+                    plugin_id, before_int, after_int, trigger, ok_count, fail_count
+                )
+        except Exception:  # noqa: BLE001 - trust history is best-effort, never fail a turn
+            pass
+
+        # ── EvolutionTap telemetry ──
         try:
             from leapflow.domain.evolution_trace import EvolutionStage
             from leapflow.telemetry.evolution_tap import emit_trace, is_enabled
diff --git a/src/leapflow/evolution/sweep.py b/src/leapflow/evolution/sweep.py
index 1f58ea36..43ea0f55 100644
--- a/src/leapflow/evolution/sweep.py
+++ b/src/leapflow/evolution/sweep.py
@@ -32,6 +32,7 @@
 from __future__ import annotations
 
 import logging
+import time
 from dataclasses import dataclass, field
 from typing import Any, Mapping, Sequence
 
@@ -63,6 +64,8 @@ class SweepOutcome:
     verdicts: tuple[EffectVerdict, ...] = ()
     quarantined: tuple[Mapping[str, Any], ...] = ()
     reclamation: tuple[ReclamationCandidate, ...] = ()
+    expired: int = 0
+    superseded: int = 0
 
     @property
     def verified(self) -> int:
@@ -83,12 +86,14 @@ def to_dict(self) -> dict[str, Any]:
             "effect_unverifiable": self.unverifiable,
             "quarantined": len(self.quarantined),
             "reclamation_candidates": [c.plugin_id for c in self.reclamation],
+            "expired": self.expired,
+            "superseded": self.superseded,
         }
 
 
 @dataclass
 class CoevolutionSweep:
-    """Runs effect verification, quarantine governance and reclamation.
+    """Runs effect verification, quarantine governance, proposal expiry and reclamation.
 
     All collaborators are optional: a sweep with nothing wired emits the
     corresponding no-op traces and returns an empty outcome, which is what keeps
@@ -100,6 +105,8 @@ class CoevolutionSweep:
     verifier: CapabilityEffectVerifier = field(default_factory=CapabilityEffectVerifier)
     reaper: UnselectableArtifactReaper = field(default_factory=UnselectableArtifactReaper)
     proposal_ids: Mapping[str, str] = field(default_factory=dict)
+    orchestrator: Any = None  # ProposalOrchestrator, optional
+    proposal_store: Any = None  # EvolutionCapabilityProposalStore, optional
 
     async def run(
         self,
@@ -117,8 +124,12 @@ async def run(
         """
         verdicts = await self._verify(verifications)
         quarantined = await self._drain()
+        expired, superseded = self._sweep_proposal_expiry()
         reclamation = self._reclaim(acquired_plugin_ids, resolutions)
-        return SweepOutcome(verdicts, quarantined, reclamation)
+        return SweepOutcome(
+            verdicts, quarantined, reclamation,
+            expired=expired, superseded=superseded,
+        )
 
     # ── effect verification (L3 closure) ──────────────────────────────────
 
@@ -295,6 +306,98 @@ def _reclaim(
             )
         return found
 
+    # ── proposal TTL and supersession ─────────────────────────────────────
+
+    def _sweep_proposal_expiry(self) -> tuple[int, int]:
+        """Expire stale proposals and supersede outdated ones."""
+        if self.orchestrator is None or self.proposal_store is None:
+            self._emit(
+                EvolutionStage.LEARN, "proposal_expiry",
+                summary="proposal store or orchestrator not available",
+                detail={"expired": 0, "superseded": 0, "no_op": True},
+            )
+            return 0, 0
+        try:
+            now = time.time()
+            active = self.proposal_store.active(limit=0)
+        except Exception:  # noqa: BLE001
+            logger.debug("sweep: could not read active proposals", exc_info=True)
+            return 0, 0
+
+        expired_count = superseded_count = 0
+        for item in active:
+            try:
+                # 1) TTL expiry
+                if item.expires_at is not None and now >= item.expires_at:
+                    self.orchestrator.expire(item.proposal_id, reason="ttl_exceeded")
+                    expired_count += 1
+                    self._emit(
+                        EvolutionStage.LEARN, "proposal_expiry",
+                        correlation={"proposal_id": item.proposal_id},
+                        summary=f"{item.proposal_id}: ttl_exceeded",
+                        detail={"proposal_id": item.proposal_id, "reason": "ttl_exceeded"},
+                    )
+                    continue
+                # 2) Supersession: same requirements hash, newer proposal exists
+                if self._has_newer_proposal(item, active):
+                    self.orchestrator.supersede(
+                        item.proposal_id,
+                        replacement_id=self._newest_for_requirements(item, active),
+                        reason="newer_proposal_exists",
+                    )
+                    superseded_count += 1
+                    self._emit(
+                        EvolutionStage.LEARN, "proposal_expiry",
+                        correlation={"proposal_id": item.proposal_id},
+                        summary=f"{item.proposal_id}: superseded by newer proposal",
+                        detail={"proposal_id": item.proposal_id, "reason": "newer_proposal_exists"},
+                    )
+            except Exception:  # noqa: BLE001 - one bad proposal must not stop the sweep
+                logger.debug("sweep: proposal expiry failed for %s", item.proposal_id, exc_info=True)
+
+        if not expired_count and not superseded_count:
+            self._emit(
+                EvolutionStage.LEARN, "proposal_expiry",
+                summary="no proposal expired or superseded",
+                detail={"expired": 0, "superseded": 0, "no_op": True},
+            )
+        return expired_count, superseded_count
+
+    @staticmethod
+    def _requirements_hash(item: Any) -> str:
+        """Stable content hash of a proposal's requirement set."""
+        from leapflow.domain.evolution_event import content_hash
+
+        reqs = [dict(r) for r in (item.requirements or ())]
+        return content_hash(reqs)
+
+    @classmethod
+    def _has_newer_proposal(cls, candidate: Any, active: Sequence[Any]) -> bool:
+        """Return True if a newer active proposal exists for the same requirements."""
+        candidate_hash = cls._requirements_hash(candidate)
+        for other in active:
+            if other.proposal_id == candidate.proposal_id:
+                continue
+            if cls._requirements_hash(other) == candidate_hash:
+                if (other.created_at or 0.0) > (candidate.created_at or 0.0):
+                    return True
+        return False
+
+    @classmethod
+    def _newest_for_requirements(cls, candidate: Any, active: Sequence[Any]) -> str:
+        """Return the proposal_id of the newest active proposal with the same requirements."""
+        candidate_hash = cls._requirements_hash(candidate)
+        newest_id = candidate.proposal_id
+        newest_at = candidate.created_at or 0.0
+        for other in active:
+            if other.proposal_id == candidate.proposal_id:
+                continue
+            if cls._requirements_hash(other) == candidate_hash:
+                if (other.created_at or 0.0) > newest_at:
+                    newest_id = other.proposal_id
+                    newest_at = other.created_at or 0.0
+        return newest_id
+
     @staticmethod
     def _emit(stage: EvolutionStage, kind: str, **kwargs: Any) -> None:
         """Record one sweep fact. Observability must never affect the observed."""
diff --git a/src/leapflow/learning/plugin_stats_store.py b/src/leapflow/learning/plugin_stats_store.py
index eae796a7..36e0c50d 100644
--- a/src/leapflow/learning/plugin_stats_store.py
+++ b/src/leapflow/learning/plugin_stats_store.py
@@ -27,6 +27,7 @@ def __init__(self, db_path: Optional[Path] = None) -> None:
         self._db_path = db_path
         self._table_created = False
         self._usage_table_created = False
+        self._transitions_table_created = False
 
     def _connect(self):
         """Get a DuckDB connection using the centralized factory."""
@@ -65,6 +66,54 @@ def _ensure_usage_table(self, conn) -> None:
         """)
         self._usage_table_created = True
 
+    def _ensure_transitions_table(self, conn) -> None:
+        """Create the trust transitions time-series table if it does not exist."""
+        if self._transitions_table_created:
+            return
+        conn.execute("""
+            CREATE SEQUENCE IF NOT EXISTS seq_trust_transition_id START 1
+        """)
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS plugin_trust_transitions (
+                id INTEGER PRIMARY KEY DEFAULT nextval('seq_trust_transition_id'),
+                plugin_id TEXT NOT NULL,
+                from_level INTEGER NOT NULL,
+                to_level INTEGER NOT NULL,
+                trigger TEXT NOT NULL,
+                consecutive_ok INTEGER,
+                consecutive_fail INTEGER,
+                transitioned_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        self._transitions_table_created = True
+
+    def record_trust_transition(
+        self,
+        plugin_id: str,
+        from_level: int,
+        to_level: int,
+        trigger: str,
+        consecutive_ok: int | None = None,
+        consecutive_fail: int | None = None,
+    ) -> bool:
+        """Record a trust level transition. Best-effort, never fails a turn."""
+        conn = self._connect()
+        if conn is None:
+            return False
+        try:
+            self._ensure_transitions_table(conn)
+            conn.execute(
+                "INSERT INTO plugin_trust_transitions "
+                "(plugin_id, from_level, to_level, trigger, consecutive_ok, consecutive_fail) "
+                "VALUES (?, ?, ?, ?, ?, ?)",
+                [plugin_id, from_level, to_level, trigger, consecutive_ok, consecutive_fail],
+            )
+            return True
+        except Exception:  # noqa: BLE001 - trust history is best-effort
+            return False
+        finally:
+            conn.close()
+
     def save_trust_state(self, state: Dict[str, Any]) -> bool:
         """Persist trust ledger state. Returns True on success."""
         conn = self._connect()
diff --git a/src/leapflow/learning/plugin_trust.py b/src/leapflow/learning/plugin_trust.py
index f7082de6..c3e53b89 100644
--- a/src/leapflow/learning/plugin_trust.py
+++ b/src/leapflow/learning/plugin_trust.py
@@ -19,8 +19,14 @@
 """
 from __future__ import annotations
 
+import logging
+from dataclasses import dataclass
+from datetime import datetime
 from enum import IntEnum
-from typing import Any, Dict
+from pathlib import Path
+from typing import Any, Dict, List
+
+logger = logging.getLogger(__name__)
 
 
 class PluginTrustLevel(IntEnum):
@@ -100,6 +106,17 @@ def record_failure(self, plugin_id: str, *, hard: bool = False) -> None:
         if self._consecutive_fail[plugin_id] >= self._demote_after:
             self._demote(plugin_id)
 
+    def unfreeze(self, plugin_id: str) -> bool:
+        """Remove plugin from frozen set and reset counters for re-probation."""
+        if plugin_id not in self._frozen:
+            return False
+        self._frozen.discard(plugin_id)
+        self._consecutive_ok.pop(plugin_id, None)
+        self._consecutive_fail.pop(plugin_id, None)
+        # Reset to DRAFT — must re-earn trust
+        self._levels[plugin_id] = PluginTrustLevel.DRAFT
+        return True
+
     # ── Internal promotion / demotion ──
 
     def _maybe_promote(self, plugin_id: str) -> None:
@@ -157,3 +174,83 @@ def load_state(cls, state: Dict[str, Any]) -> "PluginTrustLedger":
         }
         ledger._frozen = {str(k) for k in (state.get("frozen") or [])}
         return ledger
+
+
+@dataclass(frozen=True)
+class TrustTransitionRecord:
+    """A single trust level transition persisted in DuckDB."""
+
+    plugin_id: str
+    from_level: int
+    to_level: int
+    trigger: str
+    consecutive_ok: int | None
+    consecutive_fail: int | None
+    transitioned_at: datetime
+
+
+def trust_history(
+    db_path: Path | str,
+    plugin_id: str | None = None,
+    since: datetime | None = None,
+) -> List[TrustTransitionRecord]:
+    """Query trust transition history from DuckDB.
+
+    Returns records ordered by ``transitioned_at ASC``. Handles a missing
+    table gracefully (returns an empty list). ``db_path`` is the path to
+    the ``plugin_stats.duckdb`` file used by ``PluginStatsStore``.
+    """
+    try:
+        from leapflow.storage.duckdb_connect import connect
+    except ImportError:
+        return []
+
+    try:
+        conn = connect(Path(db_path))
+    except (RuntimeError, OSError):
+        return []
+
+    try:
+        # Check table existence — the table may not have been created yet.
+        tables = [
+            row[0]
+            for row in conn.execute(
+                "SELECT table_name FROM information_schema.tables "
+                "WHERE table_name = 'plugin_trust_transitions'"
+            ).fetchall()
+        ]
+        if not tables:
+            return []
+
+        clauses: list[str] = []
+        params: list[Any] = []
+        if plugin_id is not None:
+            clauses.append("plugin_id = ?")
+            params.append(plugin_id)
+        if since is not None:
+            clauses.append("transitioned_at >= ?")
+            params.append(since)
+
+        sql = "SELECT plugin_id, from_level, to_level, trigger, consecutive_ok, consecutive_fail, transitioned_at FROM plugin_trust_transitions"
+        if clauses:
+            sql += " WHERE " + " AND ".join(clauses)
+        sql += " ORDER BY transitioned_at ASC"
+
+        rows = conn.execute(sql, params).fetchall()
+        return [
+            TrustTransitionRecord(
+                plugin_id=r[0],
+                from_level=r[1],
+                to_level=r[2],
+                trigger=r[3],
+                consecutive_ok=r[4],
+                consecutive_fail=r[5],
+                transitioned_at=r[6],
+            )
+            for r in rows
+        ]
+    except Exception:  # noqa: BLE001 - query is best-effort
+        logger.debug("trust_history query failed", exc_info=True)
+        return []
+    finally:
+        conn.close()
diff --git a/src/leapflow/plugins/proposal_orchestrator.py b/src/leapflow/plugins/proposal_orchestrator.py
index a8e893c2..2eb664d9 100644
--- a/src/leapflow/plugins/proposal_orchestrator.py
+++ b/src/leapflow/plugins/proposal_orchestrator.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from datetime import datetime, timezone
 from typing import Any, Mapping, Protocol, runtime_checkable
 
 from leapflow.evolution.artifact_store import ContentAddressedArtifactStore
@@ -239,28 +240,38 @@ def record_installed(
             metadata={"terminal_reason": reason} if target == "FAILED" else {},
         )
 
-    def supersede(self, proposal_id: str, *, replacement_id: str, reason: str) -> CapabilityProposalItem:
+    def supersede(self, proposal_id: str, *, replacement_id: str, reason: str = "") -> CapabilityProposalItem:
         """Close an uninstalled proposal in favor of a newer durable proposal."""
         return self._queue.transition(
             proposal_id,
             "SUPERSEDED",
-            metadata={"terminal_reason": reason, "replacement_proposal_id": replacement_id},
+            metadata={
+                "terminal_reason": reason,
+                "replacement_proposal_id": replacement_id,
+                "swept_at": datetime.now(timezone.utc).isoformat(),
+            },
         )
 
-    def expire(self, proposal_id: str, *, reason: str) -> CapabilityProposalItem:
+    def expire(self, proposal_id: str, *, reason: str = "") -> CapabilityProposalItem:
         """Close an uninstalled proposal whose review window has elapsed."""
         return self._queue.transition(
             proposal_id,
             "EXPIRED",
-            metadata={"terminal_reason": reason},
+            metadata={
+                "terminal_reason": reason,
+                "swept_at": datetime.now(timezone.utc).isoformat(),
+            },
         )
 
-    def record_noop(self, proposal_id: str, *, reason: str) -> CapabilityProposalItem:
+    def record_noop(self, proposal_id: str, *, reason: str = "") -> CapabilityProposalItem:
         """Close a proposal resolved without acquiring a new capability."""
         return self._queue.transition(
             proposal_id,
             "NO_OP",
-            metadata={"terminal_reason": reason},
+            metadata={
+                "terminal_reason": reason,
+                "swept_at": datetime.now(timezone.utc).isoformat(),
+            },
         )
 
     def _reject(
diff --git a/src/leapflow/plugins/tool_plugins/self_management.py b/src/leapflow/plugins/tool_plugins/self_management.py
index 005a35bf..0e9990b0 100644
--- a/src/leapflow/plugins/tool_plugins/self_management.py
+++ b/src/leapflow/plugins/tool_plugins/self_management.py
@@ -1,7 +1,7 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
 """Self-Management plugin — lets the Agent introspect and manage its own plugin composition.
 
-This is the Phase 2.4 Self-Modification MVP. It exposes twelve tools:
+This is the Phase 2.4 Self-Modification MVP. It exposes thirteen tools:
 
 Read-only governance (no approval needed):
     - plugin_list     : list all registered plugins across Tool/Gateway/LLM subsystems
@@ -1477,9 +1477,11 @@ async def _install_from_dsh_source(
             if not result.get("ok"):
                 return result
             try:
-                version_info = self._version_store().record_source(
+                version_store = self._version_store()
+                version_info = version_store.record_bundle(
                     prepared.plugin_id,
                     prepared.wrapper_path,
+                    prepared.final_root,
                     version=version_label,
                     metadata={
                         "source": "dsh_source",
@@ -2051,14 +2053,9 @@ async def _plugin_rollback_handler(
         except (ImportError, ValueError):
             is_dsh = False
         if is_dsh:
-            return {
-                "ok": False,
-                "error": (
-                    "DSH bundle rollback is not supported in P0; reinstall the desired "
-                    "source bundle after removing the current plugin"
-                ),
-                "failure_code": "dsh_rollback_unsupported",
-            }
+            return await self._plugin_rollback_dsh(
+                plugin_id, version, **kwargs
+            )
         approved, denial = await self._check_approval("rollback", plugin_id)
         if not approved:
             return {"ok": False, "error": denial, "requires_approval": True}
@@ -2114,6 +2111,70 @@ async def _plugin_rollback_handler(
                 response["rollback_error"] = restoration_error
             return response
 
+    async def _plugin_rollback_dsh(
+        self, plugin_id: str, version: str, **kwargs: Any
+    ) -> Dict[str, Any]:
+        """Rollback a DSH bundle plugin to a recorded directory-level snapshot."""
+        approved, denial = await self._check_approval("rollback", plugin_id)
+        if not approved:
+            return {"ok": False, "error": denial, "requires_approval": True}
+
+        from leapflow.plugins import reload_plugin
+
+        version_store = self._version_store()
+        wrapper_target = self._resolve_install_dir() / f"{plugin_id}.py"
+        bundle_target = self._resolve_dsh_install_dir() / plugin_id
+        metadata_snapshot = version_store.snapshot_state(plugin_id)
+        wrapper_snapshot = wrapper_target.read_bytes() if wrapper_target.exists() else None
+        try:
+            _result = version_store.rollback_bundle(
+                plugin_id, version, wrapper_target, bundle_target
+            )
+            fiber = reload_plugin(plugin_id)
+            response: Dict[str, Any] = {
+                "ok": True,
+                "action": "rollback",
+                "plugin_id": plugin_id,
+                "version": version,
+                "bundle": True,
+                "state": fiber.state.value,
+                "new_generation": fiber.generation,
+            }
+            from leapflow.domain.event_types import EvolutionEventType
+
+            persisted = await self._emit_plugin_event(
+                EvolutionEventType.PLUGIN_ROLLED_BACK,
+                plugin_id=plugin_id,
+                version_id=version,
+                payload=response,
+                dedup_suffix=f"{version}:{fiber.generation}",
+            )
+            if not persisted:
+                response["audit_incomplete"] = True
+            return response
+        except (KeyError, RuntimeError, OSError, AttributeError, FileNotFoundError) as exc:
+            restoration_error = ""
+            try:
+                version_store.restore_source(wrapper_target, wrapper_snapshot)
+                version_store.restore_state(plugin_id, metadata_snapshot)
+                reload_plugin(plugin_id)
+            except (KeyError, RuntimeError, OSError, AttributeError) as restore_exc:
+                restoration_error = str(restore_exc)
+                logger.error(
+                    "DSH bundle rollback could not restore the previous runtime: %s",
+                    restore_exc,
+                    exc_info=True,
+                )
+            logger.warning("DSH bundle rollback failed: %s", exc, exc_info=True)
+            response = {
+                "ok": False,
+                "error": f"DSH bundle rollback failed: {exc}",
+                "rolled_back": restoration_error == "",
+            }
+            if restoration_error:
+                response["rollback_error"] = restoration_error
+            return response
+
     async def _plugin_enable_handler(self, plugin_id: str, **kwargs: Any) -> Dict[str, Any]:
         """Re-enable a previously disabled plugin. REQUIRES approval.
 
@@ -2278,6 +2339,108 @@ async def _plugin_reload_handler(
         except RuntimeError as exc:
             return {"ok": False, "error": f"Reload failed: {exc}"}
 
+    async def _plugin_unquarantine_handler(self, plugin_id: str, **kwargs: Any) -> Dict[str, Any]:
+        """Restore a quarantined plugin to probation for re-evaluation."""
+        if plugin_id == "self_management":
+            return {"ok": False, "error": "Cannot unquarantine self_management (not quarantined)"}
+
+        # Approval gate — forces HIGH risk via platform="plugin_management"
+        approved, denial = await self._check_approval(
+            "unquarantine", plugin_id,
+            metadata={"platform": "plugin_management"},
+        )
+        if not approved:
+            return {"ok": False, "error": denial, "requires_approval": True}
+
+        # Confirm the plugin is actually in QUARANTINED status via proposal store
+        lifecycle_store = self._capability_lifecycle_store
+        proposal = None
+        quarantine_reason = ""
+        if lifecycle_store is not None:
+            try:
+                for item in lifecycle_store.list_items(status="QUARANTINED", limit=0):
+                    pid = str(item.metadata.get("plugin_id") or "")
+                    if pid == plugin_id:
+                        proposal = item
+                        quarantine_reason = str(item.metadata.get("terminal_reason") or "")
+                        break
+            except (AttributeError, RuntimeError) as exc:
+                logger.warning("unquarantine: proposal lookup failed: %s", exc)
+
+        if proposal is None:
+            return {
+                "ok": False,
+                "error": f"Plugin '{plugin_id}' is not in QUARANTINED status",
+            }
+
+        # Unfreeze the trust ledger — resets to DRAFT
+        unfrozen = False
+        try:
+            from leapflow.learning.plugin_advisor import get_default_advisor
+
+            advisor = get_default_advisor()
+            if advisor is not None:
+                unfrozen = advisor._trust_ledger.unfreeze(plugin_id)
+        except (ImportError, AttributeError, RuntimeError) as exc:
+            logger.warning("unquarantine: trust unfreeze failed: %s", exc)
+
+        # Transition proposal: QUARANTINED -> PROBATION
+        try:
+            lifecycle_store.transition(
+                proposal.proposal_id,
+                "PROBATION",
+                metadata={"unquarantine_reason": "manual_recovery"},
+            )
+        except (ValueError, KeyError, RuntimeError) as exc:
+            return {
+                "ok": False,
+                "error": f"Proposal transition failed: {exc}",
+                "trust_unfrozen": unfrozen,
+            }
+
+        # Reload the plugin fiber
+        reload_ok = False
+        reload_error = ""
+        try:
+            from leapflow.plugins import reload_plugin
+
+            reload_plugin(plugin_id)
+            reload_ok = True
+        except (KeyError, RuntimeError, ImportError) as exc:
+            reload_error = str(exc)
+            logger.warning("unquarantine: reload failed: %s", exc)
+
+        # Emit PLUGIN_UNQUARANTINED event
+        try:
+            from leapflow.domain.event_types import EvolutionEventType
+
+            await self._emit_plugin_event(
+                EvolutionEventType.PLUGIN_UNQUARANTINED,
+                plugin_id=plugin_id,
+                proposal_id=proposal.proposal_id,
+                payload={
+                    "plugin_id": plugin_id,
+                    "original_quarantine_reason": quarantine_reason,
+                    "trust_unfrozen": unfrozen,
+                    "reload_ok": reload_ok,
+                },
+                dedup_suffix=f"{proposal.proposal_id}:unquarantine",
+            )
+        except Exception:  # noqa: BLE001
+            logger.debug("unquarantine event emission failed", exc_info=True)
+
+        response: Dict[str, Any] = {
+            "ok": True,
+            "plugin_id": plugin_id,
+            "status": "PROBATION",
+            "trust": "DRAFT",
+            "trust_unfrozen": unfrozen,
+            "reload_ok": reload_ok,
+        }
+        if reload_error:
+            response["reload_error"] = reload_error
+        return response
+
     async def _plugin_disable_handler(self, plugin_id: str, **kwargs: Any) -> Dict[str, Any]:
         """Disable a plugin by disposing its fiber. REQUIRES approval.
 
@@ -2778,6 +2941,37 @@ def tools(self) -> list[ToolMetadata]:
                 provides_capabilities=("plugin.remove",),
                 requires_platform_capabilities=("file.ops",),
             ),
+            ToolMetadata(
+                name="plugin_unquarantine",
+                description=(
+                    "Restore a quarantined plugin to probation status for re-evaluation. "
+                    "Unfreezes the trust ledger, transitions the proposal back to PROBATION, "
+                    "and reloads the plugin. REQUIRES APPROVAL."
+                ),
+                parameters_schema={
+                    "type": "object",
+                    "properties": {
+                        "plugin_id": {
+                            "type": "string",
+                            "description": "The plugin identifier to unquarantine.",
+                        },
+                    },
+                    "required": ["plugin_id"],
+                },
+                handler=self._plugin_unquarantine_handler,
+                x_leapflow={
+                    "category": "plugin_management",
+                    "risk_level": "high",
+                    "schema_cost": "medium",
+                    "requires_approval": True,
+                    "effect_scope": "local",
+                    "idempotency_scope": "session",
+                    "summary": "restore a quarantined plugin to probation (approval required)",
+                },
+                mutates_state=True,
+                provides_capabilities=("plugin.unquarantine",),
+                requires_platform_capabilities=("file.ops",),
+            ),
             ToolMetadata(
                 name="plugin_enable",
                 description=(
diff --git a/src/leapflow/storage/capability_proposal_queue.py b/src/leapflow/storage/capability_proposal_queue.py
index b4947d7b..c26e382d 100644
--- a/src/leapflow/storage/capability_proposal_queue.py
+++ b/src/leapflow/storage/capability_proposal_queue.py
@@ -43,7 +43,7 @@
     "INSTALLED": frozenset({"PROBATION", "QUARANTINED", "FAILED"}),
     "PROBATION": frozenset({"VERIFIED", "QUARANTINED", "FAILED"}),
     "VERIFIED": frozenset({"PROBATION", "QUARANTINED", "FAILED"}),
-    "QUARANTINED": frozenset({"FAILED"}),
+    "QUARANTINED": frozenset({"FAILED", "PROBATION"}),
     "REJECTED": frozenset(),
     "FAILED": frozenset(),
     "SUPERSEDED": frozenset(),
@@ -72,6 +72,7 @@ class CapabilityProposalItem:
     trust_state: Mapping[str, Any] = field(default_factory=dict)
     created_at: float = 0.0
     updated_at: float = 0.0
+    expires_at: float | None = None
     metadata: Mapping[str, Any] = field(default_factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -92,6 +93,7 @@ def to_dict(self) -> dict[str, Any]:
             "trust_state": dict(self.trust_state),
             "created_at": self.created_at,
             "updated_at": self.updated_at,
+            "expires_at": self.expires_at,
             "metadata": dict(self.metadata),
         }
 
@@ -118,6 +120,7 @@ def from_dict(cls, data: Mapping[str, Any]) -> "CapabilityProposalItem":
             trust_state=dict(data.get("trust_state") or {}),
             created_at=float(data.get("created_at") or 0.0),
             updated_at=float(data.get("updated_at") or 0.0),
+            expires_at=_coerce_optional_float(data.get("expires_at")),
             metadata=dict(data.get("metadata") or {}),
         )
 
@@ -141,9 +144,16 @@ def from_dict(cls, data: Mapping[str, Any]) -> "CapabilityProposalItem":
 class EvolutionCapabilityProposalStore:
     """Event-sourced capability proposal lifecycle used by production runtime."""
 
-    def __init__(self, event_store: Any, *, profile_id: str) -> None:
+    def __init__(
+        self,
+        event_store: Any,
+        *,
+        profile_id: str,
+        proposal_ttl_hours: int = 72,
+    ) -> None:
         self._event_store = event_store
         self._profile_id = str(profile_id)
+        self._proposal_ttl_hours = max(0, int(proposal_ttl_hours))
         self._lock = threading.RLock()
 
     def enqueue(
@@ -194,6 +204,11 @@ def prepare_enqueue(
             if existing is not None:
                 return existing, None
             now = time.time() if occurred_at is None else float(occurred_at)
+            expires_at = (
+                now + self._proposal_ttl_hours * 3600.0
+                if self._proposal_ttl_hours > 0
+                else None
+            )
             item = CapabilityProposalItem(
                 proposal_id=proposal_id,
                 status="PENDING",
@@ -204,6 +219,7 @@ def prepare_enqueue(
                 observation_ids=tuple(str(item) for item in observation_ids),
                 created_at=now,
                 updated_at=now,
+                expires_at=expires_at,
                 metadata=dict(metadata or {}),
             )
             return item, self._state_event(item, previous_status="")
@@ -285,6 +301,7 @@ def update(
                 ),
                 created_at=item.created_at,
                 updated_at=time.time(),
+                expires_at=item.expires_at,
                 metadata={**dict(item.metadata), **dict(metadata or {})},
             )
             return self._append_state(updated, previous_status=item.status)
@@ -429,6 +446,15 @@ def _proposal_identity(
     return "prop-" + content_hash(material)[:16]
 
 
+def _coerce_optional_float(value: Any) -> float | None:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
 def _coerce_status(value: Any) -> ProposalStatus:
     raw = str(value or "PENDING").upper()
     allowed = ProposalStatus.__args__  # type: ignore[attr-defined]
diff --git a/src/leapflow/storage/plugin_version_store.py b/src/leapflow/storage/plugin_version_store.py
index 595e7362..60677be5 100644
--- a/src/leapflow/storage/plugin_version_store.py
+++ b/src/leapflow/storage/plugin_version_store.py
@@ -3,8 +3,11 @@
 from __future__ import annotations
 
 import hashlib
+import io
 import json
 import os
+import shutil
+import tarfile
 import time
 from pathlib import Path
 from typing import Any
@@ -105,6 +108,144 @@ def rollback(self, plugin_id: str, version: str, target_path: Path) -> dict[str,
         entry = self.record_source(plugin_id, target, version=version, metadata={"rollback": True})
         return entry
 
+    # ── bundle (directory-level) snapshots ────────────────────────────
+
+    def record_bundle(
+        self,
+        plugin_id: str,
+        wrapper_path: Path,
+        bundle_dir: Path,
+        *,
+        version: str = "",
+        metadata: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Create a tar.gz archive of *wrapper_path* and *bundle_dir* and record it."""
+        wrapper = Path(wrapper_path)
+        bundle = Path(bundle_dir)
+        if not wrapper.is_file():
+            raise FileNotFoundError(f"Wrapper not found: {wrapper}")
+        if not bundle.is_dir():
+            raise NotADirectoryError(f"Bundle directory not found: {bundle}")
+
+        # Derive version from combined content hash when unspecified.
+        sha_hasher = hashlib.sha256()
+        sha_hasher.update(wrapper.read_bytes())
+        for p in sorted(bundle.rglob("*")):
+            if p.is_file():
+                sha_hasher.update(p.read_bytes())
+        bundle_sha256 = sha_hasher.hexdigest()
+        version_id = str(version or f"sha-{bundle_sha256[:12]}")
+
+        plugin_dir = self._plugin_dir(plugin_id)
+        versions_dir = plugin_dir / "versions"
+        versions_dir.mkdir(parents=True, exist_ok=True)
+        archive_path = versions_dir / f"{version_id}_bundle.tar.gz"
+
+        # Build archive in memory then write atomically.
+        buf = io.BytesIO()
+        with tarfile.open(fileobj=buf, mode="w:gz") as tar:
+            tar.add(str(wrapper), arcname=f"wrapper/{wrapper.name}")
+            tar.add(str(bundle), arcname="bundle")
+        archive_bytes = buf.getvalue()
+        self._write_bytes(archive_path, archive_bytes)
+
+        entry: dict[str, Any] = {
+            "plugin_id": plugin_id,
+            "version": version_id,
+            "source_path": str(wrapper),
+            "snapshot_path": str(archive_path),
+            "sha256": hashlib.sha256(wrapper.read_bytes()).hexdigest(),
+            "bundle_sha256": bundle_sha256,
+            "is_bundle": True,
+            "created_at": time.time(),
+            "metadata": dict(metadata or {}),
+        }
+        index = [
+            item for item in self._read_index(plugin_id)
+            if item.get("version") != version_id
+        ]
+        index.append(entry)
+        self._write_json(plugin_dir / "versions.json", index)
+        self._write_json(plugin_dir / "active.json", entry)
+        return entry
+
+    def rollback_bundle(
+        self,
+        plugin_id: str,
+        version: str,
+        wrapper_target: Path,
+        bundle_target_dir: Path,
+    ) -> dict[str, Any]:
+        """Restore a bundle snapshot previously recorded with *record_bundle*."""
+        entry: dict[str, Any] | None = None
+        for item in self._read_index(plugin_id):
+            if str(item.get("version")) == str(version) and item.get("is_bundle"):
+                entry = item
+                break
+        if entry is None:
+            raise KeyError(f"Bundle version not found: {plugin_id}@{version}")
+        archive_path = Path(str(entry["snapshot_path"]))
+        if not archive_path.exists():
+            raise FileNotFoundError(f"Bundle archive missing: {archive_path}")
+
+        expected_sha = str(entry.get("bundle_sha256", ""))
+        wrapper_dest = Path(wrapper_target)
+        bundle_dest = Path(bundle_target_dir)
+
+        # Extract into a temporary staging directory, then promote.
+        staging = bundle_dest.parent / f".rollback_staging_{plugin_id}_{os.getpid()}"
+        try:
+            if staging.exists():
+                shutil.rmtree(staging)
+            staging.mkdir(parents=True, exist_ok=True)
+            with tarfile.open(archive_path, "r:gz") as tar:
+                tar.extractall(staging, filter="data")
+
+            # Locate extracted artefacts.
+            extracted_wrapper_dir = staging / "wrapper"
+            extracted_bundle_dir = staging / "bundle"
+            if not extracted_bundle_dir.is_dir():
+                raise RuntimeError("Archive does not contain a bundle directory")
+            wrapper_files = list(extracted_wrapper_dir.iterdir()) if extracted_wrapper_dir.is_dir() else []
+            if not wrapper_files:
+                raise RuntimeError("Archive does not contain a wrapper file")
+            extracted_wrapper = wrapper_files[0]
+
+            # Verify SHA-256 integrity.
+            sha_hasher = hashlib.sha256()
+            sha_hasher.update(extracted_wrapper.read_bytes())
+            for p in sorted(extracted_bundle_dir.rglob("*")):
+                if p.is_file():
+                    sha_hasher.update(p.read_bytes())
+            actual_sha = sha_hasher.hexdigest()
+            if expected_sha and actual_sha != expected_sha:
+                raise RuntimeError(
+                    f"Bundle integrity check failed: expected {expected_sha[:16]}…, "
+                    f"got {actual_sha[:16]}…"
+                )
+
+            # Promote: replace wrapper and bundle directory atomically-ish.
+            wrapper_dest.parent.mkdir(parents=True, exist_ok=True)
+            self._write_bytes(wrapper_dest, extracted_wrapper.read_bytes())
+            if bundle_dest.exists():
+                shutil.rmtree(bundle_dest)
+            shutil.copytree(extracted_bundle_dir, bundle_dest)
+
+            # Update version index to mark this version active.
+            result_entry = dict(entry)
+            result_entry["metadata"] = {**result_entry.get("metadata", {}), "rollback": True}
+            idx = [
+                item for item in self._read_index(plugin_id)
+                if item.get("version") != version
+            ]
+            idx.append(result_entry)
+            plugin_dir = self._plugin_dir(plugin_id)
+            self._write_json(plugin_dir / "versions.json", idx)
+            self._write_json(plugin_dir / "active.json", result_entry)
+            return {"ok": True, "plugin_id": plugin_id, "version": version, "bundle": True}
+        finally:
+            shutil.rmtree(staging, ignore_errors=True)
+
     def _plugin_dir(self, plugin_id: str) -> Path:
         return self._root / str(plugin_id)
 
diff --git a/src/leapflow/storage/schema.py b/src/leapflow/storage/schema.py
index 9c3c524f..5b227d6d 100644
--- a/src/leapflow/storage/schema.py
+++ b/src/leapflow/storage/schema.py
@@ -5,6 +5,16 @@
 schema here rather than running ad-hoc CREATE TABLE in its own __init__.
 
 Migration is version-tracked via a ``_schema_version`` table.
+
+**Every migration must be idempotent.** The version integer records how far a
+database has been advanced, but it cannot guarantee that a migration's *contents*
+match the physical objects present -- an intermediate build may have created an
+object under a different version, and a crash between a DDL statement and the
+version bump can leave a migration half-applied. So every statement uses
+``CREATE ... IF NOT EXISTS`` / ``DROP ... IF EXISTS`` / ``ADD COLUMN IF NOT EXISTS``
+and re-running it against a database that already holds the object is a safe no-op.
+A non-idempotent ``CREATE`` here is a latent startup crash: it aborts the whole
+bootstrap transaction the first time a pre-existing object is met.
 """
 from __future__ import annotations
 
@@ -375,7 +385,7 @@ def _apply_evolution_tables(conn: duckdb.DuckDBPyConnection) -> None:
     """Create the append-only event stream and durable cold-path work queues."""
     statements = (
         """
-        CREATE TABLE evolution_events (
+        CREATE TABLE IF NOT EXISTS evolution_events (
             sequence BIGINT NOT NULL,
             event_id VARCHAR PRIMARY KEY,
             event_type VARCHAR NOT NULL,
@@ -407,7 +417,7 @@ def _apply_evolution_tables(conn: duckdb.DuckDBPyConnection) -> None:
         )
         """,
         """
-        CREATE TABLE evolution_teacher_jobs (
+        CREATE TABLE IF NOT EXISTS evolution_teacher_jobs (
             job_id VARCHAR PRIMARY KEY,
             profile_id VARCHAR NOT NULL,
             workspace_id VARCHAR NOT NULL DEFAULT '',
@@ -433,10 +443,10 @@ def _apply_evolution_tables(conn: duckdb.DuckDBPyConnection) -> None:
             UNIQUE(profile_id, episode_id)
         )
         """,
-        "CREATE INDEX idx_evo_event_session ON evolution_events(profile_id, session_id, sequence)",
-        "CREATE INDEX idx_evo_event_correlation ON evolution_events(profile_id, correlation_id, sequence)",
-        "CREATE INDEX idx_evo_event_type ON evolution_events(profile_id, event_type, sequence)",
-        "CREATE INDEX idx_evo_teacher_status ON evolution_teacher_jobs(profile_id, status, next_attempt_at)",
+        "CREATE INDEX IF NOT EXISTS idx_evo_event_session ON evolution_events(profile_id, session_id, sequence)",
+        "CREATE INDEX IF NOT EXISTS idx_evo_event_correlation ON evolution_events(profile_id, correlation_id, sequence)",
+        "CREATE INDEX IF NOT EXISTS idx_evo_event_type ON evolution_events(profile_id, event_type, sequence)",
+        "CREATE INDEX IF NOT EXISTS idx_evo_teacher_status ON evolution_teacher_jobs(profile_id, status, next_attempt_at)",
     )
     for statement in statements:
         conn.execute(statement)
@@ -445,11 +455,11 @@ def _apply_evolution_tables(conn: duckdb.DuckDBPyConnection) -> None:
 def _apply_evolution_sequence(conn: duckdb.DuckDBPyConnection) -> None:
     """Create a database-global cursor after any pre-sequence event rows."""
     conn.execute(
-        "CREATE UNIQUE INDEX idx_evo_event_sequence ON evolution_events(sequence)"
+        "CREATE UNIQUE INDEX IF NOT EXISTS idx_evo_event_sequence ON evolution_events(sequence)"
     )
     row = conn.execute("SELECT COALESCE(MAX(sequence), 0) + 1 FROM evolution_events").fetchone()
     start = max(1, int(row[0] if row else 1))
-    conn.execute(f"CREATE SEQUENCE evolution_event_sequence START {start}")
+    conn.execute(f"CREATE SEQUENCE IF NOT EXISTS evolution_event_sequence START {start}")
 
 
 def _apply_teacher_job_context(conn: duckdb.DuckDBPyConnection) -> None:
@@ -473,7 +483,7 @@ def _apply_evolution_projection(conn: duckdb.DuckDBPyConnection) -> None:
     """Create checkpointed read models derived exclusively from the event stream."""
     conn.execute(
         """
-        CREATE TABLE evolution_projections (
+        CREATE TABLE IF NOT EXISTS evolution_projections (
             projection_name VARCHAR NOT NULL,
             profile_id VARCHAR NOT NULL,
             scope_key VARCHAR NOT NULL,
@@ -490,7 +500,7 @@ def _apply_proposal_event_index(conn: duckdb.DuckDBPyConnection) -> None:
     """Retire the unused work table and index event-sourced proposal replay."""
     conn.execute("DROP TABLE IF EXISTS evolution_proposal_work")
     conn.execute(
-        "CREATE INDEX idx_evo_event_proposal "
+        "CREATE INDEX IF NOT EXISTS idx_evo_event_proposal "
         "ON evolution_events(profile_id, proposal_id, sequence)"
     )
 
diff --git a/tests/test_coevolution_sweep_wiring.py b/tests/test_coevolution_sweep_wiring.py
index b2e94f04..a099589e 100644
--- a/tests/test_coevolution_sweep_wiring.py
+++ b/tests/test_coevolution_sweep_wiring.py
@@ -15,6 +15,8 @@
 from __future__ import annotations
 
 import asyncio
+import time
+from pathlib import Path
 
 from leapflow.domain.capability_requirement import CapabilityRequirement
 from leapflow.domain.evolution_trace import EvolutionStage, EvolutionTrace
@@ -75,8 +77,8 @@ def test_empty_sweep_still_records_its_no_op_branches():
     try:
         outcome = asyncio.run(CoevolutionSweep().run())
         assert outcome == SweepOutcome()
-        # All three segments reported, each flagged as a no-op.
-        assert sink.kinds() == {"effect_verification", "quarantine_drain", "reclamation"}
+        # All four segments reported, each flagged as a no-op.
+        assert sink.kinds() == {"effect_verification", "quarantine_drain", "proposal_expiry", "reclamation"}
         assert all(t.detail.get("no_op") for t in sink.traces)
     finally:
         _teardown()
@@ -292,8 +294,8 @@ def test_production_sweep_hook_builds_and_runs_a_real_sweep():
         assert outcome.refuted == 1                                  # WM-6 wired
         assert len(outcome.quarantined) == 1                         # A-4 wired
         assert [c.plugin_id for c in outcome.reclamation] == ["gen_overrisk"]  # LF-10 wired
-        # All three dashboard segments now have observed output.
-        assert sink.kinds() == {"effect_verification", "quarantine_drain", "reclamation"}
+        # All four dashboard segments now have observed output.
+        assert sink.kinds() == {"effect_verification", "quarantine_drain", "proposal_expiry", "reclamation"}
         assert outcome.to_dict()["quarantined"] == 1
         # Verifications were drained, so a second sweep cannot double-govern them.
         assert buf.drain_verifications() == ()
@@ -413,3 +415,155 @@ def test_gap_gate_excludes_unauthorised_origins(tmp_path):
 
     # And with nothing authorised, the gate is empty rather than permissive.
     assert loop.unmet_requirements([shipped], _env(), authorising_origins=("world_model",)) == ()
+
+
+# ── proposal expiry sweep tests ───────────────────────────────────────────────
+
+
+def _proposal_queue(tmp_path: Path, *, ttl_hours: int = 72):
+    from leapflow.storage.capability_proposal_queue import EvolutionCapabilityProposalStore
+    from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+
+    events = DuckDBEvolutionEventStore(tmp_path / "events.duckdb")
+    return EvolutionCapabilityProposalStore(events, profile_id="sweep-p", proposal_ttl_hours=ttl_hours)
+
+
+def _orchestrator(queue):
+    from leapflow.evolution.artifact_store import ContentAddressedArtifactStore
+    from leapflow.plugins.adaptive_policy import AdaptiveEvolutionPolicy
+    from leapflow.plugins.proposal_orchestrator import ProposalOrchestrator
+    import tempfile
+
+    return ProposalOrchestrator(
+        queue=queue,
+        artifact_store=ContentAddressedArtifactStore(Path(tempfile.mkdtemp()) / "artifacts"),
+        approval_gate=None,
+        policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+    )
+
+
+def test_sweep_expires_stale_proposals(tmp_path: Path):
+    """A proposal with expires_at in the past is swept to EXPIRED."""
+    queue = _proposal_queue(tmp_path / "expire", ttl_hours=0)
+    # Create with an explicit past expires_at via low-level update
+    item = queue.enqueue(
+        requirements=(CapabilityRequirement.create("chat.reply", "world_model", requirement_id="req-exp"),),
+    )
+    # Manually set expires_at in the past by re-creating with occurred_at far back
+    # Since ttl_hours=0 means expires_at=None, we need a different approach.
+    # Use a queue with ttl_hours=1, but create with occurred_at far in the past.
+    queue2 = _proposal_queue(tmp_path / "expire2", ttl_hours=1)
+    item2 = queue2.enqueue(
+        requirements=(CapabilityRequirement.create("chat.stale", "world_model", requirement_id="req-stale"),),
+    )
+    # The item was created "now" with expires_at = now + 3600. Force expiry by
+    # creating a proposal with occurred_at far in the past.
+    queue3 = _proposal_queue(tmp_path / "expire3", ttl_hours=1)
+    past_item, ev = queue3.prepare_enqueue(
+        requirements=(CapabilityRequirement.create("chat.old", "world_model", requirement_id="req-old"),),
+        occurred_at=1.0,  # epoch second 1 = way in the past
+    )
+    assert ev is not None
+    queue3._event_store.append(ev)
+    assert past_item.expires_at is not None
+    assert past_item.expires_at < time.time()  # Definitely expired
+
+    orch = _orchestrator(queue3)
+    sink = _sink()
+    try:
+        outcome = asyncio.run(
+            CoevolutionSweep(
+                orchestrator=orch, proposal_store=queue3,
+            ).run()
+        )
+        assert outcome.expired == 1
+        refreshed = queue3.get(past_item.proposal_id)
+        assert refreshed is not None
+        assert refreshed.status == "EXPIRED"
+        assert refreshed.metadata["terminal_reason"] == "ttl_exceeded"
+    finally:
+        _teardown()
+
+
+def test_sweep_supersedes_outdated_proposal(tmp_path: Path):
+    """Two proposals with same requirements: the older is SUPERSEDED."""
+    queue = _proposal_queue(tmp_path / "supersede", ttl_hours=0)  # no TTL expiry
+    older, ev_old = queue.prepare_enqueue(
+        requirements=(CapabilityRequirement.create("chat.reply", "world_model", requirement_id="req-a"),),
+        occurred_at=100.0,
+    )
+    assert ev_old is not None
+    queue._event_store.append(ev_old)
+
+    newer, ev_new = queue.prepare_enqueue(
+        requirements=(CapabilityRequirement.create("chat.reply", "world_model", requirement_id="req-a"),),
+        environment={"fingerprint_id": "different"},  # different env => different proposal_id
+        occurred_at=200.0,
+    )
+    assert ev_new is not None
+    queue._event_store.append(ev_new)
+    assert older.proposal_id != newer.proposal_id
+
+    orch = _orchestrator(queue)
+    sink = _sink()
+    try:
+        outcome = asyncio.run(
+            CoevolutionSweep(
+                orchestrator=orch, proposal_store=queue,
+            ).run()
+        )
+        assert outcome.superseded == 1
+        old_item = queue.get(older.proposal_id)
+        assert old_item is not None
+        assert old_item.status == "SUPERSEDED"
+        new_item = queue.get(newer.proposal_id)
+        assert new_item is not None
+        assert new_item.status == "PENDING"  # newer remains active
+    finally:
+        _teardown()
+
+
+def test_proposal_without_ttl_not_expired(tmp_path: Path):
+    """A proposal with expires_at=None is not touched by TTL sweep."""
+    queue = _proposal_queue(tmp_path / "no_ttl", ttl_hours=0)  # expires_at=None
+    item = queue.enqueue(
+        requirements=(CapabilityRequirement.create("chat.reply", "world_model", requirement_id="req-no-ttl"),),
+    )
+    assert item.expires_at is None
+
+    orch = _orchestrator(queue)
+    sink = _sink()
+    try:
+        outcome = asyncio.run(
+            CoevolutionSweep(
+                orchestrator=orch, proposal_store=queue,
+            ).run()
+        )
+        assert outcome.expired == 0
+        assert outcome.superseded == 0
+        refreshed = queue.get(item.proposal_id)
+        assert refreshed is not None
+        assert refreshed.status == "PENDING"  # unchanged
+    finally:
+        _teardown()
+
+
+def test_sweep_proposal_expiry_cold_path():
+    """Proposal expiry lives only in CoevolutionSweep.run(), never per-turn."""
+    import ast
+    import inspect
+    import textwrap
+    from leapflow.evolution.sweep import CoevolutionSweep
+
+    source = textwrap.dedent(inspect.getsource(CoevolutionSweep.run))
+    tree = ast.parse(source)
+    calls = [
+        node.func.attr
+        for node in ast.walk(tree)
+        if isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Attribute)
+        and "expir" in getattr(node.func, "attr", "").lower()
+    ]
+    assert "_sweep_proposal_expiry" in calls, (
+        "proposal_expiry must be called inside CoevolutionSweep.run()"
+    )
diff --git a/tests/test_dsh_bundle_rollback.py b/tests/test_dsh_bundle_rollback.py
new file mode 100644
index 00000000..f71e31c4
--- /dev/null
+++ b/tests/test_dsh_bundle_rollback.py
@@ -0,0 +1,156 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Tests for DSH directory-level bundle snapshot and rollback."""
+from __future__ import annotations
+
+import hashlib
+import tarfile
+from pathlib import Path
+
+import pytest
+
+from leapflow.storage.plugin_version_store import PluginVersionStore
+
+
+# ── helpers ───────────────────────────────────────────────────────
+
+def _make_bundle(tmp_path: Path, plugin_id: str = "my_dsh") -> tuple[Path, Path]:
+    """Create a wrapper .py file and a bundle directory with several files."""
+    wrapper = tmp_path / "plugins" / f"{plugin_id}.py"
+    wrapper.parent.mkdir(parents=True, exist_ok=True)
+    wrapper.write_text("# wrapper v1\nimport json\n", encoding="utf-8")
+
+    bundle = tmp_path / "dsh" / plugin_id
+    bundle.mkdir(parents=True, exist_ok=True)
+    (bundle / "index.js").write_text("module.exports = {};", encoding="utf-8")
+    (bundle / "package.json").write_text('{"name":"test"}', encoding="utf-8")
+    sub = bundle / "lib"
+    sub.mkdir()
+    (sub / "helper.js").write_text("exports.help = true;", encoding="utf-8")
+    return wrapper, bundle
+
+
+def _content_sha256(wrapper: Path, bundle: Path) -> str:
+    """Reproduce the combined SHA-256 used by record_bundle."""
+    h = hashlib.sha256()
+    h.update(wrapper.read_bytes())
+    for p in sorted(bundle.rglob("*")):
+        if p.is_file():
+            h.update(p.read_bytes())
+    return h.hexdigest()
+
+
+# ── tests ─────────────────────────────────────────────────────────
+
+def test_bundle_snapshot_and_restore_roundtrip(tmp_path: Path) -> None:
+    """record_bundle → delete originals → rollback_bundle restores everything."""
+    wrapper, bundle = _make_bundle(tmp_path)
+    store = PluginVersionStore(tmp_path / "versions")
+
+    entry = store.record_bundle("my_dsh", wrapper, bundle, version="v1")
+
+    assert entry["version"] == "v1"
+    assert entry["is_bundle"] is True
+    assert entry["bundle_sha256"]
+    assert Path(entry["snapshot_path"]).exists()
+
+    # Capture original content for later comparison.
+    orig_wrapper = wrapper.read_text(encoding="utf-8")
+    orig_index = (bundle / "index.js").read_text(encoding="utf-8")
+    orig_helper = (bundle / "lib" / "helper.js").read_text(encoding="utf-8")
+
+    # Delete originals.
+    wrapper.unlink()
+    import shutil
+    shutil.rmtree(bundle)
+    assert not wrapper.exists()
+    assert not bundle.exists()
+
+    # Rollback.
+    result = store.rollback_bundle("my_dsh", "v1", wrapper, bundle)
+    assert result["ok"] is True
+    assert result["bundle"] is True
+
+    # Verify everything is restored.
+    assert wrapper.read_text(encoding="utf-8") == orig_wrapper
+    assert (bundle / "index.js").read_text(encoding="utf-8") == orig_index
+    assert (bundle / "lib" / "helper.js").read_text(encoding="utf-8") == orig_helper
+
+
+def test_rollback_bundle_restores_both_wrapper_and_dir(tmp_path: Path) -> None:
+    """Modify both wrapper and bundle after recording, rollback restores original."""
+    wrapper, bundle = _make_bundle(tmp_path)
+    store = PluginVersionStore(tmp_path / "versions")
+
+    store.record_bundle("my_dsh", wrapper, bundle, version="v1")
+
+    # Modify both wrapper and bundle content.
+    wrapper.write_text("# modified wrapper\n", encoding="utf-8")
+    (bundle / "index.js").write_text("MODIFIED", encoding="utf-8")
+    (bundle / "lib" / "helper.js").write_text("MODIFIED HELPER", encoding="utf-8")
+    (bundle / "new_file.txt").write_text("should disappear", encoding="utf-8")
+
+    result = store.rollback_bundle("my_dsh", "v1", wrapper, bundle)
+    assert result["ok"] is True
+
+    assert wrapper.read_text(encoding="utf-8") == "# wrapper v1\nimport json\n"
+    assert (bundle / "index.js").read_text(encoding="utf-8") == "module.exports = {};"
+    assert (bundle / "lib" / "helper.js").read_text(encoding="utf-8") == "exports.help = true;"
+    # The extra file added after recording should be gone (dir was replaced).
+    assert not (bundle / "new_file.txt").exists()
+
+
+def test_rollback_bundle_with_sha256_mismatch_fails(tmp_path: Path) -> None:
+    """Tampering with the stored archive triggers an integrity error."""
+    wrapper, bundle = _make_bundle(tmp_path)
+    store = PluginVersionStore(tmp_path / "versions")
+
+    entry = store.record_bundle("my_dsh", wrapper, bundle, version="v1")
+    archive_path = Path(entry["snapshot_path"])
+
+    # Tamper: rewrite the archive with different content.
+    tampered_wrapper = tmp_path / "tampered.py"
+    tampered_wrapper.write_text("# TAMPERED\n", encoding="utf-8")
+    tampered_bundle = tmp_path / "tampered_bundle"
+    tampered_bundle.mkdir()
+    (tampered_bundle / "bad.js").write_text("BAD", encoding="utf-8")
+    import io
+    buf = io.BytesIO()
+    with tarfile.open(fileobj=buf, mode="w:gz") as tar:
+        tar.add(str(tampered_wrapper), arcname=f"wrapper/{tampered_wrapper.name}")
+        tar.add(str(tampered_bundle), arcname="bundle")
+    archive_path.write_bytes(buf.getvalue())
+
+    with pytest.raises(RuntimeError, match="integrity check failed"):
+        store.rollback_bundle("my_dsh", "v1", wrapper, bundle)
+
+
+def test_rollback_bundle_missing_version_raises_key_error(tmp_path: Path) -> None:
+    """Attempting to rollback to a non-existent bundle version raises KeyError."""
+    store = PluginVersionStore(tmp_path / "versions")
+    wrapper = tmp_path / "w.py"
+    bundle = tmp_path / "b"
+
+    with pytest.raises(KeyError, match="Bundle version not found"):
+        store.rollback_bundle("ghost", "v99", wrapper, bundle)
+
+
+def test_record_bundle_updates_active_and_index(tmp_path: Path) -> None:
+    """Recording two bundle versions tracks both and points active to the latest."""
+    wrapper, bundle = _make_bundle(tmp_path)
+    store = PluginVersionStore(tmp_path / "versions")
+
+    store.record_bundle("my_dsh", wrapper, bundle, version="v1")
+    # Modify and record v2.
+    (bundle / "index.js").write_text("v2 content", encoding="utf-8")
+    wrapper.write_text("# wrapper v2\n", encoding="utf-8")
+    store.record_bundle("my_dsh", wrapper, bundle, version="v2")
+
+    versions = store.versions("my_dsh")
+    version_ids = [v["version"] for v in versions]
+    assert "v1" in version_ids
+    assert "v2" in version_ids
+
+    active = store.active("my_dsh")
+    assert active is not None
+    assert active["version"] == "v2"
+    assert active["is_bundle"] is True
diff --git a/tests/test_evolution_event_store.py b/tests/test_evolution_event_store.py
index 73a9ceb8..738f0302 100644
--- a/tests/test_evolution_event_store.py
+++ b/tests/test_evolution_event_store.py
@@ -279,6 +279,58 @@ def test_schema_upgrades_a_v1_database_in_order(tmp_path: Path) -> None:
     connection.close()
 
 
+def test_schema_heals_an_intermediate_build_with_preexisting_objects(tmp_path: Path) -> None:
+    """An intermediate build recorded version 2 but already created a later
+    migration's object (``idx_evo_event_sequence``). Non-idempotent DDL then aborts
+    startup with 'Index ... already exists'. Every migration must be idempotent so
+    such a database self-heals in place, and re-running is a no-op.
+    """
+    from leapflow.storage import schema as schema_mod
+
+    connection = duckdb.connect(str(tmp_path / "intermediate.duckdb"))
+    for table_def in schema_mod.TABLES:
+        connection.execute(table_def.ddl)
+        for idx_sql in table_def.indexes:
+            connection.execute(idx_sql)
+    # Real migration-2 objects, plus the sequence index a later build created under v2.
+    schema_mod._apply_evolution_tables(connection)
+    connection.execute(
+        "CREATE UNIQUE INDEX idx_evo_event_sequence ON evolution_events(sequence)"
+    )
+    # A real database that reached v2 recorded the base version first, then v2.
+    connection.execute("INSERT INTO _schema_version VALUES (1, 0.0)")
+    connection.execute("INSERT INTO _schema_version VALUES (2, 0.0)")
+
+    assert ensure_schema(connection) == CURRENT_SCHEMA_VERSION
+    assert ensure_schema(connection) == CURRENT_SCHEMA_VERSION, "re-run must be a no-op"
+    assert [
+        row[0]
+        for row in connection.execute(
+            "SELECT version FROM _schema_version ORDER BY version"
+        ).fetchall()
+    ] == list(range(1, CURRENT_SCHEMA_VERSION + 1))
+    # The healed database is functional: the global sequence exists and advances.
+    assert connection.execute("SELECT nextval('evolution_event_sequence')").fetchone()[0] >= 1
+    connection.close()
+
+
+def test_every_evolution_migration_is_idempotent(tmp_path: Path) -> None:
+    """Applying each migration twice against the same connection must not raise.
+
+    Guards the class of defect directly: a non-idempotent ``CREATE`` in any migration
+    is a latent startup crash the first time it meets a pre-existing object.
+    """
+    from leapflow.storage import schema as schema_mod
+
+    connection = duckdb.connect(str(tmp_path / "idem.duckdb"))
+    for table_def in schema_mod.TABLES:
+        connection.execute(table_def.ddl)
+    for migration in schema_mod.MIGRATIONS:
+        migration.apply(connection)
+        migration.apply(connection)  # second application must be a safe no-op
+    connection.close()
+
+
 def test_event_payload_is_deeply_immutable_and_hash_checked() -> None:
     source = {"nested": {"items": [1, 2]}}
     event = EvolutionEvent.create(
diff --git a/tests/test_evolution_lifecycle_e2e.py b/tests/test_evolution_lifecycle_e2e.py
new file mode 100644
index 00000000..cc456ea3
--- /dev/null
+++ b/tests/test_evolution_lifecycle_e2e.py
@@ -0,0 +1,578 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""End-to-end evolution lifecycle: environment trigger through sweep.
+
+Single-process integration test covering the full governed pipeline
+introduced across Phases 1-4:
+
+    Phase A — Environment trigger → AdaptationVerdict → EvolutionIntent
+    Phase B — Capability gap detection → proposal enqueue
+    Phase C — Generate, validate, register (good + INCOMPATIBLE path)
+    Phase D — Dual approval → install → fiber ACTIVE → tool invocable
+    Phase E — Trust accrual (DRAFT→CANDIDATE), quarantine, unfreeze (Phase 2)
+    Phase F — Proposal TTL sweep (Phase 1)
+    Phase G — Event chain verification (causation/correlation)
+
+Modelled after ``test_llm_coevolution_e2e`` for the single-process setup
+but exercising every Phase 1-4 feature through their real APIs.
+"""
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+from typing import Any, Mapping
+
+import pytest
+
+# ---------------------------------------------------------------------------
+# Valid echo plugin code -- returned by the fake LLM
+# ---------------------------------------------------------------------------
+ECHO_PLUGIN_CODE = '''
+"""Auto-generated echo plugin for lifecycle E2E test."""
+from typing import Any
+from leapflow.plugins.protocol import ToolMetadata
+
+
+class EchoLifecyclePlugin:
+    """Echo plugin for the full lifecycle journey."""
+
+    @property
+    def plugin_id(self) -> str:
+        return "echo_lifecycle"
+
+    @property
+    def category(self) -> str:
+        return "custom"
+
+    @property
+    def dependencies(self) -> list:
+        return []
+
+    def bind_runtime(self, **deps: Any) -> None:
+        pass
+
+    @property
+    def tools(self) -> list:
+        return [ToolMetadata(
+            name="echo_lifecycle_test",
+            description="Echo tool for lifecycle E2E test",
+            parameters_schema={
+                "type": "object",
+                "properties": {
+                    "message": {"type": "string"},
+                },
+                "required": ["message"],
+            },
+            handler=self._echo_handler,
+            x_leapflow={"category": "custom", "risk_level": "read_only"},
+            provides_capabilities=("echo.lifecycle",),
+        )]
+
+    async def _echo_handler(self, message: str = "", **kwargs: Any) -> dict:
+        return {
+            "ok": True,
+            "echoed": message,
+            "source": "lifecycle_generated",
+            "observed_effect": "echoed the input message",
+        }
+
+
+plugin = EchoLifecyclePlugin()
+'''
+
+PLUGIN_ID = "echo_lifecycle"
+TOOL_NAME = "echo_lifecycle_test"
+PROFILE_ID = "test-lifecycle"
+
+
+# ---------------------------------------------------------------------------
+# Helpers / fakes
+# ---------------------------------------------------------------------------
+class _FakeLLM:
+    """Canned LLM returning the echo plugin code."""
+
+    async def achat(self, messages: Any) -> str:
+        return f"```python\n{ECHO_PLUGIN_CODE}\n```"
+
+
+class _ApprovedResult:
+    approved = True
+    denial_message = ""
+
+
+class _ApprovingGate:
+    """Always-approve gate for both content and mutation approval."""
+
+    async def evaluate(self, descriptor: Any) -> _ApprovedResult:
+        return _ApprovedResult()
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+@pytest.fixture
+def evolution_dirs(tmp_path: Path) -> dict[str, Path]:
+    """Create all scratch directories for the lifecycle test."""
+    dirs = {
+        "plugins": tmp_path / "plugins",
+        "artifacts": tmp_path / "artifacts",
+        "events_db": tmp_path / "events.duckdb",
+        "stats_db": tmp_path / "plugin_stats.duckdb",
+    }
+    dirs["plugins"].mkdir(parents=True, exist_ok=True)
+    dirs["artifacts"].mkdir(parents=True, exist_ok=True)
+    return dirs
+
+
+@pytest.fixture
+def event_store(evolution_dirs: dict[str, Path]) -> Any:
+    """A real DuckDB-backed evolution event store."""
+    from leapflow.storage.evolution_event_store import DuckDBEvolutionEventStore
+
+    return DuckDBEvolutionEventStore(evolution_dirs["events_db"])
+
+
+@pytest.fixture
+def proposal_store(event_store: Any) -> Any:
+    """A real proposal store wired to the event store."""
+    from leapflow.storage.capability_proposal_queue import (
+        EvolutionCapabilityProposalStore,
+    )
+
+    return EvolutionCapabilityProposalStore(
+        event_store, profile_id=PROFILE_ID, proposal_ttl_hours=72,
+    )
+
+
+@pytest.fixture
+def artifact_store(evolution_dirs: dict[str, Path]) -> Any:
+    """A real CAS artifact store."""
+    from leapflow.evolution.artifact_store import ContentAddressedArtifactStore
+
+    return ContentAddressedArtifactStore(evolution_dirs["artifacts"])
+
+
+@pytest.fixture
+def policy() -> Any:
+    """An evolution policy at generate_only autonomy (permits generation)."""
+    from leapflow.plugins.adaptive_policy import AdaptiveEvolutionPolicy
+
+    return AdaptiveEvolutionPolicy(autonomy_level="generate_only")
+
+
+@pytest.fixture
+def orchestrator(proposal_store: Any, artifact_store: Any, policy: Any) -> Any:
+    """A real ProposalOrchestrator wired to stores and approval."""
+    from leapflow.plugins.proposal_orchestrator import ProposalOrchestrator
+
+    return ProposalOrchestrator(
+        queue=proposal_store,
+        artifact_store=artifact_store,
+        approval_gate=_ApprovingGate(),
+        policy=policy,
+    )
+
+
+@pytest.fixture
+def trust_ledger() -> Any:
+    """A trust ledger with short thresholds for fast promotion."""
+    from leapflow.learning.plugin_trust import PluginTrustLedger
+
+    return PluginTrustLedger(
+        candidate_at=5, verified_at=20, production_at=50, demote_after=3,
+    )
+
+
+@pytest.fixture
+def stats_store(evolution_dirs: dict[str, Path]) -> Any:
+    """A real DuckDB-backed plugin stats store."""
+    from leapflow.learning.plugin_stats_store import PluginStatsStore
+
+    return PluginStatsStore(db_path=evolution_dirs["stats_db"])
+
+
+@pytest.fixture
+def cleanup_plugin():
+    """Tear down registry / sys.modules state after the test."""
+    yield
+    sys.modules.pop(PLUGIN_ID, None)
+    try:
+        from leapflow.plugins import get_registry, get_scoped_registry
+
+        reg = get_registry()
+        scoped = get_scoped_registry()
+        if PLUGIN_ID in reg.plugins:
+            reg.unregister_plugin(PLUGIN_ID)
+        if PLUGIN_ID in scoped._fibers:
+            fiber = scoped._fibers.pop(PLUGIN_ID)
+            try:
+                fiber.dispose()
+            except Exception:
+                pass
+    except Exception:
+        pass
+
+
+# ===================================================================
+# THE TEST
+# ===================================================================
+@pytest.mark.asyncio
+async def test_full_evolution_lifecycle(
+    evolution_dirs: dict[str, Path],
+    event_store: Any,
+    proposal_store: Any,
+    artifact_store: Any,
+    policy: Any,
+    orchestrator: Any,
+    trust_ledger: Any,
+    stats_store: Any,
+    cleanup_plugin: None,
+) -> None:
+    """Complete governed evolution pipeline, single-process."""
+
+    # ── Phase A — Environment Trigger and Intent ──────────────────
+    from leapflow.domain.adaptation_verdict import AdaptationVerdict
+
+    verdict = AdaptationVerdict.create(
+        action="acquire",
+        capability="echo.lifecycle",
+        knowledge="The runtime lacks an echo capability for lifecycle testing.",
+        rationale="No existing plugin provides echo.lifecycle.",
+        confidence=0.9,
+        max_risk_level="read_only",
+        evidence_ids=("obs-001", "obs-002"),
+    )
+    intent = verdict.to_intent()
+    assert intent is not None, "acquire verdict must produce an intent"
+    assert intent.capability == "echo.lifecycle"
+    assert intent.evidence_ids == ("obs-001", "obs-002")
+    assert intent.max_risk_level == "read_only"
+    # Identity is derived from the verdict, not minted fresh
+    assert verdict.verdict_id.removeprefix("adv-") in intent.intent_id
+
+    # ── Phase B — Capability Gap to Proposal ──────────────────────
+    from leapflow.domain.capability_requirement import CapabilityRequirement
+    from leapflow.learning.capability_gap_detector import CapabilityGapDetector
+
+    detector = CapabilityGapDetector()
+    plugin_proposal = detector.proposal_from_evolution_intent(intent)
+    assert plugin_proposal.plugin_id  # non-empty, derived from capability slug
+    assert plugin_proposal.risk_level == "read_only"
+
+    # Enqueue to the durable store
+    requirement = intent.to_requirement()
+    assert isinstance(requirement, CapabilityRequirement)
+    item = proposal_store.enqueue(
+        requirements=[requirement],
+        environment={"fingerprint_id": "test-fp", "workspace_id": "ws-lifecycle"},
+        risk={"risk_level": "read_only"},
+        source="world_model",
+        observation_ids=list(intent.evidence_ids),
+        metadata={"plugin_id": PLUGIN_ID},
+    )
+    assert item.status == "PENDING"
+    proposal_id = item.proposal_id
+
+    # Re-enqueue is idempotent
+    item2 = proposal_store.enqueue(
+        requirements=[requirement],
+        environment={"fingerprint_id": "test-fp", "workspace_id": "ws-lifecycle"},
+    )
+    assert item2.proposal_id == proposal_id, "re-enqueue must be idempotent"
+
+    # ── Phase C — Generate and Validate ───────────────────────────
+    from leapflow.learning.plugin_generator import (
+        PluginGenerationRequest,
+        PluginGenerator,
+    )
+
+    generator = PluginGenerator(llm_provider=_FakeLLM())
+    gen_result = await generator.generate_and_validate(
+        PluginGenerationRequest(
+            plugin_id=PLUGIN_ID,
+            description="Echo tool for lifecycle testing",
+            provides_capabilities=("echo.lifecycle",),
+        ),
+    )
+    assert gen_result["ok"], f"Generation failed: {gen_result.get('error')}"
+    assert TOOL_NAME in gen_result["exposed_tools"]
+    generated_code = gen_result["code"]
+
+    # Register through the orchestrator (PENDING → GENERATED)
+    registered = orchestrator.register_generated(
+        proposal_id,
+        generated_code,
+        validation={"ok": True, "compatibility_ok": True, "exposed_tools": [TOOL_NAME]},
+    )
+    assert registered.status == "GENERATED"
+
+    # ── Phase C (INCOMPATIBLE path) ───────────────────────────────
+    # Create a second proposal that will fail validation
+    bad_req = CapabilityRequirement.create(
+        "bad.tool", "world_model", evidence="should fail",
+        requirement_id="req-bad-tool",
+    )
+    bad_item = proposal_store.enqueue(
+        requirements=[bad_req],
+        environment={"fingerprint_id": "test-fp-bad"},
+        risk={"risk_level": "read_only"},
+        source="world_model",
+    )
+    assert bad_item.status == "PENDING"
+    bad_proposal_id = bad_item.proposal_id
+
+    bad_registered = orchestrator.register_generated(
+        bad_proposal_id,
+        "invalid code",
+        validation={"ok": False, "compatibility_ok": False, "error": "syntax"},
+    )
+    assert bad_registered.status == "FAILED", "INCOMPATIBLE code must not reach CAS"
+
+    # ── Phase D — Approval and Install ────────────────────────────
+    # Content approval (GENERATED → APPROVED)
+    content_approval = await orchestrator.approve_content(proposal_id)
+    assert content_approval.approved is True
+    stored = proposal_store.get(proposal_id)
+    assert stored is not None and stored.status == "APPROVED"
+
+    # Mutation approval
+    mutation_approval = await orchestrator.authorize_mutation(proposal_id)
+    assert mutation_approval.approved is True
+
+    # Actual install via self_management
+    from leapflow.plugins import get_registry
+
+    reg = get_registry()
+    reg.assemble()
+    self_mgmt = reg.get_plugin("self_management")
+    self_mgmt._plugin_approval_gate = _ApprovingGate()
+    self_mgmt.bind_runtime(plugin_install_dir=str(evolution_dirs["plugins"]))
+
+    try:
+        install_result = await self_mgmt._plugin_install_handler(
+            plugin_id=PLUGIN_ID,
+            code=generated_code,
+        )
+        assert install_result["ok"], f"Install failed: {install_result.get('error')}"
+        assert TOOL_NAME in install_result["installed_tools"]
+
+        # Plugin file written
+        assert (evolution_dirs["plugins"] / f"{PLUGIN_ID}.py").exists()
+
+        # Fiber ACTIVE + tool in registry
+        assert PLUGIN_ID in reg.plugins
+        assert TOOL_NAME in reg.tool_handlers
+
+        # Invoke the tool
+        handler = reg.tool_handlers[TOOL_NAME]
+        invoke_result = await handler(message="lifecycle hello")
+        assert invoke_result["ok"] is True
+        assert invoke_result["echoed"] == "lifecycle hello"
+
+        # Record install in orchestrator lifecycle
+        orchestrator.record_installed(proposal_id, install_result)
+        stored = proposal_store.get(proposal_id)
+        assert stored is not None and stored.status == "INSTALLED"
+
+    finally:
+        self_mgmt._plugin_approval_gate = None
+        self_mgmt._plugin_install_dir = None
+
+    # ── Phase E — Trust Accrual and Governance ────────────────────
+    from leapflow.learning.plugin_trust import PluginTrustLevel
+
+    # Start at DRAFT
+    assert trust_ledger.level(PLUGIN_ID) == PluginTrustLevel.DRAFT
+
+    # Record 5 consecutive successes → CANDIDATE
+    for _ in range(5):
+        trust_ledger.record_success(PLUGIN_ID)
+    assert trust_ledger.level(PLUGIN_ID) == PluginTrustLevel.CANDIDATE
+
+    # Record trust transition in DuckDB (Phase 4 feature)
+    stats_store.record_trust_transition(
+        plugin_id=PLUGIN_ID,
+        from_level=PluginTrustLevel.DRAFT.value,
+        to_level=PluginTrustLevel.CANDIDATE.value,
+        trigger="consecutive_success",
+        consecutive_ok=5,
+        consecutive_fail=0,
+    )
+
+    # Verify trust_history (Phase 4 feature)
+    from leapflow.learning.plugin_trust import trust_history
+
+    history = trust_history(evolution_dirs["stats_db"], plugin_id=PLUGIN_ID)
+    assert len(history) >= 1
+    rec = history[0]
+    assert rec.plugin_id == PLUGIN_ID
+    assert rec.from_level == PluginTrustLevel.DRAFT.value
+    assert rec.to_level == PluginTrustLevel.CANDIDATE.value
+    assert rec.trigger == "consecutive_success"
+
+    # Record 3 consecutive failures → demotion (CANDIDATE → DRAFT)
+    for _ in range(3):
+        trust_ledger.record_failure(PLUGIN_ID)
+    assert trust_ledger.level(PLUGIN_ID) == PluginTrustLevel.DRAFT
+
+    # Hard failure → freeze
+    trust_ledger.record_success(PLUGIN_ID)  # Reset from demotion
+    trust_ledger.record_failure(PLUGIN_ID, hard=True)
+    assert trust_ledger.is_frozen(PLUGIN_ID)
+    assert trust_ledger.level(PLUGIN_ID) == PluginTrustLevel.DRAFT
+
+    # Transition proposal to QUARANTINED (Phase 2: quarantine recovery)
+    proposal_store.transition(proposal_id, "QUARANTINED")
+    stored = proposal_store.get(proposal_id)
+    assert stored is not None and stored.status == "QUARANTINED"
+
+    # Phase 2: unfreeze + QUARANTINED → PROBATION
+    unfrozen = trust_ledger.unfreeze(PLUGIN_ID)
+    assert unfrozen is True
+    assert not trust_ledger.is_frozen(PLUGIN_ID)
+    assert trust_ledger.level(PLUGIN_ID) == PluginTrustLevel.DRAFT
+
+    proposal_store.transition(proposal_id, "PROBATION")
+    stored = proposal_store.get(proposal_id)
+    assert stored is not None and stored.status == "PROBATION"
+
+    # Record the unquarantine trust transition
+    stats_store.record_trust_transition(
+        plugin_id=PLUGIN_ID,
+        from_level=PluginTrustLevel.DRAFT.value,  # frozen→unfrozen at DRAFT
+        to_level=PluginTrustLevel.DRAFT.value,
+        trigger="unfreeze",
+        consecutive_ok=0,
+        consecutive_fail=0,
+    )
+
+    # ── Phase F — Proposal Sweep (Phase 1: TTL expiry) ────────────
+    from leapflow.evolution.sweep import CoevolutionSweep, SweepOutcome
+
+    # Create a stale proposal with expires_at in the past
+    stale_req = CapabilityRequirement.create(
+        "stale.tool", "world_model", evidence="stale evidence",
+        requirement_id="req-stale-tool",
+    )
+    # Build a store with 0 TTL so proposals expire immediately
+    from leapflow.storage.capability_proposal_queue import (
+        EvolutionCapabilityProposalStore,
+    )
+
+    sweep_store = EvolutionCapabilityProposalStore(
+        event_store, profile_id=PROFILE_ID, proposal_ttl_hours=0,
+    )
+    # TTL=0 means no expiry timestamp is set, so create with explicit past expiry
+    stale_item, stale_event = sweep_store.prepare_enqueue(
+        requirements=[stale_req],
+        environment={"fingerprint_id": "test-fp-stale"},
+        risk={"risk_level": "read_only"},
+        source="sweep_test",
+        occurred_at=time.time() - 7200,  # 2 hours ago
+    )
+    if stale_event is not None:
+        event_store.append(stale_event)
+    stale_id = stale_item.proposal_id
+
+    # Manually set expires_at to the past by updating it with a past timestamp
+    # Since TTL=0 means expires_at=None, we use the main store (TTL=72h)
+    # and create a proposal with occurred_at far in the past
+    from leapflow.storage.capability_proposal_queue import CapabilityProposalItem
+
+    # Use the main proposal_store (TTL=72h) and create an already-expired proposal
+    expired_req = CapabilityRequirement.create(
+        "expired.tool", "world_model", evidence="expired evidence",
+        requirement_id="req-expired-tool",
+    )
+    # Enqueue with the main store so expires_at is set
+    expired_item, expired_event = proposal_store.prepare_enqueue(
+        requirements=[expired_req],
+        environment={"fingerprint_id": "test-fp-expired"},
+        risk={"risk_level": "read_only"},
+        source="sweep_test",
+        occurred_at=time.time() - 72 * 3600 - 1,  # Beyond TTL
+    )
+    if expired_event is not None:
+        event_store.append(expired_event)
+    expired_id = expired_item.proposal_id
+
+    # Verify the expired_at is in the past
+    stored_expired = proposal_store.get(expired_id)
+    assert stored_expired is not None
+    assert stored_expired.expires_at is not None
+    assert stored_expired.expires_at < time.time(), "proposal must be past its TTL"
+
+    sweep = CoevolutionSweep(
+        orchestrator=orchestrator,
+        proposal_store=proposal_store,
+    )
+    expired_count, superseded_count = sweep._sweep_proposal_expiry()
+    assert expired_count >= 1, f"expected at least 1 expired, got {expired_count}"
+
+    # Verify the proposal is now EXPIRED
+    stored_expired = proposal_store.get(expired_id)
+    assert stored_expired is not None and stored_expired.status == "EXPIRED"
+
+    # ── Phase G — Event Chain Verification ────────────────────────
+    from leapflow.domain.event_types import EvolutionEventType
+
+    # Read all events for the main proposal
+    records = event_store.read(
+        profile_id=PROFILE_ID,
+        correlation_id=proposal_id,
+        limit=500,
+    )
+    event_types = [r.event.event_type for r in records]
+
+    # Key lifecycle events must be present
+    assert EvolutionEventType.PROPOSAL_CREATED in event_types, (
+        f"PROPOSAL_CREATED missing; got: {event_types}"
+    )
+    assert EvolutionEventType.PROPOSAL_GENERATED in event_types, (
+        f"PROPOSAL_GENERATED missing; got: {event_types}"
+    )
+    assert EvolutionEventType.PROPOSAL_APPROVED in event_types, (
+        f"PROPOSAL_APPROVED missing; got: {event_types}"
+    )
+    assert EvolutionEventType.PLUGIN_INSTALLED in event_types, (
+        f"PLUGIN_INSTALLED missing; got: {event_types}"
+    )
+    assert EvolutionEventType.PLUGIN_QUARANTINED in event_types, (
+        f"PLUGIN_QUARANTINED missing; got: {event_types}"
+    )
+    assert EvolutionEventType.PLUGIN_PROBATION_STARTED in event_types, (
+        f"PLUGIN_PROBATION_STARTED missing; got: {event_types}"
+    )
+
+    # All events in the chain share the same correlation_id (the proposal_id)
+    for record in records:
+        assert record.event.context.correlation_id == proposal_id, (
+            f"event {record.event.event_type} has wrong correlation_id: "
+            f"{record.event.context.correlation_id}"
+        )
+
+    # The expired proposal's events also exist
+    expired_records = event_store.read(
+        profile_id=PROFILE_ID,
+        correlation_id=expired_id,
+        limit=100,
+    )
+    expired_event_types = [r.event.event_type for r in expired_records]
+    assert EvolutionEventType.PROPOSAL_CREATED in expired_event_types
+    assert EvolutionEventType.PROPOSAL_EXPIRED in expired_event_types
+
+    # The failed proposal's events exist
+    failed_records = event_store.read(
+        profile_id=PROFILE_ID,
+        correlation_id=bad_proposal_id,
+        limit=100,
+    )
+    failed_event_types = [r.event.event_type for r in failed_records]
+    assert EvolutionEventType.PROPOSAL_CREATED in failed_event_types
+    assert EvolutionEventType.PROPOSAL_FAILED in failed_event_types
+
+    print(
+        f"[lifecycle E2E] All 7 phases passed. "
+        f"Events: {len(records)} main, {len(expired_records)} expired, "
+        f"{len(failed_records)} failed."
+    )
diff --git a/tests/test_plugin_stats_persistence.py b/tests/test_plugin_stats_persistence.py
index 1d4448ff..a5922988 100644
--- a/tests/test_plugin_stats_persistence.py
+++ b/tests/test_plugin_stats_persistence.py
@@ -26,7 +26,7 @@
 from leapflow.engine.turn_usage import TurnUsageTracker
 from leapflow.learning.plugin_stats import PluginUsageTracker
 from leapflow.learning.plugin_stats_store import PluginStatsStore
-from leapflow.learning.plugin_trust import PluginTrustLedger, PluginTrustLevel
+from leapflow.learning.plugin_trust import PluginTrustLedger, PluginTrustLevel, trust_history
 
 
 def _db(tmp_path: Path) -> Path:
@@ -401,3 +401,59 @@ def test_corrupt_usage_state_degrades_to_empty_tracker(
         advisor = pa.get_default_advisor()
         assert advisor is not None
         assert advisor._usage_tracker._samples == {}
+
+
+class TestTrustTransitionHistory:
+    """Trust transition time-series persistence and query."""
+
+    def test_trust_transition_persisted_to_history_table(self, tmp_path: Path) -> None:
+        """A promotion writes a row to plugin_trust_transitions with correct levels."""
+        store = PluginStatsStore(_db(tmp_path))
+        ledger = _PersistingTrustLedger(candidate_at=5, store=store)
+        for _ in range(5):
+            ledger.record_success("alpha")
+        assert ledger.level("alpha") is PluginTrustLevel.CANDIDATE
+
+        records = trust_history(_db(tmp_path))
+        assert len(records) == 1
+        rec = records[0]
+        assert rec.plugin_id == "alpha"
+        assert rec.from_level == PluginTrustLevel.DRAFT
+        assert rec.to_level == PluginTrustLevel.CANDIDATE
+        assert rec.trigger == "success"
+        assert rec.consecutive_ok == 5
+        assert rec.consecutive_fail == 0
+        assert rec.transitioned_at is not None
+
+    def test_trust_history_query_by_plugin_id(self, tmp_path: Path) -> None:
+        """Querying by plugin_id returns only matching records."""
+        store = PluginStatsStore(_db(tmp_path))
+        ledger = _PersistingTrustLedger(candidate_at=2, store=store)
+        # Drive two plugins to CANDIDATE.
+        for _ in range(2):
+            ledger.record_success("plug_a")
+        for _ in range(2):
+            ledger.record_success("plug_b")
+        assert ledger.level("plug_a") is PluginTrustLevel.CANDIDATE
+        assert ledger.level("plug_b") is PluginTrustLevel.CANDIDATE
+
+        all_records = trust_history(_db(tmp_path))
+        assert len(all_records) == 2
+
+        a_records = trust_history(_db(tmp_path), plugin_id="plug_a")
+        assert len(a_records) == 1
+        assert a_records[0].plugin_id == "plug_a"
+
+        b_records = trust_history(_db(tmp_path), plugin_id="plug_b")
+        assert len(b_records) == 1
+        assert b_records[0].plugin_id == "plug_b"
+
+    def test_trust_history_cold_path_only(self, tmp_path: Path) -> None:
+        """A single success (no promotion) writes NO row to trust_transitions."""
+        store = PluginStatsStore(_db(tmp_path))
+        ledger = _PersistingTrustLedger(candidate_at=5, store=store)
+        ledger.record_success("beta")  # streak 1, no level change
+        assert ledger.level("beta") is PluginTrustLevel.DRAFT
+
+        records = trust_history(_db(tmp_path))
+        assert records == []
diff --git a/tests/test_proposal_orchestrator.py b/tests/test_proposal_orchestrator.py
index 70c58bab..cb10b2d1 100644
--- a/tests/test_proposal_orchestrator.py
+++ b/tests/test_proposal_orchestrator.py
@@ -301,3 +301,52 @@ def test_queue_rejects_lifecycle_shortcuts(tmp_path: Path) -> None:
 
     with pytest.raises(ValueError, match="PENDING -> INSTALLED"):
         queue.transition(proposal_id, "INSTALLED")
+
+
+def test_expire_records_reason_in_metadata(tmp_path: Path) -> None:
+    queue, proposal_id = _queue(tmp_path)
+    orchestrator = ProposalOrchestrator(
+        queue=queue,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        approval_gate=None,
+        policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+    )
+
+    item = orchestrator.expire(proposal_id, reason="ttl_exceeded")
+
+    assert item.status == "EXPIRED"
+    assert item.metadata["terminal_reason"] == "ttl_exceeded"
+    assert "swept_at" in item.metadata
+
+
+def test_supersede_records_reason_in_metadata(tmp_path: Path) -> None:
+    queue, proposal_id = _queue(tmp_path)
+    orchestrator = ProposalOrchestrator(
+        queue=queue,
+        artifact_store=ContentAddressedArtifactStore(tmp_path / "artifacts"),
+        approval_gate=None,
+        policy=AdaptiveEvolutionPolicy(autonomy_level="generate_only"),
+    )
+
+    item = orchestrator.supersede(proposal_id, replacement_id="prop-new", reason="newer_proposal_exists")
+
+    assert item.status == "SUPERSEDED"
+    assert item.metadata["terminal_reason"] == "newer_proposal_exists"
+    assert item.metadata["replacement_proposal_id"] == "prop-new"
+    assert "swept_at" in item.metadata
+
+
+def test_quarantine_to_probation_transition_allowed(tmp_path: Path) -> None:
+    """QUARANTINED proposals can be transitioned back to PROBATION for re-trial."""
+    queue, proposal_id = _queue(tmp_path)
+    # Walk the proposal through PENDING -> GENERATED -> APPROVED -> INSTALLED -> QUARANTINED
+    queue.transition(proposal_id, "GENERATED")
+    queue.transition(proposal_id, "APPROVED")
+    queue.transition(proposal_id, "INSTALLED")
+    queue.transition(proposal_id, "QUARANTINED")
+    item = queue.get(proposal_id)
+    assert item.status == "QUARANTINED"
+
+    # Now transition QUARANTINED -> PROBATION
+    recovered = queue.transition(proposal_id, "PROBATION")
+    assert recovered.status == "PROBATION"
diff --git a/tests/test_quarantine_recovery.py b/tests/test_quarantine_recovery.py
new file mode 100644
index 00000000..15bdd064
--- /dev/null
+++ b/tests/test_quarantine_recovery.py
@@ -0,0 +1,65 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+"""Phase 2 quarantine recovery path tests."""
+from __future__ import annotations
+
+import pytest
+
+from leapflow.learning.plugin_trust import PluginTrustLedger, PluginTrustLevel
+
+
+class TestUnfreeze:
+    """PluginTrustLedger.unfreeze() resets a frozen plugin for re-probation."""
+
+    def test_unfreeze_resets_trust_to_draft(self) -> None:
+        ledger = PluginTrustLedger(candidate_at=2, demote_after=1)
+        pid = "quarantined_plugin"
+
+        # Earn some trust first, then hard-freeze
+        for _ in range(3):
+            ledger.record_success(pid)
+        assert ledger.level(pid) == PluginTrustLevel.CANDIDATE
+
+        ledger.record_failure(pid, hard=True)
+        assert ledger.is_frozen(pid)
+        assert ledger.level(pid) == PluginTrustLevel.DRAFT
+
+        # Unfreeze
+        result = ledger.unfreeze(pid)
+        assert result is True
+        assert not ledger.is_frozen(pid)
+        assert ledger.level(pid) == PluginTrustLevel.DRAFT
+        # Counters are zeroed — verify by recording success and checking promotion
+        assert ledger._consecutive_ok.get(pid, 0) == 0
+        assert ledger._consecutive_fail.get(pid, 0) == 0
+
+        # Verify record_success works again after unfreeze
+        ledger.record_success(pid)
+        assert ledger._consecutive_ok[pid] == 1
+
+    def test_unfreeze_nonexistent_returns_false(self) -> None:
+        ledger = PluginTrustLedger()
+        assert ledger.unfreeze("never_frozen") is False
+
+    def test_unfreeze_nonfrozen_plugin_returns_false(self) -> None:
+        ledger = PluginTrustLedger()
+        pid = "normal_plugin"
+        ledger.record_success(pid)
+        assert ledger.unfreeze(pid) is False
+
+
+class TestUnquarantineToolMetadata:
+    """Verify plugin_unquarantine tool metadata meets governance requirements."""
+
+    def test_unquarantine_requires_approval(self) -> None:
+        from leapflow.plugins.tool_plugins.self_management import SelfManagementPlugin
+
+        plugin = SelfManagementPlugin()
+        tool = None
+        for t in plugin.tools:
+            if t.name == "plugin_unquarantine":
+                tool = t
+                break
+        assert tool is not None, "plugin_unquarantine tool not found"
+        assert tool.x_leapflow["risk_level"] == "high"
+        assert tool.x_leapflow["category"] == "plugin_management"
+        assert tool.mutates_state is True

From 524b231ed31e5557c021611e730c59c7ef52ce67 Mon Sep 17 00:00:00 2001
From: Cheney Zhang <chen.zhang@zilliz.com>
Date: Sat, 19 Sep 2026 16:45:51 +0800
Subject: [PATCH 06/10] chore: remove auto-generated .learnings/ and gitignore
 it
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The .learnings/ directory was created by an external AI skill (self-improving-agent),
not part of the LeapFlow project structure. Its content is already captured in the
Memory system (common_pitfalls_experience) and git history.

Signed-off-by: 班扬 <xingjun.wxj@alibaba-inc.com>
---
 .gitignore           |  1 +
 .learnings/ERRORS.md | 98 --------------------------------------------
 2 files changed, 1 insertion(+), 98 deletions(-)
 delete mode 100644 .learnings/ERRORS.md

diff --git a/.gitignore b/.gitignore
index 2b41683c..d5e4d30b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -221,6 +221,7 @@ __marimo__/
 *.duckdb
 *.duckdb.wal
 .leapflow/
+.learnings/
 .idea/
 
 # Swift / Xcode
diff --git a/.learnings/ERRORS.md b/.learnings/ERRORS.md
deleted file mode 100644
index 1fc00387..00000000
--- a/.learnings/ERRORS.md
+++ /dev/null
@@ -1,98 +0,0 @@
-# Errors
-
-## [ERR-20260918-P2S] sandbox-resource-default
-
-**Logged**: 2026-09-18T13:52:25Z
-**Priority**: high
-**Status**: resolved
-**Area**: backend
-
-### Summary
-A default RLIMIT_AS ceiling caused Python sandbox workers to exit before responding on macOS.
-
-### Error
-```
-Sandbox smoke test failed: worker did not respond
-```
-
-### Context
-- The plugin sandbox applied a 512 MiB address-space limit before importing runtime modules.
-- macOS virtual address-space accounting exceeded the limit during normal worker startup.
-
-### Suggested Fix
-Keep memory limits configurable but disabled by default unless validated for the deployment platform.
-
-### Metadata
-- Reproducible: yes
-- Related Files: src/leapflow/plugins/sandbox/worker.py, src/leapflow/config.py
-
-### Resolution
-- **Resolved**: 2026-09-18T13:52:25Z
-- **Notes**: Default memory limit changed to zero; explicit configured limits remain enforced.
-
----
-
-## [ERR-20260918-LNT] repository-wide-ruff-baseline
-
-**Logged**: 2026-09-18T13:52:25Z
-**Priority**: medium
-**Status**: resolved
-**Area**: tests
-
-### Summary
-Repository-wide Ruff validation reports pre-existing unused imports outside the evolution implementation surface.
-
-### Error
-```
-ruff check src tests: 33 F401/F811 findings
-```
-
-### Context
-- Targeted Ruff checks for all files changed by the evolution plan pass.
-- The remaining findings are in unrelated perception, platform, marketplace, and older test modules.
-
-### Suggested Fix
-Run a dedicated repository-wide lint cleanup and verify affected modules with their focused tests.
-
-### Metadata
-- Reproducible: yes
-- Related Files: src/leapflow/perception/signal_source.py, src/leapflow/platform/event_bus.py, tests/test_signal_source.py
-
-### Resolution
-- **Resolved**: 2026-09-18T13:52:25Z
-- **Notes**: Applied safe Ruff fixes and replaced the remaining assigned lambdas with local functions; repository-wide Ruff now passes.
-
----
-
-## [ERR-20260918-EVP] event-projection-migration-regressions
-
-**Logged**: 2026-09-18T14:30:00Z
-**Priority**: medium
-**Status**: resolved
-**Area**: tests
-
-### Summary
-Targeted tests exposed stale constructor and lazy JSON-store assumptions during the event-derived knowledge migration.
-
-### Error
-```
-3 failed: proposal_sink constructor argument, lazy JSON knowledge binding, missing injected event knowledge store
-```
-
-### Context
-- DurableTeacherWorker now requires an event-backed proposal queue and live resolver.
-- AgentEngine no longer creates a JSON knowledge store on the hot path.
-- A production-wiring unit fixture did not inject the new event-derived knowledge projection.
-
-### Suggested Fix
-Update tests and fixtures to use the event store, inject the knowledge projection explicitly, and assert fail-closed acquisition resolution.
-
-### Metadata
-- Reproducible: yes
-- Related Files: tests/test_durable_teacher.py, tests/test_distilled_knowledge.py, tests/test_degradation_feedback_loop.py
-
-### Resolution
-- **Resolved**: 2026-09-19T00:30:00Z
-- **Notes**: Updated worker tests for atomic proposal preparation, replaced lazy JSON binding with explicit event-projection injection, and fixed production governor fixtures. Full suite passes.
-
----

From ce64702adc53da531c2d89830bff321488c39fbf Mon Sep 17 00:00:00 2001
From: Cheney Zhang <chen.zhang@zilliz.com>
Date: Sat, 19 Sep 2026 17:03:32 +0800
Subject: [PATCH 07/10] docs: enrich harness evolution architecture
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: 班扬 <xingjun.wxj@alibaba-inc.com>
---
 assets/harness_evolution_architecture.png    | Bin 0 -> 506701 bytes
 docs/world_model_plugin_harness_evolution.md | 116 +++++++------------
 2 files changed, 43 insertions(+), 73 deletions(-)
 create mode 100644 assets/harness_evolution_architecture.png

diff --git a/assets/harness_evolution_architecture.png b/assets/harness_evolution_architecture.png
new file mode 100644
index 0000000000000000000000000000000000000000..cbf127c0493ca47f911b0ec8270f7c2f79849596
GIT binary patch
literal 506701
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%0A@MvuP#@8s8~;UDhcUSZH&zcjtn~GMOMN0n
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%0An@(kHp2Aq?ey$XGkB6kIgq+}<9Q;<lN_hI;
z3s$`#b3!pDggbNm81N7t4E9xf`XEV_BUR8#^YnRx=8}Rc{#_ZXudjkEeeEivvzSX{
za!2g|R?EzowEgGht)y+z<>p@Q?nK^?hK%wGT#6lZ&~ROba>}E74N@f^-6_^K38sFI
zcpd6az9N`MADv#jd7d{~QP2p@edHjNj8-7QdFK=>3rQN};G{@^XREQ;rm9pLP^2cL
zS|o%^372#^@jc^}Euz3{ZtD&mQszQMH`eb`LV?*h{G{;I2QQ0(7&VqHZH;=E(OYC3
z9F`fUSVQS4tyiJTe6baIMxoI)`UrpE*UGvDHgGT7l@)7;iqcE9dmk#Dxzr@cF_h~?
z=?MIcj8<E1R1e9Fn^_*U<*VvrA}~;r#QwEUo~>ffw@D`;98mk)iYQ;r+B)y{%@?tg
zWpN6uc_gt^Fe)K_z8=O0IG*|gH5j>wtPz-3p`67C8gH+{@I3`At#jR#^H1XuO4xd;
zj-Hnz59r1knYCXzdM6-b27TZY$RFuCJex92u63GDUo{GDoq4S6rCfd#t%klRe{*);
z6Qq_x!_4x--=~%dU8J$>TvSJF5tenyQqZgMnQ(~sL}JF)$$4OFS(M-QY|1D%!n5&2
z=9_s13;cwx_4)tc&HlP@Xx3>uuZf<ys_?_axgP#bu(NRz83W=sD_K7(udjyeSJZo2
zy!+dhW?%C=AX`hkP83ze0+vnec2lZEPJ)C>9}95bKqubc4e|qOZxQFNw2-&$X64KO
zgf4$wyyP7~HU=hjZ&OR~!wL6)$-;q(AA5uU4Q;HT$MG*;Hk~im4wm+gnBRbV7gW?Z
zom`oTWVBri{TE>)Nc(nxag>7Vb~VwdJd&-ebDYH4@zS(={t}=H^nE9{t6F_4i7yB~
z+`dR=UF8-K%zS-4)3k;-JDv!mxu$|hu@QYHjfDxD;W^Ray$N#q=llO9K?%QRjmYvb
z#8SK=QEJLejD5TPVc=iy7hTBz>-ymQEb_4S^74N$p?^kDyZ<+9=HH{e-uS<9z0W-)
z|KmM^a~?NB{u9xGW5T((-M_gDe-9Au^q+*spHHL&{?{E){lifD*FOyZzkK<+>%R<s
WOt1>+s+<0~p1ib*R4LT-?f(H@U7Pa&

literal 0
HcmV?d00001

diff --git a/docs/world_model_plugin_harness_evolution.md b/docs/world_model_plugin_harness_evolution.md
index dc71404f..416b5812 100644
--- a/docs/world_model_plugin_harness_evolution.md
+++ b/docs/world_model_plugin_harness_evolution.md
@@ -27,37 +27,21 @@ The term *Harness self-evolution* is used in this restricted sense: the Harness
 
 The architecture follows the principle that a capability should be composed rather than built into the core runtime. Tools, platform adapters, signal sources, and other extensions are specified through runtime-checkable protocols and managed by common discovery and lifecycle machinery. The Harness owns the rules of composition; plugins own concrete capability implementations.
 
-```text
-       Environment and execution evidence
-                       │
-                       ▼
-             Observe / filter / persist
-                       │
-                       ├───────────────┐
-                       ▼               │
-              World-model teacher      │
-       grade trajectory + infer verdict│
-                       │               │
-                       ▼               │
-       distilled knowledge / preference│
-                       │               │
-                       ▼               │
-             student execution loop ◄──┘
-                       │
-          unmet requirement only
-                       ▼
-     proposal → validation → approval → sandbox
-                       │
-                       ▼
-             governed plugin lifecycle
-                       │
-                       ▼
-          outcome, trust, quarantine, rollback
-                       │
-              ┌────────┴────────┐
-              ▼                 ▼
-       LeapSpace signals   LeapBoard presentation
-```
+![Figure 1. LeapFlow system architecture and governed capability-evolution pipeline.](../assets/harness_evolution_architecture.png)
+
+*Figure 1. From real-world signals to explainable, reversible capability evolution. The figure depicts LeapSpace as an evidence-producing environment and focuses on the LeapFlow execution and evolution paths. LeapBoard, the read-only presentation surface, is introduced in [Section 8](#8-leapspaceleapflowleapboard-causal-plane).*
+
+### 2.1 Reading the Architecture
+
+Figure 1 is read from left to right and then from the hot path into the cold path:
+
+1. **Signals enter the acting loop.** LeapSpace and live interaction provide observable environmental and execution evidence to the OODA-oriented hot path.
+2. **The teacher interprets completed evidence.** The world model operates on a retrospective trajectory and returns action grades plus a four-valued adaptation verdict; it does not directly install code.
+3. **The default response changes knowledge, not capability.** `absorb` and `rebind` flow through the always-on channel, distilling environmental knowledge and provider preferences into the next-turn context.
+4. **Only an unmet `acquire` verdict reaches the mutation boundary.** This opt-in channel crosses proposal, validation, approval, sandbox, and trust gates before a capability can become active.
+5. **Every consequential outcome becomes evidence.** Trust transitions, rejection, failure, quarantine, and rollback are retained as causal records that inform subsequent analysis and operator inspection.
+
+The storyline therefore progresses from **observation**, to **interpretation**, to the **least invasive valid response**, and only then—when existing knowledge and installed capability are insufficient—to governed acquisition. This ordering is the central safety and efficiency claim of the architecture.
 
 This organization makes two distinctions explicit.
 
@@ -147,48 +131,39 @@ The ordering is intentional: `absorb` and `rebind` are cheaper and safer than `a
 
 This design counters a common failure mode in agentic systems: interpreting a changed environment as proof that the incumbent implementation is defective. An incumbent can be correct for a previous application version while an alternate adapter is now more appropriate. The verdict asks what action is supported by evidence, not which component is to blame.
 
-### 4.3 Event-Sourced Knowledge and Selection
+### 4.3 Event-Sourced Knowledge, Resolution, and Selection
 
 Evolution evidence is persisted through an append-only event store. Read models, including distilled knowledge and rebind preferences, are projections over that evidence rather than independent sources of truth. A preference extracted from a `rebind` verdict can influence selection, but it is intentionally weaker than structural constraints such as declared capability fit and environment affordances.
 
-The capability resolver operationalizes this distinction. It scores live candidates from declared matching, environmental compatibility, risk cost, trust, reliability, and—when present—distilled preference. A teacher recommendation cannot make an incompatible capability eligible; it is evidence that informs a deterministic resolution process, not a hidden control channel.
-
-## 5. From Evidence to Plugin Acquisition
+Before generating new code, LeapFlow resolves a typed requirement against the live catalog. A satisfiable requirement becomes an explicit no-op or rebind result rather than a duplicate proposal. This **resolution-before-acquisition** rule operationalizes the least-invasive-response principle shown in Figure 1.
 
-### 5.1 Resolution Before Acquisition
+The capability resolver scores live candidates using declared matching, environmental compatibility, risk cost, trust, reliability, and—when present—distilled preference. A teacher recommendation cannot make an incompatible candidate eligible; it is evidence that informs a deterministic resolution process, not a hidden control channel.
 
-Before generating new code, LeapFlow resolves the requirement against the live catalog. An already satisfiable requirement becomes an explicit no-op or rebind result rather than a duplicate proposal. This avoids capability proliferation and ensures that new code is the exception rather than the default response to change.
+The user-visible `evolution.enabled` setting, disabled by default, governs the only branch that may introduce a new capability: whether an `acquire` verdict may enter the proposal path. It does not disable world-model grading, knowledge distillation, or read-only selection guidance. The system can therefore learn from an environment while capability mutation remains disabled.
 
-The acquisition branch is gated by the user-visible `evolution.enabled` setting, which is disabled by default. The setting controls whether an `acquire` verdict may enter the capability-proposal path. It does not disable world-model grading, knowledge distillation, or read-only selection guidance. Consequently, the system can learn from an environment even while capability mutation remains disabled.
+## 5. Governed Plugin Acquisition
 
-### 5.2 Governed Acquisition Pipeline
+### 5.1 Gate Sequence
 
-An eligible acquisition follows a staged path:
+Only an eligible, unresolved `acquire` requirement traverses the following sequence:
 
-```text
-classified evidence
-  → typed capability requirement
-  → live-catalog resolution
-  → proposal
-  → generation
-  → syntax / structure / protocol validation
-  → compatibility assessment
-  → approval
-  → artifact write
-  → sandbox smoke test
-  → register at DRAFT
-  → behavior tests and probation
-  → trust accrual, verification, or quarantine
-```
+| Stage | Required result before the next stage |
+|---|---|
+| Evidence and resolution | A typed, task-relevant requirement remains unsatisfied by the live catalog. |
+| Proposal and generation | A candidate artifact is associated with its causal evidence and declared capability. |
+| Validation and compatibility | Syntax, structure, import/protocol conformance, and compatibility assessment succeed. |
+| Approval and sandboxing | The operator gate permits the mutation and the artifact passes bounded sandbox smoke checks. |
+| Registration and probation | The plugin enters at `DRAFT`, then accumulates behavior-test and outcome evidence. |
+| Trust or containment | Observed outcomes support advancement, demotion, quarantine, disablement, or rollback. |
 
-The pipeline is intentionally more restrictive than “LLM writes a file and imports it.” It provides an accountable answer to four questions that an unconstrained script cannot answer reliably:
+The sequence is intentionally more restrictive than “LLM writes a file and imports it.” It preserves the answer to four accountability questions:
 
 1. **Why was this capability needed?** The requirement is linked to source evidence and resolution results.
-2. **Why is this implementation admissible?** Validation, compatibility assessment, and approval must precede activation.
+2. **Why is this implementation admissible?** Validation, compatibility assessment, and approval precede activation.
 3. **What happens if it fails?** Outcomes drive demotion, quarantine, disablement, or rollback.
 4. **Can the decision be reconstructed?** Causal records include no-op, rejected, and failed branches, not only successful installation.
 
-### 5.3 Progressive Trust and Reversibility
+### 5.2 Progressive Trust and Reversibility
 
 New plugins start with limited trust. Trust can advance through observed success and can be reduced by consecutive failures; an internal defect can permanently freeze a capability. Plugins can also be isolated in a subprocess, invoked over bounded JSON-RPC, and removed from service through lifecycle governance.
 
@@ -229,23 +204,17 @@ A practical decision rule follows:
 
 ## 8. LeapSpace–LeapFlow–LeapBoard Causal Plane
 
-The three systems form complementary surfaces rather than a monolithic control loop.
+Figure 1 details the LeapSpace-to-LeapFlow execution and evolution pipeline. LeapBoard is deliberately not a control node in that figure; it completes the architecture as the human-observable presentation surface. The three systems therefore form complementary surfaces rather than a monolithic control loop.
 
-```text
-LeapSpace                         LeapFlow                         LeapBoard
-─────────                         ────────                         ─────────
-application state                 typed observation                causal views
-reference actions       ─────►    signal filtering                  watch updates
-LeapSignal records                world-model verdicts     ─────►  evolution lens
-sandboxed experiments             capability resolution             operator inspection
-                                  plugin governance                 notifications
-```
+| Surface | Primary responsibility | Causal output |
+|---|---|---|
+| **LeapSpace** | Controlled application environments, `LeapSignal` records, and task outcomes | Typed environmental and task-outcome observations |
+| **LeapFlow** | Filtering, world-model reasoning, capability resolution, and lifecycle governance | Read-only evolution, lifecycle, and provenance events |
+| **LeapBoard** | Causal views, watch updates, evolution lens, and operator inspection | Human-observable operational state |
 
-1. **LeapSpace observes and stages:** it makes environmental conditions and outcomes available through controlled application environments, signals, and an environment-source adapter.
-2. **LeapFlow reasons and governs:** it converts admissible observations into knowledge, resolutions, and—only where justified—governed proposals and lifecycle transitions.
-3. **LeapBoard exposes and explains:** it presents state and causal outcomes to the operator without bypassing the policy and approval chain.
+**Causal path:** **LeapSpace** → *typed observations* → **LeapFlow** → *causal events* → **LeapBoard**.
 
-This decomposition preserves a critical separation of powers. LeapSpace does not directly register production capabilities; LeapBoard does not approve or execute mutations; the world model does not directly install code. Each component contributes evidence, reasoning, governance, or visibility within its own boundary.
+This decomposition preserves a separation of powers: LeapSpace produces and stages evidence; LeapFlow reasons over admissible evidence and governs capability change; LeapBoard exposes causal state without bypassing policy or approval. LeapSpace does not register production capabilities, LeapBoard does not approve or execute mutations, and the world model does not install code directly.
 
 ## 9. Safety and Scientific Integrity Properties
 
@@ -269,7 +238,7 @@ The agent may improve its knowledge and selection policy without the authority t
 
 ### 9.5 Cold-Path Governance
 
-Retrospective grading, proposal processing, telemetry, and broad co-evolution sweeps should remain off the ordinary turn-critical path. Learning must not impose material latency or fragility on normal task execution.
+Retrospective grading, proposal processing, telemetry, and broad co-evolution sweeps are designed as cold-path work and should not execute synchronously inside the ordinary turn-critical loop. This reduces direct coupling to response latency; it does not prove that background workers consume no daemon scheduling or compute resources. Operational evaluation must therefore measure their effect on ordinary execution as well as their adaptation benefit.
 
 ## 10. Limitations and Non-Claims
 
@@ -322,3 +291,4 @@ The resulting system favors the least invasive valid response. It learns first,
 | LeapBoard templates | [`src/leapflow/dashboard/templates.py`](../src/leapflow/dashboard/templates.py) |
 | Configuration and evolution gate | [`src/leapflow/config.py`](../src/leapflow/config.py) |
 | Engineering constraints | [`AGENTS.md`](../AGENTS.md) |
+| Architecture figure asset | [`assets/harness_evolution_architecture.png`](../assets/harness_evolution_architecture.png) |

From 8338bbcaac1b2bf59e00022675acc704baaba729 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8F=AD=E6=89=AC?= <xingjun.wxj@alibaba-inc.com>
Date: Sun, 20 Sep 2026 00:58:27 +0800
Subject: [PATCH 08/10] fix leapboard layout

---
 src/leapflow/dashboard/static/app.js     |  4 ++-
 src/leapflow/dashboard/static/index.html |  4 +--
 src/leapflow/dashboard/static/styles.css | 44 +++++++++++++++++++++---
 tests/test_dashboard_frontend_static.py  | 29 ++++++++++++++++
 4 files changed, 74 insertions(+), 7 deletions(-)

diff --git a/src/leapflow/dashboard/static/app.js b/src/leapflow/dashboard/static/app.js
index 60a53dee..eb69507e 100644
--- a/src/leapflow/dashboard/static/app.js
+++ b/src/leapflow/dashboard/static/app.js
@@ -1104,7 +1104,9 @@
     const max = Math.max(1, ...rows.map((r) => r.value));
     rows.forEach((row) => {
       const line = el("div", "bar-row");
-      line.appendChild(el("span", "bar-label", esc(tx(row.label))));
+      const label = el("span", "bar-label", esc(tx(row.label)));
+      label.title = tx(row.label);
+      line.appendChild(label);
       const track = el("span", "bar-track");
       const fill = el("span", "bar-fill" + (severity ? " sev-" + row.key : "")); fill.style.width = Math.round((row.value / max) * 100) + "%";
       track.appendChild(fill); line.appendChild(track); line.appendChild(el("span", "bar-value", esc(row.value))); d.appendChild(line);
diff --git a/src/leapflow/dashboard/static/index.html b/src/leapflow/dashboard/static/index.html
index de06d2a7..4c5f7016 100644
--- a/src/leapflow/dashboard/static/index.html
+++ b/src/leapflow/dashboard/static/index.html
@@ -7,7 +7,7 @@
   <link rel="preconnect" href="https://fonts.googleapis.com" />
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
   <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;700;800&family=Source+Serif+4:opsz,wght@8..60,400;8..60,600&display=swap" rel="stylesheet" />
-  <link rel="stylesheet" href="/static/styles.css?v=provenance-md-20260918" />
+  <link rel="stylesheet" href="/static/styles.css?v=bar-layout-fit-20260919" />
 </head>
 <body>
   <header class="topbar">
@@ -30,6 +30,6 @@
   </header>
   <main id="root" class="root"><div class="empty" data-i18n="Loading…">Loading…</div></main>
   <div id="toasts" class="toasts"></div>
-  <script src="/static/app.js?v=provenance-md-20260918"></script>
+  <script src="/static/app.js?v=bar-layout-fit-20260919"></script>
 </body>
 </html>
diff --git a/src/leapflow/dashboard/static/styles.css b/src/leapflow/dashboard/static/styles.css
index 521ebc43..c6fdfdfe 100644
--- a/src/leapflow/dashboard/static/styles.css
+++ b/src/leapflow/dashboard/static/styles.css
@@ -155,17 +155,53 @@ body {
 .insight-list, .dl, .citations, .summary, .prose, .md, .chips button { font-size: 0.9rem; }
 
 /* ── Figures + captions (academic numbering set by the renderer) ─────────── */
-.chart { min-height: 120px; }
+.chart { min-height: 120px; min-width: 0; container-type: inline-size; }
 .chart-placeholder { color: var(--muted); border: 1px dashed var(--line); border-radius: 0; padding: 30px 14px; text-align: center; }
 .figcaption { color: var(--muted); font-size: 0.81rem; margin-top: 7px; padding-top: 5px; border-top: 1px solid var(--line); }
 .figcaption .fignum { color: var(--accent); font-weight: 700; margin-inline-end: 5px; }
 
 /* ── Bars / sparkline / pie (flat, single-hue accents) ───────────────────── */
-.bar-row { display: grid; grid-template-columns: max-content 1fr 36px; align-items: center; gap: 8px; margin: 7px 0; }
+.bar-row {
+  display: grid;
+  grid-template-columns: fit-content(13rem) minmax(4rem, 1fr) max-content;
+  align-items: center;
+  column-gap: 0.65rem;
+  row-gap: 4px;
+  margin: 7px 0;
+}
 .bar-label, .bar-value { color: var(--muted); font-size: 0.85rem; font-variant-numeric: tabular-nums; }
-.bar-label { white-space: nowrap; }
-.bar-track { height: 8px; background: var(--track); border-radius: 0; overflow: hidden; }
+.bar-label { min-width: 0; white-space: normal; overflow-wrap: anywhere; }
+.bar-track { min-width: 0; width: 100%; height: 8px; background: var(--track); border-radius: 0; overflow: hidden; }
+.bar-value { min-width: 2ch; justify-self: end; white-space: nowrap; text-align: end; }
 .bar-fill { display: block; height: 100%; border-radius: 0; background: var(--info); }
+
+/* A chart may be narrow because of its grid cell even on a wide viewport. At
+   that point, preserve every label and value by placing the track on its own
+   row instead of allowing any grid item to overlap another. */
+@container (max-width: 18rem) {
+  .bar-row {
+    grid-template-columns: minmax(0, 1fr) max-content;
+    grid-template-areas:
+      "label value"
+      "track track";
+  }
+  .bar-label { grid-area: label; }
+  .bar-track { grid-area: track; }
+  .bar-value { grid-area: value; }
+}
+
+/* Viewport fallback for browsers without container-query support. */
+@media (max-width: 440px) {
+  .bar-row {
+    grid-template-columns: minmax(0, 1fr) max-content;
+    grid-template-areas:
+      "label value"
+      "track track";
+  }
+  .bar-label { grid-area: label; }
+  .bar-track { grid-area: track; }
+  .bar-value { grid-area: value; }
+}
 .bar-fill.sev-alert { background: var(--alert); }
 .bar-fill.sev-notable { background: var(--notable); }
 .bar-fill.sev-info { background: var(--info); }
diff --git a/tests/test_dashboard_frontend_static.py b/tests/test_dashboard_frontend_static.py
index 8f40ac25..cf4b49f8 100644
--- a/tests/test_dashboard_frontend_static.py
+++ b/tests/test_dashboard_frontend_static.py
@@ -198,3 +198,32 @@ def test_static_assets_are_cache_busted_together() -> None:
     assert versions[0] != "status-i18n-20260808", (
         "the version predates the markdown and provenance changes"
     )
+
+
+# ════════════════════════════════════════════════════════════════
+# Bar charts: long labels overlapped their tracks in narrow cells
+# ════════════════════════════════════════════════════════════════
+
+
+def test_bar_chart_labels_wrap_without_consuming_the_track() -> None:
+    """Long translated labels must never be allowed to overlap a value or bar.
+
+    ``max-content`` paired with ``white-space: nowrap`` made the maturity label
+    ``new_unproven`` paint over its track. The base grid reserves a bounded label
+    column, and a narrow chart promotes the track to a dedicated second row.
+    """
+    css = _STYLES.read_text(encoding="utf-8")
+    assert ".chart { min-height: 120px; min-width: 0; container-type: inline-size; }" in css
+    assert "grid-template-columns: fit-content(13rem) minmax(4rem, 1fr) max-content;" in css
+    assert "column-gap: 0.65rem;" in css
+    assert ".bar-label { min-width: 0; white-space: normal; overflow-wrap: anywhere; }" in css
+    assert ".bar-track { min-width: 0; width: 100%;" in css
+    assert "@container (max-width: 18rem)" in css
+    assert '"label value"\n      "track track"' in css
+
+
+def test_bar_chart_labels_preserve_full_text_for_accessibility() -> None:
+    """Wrapping is visible; the title retains the complete translated label."""
+    src = _app()
+    assert 'const label = el("span", "bar-label", esc(tx(row.label)));' in src
+    assert "label.title = tx(row.label);" in src

From 3cf32859345be7edcdb3571c1e23e88d0d3acf0c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8F=AD=E6=89=AC?= <xingjun.wxj@alibaba-inc.com>
Date: Sun, 20 Sep 2026 02:07:27 +0800
Subject: [PATCH 09/10] fix(approval): pause tool deadline for human decisions

---
 src/leapflow/daemon/approval_coordinator.py |  7 +-
 src/leapflow/domain/tool_pipeline.py        | 85 +++++++++++++++++++--
 src/leapflow/engine/engine.py               | 12 ++-
 tests/test_tool_pipeline.py                 | 45 +++++++++++
 tests/test_turn_admission_parking.py        | 25 ++++++
 5 files changed, 160 insertions(+), 14 deletions(-)

diff --git a/src/leapflow/daemon/approval_coordinator.py b/src/leapflow/daemon/approval_coordinator.py
index 2d032e85..daaf7402 100644
--- a/src/leapflow/daemon/approval_coordinator.py
+++ b/src/leapflow/daemon/approval_coordinator.py
@@ -294,7 +294,12 @@ async def request_approval(self, request: Any, route: "tuple[asyncio.Queue[Strea
         ))
         try:
             async with parked_for_human_decision():
-                result = await future
+                from leapflow.domain.tool_pipeline import (
+                    pause_tool_execution_timeout_for_human_decision,
+                )
+
+                async with pause_tool_execution_timeout_for_human_decision():
+                    result = await future
             return str(result.get("decision") or "deny")
         finally:
             self._approval_pending.pop(pending_id, None)
diff --git a/src/leapflow/domain/tool_pipeline.py b/src/leapflow/domain/tool_pipeline.py
index b7a15c53..d872cc4c 100644
--- a/src/leapflow/domain/tool_pipeline.py
+++ b/src/leapflow/domain/tool_pipeline.py
@@ -17,12 +17,84 @@
 import asyncio
 import logging
 import time
+from contextlib import asynccontextmanager
+from contextvars import ContextVar
 from dataclasses import dataclass, field
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Protocol, runtime_checkable
+from typing import Any, AsyncIterator, Awaitable, Callable, Dict, List, Optional, Protocol, runtime_checkable
 
 logger = logging.getLogger(__name__)
 
 
+class _ToolExecutionDeadline:
+    """Pauses one tool deadline while the tool awaits a human decision."""
+
+    def __init__(self, loop: asyncio.AbstractEventLoop, timeout_s: float) -> None:
+        self._loop = loop
+        self._remaining_s = timeout_s
+        self._scope: asyncio.Timeout | None = None
+        self._pause_depth = 0
+
+    def bind(self, scope: asyncio.Timeout) -> None:
+        """Bind the active ``asyncio.timeout`` scope to this deadline."""
+        self._scope = scope
+
+    def pause(self) -> None:
+        """Suspend deadline accounting until the matching resume call."""
+        if self._pause_depth == 0:
+            scope = self._scope
+            if scope is None:
+                return
+            deadline = scope.when()
+            self._remaining_s = max(0.0, (deadline or self._loop.time()) - self._loop.time())
+            scope.reschedule(None)
+        self._pause_depth += 1
+
+    def resume(self) -> None:
+        """Resume deadline accounting after the outermost human wait finishes."""
+        if self._pause_depth == 0:
+            return
+        self._pause_depth -= 1
+        if self._pause_depth == 0 and self._scope is not None:
+            self._scope.reschedule(self._loop.time() + self._remaining_s)
+
+
+_current_tool_execution_deadline: ContextVar[_ToolExecutionDeadline | None] = ContextVar(
+    "leapflow_tool_execution_deadline", default=None,
+)
+
+
+@asynccontextmanager
+async def pause_tool_execution_timeout_for_human_decision() -> AsyncIterator[None]:
+    """Exclude human approval time from the active tool execution timeout.
+
+    Outside an engine-managed tool invocation this is intentionally a no-op, so
+    approval surfaces can use it without coupling themselves to a caller.
+    """
+    deadline = _current_tool_execution_deadline.get()
+    if deadline is None:
+        yield
+        return
+    deadline.pause()
+    try:
+        yield
+    finally:
+        deadline.resume()
+
+
+async def run_tool_with_timeout(
+    awaitable: Awaitable[Dict[str, Any]], timeout_s: float,
+) -> Dict[str, Any]:
+    """Run a tool with a deadline that pauses only for human decisions."""
+    controller = _ToolExecutionDeadline(asyncio.get_running_loop(), timeout_s)
+    token = _current_tool_execution_deadline.set(controller)
+    try:
+        async with asyncio.timeout(timeout_s) as scope:
+            controller.bind(scope)
+            return await awaitable
+    finally:
+        _current_tool_execution_deadline.reset(token)
+
+
 @dataclass
 class ToolCallContext:
     """Context passed through the waterfall pipeline.
@@ -126,16 +198,17 @@ async def execute(
             The final result dict (possibly transformed by after hooks).
 
         Timeout: when ``context.annotations['timeout']`` is set (the engine
-        passes the per-tool timeout there), the handler invocation is wrapped
-        in ``asyncio.wait_for``. A timeout raises ``asyncio.TimeoutError`` so
-        the caller's existing timeout handling stays authoritative. When no
-        timeout is annotated the handler is called directly (no wrapping).
+        passes the per-tool timeout there), the handler invocation receives an
+        execution deadline. Human approval waits explicitly pause that deadline;
+        a timeout still raises ``asyncio.TimeoutError`` so the caller's existing
+        timeout handling stays authoritative. When no timeout is annotated the
+        handler is called directly (no wrapping).
         """
         timeout = context.annotations.get("timeout")
 
         async def _run_handler() -> Dict[str, Any]:
             if timeout is not None:
-                return await asyncio.wait_for(handler(context), timeout=timeout)
+                return await run_tool_with_timeout(handler(context), timeout)
             return await handler(context)
 
         if not self._interceptors:
diff --git a/src/leapflow/engine/engine.py b/src/leapflow/engine/engine.py
index 821b7445..68d5f4bd 100644
--- a/src/leapflow/engine/engine.py
+++ b/src/leapflow/engine/engine.py
@@ -5589,16 +5589,14 @@ async def _execute_general_tool(
         try:
             handler = handlers.get(name)
             if handler is not None:
-                # The tool execution pipeline wraps only the handler call,
-                # enabling composable interceptors (audit, rate-limit, etc.)
-                # without touching the surrounding approval/semantic gates.
-                # Fast path: no interceptors registered = direct call, zero overhead.
+                # The execution deadline wraps each handler consistently, whether
+                # plugins install pipeline interceptors or the direct path is used.
+                from leapflow.domain.tool_pipeline import ToolCallContext, run_tool_with_timeout
                 from leapflow.plugins import get_registry
                 from leapflow.plugins.handler_invocation import invoke_tool_handler
 
                 pipeline = get_registry().tool_pipeline
                 if pipeline.interceptor_count > 0:
-                    from leapflow.domain.tool_pipeline import ToolCallContext
 
                     spec = _default_tool_registry().specs.get(name)
                     tool_metadata: Dict[str, Any] = {}
@@ -5622,8 +5620,8 @@ async def _invoke_handler(ctx: ToolCallContext) -> Dict[str, Any]:
 
                     result = await pipeline.execute(call_ctx, _invoke_handler)
                 else:
-                    result = await asyncio.wait_for(
-                        invoke_tool_handler(handler, args), timeout=timeout
+                    result = await run_tool_with_timeout(
+                        invoke_tool_handler(handler, args), timeout
                     )
             else:
                 # No handler — tool is truly unknown
diff --git a/tests/test_tool_pipeline.py b/tests/test_tool_pipeline.py
index 5bbd4f87..6f7b2c31 100644
--- a/tests/test_tool_pipeline.py
+++ b/tests/test_tool_pipeline.py
@@ -15,6 +15,8 @@
     ToolCallContext,
     ToolExecutionPipeline,
     ToolInterceptor,
+    pause_tool_execution_timeout_for_human_decision,
+    run_tool_with_timeout,
 )
 
 
@@ -438,6 +440,49 @@ async def test_timeout_uses_metadata_override(self) -> None:
         await pipeline.execute(ctx, echo_handler)
         assert ctx.annotations["_timeout"] == 5.0
 
+    @pytest.mark.asyncio
+    async def test_human_decision_pause_excludes_wait_from_execution_timeout(self) -> None:
+        waiting = asyncio.Event()
+        answered = asyncio.Event()
+        context = ToolCallContext(tool_name="write_file", arguments={})
+
+        async def handler(_: ToolCallContext) -> Dict[str, Any]:
+            async with pause_tool_execution_timeout_for_human_decision():
+                waiting.set()
+                await answered.wait()
+            await asyncio.sleep(0.005)
+            return {"completed": True}
+
+        task = asyncio.create_task(run_tool_with_timeout(handler(context), 0.02))
+        await asyncio.wait_for(waiting.wait(), timeout=1.0)
+        await asyncio.sleep(0.05)
+        assert not task.done(), "human decision time must not consume the tool deadline"
+
+        answered.set()
+        assert await asyncio.wait_for(task, timeout=1.0) == {"completed": True}
+
+    @pytest.mark.asyncio
+    async def test_execution_still_times_out_after_human_decision_pause(self) -> None:
+        waiting = asyncio.Event()
+        answered = asyncio.Event()
+        context = ToolCallContext(tool_name="write_file", arguments={})
+
+        async def handler(_: ToolCallContext) -> Dict[str, Any]:
+            async with pause_tool_execution_timeout_for_human_decision():
+                waiting.set()
+                await answered.wait()
+            await asyncio.sleep(0.05)
+            return {"completed": True}
+
+        task = asyncio.create_task(run_tool_with_timeout(handler(context), 0.02))
+        await asyncio.wait_for(waiting.wait(), timeout=1.0)
+        await asyncio.sleep(0.05)
+        assert not task.done(), "approval wait must remain unbounded"
+
+        answered.set()
+        with pytest.raises(asyncio.TimeoutError):
+            await asyncio.wait_for(task, timeout=1.0)
+
     @pytest.mark.asyncio
     async def test_timeout_wrapper_times_out(self) -> None:
         ctx = ToolCallContext(tool_name="slow", arguments={"delay": 10.0})
diff --git a/tests/test_turn_admission_parking.py b/tests/test_turn_admission_parking.py
index e423b1fb..4b06fafd 100644
--- a/tests/test_turn_admission_parking.py
+++ b/tests/test_turn_admission_parking.py
@@ -219,3 +219,28 @@ async def turn() -> None:
     assert decision == ["allow_once"]
     assert adm.snapshot()["available"] == 1
     assert adm.snapshot()["parked"] == 0
+
+
+@pytest.mark.asyncio
+async def test_coordinator_pauses_the_tool_deadline_for_a_pending_approval() -> None:
+    """An unanswered daemon prompt must not consume its tool's execution budget."""
+    from leapflow.daemon.approval_coordinator import ApprovalCoordinator
+    from leapflow.daemon.protocol import StreamChunk
+    from leapflow.domain.tool_pipeline import run_tool_with_timeout
+    from leapflow.security.approval import ApprovalRequest
+
+    coordinator = ApprovalCoordinator()
+    queue: asyncio.Queue[StreamChunk] = asyncio.Queue()
+    request = ApprovalRequest(category="file.write", detail="write delayed-output.py")
+
+    task = asyncio.create_task(run_tool_with_timeout(
+        coordinator.request_approval(request, (queue, "req-1")), 0.02,
+    ))
+    chunk = await asyncio.wait_for(queue.get(), timeout=1.0)
+    pending_id = chunk.metadata["approval"]["pending_id"]
+
+    await asyncio.sleep(0.05)
+    assert not task.done(), "a pending approval must not expire with the tool deadline"
+
+    await coordinator.resolve(pending_id, "allow_once")
+    assert await asyncio.wait_for(task, timeout=1.0) == "allow_once"

From 200c63207adf1f51154d0a2950b37e678aee12d2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8F=AD=E6=89=AC?= <xingjun.wxj@alibaba-inc.com>
Date: Sun, 20 Sep 2026 12:51:25 +0800
Subject: [PATCH 10/10] fix(approval): make session bypass unconditional

---
 src/leapflow/security/approval.py       |  36 ++----
 src/leapflow/security/orchestrator.py   |  13 +--
 src/leapflow/security/policy.py         |   5 +-
 src/leapflow/security/risk.py           |  94 ++++++++++++++--
 src/leapflow/tools/execution_context.py |  35 +-----
 src/leapflow/tools/shell_tools.py       |   3 +-
 tests/test_approval_layer.py            | 140 +++++++++---------------
 tests/test_path_sensitivity.py          |  12 ++
 tests/test_workspace_escape_approval.py |  45 +-------
 9 files changed, 175 insertions(+), 208 deletions(-)

diff --git a/src/leapflow/security/approval.py b/src/leapflow/security/approval.py
index f1474061..88ecb157 100644
--- a/src/leapflow/security/approval.py
+++ b/src/leapflow/security/approval.py
@@ -15,7 +15,7 @@
 from typing import Any, Protocol, runtime_checkable
 
 from leapflow.security.actions import ActionDescriptor
-from leapflow.security.risk import RiskAssessment, RiskLevel
+from leapflow.security.risk import RiskAssessment
 
 logger = logging.getLogger(__name__)
 
@@ -133,28 +133,14 @@ async def check(self, command: str) -> bool:
     async def request_approval(
         self, request: ApprovalRequest,
     ) -> ApprovalDecision:
-        # Session-wide bypass: auto-approve without prompting, EXCEPT
-        # high/critical-risk actions whose risk classifier set
-        # allow_permanent=False.  Those actions require per-invocation
-        # consent; letting a low-risk approval silently extend to them
-        # would let plugin installs, external sends, and credential
-        # reads bypass the gate they are specifically designed to hit.
+        # Session-wide bypass is explicit user consent for every action that
+        # reaches this gate. Hardline actions are denied by ApprovalPolicyEngine
+        # before a request is built, so this branch never weakens that boundary.
+        # ``allow_permanent`` controls profile persistence only; it must not turn
+        # a session-wide bypass into a misleading partial bypass.
         if self._bypass_all:
-            risk = request.risk
-            if (
-                risk is not None
-                and not risk.allow_permanent
-                and risk.level in {RiskLevel.HIGH, RiskLevel.CRITICAL}
-            ):
-                logger.info(
-                    "bypass_all.fallthrough category=%s level=%s "
-                    "allow_permanent=False",
-                    request.category,
-                    risk.level.value,
-                )
-            else:
-                self._log_decision(request, ApprovalDecision.ALLOW, auto=True)
-                return ApprovalDecision.ALLOW
+            self._log_decision(request, ApprovalDecision.ALLOW, auto=True)
+            return ApprovalDecision.ALLOW
 
         grant_key = request.grant_key
         if grant_key in self._approved_categories:
@@ -164,10 +150,8 @@ async def request_approval(
         decision = await self._delegate.request_approval(request)
 
         # Validate that the delegate's decision is within the declared
-        # choices.  A delegate returning a choice the orchestrator
-        # withheld (e.g. allow_all_session when allow_permanent=False)
-        # is either a UI defect or a spoofed response; fail-closed to
-        # the request's default (deny) rather than honouring it.
+        # choices. A choice outside the request contract is either a UI defect
+        # or a spoofed response, so fail closed to the request default.
         if request.choices and decision.value not in request.choices:
             logger.warning(
                 "approval.decision_out_of_choices category=%s "
diff --git a/src/leapflow/security/orchestrator.py b/src/leapflow/security/orchestrator.py
index 62e5ce15..2c5f357c 100644
--- a/src/leapflow/security/orchestrator.py
+++ b/src/leapflow/security/orchestrator.py
@@ -217,15 +217,12 @@ def _denied(
 
     @staticmethod
     def _choices(allow_permanent: bool) -> tuple[str, ...]:
-        base = ["allow_once", "allow_session"]
+        # Session bypass is explicit consent for every action that can reach an
+        # approval prompt. ``allow_permanent`` governs only persistence beyond
+        # the current session, never the meaning of “Allow ALL for this session”.
+        base = ["allow_once", "allow_session", "allow_all_session"]
         if allow_permanent:
-            # Session-wide and profile-wide grants are only offered when
-            # the risk classifier explicitly permits reuse.  Actions
-            # whose ``allow_permanent`` is False (plugin management,
-            # external sends, credential reads, etc.) must never be
-            # auto-approved by a session bypass earned from a lower-risk
-            # approval.
-            base.extend(["allow_all_session", "allow_always"])
+            base.append("allow_always")
         base.extend(["deny", "deny_always", "show_details"])
         return tuple(base)
 
diff --git a/src/leapflow/security/policy.py b/src/leapflow/security/policy.py
index f34337b5..bb993c66 100644
--- a/src/leapflow/security/policy.py
+++ b/src/leapflow/security/policy.py
@@ -42,14 +42,15 @@ def __init__(self, rules: list[ApprovalPolicyRule] | None = None, *, bypass: boo
         self._bypass = bypass
 
     def evaluate(self, action: ActionDescriptor, risk: RiskAssessment) -> PolicyDecision:
-        # Hardline/CRITICAL always denied regardless of bypass
+        # Hardline/CRITICAL actions are not approvable and therefore never reach
+        # either config-level or session-level bypass handling.
         if risk.hardline or risk.level == RiskLevel.CRITICAL:
             return PolicyDecision(
                 verdict=PolicyVerdict.DENY,
                 reason="; ".join(risk.reasons) or "hardline_block",
                 allow_permanent=False,
             )
-        # Bypass mode: auto-allow everything below CRITICAL
+        # Config bypass auto-allows every action that remains approvable.
         if self._bypass:
             return PolicyDecision(verdict=PolicyVerdict.ALLOW, reason="bypass_mode")
         # Normal rule-based evaluation
diff --git a/src/leapflow/security/risk.py b/src/leapflow/security/risk.py
index 0f5c519e..58dc36c1 100644
--- a/src/leapflow/security/risk.py
+++ b/src/leapflow/security/risk.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import re
+import shlex
 from dataclasses import asdict, dataclass, field
 from enum import Enum
 from pathlib import Path
@@ -511,18 +512,89 @@ def _assess_mcp_tool(self, action: ActionDescriptor) -> RiskAssessment:
     def _matched_reasons(command: str, rules: tuple[tuple[re.Pattern[str], str], ...]) -> list[str]:
         return [reason for pattern, reason in rules if pattern.search(command)]
 
-    @staticmethod
-    def _mentions_sensitive_config(command: str) -> bool:
-        lowered = command.lower().replace("\\", "/")
-        configured_roots = tuple(
-            str(root).lower().replace("\\", "/").rstrip("/")
-            for root in configured_path_sensitivity_roots()
+    _SHELL_CONTROL_OPERATORS = frozenset({"&&", "||", ";", "|", "&"})
+    _SHELL_REDIRECTION_OPERATORS = frozenset({">", ">>", "<", "<<", "<<<"})
+    _SHELL_FILE_ACCESS_COMMANDS = frozenset({
+        ".", "awk", "cat", "chmod", "chown", "cp", "cut", "diff", "find", "grep", "head",
+        "less", "ln", "ls", "more", "mv", "rg", "ripgrep", "rm", "sed", "sort", "source",
+        "stat", "tail", "tee", "test", "touch", "uniq", "vim",
+    })
+    _SHELL_PATTERN_ARGUMENT_COMMANDS = frozenset({"awk", "grep", "rg", "ripgrep", "sed"})
+    _SENSITIVE_CONFIG_SUFFIXES = (
+        "/.leapflow/config.yaml", "/.leapflow/workspace.yaml", "/config/user.yaml",
+        "/mcp_servers.json", "/workspace.yaml", "/tui_history",
+    )
+
+    @classmethod
+    def _mentions_sensitive_config(cls, command: str) -> bool:
+        """Return whether a shell command addresses a sensitive path operand.
+
+        Commands are tokenized before inspecting path operands so text such as
+        ``echo config.yaml`` is not confused with file access. Shell parsing
+        failures retain the command's other risk matches but do not promote an
+        arbitrary substring to a sensitive-config operation.
+        """
+        try:
+            tokens = shlex.split(command, posix=True, comments=False)
+        except ValueError:
+            return False
+
+        segment: list[str] = []
+        for token in [*tokens, ";"]:
+            if token in cls._SHELL_CONTROL_OPERATORS:
+                if cls._segment_mentions_sensitive_config(segment):
+                    return True
+                segment = []
+            else:
+                segment.append(token)
+        return False
+
+    @classmethod
+    def _segment_mentions_sensitive_config(cls, segment: list[str]) -> bool:
+        if not segment:
+            return False
+
+        for index, token in enumerate(segment):
+            if token in cls._SHELL_REDIRECTION_OPERATORS:
+                if index + 1 < len(segment) and cls._is_sensitive_shell_path(segment[index + 1]):
+                    return True
+                continue
+            match = re.match(r"^(?:\\d*(?:>>?|<<?<?))(.+)$", token)
+            if match and cls._is_sensitive_shell_path(match.group(1)):
+                return True
+
+        command_index = next(
+            (index for index, token in enumerate(segment) if not token.startswith("-") and "=" not in token),
+            None,
         )
+        if command_index is None:
+            return False
+        command = segment[command_index].lower()
+        if command not in cls._SHELL_FILE_ACCESS_COMMANDS:
+            return False
+
+        operands = [token for token in segment[command_index + 1:] if not token.startswith("-")]
+        if command in cls._SHELL_PATTERN_ARGUMENT_COMMANDS and operands:
+            operands = operands[1:]
+        return any(cls._is_sensitive_shell_path(token) for token in operands)
+
+    @classmethod
+    def _is_sensitive_shell_path(cls, token: str) -> bool:
+        candidate = token.split("=", 1)[-1].strip().replace("\\", "/")
+        if not candidate or candidate.startswith(("http://", "https://")):
+            return False
+        expanded = str(Path(candidate).expanduser()).replace("\\", "/")
+        lowered = expanded.lower().rstrip("/")
+        if Path(expanded).name.lower() in cls._SENSITIVE_NAMES:
+            return True
+        if any(part in lowered for part in cls._SENSITIVE_PARTS):
+            return True
+        if lowered.endswith(cls._SENSITIVE_CONFIG_SUFFIXES):
+            return True
         return any(
-            token in lowered
-            for token in (
-                ".env", "vault.json", "vault.key", "secrets.yaml", "config/user.yaml",
-                "mcp_servers.json", "workspace.yaml", ".leapflow/config.yaml", "tui_history",
-                "profiles/", "config.yaml", *configured_roots,
+            lowered == root or lowered.startswith(root + "/")
+            for root in (
+                str(path).lower().replace("\\", "/").rstrip("/")
+                for path in configured_path_sensitivity_roots()
             )
         )
diff --git a/src/leapflow/tools/execution_context.py b/src/leapflow/tools/execution_context.py
index b7ba3e9b..76ca0091 100644
--- a/src/leapflow/tools/execution_context.py
+++ b/src/leapflow/tools/execution_context.py
@@ -184,33 +184,6 @@ def _active_orchestrator() -> Any:
         return None
 
 
-def is_approval_bypass_active() -> bool:
-    """Return whether approval prompts are bypassed for this turn.
-
-    The single predicate every gate consults, so a bypass cannot mean "approved"
-    at one gate and "still ask" at the next. It covers both the config/env level
-    (``approval_bypass``) and the session level (the user picked "Allow ALL for
-    this session", which arms ``SessionAwareGate._bypass_all``).
-
-    The session flag is reached through ``_delegate`` as well as ``_gate``: the
-    in-process CLI installs a wrapper gate, and looking only at ``_gate`` would
-    miss the bypass in exactly that mode.
-    """
-    ctx = current_tool_context()
-    if ctx is None:
-        return False
-    if getattr(ctx, "approval_bypass", False):
-        return True
-    orchestrator = _active_orchestrator()
-    if orchestrator is None:
-        return False
-    gate = getattr(orchestrator, "_gate", None)
-    if gate is None:
-        delegate = getattr(orchestrator, "_delegate", None)
-        if delegate is not None:
-            gate = getattr(delegate, "_gate", None)
-    return bool(gate is not None and getattr(gate, "_bypass_all", False))
-
 
 async def require_workspace_access(
     path: Path,
@@ -222,9 +195,9 @@ async def require_workspace_access(
 ) -> dict[str, Any] | None:
     """Gate access to *path*. Returns None when permitted, else a refusal dict.
 
-    The whole sequence lives here — boundary check, bypass, human approval,
-    refusal — because it used to be spelled out per call site and only the shell
-    path ever got it right. The other eleven returned the refusal directly, so
+    The whole sequence lives here — boundary check, policy, approval, refusal —
+    because it used to be spelled out per call site and only the shell path ever
+    got it right. The other eleven returned the refusal directly, so
     ``file_list``/``code_search`` refused in 39ms with a message claiming approval
     was required, and ignored a session-wide "Allow ALL" that the shell honoured.
 
@@ -237,8 +210,6 @@ async def require_workspace_access(
     refusal = workspace_scope_refusal(path, operation=operation)
     if refusal is None:
         return None
-    if is_approval_bypass_active():
-        return None
 
     orchestrator = _active_orchestrator()
     evaluate = getattr(orchestrator, "evaluate", None)
diff --git a/src/leapflow/tools/shell_tools.py b/src/leapflow/tools/shell_tools.py
index 6d563dd1..377b86d6 100644
--- a/src/leapflow/tools/shell_tools.py
+++ b/src/leapflow/tools/shell_tools.py
@@ -21,7 +21,6 @@
 
 from leapflow.tools.execution_context import (
     current_tool_context,
-    is_approval_bypass_active,
     is_within_allowed_roots,
     require_workspace_access,
     resolve_workspace_path,
@@ -273,7 +272,7 @@ async def shell_run(params: Dict[str, Any]) -> Dict[str, Any]:
         if scope_error:
             return scope_error
 
-    if _is_dangerous(command) and not is_approval_bypass_active():
+    if _is_dangerous(command):
         approved, message = await _approve_command(command, cwd)
         if not approved:
             return {"ok": False, "error": message}
diff --git a/tests/test_approval_layer.py b/tests/test_approval_layer.py
index 7dc99c6f..298a3661 100644
--- a/tests/test_approval_layer.py
+++ b/tests/test_approval_layer.py
@@ -369,7 +369,7 @@ async def check(self, *_args, **_kwargs) -> bool:
 
 
 # ════════════════════════════════════════════════════════════════
-# _bypass_all session bypass: security hardening (issue #30)
+# _bypass_all session bypass semantics
 # ════════════════════════════════════════════════════════════════
 
 
@@ -406,31 +406,42 @@ def _high_risk_permanent() -> RiskAssessment:
 
 
 @pytest.mark.asyncio
-async def test_bypass_all_does_not_auto_approve_high_no_permanent() -> None:
-    """_bypass_all must not auto-approve HIGH+allow_permanent=False actions.
-
-    This is the core of the _bypass_all privilege-escalation fix: a session
-    bypass earned from a low-risk approval must not silently extend to
-    plugin installs, external sends, or other actions the risk classifier
-    marked as non-reusable.
-    """
-    delegate = _Gate(ApprovalDecision.ALLOW_ONCE)
+async def test_bypass_all_auto_approves_high_no_permanent() -> None:
+    """Session bypass covers every action that can reach an approval prompt."""
+    delegate = _Gate(ApprovalDecision.DENY)
     gate = SessionAwareGate(delegate)
-    # Arm the bypass.
     gate._bypass_all = True
 
     request = ApprovalRequest(
         category="platform.action",
         detail="plugin install",
         risk=_high_risk_no_permanent(),
-        choices=("allow_once", "allow_session", "deny"),
+        choices=("allow_once", "allow_session", "allow_all_session", "deny"),
         default_choice="deny",
     )
     decision = await gate.request_approval(request)
 
-    # The delegate must have been consulted -- bypass did not fire.
+    assert delegate.requests == []
+    assert decision == ApprovalDecision.ALLOW
+
+
+@pytest.mark.asyncio
+async def test_high_risk_request_can_arm_and_reuse_session_bypass() -> None:
+    """The bypass choice remains valid even when persistent grants are forbidden."""
+    delegate = _Gate(ApprovalDecision.ALLOW_ALL_SESSION)
+    gate = SessionAwareGate(delegate)
+    request = ApprovalRequest(
+        category="platform.action",
+        detail="plugin install",
+        risk=_high_risk_no_permanent(),
+        choices=ApprovalOrchestrator._choices(allow_permanent=False),
+        default_choice="deny",
+    )
+
+    assert await gate.request_approval(request) == ApprovalDecision.ALLOW
+    assert gate._bypass_all is True
+    assert await gate.request_approval(request) == ApprovalDecision.ALLOW
     assert len(delegate.requests) == 1
-    assert decision == ApprovalDecision.ALLOW_ONCE
 
 
 @pytest.mark.asyncio
@@ -456,12 +467,7 @@ async def test_bypass_all_still_auto_approves_low_and_medium_risk() -> None:
 
 @pytest.mark.asyncio
 async def test_bypass_all_auto_approves_high_with_allow_permanent() -> None:
-    """HIGH + allow_permanent=True (e.g. hardware) is still bypassed.
-
-    The fix gates only on the *combination* of high risk and non-reusable
-    consent, so hardware writes that declare allow_permanent=True are
-    unaffected.
-    """
+    """The bypass also covers high-risk actions eligible for persistence."""
     delegate = _Gate(ApprovalDecision.DENY)
     gate = SessionAwareGate(delegate)
     gate._bypass_all = True
@@ -479,17 +485,15 @@ async def test_bypass_all_auto_approves_high_with_allow_permanent() -> None:
     assert delegate.requests == []
 
 
-@pytest.mark.asyncio
-async def test_choices_exclude_allow_all_session_when_not_permanent() -> None:
-    """allow_all_session must not be offered for non-reusable actions."""
+def test_choices_offer_session_bypass_without_offering_persistent_grant() -> None:
+    """Session bypass is universal while profile persistence stays risk-bound."""
     choices_restricted = ApprovalOrchestrator._choices(allow_permanent=False)
     choices_full = ApprovalOrchestrator._choices(allow_permanent=True)
 
-    assert "allow_all_session" not in choices_restricted
+    assert "allow_all_session" in choices_restricted
     assert "allow_always" not in choices_restricted
     assert "allow_all_session" in choices_full
     assert "allow_always" in choices_full
-    # Core choices are always present.
     assert "allow_once" in choices_restricted
     assert "allow_session" in choices_restricted
     assert "deny" in choices_restricted
@@ -523,13 +527,9 @@ async def test_delegate_decision_outside_choices_falls_back_to_deny() -> None:
 
 
 @pytest.mark.asyncio
-async def test_bypass_all_and_choices_validation_combined() -> None:
-    """Full chain: bypass armed → HIGH non-reusable → fallthrough → delegate
-    returns out-of-choices → denied.
-
-    Exercises all three fixes together as defence-in-depth.
-    """
-    delegate = _Gate(ApprovalDecision.ALLOW_ALL_SESSION)
+async def test_bypass_all_skips_delegate_for_high_external_action() -> None:
+    """A high-risk external action is auto-approved once bypass is armed."""
+    delegate = _Gate(ApprovalDecision.DENY)
     gate = SessionAwareGate(delegate)
     gate._bypass_all = True
 
@@ -543,26 +543,17 @@ async def test_bypass_all_and_choices_validation_combined() -> None:
             explanation="external platform send",
             allow_permanent=False,
         ),
-        choices=("allow_once", "allow_session", "deny", "deny_always"),
+        choices=ApprovalOrchestrator._choices(allow_permanent=False),
         default_choice="deny",
     )
-    decision = await gate.request_approval(request)
 
-    # Fix 1: bypass fell through (HIGH + !allow_permanent).
-    # Fix 3: delegate returned ALLOW_ALL_SESSION not in choices → deny.
-    assert decision == ApprovalDecision.DENY
-    assert len(delegate.requests) == 1
-    assert gate._bypass_all is True  # not disarmed, still set from before
+    assert await gate.request_approval(request) == ApprovalDecision.ALLOW
+    assert delegate.requests == []
 
 
 @pytest.mark.asyncio
-async def test_orchestrator_high_no_permanent_through_full_chain() -> None:
-    """End-to-end: orchestrator + SessionAwareGate for a plugin_management action.
-
-    Verifies the orchestrator builds the right choices and the gate enforces
-    them when a delegate tries to escalate.
-    """
-    # Delegate always tries ALLOW_ALL_SESSION -- a realistic UI misconfig.
+async def test_orchestrator_high_no_permanent_can_arm_bypass() -> None:
+    """A high-risk prompt may explicitly arm the session-wide bypass."""
     delegate = _Gate(ApprovalDecision.ALLOW_ALL_SESSION)
     gate = SessionAwareGate(delegate)
     orchestrator = ApprovalOrchestrator(gate)
@@ -576,16 +567,14 @@ async def test_orchestrator_high_no_permanent_through_full_chain() -> None:
 
     result = await orchestrator.evaluate(action)
 
-    # The risk classifier forces HIGH + allow_permanent=False.
     assert result.risk.level == RiskLevel.HIGH
     assert result.risk.allow_permanent is False
-    # The delegate returned ALLOW_ALL_SESSION which was not in choices → deny.
-    assert result.approved is False
-    assert gate._bypass_all is False
+    assert result.approved is True
+    assert gate._bypass_all is True
 
 
 # ════════════════════════════════════════════════════════════════
-# Irreversible / external-output physical writes under bypass (issue #34)
+# Irreversible / external-output physical writes under bypass
 # ════════════════════════════════════════════════════════════════
 
 
@@ -617,17 +606,9 @@ def _critical_no_permanent() -> RiskAssessment:
 
 
 @pytest.mark.asyncio
-async def test_bypass_all_does_not_auto_approve_irreversible_hardware_write() -> None:
-    """An irreversible physical write must fall through, not be blanket-approved.
-
-    Before #34, ``_tier_for`` marked in-envelope physical writes
-    allow_permanent=True, so an irreversible DISPENSE reached the gate as
-    HIGH+allow_permanent=True and was silently authorised by a session-wide
-    bypass earned from a lower-risk approval. With the tightening it arrives
-    as HIGH+allow_permanent=False, so the bypass must fall through to the
-    delegate for per-invocation consent.
-    """
-    delegate = _Gate(ApprovalDecision.ALLOW_ONCE)
+async def test_bypass_all_auto_approves_irreversible_hardware_write() -> None:
+    """Explicit session bypass covers irreversible but approvable actions."""
+    delegate = _Gate(ApprovalDecision.DENY)
     gate = SessionAwareGate(delegate)
     gate._bypass_all = True
 
@@ -635,36 +616,21 @@ async def test_bypass_all_does_not_auto_approve_irreversible_hardware_write() ->
         category="device.dispense",
         detail="aspirate 10 uL",
         risk=_irreversible_hardware_write(),
-        choices=("allow_once", "allow_session", "deny"),
+        choices=ApprovalOrchestrator._choices(allow_permanent=False),
         default_choice="deny",
     )
-    decision = await gate.request_approval(request)
-
-    # The delegate was consulted -- the bypass did not fire.
-    assert len(delegate.requests) == 1
-    assert decision == ApprovalDecision.ALLOW_ONCE
 
+    assert await gate.request_approval(request) == ApprovalDecision.ALLOW
+    assert delegate.requests == []
 
-@pytest.mark.asyncio
-async def test_bypass_all_does_not_auto_approve_critical_no_permanent() -> None:
-    """CRITICAL + allow_permanent=False must fall through under a session bypass.
 
-    The fallthrough covers both HIGH and CRITICAL; this guards the CRITICAL
-    arm so a session-wide bypass cannot blanket-approve, for example, a write
-    that could only be classified as an unresolvable/hardline command.
-    """
-    delegate = _Gate(ApprovalDecision.ALLOW_ONCE)
-    gate = SessionAwareGate(delegate)
-    gate._bypass_all = True
+def test_policy_blocks_critical_action_before_session_bypass() -> None:
+    """Critical actions are denied before any session bypass can be consulted."""
+    from leapflow.security.policy import ApprovalPolicyEngine, PolicyVerdict
 
-    request = ApprovalRequest(
-        category="device.actuate",
-        detail="unresolvable device command",
-        risk=_critical_no_permanent(),
-        choices=("allow_once", "allow_session", "deny"),
-        default_choice="deny",
+    decision = ApprovalPolicyEngine().evaluate(
+        ActionDescriptor.shell("unresolvable device command"),
+        _critical_no_permanent(),
     )
-    decision = await gate.request_approval(request)
 
-    assert len(delegate.requests) == 1
-    assert decision == ApprovalDecision.ALLOW_ONCE
+    assert decision.verdict is PolicyVerdict.DENY
diff --git a/tests/test_path_sensitivity.py b/tests/test_path_sensitivity.py
index 08df91cc..899dd665 100644
--- a/tests/test_path_sensitivity.py
+++ b/tests/test_path_sensitivity.py
@@ -42,6 +42,18 @@ def test_risk_classifier_uses_configured_layout_root_for_shell_config_mentions(t
         configure_path_sensitivity_roots((Path("~/.leapflow").expanduser(),))
 
 
+def test_shell_sensitive_config_detection_inspects_path_operands_not_text() -> None:
+    classifier = DefaultRiskClassifier()
+
+    assert classifier.assess(ActionDescriptor.shell("cat .env")).level == RiskLevel.HIGH
+    assert classifier.assess(ActionDescriptor.shell("printf secret > .env")).level == RiskLevel.HIGH
+    assert classifier.assess(ActionDescriptor.shell('echo "config.yaml"')).level == RiskLevel.LOW
+    assert classifier.assess(ActionDescriptor.shell("grep config.yaml README.md")).level == RiskLevel.LOW
+    assert classifier.assess(
+        ActionDescriptor.shell("awk '{print $1}' ~/.leapflow/config/user.yaml")
+    ).level == RiskLevel.HIGH
+
+
 def test_path_sensitivity_classifies_new_layout_categories(tmp_path) -> None:
     data_root = tmp_path / "custom-leap-home"
     configure_path_sensitivity_roots((data_root,))
diff --git a/tests/test_workspace_escape_approval.py b/tests/test_workspace_escape_approval.py
index 4ae4b95b..d5828e50 100644
--- a/tests/test_workspace_escape_approval.py
+++ b/tests/test_workspace_escape_approval.py
@@ -9,7 +9,7 @@
 
 These tests pin the three properties that were broken:
   1. every entry point routes through the approval gate,
-  2. every entry point honours the one bypass predicate,
+  2. every entry point keeps the approval chain observable under bypass,
   3. the escape is risk-classified so the policy engine always asks.
 """
 from __future__ import annotations
@@ -23,7 +23,6 @@
 from leapflow.security.risk import DefaultRiskClassifier, RiskLevel
 from leapflow.tools.execution_context import (
     ToolExecutionContext,
-    is_approval_bypass_active,
     require_workspace_access,
     reset_tool_context,
     set_tool_context,
@@ -140,27 +139,22 @@ async def test_entry_point_asks_before_leaving_the_workspace(
     _ENTRY_POINTS,
     ids=[f"{m}.{a}" for m, a, _, _ in _ENTRY_POINTS],
 )
-async def test_entry_point_honours_the_bypass(
+async def test_entry_point_uses_unified_approval_chain_under_bypass(
     tmp_path, module_name, attr, build_params, expected_effect,
 ) -> None:
-    """A session-wide bypass must not stop at the shell.
-
-    The file tools used to ignore it entirely, so a user who had granted
-    "Allow ALL for this session" still got refused by ``file_list`` while
-    ``shell_run`` ran freely — the worst possible split.
-    """
+    """Bypass is decided by the orchestrator rather than a tool-local shortcut."""
     outside = tmp_path / "outside"
     outside.mkdir()
     (outside / "a.txt").write_text("a", encoding="utf-8")
 
-    gate = RecordingOrchestrator(approved=False)
+    gate = RecordingOrchestrator(approved=True)
     token = set_tool_context(_context(tmp_path, gate, bypass=True))
     try:
         result = await _handler(module_name, attr)(build_params(outside))
     finally:
         reset_tool_context(token)
 
-    assert gate.actions == [], f"{attr} prompted despite an active bypass"
+    assert len(gate.actions) == 1, f"{attr} bypassed the unified approval chain"
     assert result.get("error_type") != "outside_workspace"
 
 
@@ -235,35 +229,6 @@ async def test_paths_inside_the_workspace_are_not_gated(tmp_path) -> None:
     assert gate.actions == []
 
 
-# ── one bypass predicate ─────────────────────────────────────────────────────
-
-def test_bypass_predicate_penetrates_a_wrapper_gate(tmp_path) -> None:
-    """The in-process CLI wraps the gate; looking only at ``_gate`` misses it."""
-
-    class SessionGate:
-        _bypass_all = True
-
-    class Orchestrator:
-        _gate = SessionGate()
-
-    class WrapperGate:
-        def __init__(self, delegate: Any) -> None:
-            self._delegate = delegate
-
-    token = set_tool_context(_context(tmp_path, WrapperGate(Orchestrator())))
-    try:
-        assert is_approval_bypass_active() is True
-    finally:
-        reset_tool_context(token)
-
-
-def test_bypass_predicate_is_false_without_a_grant(tmp_path) -> None:
-    token = set_tool_context(_context(tmp_path, RecordingOrchestrator(approved=True)))
-    try:
-        assert is_approval_bypass_active() is False
-    finally:
-        reset_tool_context(token)
-
 
 # ── the escape is always risk-classified above the auto-allow floor ──────────