@event4u/agent-config 3.3.0 → 4.2.0

package/scripts/bench_ab_tracka_run.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""Track A — behavioural eval runner for the package-impact A/B bench.
+
+Phase 3 Step 2 of `agents/roadmaps/road-to-package-impact-benchmark.md`.
+
+For each prompt in `internal/bench/corpora/ab-tracka.yaml`, check whether
+the expected rule/skill surface is present in the target clone. Present +
+keyword-grep passing → trigger fires. Absent → trigger does not fire.
+
+By construction the `without` clone has no agent-config surface — every
+expected_target file is missing — so its accuracy floor is 0%. The `with`
+clone has the surface installed and should score near 100%. The delta is
+the lift attributable to the package.
+
+This runner does NOT invoke `claude` — Track A measures **surface
+availability**, the necessary precondition for the rule-router to fire.
+Track B (Phase 4) measures actual end-to-end task behaviour.
+
+Output schema (consumed by bench_ab_diff.py):
+
+    results:
+      trigger_accuracy: 0.0 .. 1.0          # share of prompts that scored 1
+      false_positives: int                  # `without` matches (expected = 0)
+      per_rule_accuracy:                    # per-target hit map
+        <expected_target>: {with: 0|1, without: 0|1}
+      per_prompt:                           # full audit trail
+        - id, expected_target, with_score, without_score, notes
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(REPO_ROOT / "scripts"))
+
+from _lib import bench_ab_cache  # type: ignore[import-not-found]  # noqa: E402
+
+CORPUS_PATH = REPO_ROOT / "internal" / "bench" / "corpora" / "ab-tracka.yaml"
+CLONES_DIR = REPO_ROOT / "internal" / "bench" / "ab" / "clones"
+REPORTS_DIR = REPO_ROOT / "internal" / "bench" / "reports" / "ab"
+
+try:
+    import yaml
+except ImportError:
+    sys.stderr.write("bench_ab_tracka_run: PyYAML required (pip install pyyaml)\n")
+    raise SystemExit(2)
+
+
+def utc_stamp() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H-%M-%SZ")
+
+
+def load_corpus() -> dict:
+    return yaml.safe_load(CORPUS_PATH.read_text())
+
+
+def score_prompt(prompt: dict, clone_root: Path) -> tuple[int, str]:
+    """Return (score, reason). score=1 when the surface is present AND every keyword hits."""
+    target_rel = prompt.get("expected_target")
+    if not target_rel:
+        return 0, "no expected_target"
+    target = clone_root / target_rel
+    if not target.exists():
+        return 0, f"missing: {target_rel}"
+    keywords = prompt.get("expected_keywords") or []
+    if not isinstance(keywords, list) or not keywords:
+        # Surface presence alone counts when no keywords specified.
+        return 1, "present (no keywords)"
+    body = target.read_text(errors="replace")
+    missing = [kw for kw in keywords if not re.search(re.escape(str(kw)), body, re.IGNORECASE)]
+    if missing:
+        return 0, f"keywords missing: {','.join(missing)}"
+    return 1, "present (keywords matched)"
+
+
+def run_variant(variant: str, prompts: list[dict]) -> dict:
+    clone_root = CLONES_DIR / variant
+    if not clone_root.exists():
+        raise RuntimeError(
+            f"clone missing at {clone_root} — run scripts/bench_ab_clone.py first"
+        )
+    per_prompt = []
+    per_target: dict[str, int] = {}
+    matched = 0
+    for prompt in prompts:
+        score, reason = score_prompt(prompt, clone_root)
+        per_prompt.append(
+            {
+                "id": prompt.get("id"),
+                "expected_target": prompt.get("expected_target"),
+                "score": score,
+                "reason": reason,
+            }
+        )
+        per_target[prompt.get("expected_target", "")] = max(
+            per_target.get(prompt.get("expected_target", ""), 0), score
+        )
+        matched += score
+    total = len(prompts) or 1
+    return {
+        "trigger_accuracy": round(matched / total, 4),
+        "matched": matched,
+        "total": total,
+        "per_target_present": per_target,
+        "per_prompt": per_prompt,
+    }
+
+
+def integrity_check(without_results: dict) -> tuple[bool, str]:
+    """Track A safety: `without` MUST score 0 — there is no agent-config surface
+    to match. A non-zero score means the integrity boundary leaked and the run
+    is invalid.
+    """
+    matched = without_results.get("matched", 0)
+    if matched != 0:
+        # Identify which prompts leaked
+        leaked = [p["id"] for p in without_results.get("per_prompt", []) if p.get("score")]
+        return False, f"`without` scored {matched} (expected 0); leaked: {','.join(leaked)}"
+    return True, "without=0 (clean)"
+
+
+def write_report(variant: str, results: dict, duration: float, *, integrity_ok: bool) -> Path:
+    REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+    cache_key = bench_ab_cache.CacheKey(
+        corpus_hash=bench_ab_cache.hash_file(CORPUS_PATH),
+        claude_cli_version=bench_ab_cache.claude_cli_version(),
+        target_shape_hash=bench_ab_cache.target_shape_hash(),
+    )
+    stamp = utc_stamp()
+    payload = {
+        "schema": "ab-bench/0.1",
+        "stamp": stamp,
+        "variant": variant,
+        "corpus": "ab-tracka",
+        "cache_key": cache_key.to_dict(),
+        "duration_seconds": round(duration, 3),
+        "integrity_ok": integrity_ok,
+        "results": results,
+    }
+    path = REPORTS_DIR / f"{stamp}-ab-tracka-{variant}.json"
+    path.write_text(json.dumps(payload, indent=2) + "\n")
+    md = path.with_suffix(".md")
+    md.write_text(
+        f"# Track A · {variant}\n\n"
+        f"- Stamp: `{stamp}`\n"
+        f"- Trigger accuracy: **{results.get('trigger_accuracy', 0) * 100:.1f}%**"
+        f" ({results.get('matched', 0)}/{results.get('total', 0)})\n"
+        f"- Integrity OK: `{integrity_ok}`\n"
+    )
+    return path
+
+
+def parse_args(argv: list[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run Track A behavioural eval per variant.")
+    parser.add_argument(
+        "--variant",
+        choices=("with", "without", "both"),
+        default="both",
+        help="Which variant to run (default: both).",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv if argv is not None else sys.argv[1:])
+    if not CORPUS_PATH.exists():
+        sys.stderr.write(f"bench_ab_tracka_run: corpus missing at {CORPUS_PATH}\n")
+        return 1
+    data = load_corpus()
+    prompts = data.get("prompts") or []
+    if not prompts:
+        sys.stderr.write("bench_ab_tracka_run: corpus has no prompts\n")
+        return 1
+
+    variants = ("with", "without") if args.variant == "both" else (args.variant,)
+    integrity_ok = True
+    for variant in variants:
+        started = time.monotonic()
+        results = run_variant(variant, prompts)
+        duration = time.monotonic() - started
+        if variant == "without":
+            ok, reason = integrity_check(results)
+            integrity_ok = ok
+            if not ok:
+                sys.stderr.write(f"bench_ab_tracka_run: integrity failure — {reason}\n")
+        path = write_report(variant, results, duration, integrity_ok=integrity_ok)
+        sys.stdout.write(
+            f"bench_ab_tracka_run: {variant} → "
+            f"{results['trigger_accuracy'] * 100:.1f}% "
+            f"({results['matched']}/{results['total']}) — {path.relative_to(REPO_ROOT)}\n"
+        )
+    return 0 if integrity_ok else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/{bench_compress_memory.py → bench_condense_memory.py}

@@ -1,12 +1,12 @@
 #!/usr/bin/env python3
-"""Offline bench for input-side memory compression (Phase 2 / Step 11).
+"""Offline bench for input-side memory condensation (Phase 2 / Step 11).
 
-Runs `compress_memory.py` over a fixed corpus of memory-target files, records
+Runs `condense_memory.py` over a fixed corpus of memory-target files, records
 pre/post char counts, approximates input-token savings (chars / 4 — the
-GPT-4 / Claude rule of thumb), and emits `internal/bench/reports/caveman-v2.{json,md}`.
+GPT-4 / Claude rule of thumb), and emits `internal/bench/reports/telegraph-v2.{json,md}`.
 
 Offline (no API calls). Cadence-aligned with `docs/benchmarks.md`. Citation
-in `internal/bench/reports/caveman-v2.md` notes the chars→tokens approximation and
+in `internal/bench/reports/telegraph-v2.md` notes the chars→tokens approximation and
 points at upstream tiktoken / claude-tokenizer if a calibrated number is
 later needed.
 """
@@ -22,13 +22,13 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
-COMPRESS_SCRIPT = REPO_ROOT / "scripts" / "compress_memory.py"
-REPORT_JSON = REPO_ROOT / "internal" / "bench" / "reports" / "caveman-v2.json"
-REPORT_MD = REPO_ROOT / "internal" / "bench" / "reports" / "caveman-v2.md"
+CONDENSE_SCRIPT = REPO_ROOT / "scripts" / "condense_memory.py"
+REPORT_JSON = REPO_ROOT / "internal" / "bench" / "reports" / "telegraph-v2.json"
+REPORT_MD = REPO_ROOT / "internal" / "bench" / "reports" / "telegraph-v2.md"
 
 CORPUS: list[tuple[str, str]] = [
     ("AGENTS.md", "thin-root-package"),
-    (".agent-src.uncompressed/templates/AGENTS.md", "thin-root-consumer-template"),
+    (".agent-src.uncondensed/templates/AGENTS.md", "thin-root-consumer-template"),
     (".agent-src/templates/AGENTS.md", "thin-root-consumer-generated"),
     ("docs/contracts/ai-council-config.md", "prose-heavy-contract"),
     ("docs/contracts/implement-ticket-flow.md", "prose-heavy-contract"),
@@ -56,7 +56,7 @@ def bench_one(rel_path: str, category: str) -> dict:
         shutil.copy(src, target)
         before_chars = target.stat().st_size
         result = subprocess.run(
-            [sys.executable, str(COMPRESS_SCRIPT), str(target)],
+            [sys.executable, str(CONDENSE_SCRIPT), str(target)],
             capture_output=True, text=True, cwd=REPO_ROOT,
         )
         if result.returncode != 0:
@@ -101,11 +101,11 @@ def aggregate(rows: list[dict]) -> dict:
 def render_md(payload: dict) -> str:
     agg = payload["aggregate"]
     lines = [
-        "# caveman-v2 — input-side memory compression bench",
+        "# telegraph-v2 — input-side memory condensation bench",
         "",
         f"**Generated:** {payload['generated_at']}",
-        f"**Schema:** `caveman-v2` (input-side; offline; chars→tokens via /4 heuristic)",
-        f"**Script:** `scripts/bench_compress_memory.py`",
+        f"**Schema:** `telegraph-v2` (input-side; offline; chars→tokens via /4 heuristic)",
+        f"**Script:** `scripts/bench_condense_memory.py`",
         "",
         "## Headline",
         "",
@@ -134,13 +134,13 @@ def render_md(payload: dict) -> str:
             )
     lines += ["", "## Methodology",
               "",
-              "- Offline run: `compress_memory.py` writes `.original.md` backup + frontmatter (`original_sha256`, `compressed_at`). The frontmatter pair (≈ 120 chars) is the fixed compression tax — files with little prose net negative.",
+              "- Offline run: `condense_memory.py` writes `.original.md` backup + frontmatter (`original_sha256`, `condensed_at`). The frontmatter pair (≈ 120 chars) is the fixed condensation tax — files with little prose net negative.",
               "- chars → tokens approximation: `tokens ≈ chars / 4` (GPT-4 / Claude English rule of thumb). Calibrated number requires `tiktoken` or `claude-tokenizer`; deferred until a consumer requests pinpoint numbers.",
-              "- The `caveman-v1` output-side verdict (`vs_terse` median −9.27%) is orthogonal — input-side savings apply to the always-loaded memory budget, not the reply stream.",
+              "- The `telegraph-v1` output-side verdict (`vs_terse` median −9.27%) is orthogonal — input-side savings apply to the always-loaded memory budget, not the reply stream.",
               "",
               "## Interpretation",
               "",
-              "- **Thin-Root files net negative.** `AGENTS.md` and `templates/AGENTS.md` already follow `agents-md-thin-root` (≥ 40 % pointer ratio). The compressor's frontmatter pair adds more bytes than the sparse prose loses. **Do not compress Thin-Root files.**",
+              "- **Thin-Root files net negative.** `AGENTS.md` and `templates/AGENTS.md` already follow `agents-md-thin-root` (≥ 40 % pointer ratio). The condenseor's frontmatter pair adds more bytes than the sparse prose loses. **Do not condense Thin-Root files.**",
               "- **Prose-heavy contract docs net 3–6 % saving.** Useful but modest. Pays off when the file is large and frequently loaded.",
               "- **Rule of thumb:** target files with > 5 KB and visible paragraph prose; skip pointer-only files.",
               ""]
@@ -151,7 +151,7 @@ def main() -> int:
     rows = [bench_one(p, c) for p, c in CORPUS]
     payload = {
         "generated_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
-        "schema": "caveman-v2",
+        "schema": "telegraph-v2",
         "rows": rows,
         "aggregate": aggregate(rows),
     }

package/scripts/bench_run.py

@@ -34,8 +34,8 @@ from _lib.bench_report import (  # noqa: E402
     write_json,
     write_markdown,
 )
-from _lib import bench_caveman  # noqa: E402
-from _lib.bench_caveman_report import build_caveman_report, render_caveman_markdown  # noqa: E402
+from _lib import bench_telegraph  # noqa: E402
+from _lib.bench_telegraph_report import build_telegraph_report, render_telegraph_markdown  # noqa: E402
 from _lib.bench_cost import load_pricing  # noqa: E402
 from bench_runner import run_corpus  # noqa: E402
 
@@ -50,7 +50,7 @@ PRICING_PATH = REPO_ROOT / "internal" / "bench" / "pricing.yaml"
 SESSIONS_JSONL = REPO_ROOT / "agents" / "cost-tracking" / "sessions.jsonl"
 REPORTS_DIR = REPO_ROOT / "internal" / "bench" / "reports"
 CORPUS_DIR = REPO_ROOT / "tests" / "eval"
-CAVEMAN_CORPUS = REPO_ROOT / "internal" / "bench" / "corpora" / "caveman" / "prompts.yaml"
+TELEGRAPH_CORPUS = REPO_ROOT / "internal" / "bench" / "corpora" / "telegraph" / "prompts.yaml"
 BASELINE_COLLECTOR = REPO_ROOT / "scripts" / "bench_runner.py"
 
 
@@ -115,20 +115,20 @@ def main(argv: list[str] | None = None) -> int:
                     help="Override timestamp (test hook); defaults to UTC now")
     ap.add_argument("--no-write", action="store_true",
                     help="Compute the report but do not write files (dry run)")
-    ap.add_argument("--caveman", action="store_true",
-                    help="Run the caveman three-arm compression bench instead of the "
+    ap.add_argument("--telegraph", action="store_true",
+                    help="Run the telegraph three-arm condensation bench instead of the "
                          "selection-accuracy bench (step-16 Phase 1).")
-    ap.add_argument("--caveman-max-prompts", type=int, default=None,
-                    help="Cap prompts in the caveman bench (smoke test).")
-    ap.add_argument("--caveman-dry-run", action="store_true",
-                    help="Caveman: skip live API calls; emit a stub report with "
+    ap.add_argument("--telegraph-max-prompts", type=int, default=None,
+                    help="Cap prompts in the telegraph bench (smoke test).")
+    ap.add_argument("--telegraph-dry-run", action="store_true",
+                    help="Telegraph: skip live API calls; emit a stub report with "
                          "zero tokens (wiring check only).")
-    ap.add_argument("--caveman-report-tag", default="caveman-v1",
-                    help="Filename tag for the caveman report (default: caveman-v1).")
+    ap.add_argument("--telegraph-report-tag", default="telegraph-v1",
+                    help="Filename tag for the telegraph report (default: telegraph-v1).")
     args = ap.parse_args(argv)
 
-    if args.caveman:
-        return _run_caveman(args)
+    if args.telegraph:
+        return _run_telegraph(args)
 
     corpus_path = CORPUS_DIR / f"corpus-{args.corpus}.yaml"
     if not corpus_path.is_file():
@@ -170,7 +170,7 @@ def main(argv: list[str] | None = None) -> int:
 
 
 class _DryRunClient:
-    """Stub client for --caveman-dry-run. Returns empty CouncilResponse-shaped objects."""
+    """Stub client for --telegraph-dry-run. Returns empty CouncilResponse-shaped objects."""
 
     def ask(self, system_prompt: str, user_prompt: str, max_tokens: int = 1024):
         from ai_council.clients import CouncilResponse
@@ -185,12 +185,12 @@ def _build_anthropic_client():
     return AnthropicClient(api_key=load_anthropic_key())
 
 
-def _run_caveman(args: argparse.Namespace) -> int:
-    if not CAVEMAN_CORPUS.is_file():
-        script_output.error(f"error: caveman corpus not found: {CAVEMAN_CORPUS}")
+def _run_telegraph(args: argparse.Namespace) -> int:
+    if not TELEGRAPH_CORPUS.is_file():
+        script_output.error(f"error: telegraph corpus not found: {TELEGRAPH_CORPUS}")
         return 2
 
-    if args.caveman_dry_run:
+    if args.telegraph_dry_run:
         client = _DryRunClient()
         transport = "dry-run"
         model = "stub"
@@ -211,18 +211,18 @@ def _run_caveman(args: argparse.Namespace) -> int:
               f"in={ar.input_tokens:>4} out={ar.output_tokens:>4} "
               f"{ar.latency_ms:>5}ms{err}", file=sys.stderr)
 
-    results = bench_caveman.run_caveman_bench(
-        client, CAVEMAN_CORPUS,
-        max_prompts=args.caveman_max_prompts,
+    results = bench_telegraph.run_telegraph_bench(
+        client, TELEGRAPH_CORPUS,
+        max_prompts=args.telegraph_max_prompts,
         on_progress=_progress,
     )
 
     rates, sourced_on = load_pricing(PRICING_PATH)
     sonnet_rates = rates.get("sonnet", {"input": 0.0, "output": 0.0})
 
-    report = build_caveman_report(
+    report = build_telegraph_report(
         results=results,
-        corpus_path_rel=str(CAVEMAN_CORPUS.relative_to(REPO_ROOT)),
+        corpus_path_rel=str(TELEGRAPH_CORPUS.relative_to(REPO_ROOT)),
         generated_at=utc_now_iso(),
         bench_run_version=BENCH_RUN_VERSION,
         model=model,
@@ -232,27 +232,27 @@ def _run_caveman(args: argparse.Namespace) -> int:
     )
 
     stamp = args.stamp or utc_now_filename_stamp()
-    json_path, md_path = report_paths(REPORTS_DIR, args.caveman_report_tag, stamp)
-    # Override: caveman roadmap pins the filename to `caveman-v1.{json,md}` (no stamp).
-    fixed_json = REPORTS_DIR / f"{args.caveman_report_tag}.json"
-    fixed_md = REPORTS_DIR / f"{args.caveman_report_tag}.md"
+    json_path, md_path = report_paths(REPORTS_DIR, args.telegraph_report_tag, stamp)
+    # Override: telegraph roadmap pins the filename to `telegraph-v1.{json,md}` (no stamp).
+    fixed_json = REPORTS_DIR / f"{args.telegraph_report_tag}.json"
+    fixed_md = REPORTS_DIR / f"{args.telegraph_report_tag}.md"
 
     if not args.no_write:
         write_json(fixed_json, report)
         fixed_md.parent.mkdir(parents=True, exist_ok=True)
-        fixed_md.write_text(render_caveman_markdown(report), encoding="utf-8")
+        fixed_md.write_text(render_telegraph_markdown(report), encoding="utf-8")
         # Also drop a timestamped copy for the cadence trail.
         write_json(json_path, report)
         json_path.with_suffix(".md").write_text(
-            render_caveman_markdown(report), encoding="utf-8"
+            render_telegraph_markdown(report), encoding="utf-8"
         )
 
     cost = report["cost"]
     headline = (
-        f"caveman · prompts {report['corpus']['prompt_count']} · "
+        f"telegraph · prompts {report['corpus']['prompt_count']} · "
         f"calls {cost['totals']['calls']} · errors {cost['totals']['errors']} · "
-        f"vs_raw med {report['caveman']['aggregate']['savings_vs_raw']['median']:.2%} · "
-        f"vs_terse med {report['caveman']['aggregate']['savings_vs_terse']['median']:.2%} · "
+        f"vs_raw med {report['telegraph']['aggregate']['savings_vs_raw']['median']:.2%} · "
+        f"vs_terse med {report['telegraph']['aggregate']['savings_vs_terse']['median']:.2%} · "
         f"cost ${cost['totals']['total_cost_usd']:.6f}"
     )
     if args.quiet:
@@ -260,7 +260,7 @@ def _run_caveman(args: argparse.Namespace) -> int:
         if not args.no_write:
             print(f"report: {fixed_md.relative_to(REPO_ROOT)}")
     else:
-        print(render_caveman_markdown(report))
+        print(render_telegraph_markdown(report))
         if not args.no_write:
             print(f"\n→ json:     {fixed_json.relative_to(REPO_ROOT)}")
             print(f"→ markdown: {fixed_md.relative_to(REPO_ROOT)}")

package/scripts/bench_runner.py

@@ -2,7 +2,7 @@
 """Bench runner for the eval corpora — step-4 measurement-and-benchmark Phase 1.
 
 Deterministic, no-API skill-selection baseline. For each prompt in a
-corpus YAML, ranks the 210 skills in `.agent-src.uncompressed/skills/`
+corpus YAML, ranks the 210 skills in `.agent-src.uncondensed/skills/`
 by keyword overlap between the prompt text and each skill's
 `description` frontmatter field. Reports selection accuracy as
 `top-K contains >= 1 expected_skill`.
@@ -33,7 +33,7 @@ except ImportError:
     sys.exit(2)
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
-SKILLS_DIR = REPO_ROOT / ".agent-src.uncompressed" / "skills"
+SKILLS_DIR = REPO_ROOT / ".agent-src.uncondensed" / "skills"
 CORPUS_DIR = REPO_ROOT / "tests" / "eval"
 
 STOPWORDS = frozenset({

package/scripts/bootstrap.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+# bootstrap.sh — Thin Bash entry for the v4 unified setup wizard.
+#
+# road-to-unified-setup § C1. Replaces the legacy Python boot path.
+# Flow:
+#   1. Verify Node ≥ 20.11.0 (the package engines bound).
+#   2. Launch `npx @event4u/agent-config <subcommand>` in the background.
+#   3. Tail stdout for the `WIZARD_READY <url>` marker (Phase B4).
+#   4. Open the URL in the user's browser (best-effort; no fatal error
+#      when no `open` / `xdg-open` is available — print the URL instead).
+#   5. Wait for the server process so Ctrl-C tears the wizard down cleanly.
+#
+# Usage:
+#   scripts/bootstrap.sh install        # default — install wizard
+#   scripts/bootstrap.sh setup
+#   scripts/bootstrap.sh setup --no-extended
+#   AGENT_CONFIG_NO_OPEN=1 scripts/bootstrap.sh install   # CI / headless
+#
+# Exit codes:
+#   0 — wizard process exited cleanly
+#   1 — Node missing or below the engines bound
+#   2 — WIZARD_READY did not arrive within 30 seconds
+#   3 — npx invocation failed before the marker
+set -euo pipefail
+
+MIN_NODE_MAJOR=20
+MIN_NODE_MINOR=11
+TIMEOUT_SECONDS=30
+SUBCOMMAND="${1:-install}"
+shift || true
+
+if ! command -v node >/dev/null 2>&1; then
+    echo "error: Node.js not found in PATH (need ≥ ${MIN_NODE_MAJOR}.${MIN_NODE_MINOR}.0)." >&2
+    echo "install Node first — https://nodejs.org/" >&2
+    exit 1
+fi
+
+NODE_VERSION="$(node -p 'process.versions.node')"
+NODE_MAJOR="${NODE_VERSION%%.*}"
+NODE_MINOR="$(node -p 'process.versions.node.split(".")[1]')"
+if [ "${NODE_MAJOR}" -lt "${MIN_NODE_MAJOR}" ] \
+   || { [ "${NODE_MAJOR}" -eq "${MIN_NODE_MAJOR}" ] && [ "${NODE_MINOR}" -lt "${MIN_NODE_MINOR}" ]; }; then
+    echo "error: Node ${NODE_VERSION} is below the required ${MIN_NODE_MAJOR}.${MIN_NODE_MINOR}.0." >&2
+    exit 1
+fi
+
+PIPE="$(mktemp -u "${TMPDIR:-/tmp}/agent-config-bootstrap.XXXXXX")"
+mkfifo "${PIPE}"
+trap 'rm -f "${PIPE}"' EXIT
+
+# Always pass --no-open here — the bootstrap script owns the browser
+# launch so it can defer it until after WIZARD_READY arrives.
+npx --yes @event4u/agent-config "${SUBCOMMAND}" --no-open "$@" >"${PIPE}" 2>&1 &
+NPX_PID=$!
+
+URL=""
+DEADLINE=$(( $(date +%s) + TIMEOUT_SECONDS ))
+while IFS= read -r line; do
+    printf '%s\n' "${line}"
+    if [[ "${line}" == WIZARD_READY\ * ]]; then
+        URL="${line#WIZARD_READY }"
+        break
+    fi
+    if [ "$(date +%s)" -ge "${DEADLINE}" ]; then
+        echo "error: WIZARD_READY did not arrive within ${TIMEOUT_SECONDS}s." >&2
+        kill "${NPX_PID}" 2>/dev/null || true
+        exit 2
+    fi
+done <"${PIPE}" &
+READER_PID=$!
+
+# If npx died before we saw the marker, surface the failure.
+if ! kill -0 "${NPX_PID}" 2>/dev/null; then
+    wait "${READER_PID}" || true
+    echo "error: npx exited before WIZARD_READY arrived." >&2
+    exit 3
+fi
+
+wait "${READER_PID}" || true
+
+if [ -z "${URL}" ]; then
+    echo "error: server did not emit WIZARD_READY." >&2
+    kill "${NPX_PID}" 2>/dev/null || true
+    exit 2
+fi
+
+if [ -z "${AGENT_CONFIG_NO_OPEN:-}" ]; then
+    if command -v open >/dev/null 2>&1; then
+        open "${URL}" || true
+    elif command -v xdg-open >/dev/null 2>&1; then
+        xdg-open "${URL}" >/dev/null 2>&1 || true
+    else
+        echo "info: open the wizard manually: ${URL}"
+    fi
+fi
+
+# Keep streaming stdout so the user sees server logs until Ctrl-C.
+cat "${PIPE}" &
+wait "${NPX_PID}"

package/scripts/build_cloud_bundle.py

@@ -15,7 +15,7 @@ Customize → Skills). One ZIP per skill, sandbox-friendly.
 - Optional siblings: `references/`, `assets/`, `scripts/`, `evals/`
   (only the first three are bundled; `evals/` is local-tooling-only)
 - Tier classification from `audit_cloud_compatibility.py` (matched by
-  skill basename — uncompressed and compressed share names)
+  skill basename — uncondensed and condensed share names)
 
 ## Outputs
 
@@ -58,7 +58,7 @@ ships only the cloud-side instructions, not the full local rule.
 ## Sandbox path-swap
 
 Body text is preprocessed:
-- Literal `.agent-src.uncompressed/` and `.agent-src/` → `source/` note
+- Literal `.agent-src.uncondensed/` and `.agent-src/` → `source/` note
 - Literal `agents/` (path prefix only, not prose) → `(local-only)` note
 - Cloud header prepended explaining the constraint
 
@@ -114,13 +114,13 @@ MARKER_LINE_RE = re.compile(
 # Body preprocessing — sandbox path-swap.
 #
 # Scope: only package-internal prefixes that are unreachable from a cloud
-# sandbox (`.agent-src.uncompressed/`, `.agent-src/`). `agents/` is left
+# sandbox (`.agent-src.uncondensed/`, `.agent-src/`). `agents/` is left
 # unchanged — it lives in the user's repo, the SANDBOX_NOTE header
 # already tells the agent the host has no access.
 PATH_SWAP_PATTERNS = [
-    (re.compile(r"`\.agent-src\.uncompressed/"), "`<package-source>/"),
+    (re.compile(r"`\.agent-src\.uncondensed/"), "`<package-source>/"),
     (re.compile(r"`\.agent-src/"), "`<package-source>/"),
-    (re.compile(r"\(\.agent-src\.uncompressed/"), "(<package-source>/"),
+    (re.compile(r"\(\.agent-src\.uncondensed/"), "(<package-source>/"),
     (re.compile(r"\(\.agent-src/"), "(<package-source>/"),
 ]
 
@@ -158,7 +158,7 @@ def load_tier_map() -> dict[str, dict]:
     for row in audit.scan():
         if row["kind"] != "skills":
             continue
-        # row["path"] = .agent-src.uncompressed/skills/<name>/SKILL.md
+        # row["path"] = .agent-src.uncondensed/skills/<name>/SKILL.md
         parts = Path(row["path"]).parts
         if len(parts) >= 3:
             tier_map[parts[2]] = {

package/scripts/build_discovery_manifest.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Release-time discovery scanner — produces discovery-manifest.json.
 
-Walks the trusted-root tree (`.agent-src.uncompressed/`), extracts the
+Walks the trusted-root tree (`.agent-src.uncondensed/`), extracts the
 five Phase-4 frontmatter keys (`workspaces`, `packs`, `lifecycle`,
 `trust`, `install`), validates each value against the closed vocabulary
 in `config/discovery/*.yml`, and emits a deterministic JSON manifest
@@ -29,7 +29,7 @@ from validate_frontmatter import _FRONTMATTER_RE, parse_frontmatter  # noqa: E40
 from _lib.agent_src import artefact_roots, logical_relpath, resolve_logical, strip_source_prefix  # noqa: E402
 
 ROOT = Path(__file__).resolve().parents[1]
-SRC = ROOT / ".agent-src.uncompressed"
+SRC = ROOT / ".agent-src.uncondensed"
 VOCAB_DIR = ROOT / "config" / "discovery"
 DEFAULT_OUT = ROOT / "dist" / "discovery" / "discovery-manifest.json"
 DEFAULT_SUMMARY = ROOT / "dist" / "discovery" / "discovery-manifest.summary.md"
@@ -38,7 +38,7 @@ DEFAULT_TRUST_REPORT = ROOT / "dist" / "discovery" / "trust-report.md"
 DEFAULT_ORPHAN_REPORT = ROOT / "dist" / "discovery" / "orphan-report.md"
 DEFAULT_WORKSPACES_JSON = ROOT / "dist" / "discovery" / "workspaces.json"
 DEFAULT_PACKS_JSON = ROOT / "dist" / "discovery" / "packs.json"
-TRUST_ROOTS = (".agent-src.uncompressed", ".augment", ".claude", ".agent-src", "packages")
+TRUST_ROOTS = (".agent-src.uncondensed", ".augment", ".claude", ".agent-src", "packages")
 
 _FM_KEYS = ("workspaces", "packs", "lifecycle", "trust", "install")
 _TRUST_REQ = ("level", "confidence", "human_review_required")
@@ -55,8 +55,8 @@ def _load_yaml(path: Path) -> Any:
 def _vocab() -> tuple[list[dict[str, Any]], list[dict[str, Any]], dict[str, str]]:
     """Load discovery vocab. ``overrides`` keys are normalised to the
     *current* physical repo-relative path, regardless of whether the YAML
-    lists the legacy ``.agent-src.uncompressed/...`` prefix or a
-    ``packages/*/.agent-src.uncompressed/...`` prefix. The lookup site
+    lists the legacy ``.agent-src.uncondensed/...`` prefix or a
+    ``packages/*/.agent-src.uncondensed/...`` prefix. The lookup site
     (``_build``) compares against physical paths emitted by
     ``_iter_artefacts``.
     """
@@ -113,8 +113,8 @@ def _artefact_checksum(path: Path, fm: dict[str, Any] | None) -> str:
 def _iter_artefacts() -> Iterable[tuple[Path, str]]:
     """Deterministic order: skills → rules → commands → templates.
 
-    Walks every source root (legacy ``.agent-src.uncompressed/`` plus any
-    ``packages/*/.agent-src.uncompressed/``) so the manifest survives the
+    Walks every source root (legacy ``.agent-src.uncondensed/`` plus any
+    ``packages/*/.agent-src.uncondensed/``) so the manifest survives the
     physical move (ADR-017). Within each category, paths are sorted by
     their *logical* identity to keep ordering stable across moves.
     """