@event4u/agent-config 3.3.0 → 4.2.0

package/scripts/adoption_snapshot.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""Pull the four public adoption signals into a single dated JSONL row.
+
+Phase D Step 2 of ``road-to-adoption-proof-and-ci-green.md``.
+Signals (per ``docs/contracts/adoption-signal-floor.md``):
+
+  1. npm install count          — last 7 days, full lifetime.
+  2. npm version distribution    — latest published version.
+  3. GitHub stars / forks        — current count.
+  4. Topic-search rank           — best-rank position for the two
+     project-scoped topics (`agent-skills`, `cinematic-ai-video`).
+
+Output: one JSONL row appended to
+``agents/runtime/metrics/adoption-snapshots.jsonl``. Each row carries
+an ISO-8601 ``snapshot_at`` timestamp + the four signal payloads.
+
+CLI:
+
+  scripts/adoption_snapshot.py [--out <path>] [--no-network]
+
+  --no-network          Skip the four HTTP calls; emit a row with
+                        ``error: "skipped"`` on each signal. Used by
+                        the pytest path so tests never hit the wire.
+  --out                 Override the output JSONL path (default:
+                        ``agents/runtime/metrics/adoption-snapshots.jsonl``).
+
+Exit codes:
+
+  0 — row appended successfully.
+  1 — IO failure writing the JSONL.
+  2 — every signal failed (network outage; the row is appended but
+      annotated, so trend reports can spot the outage).
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+from urllib.error import URLError, HTTPError
+from urllib.request import Request, urlopen
+
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+DEFAULT_OUT = REPO_ROOT / "agents" / "runtime" / "metrics" / "adoption-snapshots.jsonl"
+
+NPM_PACKAGE = "@event4u/agent-config"
+NPM_DOWNLOADS_URL = f"https://api.npmjs.org/downloads/range/last-week/{NPM_PACKAGE}"
+NPM_REGISTRY_URL = f"https://registry.npmjs.org/{NPM_PACKAGE.replace('/', '%2F')}"
+GH_REPO = "event4u-app/agent-config"
+GH_REPO_URL = f"https://api.github.com/repos/{GH_REPO}"
+GH_TOPICS = ("agent-skills", "cinematic-ai-video")
+GH_SEARCH_URL_TEMPLATE = "https://api.github.com/search/repositories?q=topic:{topic}&sort=stars&order=desc&per_page=100"
+
+TIMEOUT_S = 10
+
+
+def _utc_now_iso() -> str:
+    return dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _http_get_json(url: str, headers: dict[str, str] | None = None) -> dict[str, Any]:
+    req = Request(url, headers=headers or {})
+    with urlopen(req, timeout=TIMEOUT_S) as resp:
+        body = resp.read().decode("utf-8")
+    return json.loads(body)
+
+
+def fetch_npm_downloads() -> dict[str, Any]:
+    try:
+        data = _http_get_json(NPM_DOWNLOADS_URL)
+        downloads = data.get("downloads", [])
+        total_7d = sum(d.get("downloads", 0) for d in downloads if isinstance(d, dict))
+        return {"package": NPM_PACKAGE, "last_7_days": total_7d, "source": "npm"}
+    except (URLError, HTTPError, ValueError) as exc:
+        return {"package": NPM_PACKAGE, "error": str(exc)[:120], "source": "npm"}
+
+
+def fetch_npm_version() -> dict[str, Any]:
+    try:
+        data = _http_get_json(NPM_REGISTRY_URL)
+        latest = data.get("dist-tags", {}).get("latest", "")
+        versions = list(data.get("versions", {}).keys())
+        return {
+            "latest": latest,
+            "version_count": len(versions),
+            "source": "npm-registry",
+        }
+    except (URLError, HTTPError, ValueError) as exc:
+        return {"error": str(exc)[:120], "source": "npm-registry"}
+
+
+def fetch_github_stars() -> dict[str, Any]:
+    try:
+        headers = {"Accept": "application/vnd.github+json"}
+        token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+        data = _http_get_json(GH_REPO_URL, headers=headers)
+        return {
+            "repo": GH_REPO,
+            "stars": data.get("stargazers_count", 0),
+            "forks": data.get("forks_count", 0),
+            "watchers": data.get("watchers_count", 0),
+            "source": "github-repo",
+        }
+    except (URLError, HTTPError, ValueError) as exc:
+        return {"repo": GH_REPO, "error": str(exc)[:120], "source": "github-repo"}
+
+
+def fetch_topic_rank() -> dict[str, Any]:
+    out: dict[str, Any] = {"source": "github-search"}
+    for topic in GH_TOPICS:
+        try:
+            headers = {"Accept": "application/vnd.github+json"}
+            token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+            if token:
+                headers["Authorization"] = f"Bearer {token}"
+            data = _http_get_json(GH_SEARCH_URL_TEMPLATE.format(topic=topic), headers=headers)
+            items = data.get("items", [])
+            rank = next(
+                (i + 1 for i, item in enumerate(items) if item.get("full_name") == GH_REPO),
+                None,
+            )
+            out[topic] = {
+                "rank": rank,
+                "total_results": data.get("total_count", 0),
+            }
+        except (URLError, HTTPError, ValueError) as exc:
+            out[topic] = {"error": str(exc)[:120]}
+    return out
+
+
+def collect_signals(skip_network: bool) -> dict[str, Any]:
+    if skip_network:
+        skipped = {"error": "skipped", "source": "skipped"}
+        return {
+            "npm_downloads": skipped,
+            "npm_version": skipped,
+            "github_stars": skipped,
+            "topic_rank": skipped,
+        }
+    return {
+        "npm_downloads": fetch_npm_downloads(),
+        "npm_version": fetch_npm_version(),
+        "github_stars": fetch_github_stars(),
+        "topic_rank": fetch_topic_rank(),
+    }
+
+
+def build_row(signals: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "snapshot_at": _utc_now_iso(),
+        "schema": "adoption-snapshot/v0",
+        "signals": signals,
+    }
+
+
+def append_row(out_path: Path, row: dict[str, Any]) -> None:
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    with out_path.open("a", encoding="utf-8") as fh:
+        fh.write(json.dumps(row) + "\n")
+
+
+def all_signals_failed(signals: dict[str, Any]) -> bool:
+    """True when every signal (or every topic in topic_rank) errored.
+
+    A signal block carries `error` when its HTTP call failed. For
+    `topic_rank`, the outer dict does NOT carry `error`; instead each
+    nested per-topic entry does. The outage predicate counts the
+    composite as a failure when every nested topic errored.
+    """
+    for name, value in signals.items():
+        if not isinstance(value, dict):
+            return False  # Unknown shape — treat as success to be conservative.
+        if name == "topic_rank":
+            # Outage when every nested topic errored.
+            nested = [v for k, v in value.items() if k != "source" and isinstance(v, dict)]
+            if not nested:
+                return False
+            if any("error" not in v for v in nested):
+                return False
+        else:
+            if "error" not in value:
+                return False
+    return True
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    p = argparse.ArgumentParser(prog="adoption_snapshot")
+    p.add_argument("--out", type=Path, default=DEFAULT_OUT, help="JSONL output path.")
+    p.add_argument(
+        "--no-network",
+        action="store_true",
+        help="Skip the four HTTP calls (used by the pytest path).",
+    )
+    return p.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+    signals = collect_signals(skip_network=args.no_network)
+    row = build_row(signals)
+    try:
+        append_row(args.out, row)
+    except OSError as exc:
+        print(f"error: failed to append snapshot: {exc}", file=sys.stderr)
+        return 1
+    print(f"appended snapshot @ {row['snapshot_at']} → {args.out}")
+    if not args.no_network and all_signals_failed(signals):
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/adoption_status.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""One-screen adoption dashboard for the maintainer's weekly review.
+
+Phase C Step 6 of ``road-to-adoption-proof-and-ci-green.md``. Prints
+three things in one short block:
+
+  1. Registry-submission status — counts per status from
+     ``docs/distribution/registry-submissions.md``.
+  2. Recruit-session report count — files matching
+     ``agents/recruit-sessions/[0-9]*.md`` (excludes template / runbook /
+     findings).
+  3. Latest required-check colour on ``main`` — shells out to
+     ``scripts/ci_status.py`` (zero-cost; per-shape required set).
+
+CLI:
+
+  scripts/adoption_status.py [--json] [--branch main]
+
+Exit codes:
+
+  0 — printed successfully (status itself does not gate the exit).
+  1 — IO error reading the registry-submissions sheet.
+
+Anchored to:
+
+- ``docs/distribution/registry-submissions.md`` § Tracking rows.
+- ``agents/recruit-sessions/_runbook.md`` § Post-session.
+- ``docs/contracts/ci-green-floor.md`` § Blocking set.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Iterable
+
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+REGISTRY_DOC = REPO_ROOT / "docs" / "distribution" / "registry-submissions.md"
+RECRUIT_DIR = REPO_ROOT / "agents" / "recruit-sessions"
+
+STATUS_VALUES = ("pending", "submitted", "accepted", "rejected", "stalled")
+
+
+def parse_registry_statuses(text: str) -> dict[str, int]:
+    """Parse the `Tracking rows` table; return counts per status value."""
+    counts = {s: 0 for s in STATUS_VALUES}
+    in_table = False
+    for line in text.splitlines():
+        if line.startswith("## Tracking rows"):
+            in_table = True
+            continue
+        if in_table and line.startswith("## "):
+            break
+        if not in_table:
+            continue
+        if not line.startswith("|"):
+            continue
+        cells = [c.strip() for c in line.split("|")[1:-1]]
+        if len(cells) < 4:
+            continue
+        # Header / separator rows have the literal "Registry" or "---" in cell 1.
+        if cells[0] in ("#", "---") or cells[1] in ("Registry", "---"):
+            continue
+        status_cell = cells[3].strip("`")
+        if status_cell in counts:
+            counts[status_cell] += 1
+    return counts
+
+
+def count_recruit_reports(reports_dir: Path) -> int:
+    """Count files matching `<NN>-<role>.md` under recruit-sessions/."""
+    if not reports_dir.exists():
+        return 0
+    pattern = re.compile(r"^\d{2}-[a-z][a-z0-9-]*\.md$")
+    return sum(1 for p in reports_dir.iterdir() if p.is_file() and pattern.match(p.name))
+
+
+def ci_status_color(branch: str) -> tuple[str, str]:
+    """Shell out to `scripts/ci_status.py --json` to find the required-set color."""
+    script = REPO_ROOT / "scripts" / "ci_status.py"
+    if not script.exists():
+        return ("unknown", "ci_status.py not present — Phase A Step 6 not landed")
+    if shutil.which("gh") is None:
+        return ("unknown", "gh CLI not on PATH — cannot probe required-check set")
+    try:
+        proc = subprocess.run(
+            ["python3", str(script), "--branch", branch, "--json", "--no-phantom-resolve"],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+    except subprocess.TimeoutExpired:
+        return ("unknown", f"ci_status.py timed out probing branch {branch}")
+    if proc.returncode not in (0, 1):
+        return ("unknown", f"ci_status.py exit={proc.returncode}: {proc.stderr.strip()[:80]}")
+    try:
+        data = json.loads(proc.stdout or "{}")
+    except json.JSONDecodeError:
+        return ("unknown", "ci_status.py output not parseable as JSON")
+    if data.get("red"):
+        return ("red", f"{len(data['red'])} required check(s) red")
+    if data.get("missing"):
+        return ("amber", f"{len(data['missing'])} check(s) missing on {branch}")
+    return ("green", f"{len(data.get('green', []))} required check(s) green")
+
+
+def render_text(registry_counts: dict[str, int], reports: int, ci: tuple[str, str], branch: str) -> str:
+    color_emoji = {"green": "🟢", "amber": "🟡", "red": "🔴", "unknown": "⚪"}
+    lines = []
+    lines.append("Adoption status (one-screen)")
+    lines.append("============================")
+    lines.append("")
+    lines.append("Registry submissions:")
+    for status in STATUS_VALUES:
+        lines.append(f"  {status:10} {registry_counts[status]}")
+    lines.append("")
+    lines.append(f"Recruit-session reports filed: {reports}")
+    lines.append("")
+    lines.append(f"Required-check status on {branch}: {color_emoji[ci[0]]} {ci[0]} — {ci[1]}")
+    return "\n".join(lines)
+
+
+def render_json(registry_counts: dict[str, int], reports: int, ci: tuple[str, str], branch: str) -> str:
+    return json.dumps(
+        {
+            "registries": registry_counts,
+            "recruit_reports": reports,
+            "ci": {"branch": branch, "color": ci[0], "summary": ci[1]},
+        },
+        indent=2,
+    )
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    p = argparse.ArgumentParser(prog="adoption_status")
+    p.add_argument("--json", action="store_true", help="Emit JSON instead of text.")
+    p.add_argument("--branch", default="main", help="Branch to probe for CI color (default: main).")
+    return p.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+
+    try:
+        registry_text = REGISTRY_DOC.read_text(encoding="utf-8")
+    except OSError as exc:
+        print(f"error: failed to read {REGISTRY_DOC}: {exc}", file=sys.stderr)
+        return 1
+    registry_counts = parse_registry_statuses(registry_text)
+    reports = count_recruit_reports(RECRUIT_DIR)
+    ci = ci_status_color(args.branch)
+
+    if args.json:
+        print(render_json(registry_counts, reports, ci, args.branch))
+    else:
+        print(render_text(registry_counts, reports, ci, args.branch))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/ai-video/lib/parse-blueprint.sh

@@ -4,7 +4,7 @@
 # stdout. Pure POSIX-compatible bash (no associative arrays, runs
 # on macOS bash 3.2); jq required for JSON safety.
 #
-# Schema: .agent-src.uncompressed/skills/scene-expander/scene-blueprint.schema.yaml
+# Schema: .agent-src.uncondensed/skills/scene-expander/scene-blueprint.schema.yaml
 # Contract: scripts/ai-video/lib/adapter-contract.md
 #
 # Usage:

package/scripts/ai_council/advisors.py

@@ -13,7 +13,7 @@ This module owns:
 - `plan_advisor_swap()` — walks the enabled advisors, reads their
   persona files, and returns the per-provider plan map consumed by
   `orchestrator.consult()` / `estimate()` and by the CLI.
-- `resolve_persona_text()` — reads a persona file with compressed-tree
+- `resolve_persona_text()` — reads a persona file with condensed-tree
   preference and frontmatter strip.
 
 Cross-validation against the members block already ran at config load
@@ -75,14 +75,14 @@ def resolve_persona_text(
 ) -> tuple[str, dict]:
     """Read a persona file, returning ``(body, frontmatter)``.
 
-    Compressed tree (``.agent-src/``) wins so production runs match the
-    same projection the rest of the package consumes. Uncompressed tree
-    (``.agent-src.uncompressed/``) is the fallback for in-repo
+    Condensed tree (``.agent-src/``) wins so production runs match the
+    same projection the rest of the package consumes. Uncondensed tree
+    (``.agent-src.uncondensed/``) is the fallback for in-repo
     development before ``task sync`` has projected the file.
     """
     candidates = [
         repo_root / ".agent-src" / persona_path,
-        repo_root / ".agent-src.uncompressed" / persona_path,
+        repo_root / ".agent-src.uncondensed" / persona_path,
     ]
     for candidate in candidates:
         if candidate.exists():

package/scripts/ai_council/compile_corpus.py

@@ -8,7 +8,7 @@ through the hardened
 :func:`scripts.ai_council.low_impact_corpus.parse_corpus_strict`
 parser and writes a YAML lockfile that becomes the **runtime**
 source-of-truth. The pattern mirrors `.agent-src/` vs
-`.agent-src.uncompressed/`: human edits Markdown, `task consistency`
+`.agent-src.uncondensed/`: human edits Markdown, `task consistency`
 enforces lockfile parity via the same ``git diff --quiet`` gate.
 
 YAML schema (`schema_version: 1`)::

package/scripts/ai_council/one_off_archive/2026-05/_one_off_budget_v2_audit.py

@@ -40,8 +40,8 @@ REPO_ROOT = Path(__file__).resolve().parents[4]
 ARTEFACTS = [
     REPO_ROOT / "docs/contracts/load-context-budget-model.md",
     REPO_ROOT / "agents/settings/contexts/budget-v2-matrix.md",
-    REPO_ROOT / ".agent-src.uncompressed/rules/direct-answers.md",
-    REPO_ROOT / ".agent-src.uncompressed/rules/no-cheap-questions.md",
+    REPO_ROOT / ".agent-src.uncondensed/rules/direct-answers.md",
+    REPO_ROOT / ".agent-src.uncondensed/rules/no-cheap-questions.md",
 ]
 
 ORIGINAL_ASK = (
@@ -60,7 +60,7 @@ REVIEW_PROMPT = """\
 Phase 4 selected two 4d-trim paths from a fixed option set documented
 in `budget-v2-matrix.md`. The matrix evaluated 4a (demote→auto), 4b
 (merge), 4c (shared-context, locked at 3a Model (b) literal — no-op),
-and 4d (compress prose) for every touchable always-rule. Safety-floor
+and 4d (condense prose) for every touchable always-rule. Safety-floor
 rules (scope-control, non-destructive-by-default, commit-policy,
 agent-authority) were untouchable. Outcome-untested rules were
 restricted to 4d only per the Phase 4.0 inputs gate.

package/scripts/ai_council/one_off_archive/2026-05/_one_off_context_layer_v1_review.py

@@ -93,8 +93,8 @@ follow-ups Phase 1+2 closed) produced converging findings.
   too heavy — auditable but not consumable for normal feature work,
   needs complexity standard; (3) always-budget headroom 1,552 chars
   (96.8% utilization) — slimming hebel exhausted, new strategy needed
-  (demote / merge / hard-compress / shared-context amortization);
-  (4) slow-rollout protocol compressed under autonomy mandate;
+  (demote / merge / hard-condense / shared-context amortization);
+  (4) slow-rollout protocol condensed under autonomy mandate;
   (5) one-off scripts accumulating in scripts/ai_council/.
 - P0 before merge: PR description rewrite, one-off-script decision,
   honest budget block, Phase 2A as finding.

package/scripts/ai_council/one_off_archive/2026-05/_one_off_inject_quiet_flag.py

@@ -7,7 +7,7 @@ from pathlib import Path
 # Scripts that accept --quiet (verified: 20 total = 3 pre-existing + 17 patched).
 QUIET_AWARE = {
     "check_always_budget", "check_one_off_location", "check_safety_floor_untouched",
-    "check_augmentignore", "check_command_count_messaging", "check_compressed_paths",
+    "check_augmentignore", "check_command_count_messaging", "check_condensed_paths",
     "check_council_layout", "check_council_references", "check_iron_law_prominence",
     "check_md_language", "check_memory_proposal", "check_public_catalog_links",
     "check_reply_consistency", "check_roadmap_trackable",

package/scripts/ai_council/one_off_archive/2026-05/_one_off_measure_v2.sh

@@ -2,7 +2,7 @@
 # Phase 10.7 baseline — runs only verbosity-aware patched-script tasks.
 # Skips broken-on-dirty-tree tasks (consistency, check-index, validate-schema).
 # This subset is what actually demonstrates the --quiet effect.
-TASKS="check-compressed-paths check-refs check-portability lint-roadmap-complexity check-public-catalog-links check-command-count check-cluster-patterns lint-rule-interactions lint-load-context check-context-paths check-no-roadmap-refs check-council-references lint-one-off-age check-reply-consistency check-iron-law-prominence check-always-budget check-one-off-location lint-rule-budget lint-skills lint-rule-tiers lint-handoffs lint-marketplace lint-examples"
+TASKS="check-condensed-paths check-refs check-portability lint-roadmap-complexity check-public-catalog-links check-command-count check-cluster-patterns lint-rule-interactions lint-load-context check-context-paths check-no-roadmap-refs check-council-references lint-one-off-age check-reply-consistency check-iron-law-prominence check-always-budget check-one-off-location lint-rule-budget lint-skills lint-rule-tiers lint-handoffs lint-marketplace lint-examples"
 
 run() {
   local label=$1

package/scripts/ai_council/one_off_archive/2026-05/_one_off_measure_verbosity.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 # Phase 10.7 baseline measurement: post-consistency task ci subset.
-TASKS="counts-check check-index check-router check-compression check-compressed-paths check-refs check-token-optimizer-freshness check-portability check-examples-shape lint-roadmap-complexity check-public-links check-public-catalog-links check-command-count lint-no-new-atomic-commands check-cluster-patterns lint-rule-interactions lint-load-context check-context-paths check-no-roadmap-refs check-council-references lint-one-off-age check-ownership-matrix check-reply-consistency check-iron-law-prominence check-always-budget check-one-off-location validate-schema lint-rule-budget lint-skills lint-rule-tiers lint-handoffs lint-hook-manifest lint-showcase-sessions lint-marketplace"
+TASKS="counts-check check-index check-router check-condensation check-condensed-paths check-refs check-token-optimizer-freshness check-portability check-examples-shape lint-roadmap-complexity check-public-links check-public-catalog-links check-command-count lint-no-new-atomic-commands check-cluster-patterns lint-rule-interactions lint-load-context check-context-paths check-no-roadmap-refs check-council-references lint-one-off-age check-ownership-matrix check-reply-consistency check-iron-law-prominence check-always-budget check-one-off-location validate-schema lint-rule-budget lint-skills lint-rule-tiers lint-handoffs lint-hook-manifest lint-showcase-sessions lint-marketplace"
 
 echo "=== MINIMAL ==="
 AGENT_SCRIPT_VERBOSITY=minimal task $TASKS 2>&1 > /tmp/ci-min.log

package/scripts/ai_council/one_off_archive/2026-05/_one_off_nondestructive_inline_audit.py

@@ -41,8 +41,8 @@ from scripts.ai_council.session import SessionManifest, save as save_session
 
 REPO_ROOT = Path(__file__).resolve().parents[2]
 ARTEFACTS = [
-    REPO_ROOT / ".agent-src.uncompressed/rules/non-destructive-by-default.md",
-    REPO_ROOT / ".agent-src.uncompressed/contexts/authority/destructive-mechanics.md",
+    REPO_ROOT / ".agent-src.uncondensed/rules/non-destructive-by-default.md",
+    REPO_ROOT / ".agent-src.uncondensed/contexts/authority/destructive-mechanics.md",
 ]
 
 ORIGINAL_ASK = (
@@ -192,7 +192,7 @@ def main() -> int:
 
     manifest = SessionManifest(
         mode="files",
-        artefact=".agent-src.uncompressed/rules/non-destructive-by-default.md",
+        artefact=".agent-src.uncondensed/rules/non-destructive-by-default.md",
         original_ask=ORIGINAL_ASK,
         members=[f"{r.provider}/{r.model}" for r in final_round],
         rounds=len(rounds_collected),

package/scripts/ai_council/one_off_archive/2026-05/_one_off_per_task.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 TASKS=(
-  check-compressed-paths
+  check-condensed-paths
   check-refs
   check-portability
   lint-roadmap-complexity

package/scripts/ai_council/one_off_archive/2026-05/_one_off_phase6_trigger_jaccard.py

@@ -16,7 +16,7 @@ from itertools import combinations
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parent.parent
-RULES_DIR = ROOT / ".agent-src.uncompressed/rules"
+RULES_DIR = ROOT / ".agent-src.uncondensed/rules"
 
 RULES = [
     "chat-history-cadence",

package/scripts/ai_council/one_off_archive/2026-05/_one_off_phase_2a_budget_rebalance.py

@@ -45,12 +45,12 @@ from scripts.ai_council.session import SessionManifest, save as save_session
 REPO_ROOT = Path(__file__).resolve().parents[2]
 ARTEFACTS = [
     REPO_ROOT / "docs/contracts/load-context-budget-model.md",
-    REPO_ROOT / ".agent-src.uncompressed/rules/language-and-tone.md",
-    REPO_ROOT / ".agent-src.uncompressed/rules/ask-when-uncertain.md",
-    REPO_ROOT / ".agent-src.uncompressed/rules/direct-answers.md",
-    REPO_ROOT / ".agent-src.uncompressed/contexts/communication/rules-always/language-and-tone-mechanics.md",
-    REPO_ROOT / ".agent-src.uncompressed/contexts/communication/rules-always/ask-when-uncertain-mechanics.md",
-    REPO_ROOT / ".agent-src.uncompressed/contexts/communication/rules-always/direct-answers-mechanics.md",
+    REPO_ROOT / ".agent-src.uncondensed/rules/language-and-tone.md",
+    REPO_ROOT / ".agent-src.uncondensed/rules/ask-when-uncertain.md",
+    REPO_ROOT / ".agent-src.uncondensed/rules/direct-answers.md",
+    REPO_ROOT / ".agent-src.uncondensed/contexts/communication/rules-always/language-and-tone-mechanics.md",
+    REPO_ROOT / ".agent-src.uncondensed/contexts/communication/rules-always/ask-when-uncertain-mechanics.md",
+    REPO_ROOT / ".agent-src.uncondensed/contexts/communication/rules-always/direct-answers-mechanics.md",
 ]
 
 ORIGINAL_ASK = (

package/scripts/ai_council/one_off_archive/2026-05/_one_off_rebalancing_audit.py

@@ -37,7 +37,7 @@ Rebalancing means restoring intelligence without re-inflating Always-rules.
 
 ## Actual numbers from the PR #34 diff
 
-Scope: git diff origin/main...HEAD, path .agent-src.uncompressed/rules/
+Scope: git diff origin/main...HEAD, path .agent-src.uncondensed/rules/
 
 - 35 files changed: 202 insertions, 204 deletions => net -2 lines total.
 - Largest delta: language-and-tone.md 37 ins / 96 del. The 96 lines were

package/scripts/ai_council/one_off_archive/2026-05/_one_off_tier_retrofit.py

@@ -3,7 +3,7 @@
 
 Parses agents/settings/contexts/rule-trigger-matrix.md, emits tmp/tier-classification.md,
 and inserts a `tier:` frontmatter key into every rule under
-.agent-src.uncompressed/rules/. Idempotent — re-runs are a no-op when a rule
+.agent-src.uncondensed/rules/. Idempotent — re-runs are a no-op when a rule
 already declares the same tier value.
 
 Lifecycle: scripts/_one_off/2026-05/. Purge eligible after 2026-08-04 per
@@ -17,8 +17,8 @@ from pathlib import Path
 
 REPO = Path(__file__).resolve().parents[3]
 MATRIX = REPO / "agents" / "contexts" / "rule-trigger-matrix.md"
-RULES_DIR = REPO / ".agent-src.uncompressed" / "rules"
-COMPRESSED_RULES_DIR = REPO / ".agent-src" / "rules"
+RULES_DIR = REPO / ".agent-src.uncondensed" / "rules"
+CONDENSED_RULES_DIR = REPO / ".agent-src" / "rules"
 SPREADSHEET = REPO / "tmp" / "tier-classification.md"
 
 VALID_TIERS = {"1", "2a", "2b", "3", "safety-floor", "mechanical-already"}
@@ -161,9 +161,9 @@ def main() -> int:
     for name, (tier, _) in classifications.items():
         result = apply_tier(RULES_DIR / name, tier)
         counts[result] += 1
-        compressed = COMPRESSED_RULES_DIR / name
-        if compressed.exists():
-            mirror_counts[apply_tier(compressed, tier)] += 1
+        condensed = CONDENSED_RULES_DIR / name
+        if condensed.exists():
+            mirror_counts[apply_tier(condensed, tier)] += 1
         else:
             mirror_counts["skipped"] += 1
     print(