kanibako-cli 1.6.0.dev31__tar.gz → 1.6.0.dev36__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kanibako-cli
-Version: 1.6.0.dev31
+Version: 1.6.0.dev36
 Summary: Run AI coding agents in rootless containers with per-project isolation
 Requires-Python: >=3.11
 License-File: LICENSE.md
@@ -13,4 +13,5 @@ Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: bump2version; extra == "dev"
+Requires-Dist: pexpect>=4.8; extra == "dev"
 Dynamic: license-file

{kanibako_cli-1.6.0.dev31 → kanibako_cli-1.6.0.dev36}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kanibako-cli"
-version = "1.6.0.dev31"
+version = "1.6.0.dev36"
 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"]
@@ -16,7 +16,7 @@ kanibako = "kanibako.cli:main"
 no_agent = "kanibako.targets.no_agent:NoAgentTarget"
 
 [project.optional-dependencies]
-dev = ["pytest>=7.0", "pytest-cov", "mypy", "ruff", "bump2version"]
+dev = ["pytest>=7.0", "pytest-cov", "mypy", "ruff", "bump2version", "pexpect>=4.8"]
 
 [tool.setuptools.packages.find]
 where = ["src"]

{kanibako_cli-1.6.0.dev31 → kanibako_cli-1.6.0.dev36}/src/kanibako/__init__.py

@@ -1,6 +1,6 @@
 """kanibako: Run AI coding agents in rootless containers with per-project isolation."""
 
-__version__ = "1.6.0.dev31"
+__version__ = "1.6.0.dev36"
 
 # The oldest build version whose ``setup`` run is still considered current.  The
 # setup-completion gate (W1) re-nudges the user to re-run ``kanibako setup`` when

kanibako_cli-1.6.0.dev36/src/kanibako/agent_defaults.py

@@ -0,0 +1,183 @@
+"""Per-agent plugin defaults — thin reader of each plugin's shipped defaults file.
+
+Each agent plugin package (``kanibako.plugins.claude`` / ``…goose`` / ``…codex``)
+owns ONE declarative defaults file (``<agent>-defaults.yaml``) holding that
+agent's complete DEFAULT-SET — its :class:`~kanibako.targets.base.PluginDescriptor`
+data (bindings, launch grammar, settings, container env, cred files, …) plus its
+AGENT-scope ``default_shares`` — in the specced structured form.  This mirrors how
+the system/core defaults ship (:mod:`kanibako.core_defaults` /
+``kanibako/data/core-defaults.yaml``) and how containerfiles/templates ship via
+:mod:`importlib.resources`.
+
+This module is the THIN reader those plugins call from their ``descriptor`` /
+``default_shares`` properties.  It builds the descriptor from the file so the
+in-code descriptor is no longer hand-written per plugin.
+
+Split (documented in each YAML header too):
+
+* DECLARATIVE — everything in the file: the binding ORIGIN selectors (which
+  detected install field supplies the host source — a declarative string, NOT a
+  probed value), box-side destinations, the mode/operations grammar, settings
+  routing, container env, cred-file lifecycle, host_prep/init_dirs, and the
+  agent-share box_dests.  Box-side destinations under the guest home are written
+  as ``$GUEST_HOME`` EXPRESSIONS (e.g. ``$GUEST_HOME/.local/bin/claude``) that
+  this loader expands from the single :data:`~kanibako.settings_resolve.GUEST_HOME`
+  constant — no ``/home/agent`` literal in the file.
+* CODE-RESOLVED — the CRITICAL/runtime-probed HOST binary paths stay in the
+  plugin's ``detect()`` (the contract-path constants + npm/ELF resolution).  The
+  file only names, declaratively, WHICH detected field (``binary`` / ``launcher`` /
+  ``install_dir``) each binding's host source comes from (its ``origin``); the
+  actual probed path is filled in later by ``descriptor_mounts`` from the
+  :class:`~kanibako.targets.base.AgentInstall`.
+"""
+
+from __future__ import annotations
+
+import importlib.resources
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from kanibako.settings_resolve import GUEST_HOME
+from kanibako.targets.base import (
+    BindDefault,
+    BindKind,
+    Binding,
+    BindScope,
+    Cadence,
+    Channel,
+    CredFileSpec,
+    HostSrcOrigin,
+    Operation,
+    PluginDescriptor,
+    SafeBypass,
+    SettingArg,
+)
+
+
+def _expand(value: str) -> str:
+    """Expand a ``$GUEST_HOME`` prefix in a box-side path expression.
+
+    The defaults files write every in-box destination as a ``$GUEST_HOME``
+    expression so the guest-home literal lives in exactly one place (the
+    :data:`~kanibako.settings_resolve.GUEST_HOME` constant, single SoT).  Only the
+    leading ``$GUEST_HOME`` token is substituted; the rest is left verbatim.
+    """
+    if value.startswith("$GUEST_HOME"):
+        return GUEST_HOME + value[len("$GUEST_HOME"):]
+    return value
+
+
+def _load_doc(package: str, filename: str) -> dict[str, Any]:
+    """Read and parse a plugin's bundled defaults file."""
+    ref = importlib.resources.files(package).joinpath(filename)
+    raw = yaml.safe_load(Path(str(ref)).read_text()) or {}
+    if not isinstance(raw, dict):
+        return {}
+    return raw
+
+
+def _build_binding(entry: dict[str, Any]) -> Binding:
+    """Build one :class:`Binding` from a declarative file entry.
+
+    ``origin`` names the detected install field that supplies the host source
+    (``binary`` / ``launcher`` / ``install_dir`` / ``literal``); ``box_dest`` is a
+    ``$GUEST_HOME`` expression expanded here.  ``kind`` / ``scope`` map to their
+    enums; ``ro`` defaults to True.
+    """
+    literal = entry.get("literal_src")
+    return Binding(
+        key=entry["key"],
+        origin=HostSrcOrigin(entry["origin"]),
+        box_dest=_expand(entry["box_dest"]),
+        kind=BindKind(entry["kind"]),
+        scope=BindScope(entry["scope"]),
+        ro=bool(entry.get("ro", True)),
+        literal_src=Path(literal) if literal is not None else None,
+    )
+
+
+def _build_safe_bypass(raw: dict[str, Any] | None) -> SafeBypass | None:
+    """Build the :class:`SafeBypass` toggle from its declarative block (or None)."""
+    if not raw:
+        return None
+    return SafeBypass(
+        channel=Channel(raw["channel"]),
+        flag=tuple(raw.get("flag", ())),
+        env_var=raw.get("env_var", ""),
+        env_value=raw.get("env_value", ""),
+        secure_env_value=raw.get("secure_env_value", ""),
+        secure_flag=tuple(raw.get("secure_flag", ())),
+        setting_key=raw.get("setting_key", ""),
+    )
+
+
+def _build_setting_arg(entry: dict[str, Any]) -> SettingArg:
+    return SettingArg(
+        setting_key=entry["setting_key"],
+        channel=Channel(entry["channel"]),
+        flag=tuple(entry.get("flag", ())),
+        env_var=entry.get("env_var", ""),
+    )
+
+
+def _build_cred_file(entry: dict[str, Any]) -> CredFileSpec:
+    return CredFileSpec(
+        home_rel=entry["home_rel"],
+        host_rel=entry["host_rel"],
+        cadence=Cadence(entry.get("cadence", "sync")),
+        mtime_gate=bool(entry.get("mtime_gate", True)),
+        filtered=bool(entry.get("filtered", False)),
+        is_dir=bool(entry.get("is_dir", False)),
+    )
+
+
+def load_descriptor(package: str, filename: str) -> PluginDescriptor:
+    """Build a plugin's :class:`PluginDescriptor` from its shipped defaults file.
+
+    *package* is the plugin's import package (e.g. ``"kanibako.plugins.claude"``)
+    and *filename* its declarative defaults file (e.g. ``"claude-defaults.yaml"``).
+    The returned descriptor is byte-for-byte equivalent to the former hand-written
+    one — box_dest ``$GUEST_HOME`` expressions are expanded and every enum field
+    is mapped from its string name.
+    """
+    doc = _load_doc(package, filename)
+    desc = doc.get("descriptor", {})
+
+    return PluginDescriptor(
+        command=tuple(desc["command"]),
+        bindings=tuple(_build_binding(b) for b in desc.get("bindings", [])),
+        mode={k: tuple(v) for k, v in desc.get("mode", {}).items()},
+        operations={
+            k: Operation(tuple(v["fragment"]))
+            for k, v in desc.get("operations", {}).items()
+        },
+        safe_bypass=_build_safe_bypass(desc.get("safe_bypass")),
+        settings=tuple(_build_setting_arg(s) for s in desc.get("settings", [])),
+        container_env=dict(desc.get("container_env", {})),
+        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", ())),
+    )
+
+
+def load_shares(package: str, filename: str) -> dict[str, BindDefault]:
+    """Build a plugin's AGENT-scope ``default_shares`` map from its defaults file.
+
+    Each entry maps a scoped category key (``agent.shared.<name>``) to a STRUCTURED
+    bind pair ``(host_src, box_dest)`` (spec §2a — a tuple, NOT a colon-joined
+    string).  The relative ``host_src`` joins under the per-agent store root in the
+    category resolver; ``box_dest`` is a ``$GUEST_HOME`` expression expanded here.
+    Returns ``{}`` when the file declares no shares.
+    """
+    shares: dict[str, BindDefault] = {}
+    for entry in _load_doc(package, filename).get("shares", []):
+        options = entry.get("options")
+        if options is not None:
+            shares[entry["key"]] = (
+                entry["host_src"], _expand(entry["box_dest"]), options,
+            )
+        else:
+            shares[entry["key"]] = (entry["host_src"], _expand(entry["box_dest"]))
+    return shares

kanibako_cli-1.6.0.dev36/src/kanibako/agent_representation.py

@@ -0,0 +1,152 @@
+"""Agent descriptor → KeyStore representation (block 7a — PURE, ALONGSIDE).
+
+This module represents a plugin's per-agent DESCRIPTOR delivery binds as
+agent-level category-default entries in the resolved-keyspace
+:class:`~kanibako.settings_store.KeyStore`, so agent binary/launcher/share
+delivery flows through the ONE category keyspace (the single-route invariant),
+NOT a parallel descriptor mount route.
+
+It is item-0's hard half: each :class:`~kanibako.targets.base.Binding` in a
+:class:`~kanibako.targets.base.PluginDescriptor` becomes an
+``agent.<name>.bindings.{ro,rw}.<key> = Bind(host_src, box_dest, opts)`` leaf under
+the descriptor's OWN agent name ``<name>`` (``install.name``; S27) — the §2d
+``agent.<agent>.bindings.*`` key form, NOT a bare ``agent`` token (§0 L21) —
+mirroring :func:`~kanibako.targets.assembly.resolve_binding_source`'s
+origin→host_src resolution.
+
+PURE + ALONGSIDE (the block-7a boundaries)
+------------------------------------------
+* **Imported, single-source resolution.** host_src is resolved by IMPORTING
+  :func:`~kanibako.targets.assembly.resolve_binding_source` — the origin→path
+  logic is NOT re-implemented here.
+* **No override application (S26).** ``resolve_binding_source`` is called with
+  ``override=""`` so this emits the origin DEFAULT only. A user repoint now comes
+  from a HIGHER cascade level (``box`` / ``workset`` / ``agent.<active>``), merged
+  by block 2b — NOT baked into the agent default here.
+* **No existence check (S26).** This function NEVER touches the filesystem (no
+  ``Path.exists()``); the ``AGENT_CRITICAL`` must-exist safe-fail is a CONSUMER
+  concern (the block-7b mount/reconcile step), not representation. Feed it a
+  fixture install whose paths do not exist and it still represents them.
+* **No expansion (§6a / spec §0).** ``@``-refs / ``$XDG`` / ``~`` are left RAW —
+  expansion is block 3. ``box_dest`` is carried VERBATIM: the descriptor loader
+  (:func:`kanibako.agent_defaults._build_binding`) has ALREADY expanded the
+  ``$GUEST_HOME`` box constant at load, so the :class:`Binding` this function
+  receives is post-expansion; re-expanding would be wrong. A LITERAL-origin raw
+  ``@``/``$XDG``/``~`` ``box_dest`` therefore stays raw for free (§6a).
+* **Build ALONGSIDE.** Nothing here is wired into the launch path; block 7b swaps
+  ``descriptor_mounts`` onto this representation. ``assembly.py`` /
+  ``agent_defaults.py`` / ``start.py`` are UNTOUCHED.
+
+Representation rules (the heart of the block — brief §3)
+--------------------------------------------------------
+For each :class:`Binding` in ``descriptor.bindings`` (order preserved):
+
+* **host_src** = ``resolve_binding_source(binding, install, override="")`` (the
+  origin-resolved ``LAUNCHER`` / ``INSTALL_DIR`` / ``BINARY`` / ``LITERAL`` path),
+  stored as ``str(host_src)`` (``Bind.host`` is ``str``, S1).
+* **box_dest** = ``binding.box_dest`` VERBATIM (see above).
+* **opts** = ``"ro"`` if ``binding.ro`` else ``None``. ``None`` (NOT ``""``) means
+  "no per-entry mount-options override" — ``Bind.opts`` defaults to ``None`` (S1)
+  and reconcile falls back to the category default for an rw bind. This is the
+  ``Bind`` convention, distinct from ``descriptor_mounts``'s ``""`` (an argv-mount
+  detail, not the stored shape).
+* **key path** = the descriptor's OWN agent name ``<name>`` (``install.name``;
+  S27): ``agent.<name>.bindings.ro.<key>`` or ``agent.<name>.bindings.rw.<key>``
+  per ``binding.ro``. The agent NAME is IN the key path (the §2d
+  ``agent.<agent>.*`` form, NOT a bare ``agent`` token, §0 L21), so this partial
+  merges BY NAME with 2a's discriminated ``agent.<active-name>.*`` level and any
+  higher-scope ``agent.<name>.*`` override (S8 / block 2b).
+
+None-origin rule (S27, recorded here)
+-------------------------------------
+When ``resolve_binding_source`` returns ``None`` (an unresolvable origin — e.g.
+a ``LITERAL`` binding with no ``literal_src``, or a detection field the install
+left unset), the entry is **OMITTED**. This mirrors the AGENT best-effort skip in
+:func:`~kanibako.targets.assembly.descriptor_mounts` and keeps the tier-2 typed
+accessor honest: ``bindings`` exposes ``Mapping[str, Bind]`` (NOT ``Bind | None``)
+ONLY because build omits absent/None binds (design §5/§6e) — emitting a
+``None``-host bind would be a lie a consumer crashes on.
+
+Authority: spec ``settings-keyspace-1.6.0-target.md`` §2d L356–378
+(``agent.<agent>.bindings.{ro,rw}.<key>`` — the ONLY agent key form; §0 L21
+forbids a bare ``agent.<key>``) / §2a (binding REPRESENTATION);
+``~/vault/rw/keystore-design.md`` §2 (binds are ``Bind``) / §6a (raw refs). SEAMS
+S1/S2/S3/S7/S8/S9 + S26/S27.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from kanibako.settings_store import Bind, KeyStore
+from kanibako.targets.assembly import resolve_binding_source
+
+if TYPE_CHECKING:
+    from kanibako.targets.base import AgentInstall, PluginDescriptor
+
+
+def agent_default_partial(
+    descriptor: PluginDescriptor,
+    install: AgentInstall,
+) -> 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 —
+    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.
+
+    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
+    ``KeyStore`` rooted at ``agent.<name>`` (empty ``agent.<name>`` node when no
+    binding resolves) so it merges by NAME with the 2a agent levels (S8).
+    Descriptor order is preserved.
+
+    PURE: no filesystem access, no mutation of *descriptor* / *install*.
+    """
+    # Build the ro/rw sub-tables locally, then attach only the non-empty ones so
+    # the partial shape stays minimal (an empty `ro`/`rw`/`bindings` node would be
+    # an absent-vs-present-empty distinction the merge need not carry).
+    ro_binds = KeyStore()
+    rw_binds = KeyStore()
+
+    for binding in descriptor.bindings:
+        src = resolve_binding_source(binding, install, override="")
+        if src is None:
+            # None-origin → OMIT (S27); matches the AGENT best-effort skip and
+            # keeps tier-2 `Mapping[str, Bind]` honest (design §5/§6e).
+            continue
+        opts = "ro" if binding.ro else None
+        bind = Bind(str(src), binding.box_dest, opts)
+        # `binding.key` is the stable override key; place it under ro/rw by `ro`.
+        if binding.ro:
+            ro_binds[binding.key] = bind
+        else:
+            rw_binds[binding.key] = bind
+
+    bindings = KeyStore()
+    if dict.__len__(ro_binds):
+        bindings["ro"] = ro_binds
+    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
+    agent_sub = KeyStore()
+    if dict.__len__(bindings):
+        agent_sub["bindings"] = bindings
+
+    agent = KeyStore()
+    agent[name] = agent_sub
+
+    partial = KeyStore()
+    partial["agent"] = agent
+    return partial

{kanibako_cli-1.6.0.dev31 → kanibako_cli-1.6.0.dev36}/src/kanibako/cli.py

@@ -184,6 +184,44 @@ _SUBCOMMANDS = {
 }
 
 
+def _normalize_command(effective: list[str]) -> list[str]:
+    """Reorder argv so a leading global-style flag doesn't swallow a subcommand.
+
+    The dispatcher's fallback rule ``effective[0] not in _SUBCOMMANDS -> prepend
+    "start"`` treats a LEADING flag (e.g. ``--agent goose shell``) as a bare
+    ``start`` with that flag — turning ``--agent goose shell`` into ``start
+    shell`` with ``project="shell"``, which both launches the wrong thing and
+    fires the Gate-1 setup nudge.
+
+    To honour the blanket-flag design (``kanibako --agent X <subcommand>`` ==
+    ``kanibako <subcommand> --agent X``), when ``effective[0]`` is an option
+    (starts with ``-``) and a KNOWN subcommand appears later, move the FIRST such
+    subcommand token to the front, preserving the relative order of everything
+    else.  ``--agent goose shell`` -> ``["shell", "--agent", "goose"]``.
+
+    Heuristic (kept simple, matches the documented design where flags normally
+    follow the subcommand): scan for the first token that is a ``_SUBCOMMANDS``
+    member.  A flag VALUE that happens to equal a subcommand name (e.g.
+    ``--box shell start`` where a box is literally named "shell") would be
+    matched as the subcommand; this is an accepted edge case.
+
+    The genuinely-no-subcommand cases are left untouched here so the caller's
+    existing ``prepend "start"`` rule still handles them: ``kanibako myproject``
+    (bare positional) and ``kanibako -A`` / ``kanibako -N`` (leading flags, no
+    subcommand) both fall through unchanged.
+    """
+    if not effective or not effective[0].startswith("-"):
+        return effective
+    sub_idx = next(
+        (i for i, tok in enumerate(effective) if tok in _SUBCOMMANDS),
+        None,
+    )
+    if sub_idx is None:
+        return effective
+    sub = effective[sub_idx]
+    return [sub] + effective[:sub_idx] + effective[sub_idx + 1:]
+
+
 def _ensure_initialized() -> None:
     """Ensure kanibako is initialized (create config + data dirs on first run)."""
     from kanibako.config import (
@@ -256,8 +294,9 @@ def _ensure_initialized() -> None:
     # CURATED templates instead.  The content ships as static package data and
     # is COPIED here into the runtime template dirs (@system.base_template +
     # @system.agents/<agent>/template), create-if-absent so user edits survive
-    # an upgrade.  The layered seed-once apply (templates.apply_template_layers)
-    # then copies them into each new box home at creation.
+    # an upgrade.  The layered seed-once stage+seed
+    # (templates.stage_and_seed_templates) then copies them into each new box
+    # home at creation.
     from kanibako.paths import load_std_paths
     from kanibako.templates import install_packaged_templates
 
@@ -339,6 +378,12 @@ def main(argv: list[str] | None = None) -> None:
         print(f"kanibako {__version__}")
         sys.exit(0)
     else:
+        # Reorder a leading global-style flag ahead of a later subcommand so
+        # `kanibako --agent goose shell` dispatches as `shell` (not `start` with
+        # project="shell").  Must run BEFORE the prepend-"start" fallback and the
+        # `--` split below.
+        effective = _normalize_command(effective)
+
         # If the first arg isn't a known subcommand, default to "start".
         if not effective or effective[0] not in _SUBCOMMANDS:
             effective = ["start"] + effective

{kanibako_cli-1.6.0.dev31 → kanibako_cli-1.6.0.dev36}/src/kanibako/commands/agent_cmd.py

@@ -433,9 +433,25 @@ def run_reauth(args: argparse.Namespace) -> int:
             return 1
 
     if target.check_auth():
-        # Sync refreshed credentials to the project shell directory
+        # Sync refreshed credentials to the project shell directory.  Mirror the
+        # start.py gate exactly: descriptor-bearing targets route their cred
+        # refresh through the credsync engine (descriptor.cred_files); only legacy
+        # (desc is None) targets fall back to the per-plugin refresh hook.  An
+        # ungated target.refresh_credentials here would push a descriptor agent
+        # (e.g. goose) down its legacy path / bespoke copy.
         if proj.group_auth:
-            target.refresh_credentials(proj.shell_path)
+            from pathlib import Path
+
+            from kanibako.targets import credsync
+
+            desc = target.descriptor
+            if desc is not None:
+                credsync.refresh_cred_files(
+                    desc, target, host_home=Path.home(),
+                    project_home=proj.shell_path, group_auth=proj.group_auth,
+                )
+            else:
+                target.refresh_credentials(proj.shell_path)
         print(f"{target.display_name}: authenticated.", file=sys.stderr)
         return 0
 

{kanibako_cli-1.6.0.dev31 → kanibako_cli-1.6.0.dev36}/src/kanibako/commands/box/_parser.py

@@ -1226,7 +1226,7 @@ def run_config(args: argparse.Namespace) -> int:
             from kanibako.targets import resolve_target
             from kanibako.commands.start import (
                 _build_config_env,
-                _build_effective_state,
+                _effective_behavior_for_display,
             )
             merged = load_merged_config(
                 config_file, project_toml if project_toml.exists() else None,
@@ -1257,7 +1257,7 @@ def run_config(args: argparse.Namespace) -> int:
             else:
                 agent_cfg = None
             if target is not None and agent_cfg is not None:
-                agent_state = _build_effective_state(
+                agent_state = _effective_behavior_for_display(
                     target, agent_cfg, project_toml,
                     global_config_path=std.settings,
                     workset_config_path=workset_path,

{kanibako_cli-1.6.0.dev31 → kanibako_cli-1.6.0.dev36}/src/kanibako/commands/flags.py

@@ -249,6 +249,17 @@ def check_flag_relevance(args: argparse.Namespace) -> None:
     # the excluded commands entirely.  Only a real string value counts as "set"
     # (a non-str sentinel from a MagicMock test stub is ignored).
     if isinstance(agent, str) and key not in _AGENT_FLAG_EXCLUDE:
+        # `shell` (and `box shell`) is a shell — it never launches an agent, so
+        # `--agent` is meaningless rather than wrong.  Product decision: IGNORE
+        # it with a clear note (don't hard-error), then proceed to open a plain
+        # shell.  run_shell never reads args.agent, so the value is dropped here.
+        if key in ("shell", "box shell"):
+            print(
+                "Note: --agent is ignored for 'shell' "
+                "(a shell never launches an agent).",
+                file=sys.stderr,
+            )
+            return
         if key not in AGENT_FLAG_COMMANDS:
             raise FlagRelevanceError(
                 f"--agent is not valid for '{key}'. It applies to agent "

{kanibako_cli-1.6.0.dev31 → kanibako_cli-1.6.0.dev36}/src/kanibako/commands/helper_cmd.py

@@ -370,6 +370,7 @@ def run_stop(args: argparse.Namespace) -> int:
             send_request(_socket_path(), {
                 "action": "stop",
                 "container_name": container_name,
+                "helper_num": helper_num,
             })
         except Exception:
             pass  # Best-effort stop
@@ -399,6 +400,7 @@ def run_cleanup(args: argparse.Namespace) -> int:
             send_request(_socket_path(), {
                 "action": "stop",
                 "container_name": container_name,
+                "helper_num": helper_num,
             })
         except Exception:
             pass