@event4u/agent-config 9.8.0 → 9.10.0

package/dist/agent-src/skills/learning-tutor/evals/triggers.json

@@ -0,0 +1,52 @@
+{
+    "skill": "learning-tutor",
+    "last_eval": "2026-07-30",
+    "description": "5 should-trigger + 5 should-not-trigger queries. Should-trigger covers DE + EN phrasings for the six tutoring modes — rapid competence, error-driven drill, keystone decoding, goal-backward sprint, gap probe, Feynman check. Should-not-trigger covers the near-miss neighbours (package-artifact learning capture, plan stress-testing, long-form article analysis, employee onboarding programs, plain factual how-to answers) whose vocabulary overlaps.",
+    "queries": [
+        {
+            "q": "teach me Postgres query planning — get me functional fast, practice first",
+            "trigger": true
+        },
+        {
+            "q": "quiz me on database indexes and find my blind spots, don't go easy on me",
+            "trigger": true
+        },
+        {
+            "q": "I don't get this spec — explain it so it actually clicks and then check I understood",
+            "trigger": true
+        },
+        {
+            "q": "bring mir Kubernetes bei und drill mich, statt mir einen Vortrag zu halten",
+            "trigger": true
+        },
+        {
+            "q": "I have to ship a Terraform module in two weeks and I've never used it — give me a learning plan",
+            "trigger": true
+        },
+        {
+            "q": "I keep making this same mistake — turn that learning into a rule for the package",
+            "trigger": false,
+            "note": "capturing a learning as a package artifact (agent learns, not the user) → learning-to-rule-or-skill"
+        },
+        {
+            "q": "poke holes in this migration plan, be brutal",
+            "trigger": false,
+            "note": "stress-testing a plan/artifact, not a person's understanding → adversarial-review"
+        },
+        {
+            "q": "deep-dive this article and extract the insights with mental models",
+            "trigger": false,
+            "note": "long-form content analysis for the reader, no tutoring modes or comprehension gates → deep-reading-analyst"
+        },
+        {
+            "q": "design our onboarding so new hires ramp faster, with 30/60/90 milestones",
+            "trigger": false,
+            "note": "employee onboarding program design, not tutoring a topic → onboarding-program"
+        },
+        {
+            "q": "what's the difference between a left join and an inner join?",
+            "trigger": false,
+            "note": "direct factual question — answer it, never convert it into a curriculum (per direct-answers); the skill explicitly excludes this"
+        }
+    ]
+}

package/dist/agent-src/skills/license-compliance-audit/SKILL.md

@@ -0,0 +1,161 @@
+---
+model_tier: medium
+name: license-compliance-audit
+description: "Run the offline (jscpd) and online (scanoss-py) similarity scanners on demand against a diff or path — the ONLY home of this repo's detection capability; no CI gate exists or ever ran it automatically"
+domain: engineering
+workspaces:
+  - engineering
+packs:
+  - engineering-base
+---
+
+# license-compliance-audit
+
+Gate G0 (`road-to-provenance-and-license-governance`, Phase 0) measured both
+candidate similarity detectors against a frozen golden corpus and neither
+met the pre-registered bar for a CI gate. Council resolved (2026-07-28,
+Option A): **no `lint_code_provenance.ts` in any form — not even
+advisory.** This skill is the result of that decision: the scan capability
+that used to be a planned CI gate now exists only as something a human
+invokes deliberately, so every hit gets investigated *because* a human
+asked for it — never as a silent pipeline signal nobody reads.
+
+## When to use
+
+- Before merging a diff that looks suspiciously similar to something you've
+  seen elsewhere, or that a reviewer flagged.
+- During a periodic self-audit (e.g. the Phase-4 "run the full pipeline on
+  this repo" dogfood exercise).
+- A reviewer or the `origin: uncertain` self-flag from
+  [`code-provenance`](../../rules/code-provenance.md) names a residual-class
+  file worth a closer look.
+
+Do NOT use when:
+
+- You expect this to run automatically in CI — it does not, by explicit
+  council decision; nothing here is wired into any pipeline.
+- You expect a clean result to prove the code was not copied — it cannot;
+  see the scope bound below.
+- You already have a specific, known source to check against a specific
+  license — that's [`license-compliance-borrow-check`](../license-compliance-borrow-check/SKILL.md),
+  a targeted one-source check, not a corpus-wide scan.
+
+## Procedure
+
+1. **Inspect available tooling.** The offline layer (L-1) is always
+   available via `npx`:
+   ```bash
+   npx jscpd --version
+   ```
+   The online layer (L0) is optional — check whether it is installed and
+   reachable:
+   ```bash
+   scanoss-py --version   # or: pip show scanoss
+   ```
+   Offline-only is expected and fine in most environments; report it
+   honestly rather than treating it as a failure.
+2. **Run the offline scan (L-1)** against the target path or diff:
+   ```bash
+   npx jscpd <path> --min-tokens 25
+   ```
+   `--min-tokens 25` is the pre-registered shipping value — the best
+   false-positive-clean point of the S0.3 sweep
+   (`internal/bench/provenance/reports/baseline-2026-07-28.md`). Read every
+   reported clone pair as a **candidate**, never a verdict.
+3. **If L0 is reachable, run the fingerprint scan:**
+   ```bash
+   scanoss-py scan <path>
+   ```
+   Only WFP fingerprints leave the machine, never raw source (privacy by
+   construction, principle 7). If L0 is unreachable, rate-limited, or not
+   installed, report the result as `partial (offline)` explicitly — never
+   claim a full two-layer scan ran.
+4. **Investigate every hit manually.** For each match: is the matched file
+   already in `provenance/borrows.jsonl` (cleared)? Does it read like
+   independent convergence on a common algorithm shape, or an unattributed
+   real copy? Open both files side by side before deciding — a match id is
+   a starting point, not a conclusion.
+5. **Route unresolved hits.** A hit with no existing ledger entry and no
+   independent-convergence explanation routes to
+   [`license-compliance-borrow-check`](../license-compliance-borrow-check/SKILL.md)
+   to classify and draft the entry. Never clear a hit yourself by simply
+   deciding it's fine.
+6. **Report the scope bound alongside every result** (see below) — a clean
+   run means "nothing matched this KB/corpus at this sensitivity", never
+   "no copying happened".
+
+## What the measured numbers mean — and don't
+
+On the frozen synthetic corpus (`internal/bench/provenance/`, 36 files,
+content-sha256 `dbbc84a7…34bb3`):
+
+| layer | verbatim+rename recall | rename-only recall | false positives |
+|---|---:|---:|---:|
+| L-1 jscpd `--min-tokens 25` | 10/16 | 4/8 | 0/12 |
+| L0 scanoss | 4/16 | 0/8 | 2/12 |
+| **union (both layers)** | **12/16** | **4/8** | **2/12** |
+
+Full source: `internal/bench/provenance/reports/baseline-2026-07-28.md`.
+
+- **Scope bound:** the corpus is `synthetic-canonical` — independently
+  authored implementations of well-known algorithm shapes, never fetched or
+  pasted from any upstream file. This measures **transformation-depth
+  sensitivity and false-positive rate on independent code** — it does
+  **not** measure recall against SCANOSS's real-OSS knowledge base. No
+  sample here is indexed anywhere, so a KB lookup returning zero hits says
+  nothing about the detector's real-world recall. Real-KB recall is
+  unmeasured and would need a second, real-snippet corpus.
+- **Rename-only laundering is not reliably caught** — 0/8 (SCANOSS), 4/8
+  (jscpd). The provenance ledger, not this scan, is the anti-launder
+  control (see [`code-provenance`](../../rules/code-provenance.md)).
+- **No tool sees model training data.** Unconscious reproduction from
+  training data is not addressed by this scan at all, regardless of
+  outcome.
+
+## Output format
+
+1. Per scan target: which layer(s) actually ran, hit or clean, and — if
+   the online layer was unreachable — the explicit `partial (offline)`
+   marker (never a silent green presented as a full scan).
+2. For every hit: the matched file/snippet, a manual same-shape-vs-real-copy
+   judgment, and the routing decision (already ledgered / route to
+   `license-compliance-borrow-check` / independent convergence, no action).
+3. The scope-bound paragraph from the section above, restated so the
+   requester never reads a clean result as a copying guarantee.
+
+## Gotcha
+
+- **A clean scan is not proof of originality.** It means "nothing matched
+  at this sensitivity, in this corpus/KB" — never "not copied from
+  training data".
+- **Rename-only copies routinely pass both layers.** Do not trust a clean
+  re-scan after a purely cosmetic rewrite as evidence of real
+  transformation.
+- **Both of SCANOSS's measured false positives came from independently
+  authored files** matching on convergent canonical-algorithm shape (MIT
+  snippet matches) — a hit is an investigation trigger, not an accusation.
+- **Nothing here is wired into CI.** A hit found by this skill never
+  blocked anything automatically; if you expected a pipeline signal, there
+  isn't one — that's the point of Gate G0's Option A resolution.
+
+## Do NOT
+
+- NEVER claim or imply this scan runs in CI — it explicitly does not, by
+  council decision (Gate G0, Option A).
+- NEVER report a scan as complete when the online layer was unreachable —
+  always say `partial (offline)`.
+- NEVER present a clean result as "provably not copied" — restate the
+  scope bound every time a result is shared.
+- NEVER clear a hit without either a ledger entry or a documented
+  independent-convergence judgment.
+
+## See also
+
+- [`code-provenance`](../../rules/code-provenance.md) — the rule that makes
+  the ledger, not this scan, the primary anti-launder control.
+- [`license-compliance-borrow-check`](../license-compliance-borrow-check/SKILL.md) —
+  where an unresolved hit routes for classification + ledger drafting.
+- `internal/bench/provenance/reports/baseline-2026-07-28.md` — the full
+  measured baseline this skill's numbers are drawn from.
+- `docs/CLAIMS.md` — claim `provenance-detector-transformation-sensitivity`
+  (unbacked, carries the same scope bound).

package/dist/agent-src/skills/license-compliance-audit/evals/triggers.json

@@ -0,0 +1,52 @@
+{
+    "skill": "license-compliance-audit",
+    "last_eval": "2026-07-28",
+    "description": "5 should-trigger + 5 should-not-trigger queries. Should-trigger covers running the on-demand jscpd/scanoss similarity scan on a diff or path, and asking whether a diff looks copied from known OSS. Should-not-trigger covers near-miss neighbours (a single named-source license check, notices regeneration, generic code review, dependency vetting) whose vocabulary overlaps.",
+    "queries": [
+        {
+            "q": "this diff looks suspiciously similar to something I've seen, run a similarity scan against known OSS",
+            "trigger": true
+        },
+        {
+            "q": "run jscpd and scanoss on this PR to check for copied code",
+            "trigger": true
+        },
+        {
+            "q": "do a self-audit of the whole repo for potential license violations",
+            "trigger": true
+        },
+        {
+            "q": "check whether this file matches anything in the SCANOSS knowledge base",
+            "trigger": true
+        },
+        {
+            "q": "the reviewer flagged this function as possibly lifted from elsewhere, scan for a match",
+            "trigger": true
+        },
+        {
+            "q": "I want to borrow this specific function from https://github.com/example/repo, check its license",
+            "trigger": false,
+            "note": "single named source, targeted license check → license-compliance-borrow-check"
+        },
+        {
+            "q": "regenerate the third-party notices file from the ledger",
+            "trigger": false,
+            "note": "notices regeneration → license-compliance-credits"
+        },
+        {
+            "q": "review this diff for null-safety and edge cases",
+            "trigger": false,
+            "note": "correctness review, not a similarity scan"
+        },
+        {
+            "q": "is this new npm package real or a hallucinated name?",
+            "trigger": false,
+            "note": "dependency existence check → supply-chain-intake"
+        },
+        {
+            "q": "set up a CI job that blocks merges on copied code",
+            "trigger": false,
+            "note": "no CI gate exists or is planned here — Gate G0 cancelled it; this skill is on-demand only"
+        }
+    ]
+}

package/dist/agent-src/skills/license-compliance-borrow-check/SKILL.md

@@ -0,0 +1,145 @@
+---
+model_tier: medium
+name: license-compliance-borrow-check
+description: "Paste a URL/snippet before you borrow it — detects its license, runs the derived compatibility policy, and drafts a provenance ledger entry — even before any code is written, not after"
+domain: engineering
+workspaces:
+  - engineering
+packs:
+  - engineering-base
+---
+
+# license-compliance-borrow-check
+
+## When to use
+
+- Before adapting, porting, or otherwise consciously reusing an algorithm,
+  a non-trivial structure, or more than roughly ten lines of logic shape
+  from a source you can name (a repo, a gist, a Stack Overflow answer).
+- The [`code-provenance`](../../rules/code-provenance.md) rule fired and its
+  step 3 ("check license compatibility") needs a concrete answer.
+- A reviewer or the `origin: uncertain` self-flag surfaces a borrow that was
+  never checked.
+
+Do NOT use when:
+
+- No conscious borrow happened — a well-known, unpatentable algorithm shape
+  (a for-loop, a hash map) implemented with no specific source in mind.
+- The borrow is already ledgered with a valid entry — use
+  [`license-compliance-credits`](../license-compliance-credits/SKILL.md) to
+  regenerate notices instead.
+- You want a broad similarity scan across the repo, not one source — use
+  [`license-compliance-audit`](../license-compliance-audit/SKILL.md).
+
+## A passing verdict is not a copying clearance
+
+This skill answers ONE question: is the source's license compatible with
+this repo's license, under the derived compatibility policy? An `allow`
+verdict means the license permits the reuse — it says nothing about whether
+the [`code-provenance`](../../rules/code-provenance.md) discipline (read,
+close the source, re-derive against house standards) was actually followed.
+License-clean code that is still a verbatim copy is still a violation of
+that rule. Run both checks; treat neither as a substitute for the other.
+
+## Procedure
+
+1. **Identify the source** — the URL or repo path being borrowed from, and
+   the exact commit or blob SHA the snippet was taken from (`git log -1
+   --format=%H -- <path>` on the source repo, or the URL's own commit ref).
+2. **Detect the source's license.** Check, in order: a `LICENSE`/
+   `LICENSE.md`/`COPYING` file at the source repo root; the source's
+   `package.json` `"license"` field; its `composer.json` `"license"` field;
+   an SPDX header comment in the file itself. If none resolve to a known
+   SPDX id, the license is `unknown` — never guess permissive.
+3. **Detect this repo's target policy.** Run:
+   ```bash
+   npx tsx node_modules/@event4u/agent-config/src/scripts/detect_target_license.ts . --json
+   ```
+   If `license-policy.yaml` exists at the repo root, read its
+   `policy.{allow,conditional,deny}` buckets directly. If it does not (dry
+   run only), derive the same buckets by hand from this repo's own
+   `LICENSE` file and the compatibility matrix in
+   `node_modules/@event4u/agent-config/src/scripts/_lib/detect_target_license.ts`
+   (`COMPATIBILITY_MATRIX`/`classifyBorrow`).
+4. **Classify the borrow.** Map the source's SPDX id to its source class
+   (permissive / weak-copyleft / gpl-2.0 / gpl-3.0 / agpl / sspl /
+   `unknown`), then read the verdict off the target's policy buckets:
+   `allow`, `conditional` (escalate), or `deny`. A source license of
+   `unknown` is **always** `deny` — no exception.
+5. **Act on the verdict:**
+   - `allow` → continue to step 6 (draft the ledger entry).
+   - `conditional` → STOP. Do not write the borrowed code yet. Escalate to
+     the user with the exact matrix cell that triggered it (per
+     [`ask-when-uncertain`](../../rules/ask-when-uncertain.md)) — never
+     auto-clear a conditional verdict.
+   - `deny` → refuse the borrow. Name the alternative: write it from
+     scratch, find a permissively-licensed equivalent, or ask the
+     maintainer for an explicit, recorded exception.
+6. **Draft the ledger entry** — one JSON object matching
+   `node_modules/@event4u/agent-config/src/scripts/schemas/provenance-borrow.schema.json` (`source_url`,
+   `license`, `source_sha`, `borrowed_at`, `files`, `transformation_note`,
+   `cleared_by`). Write a `transformation_note` that names a real
+   structural change — rename-only phrasing (e.g. "renamed variables",
+   "cosmetic rename") is rejected by `lint_provenance.ts` even if the code
+   has not landed yet, so draft it honestly against what will actually
+   change.
+7. **Present the draft to the user before appending it.** Once the
+   re-derived code lands, append the confirmed entry to
+   `provenance/borrows.jsonl` and verify:
+   ```bash
+   npx tsx node_modules/@event4u/agent-config/src/scripts/lint_provenance.ts
+   ```
+   Exit 0 confirms the entry is schema-valid, license-compliant, and its
+   transformation note passed the rename-only phrase check.
+
+## Output format
+
+1. The classification verdict (`allow` / `conditional` / `deny`) with the
+   exact source class → target class cell that produced it, and the source
+   license's SPDX id (or `unknown`).
+2. The draft ledger entry as a fenced JSON block, ready to append verbatim
+   once the user confirms it.
+3. For `conditional` or `deny`, the specific escalation question or refusal
+   reason presented to the user — never a silently auto-resolved verdict.
+
+## Gotcha
+
+- **`allow` is not a copying clearance** — see the section above; run
+  `code-provenance`'s read-close-re-derive discipline regardless of the
+  license verdict.
+- **No `LICENSE` file at the source is not "no license, so it's free"** — an
+  absent license file defaults to strictest (`unknown` → `deny`), not to
+  permissive.
+- **A `conditional` verdict is not a soft "probably fine"** — it is a hard
+  stop pending human escalation; treating it as advisory is the exact
+  Q1 workspace-license failure mode the roadmap's council resolved against.
+- **`license-policy.yaml` missing does not mean skip the check** — derive
+  the policy by hand from the matrix; a missing policy file is a detection
+  gap, not a green light.
+
+## Do NOT
+
+- NEVER append a ledger entry without presenting the draft to the user
+  first.
+- NEVER treat an undetectable license as permissive — `unknown` fails the
+  linter outright and must escalate.
+- NEVER let a `conditional` verdict proceed without the escalation actually
+  happening this turn.
+- NEVER write a `transformation_note` that only describes a rename or
+  formatting change — describe the real structural change, or don't borrow.
+
+## See also
+
+- [`code-provenance`](../../rules/code-provenance.md) — the rule this skill
+  answers step 3 of.
+- [`license-compliance-credits`](../license-compliance-credits/SKILL.md) —
+  regenerates `docs/THIRD-PARTY-NOTICES.md` once the entry lands.
+- [`license-compliance-audit`](../license-compliance-audit/SKILL.md) — the
+  on-demand similarity scan for suspicious diffs, not for a single known
+  source.
+- `node_modules/@event4u/agent-config/src/scripts/detect_target_license.ts`, `node_modules/@event4u/agent-config/src/scripts/_lib/detect_target_license.ts` — the license-policy derivation this skill consumes.
+- `node_modules/@event4u/agent-config/src/scripts/lint_provenance.ts`, `provenance/README.md`,
+  `node_modules/@event4u/agent-config/src/scripts/schemas/provenance-borrow.schema.json` — the ledger + its
+  contract.
+- [`ask-when-uncertain`](../../rules/ask-when-uncertain.md) — the escalation
+  shape for `conditional`/`unknown` verdicts.

package/dist/agent-src/skills/license-compliance-borrow-check/evals/triggers.json

@@ -0,0 +1,52 @@
+{
+    "skill": "license-compliance-borrow-check",
+    "last_eval": "2026-07-28",
+    "description": "5 should-trigger + 5 should-not-trigger queries. Should-trigger covers pasting a source URL/repo to check its license before borrowing, and asking whether a specific borrow is allowed. Should-not-trigger covers near-miss neighbours (regenerating notices, running a broad similarity scan, generic new-dependency intake, plain code review) whose vocabulary overlaps.",
+    "queries": [
+        {
+            "q": "I want to adapt this retry-loop from https://github.com/example/repo — is its license compatible with ours?",
+            "trigger": true
+        },
+        {
+            "q": "this Stack Overflow answer has the algorithm I need, check if I can use it before I write the code",
+            "trigger": true
+        },
+        {
+            "q": "can I borrow this LRU cache implementation, it's under GPL-3.0?",
+            "trigger": true
+        },
+        {
+            "q": "draft a ledger entry for the debounce helper I ported from another repo",
+            "trigger": true
+        },
+        {
+            "q": "what license does this vendored snippet carry and does it clear our policy?",
+            "trigger": true
+        },
+        {
+            "q": "regenerate the third-party notices file, the ledger just changed",
+            "trigger": false,
+            "note": "notices regeneration → license-compliance-credits"
+        },
+        {
+            "q": "run a similarity scan across the whole diff to check for copied code",
+            "trigger": false,
+            "note": "broad corpus scan, no single named source → license-compliance-audit"
+        },
+        {
+            "q": "add lodash to package.json and install it",
+            "trigger": false,
+            "note": "new dependency intake, not a code borrow → supply-chain-intake"
+        },
+        {
+            "q": "review this diff for correctness and style issues",
+            "trigger": false,
+            "note": "generic code review, no borrow involved"
+        },
+        {
+            "q": "what CVEs affect the version of this package we're pinned to?",
+            "trigger": false,
+            "note": "dependency vulnerability scanning, not licensing a borrow"
+        }
+    ]
+}

package/dist/agent-src/skills/license-compliance-credits/SKILL.md

@@ -0,0 +1,97 @@
+---
+model_tier: lite
+name: license-compliance-credits
+description: "Regenerate docs/THIRD-PARTY-NOTICES.md from provenance/borrows.jsonl after any ledger change — even a single new entry — never hand-edit the notices file"
+domain: engineering
+workspaces:
+  - engineering
+packs:
+  - engineering-base
+---
+
+# license-compliance-credits
+
+## When to use
+
+- `provenance/borrows.jsonl` just gained, lost, or changed a line (a new
+  borrow was ledgered via
+  [`license-compliance-borrow-check`](../license-compliance-borrow-check/SKILL.md),
+  or a correction line was appended).
+- `npx tsx node_modules/@event4u/agent-config/src/scripts/lint_provenance.ts`
+  reports the notices file is out of sync with the ledger.
+- Someone asks "are our third-party notices up to date?" or "regenerate the
+  credits file".
+
+Do NOT use when:
+
+- You want to add a NEW borrow — that starts at
+  [`license-compliance-borrow-check`](../license-compliance-borrow-check/SKILL.md);
+  this skill only regenerates the derived file from an already-updated
+  ledger.
+- The ledger itself needs fixing (a deny-class entry, a missing note) — fix
+  the offending line via `license-compliance-borrow-check`'s discipline
+  first; this skill cannot repair a bad ledger, only render it.
+
+## Procedure
+
+1. **Inspect the current state** — read `provenance/borrows.jsonl` (it may
+   be legitimately empty) and note how many lines it has before
+   regenerating, so the diff is checkable.
+2. **Regenerate the notices file:**
+   ```bash
+   npx tsx node_modules/@event4u/agent-config/src/scripts/lint_provenance.ts --regenerate-notices
+   ```
+3. **Diff `docs/THIRD-PARTY-NOTICES.md`** before vs. after — confirm only
+   that generated file changed, and that `provenance/borrows.jsonl` itself
+   was not touched (it is append-only; this command never writes to it).
+4. **Verify sync + validity** with a plain run (no flag):
+   ```bash
+   npx tsx node_modules/@event4u/agent-config/src/scripts/lint_provenance.ts
+   ```
+   Exit code 0 confirms every ledger record is schema-valid, no deny-class
+   or `unknown` license slipped through, no transformation note reads as
+   rename-only, and the notices file now matches the ledger byte-for-byte.
+5. **If the linter fails**, stop — do not hand-patch
+   `docs/THIRD-PARTY-NOTICES.md` to make it pass. Fix the actual offending
+   line in `provenance/borrows.jsonl` via
+   [`license-compliance-borrow-check`](../license-compliance-borrow-check/SKILL.md),
+   then re-run step 2.
+
+## Output format
+
+1. The regenerate command's exit status and a one-line summary of what
+   changed in the notices file (e.g. "added 1 entry: `<source_url>`
+   (`<license>`)", or "no borrows recorded" for the honest empty-ledger
+   state).
+2. The follow-up `lint_provenance` (no flag) exit code, confirming sync —
+   never report success on the regenerate step alone.
+
+## Gotcha
+
+- **`docs/THIRD-PARTY-NOTICES.md` is generated** — a hand-edit is invisible
+  until the next `lint_provenance` run flags the drift as a linter failure,
+  not as an obvious diff. Always regenerate; never patch the file directly.
+- **An empty ledger is the honest starting state, not a bug** — it renders a
+  plain "no borrows recorded" line. Do not "fix" that by adding a
+  placeholder entry.
+- **This skill cannot make a bad ledger pass** — if `lint_provenance`
+  (no flag) still fails after regenerating, the defect is in
+  `provenance/borrows.jsonl`, not in the notices file.
+
+## Do NOT
+
+- NEVER hand-edit `docs/THIRD-PARTY-NOTICES.md`.
+- NEVER skip the post-regenerate `lint_provenance` (no-flag) run —
+  regeneration and validation are two different checks; passing one does
+  not imply the other passed.
+- NEVER add or edit a line in `provenance/borrows.jsonl` from this skill —
+  that belongs to `license-compliance-borrow-check`.
+
+## See also
+
+- [`code-provenance`](../../rules/code-provenance.md) — the rule that makes
+  a ledger entry mandatory before a conscious borrow lands.
+- [`license-compliance-borrow-check`](../license-compliance-borrow-check/SKILL.md) —
+  where new ledger entries are drafted and fixed.
+- `provenance/README.md` — the ledger's append-only contract.
+- `node_modules/@event4u/agent-config/src/scripts/lint_provenance.ts` — the linter this skill wraps.

package/dist/agent-src/skills/license-compliance-credits/evals/triggers.json

@@ -0,0 +1,52 @@
+{
+    "skill": "license-compliance-credits",
+    "last_eval": "2026-07-28",
+    "description": "5 should-trigger + 5 should-not-trigger queries. Should-trigger covers regenerating THIRD-PARTY-NOTICES.md after a ledger change, and asking whether notices are in sync. Should-not-trigger covers near-miss neighbours (drafting a new ledger entry, running a similarity scan, generic changelog/readme updates) whose vocabulary overlaps.",
+    "queries": [
+        {
+            "q": "the borrows ledger just got a new entry, regenerate the notices file",
+            "trigger": true
+        },
+        {
+            "q": "are our third-party notices up to date with provenance/borrows.jsonl?",
+            "trigger": true
+        },
+        {
+            "q": "lint_provenance says NOTICES.md is out of sync, fix that",
+            "trigger": true
+        },
+        {
+            "q": "regenerate the credits file from the ledger",
+            "trigger": true
+        },
+        {
+            "q": "rebuild THIRD-PARTY-NOTICES.md after I appended to borrows.jsonl",
+            "trigger": true
+        },
+        {
+            "q": "draft a new ledger entry for this snippet I want to borrow from an MIT repo",
+            "trigger": false,
+            "note": "new borrow drafting → license-compliance-borrow-check"
+        },
+        {
+            "q": "scan this diff for copied code against known OSS",
+            "trigger": false,
+            "note": "similarity scan → license-compliance-audit"
+        },
+        {
+            "q": "update the CHANGELOG for this release",
+            "trigger": false,
+            "note": "unrelated generated doc, not the provenance ledger"
+        },
+        {
+            "q": "add a new section to the README about installation",
+            "trigger": false,
+            "note": "generic README editing, no ledger involved"
+        },
+        {
+            "q": "check whether this dependency's license is compatible with GPL",
+            "trigger": false,
+            "note": "license compatibility check on a new dep, not notices regeneration"
+        }
+    ]
+}

package/dist/agent-src/skills/llm-provider-knowledge/SKILL.md

@@ -2,7 +2,6 @@
 model_tier: inherit
 name: llm-provider-knowledge
 description: "Before stating any specific fact about an LLM provider's product — models, pricing, limits, context windows, SDK/API — for OpenAI, Gemini, Claude & others, verify against official docs, not memory."
-source: package
 domain: process
 personas: []
 workspaces:

package/dist/agent-src/skills/md-language-check/SKILL.md

@@ -23,7 +23,7 @@ packs:
 
 Fire this skill **before** writing or saving any `.md` file under:
 
-- `.agent-src.uncondensed/` (source of truth — skills, rules, commands, guidelines, templates, contexts)
+- `src/` (source of truth — skills, rules, commands, guidelines, templates, contexts)
 - `dist/agent-src/` (condensed projection)
 - `.augment/` (local agent projection)
 - `agents/` (project-specific roadmaps, contexts, sessions)