agent-bios 0.17.0 → 0.18.0

package/README.md

@@ -283,6 +283,52 @@ arbitrary package authoring/import, automatic semantic conflict resolution, or v
 native skill-menu registration; those design stages must not be inferred from the
 library UI.
 
+Studio marks rules containing explicit `guides/*.md` references with **→ GUIDE**
+and the guide names in the library. Their **Guide pointer** section links to exact
+guide members in the same package and shows each target's current consumption surface
+and state. Missing or ambiguous targets are disclosed rather than guessed. These
+are display-only references, not new dependencies or proof of loading: rule bodies,
+IDs, ordering, selection, and delivery remain unchanged. Personal body edits are
+reflected when the library refreshes; ordinary rules are not classified by meaning.
+
+Moving the library cursor to an item immediately displays its document; Enter is
+not required. Group rows show group guidance and disable item-specific actions.
+Cursor events cannot retarget an open editor or a prepared change preview.
+
+Arrow keys also navigate the reading controls: **Search ↓ buttons ↓ library →
+document**, with **←/→** between neighboring buttons and **↑** back toward search.
+At the end of search text, **→** focuses the view selector; within text, the caret
+moves normally. **←** from a closed view selector returns to search. Open menus
+keep their native arrow selection. The library keeps normal **↑/↓** item movement;
+at its top, **↑** returns to controls. In the document, arrows scroll until an
+edge: **←** returns to the library, **↑** reaches the controls/member selector,
+and **↓** at the bottom reaches pending on/off buttons when present. Disabled or
+hidden buttons are skipped. TextArea editing, modal boundaries, and Tab remain intact.
+
+In the library, **Space** toggles an item's use in future activated sessions:
+`[x]` is on, `[ ]` is off, `[-]` is removed, and `*` marks an unapplied change.
+The Available group means retained authoring items, not that every item is on.
+Stage several choices, then use **Preview on/off → Apply**, or **Discard on/off**.
+Text inputs keep normal spaces; Space on a group still expands or collapses it.
+Unapplied choices require discard confirmation on exit and cannot be mixed with
+content edits. A stale authoring revision refuses the preview or apply.
+
+Per-item choices override domain and explicit launch selections, including core
+and infrastructure defaults. Turning an item off does not delete its body, edits,
+or identity, and old snapshots and session pins remain intact. Choices survive
+updates and content restoration; full reset returns to installed defaults.
+Enabling a removed item requires Restore/Recover first. A guide switched off is
+marked in its referring rule, without automatically changing that rule. Native
+hook/agent opt-in, trust, host support, and promotion rules still apply: a checked
+item is a projection choice, not proof of execution. This does not block host
+global/project instructions or a tool from opening a file independently.
+
+The same revision-checked manager accepts `{"operation":"enable","items":{"@agent-bios/core:rule-003":false}}`
+through `corpus plan`; `true` forces inclusion, `false` excludes, and `null`
+removes that override so the normal selection applies. `list` reports `enabled`,
+`enabled_override`, and the captured authoring `revision`; pass that revision as
+`expected_revision` when planning a batch from the displayed inventory.
+
 New personal identities are allocated once in the creation plan and remain stable
 on retry; reset and history rollback do not make retired identities reusable.
 Member files are the content authority: `primary_member` identifies the main file,

package/compose/bootstrap/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: corpus
-description: Inspect or change the private agent-bios corpus used by activated sessions, including item creation, edits, consumption placement, removal, restore, recovery, selection, reset, rollback, history, and current-vs-pinned explanation. Use for requests about the user's agent-bios instructions or personal learnings; it does not alter the running session or native global files.
+description: Inspect or change the private agent-bios corpus used by activated sessions, including item creation, edits, consumption placement, enablement, removal, restore, recovery, selection, reset, rollback, history, and current-vs-pinned explanation. Use for requests about the user's agent-bios instructions or personal learnings; it does not alter the running session or native global files.
 ---
 
 # Corpus management
@@ -64,11 +64,21 @@ Supported payloads:
 {"operation":"restore","ref":"@scope/name:item-id"}
 {"operation":"recover","ref":"@local/personal:item-id"}
 {"operation":"select","selection":["@scope/name/domain"]}
+{"operation":"enable","items":{"@scope/name:item-id":false},"expected_revision":"<revision from list>"}
 {"operation":"reset"}
 {"operation":"rollback","baseline_ref":"<baseline_ref>"}
 {"operation":"rollback","history_id":"<history_id>"}
 ```
 
+For turning items on or off without losing edits, use `enable`, not remove/restore.
+Its `items` mapping supports batches: `true` forces inclusion, `false` excludes,
+and `null` returns to normal selection. Read `enabled`, `enabled_override`, and
+`revision` from `list`; the captured revision binds the whole batch. Overrides
+take precedence over domain/core/infra and per-launch selections, survive updates
+and content restoration, and clear on full reset. They do not bypass native
+opt-in, trust, host support, or promotion rules, or prevent independent file reads.
+Removed items require Restore/Recover first. Existing session pins remain unchanged.
+
 For a body edit, submit `body`; the manager updates the item's `primary_member`
 and derives every content view from that file. For a multi-file edit, submit
 `members` retaining unchanged files. A conflicting simultaneous body/member edit

package/compose/corpus_store.py

@@ -37,6 +37,7 @@ ITEM_FIELDS = {
 RUNTIME_FIELDS = {
     "digest", "revision", "content_ref", "path", "state", "created_at",
     "updated_at", "baseline_ref", "plan_id", "history_id",
+    "enabled", "enabled_override",
 }
 LEARNING_FIELDS = {"schema_version", "learning_id", "lesson", "domain", "created", "supporting_sessions",
                    "criteria", "classification", "proposed_domain", "context"}
@@ -307,8 +308,20 @@ class CorpusStore:
         for field, typ in (("items", dict), ("overrides", dict), ("tombstones", dict), ("learning_suppressions", dict)):
             if not isinstance(state.get(field), typ):
                 raise CorpusStoreError(f"personal state has invalid {field}")
+        # Optional, so reading an older state does not change its revision or the
+        # exact before/after documents used by prepared-transaction recovery.
+        self._enabled_overrides(state)
         return state
 
+    @staticmethod
+    def _enabled_overrides(user: dict[str, Any]) -> dict[str, bool]:
+        values = user.get("enabled_overrides", {})
+        if (not isinstance(values, dict) or any(
+                not isinstance(ref, str) or ":" not in ref or not isinstance(value, bool)
+                for ref, value in values.items())):
+            raise CorpusStoreError("personal state has invalid enabled_overrides")
+        return values
+
     def _write_transaction(self, tx_id: str, record: dict[str, Any]) -> None:
         _atomic_write(self.runtime / "transactions" / tx_id / "journal.json", record)
 
@@ -351,7 +364,7 @@ class CorpusStore:
                 journal["history_id"] = history_id
                 _atomic_write(journal_path, journal)
             history = {"runtime": prior["runtime"], "user": prior["user"],
-                       "revision": plan.get("expected_revision")}
+                       "revision": plan.get("expected_revision"), "details": plan.get("details", {})}
             history_path = self.user_root / "history" / history_id / "state.json"
             if not history_path.exists():
                 _atomic_write(history_path, history)
@@ -701,7 +714,7 @@ class CorpusStore:
                     active = [item for item in items if item.get("active", True) is not False]
                     selection = self._effective_selection(user, defaults, None)
                     self._validate_snapshot_selection(selection, _inventory, active)
-                    selected = self._selected_items(active, selection)
+                    selected = self._selected_items(active, selection, self._enabled_overrides(user))
                     self._require_resolved(selected)
                     catalog.compile_items(_copy_json(selected), Path(temp) / host, host)
         except Exception as exc:
@@ -896,18 +909,24 @@ class CorpusStore:
                 "revision": revision, "baseline_count": len(refs),
                 "personal_items": len(user["items"]), "overrides": len(user["overrides"]),
                 "tombstones": len(user["tombstones"]), "selection": self._effective_selection(user, defaults, None),
+                "enabled_overrides": _copy_json(self._enabled_overrides(user)),
             }
 
     def list_items(self, include_removed: bool = True) -> list[dict[str, Any]]:
         with self._lock():
             self._recover_locked()
             runtime, user = self._runtime_state(), self._user_state()
-            selected_ref, inventory, _defaults = self._selected_baseline(runtime)
+            selected_ref, inventory, defaults = self._selected_baseline(runtime)
             all_items, _, _, _ = self._effective_items(runtime, user)
             effective = {item["ref"]: item for item in all_items}
             for host in ("claude", "codex"):
                 effective.update({item["ref"]: item for item in self._effective_items(runtime, user, host=host, include_suppressed=True)[0]})
             source = {item["ref"]: self._validate_item(item, allow_origin=True) for item in inventory["items"]}
+            overrides = self._enabled_overrides(user)
+            selection = self._effective_selection(user, defaults, None)
+            enabled = {item["ref"] for item in self._selected_items(
+                [item for item in effective.values() if item.get("active", True) is not False], selection, overrides)}
+            revision = self._authoring_revision(runtime, user)
             rows: list[dict[str, Any]] = []
             for ref in sorted(set(source) | set(user["items"]) | set(effective)):
                 base = source.get(ref)
@@ -919,6 +938,9 @@ class CorpusStore:
                 row["state"] = "removed" if removed else ("conflict" if item and (item.get("conflict") or item.get("content_conflict")) else "active")
                 row["digest"] = _digest(item or base or user["items"][ref])
                 row["baseline_ref"] = selected_ref if base else None
+                row["enabled"] = not removed and ref in enabled
+                row["enabled_override"] = overrides.get(ref)
+                row["revision"] = revision
                 rows.append(row)
             return rows
 
@@ -944,7 +966,11 @@ class CorpusStore:
                 return {"ref": ref, "history": self.history(ref)}
             removed = ref in user["tombstones"] or (effective is not None and effective.get("active", True) is False)
             state = "removed" if removed else ("conflict" if effective and (effective.get("conflict") or effective.get("content_conflict")) else "active")
-            return {"ref": ref, "item": effective, "digest": _digest(effective) if effective else None, "state": state}
+            overrides = self._enabled_overrides(user)
+            enabled = bool(effective and not removed and self._selected_items(
+                [effective], self._effective_selection(user, _defaults, None), overrides))
+            return {"ref": ref, "item": effective, "digest": _digest(effective) if effective else None, "state": state,
+                    "enabled": enabled, "enabled_override": overrides.get(ref)}
 
     # ---- plans --------------------------------------------------------------
 
@@ -971,7 +997,7 @@ class CorpusStore:
         if not isinstance(payload, dict):
             raise ValidationError("plan payload must be an object")
         op = payload.get("operation", payload.get("op"))
-        if op not in {"create", "update", "remove", "restore", "recover", "reset", "rollback", "select"}:
+        if op not in {"create", "update", "remove", "restore", "recover", "reset", "rollback", "select", "enable"}:
             raise ValidationError("unknown corpus operation")
         allowed = {
             "create": {"operation", "op", "item", "package_id", "expected_revision"},
@@ -982,6 +1008,7 @@ class CorpusStore:
             "reset": {"operation", "op", "expected_revision"},
             "rollback": {"operation", "op", "baseline_ref", "history_id", "expected_revision"},
             "select": {"operation", "op", "selection", "expected_revision"},
+            "enable": {"operation", "op", "items", "expected_revision"},
         }[op]
         unknown = set(payload) - allowed
         if unknown:
@@ -1114,6 +1141,31 @@ class CorpusStore:
             else:
                 next_user["items"][ref].pop("active", None)
             details["ref"] = ref
+        elif op == "enable":
+            choices = payload.get("items")
+            if not isinstance(choices, dict) or not choices:
+                raise ValidationError("enable needs a non-empty mapping of refs to booleans or null")
+            available = dict(effective)
+            for host in ("claude", "codex"):
+                available.update({item["ref"]: item for item in self._effective_items(runtime, user, host=host)[0]})
+            overrides = dict(self._enabled_overrides(user))
+            known = set(available) | set(overrides) | set(user["items"]) | {item["ref"] for item in inventory["items"]}
+            for ref, value in choices.items():
+                if not isinstance(ref, str) or ref not in known:
+                    raise ValidationError(f"unknown corpus enablement ref: {ref}")
+                if value is None:
+                    overrides.pop(ref, None)
+                elif not isinstance(value, bool):
+                    raise ValidationError("enable values must be booleans or null")
+                elif ref not in available or available[ref].get("active", True) is False:
+                    raise ValidationError("recover or restore a removed item before enabling it")
+                else:
+                    overrides[ref] = value
+            if overrides:
+                next_user["enabled_overrides"] = overrides
+            else:
+                next_user.pop("enabled_overrides", None)
+            details["items"] = _copy_json(choices)
         elif op == "select":
             selection = self._validate_selection(payload.get("selection"), inventory)
             next_user["selection"] = selection
@@ -1208,7 +1260,8 @@ class CorpusStore:
             history_id = f"{prepared['prepared_at'].replace(':', '').replace('+00:00', 'Z')}-{plan_id[:12]}"
             prepared["history_id"] = history_id
             self._write_transaction(plan_id, prepared)
-            _atomic_write(self.user_root / "history" / history_id / "state.json", {"runtime": runtime, "user": user, "revision": current})
+            _atomic_write(self.user_root / "history" / history_id / "state.json",
+                          {"runtime": runtime, "user": user, "revision": current, "details": details})
             if details.get("operation") == "reset":
                 _atomic_write(self.user_root / "trash" / history_id / "state.json", {"runtime": runtime, "user": user, "revision": current})
             _atomic_write(self._user_state_path, next_user)
@@ -1225,11 +1278,18 @@ class CorpusStore:
 
     # ---- immutable snapshots and history -----------------------------------
 
-    def _selected_items(self, items: list[dict[str, Any]], selection: list[str] | None) -> list[dict[str, Any]]:
-        if selection and "all" in selection:
-            return items
+    def _selected_items(self, items: list[dict[str, Any]], selection: list[str] | None,
+                        overrides: dict[str, bool] | None = None) -> list[dict[str, Any]]:
+        overrides = overrides or {}
         selected: list[dict[str, Any]] = []
         for item in items:
+            if item["ref"] in overrides:
+                if overrides[item["ref"]]:
+                    selected.append(item)
+                continue
+            if selection and "all" in selection:
+                selected.append(item)
+                continue
             if item.get("tier") in {"core", "infra"}:
                 selected.append(item)
                 continue
@@ -1268,7 +1328,7 @@ class CorpusStore:
             active = [item for item in items if item.get("active", True) is not False]
             effective_selection = self._effective_selection(user, defaults, selection)
             self._validate_snapshot_selection(effective_selection, inventory, active)
-            selected = self._selected_items(active, effective_selection)
+            selected = self._selected_items(active, effective_selection, self._enabled_overrides(user))
             self._require_resolved(selected)
             selected, promotion_warnings = self._resolve_promotions(selected, user, host, baseline_ref)
             bootstrap_path = self.repo / "compose" / "bootstrap" / "SKILL.md"
@@ -1372,7 +1432,11 @@ class CorpusStore:
                 continue
             if ref is not None:
                 user = record.get("user", {})
-                if ref not in user.get("items", {}) and ref not in user.get("overrides", {}) and ref not in user.get("tombstones", {}):
+                details = record.get("details", {})
+                changed = details.get("items", {}) if details.get("operation") == "enable" else {}
+                if (ref not in user.get("items", {}) and ref not in user.get("overrides", {})
+                        and ref not in user.get("tombstones", {}) and ref not in user.get("enabled_overrides", {})
+                        and ref not in changed):
                     continue
             rows.append({"history_id": path.parent.name, "revision": record.get("revision"), "path": str(path.parent)})
         return rows

package/compose/corpus_ui.py

@@ -11,11 +11,14 @@ import json
 import re
 from pathlib import PurePosixPath
 from typing import Any
-from urllib.parse import unquote
+from urllib.parse import quote, unquote
+
+from rich.text import Text
 
 from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.containers import Horizontal, Vertical
+from textual.events import Key
 from textual.screen import ModalScreen
 from textual.widgets import (
     Button,
@@ -41,6 +44,40 @@ SURFACES = ("always", "relevant", "requested", "event", "delegated")
 VIEWS = ("effective", "installed", "change", "diff", "history")
 
 
+def availability_label(state: str) -> str:
+    return "available" if state == "active" else state
+
+
+def guide_pointers(item: dict[str, Any], inventory: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Display literal guide references, not inferred dependencies or new routing."""
+    if item.get("kind") != "rule":
+        return []
+    paths = dict.fromkeys(re.findall(r"\bguides/[A-Za-z0-9][A-Za-z0-9_./-]*\.md\b", item.get("body", "")))
+    result = []
+    for path in paths:
+        if ".." in PurePosixPath(path).parts:
+            continue
+        matches = [candidate for candidate in inventory
+                   if candidate.get("package_id") == item.get("package_id")
+                   and candidate.get("kind") == "guide" and path in candidate.get("members", {})]
+        result.append({"path": path, "target": matches[0] if len(matches) == 1 else None,
+                       "problem": "Ambiguous guide reference" if matches else "Not found in this package"})
+    return result
+
+
+def library_label(item: dict[str, Any], inventory: list[dict[str, Any]]) -> Text:
+    pointers = guide_pointers(item, inventory)
+    label = Text()
+    mark = "-" if item.get("state") == "removed" else "x" if item.get("enabled", True) else " "
+    label.append(f"[{mark}]" + ("* " if item.get("enabled_pending") else " "))
+    if pointers:
+        label.append("→ GUIDE ", style="bold cyan")
+        label.append(", ".join(PurePosixPath(pointer["path"]).stem for pointer in pointers))
+        label.append(" · ")
+    label.append(f"{item.get('title', item.get('ref'))} · {item.get('surface', '?')}")
+    return label
+
+
 def render_member_body(body: str, member: str | None, kind: str | None = None) -> str:
     """Render prose as Markdown and preserve source files as literal code."""
     suffix = PurePosixPath(member).suffix.lower() if member else ""
@@ -82,7 +119,35 @@ class Confirmation(ModalScreen[bool]):
 class CorpusMarkdownViewer(MarkdownViewer):
     """Keep all links inside Studio; never hand a URL to the operating system."""
 
+    BINDINGS = [
+        Binding("left", "left_or_library", "Library", show=False),
+        Binding("up", "up_or_controls", "Controls", show=False),
+        Binding("down", "down_or_pending", "Pending choices", show=False),
+    ]
+
+    def action_left_or_library(self) -> None:
+        if self.scroll_x <= 0:
+            self.app.action_focus_library()
+        else:
+            self.action_scroll_left()
+
+    def action_up_or_controls(self) -> None:
+        if self.scroll_y <= 0:
+            if not self.app._focus_id("member-select"):
+                self.app._focus_controls()
+        else:
+            self.action_scroll_up()
+
+    def action_down_or_pending(self) -> None:
+        if self.scroll_y >= self.max_scroll_y:
+            self.app._focus_id("enablement-preview")
+        else:
+            self.action_scroll_down()
+
     async def _on_markdown_link_clicked(self, message: Markdown.LinkClicked) -> None:
+        # stop() prevents bubbling, not the inherited MarkdownViewer handler.
+        # Its default go() would try to load corpus:// as a filesystem path.
+        message.prevent_default()
         message.stop()
         if message.href.startswith("corpus://"):
             ref = unquote(message.href.removeprefix("corpus://"))
@@ -91,6 +156,57 @@ class CorpusMarkdownViewer(MarkdownViewer):
             self.app.notify("External links are disabled in Corpus Studio.", severity="warning")
 
 
+class CorpusSearch(Input):
+    """Leave search with arrows without taking editing keys away from text."""
+
+    BINDINGS = [
+        Binding("down", "focus_controls", "Controls", show=False),
+        Binding("right", "right_or_view", "View", show=False),
+    ]
+
+    def action_focus_controls(self) -> None:
+        self.app._focus_controls()
+
+    def action_right_or_view(self) -> None:
+        if self.selection.start == self.selection.end == len(self.value):
+            self.app._focus_id("view-select")
+        else:
+            self.action_cursor_right()
+
+
+class CorpusTree(Tree):
+    """Space is local to the library, never intercepted in text inputs."""
+
+    BINDINGS = [
+        Binding("space", "toggle_item", "On/off"),
+        Binding("up", "up_or_controls", "Controls", show=False),
+        Binding("down", "down_or_pending", "Pending choices", show=False),
+        Binding("right", "focus_document", "Document", show=False),
+    ]
+
+    def action_up_or_controls(self) -> None:
+        if self.cursor_line <= 0:
+            self.app._focus_controls()
+        else:
+            self.action_cursor_up()
+
+    def action_down_or_pending(self) -> None:
+        before = self.cursor_node
+        self.action_cursor_down()
+        if self.cursor_node is before:
+            self.app._focus_id("enablement-preview")
+
+    def action_focus_document(self) -> None:
+        self.app._focus_document()
+
+    async def action_toggle_item(self) -> None:
+        node = self.cursor_node
+        if node is not None and isinstance(node.data, str):
+            await self.app.toggle_enabled(node.data)
+        else:
+            self.action_toggle_node()
+
+
 class CorpusStudio(App[None]):
     """Searchable corpus library, editor, and revision-bound Preview → Apply flow."""
 
@@ -136,6 +252,9 @@ class CorpusStudio(App[None]):
     .actions { height: 3; align-horizontal: right; }
     .actions Button { margin-left: 1; }
     #status-line { height: 1; padding: 0 1; color: $text-muted; }
+    #enablement-bar { height: 3; display: none; }
+    #enablement-summary { width: 1fr; padding: 1; }
+    #enablement-bar Button { margin-right: 1; }
     """
 
     def __init__(self, store: Any) -> None:
@@ -150,13 +269,16 @@ class CorpusStudio(App[None]):
         self.view_item: dict[str, Any] | None = None
         self.member_drafts: dict[str, str] = {}
         self.pending_plan: dict[str, Any] | None = None
+        self.toggle_drafts: dict[str, bool] = {}
+        self.toggle_original: dict[str, bool] = {}
+        self.toggle_revision: str | None = None
         self.mode = "view"
 
     def compose(self) -> ComposeResult:
         yield Header()
         with Vertical(id="toolbar"):
             with Horizontal(id="search-row"):
-                yield Input(placeholder="Search title, content, ref, package, domain, or state", id="search")
+                yield CorpusSearch(placeholder="Search title, content, ref, package, domain, or state (↓ controls)", id="search")
                 yield Select([(view.title(), view) for view in VIEWS], value="effective",
                              allow_blank=False, id="view-select")
             with Horizontal(id="action-row"):
@@ -167,7 +289,7 @@ class CorpusStudio(App[None]):
                 yield Button("Recover", id="recover", compact=True)
                 yield Button("Reset", id="reset", variant="error", compact=True)
         with Horizontal(id="workspace"):
-            yield Tree("Corpus", id="library")
+            yield CorpusTree("Corpus", id="library")
             with Vertical(id="detail"):
                 yield Select([], prompt="Bundle document", allow_blank=True, id="member-select")
                 yield CorpusMarkdownViewer(
@@ -207,6 +329,10 @@ class CorpusStudio(App[None]):
                     with Horizontal(classes="actions"):
                         yield Button("Cancel plan", id="plan-cancel")
                         yield Button("Apply", id="apply", variant="success")
+        with Horizontal(id="enablement-bar"):
+            yield Static("", id="enablement-summary", markup=False)
+            yield Button("Preview on/off", id="enablement-preview", variant="primary")
+            yield Button("Discard on/off", id="enablement-discard")
         yield Static("Stored privately; no host session is activated by this screen.", id="status-line")
         yield Footer()
 
@@ -214,6 +340,63 @@ class CorpusStudio(App[None]):
         await self.refresh_library()
         self.query_one("#search", Input).focus()
 
+    @staticmethod
+    def _focusable(widget: Any) -> bool:
+        return widget.focusable and all(getattr(node, "display", True) for node in [widget, *widget.ancestors])
+
+    def _focus_id(self, *ids: str) -> bool:
+        # Query the current screen only: arrows must never escape a modal.
+        for ident in ids:
+            for widget in self.screen.query(f"#{ident}"):
+                if self._focusable(widget):
+                    widget.focus()
+                    return True
+        return False
+
+    def _focus_controls(self) -> None:
+        for button in self.screen.query("#action-row Button"):
+            if self._focusable(button):
+                button.focus()
+                return
+        self._focus_id("library" if getattr(self.focused, "id", None) == "search" else "search")
+
+    def _focus_document(self) -> None:
+        if self.mode != "view" or self._focus_id("member-select"):
+            return
+        for viewer in self.screen.query("#wiki"):
+            if self._focusable(viewer.document):
+                viewer.document.focus()
+
+    def on_key(self, event: Key) -> None:
+        focused = self.focused
+        moved = False
+        if isinstance(focused, Button) and focused.parent is not None:
+            siblings = [button for button in focused.parent.query(Button)
+                        if button.parent is focused.parent and self._focusable(button)]
+            if event.key in {"left", "right"} and focused in siblings:
+                index = siblings.index(focused) + (-1 if event.key == "left" else 1)
+                if 0 <= index < len(siblings):
+                    siblings[index].focus()
+                    moved = True
+            elif event.key in {"up", "down"} and len(self.screen_stack) == 1:
+                if focused.parent.id == "action-row":
+                    moved = self._focus_id("search" if event.key == "up" else "library")
+                elif focused.parent.id == "enablement-bar":
+                    moved = self._focus_id("library")
+                elif self.mode == "editor" and event.key == "up":
+                    moved = self._focus_id("editor-body")
+        elif isinstance(focused, Select) and not focused.expanded and self.mode == "view":
+            if event.key == "left" and focused.id in {"view-select", "member-select"}:
+                moved = self._focus_id("search" if focused.id == "view-select" else "library")
+            elif event.key == "right" and focused.id == "member-select":
+                for viewer in self.screen.query("#wiki"):
+                    if self._focusable(viewer.document):
+                        viewer.document.focus()
+                        moved = True
+        if moved:
+            event.prevent_default()
+            event.stop()
+
     def _set_mode(self, mode: str) -> None:
         self.mode = mode
         self.query_one("#member-select", Select).disabled = mode == "preview"
@@ -224,6 +407,83 @@ class CorpusStudio(App[None]):
         self.query_one("#wiki").display = mode == "view"
         self.query_one("#editor-panel").display = mode == "editor"
         self.query_one("#preview-panel").display = mode == "preview"
+        self._toggle_controls()
+        # Hiding a panel does not reliably release its focused child. Choose a
+        # visible, non-destructive entry point for the next screen state.
+        if mode == "preview":
+            self._focus_id("plan-cancel")
+        elif mode == "view":
+            self._focus_id("enablement-preview", "library")
+
+    def _display_items(self) -> list[dict[str, Any]]:
+        return [dict(row, enabled=self.toggle_drafts[row["ref"]], enabled_pending=True)
+                if row.get("ref") in self.toggle_drafts else row for row in self.items]
+
+    def _toggle_controls(self) -> None:
+        pending = bool(self.toggle_drafts)
+        self.query_one("#enablement-bar").display = pending and self.mode == "view"
+        self.query_one("#enablement-summary", Static).update(
+            f"{len(self.toggle_drafts)} unapplied on/off change(s) · * = pending")
+        if self.mode == "view":
+            for selector in ("#create", "#reset"):
+                self.query_one(selector).disabled = pending
+            if pending:
+                for selector in ("#edit", "#remove", "#restore", "#recover"):
+                    self.query_one(selector).disabled = True
+
+    async def _repaint_enablement(self) -> None:
+        displayed = self._display_items()
+        by_ref = {row["ref"]: row for row in displayed}
+        nodes = [self.query_one("#library", Tree).root]
+        while nodes:
+            node = nodes.pop()
+            if isinstance(node.data, str) and node.data in by_ref:
+                node.set_label(library_label(by_ref[node.data], displayed))
+            nodes.extend(node.children)
+        self._toggle_controls()
+        if self.current_ref:
+            await self.select_ref(self.current_ref)
+
+    async def toggle_enabled(self, ref: str) -> None:
+        if self.mode != "view":
+            return
+        row = self._row(ref)
+        if row is None or row.get("state") == "removed":
+            self.notify("Recover or restore this item before changing its use.", severity="warning")
+            return
+        if not self.toggle_drafts:
+            self.toggle_revision = row["revision"]
+        original = self.toggle_original.setdefault(ref, row["enabled"])
+        value = not self.toggle_drafts.get(ref, row["enabled"])
+        if value == original:
+            self.toggle_drafts.pop(ref, None)
+            self.toggle_original.pop(ref, None)
+        else:
+            self.toggle_drafts[ref] = value
+        if not self.toggle_drafts:
+            self.toggle_revision = None
+        await self._repaint_enablement()
+
+    def _clear_toggle_drafts(self) -> None:
+        self.toggle_drafts.clear()
+        self.toggle_original.clear()
+        self.toggle_revision = None
+
+    async def _discard_toggles(self) -> None:
+        self._clear_toggle_drafts()
+        self._toggle_controls()
+        await self.refresh_library(self.query_one("#search", Input).value)
+        if self.current_ref:
+            await self.select_ref(self.current_ref)
+        self._focus_id("library")
+
+    def _preview_toggles(self) -> None:
+        if not self.toggle_drafts or self.mode != "view":
+            return
+        summary = "Use in future sessions (no content is deleted):\n" + "\n".join(
+            f"{'ON' if enabled else 'OFF'}  {ref}" for ref, enabled in self.toggle_drafts.items())
+        self._stage_plan({"operation": "enable", "items": dict(self.toggle_drafts),
+                          "expected_revision": self.toggle_revision}, summary)
 
     async def refresh_library(self, query: str = "") -> None:
         if self.mode != "view":
@@ -239,20 +499,22 @@ class CorpusStudio(App[None]):
             self.query_one("#status-line", Static).update(str(exc))
             return
         visible = [item for item in self.items if self._matches(item, query)]
+        displayed = self._display_items()
+        display_by_ref = {item["ref"]: item for item in displayed}
         groups: dict[tuple[str, str], Any] = {}
         state_nodes: dict[str, Any] = {}
         for item in visible:
             state = str(item.get("state", "active"))
             package = str(item.get("package_id", "unknown"))
             if state not in state_nodes:
-                state_nodes[state] = tree.root.add(state.title())
+                state_nodes[state] = tree.root.add(availability_label(state).title())
                 state_nodes[state].expand()
             key = (state, package)
             if key not in groups:
                 groups[key] = state_nodes[state].add(package)
                 groups[key].expand()
             groups[key].add_leaf(
-                f"{item.get('title', item.get('ref'))} · {item.get('surface', '?')}",
+                library_label(display_by_ref[item["ref"]], displayed),
                 data=item.get("ref"),
             )
         tree.root.expand()
@@ -263,6 +525,7 @@ class CorpusStudio(App[None]):
         )
         if visible and (self.current_ref is None or not any(i.get("ref") == self.current_ref for i in visible)):
             await self.select_ref(str(visible[0]["ref"]))
+        self._toggle_controls()
 
     @staticmethod
     def _matches(item: dict[str, Any], query: str) -> bool:
@@ -309,6 +572,7 @@ class CorpusStudio(App[None]):
         self.query_one("#remove", Button).disabled = row.get("state") == "removed"
         self.query_one("#restore", Button).disabled = not bool(row.get("baseline_ref"))
         self.query_one("#recover", Button).disabled = not self._recoverable(row)
+        self._toggle_controls()
 
     def _select_members(self, item: dict[str, Any] | None, preferred: str | None = None) -> None:
         selector = self.query_one("#member-select", Select)
@@ -327,8 +591,7 @@ class CorpusStudio(App[None]):
             members[self.current_member] = self.query_one("#editor-body", TextArea).text
         return members
 
-    @staticmethod
-    def _render_item(row: dict[str, Any], result: dict[str, Any], view: str) -> str:
+    def _render_item(self, row: dict[str, Any], result: dict[str, Any], view: str) -> str:
         if view == "effective" and isinstance(result.get("item"), dict):
             item = result["item"]
             links = "\n".join(
@@ -344,11 +607,34 @@ class CorpusStudio(App[None]):
                     + (f" Available members: {members}." if members else "") + "\n"
                 )
             body = render_member_body(item.get("body", ""), item.get("primary_member"), item.get("kind"))
+            displayed = self._display_items()
+            display_row = next((entry for entry in displayed if entry.get("ref") == item.get("ref")), row)
+            pointers = guide_pointers(item, displayed)
+            guide_links = ""
+            if pointers:
+                lines = []
+                for pointer in pointers:
+                    target = pointer["target"]
+                    if target is None:
+                        lines.append(f"- `{pointer['path']}` — {pointer['problem']}")
+                    else:
+                        destination = quote(target["ref"], safe="@/:")
+                        use = "ON" if target.get("enabled", True) else "OFF — linked guide disabled"
+                        lines.append(f"- [{pointer['path']}](corpus://{destination}) — "
+                                     f"**{target['surface']}** · {availability_label(target.get('state', 'active'))} · {use}")
+                guide_links = (
+                    "## Guide pointer\n\nThis rule explicitly references the following guide(s). "
+                    "The rule keeps its own consumption surface; these links do not change "
+                    "delivery or prove that a guide was loaded.\n\n" + "\n".join(lines) + "\n\n## Rule\n\n"
+                )
             return (
                 f"# {item.get('title', item.get('ref'))}\n\n"
-                f"`{item.get('ref')}` · **{row.get('state', 'active')}** · "
+                f"`{item.get('ref')}` · **{availability_label(row.get('state', 'active'))}** · "
                 f"{item.get('surface')} · {item.get('kind')}\n\n"
-                f"{reconciliation}\n{body}\n\n## Dependencies\n\n{links}\n"
+                f"Use in future sessions: **{'ON' if display_row.get('enabled', True) else 'OFF'}**"
+                + (" (pending; not applied)" if display_row.get("enabled_pending") else " (saved selection)")
+                + ". Inclusion is not proof of loading or permission to execute.\n\n"
+                f"{guide_links}{reconciliation}\n{body}\n\n## Dependencies\n\n{links}\n"
                 + ("\n## Native consumption\n\nRequires explicit `agent-launch --corpus-native`.\n"
                    if item.get("kind") == "hook" else "")
             )
@@ -359,6 +645,26 @@ class CorpusStudio(App[None]):
         if isinstance(event.node.data, str):
             await self.select_ref(event.node.data)
 
+    async def on_tree_node_highlighted(self, event: Tree.NodeHighlighted) -> None:
+        tree = self.query_one("#library", Tree)
+        # Ignore queued highlights superseded by another cursor move or tree rebuild.
+        if self.mode != "view" or event.node is not tree.cursor_node:
+            return
+        if isinstance(event.node.data, str):
+            await self.select_ref(event.node.data)
+            return
+        # A group is not the previously displayed item: never leave its edit/delete
+        # actions live while the cursor points at a different kind of node.
+        self.current_ref = None
+        self.view_item = None
+        self._select_members(None)
+        for selector in ("#edit", "#remove", "#restore", "#recover"):
+            self.query_one(selector, Button).disabled = True
+        label = str(event.node.label.plain)
+        await self.query_one("#wiki", CorpusMarkdownViewer).document.update(
+            f"# Corpus group\n\n{label}\n\nMove the cursor to a corpus item to read it."
+        )
+
     async def on_markdown_link_clicked(self, message: Markdown.LinkClicked) -> None:
         # CorpusMarkdownViewer normally handles this before it bubbles.  Keeping
         # the app handler makes direct Markdown messages safe in tests and future layouts.
@@ -410,6 +716,9 @@ class CorpusStudio(App[None]):
     def _open_editor(self, item: dict[str, Any] | None) -> None:
         if self.mode != "view":
             return
+        if self.toggle_drafts:
+            self.notify("Apply or discard on/off changes first.", severity="warning")
+            return
         preferred = self.current_member if item and item.get("ref") == self.current_ref else None
         self.editor_item = item
         self.editor_ref = str(item["ref"]) if item else None
@@ -528,6 +837,8 @@ class CorpusStudio(App[None]):
     async def action_request_quit(self) -> None:
         if self.editor_dirty():
             self.push_screen(Confirmation("Discard the unsaved draft and exit Studio?"), self._discard_and_exit)
+        elif self.toggle_drafts:
+            self.push_screen(Confirmation("Discard unapplied on/off changes and exit Studio?"), self._discard_and_exit)
         else:
             self.exit()
 
@@ -588,6 +899,9 @@ class CorpusStudio(App[None]):
         }, diff + hook_summary
 
     def _stage_plan(self, payload: dict[str, Any], summary: str) -> None:
+        if self.toggle_drafts and payload.get("operation") != "enable":
+            self.notify("Apply or discard on/off changes first.", severity="warning")
+            return
         try:
             plan = self.store.plan(payload)
         except Exception as exc:
@@ -616,6 +930,8 @@ class CorpusStudio(App[None]):
             self.notify(str(exc), severity="error")
             return
         ref = result.get("details", {}).get("ref")
+        if result.get("details", {}).get("operation") == "enable":
+            self._clear_toggle_drafts()
         self.pending_plan = None
         self._set_mode("view")
         await self.refresh_library(self.query_one("#search", Input).value)
@@ -625,7 +941,11 @@ class CorpusStudio(App[None]):
 
     async def on_button_pressed(self, event: Button.Pressed) -> None:
         button = event.button.id
-        if button == "create":
+        if button == "enablement-preview":
+            self._preview_toggles()
+        elif button == "enablement-discard":
+            await self._discard_toggles()
+        elif button == "create":
             self.action_create()
         elif button == "edit":
             self.action_edit()

package/compose/corpus_understand.py

@@ -144,7 +144,12 @@ class CorpusUnderstand:
         return value
 
     def _bundles(self) -> list[dict]:
-        rows = [x for x in self.store.list_items(include_removed=False) if x.get("state") == "active"]
+        # Projection preferences and the inventory read revision are not learning
+        # content. Disabled items remain readable and learnable without repinning
+        # every bundle when an unrelated activation preference changes.
+        rows = [{key: value for key, value in x.items()
+                 if key not in {"enabled", "enabled_override", "revision"}}
+                for x in self.store.list_items(include_removed=False) if x.get("state") == "active"]
         bundles, assigned = [], set()
         for ident, title, purpose, numbers in CORE_BUNDLES:
             wanted = {f"rule-{n:03}" for n in numbers}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-bios",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "releaseDate": "2026-09-11",
   "description": "A thin, low-level instruction layer for LLM CLI agents: one set of principles and behavior whichever model you run. Stores a private, editable corpus for explicitly activated sessions.",
   "bin": {

package/provenance.json

@@ -1 +1 @@
-{"commit":"7b616f4ae5366b1395560b3a88556287ac36122d","committedAt":"2026-09-11T15:52:49+09:00","dirty":false}
+{"commit":"588260e5b60f52f0f58b47e8d2ef7ae567b382a6","committedAt":"2026-09-11T21:09:27+09:00","dirty":false}