kanibako-cli 1.6.0.dev36__tar.gz → 1.7.0rc0__tar.gz

{kanibako_cli-1.6.0.dev36/src/kanibako_cli.egg-info → kanibako_cli-1.7.0rc0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kanibako-cli
-Version: 1.6.0.dev36
+Version: 1.7.0rc0
 Summary: Run AI coding agents in rootless containers with per-project isolation
 Requires-Python: >=3.11
 License-File: LICENSE.md

{kanibako_cli-1.6.0.dev36 → kanibako_cli-1.7.0rc0}/README.md

@@ -39,12 +39,12 @@ by the `kanibako` meta-package); other agents can be added as plugins.
 - **Vault snapshots** -- per-box read-only and read-write shared
   directories with smart snapshot strategy detection (reflink, hardlink,
   or tar.xz depending on filesystem)
-- **Shell customization** -- per-box environment variables (`box config
+- **Shell customization** -- per-box environment variables (`box set
   env.*`), drop-in init scripts (`shell.d/`), and layered seed-once home
   templates
 - **Agent configuration** -- per-agent YAML config with default args, state
   knobs, env vars, and shared caches; per-box setting overrides via
-  `box config`
+  `box set`
 - **Shared caches** -- global download caches (pip, cargo, npm, etc.)
   shared across boxes; agent-level caches via the agent config
 - **Plugin system** -- agent-agnostic core (`kanibako-cli`); Claude/Codex/Goose
@@ -220,7 +220,7 @@ shortcuts for common operations:
 | `box list` / `box ls` | List projects (`--all`, `--orphan`, `-q`) |
 | `box info` / `box inspect` | Project details (mode, paths, lock, rig) |
 | `box rm` / `box delete` | Remove project (`--purge` deletes metadata, `--force` skips confirm) |
-| `box config` | View or modify project configuration |
+| `box set` / `box get` / `box show` / `box reset` | View or modify project configuration |
 | `box diagnose [project]` | Check project box health |
 
 **Relocation & conversion:**
@@ -265,7 +265,7 @@ shortcuts for common operations:
 | `workset list` / `workset ls` | List working sets (`-q`) |
 | `workset info` / `workset inspect` | Working set details |
 | `workset rm` / `workset delete` | Remove working set (`--purge`, `--force`) |
-| `workset config` | View or modify workset configuration (use `workset config default <key>=<value>` for default-workset defaults) |
+| `workset set` / `workset get` / `workset show` / `workset reset` | View or modify workset configuration (use `workset set default <key>=<value>` for default-workset defaults) |
 | `workset connect <workset> [source]` | Add project to working set (`--name`) |
 | `workset disconnect <workset> <project>` | Remove project from working set (`--force`) |
 
@@ -275,7 +275,7 @@ shortcuts for common operations:
 |------------|-------------|
 | `agent list` / `agent ls` | List configured agents (`-q`) |
 | `agent info` / `agent inspect` | Agent configuration details |
-| `agent config` | View or modify agent configuration |
+| `agent set` / `agent get` / `agent show` / `agent reset` | View or modify agent configuration |
 | `agent reauth [project]` | Refresh credentials |
 
 ### `box helper` / `box fork` Subcommands
@@ -300,7 +300,7 @@ The runtime helper and fork verbs (formerly under `crab`) now live under `box`:
 | Subcommand | Description |
 |------------|-------------|
 | `system info` / `system inspect` | System details (version, runtime, paths) |
-| `system config` | View or modify global configuration |
+| `system set` / `system get` / `system show` / `system reset` | View or modify global configuration |
 | `system upgrade` | Self-update (`--check` for dry run) |
 | `system diagnose` | Check system health (runtime, images, agents, storage) |
 
@@ -349,7 +349,7 @@ error, not a silent no-op).
 #### `--box`: operate on any box
 
 `--box` substitutes for being in the box's directory: `kanibako stop --box myproj`,
-`kanibako box config --box myproj model=opus`. The value is a **box name (resolved
+`kanibako box set --box myproj model=opus`. The value is a **box name (resolved
 first) or a path**. It is the *subject* the command acts on, and stays orthogonal to
 the `move`/`convert` *destination* group, so they coexist:
 
@@ -408,7 +408,7 @@ confirm. Non-TTY runs (CI / headless) skip the prompt gracefully.
 nudge to run `setup` if it has never been run, then proceed.
 
 Because `system.*` keys are **file-only** (see [Configuration](#configuration)),
-the default agent is *not* settable via `kanibako system config` -- use `setup` or
+the default agent is *not* settable via `kanibako system set` -- use `setup` or
 edit `global/settings.yaml` directly.
 
 ## Project Modes
@@ -431,11 +431,11 @@ and run `kanibako`, and the box joins the primary workset.
 
 The primary workset is addressable through the same `workset` commands as named
 worksets (workset name token `__PRIMARY__`), so primary-workset settings use the
-ordinary `workset config default` mechanism (see [Configuration](#configuration)):
+ordinary `workset set default` mechanism (see [Configuration](#configuration)):
 
 ```bash
-kanibako workset config default model=opus          # default for ALL primary-mode boxes
-kanibako workset config default group_auth=false    # distinct credentials by default
+kanibako workset set default model=opus          # default for ALL primary-mode boxes
+kanibako workset set default group_auth=false    # distinct credentials by default
 ```
 
 The names `__PRIMARY__` / `__STANDALONE__` (and legacy `default`) are reserved
@@ -629,9 +629,9 @@ container:
 
 ```bash
 # Persistent (stored in project config)
-kanibako box config env.EDITOR=vim           # project-level
-kanibako system config env.EDITOR=nano       # global (all projects)
-kanibako box config env.EDITOR               # show one value
+kanibako box set env.EDITOR=vim              # project-level
+kanibako system set env.EDITOR=nano          # global (all projects)
+kanibako box get env.EDITOR                  # show one value
 
 # Per-run (not persisted)
 kanibako start -e EDITOR=vim -e DEBUG=1
@@ -644,7 +644,7 @@ Project env vars override global ones.
 The shell prompt is controlled by the `KANIBAKO_PS1` environment variable:
 
 ```bash
-kanibako box config env.KANIBAKO_PS1="(myproject) \u:\w\$ "
+kanibako box set env.KANIBAKO_PS1="(myproject) \u:\w\$ "
 ```
 
 ### Init scripts
@@ -702,8 +702,8 @@ Manage agent settings via the CLI:
 
 ```bash
 kanibako agent list                    # list configured agents
-kanibako agent config model            # show effective model
-kanibako agent config model=sonnet     # set agent-level default
+kanibako agent get claude model        # show the agent's model
+kanibako agent set claude model=sonnet # set agent-level default
 ```
 
 ## Home Templates
@@ -822,7 +822,7 @@ guide.
 pip install kanibako-target-myagent
 
 # Use a specific target
-kanibako box config box.agent=myagent
+kanibako box set box.agent=myagent
 kanibako start
 
 # (`crab_name` is gone -- select the agent via box.agent)
@@ -846,29 +846,30 @@ CLI flag > settings_required > box > workset > agent.<agent> > system > settings
 **file-only** -- the CLI reads and shows them but refuses to set them (edit the
 file directly); `setup` and programmatic writers still write them.
 
-All settings levels share a unified interface:
+All settings levels share the same four verbs -- `set` / `get` / `show` /
+`reset`:
 
 ```bash
 # Box level
-kanibako box config                     # show box overrides
-kanibako box config --effective         # show resolved values (inherited + overrides)
-kanibako box config model               # get one key
-kanibako box config model=sonnet        # set one key
-kanibako box config --reset model       # remove override, back to default
+kanibako box show                       # show box overrides
+kanibako box show --effective           # show resolved values (inherited + overrides)
+kanibako box get model                  # get one key
+kanibako box set model=sonnet           # set one key
+kanibako box reset model                # remove override, back to default
 
 # Workset level (group defaults inherited by member boxes)
-kanibako workset config <workset> model=opus
-kanibako workset config default model=opus   # primary-workset default
+kanibako workset set <workset> model=opus
+kanibako workset set default model=opus      # primary-workset default
 
 # Agent level (defaults for all boxes using this agent)
-kanibako agent config model=opus
+kanibako agent set claude model=opus
 
 # System level (global settings defaults)
-kanibako system config model=opus
-kanibako system config --reset --all    # reset all global settings
+kanibako system set model=opus
+kanibako system reset --all             # reset all global settings
 ```
 
-`kanibako system config` sets **non-`system.`** settings only. `system.*`-prefixed
+`kanibako system set` sets **non-`system.`** settings only. `system.*`-prefixed
 keys (layout paths AND `system.default_agent`) are **file-only**: the CLI shows them
 but refuses to set/reset them, pointing you at the config file. Set the default agent
 with `kanibako setup`; edit structural paths in `~/.config/kanibako.yaml` directly.

{kanibako_cli-1.6.0.dev36 → kanibako_cli-1.7.0rc0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kanibako-cli"
-version = "1.6.0.dev36"
+version = "1.7.0rc0"
 description = "Run AI coding agents in rootless containers with per-project isolation"
 requires-python = ">=3.11"
 dependencies = ["argcomplete>=3.0", "PyYAML>=6.0", "packaging>=20.0"]

kanibako_cli-1.7.0rc0/src/kanibako/__init__.py

@@ -0,0 +1,25 @@
+"""kanibako: Run AI coding agents in rootless containers with per-project isolation."""
+
+__version__ = "1.7.0rc0"
+
+# Two-tier setup/config compatibility constants for the 5-band setup-completion
+# gate (design: ``plans/2026-06-23-setup-version-tiers-NEXT.md``).  Both are
+# compared against the recorded ``system.setup_completed`` marker by BASE version
+# (PEP 440 via ``packaging.version``), so a dev/rc build of the same base reads
+# as the released base, not "from the future".
+#
+# * ``SETUP_BCV`` — backward-compatible version: the OLDEST setup/config version
+#   this build can function with AT ALL.  Below it, the build can no longer
+#   auto-fill the gaps → the gate ERRORS (rc1) and the user must re-run setup.
+#   Bump only when a setup change can no longer be auto-filled.
+# * ``SETUP_FCV`` — forward-compatible version: the oldest version whose setup is
+#   COMPLETELY compatible (nothing new since).  At or above it (but below the
+#   running build) the gate SILENTLY bumps the marker forward.  Between BCV and
+#   FCV the gate NUDGES (non-blocking) to re-run setup.  Bump whenever setup adds
+#   a new feature/case.
+#
+# Invariant: ``SETUP_BCV <= SETUP_FCV <= __version__`` (base versions).  Most
+# releases change setup in no way → bump NEITHER → existing configs land
+# ``>= FCV`` → silent.
+SETUP_BCV = "1.6.0"
+SETUP_FCV = "1.7.0"

{kanibako_cli-1.6.0.dev36 → kanibako_cli-1.7.0rc0}/src/kanibako/agent_config.py

@@ -16,15 +16,19 @@ class AgentConfig:
     """Per-agent configuration loaded from an agent YAML file.
 
     Sections:
-      agent  — identity (name, run_args) plus agent-state knobs
-               (model, access, start_mode, autonomous, …)
-      env    — raw env vars injected into container
+      agent     — identity (name, run_args) plus agent-state knobs
+                  (model, access, start_mode, autonomous, …)
+      env       — raw env vars injected into container (VAR -> value)
+      env_file  — env-from-file pointers (VAR -> host PATH): at launch the
+                  file's contents become the env var's VALUE (secret stays in
+                  the host file, only the path is stored — spec §2d).
     """
 
     name: str = ""
     run_args: list[str] = field(default_factory=list)
     state: dict[str, str] = field(default_factory=dict)
     env: dict[str, str] = field(default_factory=dict)
+    env_file: dict[str, str] = field(default_factory=dict)
     tweakcc: dict = field(default_factory=dict)
 
 
@@ -34,10 +38,10 @@ def agents_dir(data_path: Path, paths_agents: str = "agents") -> Path:
 
 
 def agent_settings_path(agents_root: Path, agent_id: str) -> Path:
-    """Return ``@agent.<agent>.meta.settings`` for *agent_id*.
+    """Return ``@meta.agent.<agent>.settings`` for *agent_id*.
 
     The per-agent SETTINGS cascade file lives INSIDE the per-agent store dir
-    (``@agent.<agent>.meta.path`` = ``agents/<agent>/``) as ``settings.yaml``
+    (``@meta.agent.<agent>.path`` = ``agents/<agent>/``) as ``settings.yaml``
     — NOT the old sibling ``agents/<agent>.yaml`` file (D-2026-06-22).  This
     parallels the per-agent template dir ``agents/<agent>/template`` and the
     Part-3 ``agents/<agent>/{plugins,cache}`` stores.
@@ -76,6 +80,10 @@ def load_agent_config(path: Path) -> AgentConfig:
         k: str(v) for k, v in agent_sec.items() if k not in IDENTITY_KEYS
     }
     cfg.env = {k: str(v) for k, v in data.get("env", {}).items()}
+    # env_file: VAR -> host PATH pointer (the token file). Stored as a plain
+    # string path; the file's CONTENTS (the secret) are never persisted here —
+    # they are read into the container env only at launch (spec §2d).
+    cfg.env_file = {k: str(v) for k, v in data.get("env_file", {}).items()}
     cfg.tweakcc = dict(data.get("tweakcc", {}))
 
     return cfg
@@ -93,6 +101,7 @@ def write_agent_config(path: Path, cfg: AgentConfig) -> None:
     data: dict = {
         "agent": agent_sec,
         "env": dict(cfg.env),
+        "env_file": dict(cfg.env_file),
         "tweakcc": dict(cfg.tweakcc),
     }
     # The settings file lives inside the per-agent store dir

{kanibako_cli-1.6.0.dev36 → kanibako_cli-1.7.0rc0}/src/kanibako/agent_defaults.py

@@ -159,6 +159,7 @@ def load_descriptor(package: str, filename: str) -> PluginDescriptor:
         cred_files=tuple(_build_cred_file(c) for c in desc.get("cred_files", [])),
         host_prep=bool(desc.get("host_prep", False)),
         init_dirs=tuple(desc.get("init_dirs", ())),
+        auth_share_support=bool(desc.get("auth_share_support", False)),
     )
 
 

kanibako_cli-1.7.0rc0/src/kanibako/agent_ref.py

@@ -0,0 +1,168 @@
+"""Agent-ref parsing: the ``persona+harness`` selection grammar (rider MVP).
+
+An ``--agent`` value is a *ref* that names an agent as ``persona+harness`` —
+for example ``navigator+claude``.  This module is the single, dependency-light,
+pure parser for that grammar; every ref source (explicit ``--agent``, box /
+workset / system settings) is normalised through here on the way into the
+resolver so the rest of the code deals only in *node-names*.
+
+Terminology (design SOT ``plans/2026-06-24-agent-variant-DESIGN.md``):
+
+* **harness** — the agent runtime/plugin, right of the separator (``claude``).
+  Resolves the target/plugin (``resolve_target`` / ``discover_targets`` key).
+* **persona** — the identity, left of the separator (``navigator``).
+* **node-name** — the canonical fused form ``persona℘harness`` (``navigator℘claude``).
+  This is the on-disk ``agents/<node>/`` dir and the keyspace ``agent.<node>.*``
+  slot.  It is what ``resolve_agent`` returns and what ``KANIBAKO_AGENT`` stamps.
+
+Separators: the human-typable ``+`` (U+002B) and the canonical ``℘`` (U+2118,
+SCRIPT CAPITAL P — "persona").  Both are accepted on input; the node-name always
+canonicalises the separator to ``℘``.  Only the FIRST separator splits (a persona
+segment may not itself contain a separator; the harness segment is whatever
+follows, verbatim, and is likewise separator-checked).
+
+Backward compatibility (LOAD-BEARING): a bare ref with no separator (``claude``)
+parses to ``(raw, raw)`` — node == harness == the bare name — so every bare path
+is byte-for-byte identical to pre-rider behaviour.
+"""
+
+from __future__ import annotations
+
+from kanibako.errors import ConfigError
+
+#: The canonical persona/harness separator (U+2118 SCRIPT CAPITAL P).
+CANONICAL_SEP = "℘"  # ℘
+#: The human-typable separator (U+002B PLUS SIGN).
+PLUS_SEP = "+"
+#: Both accepted separators.
+SEPARATORS = (PLUS_SEP, CANONICAL_SEP)
+
+#: Characters permitted in a persona OR harness segment (fs- and key-safe).
+#: Alphanumeric plus ``-``, ``.``, ``_`` — NO separators, NO path/whitespace.
+_SAFE_EXTRA = frozenset("-._")
+
+
+def _is_segment_safe(segment: str) -> bool:
+    """A non-empty segment of only ``[A-Za-z0-9]`` plus ``-`` / ``.`` / ``_``."""
+    if not segment:
+        return False
+    return all(ch.isalnum() or ch in _SAFE_EXTRA for ch in segment)
+
+
+def _first_sep_index(raw: str) -> int:
+    """Index of the FIRST separator in *raw*, or ``-1`` if none."""
+    indices = [raw.find(sep) for sep in SEPARATORS]
+    present = [i for i in indices if i != -1]
+    return min(present) if present else -1
+
+
+def parse_agent_ref(raw: str) -> tuple[str, str]:
+    """Parse an agent ref into ``(node, harness)``.
+
+    * Bare (no separator): ``"claude"`` -> ``("claude", "claude")`` — node and
+      harness are the same, preserving backward compatibility.
+    * Composite: ``"navigator+claude"`` -> ``("navigator℘claude", "claude")`` —
+      the persona (left) and harness (right) are validated and re-joined with
+      the canonical ``℘`` separator to form the node-name.
+
+    Splits on the FIRST separator only; a second separator in EITHER segment is
+    rejected (a segment must be fs/key-safe: alnum plus ``-``/``.``/``_``).
+
+    :raises ConfigError: on empty input, an empty persona/harness segment, or a
+        segment containing an illegal character (incl. a stray separator).
+    """
+    if not isinstance(raw, str):
+        raise ConfigError(
+            f"agent ref must be a string, got {type(raw).__name__}: {raw!r}"
+        )
+    ref = raw.strip()
+    if not ref:
+        raise ConfigError("agent ref is empty")
+
+    idx = _first_sep_index(ref)
+    if idx == -1:
+        # Bare: node == harness == the whole (validated) name.
+        if not _is_segment_safe(ref):
+            raise ConfigError(
+                f"invalid agent name '{ref}': names may contain only letters, "
+                f"digits, '-', '.', '_'"
+            )
+        return ref, ref
+
+    persona = ref[:idx]
+    harness = ref[idx + 1 :]
+
+    if not _is_segment_safe(persona):
+        raise ConfigError(
+            f"invalid agent ref '{raw}': the persona segment '{persona}' must be "
+            f"non-empty and contain only letters, digits, '-', '.', '_' "
+            f"(no separator)"
+        )
+    if not _is_segment_safe(harness):
+        raise ConfigError(
+            f"invalid agent ref '{raw}': the harness segment '{harness}' must be "
+            f"non-empty and contain only letters, digits, '-', '.', '_' "
+            f"(no separator)"
+        )
+
+    node = f"{persona}{CANONICAL_SEP}{harness}"
+    return node, harness
+
+
+def harness_of(node: str) -> str:
+    """Return the harness (part right of ``℘``) of a *node*-name.
+
+    A bare node with no separator IS its own harness (``"claude" -> "claude"``).
+    Only the canonical ``℘`` is recognised here — callers pass node-names, which
+    are always canonicalised.  ``+`` is deliberately NOT split here so a literal
+    ``+`` in an already-canonical node (there should be none) is not mistaken for
+    a separator; use :func:`parse_agent_ref` / :func:`canonicalize_agent_ref` for
+    raw, possibly-``+`` input.
+    """
+    _, _, harness = node.rpartition(CANONICAL_SEP)
+    return harness if harness else node
+
+
+def with_harness(node: str, harness: str) -> str:
+    """Return *node* with its harness segment REPLACED by *harness*.
+
+    Preserves the persona (left of ``℘``) while swapping the harness — used when
+    the actually-RESOLVED target differs from the requested harness (e.g. the
+    ``NoAgentTarget`` fallback when a named agent's binary is absent), so the
+    on-disk ``agents/<node>/`` dir + keyspace slot follow the real target.
+
+    * bare node (``"claude"``, harness ``"claude"``) -> ``"claude"`` (unchanged);
+    * bare node, fallback harness (``"claude"``, ``"no_agent"``) -> ``"no_agent"``;
+    * rider node (``"navigator℘claude"``, ``"claude"``) -> ``"navigator℘claude"``;
+    * rider node, fallback (``"navigator℘claude"``, ``"no_agent"``) ->
+      ``"navigator℘no_agent"`` (persona kept, harness swapped).
+    """
+    persona, sep, _ = node.rpartition(CANONICAL_SEP)
+    if not sep:
+        # Bare node: it IS just a harness — replace wholesale.
+        return harness
+    return f"{persona}{CANONICAL_SEP}{harness}"
+
+
+def display_agent_ref(node: str) -> str:
+    """Return the USER-FACING form of a *node*-name (``℘`` -> ``+``).
+
+    Presentation-only inverse of :func:`canonicalize_agent_ref`: internal storage,
+    keyspace, on-disk paths, and ``KANIBAKO_AGENT`` all keep the canonical ``℘``
+    form; whenever an agent ref is rendered to the user (error text, ``crab``/``box``
+    listings, session labels, log lines) it is shown with the typable ``+``.
+
+    Bare names contain no ``℘`` -> returned unchanged (existing output byte-identical).
+    Does NOT validate: it is a pure display swap tolerant of any string.
+    """
+    return node.replace(CANONICAL_SEP, PLUS_SEP)
+
+
+def canonicalize_agent_ref(raw: str) -> str:
+    """Return the canonical *node*-name for a raw ref (``+`` -> ``℘``).
+
+    Idempotent: a node that is already canonical (or bare) returns unchanged.
+    Validates via :func:`parse_agent_ref`, so a malformed ref raises ``ConfigError``.
+    """
+    node, _ = parse_agent_ref(raw)
+    return node

{kanibako_cli-1.6.0.dev36 → kanibako_cli-1.7.0rc0}/src/kanibako/agent_representation.py

@@ -88,17 +88,29 @@ if TYPE_CHECKING:
 def agent_default_partial(
     descriptor: PluginDescriptor,
     install: AgentInstall,
+    node_name: str | None = None,
 ) -> KeyStore:
     """Represent a descriptor's delivery bindings as an agent-level KeyStore partial.
 
     Returns a :class:`~kanibako.settings_store.KeyStore` partial rooted at
-    ``agent.<name>`` where ``<name>`` is the descriptor's OWN agent (``install.name``;
-    S27 / §2d), holding each resolvable :class:`~kanibako.targets.base.Binding` as a
-    ``agent.<name>.bindings.{ro,rw}.<key> = Bind(host_src, box_dest, opts)`` leaf —
+    ``agent.<node>`` where ``<node>`` is the ACTIVE node-name (*node_name*), holding
+    each resolvable :class:`~kanibako.targets.base.Binding` as a
+    ``agent.<node>.bindings.{ro,rw}.<key> = Bind(host_src, box_dest, opts)`` leaf —
     mirroring :func:`~kanibako.targets.assembly.resolve_binding_source` with NO
     override and NO existence check (S26). See the module docstring for the full
     rules and the None-origin OMIT contract.
 
+    RIDER threading (Block E fix 2a): the read side (``_agent_pick_node``) walks
+    ``agent.default`` ∪ ``agent.<active_agent>``, where ``<active_agent>`` is the
+    resolved NODE-name (``navigator℘claude`` for a rider). The descriptor's
+    ``install.name`` is the HARNESS (``"claude"``, hardcoded in claude's ``detect()``),
+    so rooting the binds under ``install.name`` ORPHANS a rider's AGENT_CRITICAL
+    delivery binds at ``agent.claude.*`` (never read → the ``claude`` binary is never
+    mounted → the container exits immediately). So the partial roots under the ACTIVE
+    node-name (*node_name*). For a BARE agent node==harness=="claude", so the binds
+    still land at ``agent.claude.*`` — byte-identical. *node_name* falls back to
+    ``install.name`` only when a caller omits it (legacy / test convenience).
+
     The partial nests ``agent.<name>.bindings`` with ``ro`` / ``rw`` sub-tables; a
     sub-table is present only if at least one binding lands in it, ``bindings`` is
     present only if at least one binding resolved, and the result is ALWAYS a
@@ -134,12 +146,14 @@ def agent_default_partial(
     if dict.__len__(rw_binds):
         bindings["rw"] = rw_binds
 
-    # Root under the descriptor's OWN agent name (§2d ``agent.<agent>.*``): the
-    # claude descriptor's binds land at ``agent.claude.bindings.*``. The agent NAME
-    # is part of the KEY PATH (NOT a bare ``agent`` token, §0 L21) — so this partial
-    # merges BY NAME with 2a's discriminated ``agent.<active>.*`` level and any
-    # higher-scope ``agent.<name>.*`` override (block 2b).
-    name = install.name
+    # Root under the ACTIVE node-name (§2d ``agent.<agent>.*``): for a BARE agent the
+    # node-name IS the harness (``agent.claude.bindings.*``); for a RIDER it is the
+    # composite node (``agent.navigator℘claude.bindings.*``) the read side actually
+    # walks (fix 2a). The agent NAME is part of the KEY PATH (NOT a bare ``agent``
+    # token, §0 L21) — so this partial merges BY NAME with 2a's discriminated
+    # ``agent.<active>.*`` level and any higher-scope ``agent.<node>.*`` override
+    # (block 2b), including the node-keyed override bridge.
+    name = node_name if node_name is not None else install.name
     agent_sub = KeyStore()
     if dict.__len__(bindings):
         agent_sub["bindings"] = bindings

{kanibako_cli-1.6.0.dev36 → kanibako_cli-1.7.0rc0}/src/kanibako/channels.py

@@ -9,17 +9,17 @@ file-seeding live in sub-step 6b.
 
 Two channel scopes (TARGET §1, §2c, §2f):
 
-* **system scope** — five type roots under ``@system.channels`` (commons, chat,
+* **system scope** — five type roots under ``@system.channelroot`` (commons, chat,
   broadcast, mailboxes, share).  The instance-owned types (mailboxes, share) are
   *partitioned* by the workset-name token: ``mailboxes/<ws>`` and ``share/<ws>``
   where ``<ws>`` is ``__PRIMARY__`` | ``<named>`` | ``__STANDALONE__``.  These
   partition roots apply to EVERY mode (standalone included).
-* **workset scope** — three type roots under ``@workset.meta.root/channels``
+* **workset scope** — three type roots under ``@meta.workset.path/channels``
   (commons, chat, share).  These exist for the PRIMARY and NAMED modes ONLY;
-  standalone has no workset-local channels (its ``workset.channels`` is
+  standalone has no workset-local channels (its ``workset.channelroot`` is
   ``<None>`` per the TARGET).
 
-The per-instance partition ADDRESSES (``box.meta.{inbox,share_global,
+The per-instance partition ADDRESSES (``meta.box.{inbox,share_global,
 share_workset}``) are this box's own mailbox/share dirs *within* the partitioned
 roots — derived from the workset-name token + the box name.
 
@@ -27,7 +27,7 @@ roots — derived from the workset-name token + the box name.
 ``ProjectPaths`` (the legacy comms block used only ``proj.name``).  Per the
 design-review A8 resolution we derive them HERE from ``proj.mode`` + ``proj.
 group`` rather than widening the resolver's public shape: PRIMARY roots at
-``@system.primary_workset`` with token ``__PRIMARY__``; NAMED roots at
+``@config.primary_workset`` with token ``__PRIMARY__``; NAMED roots at
 ``proj.group.root`` with token ``proj.group.name``; STANDALONE roots at
 ``proj.metadata_path`` (the root; the workspace is a subdir) with token
 ``__STANDALONE__``.
@@ -68,9 +68,9 @@ class SystemPartition:
 class WorksetChannels:
     """The workset-local channel roots (PRIMARY/NAMED only).
 
-    ``@workset.channels = @workset.meta.root/channels`` with ``commons``,
+    ``@workset.channelroot = @meta.workset.path/channels`` with ``commons``,
     ``chat`` (+ the reserved ``broadcast.md`` / default ``general.md`` files
-    inside it), and ``share`` (per-box subdirs are ``box.meta.share_workset``).
+    inside it), and ``share`` (per-box subdirs are ``meta.box.share_workset``).
     """
 
     root: Path
@@ -83,7 +83,7 @@ class WorksetChannels:
 
 @dataclass(frozen=True)
 class BoxChannelAddresses:
-    """This box's own partition ADDRESSES (TARGET §2c ``box.meta.*``).
+    """This box's own partition ADDRESSES (TARGET §2c ``meta.box.*``).
 
     * ``inbox`` == ``@system.channels.mailboxes/<ws>/<box>`` — this box's own
       mailbox dir (also surfaced in-box at ``~/channels/inbox``).
@@ -126,7 +126,7 @@ def own_partition_dirs(
     The lower-level primitive behind :func:`box_channel_addresses` — it takes the
     workset-name token + box name directly (no ``ProjectPaths``), so the lifecycle
     relocation can compute BOTH the OLD and the NEW partition for a box being
-    moved/converted.  Mirrors :func:`system_partition` + the ``box.meta.{inbox,
+    moved/converted.  Mirrors :func:`system_partition` + the ``meta.box.{inbox,
     share_global}`` joins (TARGET §2c).
     """
     part = system_partition(std, ws_token)
@@ -162,9 +162,9 @@ def workset_name_token(proj: ProjectPaths) -> str:
 
 
 def workset_root(proj: ProjectPaths, std: StandardPaths) -> Path:
-    """Return ``@workset.meta.root`` for *proj*.
+    """Return ``@meta.workset.path`` for *proj*.
 
-    PRIMARY → ``@system.primary_workset``; NAMED → the named workset root
+    PRIMARY → ``@config.primary_workset``; NAMED → the named workset root
     (``proj.group.root``); STANDALONE → the project root itself
     (``proj.metadata_path``, which for standalone IS the root — the workspace is
     a ``workspace/`` subdir under it, so ``project_path`` is not the root).
@@ -214,7 +214,7 @@ def workset_channel_paths(
     """Derive the WORKSET-local channel roots for *proj* (PRIMARY/NAMED only).
 
     Returns ``None`` for standalone (no workset-local channels).  Rooted at
-    ``@workset.meta.root/channels`` (A3 — a derived helper, NOT new fields on
+    ``@meta.workset.path/channels`` (A3 — a derived helper, NOT new fields on
     ``ProjectPaths``).
     """
     if not has_workset_channels(proj):
@@ -234,7 +234,7 @@ def workset_channel_paths(
 def box_channel_addresses(
     proj: ProjectPaths, std: StandardPaths
 ) -> BoxChannelAddresses:
-    """Derive this box's own partition addresses (``box.meta.*``) for *proj*.
+    """Derive this box's own partition addresses (``meta.box.*``) for *proj*.
 
     ``inbox`` / ``share_global`` always resolve (system-scope, every mode);
     ``share_workset`` is ``None`` for standalone.  *proj.name* is the box name.