@event4u/agent-config 5.5.0 → 5.6.0

package/scripts/ai-video/adapters/openai-images.sh

@@ -42,12 +42,98 @@ aiv_cmd_run() {
   seed="$(printf '%s' "${stdin_json}" | jq -r '.seed // empty')"
   ref_first="$(printf '%s' "${stdin_json}" | jq -r '.ref_images[0] // empty')"
 
-  # Live mode is implementation-scaffolded: we do NOT yet POST to the
-  # OpenAI Images API from inside this adapter. The cost-floor gate
-  # (Phase 5 Step 6) refuses live mode unless the operator explicitly
-  # confirms in-turn; this branch surfaces a clear stub error so the
-  # contract surface stays stable while the live path is wired later.
-  aiv_die 9 "${ADAPTER_ID}: live mode not yet wired (prompt=${#prompt} chars, seed=${seed:-unset}, ref=${ref_first:-none})"
+  [ -n "${prompt}" ] || aiv_die 7 "${ADAPTER_ID}: empty prompt (prompt.* blocks required)"
+
+  # Images-generations API has no negative-prompt field — fold the
+  # negative list into the prompt as an explicit "Avoid:" clause.
+  local negative
+  negative="$(printf '%s' "${stdin_json}" | jq -r '(.negative // []) | join(", ")')"
+  [ -n "${negative}" ] && prompt="${prompt} Avoid: ${negative}."
+
+  # gpt-image-1 has no seed param. Log if present.
+  [ -n "${seed}" ] && printf '%s: seed=%s ignored (gpt-image-1 has no seed)\n' "${ADAPTER_ID}" "${seed}" >&2
+  : "${ref_first:=}"
+
+  # Resolve size from requested aspect (stdin .aspect overrides XML tuning).
+  local aspect quality size out
+  aspect="$(printf '%s' "${stdin_json}" | jq -r --arg a "${AIV_TUNING_ASPECT:-16:9}" '.aspect // $a')"
+  quality="${AIV_TUNING_QUALITY:-high}"
+  case "${aspect}" in
+    16:9|3:2|landscape) size="1536x1024" ;;
+    9:16|2:3|portrait)  size="1024x1536" ;;
+    1:1|square)         size="1024x1024" ;;
+    *)                  size="1536x1024" ;;
+  esac
+
+  # Output path: caller-set AIV_OUT wins; else a temp PNG.
+  out="${AIV_OUT:-}"
+  [ -n "${out}" ] || out="$(mktemp -t aiv-openai-XXXXXX).png"
+
+  # Collect reference image files. When present → /v1/images/edits
+  # (reference-conditioned, so the model adheres to the supplied
+  # character); otherwise plain text-to-image /v1/images/generations.
+  local -a ref_files=() tmp_files=()
+  local r tmp
+  while IFS= read -r r; do
+    [ -n "${r}" ] || continue
+    case "${r}" in
+      http://*|https://*)
+        tmp="$(mktemp -t aiv-ref-XXXXXX).png"
+        curl -sS -L -o "${tmp}" "${r}" || aiv_die 8 "${ADAPTER_ID}: failed to download ref image: ${r}"
+        ref_files+=("${tmp}"); tmp_files+=("${tmp}") ;;
+      *)
+        case "${r}" in /*) : ;; *) r="$(pwd)/${r}" ;; esac
+        [ -f "${r}" ] || aiv_die 7 "${ADAPTER_ID}: ref image not found: ${r}"
+        ref_files+=("${r}") ;;
+    esac
+  done < <(printf '%s' "${stdin_json}" | jq -r '.ref_images[]? // empty')
+
+  local req resp http_code body b64
+  if [ "${#ref_files[@]}" -gt 0 ]; then
+    # Reference-conditioned edit. gpt-image-1 accepts multiple image[] refs.
+    local -a fargs=(-F "model=${AIV_MODEL:-gpt-image-1}" -F "prompt=${prompt}" \
+      -F "size=${size}" -F "quality=${quality}" -F "n=1")
+    for r in "${ref_files[@]}"; do fargs+=(-F "image[]=@${r};type=image/png"); done
+    printf '%s: edits endpoint with %d reference image(s)\n' "${ADAPTER_ID}" "${#ref_files[@]}" >&2
+    resp="$(curl -sS -w '\n%{http_code}' \
+      -X POST "${AIV_ENDPOINT%/}/images/edits" \
+      -H "Authorization: Bearer ${AIV_KEY}" \
+      "${fargs[@]}")" \
+      || aiv_die 8 "${ADAPTER_ID}: curl to ${AIV_ENDPOINT%/}/images/edits failed"
+  else
+    req="$(jq -n \
+      --arg m "${AIV_MODEL:-gpt-image-1}" --arg p "${prompt}" \
+      --arg s "${size}" --arg q "${quality}" \
+      '{model: $m, prompt: $p, size: $s, quality: $q, n: 1}')"
+    resp="$(curl -sS -w '\n%{http_code}' \
+      -X POST "${AIV_ENDPOINT%/}/images/generations" \
+      -H "Authorization: Bearer ${AIV_KEY}" \
+      -H "Content-Type: application/json" \
+      --data-binary "${req}")" \
+      || aiv_die 8 "${ADAPTER_ID}: curl to ${AIV_ENDPOINT%/}/images/generations failed"
+  fi
+  # Clean up any downloaded temp refs (set -u safe on empty arrays).
+  for tmp in ${tmp_files[@]+"${tmp_files[@]}"}; do rm -f "${tmp}"; done
+
+  http_code="$(printf '%s' "${resp}" | tail -n1)"
+  body="$(printf '%s' "${resp}" | sed '$d')"
+  case "${http_code}" in
+    2*) : ;;
+    *) aiv_die 8 "${ADAPTER_ID}: HTTP ${http_code}: $(printf '%s' "${body}" | jq -r '.error.message // .error // "unknown error"' 2>/dev/null | head -c 300)" ;;
+  esac
+
+  # gpt-image-1 always returns base64 (no url).
+  b64="$(printf '%s' "${body}" | jq -r '.data[0].b64_json // empty')"
+  [ -n "${b64}" ] || aiv_die 8 "${ADAPTER_ID}: no image data in response (got: $(printf '%s' "${body}" | head -c 200))"
+
+  # Portable base64 decode (GNU -d / BSD -D).
+  local b64dec
+  if printf '' | base64 -d >/dev/null 2>&1; then b64dec='base64 -d'; else b64dec='base64 -D'; fi
+  printf '%s' "${b64}" | ${b64dec} > "${out}" \
+    || aiv_die 8 "${ADAPTER_ID}: base64 decode to ${out} failed"
+
+  case "${out}" in /*) : ;; *) out="$(pwd)/${out}" ;; esac
+  jq -n --arg p "${out}" '{video_path: $p, audio_embedded: false}'
 }
 
 aiv_cmd_submit() { aiv_cmd_run "$@"; }

package/scripts/audit_auto_rules.py

@@ -25,8 +25,24 @@ from pathlib import Path
 import yaml
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
-SRC_RULES = REPO_ROOT / ".agent-src.uncondensed" / "rules"
-PROJECTED_RULES = REPO_ROOT / ".augment" / "rules"
+sys.path.insert(0, str(REPO_ROOT / "scripts"))
+from _lib.agent_src import artefact_roots  # noqa: E402
+
+# Pre-monorepo this was REPO_ROOT/.agent-src.uncondensed/rules. Post-move
+# (ADR-017) source rules live under packages/*/.agent-src.uncondensed/rules.
+def _src_rule_paths() -> list[Path]:
+    paths: list[Path] = []
+    seen: set[str] = set()
+    for root in artefact_roots():
+        d = root / "rules"
+        if d.is_dir():
+            for p in sorted(d.glob("*.md")):
+                if p.name not in seen:
+                    seen.add(p.name)
+                    paths.append(p)
+    return paths
+
+PROJECTED_RULES = REPO_ROOT / ".agent-src" / "rules"
 REPORT_DIR = REPO_ROOT / "agents" / "reports"
 JSON_OUT = REPORT_DIR / "auto-rules-audit.json"
 MD_OUT = REPORT_DIR / "auto-rules-audit.md"
@@ -67,7 +83,7 @@ def _trigger_summary(triggers: list) -> dict:
 
 def collect() -> list[dict]:
     rules: list[dict] = []
-    for path in sorted(SRC_RULES.glob("*.md")):
+    for path in _src_rule_paths():
         text = path.read_text(encoding="utf-8")
         fm, body = _split_frontmatter(text)
         if fm.get("type") != "auto":
@@ -107,7 +123,7 @@ def render_markdown(rules: list[dict]) -> str:
         "# Auto-Rule Audit",
         "",
         "Generated by `scripts/audit_auto_rules.py` for Phase 5 of",
-        "`agents/roadmaps/road-to-augment-limit-fit.md`. Re-run after",
+        "`agents/roadmaps/archive/road-to-augment-limit-fit.md`. Re-run after",
         "any rule add/merge/deprecate to refresh the baseline.",
         "",
         "## Totals",
@@ -141,8 +157,8 @@ def render_markdown(rules: list[dict]) -> str:
 
 
 def main() -> int:
-    if not SRC_RULES.is_dir():
-        print(f"❌  Missing source dir: {SRC_RULES}", file=sys.stderr)
+    if not _src_rule_paths():
+        print("❌  No source rules found under any artefact root's rules/", file=sys.stderr)
         return 1
     rules = collect()
     REPORT_DIR.mkdir(parents=True, exist_ok=True)

package/scripts/audit_command_surface.py

@@ -37,7 +37,12 @@ from pathlib import Path
 from typing import List
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
-DEFAULT_ROOT = REPO_ROOT / ".agent-src.uncondensed" / "commands"
+# Pre-monorepo: REPO_ROOT/.agent-src.uncondensed/commands. Post-move (ADR-017)
+# the core command surface lives under packages/core/.agent-src.uncondensed.
+# Fall back to the legacy path only if the packages layout is absent.
+_CORE_COMMANDS = REPO_ROOT / "packages" / "core" / ".agent-src.uncondensed" / "commands"
+_LEGACY_COMMANDS = REPO_ROOT / ".agent-src.uncondensed" / "commands"
+DEFAULT_ROOT = _CORE_COMMANDS if _CORE_COMMANDS.is_dir() else _LEGACY_COMMANDS
 REPORT_DIR = REPO_ROOT / "agents" / "reports"
 OUT_JSON = REPORT_DIR / "command-surface.json"
 OUT_MD = REPORT_DIR / "command-surface.md"

package/scripts/audit_initial_context.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""Initial-context token audit (roadmap `road-to-lean-initial-context`).
+
+Serves three roadmap steps with one analyzer (no new analyzer where one
+exists — reuses `scripts/_lib/token_count.py`):
+
+- **0B.2** — always-on rule-body footprint per tool projection.
+- **0B.4** — description-catalog initial cost (skill + command name+desc).
+- **1.3** — unified `audit:tokens` surfacing per-tool initial-token estimate,
+  longest rules in tokens, and the description-catalog pool.
+
+`char != token`: every number is reported in both. GPT counts are exact when
+`tiktoken` is installed, else a documented proxy (see `token_count`).
+
+Usage:
+    python3 scripts/audit_initial_context.py            # markdown report → stdout
+    python3 scripts/audit_initial_context.py --json     # machine-readable
+    python3 scripts/audit_initial_context.py --write     # write report files
+    python3 scripts/audit_initial_context.py --fail-if-over-budget  # CI gate (1.4)
+
+Exit codes: 0 = ok (or no budget set); 1 = a measured surface exceeds its
+configured token budget (only with --fail-if-over-budget).
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as _dt
+import glob
+import json
+import re
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(REPO_ROOT / "scripts"))
+from _lib import token_count  # noqa: E402
+
+try:
+    import yaml
+except ImportError:  # pragma: no cover
+    sys.stderr.write("error: PyYAML required (pip install pyyaml)\n")
+    sys.exit(2)
+
+REPORT_DIR = REPO_ROOT / "internal" / "bench" / "reports"
+
+# Tools whose rules/ dir holds one .md per rule (full body projected today).
+DIR_RULE_TOOLS = (".claude", ".augment", ".cursor")
+# Tools whose always-on surface is a single monolithic file.
+MONOLITH_TOOLS = (".windsurfrules",)
+
+# Initial-token budget per surface (None = advisory only, no gate). These are
+# soft ceilings the audit can enforce once a baseline is agreed (1.4). Set
+# generously now; tighten as Phase 3 lands.
+BUDGETS: dict[str, int | None] = {
+    "rules.gpt": None,
+    "skill_catalog.gpt": None,
+    "command_catalog.gpt": None,
+}
+
+
+def _frontmatter(path: Path) -> dict:
+    try:
+        text = path.read_text(encoding="utf-8", errors="ignore")
+    except OSError:
+        return {}
+    m = re.match(r"^---\s*\n(.*?)\n---\s*\n", text, re.DOTALL)
+    if not m:
+        return {}
+    try:
+        return yaml.safe_load(m.group(1)) or {}
+    except yaml.YAMLError:
+        return {}
+
+
+def _measure_files(paths: list[Path]) -> dict:
+    blob = "".join(p.read_text(encoding="utf-8", errors="ignore") for p in paths)
+    out = token_count.measure(blob)
+    out["files"] = len(paths)
+    return out
+
+
+def rule_footprint() -> dict:
+    """0B.2 — always-on rule footprint per tool."""
+    tools: dict[str, dict] = {}
+    for tool in DIR_RULE_TOOLS:
+        files = sorted((REPO_ROOT / tool / "rules").glob("*.md"))
+        if files:
+            tools[tool] = _measure_files(files)
+    for tool in MONOLITH_TOOLS:
+        f = REPO_ROOT / tool
+        if f.is_file():
+            m = token_count.measure(f.read_text(encoding="utf-8", errors="ignore"))
+            m["files"] = 1
+            tools[tool] = m
+    return tools
+
+
+def _catalog(glob_pat: str) -> dict:
+    entries = []
+    for f in glob.glob(str(REPO_ROOT / glob_pat), recursive=True):
+        fm = _frontmatter(Path(f))
+        name = fm.get("name") or Path(f).parent.name
+        desc = fm.get("description", "")
+        if desc:
+            entries.append(f"{name}: {desc}")
+    m = token_count.measure("\n".join(entries))
+    m["entries"] = len(entries)
+    return m
+
+
+def description_catalog() -> dict:
+    """0B.4 — description-catalog cost (eager progressive-disclosure surface)."""
+    return {
+        "skills_projected": _catalog(".claude/skills/*/SKILL.md"),
+        "skills_core_source": _catalog("packages/core/.agent-src.uncondensed/skills/*/SKILL.md"),
+        "commands_core_source": _catalog("packages/core/.agent-src.uncondensed/commands/**/*.md"),
+    }
+
+
+def longest_rules(top: int = 10) -> list[dict]:
+    """1.3 — longest rules in tokens (the trim candidates)."""
+    rows = []
+    for tool in DIR_RULE_TOOLS:
+        d = REPO_ROOT / tool / "rules"
+        if d.is_dir():
+            for p in d.glob("*.md"):
+                m = token_count.measure(p.read_text(encoding="utf-8", errors="ignore"))
+                rows.append({"id": p.stem, "tokens_gpt": m["tokens_gpt"], "chars": m["chars"]})
+            break  # one tool is representative — bodies are identical across DIR tools
+    rows.sort(key=lambda r: (-r["tokens_gpt"], r["id"]))
+    return rows[:top]
+
+
+def build() -> dict:
+    return {
+        "generated": _dt.datetime.now(_dt.timezone.utc).isoformat(timespec="seconds"),
+        "token_method": token_count.method_note(),
+        "rule_footprint": rule_footprint(),
+        "description_catalog": description_catalog(),
+        "longest_rules": longest_rules(),
+    }
+
+
+def render_md(d: dict) -> str:
+    L = ["# Initial-context token audit", "",
+         f"- generated: `{d['generated']}`",
+         f"- token method: {d['token_method']}", "",
+         "## 0B.2 — always-on rule footprint per tool", "",
+         "| tool | files | chars | GPT tok | Claude tok |",
+         "|---|--:|--:|--:|--:|"]
+    for tool, m in d["rule_footprint"].items():
+        L.append(f"| `{tool}` | {m['files']} | {m['chars']:,} | {m['tokens_gpt']:,} | {m['tokens_claude']:,} |")
+    L += ["", "## 0B.4 — description-catalog cost (eager)", "",
+          "| catalog | entries | chars | GPT tok | Claude tok |",
+          "|---|--:|--:|--:|--:|"]
+    for name, m in d["description_catalog"].items():
+        L.append(f"| {name} | {m['entries']} | {m['chars']:,} | {m['tokens_gpt']:,} | {m['tokens_claude']:,} |")
+    L += ["", "## 1.3 — top-10 longest rules (token trim candidates)", "",
+          "| rule | GPT tok | chars |", "|---|--:|--:|"]
+    for r in d["longest_rules"]:
+        L.append(f"| `{r['id']}` | {r['tokens_gpt']:,} | {r['chars']:,} |")
+    L.append("")
+    return "\n".join(L)
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("--json", action="store_true")
+    ap.add_argument("--write", action="store_true", help="write report files under internal/bench/reports/")
+    ap.add_argument("--fail-if-over-budget", action="store_true",
+                    help="exit 1 if a surface exceeds its configured token budget (1.4)")
+    args = ap.parse_args(argv)
+
+    data = build()
+
+    if args.fail_if_over_budget:
+        breaches = []
+        rf = next(iter(data["rule_footprint"].values()), {})
+        checks = {
+            "rules.gpt": rf.get("tokens_gpt", 0),
+            "skill_catalog.gpt": data["description_catalog"]["skills_projected"]["tokens_gpt"],
+            "command_catalog.gpt": data["description_catalog"]["commands_core_source"]["tokens_gpt"],
+        }
+        for key, val in checks.items():
+            cap = BUDGETS.get(key)
+            if cap is not None and val > cap:
+                breaches.append(f"{key} {val} > budget {cap}")
+        if breaches:
+            print("❌  initial-context budget: " + "; ".join(breaches))
+            return 1
+        print("✅  initial-context budget: pass (or advisory-only)")
+        return 0
+
+    if args.json:
+        print(json.dumps(data, indent=2, sort_keys=True))
+    else:
+        print(render_md(data))
+
+    if args.write:
+        REPORT_DIR.mkdir(parents=True, exist_ok=True)
+        (REPORT_DIR / "projection-cost.json").write_text(
+            json.dumps(data, indent=2, sort_keys=True), encoding="utf-8")
+        (REPORT_DIR / "projection-cost.md").write_text(render_md(data), encoding="utf-8")
+        print(f"\n→ wrote {REPORT_DIR.relative_to(REPO_ROOT)}/projection-cost.{{json,md}}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/bench_ab_diff.py

@@ -10,7 +10,7 @@ Inputs: two report JSON paths. Output: a JSON artefact under
 The diff content depends on the corpus:
 
 - `ab-tracka` — trigger-accuracy %, false-positive count, per-rule lift.
-- `ab-trackb` — completion-rate per category, wall-time, tokens, cost,
+- `ab-trackb` — completion-rate per category, wall-time, tokens,
   ask-vs-act ratio, tool-call count.
 
 Phase 2 only writes the structural skeleton (delta object with `with`,
@@ -74,7 +74,7 @@ def compute_track_a_diff(with_results: dict, without_results: dict) -> dict:
 
 
 def compute_track_b_diff(with_results: dict, without_results: dict) -> dict:
-    """Track B: completion rate per category + wall-time + tokens + cost + ask-vs-act."""
+    """Track B: completion rate per category + wall-time + tokens + ask-vs-act."""
     def mean(d: dict, key: str) -> float:
         try:
             return float(d.get(key, 0.0))
@@ -111,15 +111,8 @@ def compute_track_b_diff(with_results: dict, without_results: dict) -> dict:
                 3,
             ),
         },
-        "cost_usd": {
-            "with": mean(with_results, "mean_cost_usd"),
-            "without": mean(without_results, "mean_cost_usd"),
-            "delta": round(
-                mean(with_results, "mean_cost_usd")
-                - mean(without_results, "mean_cost_usd"),
-                4,
-            ),
-        },
+        # cost_usd comparison intentionally omitted — API pricing misleads
+        # subscription users; tokens are the currency-neutral metric.
         "ask_vs_act_ratio": {
             "with": mean(with_results, "ask_vs_act_ratio"),
             "without": mean(without_results, "ask_vs_act_ratio"),

package/scripts/bench_run.py

@@ -150,7 +150,7 @@ def main(argv: list[str] | None = None) -> int:
     headline = (
         f"bench {report['corpus']['id']} · "
         f"selection {sel['selection_accuracy']:.2%} ({verdict['selection']}) · "
-        f"cost ${cost['totals']['total_cost_usd']:.6f} ({cost.get('source', 'n/a')}) · "
+        f"tokens {cost.get('source', 'n/a')} · "
         f"quality {qual['quality_score']:.2%} ({verdict['quality']}) · "
         f"overall {verdict['overall']}"
     )
@@ -252,8 +252,7 @@ def _run_telegraph(args: argparse.Namespace) -> int:
         f"telegraph · prompts {report['corpus']['prompt_count']} · "
         f"calls {cost['totals']['calls']} · errors {cost['totals']['errors']} · "
         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}"
+        f"vs_terse med {report['telegraph']['aggregate']['savings_vs_terse']['median']:.2%}"
     )
     if args.quiet:
         print(headline)

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.uncondensed/skills/`
+corpus YAML, ranks the skills in the projected catalog `.agent-src/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.uncondensed" / "skills"
+SKILLS_DIR = REPO_ROOT / ".agent-src" / "skills"
 CORPUS_DIR = REPO_ROOT / "tests" / "eval"
 
 STOPWORDS = frozenset({

package/scripts/condense.py

@@ -144,6 +144,31 @@ def _read_augment_rules_use_symlinks() -> bool:
     return False
 
 
+def _lean_projection_mode() -> str:
+    """Read lean_projection.mode from .agent-settings.yml.
+
+    `eager-all` (default) → every rule body inlined into every projection
+    (today's behaviour). `thin` → kernel full-bodied + non-kernel rules as
+    router-resolved pointers (lean-initial-context Phase 3.1; ~36k GPT tok
+    lighter, measured). Missing / malformed → `eager-all`, so the thin path
+    is strictly opt-in and one-flip-revertible (see docs/contracts/rule-router.md
+    § Kill-switch). The flip MUST be live-A/B-validated before it ships as the
+    default — a thin projection only holds behaviour if the agent resolves the
+    pointer on trigger-match.
+    """
+    try:
+        from scripts._lib.agent_settings import load_agent_settings
+    except ImportError:  # pragma: no cover — script-style invocation
+        import sys as _sys
+        from pathlib import Path as _Path
+        _sys.path.insert(0, str(_Path(__file__).resolve().parent))
+        from _lib.agent_settings import load_agent_settings  # type: ignore[import-not-found]
+
+    data = load_agent_settings(project_path=SETTINGS_FILE)
+    lean = data.get("lean_projection")
+    if isinstance(lean, dict) and str(lean.get("mode", "")).strip().lower() == "thin":
+        return "thin"
+    return "eager-all"
 
 
 def file_hash(filepath: Path) -> str:
@@ -654,6 +679,18 @@ def generate_rule_symlinks() -> int:
     # All .md files in .agent-src/rules/ — not just universal ones
     rules = sorted([f.name for f in RULES_SOURCE.glob("*.md")])
     tool_dirs = _filter_tool_dirs(TOOL_DIRS)
+
+    # Thin-projection opt-in (lean-initial-context Phase 3.1). Default
+    # `eager-all` keeps the symlink behaviour below untouched; `thin` writes
+    # kernel rules full + non-kernel rules as router-resolved pointers.
+    thin_files: dict[str, str] | None = None
+    if _lean_projection_mode() == "thin":
+        try:
+            from scripts.project_thin_rules import build_thin
+        except ImportError:  # pragma: no cover — script-style invocation
+            from project_thin_rules import build_thin  # type: ignore[import-not-found]
+        thin_files = build_thin(RULES_SOURCE)
+
     total = 0
     for tool_dir, rel_prefix in tool_dirs.items():
         target_dir = PROJECT_ROOT / tool_dir
@@ -666,17 +703,21 @@ def generate_rule_symlinks() -> int:
 
         for rule in rules:
             link = target_dir / rule
-            target = Path(rel_prefix) / rule
             if link.exists() or link.is_symlink():
                 link.unlink()
-            link.symlink_to(target)
+            if thin_files is not None:
+                # Thin mode: write a real file (kernel full / non-kernel pointer),
+                # not a symlink to the full source body.
+                link.write_text(thin_files[rule], encoding="utf-8")
+            else:
+                link.symlink_to(Path(rel_prefix) / rule)
             total += 1
 
     # Verify counts match across all tool directories
     source_count = len(rules)
     for tool_dir in tool_dirs:
         target_dir = PROJECT_ROOT / tool_dir
-        tool_count = len([f for f in target_dir.iterdir() if f.is_symlink() and f.suffix == ".md"])
+        tool_count = len([f for f in target_dir.iterdir() if f.suffix == ".md"])
         if tool_count != source_count:
             print(f"  ⚠️  {tool_dir}: {tool_count} rules (expected {source_count})")
 

package/scripts/iron_law_sha.py

@@ -26,7 +26,15 @@ import sys
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
-RULES_DIR = REPO_ROOT / ".agent-src.uncondensed" / "rules"
+sys.path.insert(0, str(REPO_ROOT / "scripts"))
+from _lib.agent_src import artefact_roots  # noqa: E402
+
+# Pre-monorepo this was REPO_ROOT/.agent-src.uncondensed/rules. Post-move
+# (ADR-017) the source rules live under packages/*/.agent-src.uncondensed/rules.
+# Resolve the same way measure_rule_budget does (multi-root aware) so the
+# Iron-Law SHA gate keeps working against the current layout.
+def _rules_dirs() -> list[Path]:
+    return [root / "rules" for root in artefact_roots() if (root / "rules").is_dir()]
 
 # Locked kernel set — kept in sync with measure_rule_budget.KERNEL_RULES.
 KERNEL_RULES = (
@@ -58,10 +66,11 @@ def iron_law_sha(text: str) -> str:
 
 
 def rule_sha(rule_id: str) -> str:
-    path = RULES_DIR / f"{rule_id}.md"
-    if not path.exists():
-        raise FileNotFoundError(path)
-    return iron_law_sha(path.read_text(encoding="utf-8"))
+    for rules_dir in _rules_dirs():
+        path = rules_dir / f"{rule_id}.md"
+        if path.exists():
+            return iron_law_sha(path.read_text(encoding="utf-8"))
+    raise FileNotFoundError(f"{rule_id}.md not found under any artefact root's rules/")
 
 
 def main(argv: list[str] | None = None) -> int:

package/scripts/measure_rule_budget.py

@@ -28,6 +28,7 @@ from pathlib import Path
 REPO_ROOT = Path(__file__).resolve().parent.parent
 sys.path.insert(0, str(REPO_ROOT / "scripts"))
 from _lib.agent_src import artefact_roots  # noqa: E402
+from _lib import token_count  # noqa: E402
 
 OVERRIDES_FILE = REPO_ROOT / "docs" / "contracts" / "iron-law-overrides.txt"
 TREND_FILE = REPO_ROOT / "agents" / "runtime" / ".rule-budget-history.jsonl"
@@ -91,6 +92,9 @@ def measure_rule(path: Path) -> dict[str, object]:
         "tier": fields.get("tier", ""),
         "chars": len(body),
         "lines": body.count("\n"),
+        # Real-tokenizer truth alongside the char proxy (roadmap 0B.1).
+        "tokens_gpt": token_count.gpt_tokens(body).tokens,
+        "tokens_claude": token_count.claude_tokens(body).tokens,
     }
 
 
@@ -141,6 +145,11 @@ def aggregate(rules: list[dict[str, object]]) -> dict[str, object]:
         "auto_chars": sum(int(r["chars"]) for r in auto),
         "kernel_chars": sum(int(r["chars"]) for r in kernel),
         "total_chars": total_chars,
+        "kernel_tokens_gpt": sum(int(r.get("tokens_gpt", 0)) for r in kernel),
+        "kernel_tokens_claude": sum(int(r.get("tokens_claude", 0)) for r in kernel),
+        "total_tokens_gpt": sum(int(r.get("tokens_gpt", 0)) for r in rules),
+        "total_tokens_claude": sum(int(r.get("tokens_claude", 0)) for r in rules),
+        "token_method": token_count.method_note(),
         "kernel_hard": KERNEL_HARD,
         "kernel_target": KERNEL_TARGET,
         "per_rule_hard": PER_RULE_HARD,
@@ -181,6 +190,12 @@ def render_table(rules: list[dict[str, object]], agg: dict[str, object]) -> str:
     )
     lines.append(f"        total: {agg['total_chars']:>6} chars across {agg['rule_count']} rules")
     lines.append("")
+    lines.append(
+        f"kernel-tokens: {agg['kernel_tokens_gpt']:>6} GPT · {agg['kernel_tokens_claude']:>6} Claude  "
+        f"(total {agg['total_tokens_gpt']} GPT · {agg['total_tokens_claude']} Claude)"
+    )
+    lines.append(f"  token method: {agg['token_method']}")
+    lines.append("")
     lines.append(f"top-5 largest:")
     for r in agg["top5_largest"]:  # type: ignore[index]
         lines.append(f"  {r['chars']:>5}  {r['id']}  ({r['type']})")