@event4u/agent-config 8.1.0 → 8.2.0

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:
 

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

@@ -15,7 +15,7 @@ packs:
 
 ## When to use
 
-* Creating a new Python script in `scripts/{name}.py` (linters, checks, generators, measure tools)
+* Creating a new TypeScript script in `src/scripts/{name}.ts` (linters, checks, generators, measure tools — run via `./scripts-run src/scripts/{name}`)
 * Editing an existing script that prints progress or success lines
 * Wiring a script into `Taskfile.yml` or `taskfiles/*.yml`
 * Reviewing a PR that adds scripts and asking "why does this still print on minimal?"
@@ -48,38 +48,25 @@ family **must** go through Understand → Research → Draft from the
 
 * **Understand** — what failure does this script catch that no existing
   check catches? Is it a one-off (then archive it) or evergreen?
-* **Research** — `ls scripts/check_*.py scripts/lint_*.py`, grep for
-  overlap, skim 1–2 peer scripts (e.g. `lint_handoffs.py`,
-  `check_md_language.py`).
+* **Research** — `ls src/scripts/check_*.ts src/scripts/lint_*.ts`, grep for
+  overlap, skim 1–2 peer scripts (e.g. `lint_handoffs.ts`,
+  `check_md_language.ts`).
 * **Draft** — propose name + one-line purpose first. Only fill the body
   after the shape is confirmed.
 
-### 1. `--quiet` flag — argparse + sys.argv fallback
+### 1. `--quiet` flag — argv check
 
-Every `check_*.py` / `lint_*.py` script MUST accept `--quiet` so the
+Every `check_*.ts` / `lint_*.ts` script MUST accept `--quiet` so the
 silent Taskfile layer (§ 4) can suppress success-only output.
 
-**With argparse (preferred):**
+**Canonical pattern (see e.g. `lint_handoffs.ts`):**
 
-```python
-parser = argparse.ArgumentParser(...)
-parser.add_argument("--quiet", action="store_true",
-                    help="Only print on failure")
-args = parser.parse_args()
-...
-if not args.quiet:
-    print("✅ All clean")
-```
-
-**Plain script (no argparse) fallback:**
-
-```python
-import sys
-
-QUIET = "--quiet" in sys.argv
-...
-if not QUIET:
-    print("✅ All clean")
+```ts
+const QUIET = process.argv.slice(2).includes('--quiet');
+// ...
+if (!QUIET) {
+    console.log('✅ All clean');
+}
 ```
 
 Failure output (`❌`, non-zero exit) is **never** gated — failures must
@@ -90,15 +77,15 @@ always print regardless of `--quiet`.
 For anything richer than a single `✅`/`❌`, import the verbosity-aware
 router instead of raw `print()`:
 
-```python
-from _lib.script_output import info, success, warn, error, flush_summary
+```ts
+import { info, success, warn, error, flush_summary } from './_lib/script_output.js';
 
-info("Loading manifest")          # drops on silent + minimal
-success("Wrote 3 files")          # collected at minimal, printed at verbose
-warn("Skipping stale entry")      # stderr unless silent
-error("Manifest missing")         # stderr always
+info('Loading manifest');          // drops on silent + minimal
+success('Wrote 3 files');          // collected at minimal, printed at verbose
+warn('Skipping stale entry');      // stderr unless silent
+error('Manifest missing');         // stderr always
 
-flush_summary("Done — 3 entries") # one-line summary at minimal
+flush_summary('Done — 3 entries'); // one-line summary at minimal
 ```
 
 Resolution order (first wins, cached for the process):
@@ -110,7 +97,7 @@ Resolution order (first wins, cached for the process):
 
 The resolved level is exported back into `AGENT_SCRIPT_VERBOSITY` so
 child processes inherit it. Tests reset via `reset_level()` from the
-same module — see `tests/test_script_output.py`.
+same module — see `tests/lib/script_output.test.ts`.
 
 ### 3. Iron-Law carve-outs — never silenced
 
@@ -125,8 +112,8 @@ helpers, so verbosity settings cannot suppress them:
 * Any prompt that asks the user for confirmation per
   [`non-destructive-by-default`](../../rules/non-destructive-by-default.md) — Hard Floor cannot be silenced
 
-If unsure, check `scripts/ai_council/one_off_archive/2026-05/_one_off_silent_taskfiles.py`
-`CARVE_OUTS` for the canonical list.
+If unsure, check `src/scripts/ai_council/one_off_archive/2026-05/README.md`
+for the archived carve-out inventory.
 
 ### 4. Taskfile wiring — `silent: true` + `{{.QUIET_FLAG}}`
 
@@ -157,13 +144,13 @@ do **not** add `silent: true` and do **not** use `{{.QUIET_FLAG}}`.
 ### 5. Validate
 
 * Run `./scripts-run src/scripts/skill_linter src/skills/script-writing/SKILL.md` → 0 FAIL
-* Run `python3 scripts/{your-script}.py --quiet` and the verbose path — exit code 0 on clean, non-zero on failure regardless of flag
-* If the script uses `_lib/script_output`, add a test under `tests/` patterned on `tests/test_script_output.py` — assert `silent` / `minimal` / `verbose` behave per § 2
+* Run `./scripts-run src/scripts/{your-script} --quiet` and the verbose path — exit code 0 on clean, non-zero on failure regardless of flag
+* If the script uses `_lib/script_output`, add a test under `tests/` patterned on `tests/lib/script_output.test.ts` — assert `silent` / `minimal` / `verbose` behave per § 2
 * Run the full CI pipeline locally (see `Taskfile.yml` in this repo for the script list) — must exit 0 except for tolerated warnings
 
 ## Output format
 
-1. Script file at `scripts/{name}.py` with `--quiet` accepted
+1. Script file at `src/scripts/{name}.ts` with `--quiet` accepted
 2. Taskfile wiring with `silent: true` + `{{.QUIET_FLAG}}` (unless carve-out)
 3. Test under `tests/` if `_lib/script_output` is used
 4. Linter output showing 0 FAIL
@@ -175,7 +162,7 @@ do **not** add `silent: true` and do **not** use `{{.QUIET_FLAG}}`.
 * Using raw `print()` for progress lines — drops on `minimal`, no inheritance
 * Adding `silent: true` to a release / install-keys task — bypasses the Hard Floor confirmation
 * Editing `Taskfile.yml`'s `QUIET_FLAG` var — single source of truth, do not duplicate
-* Forgetting that `from _lib.script_output import …` requires the script's resolution to walk up to `scripts/` — copy the `Path(__file__).resolve().parent` pattern from a peer
+* Forgetting that `import … from './_lib/script_output.js'` resolves relative to the script's own directory — copy the import path from a peer under `src/scripts/`
 
 ## Frugality Standards
 
@@ -217,7 +204,7 @@ applies — with prose-only validation:
 
 * Emit the full script + Taskfile snippet as copyable Markdown blocks. Do not attempt to write to disk.
 * Self-check: `--quiet` accepted, failures never gated, success lines gated, helper imports look syntactically right.
-* Tell the user to save under `scripts/{name}.py`, wire the Taskfile entry, and run `task lint-skills && task ci` locally before committing.
+* Tell the user to save under `src/scripts/{name}.ts`, wire the Taskfile entry, and run `task lint-skills && task ci` locally before committing.
 * Skip every reference to running the linter or `task` commands yourself — they only run on the user's machine.
 
 ## Examples

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

@@ -70,7 +70,7 @@ Ask: **"Does the model need this to do its job correctly?"**
 
 Skills in `.agent-src.uncondensed/skills/{name}/SKILL.md` AND commands in
 `.agent-src.uncondensed/commands/{name}.md` both project into
-`.claude/skills/` (see `scripts/condense.py` →
+`.claude/skills/` (see `scripts/condense.ts` →
 `generate_claude_skills` + `generate_claude_commands`). Claude treats
 the whole directory as native skills.
 
@@ -158,7 +158,7 @@ generic descriptions cause **undertriggering**. Normative source:
 
 Three rules: name 2+ triggers (domains, symptoms, user phrasing), end with
 `... even if they don't explicitly ask for \`<skill-name>\`.`, and stay
-**≤ 200 characters** (`skill_linter.py` warns `description_too_long` above
+**≤ 200 characters** (`skill_linter.ts` warns `description_too_long` above
 that). When trimming to fit, drop adjectives or the second example phrasing
 before you drop a trigger class or the `even if ...` tail.
 
@@ -336,7 +336,7 @@ rubric:
 via a fresh sub-agent reading the output against the criterion — keep
 each criterion to one falsifiable sentence.
 
-**Loop** (orchestrated by `scripts/run_skill_evals.py`):
+**Loop** (orchestrated by `scripts/run_skill_evals.ts`):
 
 1. **Scaffold** — `./scripts-run src/scripts/run_skill_evals scaffold {skill}`
    creates `runs/{timestamp}-{baseline,with-skill}/` and seeds each

package/dist/agent-src/skills/source-discovery/SKILL.md

@@ -113,12 +113,12 @@ never a build input**:
 
 - Load **negative facts + pointers** as leads (`trust: durable`).
 - Load **positive structure** under **"Assumed (from card · GLOBAL,
-  unverified)"** — record via `evidence_report.py add --bucket assumed --origin
+  unverified)"** — record via `evidence_report.ts add --bucket assumed --origin
   global …` and **re-confirm vs the live source this session** before use
   (version skew / schema drift). Never "Verified" on the global card alone.
 - `public`/`vendor` seen in ≥ `auto_promote_threshold` distinct repos → one-tap
   promotion **suggestion** (never silent); `proprietary` is manual-only. Record
-  sightings via `_lib/knowledge_global_promote.py record-seen`.
+  sightings via `_lib/knowledge_global_promote.ts record-seen`.
 
 ## Missing structure → fixed extension workflow
 
@@ -126,7 +126,7 @@ When the field/endpoint/table you need is **not** there:
 
 1. **Search** the relevant sources.
 2. **Not found** — record the **absence-search log** with `searched` *and*
-   `not_searched` (via `evidence_report.py add --bucket gaps --searched … --not-searched …`).
+   `not_searched` (via `evidence_report.ts add --bucket gaps --searched … --not-searched …`).
 3. **Negative-fact card** — only **after the search is exhausted across all
    relevant sources** for that claim: write `type: anti-hallucination`,
    `polarity: negative`, with `actionable` + `next_step` + a `revalidate_if`

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

@@ -14,7 +14,8 @@ packs:
 
 > **Grounded corpus:** tuning decisions (indexes, keyset pagination, N+1,
 > trigram search, lock contention) ground via the
-> [`database`](../database/SKILL.md) corpus — `ground.py search
+> [`database`](../database/SKILL.md) corpus — `./scripts-run
+> <skills-root>/corpus-grounding/scripts/ground search
 > --manifest <skills-root>/database/data/manifest.json "<symptom>"`.
 
 ## When to use

package/dist/agent-src/skills/subagent-orchestration/SKILL.md

@@ -201,7 +201,7 @@ in [`using-git-worktrees`](../using-git-worktrees/SKILL.md) and
 its `## Output` block → control passes to delegated-skill in a fresh
 worktree → delegated-skill consumes the input shape declared in its
 `## Input` (or `## When the agent should load this`) block. The
-handoff is auditable; `lint_handoffs.py` validates the chain.
+handoff is auditable; `lint_handoffs.ts` validates the chain.
 
 **Example chain (W3 launch):** `positioning-strategy` (worktree A) →
 `messaging-architecture` (worktree B, consumes positioning's

package/dist/agent-src/skills/systematic-debugging/SKILL.md

@@ -104,13 +104,11 @@ Goal: locate the failure in a single component, layer, or call site.
    recent dependency updates, config edits, infra changes.
 4. **Consult memory for prior matches.** Via
    [`memory-access`](../../../docs/guidelines/agent-infra/memory-access.md):
-   ```python
-   from scripts.memory_lookup import retrieve
-   priors = retrieve(
-       types=["incident-learnings", "historical-patterns"],
-       keys=[<error class>, <failing path(s)>],
-       limit=3,
-   )
+   ```bash
+   agent-config memory:lookup \
+     --types incident-learnings,historical-patterns \
+     --key <error class> --key <failing path> \
+     --limit 3
    ```
    A matching `incident-learning` may already name the root cause, the
    fix, and the regression test. A matching `historical-pattern`

package/dist/agent-src/skills/tailwind-engineer/SKILL.md

@@ -53,10 +53,10 @@ one-line comment naming the design source.
 
 Token authoring (DTCG 3-layer model, CSS-var/Tailwind generation) lives
 in [`design-tokens`](../design-tokens/SKILL.md); its
-`tokens.py validate --dir <path>` is the **single token-discipline
+`tokens.ts validate --dir <path>` is the **single token-discipline
 linter** — the mechanical check behind this rule (no hardcoded hex / px /
 rem outside the token files). Greenfield Tailwind config: bundled
-`scripts/tailwind_config_gen.py` (Apache-2.0-derived, pure templating)
+`scripts/tailwind_config_gen.ts` (Apache-2.0-derived, pure templating)
 scaffolds `tailwind.config.{js,ts}` per framework.
 
 ### 2. Compose, don't inline