@event4u/agent-config 6.0.0 → 7.0.0

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

@@ -154,6 +154,60 @@ Follow-up is **not** authored from scratch — deferred steps copied
 verbatim (with phase context). Preserves plan exactly as author
 originally wrote it.
 
+### 8. Source-derived & capability-adoption roadmaps (conditional)
+
+Fires **only** when roadmap originates from external input or adopts
+capabilities into the suite:
+
+- competitive / capability harvest, external suggestion, or external
+  LLM ideation thread, **or**
+- decision to integrate/adopt new skills, commands, or a pack, **or**
+- plan whose design has genuinely contested, unresolved trade-offs.
+
+Ordinary internally-originated roadmap → **skip this section**; §§ 0–7
+are the whole job. Don't bolt a Provenance block or gap-table onto a
+plan needing neither (template rule 18).
+
+When it fires, add four moves to §§ 0–7:
+
+**A. Gap-table before drafting (don't adopt — integrate).** Audit each
+proposed item against the *existing* skill / command / rule surface;
+classify `KEEP` (verified gap), `FOLD` (into a named existing artefact),
+`CUT` (already covered). Only `KEEP` items become scope; `FOLD`/`CUT`
+recorded so the cut is auditable. Negative grep ≠ proof — open the
+nearest existing artefacts (per
+[`think-before-action`](../../rules/think-before-action.md); for an
+external source,
+[`external-reference-deep-dive`](../../rules/external-reference-deep-dive.md)).
+
+**B. Resolve contested design in council *first*, then author.** Default
+council flow (`/roadmap:ai-council`) *challenges a finished roadmap*. For
+a contested/source-derived plan, run council **up front** on the design
+questions (`/council:design`, or the
+[`ai-council`](../ai-council/SKILL.md) skill), converge, **then** write
+the roadmap encoding the verdicts — ships already-decided, not as open
+questions in prose. One run, converge; don't relitigate.
+
+**C. Encode the decision so it survives.**
+- Inline council convergence under `## Council notes (<date>, <depth>)`
+  — members + date, **never** a session filepath
+  ([`no-roadmap-references`](../../rules/no-roadmap-references.md)).
+- Add `## Provenance` — source by **neutral descriptor** (never the raw
+  competitor/tool name,
+  [`source-confidentiality`](../../rules/source-confidentiality.md));
+  retain the real link as an `ENC1:` token via
+  `src/scripts/_lib/link_crypto.ts encrypt --value <url>`.
+- Save the locked decision to memory (project type, "don't relitigate")
+  so a future session does not re-derive it.
+
+**D. Make "integration, not dump" a testable acceptance criterion.** AC
+encodes the anti-dump litmus, decidably: visible commands within the
+pack's `size_class` budget; each new visible command reuses ≥ 2 existing
+skills; no new artefact duplicates an existing one; governance preflight
+recorded — `domain-adoption-policy` (new domain?), `persona-governance`
+(new personas?), `framework-neutrality`, `size-enforcement` —
+disposition stated in the roadmap.
+
 ## Output format
 
 A single Markdown file at `agents/roadmaps/{name}.md`:
@@ -192,6 +246,10 @@ to every roadmap you author.
 3. Are checkboxes present in every non-intro phase?
 4. Are exit criteria decidable, or vibe-based ("looks good")?
 5. Is content duplicated from another roadmap (supersession instead)?
+6. *Source-derived/adoption only (§ 8):* gap-table (`KEEP`/`FOLD`/`CUT`)
+   behind the scope? `## Provenance` block with `ENC1:` link? inlined
+   council convergence? anti-dump acceptance criterion? (Internally
+   originated → these must be **absent**, not empty.)
 
 ## Do NOT
 
@@ -219,6 +277,15 @@ to every roadmap you author.
 * Use ALL-CAPS Iron-Law fenced blocks — those belong in
   [`kernel-membership`](../../../docs/contracts/kernel-membership.md)-listed
   rules, not roadmaps.
+* Adopt items from an external source / harvest **without a
+  `KEEP`/`FOLD`/`CUT` gap-table** against the existing surface (§ 8) —
+  skill dump, not integration.
+* Add a `## Provenance` block (or gap-table) to an **internally
+  originated** roadmap — § 8 is conditional; an empty Provenance section
+  is noise (template rule 18).
+* Name the raw competitor / tool in a tracked roadmap, or paste a raw
+  source link — anonymize + `ENC1:`-encrypt
+  ([`source-confidentiality`](../../rules/source-confidentiality.md)).
 
 ## Gotchas
 
@@ -238,6 +305,15 @@ to every roadmap you author.
   "merge PR #X" or "commit phase Y" couple roadmap closure to git
   operations the user has not authorized. Roadmap completion is
   decoupled from delivery; ship-the-PR is its own decision.
+- **Adopting an external suggestion verbatim** — a harvest/suggestion
+  roadmap copying the source's item list without the § 8
+  `KEEP`/`FOLD`/`CUT` audit becomes a skill dump: existing items get
+  rebuilt, fold-candidates spawn duplicates. The gap-table is the
+  integration discipline.
+- **Council-as-afterthought** — running council only *after* a contested
+  roadmap is written wastes the convergence: the plan still reads as
+  open questions. Source-derived/contested → council *first* (§ 8.B),
+  then author the verdicts.
 
 ## Examples
 

package/dist/agent-src/skills/root-cause-frameworks/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: root-cause-frameworks
+description: "Use when tracing the root cause of a resolved incident or recurring bug — 5-whys chain, fishbone categorisation, contributing-factors split — even if the user says 'why does this keep breaking?'."
+source: package
+domain: quality
+model_tier: high
+workspaces:
+  - engineering
+packs:
+  - analysis-workbench
+lifecycle: active
+trust:
+  level: professional
+  confidence: medium
+  human_review_required: false
+install:
+  default: false
+  removable: true
+---
+
+# root-cause-frameworks
+
+> Structured root-cause analysis for resolved incidents and recurring bugs.
+> Sibling of [`systematic-debugging`](../systematic-debugging/SKILL.md) (live
+> reproduction loop) and [`bug-analyzer`](../bug-analyzer/SKILL.md) (static
+> call-site analysis) — this skill takes the post-resolution "why did this
+> happen and how do we stop it recurring?" view.
+
+## When to use
+
+- A resolved incident needs a structured cause investigation before
+  writing the post-mortem.
+- A bug recurs and the team needs to understand the underlying system
+  condition, not just the symptom.
+- Invoked directly or by [`blameless-post-mortem`](../blameless-post-mortem/SKILL.md)
+  to populate the cause section.
+
+Do NOT use when:
+
+- Actively debugging a failing test or unresolved crash — use
+  [`systematic-debugging`](../systematic-debugging/SKILL.md) instead.
+- The goal is to enumerate call-site impact of a change — use
+  [`blast-radius-analyzer`](../blast-radius-analyzer/SKILL.md) instead.
+
+## Procedure
+
+Work through the three methods in order; return the best-supported result.
+
+### 1. 5-Whys chain
+
+Ask "Why did X happen?" iteratively, attaching **evidence** to each
+link. Continue until the link is unfalsifiable, evidence runs out, or
+you reach a systemic condition outside the team's control.
+
+Rules:
+
+- Each link must cite at least one piece of evidence (log line, metric,
+  test failure, code path, human observation). Label unverified links
+  explicitly as `[speculative]`.
+- If a link branches into two independent causes, follow both — a
+  branching chain is common and valid.
+- Stop a branch when: (a) the next Why has no available evidence, or
+  (b) the answer is outside the system boundary (e.g. "the cloud
+  provider had an outage").
+
+### 2. Fishbone / Ishikawa (if chain stalls or branches widely)
+
+When the 5-whys chain stalls before reaching a systemic cause, or
+branches into more than three independent paths, map contributing
+factors across six categories:
+
+| Category | Sample questions |
+|---|---|
+| People | Knowledge gap, on-call fatigue, ambiguous ownership? |
+| Process | Missing review step, deploy gate skipped, alert threshold wrong? |
+| Technology | Library version, configuration drift, race condition, hardware limit? |
+| Data | Unexpected input shape, stale cache, missing validation, schema mismatch? |
+| Environment | Infra difference between environments, dependency version skew? |
+| Communication | Unclear spec, siloed knowledge, delayed escalation? |
+
+List each identified factor as a bullet under its category. A factor
+may appear in more than one category — that is evidence of a systemic
+coupling worth naming.
+
+### 3. Contributing-factors split
+
+Classify every cause surfaced in steps 1–2 into exactly one bucket:
+
+| Bucket | Definition |
+|---|---|
+| `root` | The condition that, if absent, the incident would not have occurred. |
+| `contributing` | A condition that increased likelihood or severity, but not sufficient alone. |
+| `amplifying` | A condition that made recovery slower or harder once the incident started. |
+| `coincidence` | Present at the time but causally unrelated. |
+
+A well-formed analysis typically has **one** root cause and two to
+four contributing causes. Multiple `root` entries indicate the chain
+has not been traced far enough, or that the incident was a genuine
+compound failure — label it explicitly.
+
+## Output
+
+The output has three ordered sections:
+
+1. **Why-chain** — numbered chain, each link with evidence (or
+   `[speculative]` flag) and any branch markers.
+2. **Cause taxonomy** — each identified cause labelled
+   `root` / `contributing` / `amplifying` / `coincidence`, with a
+   one-sentence justification.
+3. **Evidence gaps** — explicit list of claims that could not be
+   verified and what evidence would resolve them. An empty list is
+   fine; omitting the section is not.
+
+May invoke [`systematic-debugging`](../systematic-debugging/SKILL.md) or
+[`bug-analyzer`](../bug-analyzer/SKILL.md) mid-procedure to gather
+evidence for a specific hypothesis, then continue the analysis.
+
+## Do NOT
+
+- Do NOT present a `[speculative]` link as confirmed cause.
+- Do NOT collapse multiple contributing factors into a single root
+  cause to produce a cleaner narrative.
+- Do NOT invent evidence — if a log line is needed but unavailable,
+  name the gap.
+- Do NOT reproduce the systematic-debugging reproduce → isolate → fix
+  loop; this skill assumes the bug is already understood or resolved.
+
+## Gotchas
+
+- Single "root cause" is often an oversimplification — a compound
+  failure with one root and several contributing causes is the norm,
+  not an edge case.
+- An unfalsifiable why-link (e.g. "we don't know") is a stop signal
+  for that branch; do not guess past it.
+- Correlation ≠ causation — require a causal mechanism for every link,
+  not just temporal proximity.
+
+## See also
+
+- [`blameless-post-mortem`](../blameless-post-mortem/SKILL.md) — invokes
+  this skill for the cause section.
+- [`systematic-debugging`](../systematic-debugging/SKILL.md) — live
+  reproduction and fix loop.
+- [`bug-analyzer`](../bug-analyzer/SKILL.md) — static call-site analysis.
+- [`risk-officer`](../risk-officer/SKILL.md) — mitigation framing for
+  corrective actions after the cause is established.

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

@@ -40,8 +40,8 @@ raises `TOTAL_CAP`.
 ### 1. Inspect the current budget state
 
 ```bash
-python3 scripts/measure_augment_budget.py --json > /tmp/budget-before.json
-python3 scripts/measure_rule_budget.py --json > /tmp/rule-budget-before.json
+./scripts-run src/scripts/measure_augment_budget --json > /tmp/budget-before.json
+./scripts-run src/scripts/measure_rule_budget --json > /tmp/rule-budget-before.json
 ```
 
 ### 2. Run the audit pipeline
@@ -49,9 +49,9 @@ python3 scripts/measure_rule_budget.py --json > /tmp/rule-budget-before.json
 The audit infrastructure already exists — compose it:
 
 ```bash
-python3 scripts/audit_auto_rules.py      # → agents/runtime/reports/auto-rules-audit.{json,md}
-python3 scripts/audit_overlap.py         # → appends overlap pairs to the MD
-python3 scripts/audit_likelihood.py      # → agents/runtime/reports/auto-rules-likelihood.json
+./scripts-run src/scripts/audit_auto_rules      # → agents/runtime/reports/auto-rules-audit.{json,md}
+./scripts-run src/scripts/audit_overlap         # → appends overlap pairs to the MD
+./scripts-run src/scripts/audit_likelihood      # → agents/runtime/reports/auto-rules-likelihood.json
 ```
 
 Then read `agents/runtime/reports/auto-rules-audit.md` end-to-end.
@@ -94,9 +94,9 @@ For each approved verdict:
 
 ```bash
 bash scripts/condense.sh --sync
-python3 scripts/condense.py --generate-tools
-python3 scripts/measure_augment_budget.py --check   # must exit 0
-python3 scripts/skill_linter.py --all               # 0 FAIL
+./scripts-run src/scripts/condense --generate-tools
+./scripts-run src/scripts/measure_augment_budget --check   # must exit 0
+./scripts-run src/scripts/skill_linter --all               # 0 FAIL
 ```
 
 Then run your package's full CI pipeline (see `Taskfile.yml` for the
@@ -107,7 +107,7 @@ canonical sequence) before pushing.
 Append a snapshot to `agents/.augment-budget-history.jsonl`:
 
 ```bash
-python3 scripts/measure_augment_budget.py --trend-append
+./scripts-run src/scripts/measure_augment_budget --trend-append
 ```
 
 Commit the cleanup as a separate chunk from any rule-add commits so

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

@@ -90,8 +90,8 @@ no silent edits, max two rounds.
 ### 3b. Path conventions in frontmatter and body — load-bearing
 
 Three different surfaces, three different rules. Mixing them up will
-either fail the schema (`python3 scripts/validate_frontmatter.py`) or
-fail `python3 scripts/lint_load_context.py`. Canonical reference:
+either fail the schema (`./scripts-run src/scripts/validate_frontmatter`) or
+fail `./scripts-run src/scripts/lint_load_context`. Canonical reference:
 [`templates/rule.md`](../../templates/rule.md) § Path conventions and
 [`docs/contracts/load-context-schema.md`](../../../docs/contracts/load-context-schema.md).
 
@@ -126,10 +126,10 @@ the PR or split by responsibility.
 
 ### 5. Validate
 
-* Run `python3 scripts/skill_linter.py src/rules/{name}.md`
+* Run `./scripts-run src/scripts/skill_linter src/rules/{name}.md`
   → must report **0 FAIL**.
 * Run `bash scripts/condense.sh --sync` to regenerate `dist/agent-src/rules/{name}.md`.
-* Run `python3 scripts/condense.py --generate-tools` to project into `.claude/`, `.cursor/`, `.clinerules/`, `.windsurfrules`.
+* Run `./scripts-run src/scripts/condense --generate-tools` to project into `.claude/`, `.cursor/`, `.clinerules/`, `.windsurfrules`.
 * Run the full CI pipeline locally (see `Taskfile.yml` in this repo for
   the script list) — must exit 0 except for tolerated warnings.
 
@@ -138,7 +138,7 @@ the PR or split by responsibility.
 After validation, before declaring the rule done, run:
 
 ```bash
-python3 scripts/measure_augment_budget.py --check
+./scripts-run src/scripts/measure_augment_budget --check
 ```
 
 If utilisation is `≥ 0.95` (or the check exits non-zero), **STOP** and
@@ -206,7 +206,7 @@ and body links (relative `../../docs/...`, rewriter handles depth).
 1. Complete rule file at `src/rules/{name}.md`
 2. Frontmatter fully populated, no placeholders left
 3. Linter output showing 0 FAIL
-4. Confirmation that `bash scripts/condense.sh --sync` + `python3 scripts/condense.py --generate-tools` ran clean
+4. Confirmation that `bash scripts/condense.sh --sync` + `./scripts-run src/scripts/condense --generate-tools` ran clean
 
 ## Gotchas
 
@@ -214,7 +214,7 @@ and body links (relative `../../docs/...`, rewriter handles depth).
 * Defaulting to `always` "just in case" — token cost is real, `auto` is default.
 * Description like "Rule about X" — it must describe *when*, not *what*.
 * Pasting a workflow into a rule — if it has numbered steps, split into a skill.
-* Forgetting to run `python3 scripts/condense.py --generate-tools` — downstream tools stay stale.
+* Forgetting to run `./scripts-run src/scripts/condense --generate-tools` — downstream tools stay stale.
 * Editing `dist/agent-src/rules/` or `.augment/rules/` directly — those are generated.
 
 ## Frugality Standards

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

@@ -138,7 +138,7 @@ Every Taskfile task that wraps a `--quiet`-aware script MUST set
 tasks:
   lint-handoffs:
     silent: true
-    cmd: python3 scripts/lint_handoffs.py {{.QUIET_FLAG}}
+    cmd: ./scripts-run src/scripts/lint_handoffs {{.QUIET_FLAG}}
 ```
 
 The `QUIET_FLAG` var is defined once at the root of `Taskfile.yml`
@@ -156,7 +156,7 @@ do **not** add `silent: true` and do **not** use `{{.QUIET_FLAG}}`.
 
 ### 5. Validate
 
-* Run `python3 scripts/skill_linter.py .agent-src.uncondensed/skills/script-writing/SKILL.md` → 0 FAIL
+* 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 the full CI pipeline locally (see `Taskfile.yml` in this repo for the script list) — must exit 0 except for tolerated warnings

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

@@ -135,7 +135,7 @@ Telemetry / APM     → strip from request/response captures; allowlist headers.
 
 ## Provenance
 
-- Adopted from: `Microck/ordinary-claude-skills@8f5c83174f7aa683b4ddc7433150471983b93131:skills_all/secrets-management/SKILL.md` (MIT, © 2025 Microck) — **Sunset Policy applied**: 346-line provider cookbook reduced to a ~140-line decision framework; per-provider deep-dives externalized to upstream docs below.
+- Adopted from: an external reference (MIT, © 2025 an external reference) — **Sunset Policy applied**: 346-line provider cookbook reduced to a ~140-line decision framework; per-provider deep-dives externalized to upstream docs below.
 - Externalized provider docs:
   - HashiCorp Vault: https://developer.hashicorp.com/vault/docs · https://developer.hashicorp.com/vault/docs/secrets/databases
   - AWS Secrets Manager: https://docs.aws.amazon.com/secretsmanager/ · rotation: https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html

package/dist/agent-src/skills/security-audit/SKILL.md

@@ -116,6 +116,7 @@ For each vulnerability:
 - **security** — complementary: security is about writing secure code, this is about finding holes
 - **universal-project-analysis** — provides context about packages and framework usage
 - **bug-analyzer** — some bugs have security implications (chain when found)
+- **untrusted-input-defense** / **lethal-trifecta-guard** (rules) — prompt-injection / agent-config defense; consult when the audited code ingests untrusted content or wires an autonomous egress path
 
 ## Gotcha
 
@@ -130,3 +131,7 @@ For each vulnerability:
 - Do NOT assume frameworks handle everything — verify middleware and config
 - Do NOT confuse code quality issues with security vulnerabilities
 - Do NOT skip dependency checking — known CVEs are real risks
+
+## See also
+
+- [`docs/threat-model.md`](../../docs/threat-model.md) — package attack surface and trust boundary documentation.

package/dist/agent-src/skills/skill-improvement-pipeline/SKILL.md

@@ -64,6 +64,22 @@ Show the user:
 > → {Promote / Reject / Note / Update existing}
 ```
 
+#### Cross-project promotion signal (surfacing only — never an auto-writer)
+
+Same learning now seen in **≥ 2 distinct projects** → strong candidate for a
+*shared* surface (global rule/skill or a `src/patterns/` recipe), not a
+project-local note. **Surface** it; do **not** auto-write:
+
+```
+> Cross-project: also seen in {other-project}.
+> ≥2 projects ⇒ candidate for a shared surface (global rule / skill / pattern).
+> → surface for promotion (human decides; no auto-write)
+```
+
+A *signal*, not a store: no auto-write, no decay, no runtime (the writable
+per-project learning store stays rejected — [[council-agent-memory-sunset]]).
+The human decides whether the cross-project recurrence justifies promotion.
+
 ### Step 3: Classify
 
 #### Category tag
@@ -96,10 +112,10 @@ Decide what to create:
 - **Update existing** → use `skill-management` skill
 
 After creation:
-1. Run `python3 scripts/skill_linter.py {path}` — must pass (0 fail)
+1. Run `./scripts-run src/scripts/skill_linter {path}` — must pass (0 fail)
 2. Copy to `.augment/`
-3. Mark hash: `python3 scripts/condense.py --mark-done "{relative_path}"`
-4. Regenerate tools: `python3 scripts/condense.py --generate-tools`
+3. Mark hash: `./scripts-run src/scripts/condense --mark-done "{relative_path}"`
+4. Regenerate tools: `./scripts-run src/scripts/condense --generate-tools`
 
 ### Step 5: Decide scope
 

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

@@ -42,7 +42,7 @@ Do not use when:
 7. Validate — condensed version must be: easier to scan, easier to trigger, at least as safe
 
 **Iron rule:** Condensation must NOT weaken validation or remove decision hints that prevent mistakes.
-**Linter gate:** After condensation, run `python3 scripts/skill_linter.py` on the file — must be 0 FAIL.
+**Linter gate:** After condensation, run `./scripts-run src/scripts/skill_linter` on the file — must be 0 FAIL.
 
 ### Mode: Decondense
 **Trigger:** "expand skill", "decondense skill", "make skill clearer"
@@ -56,7 +56,7 @@ Do not use when:
 7. Validate — expanded version must be: clearer, still executable, not noisy
 
 **Iron rule:** Expansion must NOT turn skills into documentation. Add context, not prose.
-**Linter gate:** After expansion, run `python3 scripts/skill_linter.py` on the file — must be 0 FAIL.
+**Linter gate:** After expansion, run `./scripts-run src/scripts/skill_linter` on the file — must be 0 FAIL.
 
 ### Mode: Refactor
 **Trigger:** "refactor skill", "improve skill", "fix skill structure"
@@ -68,7 +68,7 @@ Do not use when:
 5. Refine scope — ensure single responsibility, split if multiple workflows
 6. Compare before/after — must be clearer, at least as executable, not broader
 
-**Linter gate:** After refactoring, run `python3 scripts/skill_linter.py` on the file — must be 0 FAIL.
+**Linter gate:** After refactoring, run `./scripts-run src/scripts/skill_linter` on the file — must be 0 FAIL.
 
 **Independence check:** After refactoring, verify the skill is still executable without opening any guideline.
 If the refactor introduced guideline delegations ("see guideline X"), ensure the Procedure still works standalone.

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

@@ -154,7 +154,7 @@ Before scoring the 5 Killers, verify structure:
 - Gotchas
 - Do NOT
 
-**Linter:** Run `python3 scripts/skill_linter.py` on any skill after review — must be 0 FAIL.
+**Linter:** Run `./scripts-run src/scripts/skill_linter` on any skill after review — must be 0 FAIL.
 
 **Rules** — must be:
 - Short and directive

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

@@ -159,7 +159,7 @@ description: "Use when writing Playwright E2E tests — locators, assertions,
 ```
 
 The *good* version routes correctly on *"my E2E keeps flaking on CI"*
-without naming Playwright. Run `python3 scripts/audit_skill_descriptions.py`
+without naming Playwright. Run `./scripts-run src/scripts/audit_skill_descriptions`
 after writing; if flagged `too-short` or `no-trigger-prefix`, rewrite
 before commit.
 
@@ -320,7 +320,7 @@ each criterion to one falsifiable sentence.
 
 **Loop** (orchestrated by `scripts/run_skill_evals.py`):
 
-1. **Scaffold** — `python3 scripts/run_skill_evals.py scaffold {skill}`
+1. **Scaffold** — `./scripts-run src/scripts/run_skill_evals scaffold {skill}`
    creates `runs/{timestamp}-{baseline,with-skill}/` and seeds each
    scenario's `meta.json`.
 2. **Baseline run** — spawn one sub-agent per scenario **without** the
@@ -331,10 +331,10 @@ each criterion to one falsifiable sentence.
 4. **Grade** — for each scenario, write a `grade.json` file with
    per-assertion pass/fail. Deterministic assertions auto-grade;
    rubric assertions need a grader sub-agent.
-5. **Aggregate** — `python3 scripts/run_skill_evals.py aggregate {skill}
+5. **Aggregate** — `./scripts-run src/scripts/run_skill_evals aggregate {skill}
    --run {timestamp}` produces `runs/{timestamp}-benchmark.json` with
    pass-rate, timing, token deltas baseline-vs-with-skill.
-6. **Report** — `python3 scripts/run_skill_evals.py report {skill}
+6. **Report** — `./scripts-run src/scripts/run_skill_evals report {skill}
    --run {timestamp}` prints the diff. Iterate on the skill body
    until `with-skill` outperforms `baseline` on every scenario.
 
@@ -403,7 +403,7 @@ utility libs, or simple state managers.
 * Including baseline knowledge the model already has
 * Description too long or not a trigger
 * Renaming a heading to "Procedure:" without numbered steps or `###` sub-headings
-* **Always run `python3 scripts/skill_linter.py` before saving — 0 FAIL required**
+* **Always run `./scripts-run src/scripts/skill_linter` before saving — 0 FAIL required**
 
 ## Frugality Standards
 

package/dist/agent-src/skills/skill-writing/evals/triggers.json

@@ -1,5 +1,6 @@
 {
   "skill": "skill-writing",
+  "last_eval": "2026-06-16",
   "description": "5 should-trigger + 5 should-not-trigger queries. No query mentions 'skill-writing' directly. Near-misses share 'skill' vocabulary but route to skill-management, lint-skills, or unrelated skills.",
   "queries": [
     {"q": "let's create a skill for database migrations", "trigger": true},