@event4u/agent-config 3.3.0 → 4.2.0

package/scripts/{compress.py → condense.py}

@@ -1,22 +1,22 @@
 #!/usr/bin/env python3
 """
-Agent-config sync — compress .agent-src.uncompressed/ → .agent-src/
+Agent-config sync — condense .agent-src.uncondensed/ → .agent-src/
 and project .agent-src/ → .augment/ (copies for rules by default,
 symlinks for the rest; opt into rule symlinks via
 augment.rules_use_symlinks in .agent-settings.yml).
 
-Copies non-.md files as-is. Lists .md files that need compression (done by the
+Copies non-.md files as-is. Lists .md files that need condensation (done by the
 Augment agent interactively). Tracks SHA-256 hashes of source files to detect
-changes since last compression.
+changes since last condensation.
 
 Usage:
-    python scripts/compress.py              # sync all non-.md files + cleanup + project
-    python scripts/compress.py --list       # list .md files needing compression
-    python scripts/compress.py --changed    # list only .md files changed since last compression
-    python scripts/compress.py --check      # check if directories are in sync
-    python scripts/compress.py --mark-done <relative-path>  # mark file as compressed (update hash)
-    python scripts/compress.py --mark-all-done              # mark ALL .md files as compressed
-    python scripts/compress.py --project-augment            # rebuild .augment/ projection
+    python scripts/condense.py              # sync all non-.md files + cleanup + project
+    python scripts/condense.py --list       # list .md files needing condensation
+    python scripts/condense.py --changed    # list only .md files changed since last condensation
+    python scripts/condense.py --check      # check if directories are in sync
+    python scripts/condense.py --mark-done <relative-path>  # mark file as condensed (update hash)
+    python scripts/condense.py --mark-all-done              # mark ALL .md files as condensed
+    python scripts/condense.py --project-augment            # rebuild .augment/ projection
 """
 
 from __future__ import annotations
@@ -42,19 +42,19 @@ PROJECT_ROOT = Path(__file__).resolve().parent.parent
 # Legacy single-root anchor — kept for backward compatibility with callers
 # that pass it explicitly. Multi-root iteration (post-ADR-017 physical
 # move) goes through `_lib.agent_src` helpers.
-SOURCE_DIR = PROJECT_ROOT / ".agent-src.uncompressed"
+SOURCE_DIR = PROJECT_ROOT / ".agent-src.uncondensed"
 TARGET_DIR = PROJECT_ROOT / ".agent-src"
 AUGMENT_DIR = PROJECT_ROOT / ".augment"
-HASH_FILE = PROJECT_ROOT / ".compression-hashes.json"
+HASH_FILE = PROJECT_ROOT / "internal" / ".condensation-hashes.json"
 SETTINGS_FILE = PROJECT_ROOT / ".agent-settings.yml"
 
 
 def _iter_sources():
     """Yield (physical_path, logical_relpath) for every source artefact.
 
-    Wraps `_lib.agent_src.iter_all_sources` so the compressor walks every
-    active source root (legacy `.agent-src.uncompressed/` plus any
-    `packages/*/.agent-src.uncompressed/`) and keys outputs by the
+    Wraps `_lib.agent_src.iter_all_sources` so the condenseor walks every
+    active source root (legacy `.agent-src.uncondensed/` plus any
+    `packages/*/.agent-src.uncondensed/`) and keys outputs by the
     logical relative path that survives the physical move (ADR-017).
     """
     yield from iter_all_sources()
@@ -69,7 +69,7 @@ def _any_source_root_exists() -> bool:
     """True if at least one artefact source root contains files."""
     return bool(artefact_roots())
 
-# Self-projection tool toggle — see .agent-tools.yml. When the file is
+# Self-projection tool toggle — see agents/.agent-tools.yml. When the file is
 # absent (e.g. tests run in tmp dirs, consumer projects), `_active_tools`
 # returns ``None`` which is treated as "emit every tool".
 _ALL_TOOLS = frozenset({
@@ -81,11 +81,11 @@ _ALL_TOOLS = frozenset({
 def _active_tools() -> frozenset[str] | None:
     """Return the set of active self-projection tools, or None for "all".
 
-    Reads `.agent-tools.yml` relative to the current `PROJECT_ROOT` so
-    test fixtures that monkey-patch `compress.PROJECT_ROOT` see their own
-    (empty) project root and get the default "all tools" behaviour.
+    Reads `agents/.agent-tools.yml` relative to the current `PROJECT_ROOT`
+    so test fixtures that monkey-patch `condense.PROJECT_ROOT` see their
+    own (empty) project root and get the default "all tools" behaviour.
     """
-    tools_file = PROJECT_ROOT / ".agent-tools.yml"
+    tools_file = PROJECT_ROOT / "agents" / ".agent-tools.yml"
     if not tools_file.exists():
         return None
     try:
@@ -103,12 +103,12 @@ def _tool_active(tool_id: str) -> bool:
     active = _active_tools()
     return True if active is None else tool_id in active
 
-# Files to copy as-is even if .md (not compressed by agent)
+# Files to copy as-is even if .md (not condensed by agent)
 COPY_AS_IS = {"README.md"}
 
 # Directories (relative to SOURCE_DIR) whose .md content is data, not prose,
 # and must be copied verbatim. Ghostwriter fixtures carry voice_samples that
-# would be destroyed by caveman compression.
+# would be destroyed by telegraph condensation.
 COPY_AS_IS_DIRS = frozenset({"ghostwriter"})
 
 
@@ -154,7 +154,7 @@ def file_hash(filepath: Path) -> str:
 
 
 def load_hashes() -> dict:
-    """Load stored compression hashes from JSON file."""
+    """Load stored condensation hashes from JSON file."""
     if HASH_FILE.exists():
         try:
             return json.loads(HASH_FILE.read_text())
@@ -164,13 +164,13 @@ def load_hashes() -> dict:
 
 
 def save_hashes(hashes: dict) -> None:
-    """Save compression hashes to JSON file."""
+    """Save condensation hashes to JSON file."""
     HASH_FILE.parent.mkdir(parents=True, exist_ok=True)
     HASH_FILE.write_text(json.dumps(hashes, indent=2, sort_keys=True) + "\n")
 
 
 def mark_done(relative_path: str) -> None:
-    """Mark a single file as compressed by storing its current source hash.
+    """Mark a single file as condensed by storing its current source hash.
 
     Also runs the path rewriter on the just-written `.agent-src/<path>` so
     logical names from the source frontmatter resolve to deployment-correct
@@ -185,14 +185,14 @@ def mark_done(relative_path: str) -> None:
     hashes = load_hashes()
     hashes[relative_path] = file_hash(source_file)
     save_hashes(hashes)
-    print(f"✅  Marked as compressed: {relative_path}")
+    print(f"✅  Marked as condensed: {relative_path}")
 
 
 def apply_path_rewriter(relative_path: str) -> bool:
     """Apply `_rewrite_paths` to `.agent-src/<relative_path>` in-place.
 
     Returns True if the file was modified, False otherwise. Silently
-    returns False if the target doesn't exist (compression hasn't run
+    returns False if the target doesn't exist (condensation hasn't run
     yet) — `--mark-done` is also valid before content exists.
     """
     target = TARGET_DIR / relative_path
@@ -207,20 +207,20 @@ def apply_path_rewriter(relative_path: str) -> bool:
 
 
 def mark_all_done() -> None:
-    """Mark ALL .md files as compressed (e.g. after initial full compression)."""
+    """Mark ALL .md files as condensed (e.g. after initial full condensation)."""
     hashes = load_hashes()
     count = 0
     for source_file, relative in _iter_sources():
-        if not should_compress(source_file):
+        if not should_condense(source_file):
             continue
         hashes[relative] = file_hash(source_file)
         count += 1
     save_hashes(hashes)
-    print(f"✅  Marked {count} files as compressed")
+    print(f"✅  Marked {count} files as condensed")
 
 
 def list_changed_md(source_dir: Path) -> list:
-    """List .md files whose source hash differs from stored hash (= need recompression).
+    """List .md files whose source hash differs from stored hash (= need recondensation).
 
     The ``source_dir`` parameter is retained for backward compatibility but
     ignored — iteration walks every active source root (ADR-017).
@@ -229,7 +229,7 @@ def list_changed_md(source_dir: Path) -> list:
     hashes = load_hashes()
     changed = []
     for source_file, relative in _iter_sources():
-        if not should_compress(source_file):
+        if not should_condense(source_file):
             continue
         current_hash = file_hash(source_file)
         stored_hash = hashes.get(relative)
@@ -262,15 +262,15 @@ def clean_stale_hashes(source_dir: Path) -> int:
 
 
 
-def should_compress(filepath: Path) -> bool:
-    """Check if file should be compressed (is .md and not in copy-as-is list)."""
+def should_condense(filepath: Path) -> bool:
+    """Check if file should be condensed (is .md and not in copy-as-is list)."""
     if filepath.suffix != ".md":
         return False
     if filepath.name in COPY_AS_IS:
         return False
     # Determine the logical relative path so the COPY_AS_IS_DIRS check
-    # works for both legacy (`.agent-src.uncompressed/`) and post-move
-    # (`packages/*/.agent-src.uncompressed/`) source roots.
+    # works for both legacy (`.agent-src.uncondensed/`) and post-move
+    # (`packages/*/.agent-src.uncondensed/`) source roots.
     rel_parts: tuple[str, ...] = filepath.parts
     for root in artefact_roots():
         try:
@@ -321,8 +321,8 @@ def sync_non_md(source_dir: Path, target_dir: Path) -> int:
     copied = 0
     seen: set[str] = set()
     for source_file, relative in _iter_sources():
-        if should_compress(source_file):
-            continue  # .md files are compressed by the agent, not copied here
+        if should_condense(source_file):
+            continue  # .md files are condensed by the agent, not copied here
         if relative in seen:
             continue
         seen.add(relative)
@@ -334,12 +334,12 @@ def sync_non_md(source_dir: Path, target_dir: Path) -> int:
 
 
 def list_md_files(source_dir: Path) -> list:
-    """List all .md files that need compression by the agent."""
+    """List all .md files that need condensation by the agent."""
     del source_dir  # multi-root: ignored, kept for signature stability
     files: list[str] = []
     seen: set[str] = set()
     for source_file, relative in _iter_sources():
-        if not should_compress(source_file):
+        if not should_condense(source_file):
             continue
         if relative in seen:
             continue
@@ -402,7 +402,7 @@ USER_TYPE_TOOL_DIRS = {
 }
 
 # Map tool-projection directories to the canonical tool ID used by
-# `.agent-tools.yml`. Directories not in this map are always emitted.
+# `agents/.agent-tools.yml`. Directories not in this map are always emitted.
 _DIR_TOOL_ID = {
     ".claude/rules": "claude-code",
     ".cursor/rules": "cursor",
@@ -415,7 +415,7 @@ _DIR_TOOL_ID = {
 
 
 def _filter_tool_dirs(mapping: dict[str, str]) -> dict[str, str]:
-    """Drop entries whose tool ID is not active in `.agent-tools.yml`."""
+    """Drop entries whose tool ID is not active in `agents/.agent-tools.yml`."""
     return {
         d: p for d, p in mapping.items()
         if _tool_active(_DIR_TOOL_ID.get(d, "claude-code"))
@@ -432,7 +432,7 @@ def strip_frontmatter(content: str) -> str:
 
 
 # ── Path rewriter (P1 of road-to-path-fixes.md) ───────────────────────────
-# Source files use logical names that the rewriter resolves at compress
+# Source files use logical names that the rewriter resolves at condense
 # time, so the shipped `.agent-src/` (and `.augment/` projection) carry
 # deployment-correct relative paths without the agent author having to
 # know how deep their file lives.
@@ -440,12 +440,12 @@ def strip_frontmatter(content: str) -> str:
 # Frontmatter rewrites:
 #   load_context: / load_context_eager:
 #     contexts/<area>/<file>.md                          (logical, preferred)
-#     .agent-src.uncompressed/contexts/<area>/<file>.md  (legacy)
+#     .agent-src.uncondensed/contexts/<area>/<file>.md  (legacy)
 #       → ../contexts/<area>/<file>.md  (relative from .agent-src/rules/)
 #   triggers[].path_prefix:
 #     LEFT ALONE — `path_prefix:` is a literal match pattern, not a
 #     file reference. Source-of-truth rules that fire on edits under
-#     `.agent-src.uncompressed/` keep that prefix verbatim (see
+#     `.agent-src.uncondensed/` keep that prefix verbatim (see
 #     road-to-path-fixes.md P2.2 / Modified Option 1).
 #
 # Body-link rewrites:
@@ -455,7 +455,7 @@ def strip_frontmatter(content: str) -> str:
 # Idempotent: applying twice is a no-op (rewritten patterns no longer
 # match the source patterns).
 
-_LEGACY_SRC_PREFIX = ".agent-src.uncompressed/"
+_LEGACY_SRC_PREFIX = ".agent-src.uncondensed/"
 _PROJECTED_SRC_PREFIX = ".agent-src/"
 
 # A YAML list item under load_context*: `  - some/path.md` (optionally quoted)
@@ -513,7 +513,7 @@ def _rewrite_path_prefix_value(value: str) -> str:
     `path_prefix:` is a literal match pattern the host evaluates against
     the file the agent is editing — not a file reference. Rewriting it
     breaks the workflow it was authored for: source-of-truth rules that
-    fire when the agent edits files under `.agent-src.uncompressed/`
+    fire when the agent edits files under `.agent-src.uncondensed/`
     keep that prefix verbatim. The prefix ban therefore applies only to
     `load_context:` entries and body links (see road-to-path-fixes.md
     P2.2 + the AI-Council convergence on 2026-05-06).
@@ -556,10 +556,10 @@ def _rewrite_body_links(body: str, prefix: str) -> str:
 
 # ── Human-review banner injection (Phase 5.3 / ADR-018) ───────────────────
 # Source artefacts may set `trust.human_review_required: true` in their
-# frontmatter. The compressor injects a short, parser-stable banner block
+# frontmatter. The condenseor injects a short, parser-stable banner block
 # at the top of the projected body so every downstream surface (agent
 # memory, .augment, .claude, etc.) surfaces the gate. Idempotent — the
-# marker comment prevents double-injection on re-compress.
+# marker comment prevents double-injection on re-condense.
 
 _HRR_BANNER_MARKER = "<!-- agent-config:human-review-banner -->"
 
@@ -1063,7 +1063,7 @@ def generate_user_type_symlinks() -> int:
 def generate_tools() -> None:
     """Generate all tool-specific directories and files.
 
-    `.agent-tools.yml` (top-level) gates per-tool emission. When the file
+    `agents/.agent-tools.yml` gates per-tool emission. When the file
     is missing, every tool is emitted (preserves test fixtures and
     pre-gating behaviour). See `_active_tools()` and `_tool_active()`.
     """
@@ -1095,7 +1095,7 @@ def generate_tools() -> None:
 
 
 # ── .augment/ projection ──────────────────────────────────────────────
-# The package uses .agent-src/ as the tool-agnostic compressed source of truth.
+# The package uses .agent-src/ as the tool-agnostic condensed source of truth.
 # .augment/ is a generated projection so that Augment Code (which reads from
 # .augment/) works on the package repo itself. Rules default to copies
 # because Augment Code historically does not load symlinked rule files;
@@ -1174,7 +1174,7 @@ def project_to_augment() -> None:
     # Cleanup: remove any stray top-level entries in .augment/ that are no longer projected.
     # `state` holds runtime state files written by hooks (onboarding-gate,
     # context-hygiene, …) and must survive sync — it is regenerated by
-    # the next hook fire, not by compress.
+    # the next hook fire, not by condense.
     known = set(AUGMENT_SYMLINK_DIRS) | set(AUGMENT_SYMLINK_FILES) | {"rules", "state"}
     for item in AUGMENT_DIR.iterdir():
         if item.name in known:
@@ -1211,10 +1211,10 @@ def clean_tools() -> None:
 
 def main() -> None:
     # Multi-root awareness (ADR-017): tolerate a missing legacy
-    # `.agent-src.uncompressed/` as long as at least one package-scoped
+    # `.agent-src.uncondensed/` as long as at least one package-scoped
     # source root carries artefacts.
     if not SOURCE_DIR.exists() and not _any_source_root_exists():
-        print(f"❌  No source directory found (looked at {SOURCE_DIR} and packages/*/.agent-src.uncompressed)")
+        print(f"❌  No source directory found (looked at {SOURCE_DIR} and packages/*/.agent-src.uncondensed)")
         sys.exit(1)
 
     arg = sys.argv[1] if len(sys.argv) > 1 else "--sync"
@@ -1228,15 +1228,15 @@ def main() -> None:
     elif arg == "--changed":
         changed = list_changed_md(SOURCE_DIR)
         if not changed:
-            print("✅  No .md files changed since last compression")
+            print("✅  No .md files changed since last condensation")
             sys.exit(0)
-        print(f"📝  {len(changed)} .md files changed since last compression:\n")
+        print(f"📝  {len(changed)} .md files changed since last condensation:\n")
         for f in changed:
             print(f"  {f}")
 
     elif arg == "--mark-done":
         if len(sys.argv) < 3:
-            print("Usage: python scripts/compress.py --mark-done <relative-path>")
+            print("Usage: python scripts/condense.py --mark-done <relative-path>")
             sys.exit(1)
         mark_done(sys.argv[2])
 
@@ -1246,7 +1246,7 @@ def main() -> None:
     elif arg == "--check":
         missing, stale = check_sync(SOURCE_DIR, TARGET_DIR)
         if not missing and not stale:
-            print("✅  .agent-src/ is in sync with .agent-src.uncompressed/")
+            print("✅  .agent-src/ is in sync with .agent-src.uncondensed/")
             sys.exit(0)
         if missing:
             print(f"❌  Missing in .agent-src/ ({len(missing)}):")
@@ -1256,7 +1256,7 @@ def main() -> None:
             print(f"❌  Stale in .agent-src/ ({len(stale)}):")
             for f in stale:
                 print(f"  {f}")
-        print(f"\nRun 'task sync' to fix non-.md files, then ask the agent to compress .md files.")
+        print(f"\nRun 'task sync' to fix non-.md files, then ask the agent to condense .md files.")
         sys.exit(1)
 
     elif arg == "--sync":
@@ -1278,7 +1278,7 @@ def main() -> None:
         changed = list_changed_md(SOURCE_DIR)
         print(f"\n✅  Done: {copied} copied, {deleted} stale deleted")
         if changed:
-            print(f"📝  {len(changed)} .md files need compression (run --changed to see them)")
+            print(f"📝  {len(changed)} .md files need condensation (run --changed to see them)")
         else:
             print(f"✅  All .md files are up to date")
         print(f"\n--- Projecting .agent-src/ → .augment/ ---")
@@ -1298,15 +1298,15 @@ def main() -> None:
 
         if changed:
             has_issues = True
-            print(f"❌  {len(changed)} .md file(s) need recompression:\n")
+            print(f"❌  {len(changed)} .md file(s) need recondensation:\n")
             for f in changed:
                 stored = load_hashes().get(f)
                 reason = "no hash stored" if stored is None else "hash mismatch"
                 print(f"  {f}  ({reason})")
-            print(f"\nRun '/compress' command to recompress these files.")
+            print(f"\nRun '/condense' command to recondense these files.")
 
         if not has_issues:
-            print("✅  All compression hashes are clean (no stale, no mismatches)")
+            print("✅  All condensation hashes are clean (no stale, no mismatches)")
             sys.exit(0)
         sys.exit(1)
 
@@ -1327,7 +1327,7 @@ def main() -> None:
         project_to_augment()
 
     else:
-        print("Usage: python scripts/compress.py [--sync|--list|--changed|--check|--check-hashes|--clean-hashes|--mark-done <path>|--mark-all-done|--generate-tools|--clean-tools|--project-augment]")
+        print("Usage: python scripts/condense.py [--sync|--list|--changed|--check|--check-hashes|--clean-hashes|--mark-done <path>|--mark-all-done|--generate-tools|--clean-tools|--project-augment]")
         sys.exit(1)
 
 

package/scripts/condense.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+# Augment Sync — sync non-.md files and cleanup stale files
+#
+# Usage:
+#   ./scripts/condense.sh              # sync non-.md files + cleanup
+#   ./scripts/condense.sh --list       # list ALL .md files
+#   ./scripts/condense.sh --changed    # list .md files changed since last condensation
+#   ./scripts/condense.sh --check      # check if dirs are in sync
+#   ./scripts/condense.sh --mark-done <path>  # mark file as condensed
+#   ./scripts/condense.sh --mark-all-done     # mark all files as condensed
+#
+# .md condensation is done by the Augment agent interactively.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+python3 "$SCRIPT_DIR/condense.py" "${@:---sync}"

package/scripts/{compress_memory.py → condense_memory.py}

@@ -1,14 +1,14 @@
 #!/usr/bin/env python3
-"""Input-side memory compression — Phase 2 of step-16-caveman-substance.
+"""Input-side memory condensation — Phase 2 of step-16-telegraph-substance.
 
-Rewrites memory files (AGENTS.md, CLAUDE.md, .cursorrules, ...) to caveman
+Rewrites memory files (AGENTS.md, CLAUDE.md, .cursorrules, ...) to telegraph
 grammar (drop articles / auxiliaries) while preserving carve-outs byte-for-byte
 (code blocks, numbered-options, status markers, Iron-Law ALL-CAPS, backtick
 spans). Writes `.original.md` backup before mutating. Gated by Phase 0
 `validate_safe_paths.assert_safe`. Idempotency guard: `original_sha256:` +
-`compressed_at:` frontmatter refuse re-compression on body-hash drift.
+`condensed_at:` frontmatter refuse re-condensation on body-hash drift.
 
-CLI: `compress_memory.py <path> [--check|--decompress]`. Stdlib-only.
+CLI: `condense_memory.py <path> [--check|--decondense]`. Stdlib-only.
 """
 from __future__ import annotations
 
@@ -24,14 +24,14 @@ sys.path.insert(0, str(REPO_ROOT / "scripts"))
 
 from validate_safe_paths import SensitivePathError, assert_safe  # noqa: E402
 
-__all__ = ["compress_text", "compress_file", "decompress_file", "CompressionRefused"]
+__all__ = ["condense_text", "condense_file", "decondense_file", "CondensationRefused"]
 
 
-class CompressionRefused(RuntimeError):
-    """Raised when the target is already compressed and body hash diverged."""
+class CondensationRefused(RuntimeError):
+    """Raised when the target is already condensed and body hash diverged."""
 
 
-# Carve-out region patterns — mirrors caveman-speak.md § Carve-outs (1–7).
+# Carve-out region patterns — mirrors telegraph-speak.md § Carve-outs (1–7).
 RE_FENCE = re.compile(r"^```")
 RE_NUMBERED = re.compile(r"^>?\s*\d+\.\s")
 RE_STATUS = re.compile(r"^\s*(?:❌|⚠️|✅)")
@@ -43,26 +43,26 @@ DROP_TOKENS = {"the", "a", "an", "is", "are", "was", "were", "be", "been",
                "being", "that", "which"}
 
 
-def _compress_words(text: str) -> str:
+def _condense_words(text: str) -> str:
     out = WORD_RE.sub(lambda m: "" if m.group(0).lower() in DROP_TOKENS else m.group(0), text)
     out = re.sub(r"[ \t]{2,}", " ", out)
     return re.sub(r" +([,.;:!?])", r"\1", out)
 
 
-def _compress_prose_line(line: str) -> str:
-    """Compress a prose line; preserve backtick-spans byte-for-byte."""
+def _condense_prose_line(line: str) -> str:
+    """Condense a prose line; preserve backtick-spans byte-for-byte."""
     parts: list[str] = []
     last = 0
     for span in RE_BACKTICK_SPAN.finditer(line):
-        parts.append(_compress_words(line[last:span.start()]))
+        parts.append(_condense_words(line[last:span.start()]))
         parts.append(span.group(0))
         last = span.end()
-    parts.append(_compress_words(line[last:]))
+    parts.append(_condense_words(line[last:]))
     return "".join(parts)
 
 
-def compress_text(body: str) -> str:
-    """Compress a memory-file body. Idempotent on already-caveman text."""
+def condense_text(body: str) -> str:
+    """Condense a memory-file body. Idempotent on already-telegraph text."""
     out: list[str] = []
     in_fence = False
     for raw in body.splitlines(keepends=True):
@@ -75,7 +75,7 @@ def compress_text(body: str) -> str:
                 or RE_IRONLAW.match(stripped.strip()):
             out.append(raw)
             continue
-        out.append(_compress_prose_line(raw))
+        out.append(_condense_prose_line(raw))
     return "".join(out)
 
 
@@ -98,38 +98,38 @@ def _has_sha_marker(fm: str) -> bool:
 
 
 def _inject_frontmatter(fm: str, sha: str, ts: str) -> str:
-    drop = re.compile(r"^(original_sha256|compressed_at):.*$", re.MULTILINE)
+    drop = re.compile(r"^(original_sha256|condensed_at):.*$", re.MULTILINE)
     inner = drop.sub("", fm.strip().strip("-").strip()).strip() if fm else ""
     body = inner + ("\n" if inner else "")
-    return f"---\n{body}original_sha256: {sha}\ncompressed_at: {ts}\n---\n"
+    return f"---\n{body}original_sha256: {sha}\ncondensed_at: {ts}\n---\n"
 
 
 def _backup_path(target: Path) -> Path:
     return target.parent / (target.name + ".original.md")
 
 
-def compress_file(target: Path) -> Path:
+def condense_file(target: Path) -> Path:
     assert_safe(target)
     text = target.read_text(encoding="utf-8")
     fm, body = _split_frontmatter(text)
     if _has_sha_marker(fm):
-        if _sha256(compress_text(body)) != _sha256(body):
-            raise CompressionRefused(
-                f"{target}: body hash diverged; decompress first "
-                f"(`scripts/compress_memory.py {target} --decompress`)."
+        if _sha256(condense_text(body)) != _sha256(body):
+            raise CondensationRefused(
+                f"{target}: body hash diverged; decondense first "
+                f"(`scripts/condense_memory.py {target} --decondense`)."
             )
         return target
     backup = _backup_path(target)
     backup.write_text(text, encoding="utf-8")
     ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
     target.write_text(
-        _inject_frontmatter(fm, _sha256(body), ts) + compress_text(body),
+        _inject_frontmatter(fm, _sha256(body), ts) + condense_text(body),
         encoding="utf-8",
     )
     return backup
 
 
-def decompress_file(target: Path) -> Path:
+def decondense_file(target: Path) -> Path:
     assert_safe(target)
     backup = _backup_path(target)
     if not backup.is_file():
@@ -140,27 +140,27 @@ def decompress_file(target: Path) -> Path:
 
 
 def _main(argv: list[str]) -> int:
-    ap = argparse.ArgumentParser(description="Compress memory files to caveman grammar.")
+    ap = argparse.ArgumentParser(description="Condense memory files to telegraph grammar.")
     ap.add_argument("path", type=Path)
     grp = ap.add_mutually_exclusive_group()
     grp.add_argument("--check", action="store_true", help="exit 0 if safe; no writes")
-    grp.add_argument("--decompress", action="store_true", help="restore .original.md")
+    grp.add_argument("--decondense", action="store_true", help="restore .original.md")
     args = ap.parse_args(argv)
     try:
         if args.check:
             assert_safe(args.path)
             return 0
-        if args.decompress:
-            decompress_file(args.path)
-            print(f"decompressed: {args.path}")
+        if args.decondense:
+            decondense_file(args.path)
+            print(f"decondenseed: {args.path}")
             return 0
-        backup = compress_file(args.path)
-        print(f"compressed: {args.path}  (backup: {backup})")
+        backup = condense_file(args.path)
+        print(f"condensed: {args.path}  (backup: {backup})")
         return 0
     except SensitivePathError as exc:
         print(f"error: refused: {exc}", file=sys.stderr)
         return 2
-    except CompressionRefused as exc:
+    except CondensationRefused as exc:
         print(f"error: {exc}", file=sys.stderr)
         return 3
     except FileNotFoundError as exc:

package/scripts/config/presets.py

@@ -34,7 +34,7 @@ logger = logging.getLogger(__name__)
 PRESET_ID_ENV = "AGENT_CONFIG_PRESET_ID"
 SEED_PRESET_IDS: tuple[str, ...] = ("fast", "balanced", "strict")
 DEFAULT_PRESET_ID = "balanced"
-PRESETS_DIRNAME = ".agent-src.uncompressed/presets"
+PRESETS_DIRNAME = ".agent-src.uncondensed/presets"
 
 SOURCE_PACK = "pack"
 SOURCE_PROFILE = "profile"
@@ -94,7 +94,7 @@ def _load_yaml(path: Path) -> dict[str, Any]:
 
 def _preset_file(project_root: Path, preset_id: str) -> Path:
     # Legacy single-root layout — honor when present so tests that mock a
-    # ``.agent-src.uncompressed/`` sub-tree under ``project_root`` keep working.
+    # ``.agent-src.uncondensed/`` sub-tree under ``project_root`` keep working.
     legacy = project_root / PRESETS_DIRNAME / f"{preset_id}.yml"
     if legacy.exists():
         return legacy

package/scripts/config/profiles.py

@@ -40,7 +40,7 @@ SEED_PROFILE_IDS: tuple[str, ...] = (
     "ops",
 )
 DEFAULT_PROFILE_ID = "developer"
-PROFILES_DIRNAME = ".agent-src.uncompressed/profiles"
+PROFILES_DIRNAME = ".agent-src.uncondensed/profiles"
 
 SOURCE_PACK = "pack"
 SOURCE_USER = "user-settings"

package/scripts/cost_by_conversation.py

@@ -27,7 +27,7 @@ def _load(path: Path) -> list[dict]:
 def group(rows: list[dict]) -> dict:
     by_conv: dict = defaultdict(lambda: {
         "sessions": 0, "total_cost_usd": 0.0, "input_tokens": 0,
-        "output_tokens": 0, "caveman_delta_tokens": 0,
+        "output_tokens": 0, "telegraph_delta_tokens": 0,
         "by_model": defaultdict(lambda: {"sessions": 0, "cost_usd": 0.0}),
     })
     for row in rows:
@@ -38,7 +38,7 @@ def group(rows: list[dict]) -> dict:
         b["total_cost_usd"] += cost
         b["input_tokens"] += int(row.get("input_tokens") or 0)
         b["output_tokens"] += int(row.get("output_tokens") or 0)
-        b["caveman_delta_tokens"] += int(row.get("caveman_delta_tokens") or 0)
+        b["telegraph_delta_tokens"] += int(row.get("telegraph_delta_tokens") or 0)
         m = b["by_model"][str(row.get("model") or "unknown")]
         m["sessions"] += 1
         m["cost_usd"] += cost
@@ -53,7 +53,7 @@ def render_text(report: dict) -> str:
         lines.append(
             f"  {cid}: {b['sessions']} sessions · ${b['total_cost_usd']:.4f} · "
             f"in {b['input_tokens']:,} · out {b['output_tokens']:,} · "
-            f"caveman_delta {b['caveman_delta_tokens']:+,}"
+            f"telegraph_delta {b['telegraph_delta_tokens']:+,}"
         )
         for model, m in sorted(b["by_model"].items()):
             lines.append(f"      {model}: {m['sessions']} sessions · ${m['cost_usd']:.4f}")