@event4u/agent-config 3.3.0 → 4.2.0

package/scripts/build_linear_digest.py

@@ -2,7 +2,7 @@
 """build_linear_digest.py — build the Linear AI rules digest.
 
 Concatenates a curated set of cloud-safe rules from
-`.agent-src.uncompressed/rules/` into three Markdown files under
+`.agent-src.uncondensed/rules/` into three Markdown files under
 `dist/linear/`:
 
   workspace.md  — universal coding posture (18 rules)
@@ -42,7 +42,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parent.parent
-# Compressed source is the shipped form — denser, sharper section
+# Condensed source is the shipped form — denser, sharper section
 # structure; better fit for a guidance field than the verbose authoring
 # layer. The inclusion list at docs/contracts/linear-ai-rules-inclusion.md
 # remains the human-readable spec.
@@ -165,7 +165,7 @@ def render_digest(layer: str, entries: list[RuleEntry]) -> tuple[str, dict]:
     parts.append(f"# event4u/agent-config — Linear AI {layer.title()} Digest\n")
     parts.append(
         "> Auto-generated by `scripts/build_linear_digest.py` from "
-        "`.agent-src/rules/` (compressed source) plus the inclusion list "
+        "`.agent-src/rules/` (condensed source) plus the inclusion list "
         "at `docs/contracts/linear-ai-rules-inclusion.md`. Do not edit "
         "this file by hand — re-run `task build-linear-digest` to "
         "regenerate.\n"

package/scripts/build_rule_trigger_matrix.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Build agents/settings/contexts/rule-trigger-matrix.md.
 
-Emits a single matrix mapping every rule in `.agent-src.uncompressed/rules/`
+Emits a single matrix mapping every rule in `.agent-src.uncondensed/rules/`
 to its trigger event, observability, enforcement surface, hook-cost
 estimate, and Tier classification. Sourced from the Phase 1 inventory of
 `road-to-rule-hardening.md` plus `road-to-context-layer-maturity.md`
@@ -18,9 +18,9 @@ from pathlib import Path
 import yaml
 
 REPO_ROOT = Path(__file__).resolve().parents[1]
-SRC_RULES = REPO_ROOT / ".agent-src.uncompressed" / "rules"
+SRC_RULES = REPO_ROOT / ".agent-src.uncondensed" / "rules"
 COMP_RULES = REPO_ROOT / ".agent-src" / "rules"
-SRC_PREFIX = ".agent-src.uncompressed/"
+SRC_PREFIX = ".agent-src.uncondensed/"
 COMP_PREFIX = ".agent-src/"
 OUT = REPO_ROOT / "agents" / "contexts" / "rule-trigger-matrix.md"
 
@@ -80,7 +80,7 @@ add("roadmap-progress-sync.md", "file-edit on agents/roadmaps/**", "hook",
 add("context-hygiene.md", "turn counter / tool-loop / topic shift", "hook",
     "state", "medium", "1",
     notes="Per-turn counter + tool-call repetition detector. Cross-platform persistence is the cost driver.")
-add("size-enforcement.md", "file save on .agent-src.uncompressed/{skills,rules,commands}/**",
+add("size-enforcement.md", "file save on .agent-src.uncondensed/{skills,rules,commands}/**",
     "mechanical-already", "tool-call", "NA-mechanical", "mechanical-already",
     notes="Enforced by skill_linter.py + check_always_budget.py")
 add("no-roadmap-references.md", "file save on stable artifacts", "mechanical-already",
@@ -127,7 +127,7 @@ add("cli-output-handling.md", "tool-call (verbose CLI)", "hook", "tool-call",
     "low", "2a", notes="Pre-tool-call marker on git/test/lint invocations")
 add("artifact-drafting-protocol.md", "skill/rule create or major rewrite",
     "hook", "output", "medium", "2a",
-    notes="Marker on file-create in .agent-src.uncompressed/{skills,rules,commands}/")
+    notes="Marker on file-create in .agent-src.uncondensed/{skills,rules,commands}/")
 add("missing-tool-handling.md", "tool failure (command not found)", "hook",
     "output", "low", "2a", notes="Post-tool-failure marker — strong fit")
 add("token-efficiency.md", "every reply / verbose-tool invocation", "hook",
@@ -144,7 +144,7 @@ add("downstream-changes.md", "post-edit (callsite check)", "hook",
 add("ui-audit-gate.md", "pre-edit on UI files (settings.state.ui_audit empty)",
     "settings", "tool-call", "medium", "2b",
     notes="Block edit until state.ui_audit populated")
-add("preservation-guard.md", "skill/rule merge or compress", "hook",
+add("preservation-guard.md", "skill/rule merge or condense", "hook",
     "tool-call", "medium", "2b",
     notes="Pre-merge structured check — diff-shape verifiable")
 add("minimal-safe-diff.md", "every diff", "hook", "tool-call",
@@ -258,7 +258,7 @@ def emit():
     lines.append("| Column | Meaning |")
     lines.append("|---|---|")
     lines.append("| `type` | Frontmatter `type` (`always` / `auto`) |")
-    lines.append("| `raw` | Compressed rule size in chars (`.agent-src/rules/<name>`) |")
+    lines.append("| `raw` | Condensed rule size in chars (`.agent-src/rules/<name>`) |")
     lines.append("| `ext` | Extended size under Model (b): raw + transitive `load_context` |")
     lines.append("| `trigger` | Observable event that should activate the rule |")
     lines.append("| `obs` | Where the trigger is observable: `hook` (platform hook), `settings` (`.agent-settings.yml` state), `agent-only` (in-head), `mechanical-already` (precedent — already enforced by a script) |")
@@ -295,7 +295,7 @@ def emit():
     lines.append("## `load_context:` chains (CL Phase 1 inventory)")
     lines.append("")
     lines.append("Rules that load at least one context, with `rule → context → depth → chars`.")
-    lines.append("Chars are measured on the compressed context file (Model (b) literal).")
+    lines.append("Chars are measured on the condensed context file (Model (b) literal).")
     lines.append("")
     lines.append("| Rule | Context | Depth | Chars |")
     lines.append("|---|---|---:|---:|")

package/scripts/chat_history.py

@@ -47,7 +47,7 @@ DEFAULT_SETTINGS_FILE = ".agent-settings.yml"
 SCHEMA_VERSION = 4
 DEFAULT_MAX_SESSIONS = 5
 VALID_FREQS = {"per_turn", "per_phase", "per_tool"}
-VALID_OVERFLOW = {"rotate", "compress"}
+VALID_OVERFLOW = {"rotate", "condense"}
 
 # Replay-mode signal — when set, every write to the on-disk transcript
 # is a no-op. Honoured per `docs/contracts/hook-architecture-v1.md`
@@ -905,7 +905,7 @@ def overflow_handle(max_kb: int, mode: str = "rotate", *,
     """Enforce max_kb. Returns {'action', 'kept', 'dropped'}.
 
     Rotate: drop oldest entries (keep header) until file ≤ max_kb.
-    Compress: mark oldest 50% as stale and leave a `needs_compress`
+    Condense: mark oldest 50% as stale and leave a `needs_condense`
               marker entry for the agent to rewrite on next turn.
     """
     if mode not in VALID_OVERFLOW:
@@ -934,12 +934,12 @@ def overflow_handle(max_kb: int, mode: str = "rotate", *,
         _atomic_write_text(p, header_line + "".join(kept))
         return {"action": "rotate", "kept": len(kept), "dropped": dropped}
     marker = {
-        "t": "needs_compress",
+        "t": "needs_condense",
         "ts": _now(),
-        "reason": f"file exceeded {max_kb} KB, compress-mode requested",
+        "reason": f"file exceeded {max_kb} KB, condense-mode requested",
     }
     append(marker, path=p)
-    return {"action": "compress_marked", "kept": len(entries), "dropped": 0}
+    return {"action": "condense_marked", "kept": len(entries), "dropped": 0}
 
 
 def hook_append(event: str, *,

package/scripts/check_always_budget.py

@@ -32,7 +32,7 @@ import yaml
 
 REPO_ROOT = Path(__file__).resolve().parents[1]
 RULES_DIR = REPO_ROOT / ".agent-src" / "rules"
-SRC_PREFIX = ".agent-src.uncompressed/"
+SRC_PREFIX = ".agent-src.uncondensed/"
 COMP_PREFIX = ".agent-src/"
 
 TOTAL_CAP = 49_000
@@ -49,7 +49,7 @@ CONCENTRATION_TOP3_PCT = 0.30
 
 # Transitional concentration allowlist — non-safety-floor rules whose
 # extended share exceeds CONCENTRATION_SINGLE_PCT after the kernel-trim
-# refactor (commit 4e771da `refactor(kernel): compress 8 kernel rules
+# refactor (commit 4e771da `refactor(kernel): condense 8 kernel rules
 # per P2.2 playbook + lock kernel`). Trimming safety-floor rules shrank
 # the denominator, mechanically lifting non-floor rules' percentage
 # share even though their absolute size did not grow. Each entry pins
@@ -70,7 +70,13 @@ KNOWN_CONCENTRATION_BREACHES: dict[str, int] = {
 # scope-control-allowlisted + non-destructive-allowlisted) clears the
 # 30 % cap; the entry below pins the measured ceiling. Future trim
 # work drops this back to None (default 30 %).
-KNOWN_TOP3_CONCENTRATION_CEILING: int | None = 10_900
+# Bumped 10_900 → 11_300 in v4.0.0: branch-drift commits (`d30d441e`,
+# `d824408c`) raised the non-safety-floor top-3 sum
+# (language-and-tone + no-cheap-questions + ask-when-uncertain) past
+# the prior lock. Same rationale as the kernel-budget breach bump in
+# `scripts/smoke/kernel.sh`: shrinkage belongs in a separate kernel-
+# rule-edit PR per `scope-control § Kernel-rule edits` slow-rollout.
+KNOWN_TOP3_CONCENTRATION_CEILING: int | None = 11_300
 
 # Q3=A locked safety-floor rules — out of scope for slimming and for the
 # concentration check. Their size is intentional (Iron Laws + obligation
@@ -175,7 +181,7 @@ def _load_context_paths(path: Path) -> list[str]:
     return out
 
 
-def _src_to_compressed(entry: str) -> Path:
+def _src_to_condensed(entry: str) -> Path:
     if entry.startswith(SRC_PREFIX):
         return REPO_ROOT / (COMP_PREFIX + entry[len(SRC_PREFIX):])
     return REPO_ROOT / entry
@@ -189,7 +195,7 @@ def _walk_contexts(rule: Path) -> tuple[set[Path], list[tuple[str, str]]]:
     while stack:
         node, depth, chain = stack.pop()
         for entry in _load_context_paths(node):
-            comp = _src_to_compressed(entry)
+            comp = _src_to_condensed(entry)
             new_chain = f"{chain} → {entry}"
             if depth + 1 > MAX_DEPTH:
                 violations.append((rule.name, new_chain))

package/scripts/check_augment_description_cap.py

@@ -2,7 +2,7 @@
 """Auto-rule description-length CI gate (Phase 1.3 of
 road-to-augment-limit-fit).
 
-For every `type: auto` rule under `.agent-src.uncompressed/rules/`,
+For every `type: auto` rule under `.agent-src.uncondensed/rules/`,
 fail CI when the frontmatter `description:` exceeds DESC_CAP chars.
 
 Why: Augment injects each auto-rule's description into the
@@ -10,7 +10,7 @@ workspace-guidelines registry stub. Empirical 2026-05-08 budget
 analysis showed this channel consuming 25 % of the 49,512-char
 ceiling. Capping descriptions guards future drift.
 
-Source of truth: `.agent-src.uncompressed/rules/`. The compressed
+Source of truth: `.agent-src.uncondensed/rules/`. The condensed
 projection is regenerated; the source dictates what ships.
 
 Exit codes: 0 = pass, 1 = at least one rule over cap.
@@ -23,7 +23,7 @@ import sys
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
-RULES_DIR = REPO_ROOT / ".agent-src.uncompressed" / "rules"
+RULES_DIR = REPO_ROOT / ".agent-src.uncondensed" / "rules"
 DESC_CAP = 150
 
 

package/scripts/check_cluster_patterns.py

@@ -2,7 +2,7 @@
 """Cluster-pattern compliance check.
 
 Compares each cluster dispatcher under
-`.agent-src.uncompressed/commands/<cluster>.md` against the Phase 1
+`.agent-src.uncondensed/commands/<cluster>.md` against the Phase 1
 reference patterns (`fix.md`, `optimize.md`, `feature.md`).
 
 Required structure:
@@ -49,7 +49,7 @@ def _resolve_command(cluster: str) -> Path:
     hit = resolve_logical(rel)
     if hit is not None:
         return hit
-    return ROOT / ".agent-src.uncompressed" / rel
+    return ROOT / ".agent-src.uncondensed" / rel
 
 REQUIRED_SECTIONS = ["## Sub-commands", "## Dispatch", "## Rules"]
 TABLE_HEADER_RE = re.compile(

package/scripts/check_command_count_messaging.py

@@ -6,11 +6,11 @@ Public surfaces (README.md, AGENTS.md, docs/getting-started.md) advertise
 the size of the command catalog. PR #34 collapses atomic commands into
 clusters via deprecation shims — the externally meaningful number is the
 **active** command count (non-shim files), not the raw file count. This
-gate sources canonical counts from `.agent-src.uncompressed/commands/`
+gate sources canonical counts from `.agent-src.uncondensed/commands/`
 frontmatter and fails when any documented number drifts from those.
 
 Canonical counts:
-    total   = number of *.md files under .agent-src.uncompressed/commands/
+    total   = number of *.md files under .agent-src.uncondensed/commands/
     shims   = files whose frontmatter declares `superseded_by:`
     active  = total - shims
 
@@ -56,7 +56,7 @@ def _command_files() -> list[Path]:
     """Every command ``*.md`` file across all source roots (legacy + packages/*).
 
     Multi-root aware per ADR-017: post-move the commands live under
-    ``packages/<pack>/.agent-src.uncompressed/commands/``, and the
+    ``packages/<pack>/.agent-src.uncondensed/commands/``, and the
     canonical count is the union across packs (deduped by logical path).
     """
     seen: dict[str, Path] = {}

package/scripts/{check_compression.py → check_condensation.py}

@@ -1,10 +1,10 @@
 #!/usr/bin/env python3
 """
-Compression quality checker for agent-config packages.
+Condensation quality checker for agent-config packages.
 
-Compares .agent-src.uncompressed/ source files with their .agent-src/ compressed versions.
-Checks that compression preserved structural integrity:
-- All headings from source present in compressed
+Compares .agent-src.uncondensed/ source files with their .agent-src/ condensed versions.
+Checks that condensation preserved structural integrity:
+- All headings from source present in condensed
 - All code blocks preserved exactly
 - YAML frontmatter identical
 - Word count reduction within healthy range (10-60%)
@@ -25,17 +25,17 @@ from pathlib import Path
 from typing import List, Literal
 
 # Import the rewriter so frontmatter comparison can normalise the source
-# side through the same path transformations the compressor applies. Without
+# side through the same path transformations the condenseor applies. Without
 # this, every `load_context:` logical name (e.g. `contexts/foo.md`) and every
 # `../../docs/...` body link looks like a frontmatter / body mismatch even
 # though the rewriter is doing exactly what road-to-path-fixes.md P2/P3
 # specified.
 sys.path.insert(0, str(Path(__file__).resolve().parent))
-from compress import _rewrite_paths  # noqa: E402
+from condense import _rewrite_paths  # noqa: E402
 
 Severity = Literal["error", "warning", "info"]
 
-SOURCE_DIR = Path(".agent-src.uncompressed")
+SOURCE_DIR = Path(".agent-src.uncondensed")
 TARGET_DIR = Path(".agent-src")
 
 
@@ -83,8 +83,8 @@ def count_iron_law_structure(body: str) -> dict:
     """Count structural units in an Iron Law body.
 
     Returns counts of paragraphs (blank-line-separated prose blocks),
-    list items (bullet + numbered), and fenced code blocks. Caveman
-    compression may shorten word count freely; what must NOT change is
+    list items (bullet + numbered), and fenced code blocks. Telegraph
+    condensation may shorten word count freely; what must NOT change is
     the count of these structural units. Each represents a passage of
     the law that the source decided to keep.
 
@@ -168,45 +168,45 @@ def extract_iron_law_sections(text: str) -> list[tuple[str, int, str]]:
     return sections
 
 
-def check_pair(rel_path: str, source: str, compressed: str) -> List[Issue]:
-    """Compare source and compressed versions of a file."""
+def check_pair(rel_path: str, source: str, condensed: str) -> List[Issue]:
+    """Compare source and condensed versions of a file."""
     issues: List[Issue] = []
 
     # Frontmatter check
     src_fm = extract_frontmatter(source)
-    cmp_fm = extract_frontmatter(compressed)
+    cmp_fm = extract_frontmatter(condensed)
     if src_fm and src_fm != cmp_fm:
         issues.append(Issue(rel_path, "frontmatter_mismatch", "error",
-                            "YAML frontmatter differs between source and compressed"))
+                            "YAML frontmatter differs between source and condensed"))
 
-    # Heading preservation — check H1 and H2 headings (H3+ may be merged during compression)
+    # Heading preservation — check H1 and H2 headings (H3+ may be merged during condensation)
     src_headings = extract_headings(source)
-    cmp_headings = extract_headings(compressed)
+    cmp_headings = extract_headings(condensed)
     for h in src_headings:
         # Only check H1 and H2 (## level) — H3+ subheadings may be merged
         if h.startswith("# ") or (h.startswith("## ") and not h.startswith("### ")):
             if h not in cmp_headings:
                 issues.append(Issue(rel_path, "missing_heading", "warning",
-                                    f"H1/H2 heading lost during compression: {h}"))
+                                    f"H1/H2 heading lost during condensation: {h}"))
     # Also flag if comment lines inside code blocks are being treated as headings
     # Filter out false positives from code blocks
 
     # Code block preservation
     src_blocks = extract_code_blocks(source)
-    cmp_blocks = extract_code_blocks(compressed)
+    cmp_blocks = extract_code_blocks(condensed)
     if len(src_blocks) > len(cmp_blocks):
         issues.append(Issue(rel_path, "lost_code_blocks", "error",
-                            f"Code blocks lost: source has {len(src_blocks)}, compressed has {len(cmp_blocks)}"))
+                            f"Code blocks lost: source has {len(src_blocks)}, condensed has {len(cmp_blocks)}"))
     for i, block in enumerate(src_blocks):
         if i < len(cmp_blocks) and block.strip() != cmp_blocks[i].strip():
             # Only flag if content actually changed (not just whitespace)
             if block.replace(" ", "").replace("\n", "") != cmp_blocks[i].replace(" ", "").replace("\n", ""):
                 issues.append(Issue(rel_path, "modified_code_block", "error",
-                                    f"Code block {i+1} content changed during compression"))
+                                    f"Code block {i+1} content changed during condensation"))
 
     # Iron Law preservation — non-negotiable behavioral rules, see preservation-guard
     src_laws = extract_iron_law_sections(source)
-    cmp_laws = extract_iron_law_sections(compressed)
+    cmp_laws = extract_iron_law_sections(condensed)
     cmp_law_map = {h: (lvl, body) for h, lvl, body in cmp_laws}
     # Build a level-agnostic lookup so we can detect heading-level downgrades
     # (`## Iron Law` → `### Iron Law`).
@@ -225,11 +225,11 @@ def check_pair(rel_path: str, source: str, compressed: str) -> List[Issue]:
                                         f"({src_heading.strip()})"))
                     continue
             issues.append(Issue(rel_path, "iron_law_missing", "error",
-                                f"Iron Law section removed during compression: "
+                                f"Iron Law section removed during condensation: "
                                 f"{src_heading.strip()}"))
             continue
         # Section exists at correct level — check structural-unit survival.
-        # Caveman compression is fine (drop articles, terse phrasing); what
+        # Telegraph condensation is fine (drop articles, terse phrasing); what
         # must NOT change is the count of paragraphs, list items, and code
         # blocks. Each is a passage the source kept on purpose.
         _, cmp_body = cmp_law_map[src_heading]
@@ -246,23 +246,23 @@ def check_pair(rel_path: str, source: str, compressed: str) -> List[Issue]:
 
     # Word count ratio
     src_words = len(source.split())
-    cmp_words = len(compressed.split())
+    cmp_words = len(condensed.split())
     if src_words > 0:
         reduction = (1 - cmp_words / src_words) * 100
         if reduction > 60:
             issues.append(Issue(rel_path, "excessive_reduction", "warning",
-                                f"Compression reduced {reduction:.0f}% — possible content loss "
+                                f"Condensation reduced {reduction:.0f}% — possible content loss "
                                 f"({src_words} → {cmp_words} words)"))
         elif reduction < 5 and src_words > 100:
             issues.append(Issue(rel_path, "minimal_reduction", "info",
-                                f"Compression only reduced {reduction:.0f}% "
+                                f"Condensation only reduced {reduction:.0f}% "
                                 f"({src_words} → {cmp_words} words)"))
 
     return issues
 
 
 def scan_all(root: Path) -> List[Issue]:
-    """Scan all .md file pairs for compression quality issues."""
+    """Scan all .md file pairs for condensation quality issues."""
     issues: List[Issue] = []
     source_dir = root / SOURCE_DIR
     target_dir = root / TARGET_DIR
@@ -277,7 +277,7 @@ def scan_all(root: Path) -> List[Issue]:
         if not target_file.exists():
             continue  # sync-check handles missing files
 
-        # Skip commands — they are copied verbatim, not compressed
+        # Skip commands — they are copied verbatim, not condensed
         rel_str = str(rel)
         if rel_str.startswith("commands/"):
             continue
@@ -286,7 +286,7 @@ def scan_all(root: Path) -> List[Issue]:
         target_text = target_file.read_text(encoding="utf-8")
         # Normalise source through the path rewriter (idempotent) so logical
         # `load_context:` names and `../../docs/...` body links match the
-        # depth-aware form the compressor produced. Compression word-count
+        # depth-aware form the condenseor produced. Condensation word-count
         # checks downstream are unaffected because rewriting only edits
         # frontmatter list values and link targets, not prose tokens.
         source_text = _rewrite_paths(source_text, rel_str)
@@ -297,9 +297,9 @@ def scan_all(root: Path) -> List[Issue]:
 
 def format_text(issues: List[Issue]) -> str:
     if not issues:
-        return "✅  Compression quality check passed."
+        return "✅  Condensation quality check passed."
     icons = {"error": "🔴", "warning": "🟡", "info": "ℹ️"}
-    lines = [f"Found {len(issues)} compression quality issue(s):\n"]
+    lines = [f"Found {len(issues)} condensation quality issue(s):\n"]
     for i in issues:
         lines.append(f"  {icons[i.severity]} [{i.check}] {i.file}: {i.message}")
     errors = sum(1 for i in issues if i.severity == "error")
@@ -309,7 +309,7 @@ def format_text(issues: List[Issue]) -> str:
 
 
 def scan_summary(root: Path) -> str:
-    """Generate per-category compression summary stats."""
+    """Generate per-category condensation summary stats."""
     source_dir = root / SOURCE_DIR
     target_dir = root / TARGET_DIR
     if not source_dir.exists() or not target_dir.exists():
@@ -327,7 +327,7 @@ def scan_summary(root: Path) -> str:
         cat = parts[0] if len(parts) > 1 else "root"
         categories.setdefault(cat, []).append((src_words, cmp_words))
 
-    lines = ["Category         | Files | Avg Source | Avg Compressed | Avg Reduction",
+    lines = ["Category         | Files | Avg Source | Avg Condensed | Avg Reduction",
              "---              | ---   | ---        | ---            | ---"]
     total_src = total_cmp = total_files = 0
     for cat in sorted(categories):
@@ -346,9 +346,9 @@ def scan_summary(root: Path) -> str:
 
 
 def main() -> int:
-    parser = argparse.ArgumentParser(description="Check compression quality")
+    parser = argparse.ArgumentParser(description="Check condensation quality")
     parser.add_argument("--format", choices=["text", "json"], default="text")
-    parser.add_argument("--summary", action="store_true", help="Show per-category compression stats")
+    parser.add_argument("--summary", action="store_true", help="Show per-category condensation stats")
     parser.add_argument("--root", type=Path, default=Path("."))
     args = parser.parse_args()
 

package/scripts/{check_compressed_paths.py → check_condensed_paths.py}

@@ -1,15 +1,15 @@
 #!/usr/bin/env python3
-"""Validate compressed-output paths in `.agent-src/rules/*.md`.
+"""Validate condensed-output paths in `.agent-src/rules/*.md`.
 
-Runs after `scripts/compress.py` projects sources to `.agent-src/`. The
-rewriter in `compress.py` is the load-bearing primitive (road-to-path-fixes
+Runs after `scripts/condense.py` projects sources to `.agent-src/`. The
+rewriter in `condense.py` is the load-bearing primitive (road-to-path-fixes
 P1.2); this script is the post-condition gate (P5.1) — every `load_context:`
 entry in `.agent-src/rules/*.md` must resolve relative to the rule file's
 directory to an existing file, and forbidden substrings must not survive
 the rewrite (unless declared in `validator_ignore`).
 
 Forbidden substrings (load_context + body):
-  - `.agent-src.uncompressed/`            unless declared in validator_ignore
+  - `.agent-src.uncondensed/`            unless declared in validator_ignore
   - `../../docs/`                         body-link two-up form (rewriter
                                            collapses to single-up)
   - `../../agents/`                       same shape, different root
@@ -25,7 +25,7 @@ Body-link checks (Council Decision 2, 2026-05-06):
 `validator_ignore:` frontmatter primitive:
   - Per-rule allowlist for rules that *describe* a forbidden substring as
     their subject matter (e.g. `augment-source-of-truth` documents the
-    `.agent-src.uncompressed/` boundary). Each entry: `{type, pattern,
+    `.agent-src.uncondensed/` boundary). Each entry: `{type, pattern,
     reason}`. The validator emits an audit line per matched ignore so
     drift cannot hide.
 
@@ -46,7 +46,7 @@ ROOT = Path(__file__).resolve().parent.parent
 RULES_DIR = ROOT / ".agent-src" / "rules"
 
 FORBIDDEN_SUBSTRINGS = (
-    ".agent-src.uncompressed/",
+    ".agent-src.uncondensed/",
     "../../docs/",
     "../../agents/",
 )
@@ -189,7 +189,7 @@ def _check_body(rule_file: Path, body: str, viols: list[Violation],
 
 def main() -> int:
     if not RULES_DIR.is_dir():
-        print(f"❌  {RULES_DIR} not found — run compression first", file=sys.stderr)
+        print(f"❌  {RULES_DIR} not found — run condensation first", file=sys.stderr)
         return 3
     viols: list[Violation] = []
     audited: list[tuple[str, IgnoreEntry]] = []
@@ -213,7 +213,7 @@ def main() -> int:
         return 1
     rule_count = len(list(RULES_DIR.glob('*.md')))
     if not QUIET:
-        print(f"✅  compressed-path check clean ({rule_count} rules, {len(audited)} ignore(s) audited)")
+        print(f"✅  condensed-path check clean ({rule_count} rules, {len(audited)} ignore(s) audited)")
     return 0
 
 

package/scripts/check_context_paths.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Context-file path & orphan checker.
 
-Validates that every `*.md` under `.agent-src.uncompressed/contexts/`:
+Validates that every `*.md` under `.agent-src.uncondensed/contexts/`:
 
 1. Lives in a locked sub-tree (or is one of six grandfathered root files).
 2. Does not collide on basename with another context file in another sub-tree.
@@ -22,7 +22,7 @@ from dataclasses import asdict, dataclass
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parent.parent
-CONTEXTS_ROOT = ROOT / ".agent-src.uncompressed" / "contexts"
+CONTEXTS_ROOT = ROOT / ".agent-src.uncondensed" / "contexts"
 
 # Sub-trees that may contain context files. Update in lock-step with
 # docs/contracts/context-paths.md whenever a roadmap revision adds one.
@@ -56,10 +56,10 @@ GRANDFATHERED_ROOT_FILES = frozenset({
 # Without this scan dir, every newly-introduced context would orphan
 # until the consuming artefact lands, blocking phase-by-phase commits.
 REFERENCE_SCAN_DIRS = (
-    ".agent-src.uncompressed/rules",
-    ".agent-src.uncompressed/skills",
-    ".agent-src.uncompressed/commands",
-    ".agent-src.uncompressed/contexts",
+    ".agent-src.uncondensed/rules",
+    ".agent-src.uncondensed/skills",
+    ".agent-src.uncondensed/commands",
+    ".agent-src.uncondensed/contexts",
     "agents/roadmaps",
 )
 
@@ -139,7 +139,7 @@ def _build_reference_corpus(root: Path) -> str:
 def _check_orphans(contexts: list[Path], corpus: str, root: Path) -> list[Violation]:
     out: list[Violation] = []
     for ctx in contexts:
-        rel_src = str(ctx.relative_to(root))                       # .agent-src.uncompressed/contexts/...
+        rel_src = str(ctx.relative_to(root))                       # .agent-src.uncondensed/contexts/...
         rel_short = rel_src.split("contexts/", 1)[-1]               # judges/persona-voice-rubric.md
         candidates = (rel_src, f"contexts/{rel_short}", rel_short)
         # Exclude self-references: drop this file's own content from the

package/scripts/check_council_layout.py

@@ -22,7 +22,7 @@ audit's evidence trail. `agents/runtime/` is exempt too — the
 canonical council dirs live at `agents/runtime/council/{questions,
 responses,sessions}/` and the whole `runtime/` tree is gitignored.
 
-Failure modes are enforced by `.agent-src.uncompressed/skills/ai-council/SKILL.md`
+Failure modes are enforced by `.agent-src.uncondensed/skills/ai-council/SKILL.md`
 § "Output path convention".
 
 Exit codes:
@@ -112,7 +112,7 @@ def main() -> int:
         for f in findings:
             print(f"  - {f}")
         print(
-            "\nRule: .agent-src.uncompressed/skills/ai-council/SKILL.md "
+            "\nRule: .agent-src.uncondensed/skills/ai-council/SKILL.md "
             '§ "Output path convention"'
         )
         return 1

package/scripts/check_council_references.py

@@ -53,8 +53,8 @@ PATTERN = re.compile(
 # Only these durable surfaces are scanned. Archive, analysis, and the
 # council dirs themselves are excluded by design.
 #
-# Source roots (legacy `.agent-src.uncompressed/` and every
-# `packages/*/.agent-src.uncompressed/`) are discovered at runtime via
+# Source roots (legacy `.agent-src.uncondensed/` and every
+# `packages/*/.agent-src.uncondensed/`) are discovered at runtime via
 # `artefact_roots()` so the linter follows the monorepo physical layout.
 FIXED_SCAN_ROOTS = (
     "agents/roadmaps",
@@ -92,12 +92,12 @@ ALLOWLIST_PREFIXES: tuple[str, ...] = (
     # the SKIP_DIRS contract in scripts/check_references.py).
     "agents/evidence/analysis/",
     # The rule itself documents forbidden vs. allowed forms.
-    ".agent-src.uncompressed/rules/no-roadmap-references.md",
+    ".agent-src.uncondensed/rules/no-roadmap-references.md",
     # ai-council skill documents the output-path schema.
-    ".agent-src.uncompressed/skills/ai-council/",
+    ".agent-src.uncondensed/skills/ai-council/",
     # Council commands document the output-path schema.
-    ".agent-src.uncompressed/commands/council/",
-    ".agent-src.uncompressed/commands/council.md",
+    ".agent-src.uncondensed/commands/council/",
+    ".agent-src.uncondensed/commands/council.md",
 )
 # Top-level files that are also exempt (e.g. CHANGELOG with historical entries).
 ALLOWLIST_FILES: frozenset[str] = frozenset({
@@ -136,8 +136,8 @@ def _is_allowlisted(rel: str) -> bool:
     """Match a repo-relative POSIX path against the allowlist.
 
     Allowlist prefixes are written against the legacy
-    ``.agent-src.uncompressed/`` layout. A physical hit under
-    ``packages/*/.agent-src.uncompressed/`` is normalised to the same
+    ``.agent-src.uncondensed/`` layout. A physical hit under
+    ``packages/*/.agent-src.uncondensed/`` is normalised to the same
     logical path before matching so entries keep covering relocated files.
     """
     if rel in ALLOWLIST_FILES:
@@ -152,7 +152,7 @@ def _is_allowlisted(rel: str) -> bool:
     return False
 
 
-_LEGACY_PREFIX_STR = ".agent-src.uncompressed/"
+_LEGACY_PREFIX_STR = ".agent-src.uncondensed/"
 
 
 def _is_structurally_allowed(source_rel: str, target_capture: str) -> bool:

package/scripts/check_iron_law_prominence.py

@@ -107,8 +107,8 @@ def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument(
         "paths", nargs="*",
-        default=[".agent-src.uncompressed/rules"],
-        help="Files or directories to scan (default: .agent-src.uncompressed/rules)",
+        default=[".agent-src.uncondensed/rules"],
+        help="Files or directories to scan (default: .agent-src.uncondensed/rules)",
     )
     parser.add_argument("--format", choices=["text", "json"], default="text")
     parser.add_argument("--quiet", action="store_true", help="Only print on failure")

package/scripts/check_kernel_rule_bundle.py

@@ -2,7 +2,7 @@
 """check_kernel_rule_bundle — Phase 4.2 of road-to-always-budget-relief.
 
 Fails when a single PR (or commit range) modifies more than one
-kernel rule under `.agent-src.uncompressed/rules/`. Override via the
+kernel rule under `.agent-src.uncondensed/rules/`. Override via the
 PR label `bundled-always-rules-acknowledged`.
 
 Kernel set is the locked 9-rule list in
@@ -43,7 +43,7 @@ KERNEL_RULES = frozenset({
     "verify-before-complete.md",
 })
 
-KERNEL_DIR = ".agent-src.uncompressed/rules"
+KERNEL_DIR = ".agent-src.uncondensed/rules"
 DEFAULT_LABEL = "bundled-always-rules-acknowledged"