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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kanibako-cli
-Version: 1.6.0.dev30
+Version: 1.6.0.dev31
 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.dev30 → kanibako_cli-1.6.0.dev31}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kanibako-cli"
-version = "1.6.0.dev30"
+version = "1.6.0.dev31"
 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.6.0.dev30 → kanibako_cli-1.6.0.dev31}/src/kanibako/__init__.py

@@ -1,6 +1,6 @@
 """kanibako: Run AI coding agents in rootless containers with per-project isolation."""
 
-__version__ = "1.6.0.dev30"
+__version__ = "1.6.0.dev31"
 
 # 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.dev31/src/kanibako/box_seed.py

@@ -0,0 +1,84 @@
+"""Uniform per-box seed-once query/record API.
+
+This is the single read/write surface the launch path (Step 3) will call to
+ask "has this box already been seeded?" and to record "this box is now
+seeded".  It hides where each box's seeded flag lives by dispatching on
+``proj.mode`` (a :class:`kanibako.paths.BoxMode`) to whichever registry owns
+the box:
+
+* ``BoxMode.primary``    → the ``seeded`` section's ``projects`` domain in
+  ``registry.yaml`` (keyed by ``proj.name``).
+* ``BoxMode.standalone`` → the ``seeded`` section's ``standalone`` domain in
+  ``registry.yaml`` (keyed by ``proj.name``).
+* ``BoxMode.named``      → ``WorksetProject.seeded`` inside the owning
+  workset's ``settings.yaml`` (located via ``proj.group.root``).
+
+It is the explicit, registry-resident successor to the brittle ``.seeded``
+sentinel file (now REMOVED): Step 3 wired launch-time detection over to here,
+ORing this registry flag with an existing-inbox backstop for legacy boxes.
+Layering: this module
+depends on ``paths`` (types only), ``registry_store``, and ``workset``; none of
+those import ``box_seed``, so there is no import cycle.
+"""
+
+from __future__ import annotations
+
+from kanibako import registry_store
+from kanibako.paths import BoxMode, ProjectPaths, StandardPaths
+
+
+def box_is_seeded(proj: ProjectPaths, std: StandardPaths) -> bool:
+    """Return whether *proj*'s box has completed its one-time seed.
+
+    Dispatches on ``proj.mode`` to the owning registry.  Returns False for a
+    box that has never been seeded (or, defensively, a ``named`` box whose
+    group/workset-project cannot be resolved).
+    """
+    if proj.mode is BoxMode.primary:
+        return registry_store.is_box_seeded(std.data_path, "projects", proj.name)
+    if proj.mode is BoxMode.standalone:
+        return registry_store.is_box_seeded(std.data_path, "standalone", proj.name)
+    # BoxMode.named: the flag lives on the WorksetProject.
+    if proj.group is None:
+        return False
+    from kanibako.errors import WorksetError
+    from kanibako.workset import load_workset
+
+    try:
+        ws = load_workset(proj.group.root)
+    except WorksetError:
+        # Defensive: a named box whose workset cannot be loaded (e.g. its
+        # settings.yaml is absent or not yet materialised) reads as unseeded.
+        return False
+    for p in ws.projects:
+        if p.name == proj.name:
+            return p.seeded
+    return False
+
+
+def mark_box_seeded(proj: ProjectPaths, std: StandardPaths) -> None:
+    """Record that *proj*'s box has completed its one-time seed.
+
+    Dispatches on ``proj.mode`` to the owning registry.  Idempotent; a no-op
+    (defensive) for a ``named`` box whose group/workset-project cannot be
+    resolved.
+    """
+    if proj.mode is BoxMode.primary:
+        registry_store.mark_box_seeded_entry(std.data_path, "projects", proj.name)
+        return
+    if proj.mode is BoxMode.standalone:
+        registry_store.mark_box_seeded_entry(std.data_path, "standalone", proj.name)
+        return
+    # BoxMode.named: persist on the WorksetProject via the workset's public API.
+    if proj.group is None:
+        return
+    from kanibako.errors import WorksetError
+    from kanibako.workset import load_workset, set_project_seeded
+
+    try:
+        ws = load_workset(proj.group.root)
+        set_project_seeded(ws, proj.name)
+    except WorksetError:
+        # Defensive: a named box whose workset cannot be loaded/updated is a
+        # no-op (mirrors the missing-group guard above).
+        return

{kanibako_cli-1.6.0.dev30 → kanibako_cli-1.6.0.dev31}/src/kanibako/commands/start.py

@@ -37,6 +37,31 @@ from kanibako.targets import assembly, credsync, resolve_target
 from kanibako.targets.assembly import BindingSourceError, descriptor_mounts
 from kanibako.utils import container_name_for, project_hash, short_hash
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from kanibako.paths import ProjectPaths, StandardPaths
+
+
+def _box_already_seeded(proj: ProjectPaths, std: StandardPaths) -> bool:
+    """True when *proj*'s box has already had its one-time home seed applied.
+
+    Two ORed signals decide this:
+
+    * the authoritative per-box ``seeded`` registry flag
+      (:func:`kanibako.box_seed.box_is_seeded`); and
+    * the backstop that the box's own mailbox (inbox) dir already exists
+      — that dir is created during launch AFTER the seed gate, so on a first
+      launch it is absent (→ seed) and on every later launch it is present
+      (→ skip).  The inbox backstop also covers LEGACY boxes created before
+      the registry flag existed.
+    """
+    from kanibako import box_seed, channels
+
+    if box_seed.box_is_seeded(proj, std):
+        return True
+    return channels.box_channel_addresses(proj, std).inbox.exists()
+
 
 def add_start_parser(subparsers: argparse._SubParsersAction) -> None:
     p = subparsers.add_parser(
@@ -902,13 +927,28 @@ def _run_container(
                 logger.info(action)
 
         # Seed-once gate (BUG-D): seed the box home exactly once, on its FIRST
-        # start — whether the box was created by this very `start` (proj.is_new)
-        # or earlier by `box create` (which makes the metadata dir, leaving
-        # is_new False at start time).  The `.seeded` sentinel under the metadata
-        # dir records completion so subsequent launches never re-seed (user edits
-        # to seeded files survive, D-B6).
-        from kanibako.templates import mark_seeded, needs_seed
-        seed_box = needs_seed(proj.metadata_path, is_new=proj.is_new)
+        # start — whether the box was created by this very `start` or earlier by
+        # `box create`.  Detection ORs two signals (see `_box_already_seeded`):
+        # the authoritative per-box `seeded` registry flag, plus a backstop that
+        # the box's mailbox (inbox) already exists.  The inbox dir is created
+        # later in launch (after this gate), so it is absent on a first start
+        # (→ seed) and present on every later start (→ skip), and it also covers
+        # LEGACY boxes that predate the registry flag.  This replaces the brittle
+        # `.seeded` sentinel file (removed); the non-destructive create-if-absent
+        # template/seed application (S1) is the failsafe so a mis-detection can
+        # never clobber user edits.
+        from kanibako.box_seed import box_is_seeded, mark_box_seeded
+        flag_seeded = box_is_seeded(proj, std)
+        already_seeded = _box_already_seeded(proj, std)
+        seed_box = not already_seeded
+        # ADOPT-ON-DETECT: a legacy box detected seeded only via its existing
+        # inbox (flag still False) gets the authoritative flag stamped once, so
+        # future detection uses the flag.  Cheap + idempotent; never fatal.
+        if not flag_seeded and already_seeded:
+            try:
+                mark_box_seeded(proj, std)
+            except Exception:  # pragma: no cover - adopt is best-effort
+                logger.debug("adopt-on-detect: could not stamp seeded flag", exc_info=True)
 
         # Template application + agent init for new projects.
         if seed_box:
@@ -948,10 +988,11 @@ def _run_container(
                 logger=logger, group_auth=proj.group_auth,
             )
 
-        # Record seed-once completion so subsequent launches skip the blocks
-        # above (idempotent; only the first start writes meaningful content).
+        # Record seed-once completion via the authoritative per-box registry
+        # flag so subsequent launches skip the blocks above (idempotent; only the
+        # first start writes meaningful content).
         if seed_box:
-            mark_seeded(proj.metadata_path)
+            mark_box_seeded(proj, std)
 
         # Synced copies (the `<scope>.synced.<name>` category) — applied on
         # EVERY launch (mtime-gated), unlike copy-once seeds.  Distinct from the
@@ -2010,6 +2051,7 @@ def _apply_init_seeds(
     import shutil
 
     from kanibako.settings_resolve import GUEST_HOME
+    from kanibako.templates import copy_resource_tree_if_absent
 
     default_seeds = target.default_seeds() if target is not None else {}
 
@@ -2050,8 +2092,11 @@ def _apply_init_seeds(
             continue
         if src.is_dir():
             dest.mkdir(parents=True, exist_ok=True)
-            shutil.copytree(str(src), str(dest), dirs_exist_ok=True)
-        else:
+            # Create-if-absent: a seed delivers content ONCE; existing home
+            # content is owned by the box and must never be overwritten by a
+            # re-seed (the playbook-clobber bug).
+            copy_resource_tree_if_absent(src, dest)
+        elif not dest.exists():
             dest.parent.mkdir(parents=True, exist_ok=True)
             shutil.copy2(str(src), str(dest))
 

{kanibako_cli-1.6.0.dev30 → kanibako_cli-1.6.0.dev31}/src/kanibako/registry_store.py

@@ -66,6 +66,7 @@ _SECTIONS: tuple[str, ...] = (
     "workset_roots",
     "connected",
     "standalone",
+    "seeded",
     "rigs",
     "image_shells",
 )
@@ -95,6 +96,9 @@ def load_registry(data_path: Path) -> dict[str, dict]:
     """
     path = registry_path(data_path)
     data = load_doc(path) if path.is_file() else {}
+    seeded_raw = data.get("seeded", {})
+    if not isinstance(seeded_raw, dict):
+        seeded_raw = {}
     return {
         "projects": {
             k: str(v) for k, v in dict(data.get("projects", {})).items()
@@ -107,6 +111,16 @@ def load_registry(data_path: Path) -> dict[str, dict]:
         },
         "connected": dict(data.get("connected", {})),
         "standalone": dict(data.get("standalone", {})),
+        "seeded": {
+            "projects": {
+                k: bool(v)
+                for k, v in dict(seeded_raw.get("projects", {})).items()
+            },
+            "standalone": {
+                k: bool(v)
+                for k, v in dict(seeded_raw.get("standalone", {})).items()
+            },
+        },
         "rigs": dict(data.get("rigs", {})),
         "image_shells": dict(data.get("image_shells", {})),
     }
@@ -122,7 +136,17 @@ def save_registry(data_path: Path, registry: dict[str, dict]) -> None:
     data: dict = {}
     for section in _SECTIONS:
         entries = registry.get(section, {}) or {}
-        if section in _NAME_SECTIONS:
+        if section == "seeded":
+            # Nested ``{domain: {name: bool}}`` shape (NOT a name->path map):
+            # persist each domain with its inner keys sorted for stable diffs.
+            data[section] = {
+                domain: {
+                    name: bool(entries.get(domain, {})[name])
+                    for name in sorted(entries.get(domain, {}))
+                }
+                for domain in ("projects", "standalone")
+            }
+        elif section in _NAME_SECTIONS:
             data[section] = {name: entries[name] for name in sorted(entries)}
         else:
             data[section] = dict(entries)
@@ -224,3 +248,38 @@ def standalone_name_for_root(data_path: Path, root: Path) -> str | None:
         if root_str == target:
             return name
     return None
+
+
+# ---------------------------------------------------------------------------
+# Seeded-flag helpers (``seeded`` section: {domain: {box_name: bool}})
+# ---------------------------------------------------------------------------
+#
+# These are the per-box seed-once read/write primitives for the PRIMARY
+# (``domain == "projects"``) and STANDALONE (``domain == "standalone"``)
+# registries, the explicit successor to the brittle ``.seeded`` sentinel file.
+# The named-workset seeded flag lives on ``WorksetProject.seeded`` instead.
+# The uniform launch-path API that dispatches across all three lives in
+# :mod:`kanibako.box_seed`.
+
+
+def is_box_seeded(data_path: Path, domain: str, box_name: str) -> bool:
+    """Return whether *box_name* in *domain* has completed its one-time seed.
+
+    *domain* is ``"projects"`` (PRIMARY) or ``"standalone"``.  False when the
+    section/domain/name is absent (a fresh or legacy registry).
+    """
+    return bool(
+        load_registry(data_path)["seeded"].get(domain, {}).get(box_name, False)
+    )
+
+
+def mark_box_seeded_entry(data_path: Path, domain: str, box_name: str) -> None:
+    """Record that *box_name* in *domain* has completed its one-time seed.
+
+    Idempotent; preserves every sibling section (whole-file rewrite via
+    ``save_registry``).  Reuses ``load_registry``/``save_registry`` — no extra
+    YAML I/O.
+    """
+    registry = load_registry(data_path)
+    registry["seeded"].setdefault(domain, {})[box_name] = True
+    save_registry(data_path, registry)

{kanibako_cli-1.6.0.dev30 → kanibako_cli-1.6.0.dev31}/src/kanibako/templates.py

@@ -62,44 +62,6 @@ def workset_template_dir(proj: ProjectPaths, std: StandardPaths) -> Path | None:
     return workset_root(proj, std) / "template"
 
 
-#: Sentinel filename (under the box metadata dir) recording that the seed-once
-#: home content (templates + credential seeds + init seeds) has been applied.
-#: Its presence — NOT ``proj.is_new`` — is what gates seed-once application, so a
-#: box made via the two-step ``box create`` then ``start`` flow (which creates
-#: the metadata dir at CREATE time, leaving ``is_new`` False at START) is still
-#: seeded exactly once on its first ``start`` (BUG-D).
-SEED_MARKER = ".seeded"
-
-
-def seed_marker_path(metadata_path: Path) -> Path:
-    """Return the seed-once sentinel path under *metadata_path*."""
-    return metadata_path / SEED_MARKER
-
-
-def needs_seed(metadata_path: Path, *, is_new: bool) -> bool:
-    """True when the box still needs its one-time home seeding.
-
-    A box needs seeding when it is freshly created (*is_new*) OR when it was
-    created earlier (e.g. via ``box create``) but never seeded — detected by the
-    absence of the :data:`SEED_MARKER` sentinel under *metadata_path*.  Once the
-    sentinel exists the box is never re-seeded, so user edits to seeded files
-    survive subsequent launches (D-B6).
-    """
-    if is_new:
-        return True
-    return not seed_marker_path(metadata_path).exists()
-
-
-def mark_seeded(metadata_path: Path) -> None:
-    """Record that the box's one-time home seeding has completed.
-
-    Writes the :data:`SEED_MARKER` sentinel under *metadata_path* so a later
-    launch's :func:`needs_seed` returns False.  Idempotent.
-    """
-    metadata_path.mkdir(parents=True, exist_ok=True)
-    seed_marker_path(metadata_path).touch()
-
-
 def apply_template_layers(
     home: Path,
     layers: list[Path | None],
@@ -109,10 +71,11 @@ def apply_template_layers(
     The 1.6.0 home-seed model layers ordered template sources into the box home
     at creation (base -> agent -> workset; later overlays earlier).  The copy is
     NON-DESTRUCTIVE toward files that ALREADY EXIST in *home* before this seed
-    pass begins: such a pre-existing file (a user-edited home file on a
-    marker-less migrated box) is NEVER clobbered.  This is the guard against
-    re-seed DATA LOSS — a box whose home is already populated but lacks the
-    ``.seeded`` marker would otherwise have its files overwritten.
+    pass begins: such a pre-existing file (a user-edited home file on a box that
+    detection mis-flags as un-seeded) is NEVER clobbered.  This is the guard
+    against re-seed DATA LOSS — a box whose home is already populated but which
+    detection (the per-box registry flag + inbox backstop) fails to recognise as
+    seeded would otherwise have its files overwritten.
 
     Within a SINGLE seed pass, cross-layer LAST-WINS is still honoured: a file
     written by an earlier layer during this pass IS overwritten by a later
@@ -122,12 +85,14 @@ def apply_template_layers(
     are skipped (a ``<None>`` / absent layer contributes nothing — e.g.
     STANDALONE boxes have no workset layer).
 
-    This is SEED-ONCE: callers invoke it only when the box still
-    :func:`needs_seed`.  It does NOT special-case or merge any file — every file
-    is a plain ordered copy (the CLAUDE.md merge special-case is gone, D-B5).
-    The caller is responsible for never re-running it once the box is marked
-    seeded so user edits made inside the box survive (D-B6); the non-destructive
-    copy here is an additional safety net for the marker-less re-seed case.
+    This is SEED-ONCE: callers invoke it only when the box still needs seeding
+    (the launch gate detects an already-seeded box via the per-box registry flag
+    OR the existing-inbox backstop).  It does NOT special-case or merge any file
+    — every file is a plain ordered copy (the CLAUDE.md merge special-case is
+    gone, D-B5).  The caller is responsible for never re-running it once the box
+    is recorded seeded so user edits made inside the box survive (D-B6); the
+    non-destructive copy here is an additional safety net against a re-seed
+    caused by mis-detection.
     """
     written: set[Path] = set()
     for layer in layers:
@@ -189,6 +154,11 @@ def _copy_resource_tree_if_absent(src: Path, dest: Path) -> None:
         shutil.copy2(str(entry), str(target))
 
 
+# Public alias so other modules (e.g. the seed-once apply in commands.start)
+# can reuse the create-if-absent tree copy without reaching for a private name.
+copy_resource_tree_if_absent = _copy_resource_tree_if_absent
+
+
 def _packaged_base_template() -> Path | None:
     """Locate the packaged base-template content (``kanibako.data/templates/base``)."""
     try:

{kanibako_cli-1.6.0.dev30 → kanibako_cli-1.6.0.dev31}/src/kanibako/workset.py

@@ -106,6 +106,7 @@ class WorksetProject:
 
     name: str
     source_path: Path   # original project path (for reference / cloning)
+    seeded: bool = False  # True once the box's one-time seed has completed
 
 
 @dataclass
@@ -174,7 +175,11 @@ def _write_workset_toml(ws: Workset) -> None:
         "created": ws.created,
         "group_auth": ws.group_auth,
         "projects": [
-            {"name": proj.name, "source_path": str(proj.source_path)}
+            {
+                "name": proj.name,
+                "source_path": str(proj.source_path),
+                "seeded": proj.seeded,
+            }
             for proj in ws.projects
         ],
     }
@@ -204,6 +209,7 @@ def _load_workset_toml(root: Path) -> Workset:
             WorksetProject(
                 name=entry["name"],
                 source_path=Path(entry["source_path"]),
+                seeded=bool(entry.get("seeded", False)),
             )
         )
     return Workset(name=name, root=root, created=created, projects=projects, group_auth=group_auth)
@@ -673,6 +679,23 @@ def _detach_project(ws: Workset, name: str) -> None:
     ws.projects[:] = [p for p in ws.projects if p.name != name]
 
 
+def set_project_seeded(ws: Workset, name: str) -> bool:
+    """Mark the project *name* in *ws* as seeded and persist the change.
+
+    Sets ``WorksetProject.seeded`` True for the matching project and rewrites
+    the workset identity (preserving cascade settings).  Idempotent; a no-op
+    that returns False when *name* is not a project in *ws*, True otherwise.
+    This is the public persist entry point used by :mod:`kanibako.box_seed` so
+    callers do not reach for the module-private ``_write_workset_toml``.
+    """
+    for proj in ws.projects:
+        if proj.name == name:
+            proj.seeded = True
+            _write_workset_toml(ws)
+            return True
+    return False
+
+
 def remove_project(
     ws: Workset, name: str, *, remove_files: bool = False,
     std: StandardPaths | None = None,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kanibako-cli
-Version: 1.6.0.dev30
+Version: 1.6.0.dev31
 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.dev30 → kanibako_cli-1.6.0.dev31}/src/kanibako_cli.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/kanibako/auth_browser.py
 src/kanibako/auth_parser.py
 src/kanibako/baseline.py
 src/kanibako/box_identity.py
+src/kanibako/box_seed.py
 src/kanibako/browser_sidecar.py
 src/kanibako/browser_state.py
 src/kanibako/bun_sea.py
@@ -110,6 +111,7 @@ tests/test_auth_browser.py
 tests/test_auth_parser.py
 tests/test_baseline.py
 tests/test_box_identity.py
+tests/test_box_seed.py
 tests/test_browser_sidecar.py
 tests/test_browser_state.py
 tests/test_bun_sea.py

kanibako_cli-1.6.0.dev31/tests/test_box_seed.py

@@ -0,0 +1,137 @@
+"""Tests for kanibako.box_seed -- the uniform per-box seed-once dispatcher."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from kanibako import box_seed, registry_store
+from kanibako.paths import BoxMode, ProjectGroup, ProjectPaths
+from kanibako.workset import add_project, create_workset, load_workset
+
+
+def _make_proj(mode: BoxMode, name: str, group: ProjectGroup | None) -> ProjectPaths:
+    """Build a minimal ProjectPaths carrying only the dispatch-relevant fields."""
+    dummy = Path("/nonexistent")
+    return ProjectPaths(
+        project_path=dummy,
+        project_hash="0" * 16,
+        metadata_path=dummy,
+        shell_path=dummy,
+        vault_ro_path=dummy,
+        vault_rw_path=dummy,
+        mode=mode,
+        name=name,
+        group=group,
+    )
+
+
+def _primary_group(std) -> ProjectGroup:
+    return ProjectGroup(
+        name="default",
+        root=std.data_path,
+        is_default=True,
+        local_shared_base=std.data_path,
+    )
+
+
+# ---------------------------------------------------------------------------
+# PRIMARY → registry seeded.projects
+# ---------------------------------------------------------------------------
+
+
+def test_primary_routes_to_projects_domain(std, tmp_home):
+    proj = _make_proj(BoxMode.primary, "myapp", _primary_group(std))
+
+    assert box_seed.box_is_seeded(proj, std) is False
+    box_seed.mark_box_seeded(proj, std)
+    assert box_seed.box_is_seeded(proj, std) is True
+
+    # Landed in projects domain ONLY.
+    assert registry_store.is_box_seeded(std.data_path, "projects", "myapp") is True
+    assert registry_store.is_box_seeded(std.data_path, "standalone", "myapp") is False
+
+
+# ---------------------------------------------------------------------------
+# STANDALONE → registry seeded.standalone
+# ---------------------------------------------------------------------------
+
+
+def test_standalone_routes_to_standalone_domain(std, tmp_home):
+    proj = _make_proj(BoxMode.standalone, "abc_box", None)
+
+    assert box_seed.box_is_seeded(proj, std) is False
+    box_seed.mark_box_seeded(proj, std)
+    assert box_seed.box_is_seeded(proj, std) is True
+
+    # Landed in standalone domain ONLY.
+    assert registry_store.is_box_seeded(std.data_path, "standalone", "abc_box") is True
+    assert registry_store.is_box_seeded(std.data_path, "projects", "abc_box") is False
+
+
+# ---------------------------------------------------------------------------
+# NAMED → WorksetProject.seeded
+# ---------------------------------------------------------------------------
+
+
+def test_named_routes_to_workset_project(std, tmp_home):
+    ws = create_workset("myset", tmp_home / "worksets" / "myset", std)
+    add_project(ws, "projname", tmp_home / "project")
+
+    group = ProjectGroup(
+        name=ws.name,
+        root=ws.root,
+        is_default=False,
+        local_shared_base=ws.root,
+    )
+    proj = _make_proj(BoxMode.named, "projname", group)
+
+    assert box_seed.box_is_seeded(proj, std) is False
+    box_seed.mark_box_seeded(proj, std)
+    assert box_seed.box_is_seeded(proj, std) is True
+
+    # Landed on the WorksetProject, NOT in either registry domain.
+    assert load_workset(ws.root).projects[0].seeded is True
+    assert registry_store.is_box_seeded(std.data_path, "projects", "projname") is False
+    assert (
+        registry_store.is_box_seeded(std.data_path, "standalone", "projname") is False
+    )
+
+
+def test_named_missing_group_is_defensive(std, tmp_home):
+    """A named box with no group reads unseeded and mark is a no-op."""
+    proj = _make_proj(BoxMode.named, "orphan", None)
+    assert box_seed.box_is_seeded(proj, std) is False
+    box_seed.mark_box_seeded(proj, std)  # must not raise
+    assert box_seed.box_is_seeded(proj, std) is False
+
+
+def test_named_unloadable_workset_is_defensive(std, tmp_home):
+    """A named box whose workset root has no settings.yaml reads unseeded.
+
+    The seed gate calls ``box_is_seeded``/``mark_box_seeded`` early in launch; a
+    named box whose workset cannot be loaded (e.g. a not-yet-materialised root)
+    must NOT raise — it reads as unseeded and the mark is a no-op.
+    """
+    bare_root = tmp_home / "no-such-workset"
+    bare_root.mkdir()
+    group = ProjectGroup(
+        name="ghostset", root=bare_root, is_default=False, local_shared_base=bare_root,
+    )
+    proj = _make_proj(BoxMode.named, "projname", group)
+
+    assert box_seed.box_is_seeded(proj, std) is False  # must not raise
+    box_seed.mark_box_seeded(proj, std)  # must not raise
+    assert box_seed.box_is_seeded(proj, std) is False
+
+
+def test_marking_one_mode_leaves_others_empty(std, tmp_home):
+    """Marking the primary box does not touch the standalone domain or worksets."""
+    ws = create_workset("myset", tmp_home / "worksets" / "myset", std)
+    add_project(ws, "shared", tmp_home / "project")
+
+    primary = _make_proj(BoxMode.primary, "shared", _primary_group(std))
+    box_seed.mark_box_seeded(primary, std)
+
+    # Standalone domain untouched; the same-named workset project unseeded.
+    assert registry_store.is_box_seeded(std.data_path, "standalone", "shared") is False
+    assert load_workset(ws.root).projects[0].seeded is False