@event4u/agent-config 8.1.0 → 8.3.0

package/dist/agent-src/skills/prediction-pool-optimizer/reference/ev-fixtures.md

@@ -17,7 +17,7 @@ No quote rule. No strategy limit. Goal: place well.
 
 **Match (football):** Poisson on market xG ≈ 1.7 : 0.8.
 
-**Script-verified** (`score_ev.py --lh 1.7 --la 0.8 --exact 4 --diff 3 --tendency 2`):
+**Script-verified** (`score_ev.ts --lh 1.7 --la 0.8 --exact 4 --diff 3 --tendency 2`):
 
 ```
 EV-max tip : 1:0  (EV 1.574)
@@ -65,7 +65,7 @@ Away 22%.
 
 **Reasoning:** N ≥ 100 and you behind → pure EV converges with the field, can't
 create the gap; target is **P(finish 1st)**, not E(points). Don't guess the
-variance: run `pool_winsim.py` with the pool's `N` and your `my_lead`. Shows
+variance: run `pool_winsim.ts` with the pool's `N` and your `my_lead`. Shows
 P(win) collapsing under EV-max-everywhere, returns the **specific flips**
 (higher-variance scorelines on high-consensus matches) that raise P(win) most
 per unit EV given up.
@@ -132,7 +132,7 @@ medium.) **Not** team B — the modal-player trap.
 
 **Rule:** kicktipp 2 / 3 / 5 — tendency = 2, goal-difference = 3, exact = 5.
 
-**Matches (script-verified, `score_ev.py … --tendency 2 --diff 3 --exact 5`):**
+**Matches (script-verified, `score_ev.ts … --tendency 2 --diff 3 --exact 5`):**
 
 | Match (λ) | EV-max | a high tip's EV | verdict |
 |---|---|---|---|
@@ -148,7 +148,7 @@ EV-max.** Adding goals — especially the underdog's — only shrinks the hit
 probability without protecting the diff/tendency points.
 
 **Known-good behaviour:** any 3:2 / 4:x / x:4 tip in the run → the grid wasn't
-run; `score_ev.py` is the gate. (Risk: low; correctness fixture, not strategy.)
+run; `score_ev.ts` is the gate. (Risk: low; correctness fixture, not strategy.)
 
 ---
 
@@ -156,7 +156,7 @@ run; `score_ev.py` is the gate. (Risk: low; correctness fixture, not strategy.)
 
 **Rule:** kicktipp 2 / 3 / 5 (as Fixture 7).
 
-**Matches (script-verified, `score_ev.py … --tendency 2 --diff 3 --exact 5`):**
+**Matches (script-verified, `score_ev.ts … --tendency 2 --diff 3 --exact 5`):**
 
 ```
 λ 1.0:1.0  ->  EV-max 0:0 (1.196), 1:1 tied (1.196)   # a draw IS the optimum
@@ -171,5 +171,5 @@ As λ rises past ~1.1 a one-goal win edges ahead, but the draw stays in the top
 tips. Grid surfaces this; intuition suppresses it.
 
 **Known-good behaviour:** a tip set with **near-zero draws across many
-low-scoring even matches** is a red flag — re-run `score_ev.py`, let the grid
+low-scoring even matches** is a red flag — re-run `score_ev.ts`, let the grid
 decide, don't default every close game to 1:0.

package/dist/agent-src/skills/prediction-pool-optimizer/reference/odds-and-bonus.md

@@ -86,7 +86,7 @@ does. Optimize each on expected points under its point weight.
 
 | Question type | Example | Method |
 |---|---|---|
-| **Outright winner** | "Who wins the tournament?" | Outright "to win" market, consensus per A; or `poisson_sim.py` `title_pct`. EV-max under the question's points. |
+| **Outright winner** | "Who wins the tournament?" | Outright "to win" market, consensus per A; or `poisson_sim.ts` `title_pct`. EV-max under the question's points. |
 | **Group / stage** | "Who wins group X?", "Who advances?" | "To win group" / "to qualify" markets; or `advance_pct` from the simulator. |
 | **Finalists / matchup** | "Who reaches the final?" | "To reach final" market per team; simulator pairing is approximate — prefer the market. |
 | **Top scorer (player)** | "Tournament top scorer?" | "Top goalscorer" outright market, consensus per A; EV-max player (favourite unless rarity scoring rewards a longer shot). |

package/dist/agent-src/skills/premortem/SKILL.md

@@ -109,7 +109,7 @@ If the analysis surfaces a pattern worth preserving for future decisions:
   not a prediction; label scenarios as prospective.
 - Do NOT auto-promote memory candidates — `/memory propose` is the intake;
   `/memory promote` requires explicit human action and passes
-  `check_memory_proposal.py`.
+  `check_memory_proposal.ts`.
 
 ## Gotchas
 

package/dist/agent-src/skills/project-docs/SKILL.md

@@ -79,7 +79,7 @@ regulations, workflows, and edge cases that the agent needs to understand the pr
 3. **List `agents/reference/docs/`** — read detail docs for the specific topic you're working on.
 4. **Check module docs** — if working in a module, resolve `{module_root}` from
    `modules.root_paths` and `{agent_folder}` from `modules.agent_folder` (see
-   `scripts/_lib/agent_settings.py::enumerate_modules()`), then check:
+   `scripts/_lib/agent_settings.ts::enumerate_modules()`), then check:
    - `{module_root}/{Module}/{agent_folder}/` — module-specific docs
    - `{module_root}/{Module}/{agent_folder}/settings/contexts/` — module-specific contexts (if exists)
    - `{module_root}/{Module}/{agent_folder}/settings/contexts/domain/` — module-specific domain knowledge (if exists)

package/dist/agent-src/skills/quality-tools/SKILL.md

@@ -23,6 +23,30 @@ Use this skill whenever running or configuring code quality tools:
 - **PHP**: PHPStan (static analysis), Rector (automated refactoring), ECS (coding standards)
 - **JS/TS**: Biome (linting + formatting), TypeScript compiler (type checking), Jest/Vitest (tests)
 
+## Execution policy — on demand only, never proactive
+
+```
+NEVER RUN QUALITY TOOLS PROACTIVELY WHEN quality.local_auto_run IS
+false OR MISSING (THE DEFAULT). DO NOT ASK WHETHER TO RUN THEM.
+THE USER RUNS THEM MANUALLY. REMOTE CI IS THE AUTHORITATIVE GATE.
+```
+
+Toolchains differ per language and project, often unknown to the agent —
+discovery + execution burns time and tokens. Under the default, exactly
+three triggers justify running a quality tool:
+
+1. **Explicit ask this turn** — user says so or invokes `/quality-fix`.
+2. **Concrete CI failure** — remote pipeline reports a failing check;
+   run exactly that failing check to reproduce and fix (`/fix:ci` is
+   the canonical flow).
+3. **New-gate carve-out** — change itself introduces a NEW CI gate,
+   smoke test, or test file; must run once locally to be proven.
+
+`quality.local_auto_run: true` restores legacy autonomous behaviour
+(run pipeline when work is ready for verification). When runs are
+suppressed, completion message says *"quality gates delegated to
+remote CI"* — never that the tools passed.
+
 ## Language detection
 
 Detect which tools to run based on **what files were changed**:
@@ -37,9 +61,9 @@ If both PHP and JS/TS files changed → run **both** pipelines.
 
 ## Related rules and guidelines
 
-- `verify-before-complete` rule — timing: run quality tools ONCE at the end, not after each edit
+- `verify-before-complete` rule — no pass claims without fresh output; suppressed runs surfaced as "delegated to remote CI", never claimed
 - `php-coding` rule → PHPStan section — inline ignores, PHPDoc rules
-- `verify-before-complete` rule — must run quality checks before claiming work is done
+- `contexts/execution/verification-mechanics.md` — Gate zero (`local_auto_run`) + timing when `true` (quality tools ONCE at the end, not after each edit)
 - [`testing-anti-patterns`](../testing-anti-patterns/SKILL.md) and
   [`process-anti-patterns.md`](../testing-anti-patterns/process-anti-patterns.md) —
   test-side rationalizations these tools cannot catch (e.g. "CI is red,

package/dist/agent-src/skills/react-shadcn-ui/SKILL.md

@@ -23,11 +23,12 @@ execution:
 # react-shadcn-ui
 
 > **Grounded stack guidance:** pull idiomatic Do/Don't + docs URLs via
-> `ground.py search --manifest <skills-root>/design-intelligence/data/manifest.json
+> `./scripts-run <skills-root>/corpus-grounding/scripts/ground search
+> --manifest <skills-root>/design-intelligence/data/manifest.json
 > --stack shadcn "<topic>"` (also `--stack react`, `--stack nextjs`). See
 > [`design-intelligence`](../design-intelligence/SKILL.md).
 
-## Component installer — `scripts/shadcn_add.py` (gated, assisted)
+## Component installer — `scripts/shadcn_add.ts` (gated, assisted)
 
 Bundled installer (Apache-2.0-derived, see header + `design-intelligence/ATTRIBUTION.md`)
 wraps `npx shadcn@latest add <components>` — **the only subprocess+network
@@ -47,14 +48,14 @@ block above:
 ## Compatibility
 
 - **Tested against:** `shadcn@2.1`, Tailwind CSS `3.x`, React `18+`.
-- The audit step (`directives/ui/audit.py`) reads the line above and
+- The audit step (`directives/ui/audit.ts`) reads the line above and
   compares it with `state.ui_audit.shadcn_inventory.version`; a major
   mismatch triggers a soft halt before this skill runs.
 
 ## When to use
 
-Use when `state.stack.frontend == "react-shadcn"` and `directives/ui/apply.py`,
-`review.py`, or `polish.py` dispatches to this skill, or when a React project
+Use when `state.stack.frontend == "react-shadcn"` and `directives/ui/apply.ts`,
+`review.ts`, or `polish.ts` dispatches to this skill, or when a React project
 clearly uses shadcn/ui (presence of `components.json`, `@radix-ui/*`
 dependencies, a `components/ui/` folder of generated primitives).
 
@@ -216,8 +217,8 @@ Default path = bundled `scripts/shadcn_add.ts` + `components.json`; works on mos
 
 ### Review pass — a11y findings + preview envelope
 
-When this skill is dispatched by `directives/ui/review.py` (test slot)
-or `directives/ui/polish.py` (verify slot) — i.e. a review/polish run,
+When this skill is dispatched by `directives/ui/review.ts` (test slot)
+or `directives/ui/polish.ts` (verify slot) — i.e. a review/polish run,
 not the initial apply — it also emits:
 
 - `state.ui_review.a11y` — `{violations: [{rule, selector, severity}, ...],

package/dist/agent-src/skills/react-shadcn-ui/scripts/shadcn_add.ts

@@ -23,7 +23,7 @@ import { spawnSync } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import process from 'node:process';
-import { pathToFileURL } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 
 export class ShadcnInstaller {
     projectRoot: string;
@@ -226,7 +226,7 @@ function _calledProcessError(cmd: string[], status: number | null, signal: strin
     return `Command ${cmdRepr} returned non-zero exit status ${status}.`;
 }
 
-const PROG = 'shadcn_add.py';
+const PROG = 'shadcn_add';
 
 const HELP =
     `usage: ${PROG} [-h] [--all] [--overwrite] [--dry-run] [--list]\n` +
@@ -249,22 +249,22 @@ const HELP =
     '\n' +
     'Examples:\n' +
     '  # Add single component\n' +
-    '  python shadcn_add.py button\n' +
+    '  ./scripts-run <skills-root>/react-shadcn-ui/scripts/shadcn_add button\n' +
     '\n' +
     '  # Add multiple components\n' +
-    '  python shadcn_add.py button card dialog\n' +
+    '  ./scripts-run <skills-root>/react-shadcn-ui/scripts/shadcn_add button card dialog\n' +
     '\n' +
     '  # Add all components\n' +
-    '  python shadcn_add.py --all\n' +
+    '  ./scripts-run <skills-root>/react-shadcn-ui/scripts/shadcn_add --all\n' +
     '\n' +
     '  # Overwrite existing components\n' +
-    '  python shadcn_add.py button --overwrite\n' +
+    '  ./scripts-run <skills-root>/react-shadcn-ui/scripts/shadcn_add button --overwrite\n' +
     '\n' +
     '  # Dry run (show what would be done)\n' +
-    '  python shadcn_add.py button card --dry-run\n' +
+    '  ./scripts-run <skills-root>/react-shadcn-ui/scripts/shadcn_add button card --dry-run\n' +
     '\n' +
     '  # List installed components\n' +
-    '  python shadcn_add.py --list\n' +
+    '  ./scripts-run <skills-root>/react-shadcn-ui/scripts/shadcn_add --list\n' +
     '        \n';
 
 const USAGE =
@@ -380,9 +380,30 @@ export function main(argv: string[] = process.argv.slice(2)): number {
     return success ? 0 : 1;
 }
 
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) {
+        return false;
+    }
+    const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+    if (import.meta.url === argvUrl) {
+        return true;
+    }
+    // A symlinked invocation (e.g. via an installed `.augment/` projection,
+    // or macOS /var → /private/var temp dirs) makes the raw URLs differ:
+    // import.meta.url is the resolved real path while argv[1] keeps the
+    // symlink path. Compare realpaths so the entry guard still fires
+    // (without this the CLI silently no-ops when run through a symlink).
+    try {
+        const here = fs.realpathSync(fileURLToPath(import.meta.url));
+        const argv = fs.realpathSync(path.resolve(process.argv[1]));
+        return here === argv;
+    } catch {
+        return false;
+    }
+}
+
 const _invokedDirectly =
-    process.argv[1] !== undefined &&
-    import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+    _isCliEntry();
 if (_invokedDirectly) {
     process.exitCode = main();
 }

package/dist/agent-src/skills/refine-prompt/SKILL.md

@@ -51,7 +51,7 @@ plan, does not implement, does not write back anywhere.
 ## Input
 
 Exactly one path: a non-empty raw string carried in
-`state.input.data.raw` (built by [`work_engine.resolvers.prompt`](../../templates/scripts/work_engine/resolvers/prompt.py)).
+`state.input.data.raw` (built by [`work_engine/resolvers/prompt.ts`](../../templates/scripts/work_engine/resolvers/prompt.ts)).
 No branch detection, no URL parsing, no clipboard fallback — the
 calling command (`/work`) owns prompt capture; this skill only refines.
 
@@ -160,20 +160,20 @@ step 3 — never both implicit.
 
 ### 5. Score confidence
 
-Delegate to [`scripts.work_engine.scoring.confidence`](../../templates/scripts/work_engine/scoring/confidence.py):
+Delegate to [`work_engine/scoring/confidence.ts`](../../templates/scripts/work_engine/scoring/confidence.ts):
 
-```python
-from work_engine.scoring.confidence import score
-result = score(raw=prompt_raw, ac=reconstructed_ac, assumptions=assumptions)
-# result.band ∈ {"high", "medium", "low"}
-# result.score ∈ [0.0, 1.0]
-# result.dimensions: dict[str, int]   # 0–2 per dimension
-# result.reasons: list[str]            # human-readable rationale
+```ts
+import { score } from './work_engine/scoring/confidence.js';
+const result = score({ raw: promptRaw, ac: reconstructedAc, assumptions });
+// result.band ∈ {"high", "medium", "low"}
+// result.score ∈ [0.0, 1.0]
+// result.dimensions: Record<string, number>  // 0–2 per dimension
+// result.reasons: string[]                   // human-readable rationale
 ```
 
 The rubric (5 dimensions × 0–2, sum / 10) and band thresholds
 (`high ≥ 0.8`, `medium 0.5–0.79`, `low < 0.5`) are owned by
-`confidence.py`. Do not re-derive them in prose.
+`confidence.ts`. Do not re-derive them in prose.
 
 ### 6. Self-review (3-scan checklist)
 
@@ -187,7 +187,7 @@ Source: adapted from an external reference `writing-plans/SKILL.md` § Self-Revi
 
 ## Band-action mapping
 
-The `refine` dispatcher step in `directives/backend/refine.py` reads
+The `refine` dispatcher step in `directives/backend/refine.ts` reads
 the score and returns one of three outcomes — the skill does not
 decide the action, only produces the inputs.
 
@@ -267,7 +267,7 @@ For `low`, the question replaces the AC list:
   verbatim for replay; reconstructed output lands in
   `data.reconstructed_ac` and `data.assumptions`.
 - Do NOT re-derive band thresholds in prose. They live in
-  `confidence.py` and only there.
+  `confidence.ts` and only there.
 - Do NOT read source files, `.env*`, secrets, or arbitrary user
   files when stack-detecting in mini / max mode. The allowlist
   above (`package.json`, `composer.json`, `pyproject.toml`,
@@ -284,8 +284,8 @@ For `low`, the question replaces the AC list:
 
 - [`refine-ticket`](../refine-ticket/SKILL.md) — sibling for ticket-shaped input
 - [`prompt-optimizer`](../prompt-optimizer/SKILL.md) — engine-outbound sibling; same `prompt_optimization` setting controls its mode
-- [`work_engine.resolvers.prompt`](../../templates/scripts/work_engine/resolvers/prompt.py) — envelope builder
-- [`work_engine.scoring.confidence`](../../templates/scripts/work_engine/scoring/confidence.py) — rubric + band thresholds
+- [`work_engine/resolvers/prompt.ts`](../../templates/scripts/work_engine/resolvers/prompt.ts) — envelope builder
+- [`work_engine/scoring/confidence.ts`](../../templates/scripts/work_engine/scoring/confidence.ts) — rubric + band thresholds
 - [`ask-when-uncertain`](../../rules/ask-when-uncertain.md) — one-question-per-turn Iron Law
 - [`artifact-drafting-protocol`](../../rules/artifact-drafting-protocol.md) — this skill was drafted under it
 - AI Council session: `agents/runtime/council/responses/prompt-master-mini.json` (2026-05-17) — analysis behind the mini/max split and `/raw` bypass <!-- council-ref-allowed: ADR decision trace -->

package/dist/agent-src/skills/refine-ticket/SKILL.md

@@ -105,17 +105,14 @@ bullets + body.
 **Auto-fetch parent (Phase F4).** Before detection, check the
 issue type and fold parent context in:
 
-```python
-from scripts.refine_ticket_detect import (
-    issuetype_needs_parent, fold_parent_context,
-)
-
-if issuetype_needs_parent(ticket["issuetype"]):
-    parent_key = ticket["parent_key"]          # from `fields.parent.key`
-    parent = fetch_jira_issue(parent_key)      # +1 API call
-    ticket_body = fold_parent_context(
-        ticket_body, parent_body=parent["body"], parent_key=parent_key,
-    )
+```ts
+import { issuetype_needs_parent, fold_parent_context } from 'scripts/refine_ticket_detect.js';
+
+if (issuetype_needs_parent(ticket.issuetype)) {
+    const parentKey = ticket.parent_key;        // from `fields.parent.key`
+    const parent = fetch_jira_issue(parentKey); // +1 API call
+    ticketBody = fold_parent_context(ticketBody, parent.body, parentKey);
+}
 ```
 
 Rules:
@@ -146,9 +143,9 @@ logic in prose:
 
 ```bash
 ./agent-config refine-ticket:detect <ticket-body-file>
-# or, inside the skill run:
-from scripts.refine_ticket_detect import detect, load_map
-decision = detect(ticket_body, load_map(), cwd=Path.cwd())
+# or, inside the skill run (scripts/refine_ticket_detect.ts):
+#   import { detect, load_map } from 'scripts/refine_ticket_detect.js';
+#   const decision = detect(ticketBody, load_map(), process.cwd());
 ```
 
 The helper consumes [`detection-map.yml`](detection-map.yml) (co-located
@@ -179,8 +176,8 @@ risks instead of inventing terms.
 
 The match lists and `require_count` thresholds are owned by
 `detection-map.yml` — edit the map, not this skill. Tests:
-[`tests/test_refine_ticket_detect.py`](../../../tests/test_refine_ticket_detect.py)
-(17 cases, DE + EN fixtures, repo-aware + graceful-degrade coverage).
+[`tests/scripts/refine_ticket_detect.test.ts`](../../../tests/scripts/refine_ticket_detect.test.ts)
+(DE + EN fixtures, repo-aware + graceful-degrade coverage).
 
 ### 3. Orchestrate
 
@@ -279,17 +276,19 @@ Source: adapted from an external reference `writing-plans/SKILL.md` § Self-Revi
 **Probe write access first (Phase F6).** Before rendering, do a
 cheap upfront check:
 
-```python
-from scripts.refine_ticket_detect import render_close_prompt
+```ts
+import { render_close_prompt } from 'scripts/refine_ticket_detect.js';
 
-try:
-    me     = jira_get("/myself")               # existence → auth works
-    meta   = jira_get(f"/issue/{key}/editmeta")# fields → write access
-    write  = bool(meta.get("fields"))
-except Exception:
-    write = None                                # probe itself failed
+let write: boolean | null;
+try {
+    const me = jira_get('/myself');                 // existence → auth works
+    const meta = jira_get(`/issue/${key}/editmeta`); // fields → write access
+    write = Boolean(meta.fields);
+} catch {
+    write = null;                                    // probe itself failed
+}
 
-print(render_close_prompt(write))
+console.log(render_close_prompt(write));
 ```
 
 Behaviour:

package/dist/agent-src/skills/refine-ticket/detection-map.yml

@@ -2,7 +2,7 @@
 #
 # Declares which sub-skills fire on which ticket-body signals.
 # Consumed by:
-#   - scripts/refine_ticket_detect.py  (deterministic helper, pytest-covered)
+#   - scripts/refine_ticket_detect.ts  (deterministic helper, vitest-covered)
 #   - the refine-ticket skill's Step 2  (cites this file, never re-derives)
 #
 # Schema:

package/dist/agent-src/skills/review-routing/SKILL.md

@@ -60,13 +60,12 @@ using [`reviewer-awareness`](../../rules/reviewer-awareness.md).
 **Also** pull agent-written signals via the shared abstraction (see
 [`memory-access`](../../../docs/guidelines/agent-infra/memory-access.md)):
 
-```python
-from scripts.memory_lookup import retrieve
-extra = retrieve(
-    types=["ownership", "historical-patterns", "incident-learnings"],
-    keys=<changed file paths>,
-    limit=5,
-)
+```bash
+agent-config memory:lookup \
+  --types ownership,historical-patterns,incident-learnings \
+  --key <changed file path> \
+  --limit 5
+# Repeat --key per changed path.
 ```
 
 Treat `source: "curated"` as equal-trust to the project YAML.

package/dist/agent-src/skills/roadmap-management/SKILL.md

@@ -88,7 +88,7 @@ Common shapes:
 - Symfony bundles — `src/Bundle/{Bundle}/agents/roadmaps/`
 - Node / Python / Go monorepo packages — `packages/{Pkg}/agents/roadmaps/`
 
-Use `scripts/_lib/agent_settings.py::enumerate_modules()` to discover the
+Use `scripts/_lib/agent_settings.ts::enumerate_modules()` to discover the
 actual paths in the current project; never assume `app/Modules/`.
 
 The file `.augment/templates/roadmaps.md` defines the canonical structure.
@@ -152,11 +152,16 @@ Every roadmap follows this structure:
 ### Quality gates
 
 Every roadmap implicitly includes the project's quality pipeline
-(static analysis, autofixes, tests). What's configurable is **when**
-the pipeline runs during `/roadmap:process-step|phase|full`,
-controlled by `roadmap.quality_cadence` in `.agent-settings.yml`:
-
-| Cadence | Pipeline runs | Trade-off |
+(static analysis, autofixes, tests). Whether the agent runs it locally
+at all is gated by `quality.local_auto_run`: `false` or missing (the
+default) → agent never runs the pipeline locally; user runs it
+manually, remote CI on the PR is the authoritative gate (run-end
+report: *"quality gates delegated to remote CI"*; new-gate carve-out
+steps still run once). When `local_auto_run: true`, **when** the
+pipeline runs during `/roadmap:process-step|phase|full` is controlled
+by `roadmap.quality_cadence` in `.agent-settings.yml`:
+
+| Cadence | Pipeline runs (`local_auto_run: true` only) | Trade-off |
 |---|---|---|
 | `end_of_roadmap` (default) | Once before archiving | Fastest, fewest tokens; errors compound across phases |
 | `per_phase` | After every completed phase + final | Balanced; catches drift at phase boundaries |

package/dist/agent-src/skills/rule-refactor/SKILL.md

@@ -31,7 +31,7 @@ Do NOT use this skill for:
 
 **Threshold-lift is forbidden.** When the budget breaches, the
 content must shrink — not the gate. Loosening `FAIL_THRESHOLD` in
-`scripts/measure_augment_budget.py` to make CI pass is an explicit
+`scripts/measure_augment_budget.ts` to make CI pass is an explicit
 anti-pattern. The only valid budget-growth move is an ADR that
 raises `TOTAL_CAP`.
 

package/dist/agent-src/skills/rule-writing/SKILL.md

@@ -101,11 +101,11 @@ fail `./scripts-run src/scripts/lint_load_context`. Canonical reference:
 | `triggers[].path_prefix:` | **Literal match pattern** the host evaluates against the file the agent is editing — not rewritten | `src/skills/` (source-of-truth rules) or `agents/`, `app/`, `.augment/` |
 | Body links to guidelines / contracts | **Verbatim relative form** — `../../docs/...` works in any markdown viewer; rewriter handles depth | `[guideline](../../docs/guidelines/<group>/<name>.md)` |
 
-The condense-time rewriter (`scripts/condense.py::_rewrite_paths`) is
+The condense-time rewriter (`scripts/condense.ts::_rewrite_paths`) is
 idempotent and depth-aware — it resolves logical names and body links
 to the deployment-correct relative path at condense time, leaving
 `path_prefix:` literally as written. The schema regex
-(`scripts/schemas/rule.schema.json`) and `scripts/lint_load_context.py`
+(`scripts/schemas/rule.schema.json`) and `scripts/lint_load_context.ts`
 both reject the `src/` prefix in `load_context:` /
 `load_context_eager:` with an error pointing at the canonical logical
 name.
@@ -146,7 +146,7 @@ invoke [`rule-refactor`](../rule-refactor/SKILL.md). Do NOT:
 
 * Trim the new rule further to "just fit" — if it needs that body to
   do its job, the rule is right and the rule set around it is wrong.
-* Raise `FAIL_THRESHOLD` in `scripts/measure_augment_budget.py` —
+* Raise `FAIL_THRESHOLD` in `scripts/measure_augment_budget.ts` —
   threshold-lift is explicitly forbidden (see the
   [`validation-budget`](../../rules/validation-budget.md) rule and
   the `rule-refactor` Iron Law).
@@ -162,7 +162,7 @@ move-to-context / promote-to-skill so the new rule earns its space.
 ### 6. Governance baseline (when introducing a new linter check)
 
 **Advisory, reviewer-checked — no CI gate.** When the same PR adds a
-new check to `scripts/skill_linter.py` (or strengthens an existing
+new check to `scripts/skill_linter.ts` (or strengthens an existing
 one) such that previously-clean rules now warn, the PR body MUST
 record the pre-existing violations on `main` in a Markdown table:
 
@@ -250,7 +250,7 @@ to every rule you author.
 ## Cloud Behavior
 
 On cloud surfaces (Claude.ai Web, Skills API) the package's
-`scripts/skill_linter.py`, `scripts/condense.py`, and `task` runner
+`scripts/skill_linter.ts`, `scripts/condense.ts`, and `task` runner
 are not reachable. The skill still applies — with prose-only
 validation: