@event4u/agent-config 3.3.0 → 4.1.0

package/scripts/_archive/_p43_bodies.py

@@ -1,10 +1,10 @@
 #!/usr/bin/env python3
-"""P4.3 — Write compressed rule bodies. Run after _p43_compress.py."""
+"""P4.3 — Write condensed rule bodies. Run after _p43_condense.py."""
 from __future__ import annotations
 import pathlib
 
 ROOT = pathlib.Path(__file__).resolve().parents[1]
-RULES = ROOT / ".agent-src.uncompressed" / "rules"
+RULES = ROOT / ".agent-src.uncondensed" / "rules"
 
 
 def write(name: str, content: str) -> None:
@@ -23,7 +23,7 @@ description: "Before coding, modifying, or debugging — analyze first, verify w
 alwaysApply: false
 source: package
 load_context:
-  - .agent-src.uncompressed/contexts/communication/rules-auto/think-before-action-mechanics.md
+  - .agent-src.uncondensed/contexts/communication/rules-auto/think-before-action-mechanics.md
 triggers:
   - intent: "before coding"
   - intent: "before debugging"
@@ -63,7 +63,7 @@ description: "Writing or reviewing code — check relevant guideline before writ
 alwaysApply: false
 source: package
 load_context:
-  - .agent-src.uncompressed/contexts/communication/rules-auto/guidelines-mechanics.md
+  - .agent-src.uncondensed/contexts/communication/rules-auto/guidelines-mechanics.md
 triggers:
   - intent: "writing code"
   - intent: "reviewing code"
@@ -94,7 +94,7 @@ description: "When running CLI tools, fetching logs, or producing replies — re
 alwaysApply: false
 source: package
 load_context:
-  - .agent-src.uncompressed/contexts/communication/rules-auto/token-efficiency-mechanics.md
+  - .agent-src.uncondensed/contexts/communication/rules-auto/token-efficiency-mechanics.md
 triggers:
   - intent: "verbose CLI output"
   - intent: "fetching logs"
@@ -132,9 +132,9 @@ description: "Deciding whether to ask the user or just act on a workflow step
 alwaysApply: false
 source: package
 load_context:
-  - .agent-src.uncompressed/contexts/execution/autonomy-detection.md
-  - .agent-src.uncompressed/contexts/execution/autonomy-mechanics.md
-  - .agent-src.uncompressed/contexts/execution/autonomy-examples.md
+  - .agent-src.uncondensed/contexts/execution/autonomy-detection.md
+  - .agent-src.uncondensed/contexts/execution/autonomy-mechanics.md
+  - .agent-src.uncondensed/contexts/execution/autonomy-examples.md
 triggers:
   - intent: "trivial workflow question"
   - intent: "autonomy mode"
@@ -176,7 +176,7 @@ description: "Asking the user a question, presenting options, or summarizing pro
 alwaysApply: false
 source: package
 load_context:
-  - .agent-src.uncompressed/contexts/communication/rules-auto/user-interaction-mechanics.md
+  - .agent-src.uncondensed/contexts/communication/rules-auto/user-interaction-mechanics.md
 triggers:
   - intent: "ask user a question"
   - intent: "numbered options"
@@ -232,4 +232,4 @@ lookup material.
 if __name__ == "__main__":
     for name, content in FILES.items():
         write(name, content)
-    print(f"✓ wrote {len(FILES)} compressed rule bodies")
+    print(f"✓ wrote {len(FILES)} condensed rule bodies")

package/scripts/_archive/{_p43_compress.py → _p43_condense.py}

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""P4.3 — Surgical compression of 22 compress-and-keep auto-rules.
+"""P4.3 — Surgical condensation of 22 condense-and-keep auto-rules.
 
 Writes new bodies for the largest rules (Iron Laws preserved verbatim,
 extended rationale relocated to contexts/communication/rules-auto/).
@@ -13,8 +13,8 @@ import re
 import sys
 
 ROOT = pathlib.Path(__file__).resolve().parents[1]
-RULES = ROOT / ".agent-src.uncompressed" / "rules"
-CTXDIR = ROOT / ".agent-src.uncompressed" / "contexts" / "communication" / "rules-auto"
+RULES = ROOT / ".agent-src.uncondensed" / "rules"
+CTXDIR = ROOT / ".agent-src.uncondensed" / "contexts" / "communication" / "rules-auto"
 
 # Triggers per rule (keyword / phrase / file_pattern / path_prefix / intent / command)
 TRIGGERS: dict[str, list[dict]] = {
@@ -31,7 +31,7 @@ TRIGGERS: dict[str, list[dict]] = {
     "missing-tool-handling":     [{"keyword": "command not found"}, {"keyword": "not installed"}, {"intent": "install tool"}],
     "no-attribution-footers":    [{"intent": "PR body"}, {"intent": "commit message"}, {"intent": "Jira comment"}, {"keyword": "co-authored"}],
     "no-roadmap-references":     [{"path_prefix": "agents/roadmaps/"}, {"intent": "link from stable artifact"}],
-    "preservation-guard":        [{"intent": "merge skill"}, {"intent": "compress rule"}, {"intent": "refactor artifact"}, {"keyword": "Iron Law"}],
+    "preservation-guard":        [{"intent": "merge skill"}, {"intent": "condense rule"}, {"intent": "refactor artifact"}, {"keyword": "Iron Law"}],
     "role-mode-adherence":       [{"keyword": "active_role"}, {"keyword": "role-mode"}, {"intent": "mode marker"}],
     "runtime-safety":            [{"keyword": "execution"}, {"keyword": "automated"}, {"keyword": "assisted"}, {"keyword": "handler"}],
     "security-sensitive-stop":   [{"keyword": "auth"}, {"keyword": "billing"}, {"keyword": "tenant"}, {"keyword": "secret"}, {"keyword": "webhook"}],
@@ -115,4 +115,4 @@ if __name__ == "__main__":
     # Imported by _p43_bodies.py — when run directly, only stamp triggers.
     for rid in TRIGGERS:
         patch_triggers_only(rid)
-    print("✓ triggers stamped on all 22 compress-and-keep rules")
+    print("✓ triggers stamped on all 22 condense-and-keep rules")

package/scripts/_archive/_p4_migrate.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import re, sys, pathlib
 
 ROOT = pathlib.Path(__file__).resolve().parents[1]
-RULES = ROOT / ".agent-src.uncompressed" / "rules"
+RULES = ROOT / ".agent-src.uncondensed" / "rules"
 GUIDELINES = ROOT / "docs" / "guidelines"
 
 # (rule_id, route, triggers, iron_law_one_liner)
@@ -35,7 +35,7 @@ SKILL_MIGRATIONS = [
      [("keyword", "docker"), ("keyword", "artisan"), ("keyword", "composer"), ("phrase", "inside the container")],
      "Run PHP / artisan / composer / phpstan / rector / ecs / phpunit inside the project container, never on the host."),
     ("docs-sync", "skill:agent-docs-writing",
-     [("path_prefix", ".agent-src.uncompressed/"), ("path_prefix", ".augment/"), ("keyword", "rename"), ("keyword", "delete")],
+     [("path_prefix", ".agent-src.uncondensed/"), ("path_prefix", ".augment/"), ("keyword", "rename"), ("keyword", "delete")],
      "On any add / rename / delete of skill / rule / command / guideline, update counts and cross-references in the same edit."),
     ("e2e-testing", "command:e2e-heal",
      [("keyword", "playwright"), ("keyword", "e2e"), ("phrase", "page object")],
@@ -77,8 +77,8 @@ GUIDELINE_MIGRATIONS = [
      [("phrase", "/implement-ticket"), ("phrase", "/work"), ("keyword", "telemetry")],
      "After a `/implement-ticket` or `/work` phase-step, emit one `telemetry:record` call with consulted + applied ids when telemetry is enabled."),
     ("augment-portability", "guideline:augment-portability-patterns",
-     [("path_prefix", ".augment/"), ("path_prefix", ".agent-src.uncompressed/"), ("keyword", "portable")],
-     "Files inside `.augment/` and `.agent-src.uncompressed/` MUST stay project-agnostic — no project names, domains, stacks."),
+     [("path_prefix", ".augment/"), ("path_prefix", ".agent-src.uncondensed/"), ("keyword", "portable")],
+     "Files inside `.augment/` and `.agent-src.uncondensed/` MUST stay project-agnostic — no project names, domains, stacks."),
     ("command-suggestion-policy", "contract:command-suggestion-flow",
      [("phrase", "free-form prompt"), ("phrase", "command suggestion")],
      "When a free-form prompt matches a command, surface matches as numbered options with as-is escape; never auto-execute."),
@@ -89,10 +89,10 @@ GUIDELINE_MIGRATIONS = [
      [("path_prefix", "agents/roadmaps/")],
      "Any touch to `agents/roadmaps/` regenerates the dashboard in the same response; archive the roadmap when 0 open items remain."),
     ("rule-type-governance", "guideline:agent-infra/rule-type-governance",
-     [("path_prefix", ".agent-src.uncompressed/rules/")],
+     [("path_prefix", ".agent-src.uncondensed/rules/")],
      "Choose `always` vs `auto` per the governance table; over-broad `always` rules degrade the kernel budget."),
     ("skill-quality", "guideline:agent-infra/skill-quality-checklist",
-     [("path_prefix", ".agent-src.uncompressed/skills/")],
+     [("path_prefix", ".agent-src.uncondensed/skills/")],
      "Every skill must be executable, validated, and self-contained — full checklist in the guideline."),
 ]
 
@@ -164,7 +164,7 @@ def write_guideline(rule_id: str, route: str, body: str, existing_fm: dict) -> p
     desc = existing_fm.get("description", "")
     header = (f"# {rule_id.replace('-', ' ').title()}\n\n"
               f"> {desc}\n\n"
-              f"_Origin: migrated from `.agent-src.uncompressed/rules/{rule_id}.md` "
+              f"_Origin: migrated from `.agent-src.uncondensed/rules/{rule_id}.md` "
               f"per P4.2 of `road-to-kernel-and-router.md`._\n\n")
     target.write_text(header + body.lstrip())
     return target

package/scripts/_archive/_phase2_shim_helper.py

@@ -50,7 +50,7 @@ PHASE2_SHIMS: list[tuple[str, str]] = [
 ]
 
 DEPRECATED_IN = "1.17.0"
-COMMANDS_DIR = Path(".agent-src.uncompressed/commands")
+COMMANDS_DIR = Path(".agent-src.uncondensed/commands")
 
 
 def patch_file(stem: str, target: str) -> str:

package/scripts/_archive/_pilot_council_question.py

@@ -6,11 +6,11 @@ OUT.parent.mkdir(parents=True, exist_ok=True)
 
 framing = """# Cross-check request — Phase 1 of "Road to Rule Kernel and Router"
 
-We are about to compress a 56-rule "always-active" set down to a small
+We are about to condense a 56-rule "always-active" set down to a small
 hard-capped kernel + a router-loaded auto bucket. Phase 1 is purely
 classification + projection — no source rules edited yet. Two contracts
 were produced. We want a neutral second opinion BEFORE Phase 2 ships
-compression to the actual rule files.
+condensation to the actual rule files.
 
 ## What we want from you
 
@@ -23,13 +23,13 @@ compression to the actual rule files.
    lists 4 criteria (Iron-Law floor / mode-independent / pre-action
    gate / cross-cutting). Are these the right gates? Is anything
    missing or redundant?
-3. **Compression-rate r = 0.742.** Three pilots gave r-values 0.677 /
+3. **Condensation-rate r = 0.742.** Three pilots gave r-values 0.677 /
    0.712 / 0.838. We locked the **mean**. Reasonable, or should we use
    median (0.712) / max (0.838) as a more conservative budget cushion?
    Note: pilot range straddles the typical 0.6-0.75 band; max came
    from the shortest rule (already-lean floor effect).
 4. **The 1.5k per-rule cap with ADR-override.** Two of the three pilots
-   land >1.5k post-compression and would need an `iron-law-override`
+   land >1.5k post-condensation and would need an `iron-law-override`
    ADR. Is the per-rule cap realistic, or should we raise the per-rule
    ceiling (e.g. 2.5k or 3.5k) and lower the bucket cap (e.g. from 25k
    to 20k)? What's the failure mode you'd be most worried about?
@@ -49,7 +49,7 @@ with OUT.open("a") as fh:
     fh.write(Path("docs/contracts/rule-classification.md").read_text())
     fh.write("\n\n---\n\n## Contract 2 — docs/contracts/kernel-membership.md\n\n")
     fh.write(Path("docs/contracts/kernel-membership.md").read_text())
-    fh.write("\n\n---\n\n## Pilot inputs (compressed bodies, for reference)\n")
+    fh.write("\n\n---\n\n## Pilot inputs (condensed bodies, for reference)\n")
     for rid in ("agent-authority", "direct-answers", "language-and-tone"):
         fh.write(f"\n### Pilot — {rid}\n\n")
         fh.write(Path(f"docs/contracts/pilot/{rid}.md").read_text())

package/scripts/_cli/explain_last/inputs.py

@@ -85,7 +85,7 @@ def build(project_root: Path) -> dict[str, Any] | None:
 def _pack_marker(project_root: Path) -> Path | None:
     for candidate in (
         project_root / ".agent-pack.yml",
-        project_root / ".agent-src.uncompressed" / ".agent-pack.yml",
+        project_root / ".agent-src.uncondensed" / ".agent-pack.yml",
     ):
         if candidate.exists():
             return candidate

package/scripts/_lib/agent_settings.py

@@ -50,6 +50,7 @@ Contract — pure, read-only, tolerant:
 """
 from __future__ import annotations
 
+import copy
 import logging
 import os
 from pathlib import Path
@@ -60,6 +61,7 @@ from . import user_global_paths
 logger = logging.getLogger(__name__)
 
 DEFAULT_PROJECT_FILE = ".agent-settings.yml"
+DEFAULT_TEAM_FILE = ".agent-project-settings.yml"
 USER_GLOBAL_FILENAME = "agent-settings.yml"
 
 #: Canonical write target under the new ``~/.event4u/agent-config/``
@@ -86,11 +88,25 @@ MERGEABLE_KEYS: tuple[str, ...] = (
     "cost_profile",
     "personal.bot_icon",
     "personal.autonomy",
-    "caveman.speak_scope",
+    "telegraph.speak_scope",
 )
 
 _DEFAULTS: dict[str, Any] = {}
 
+#: Defaults applied by :func:`get_modules_config` when a key is absent
+#: from both the team file and the developer cascade. The values mirror
+#: the ``modules:`` block shipped in
+#: ``templates/agents/agent-project-settings.example.yml``. Lists are
+#: returned as fresh copies — callers may mutate the result safely.
+MODULES_DEFAULTS: dict[str, Any] = {
+    "enabled": False,
+    "root_paths": [],
+    "namespace_template": "",
+    "agent_folder": "agents",
+    "skip_dirs": [".module-template", ".example"],
+    "detection_acknowledged": False,
+}
+
 
 #: Anchor identifier returned by :func:`find_project_root_with_anchor`.
 ANCHOR_AGENT_SETTINGS = "agent-settings"
@@ -470,6 +486,184 @@ def load_agent_settings(
     return merged
 
 
+def get_modules_config(
+    project_root: Path | str | None = None,
+    team_path: Path | str | None = None,
+    project_path: Path | str | None = None,
+    cwd: Path | None = None,
+) -> dict[str, Any]:
+    """Return the merged ``modules:`` configuration with defaults applied.
+
+    Three-tier precedence (deepest wins) per the layered-settings model
+    documented in ``docs/guidelines/agent-infra/layered-settings.md``:
+
+    1. :data:`MODULES_DEFAULTS` — package-shipped defaults.
+    2. Team file — ``<project_root>/.agent-project-settings.yml``
+       (committed, all developers see the same values).
+    3. Developer cascade — every ``.agent-settings.yml`` walked by
+       :func:`_resolve_cascade_paths` (git-ignored local overrides).
+
+    The team layer may pin keys via a top-level ``locked_keys`` list of
+    dotted paths (e.g. ``[modules.root_paths]``). Locked keys discard any
+    matching override from the developer cascade and emit a ``logging``
+    INFO record. Locks are advisory — the team file always wins anyway —
+    but the explicit list makes the intent reviewable and gives the loader
+    a hook for the warning.
+
+    ``project_root`` defaults to ``find_project_root(cwd or Path.cwd())``.
+    ``team_path`` overrides the resolved team-file location for tests.
+    ``project_path`` + ``cwd`` flow through to :func:`load_agent_settings`
+    unchanged.
+
+    Pure, read-only — no file is ever written. Missing files / malformed
+    YAML / absent ``modules:`` block all return the defaults.
+    """
+    cwd_resolved = cwd if cwd is not None else Path.cwd()
+
+    if team_path is not None:
+        team_file = Path(team_path)
+    else:
+        if project_root is not None:
+            root = Path(project_root)
+        else:
+            root = find_project_root(cwd_resolved) or cwd_resolved
+        team_file = root / DEFAULT_TEAM_FILE
+
+    team_raw = _read_yaml(team_file) or {}
+    team_modules = team_raw.get("modules") if isinstance(team_raw.get("modules"), dict) else {}
+    locked_keys_raw = team_raw.get("locked_keys")
+    locked_keys: tuple[str, ...] = tuple(
+        k for k in (locked_keys_raw or []) if isinstance(k, str)
+    )
+
+    dev_merged = load_agent_settings(
+        project_path=project_path,
+        cwd=cwd,
+    )
+    dev_modules = dev_merged.get("modules") if isinstance(dev_merged.get("modules"), dict) else {}
+
+    merged: dict[str, Any] = copy.deepcopy(MODULES_DEFAULTS)
+    if team_modules:
+        _deep_merge(merged, team_modules)
+
+    if dev_modules:
+        for key, value in dev_modules.items():
+            dotted = f"modules.{key}"
+            if dotted in locked_keys and key in (team_modules or {}):
+                logger.info(
+                    "agent_settings: ignoring developer override of locked key %s",
+                    dotted,
+                )
+                continue
+            if isinstance(value, dict) and isinstance(merged.get(key), dict):
+                _deep_merge(merged[key], value)
+            else:
+                merged[key] = value
+
+    return merged
+
+
+def enumerate_modules(
+    project_root: Path | str | None = None,
+    cwd: Path | None = None,
+    modules_config: dict[str, Any] | None = None,
+) -> list[dict[str, Any]]:
+    """Enumerate every module under ``modules.root_paths``.
+
+    Phase D Step 1 of road-to-configurable-modules. For each path in
+    ``modules.root_paths`` (resolved relative to ``project_root``), lists
+    immediate subdirectories that survive the ``modules.skip_dirs`` filter
+    and reports whether each module ships a per-module agent folder
+    (``modules.agent_folder``, default ``agents``).
+
+    Returns a list of dicts \u2014 one per discovered module \u2014 sorted by
+    ``(root_path, name)`` for deterministic output:
+
+    * ``name``               \u2014 directory name of the module
+    * ``root_path``          \u2014 repo-relative root containing the module
+    * ``module_path``        \u2014 repo-relative path to the module itself
+    * ``has_agent_folder``   \u2014 ``True`` iff a directory matching
+      ``modules.agent_folder`` lives directly under the module
+    * ``agent_folder_path``  \u2014 repo-relative path to that folder
+      (``None`` when ``has_agent_folder`` is ``False``)
+
+    Contract:
+
+    * ``modules.enabled`` is **not** consulted \u2014 callers decide whether
+      to skip the call. Disabled projects normally yield ``[]`` because
+      ``root_paths`` is empty by default.
+    * Missing roots are skipped silently (logged at INFO).
+    * Hidden directories (leading ``.``) and entries in
+      ``modules.skip_dirs`` are filtered out.
+    * Symlinks are followed only when they resolve inside the project
+      root \u2014 same boundary as ``find_project_root``.
+    * Pure, read-only \u2014 no file or directory is ever written.
+
+    ``modules_config`` lets tests inject a pre-built dict; when ``None``
+    the function calls :func:`get_modules_config` with the same
+    ``project_root`` / ``cwd`` so the precedence chain matches.
+    """
+    cwd_resolved = cwd if cwd is not None else Path.cwd()
+    if project_root is not None:
+        root = Path(project_root)
+    else:
+        root = find_project_root(cwd_resolved) or cwd_resolved
+    root = root.resolve()
+
+    if modules_config is None:
+        modules_config = get_modules_config(project_root=root, cwd=cwd)
+
+    root_paths_raw = modules_config.get("root_paths") or []
+    skip_dirs_raw = modules_config.get("skip_dirs") or MODULES_DEFAULTS["skip_dirs"]
+    agent_folder = str(modules_config.get("agent_folder") or MODULES_DEFAULTS["agent_folder"])
+
+    skip_dirs: set[str] = {str(s) for s in skip_dirs_raw if isinstance(s, str)}
+
+    discovered: list[dict[str, Any]] = []
+    for raw in root_paths_raw:
+        if not isinstance(raw, str) or not raw.strip():
+            continue
+        root_rel = raw.strip().strip("/")
+        root_abs = (root / root_rel).resolve()
+        try:
+            if not root_abs.is_dir() or not str(root_abs).startswith(str(root)):
+                logger.info("enumerate_modules: skipping missing/out-of-tree root %s", root_rel)
+                continue
+        except OSError:
+            logger.info("enumerate_modules: unreadable root %s", root_rel)
+            continue
+
+        try:
+            children = sorted(root_abs.iterdir(), key=lambda p: p.name)
+        except OSError:
+            logger.info("enumerate_modules: cannot list %s", root_rel)
+            continue
+
+        for child in children:
+            name = child.name
+            if name.startswith(".") or name in skip_dirs:
+                continue
+            if not child.is_dir():
+                continue
+            agent_dir = child / agent_folder
+            has_agent = agent_dir.is_dir()
+            try:
+                module_rel = child.resolve().relative_to(root)
+            except ValueError:
+                continue
+            entry: dict[str, Any] = {
+                "name": name,
+                "root_path": root_rel,
+                "module_path": str(module_rel),
+                "has_agent_folder": has_agent,
+                "agent_folder_path": str(module_rel / agent_folder) if has_agent else None,
+            }
+            discovered.append(entry)
+
+    discovered.sort(key=lambda m: (m["root_path"], m["name"]))
+    return discovered
+
+
 def iter_setting_overrides(
     project_path: Path | str | None = None,
     user_global_path: Path | str | None = None,

package/scripts/_lib/agent_src.py

@@ -1,17 +1,17 @@
 """Locate artefact source roots across the monorepo physical layout.
 
 Phase 4 of the monorepo migration (ADR-017) physically moves source
-artefacts out of the flat ``.agent-src.uncompressed/`` directory into
-``packages/core/.agent-src.uncompressed/`` and
-``packages/pack-*/.agent-src.uncompressed/`` trees. This helper hides
+artefacts out of the flat ``.agent-src.uncondensed/`` directory into
+``packages/core/.agent-src.uncondensed/`` and
+``packages/pack-*/.agent-src.uncondensed/`` trees. This helper hides
 that decision from every scanner so they keep working pre-move and
 post-move with the same call shape.
 
 Contract:
 
 - ``artefact_roots()`` returns every directory that contains source
-  ``.md`` artefacts. Pre-move that is ``.agent-src.uncompressed/`` at
-  the repo root. Post-move it is every ``packages/*/.agent-src.uncompressed/``.
+  ``.md`` artefacts. Pre-move that is ``.agent-src.uncondensed/`` at
+  the repo root. Post-move it is every ``packages/*/.agent-src.uncondensed/``.
   Both can coexist during the migration window.
 - ``iter_artefacts()`` yields every source ``.md`` path under those roots.
 - ``logical_relpath(p)`` returns the artefact's stable identity path
@@ -19,7 +19,7 @@ Contract:
   root contains it. This is what manifests, hash maps, and projections
   use as the artefact key.
 - ``strip_source_prefix(p)`` returns the same as ``logical_relpath``
-  but accepts repo-relative POSIX strings (used by the compressor's
+  but accepts repo-relative POSIX strings (used by the condenseor's
   output-path computation and the LEGACY_SRC_PREFIX logic).
 """
 from __future__ import annotations
@@ -28,22 +28,22 @@ from pathlib import Path
 from typing import Iterator
 
 ROOT = Path(__file__).resolve().parents[2]
-LEGACY_SRC = ROOT / ".agent-src.uncompressed"
+LEGACY_SRC = ROOT / ".agent-src.uncondensed"
 PACKAGES = ROOT / "packages"
 
 # Repo-relative POSIX path prefixes that anchor an artefact source tree.
 # Order: legacy first (kept until the move lands), then packages/*. Each
 # entry is the prefix that gets stripped to obtain the logical path.
-_LEGACY_PREFIX = ".agent-src.uncompressed/"
-_PACKAGE_SUFFIX = "/.agent-src.uncompressed/"
+_LEGACY_PREFIX = ".agent-src.uncondensed/"
+_PACKAGE_SUFFIX = "/.agent-src.uncondensed/"
 
 
 def artefact_roots() -> list[Path]:
     """Every existing directory that contains source ``.md`` artefacts.
 
-    Returns at most one ``.agent-src.uncompressed/`` root (legacy) plus
+    Returns at most one ``.agent-src.uncondensed/`` root (legacy) plus
     one root per ``packages/*/`` subdirectory that exposes its own
-    ``.agent-src.uncompressed/`` tree. Order is stable: legacy first,
+    ``.agent-src.uncondensed/`` tree. Order is stable: legacy first,
     then ``packages/`` entries sorted alphabetically.
     """
     roots: list[Path] = []
@@ -51,7 +51,7 @@ def artefact_roots() -> list[Path]:
         roots.append(LEGACY_SRC)
     if PACKAGES.exists():
         for pkg in sorted(PACKAGES.iterdir()):
-            sub = pkg / ".agent-src.uncompressed"
+            sub = pkg / ".agent-src.uncondensed"
             if sub.is_dir():
                 roots.append(sub)
     return roots
@@ -111,11 +111,11 @@ def logical_relpath(path: Path) -> str:
     """Return the artefact's logical identity path (POSIX, no prefix).
 
     Examples:
-        ``.agent-src.uncompressed/skills/laravel/SKILL.md``
+        ``.agent-src.uncondensed/skills/laravel/SKILL.md``
             → ``skills/laravel/SKILL.md``
-        ``packages/pack-laravel/.agent-src.uncompressed/skills/laravel/SKILL.md``
+        ``packages/pack-laravel/.agent-src.uncondensed/skills/laravel/SKILL.md``
             → ``skills/laravel/SKILL.md``
-        ``packages/core/.agent-src.uncompressed/rules/scope-control.md``
+        ``packages/core/.agent-src.uncondensed/rules/scope-control.md``
             → ``rules/scope-control.md``
 
     Raises ``ValueError`` if ``path`` is not under any known source root.
@@ -130,15 +130,15 @@ def logical_relpath(path: Path) -> str:
 
 
 def strip_source_prefix(rel: str) -> str | None:
-    """Strip the ``.agent-src.uncompressed/`` anchor from a repo-relative path.
+    """Strip the ``.agent-src.uncondensed/`` anchor from a repo-relative path.
 
     Accepts both the legacy flat layout and the monorepo packages layout.
     Returns ``None`` if the path is not under any source root.
 
     Examples:
-        ``".agent-src.uncompressed/rules/foo.md"`` → ``"rules/foo.md"``
-        ``"packages/core/.agent-src.uncompressed/rules/foo.md"`` → ``"rules/foo.md"``
-        ``"packages/pack-laravel/.agent-src.uncompressed/skills/x/SKILL.md"``
+        ``".agent-src.uncondensed/rules/foo.md"`` → ``"rules/foo.md"``
+        ``"packages/core/.agent-src.uncondensed/rules/foo.md"`` → ``"rules/foo.md"``
+        ``"packages/pack-laravel/.agent-src.uncondensed/skills/x/SKILL.md"``
             → ``"skills/x/SKILL.md"``
         ``"docs/architecture.md"`` → ``None``
     """