@event4u/agent-config 8.7.0 → 8.9.0

package/src/scripts/build_proof.ts

@@ -26,6 +26,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { REPO, LEDGER_REL, load_ledger, pointer_unresolved } from './check_claims.js';
 import { collectSkillGaps } from './check_skill_gaps.js';
 import { loadRows as loadComparisonRows } from './check_comparison.js';
+import { computeStatus as domainSoundnessStatus } from './domain_soundness_status.js';
 
 const _FILE = fileURLToPath(import.meta.url);
 const OUT_REL = 'docs/proof.md';
@@ -107,6 +108,54 @@ function render(): string {
         L.push('Benchmark results are published under `docs/` including measured nulls.');
     }
     L.push('');
+    L.push('**Behavioural-eval coverage — the honest baseline.** Skill *quality* is only');
+    L.push('as good as its measurement. Today **2 of 264** skills carry a behavioural');
+    L.push('`evals.json`, and the highest-traffic / highest-cost tiers (default-surface +');
+    L.push('`rich` + routers, **0 of 35**) are not yet covered. We publish that gap rather');
+    L.push('than imply "264 evaluated skills": coverage is measured per tier');
+    L.push('(`./scripts-run src/scripts/skill_eval_coverage`) and **CI-ratcheted so it can');
+    L.push('only rise** — a merged change can never lower it. Authoring the priority-tier');
+    L.push('evals is gated on per-case human ratification (a generated assertion that');
+    L.push('checks the wrong property is worse than none), so the number grows');
+    L.push('deliberately, not overnight.');
+    L.push('');
+    const ds = domainSoundnessStatus();
+    L.push('**Non-coding domain soundness — scoped, not proven.** The `finance` /');
+    L.push('`founder` / `ops` / `content` profiles sell concrete domain value (DCF,');
+    L.push('runway, RICE, incident command, messaging), but the skills are forged on');
+    L.push('TS/PHP — "promising, not proven" off those stacks. A disclaimer floor');
+    L.push('bounds *liability*, not *correctness*: a skill can be format-correct,');
+    L.push(`disclaimered, and still embed a wrong domain assumption. Today **${ds.validated} of ${ds.total}**`);
+    L.push('default-surface domain skills carry a sourced `domain-truth` fixture');
+    L.push('(`./scripts-run src/scripts/domain_soundness_status`); the rest are labeled');
+    L.push('`unvalidated` and the validated count is CI-ratcheted. The fixtures landed');
+    L.push('so far are the **deterministic** targets (runway, unit-economics, DCF,');
+    L.push('forecasting, scenario band/sensitivity), whose answer keys are computed');
+    L.push('from cited standard formulas — never the skill\'s own output; the');
+    L.push('**rubric** targets (incident command, messaging, fundraising, editorial)');
+    L.push('need domain-competent grounding and remain unvalidated, so validation');
+    L.push('lands deliberately — the gap is published, never implied away.');
+    L.push('');
+    L.push('**Second-brain substrate — measured recall lift, honestly bounded.** On a');
+    L.push('deterministic multi-session recall corpus, the memory substrate beats a');
+    L.push('no-memory baseline AND an equal-byte placebo: memory-on **27/27** vs');
+    L.push('no-memory **10/27** vs placebo **9/27** (claude-haiku-4-5, 9 tasks × 3');
+    L.push('seeds, sign test **p = 0.031** for both pairings) — a real,');
+    L.push('placebo-controlled lift (`internal/bench/reports/second-brain-delta.json`).');
+    L.push('Scoped, not oversold: this is the context-value upper bound (perfect');
+    L.push('retrieval on a one-fact-per-task corpus), NOT retrieval precision under a');
+    L.push('large store; the lift concentrates exactly where memory is the only source');
+    L.push('and ties where the prompt self-contains the fact. Boundary vs a human PKM,');
+    L.push('and why the Obsidian export stays declined, are in');
+    L.push('[`docs/second-brain-scope.md`](second-brain-scope.md).');
+    L.push('');
+    L.push('A follow-up removed the perfect-retrieval assumption: against a store of');
+    L.push('keyword-overlapping confusers the REAL retrieval recalls the needed');
+    L.push('decision into the top-5 (9/9) and the model disambiguates it — retrieval-on');
+    L.push('**27/27** vs no-memory **5/27** and vs placebo **5/27** (p=0.008 both). The');
+    L.push('honest limit: the keyword scorer recalls but does not rank (mean tie-set');
+    L.push('3.3), which is the SQLite-FTS5 activation signal (ADR-116) at scale.');
+    L.push('');
     L.push('## 3. Known limits (published, witness-tested)');
     L.push('');
     const skillGaps = collectSkillGaps();
@@ -164,6 +213,8 @@ function render(): string {
     L.push('task check-refs     # no broken internal references');
     L.push('task check-skill-gaps    # every logged known-limit cites a real witness test');
     L.push('task check-comparison    # every comparison-table "our evidence" pointer resolves');
+    L.push('./scripts-run src/scripts/skill_eval_coverage         # behavioural-eval coverage, per tier');
+    L.push('./scripts-run src/scripts/skill_eval_coverage --check # the ratchet: coverage may not drop');
     L.push('task build-proof-check   # this page is in sync with its sources');
     L.push('```');
     L.push('');

package/src/scripts/chat_history.ts

@@ -43,6 +43,8 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { _entry_tokens_estimate } from './memory_lookup.js';
+
 import { load_agent_settings } from './_lib/agent_settings.js';
 
 export const DEFAULT_FILE = 'agents/runtime/.agent-chat-history';
@@ -708,6 +710,26 @@ export function read_entries(
         agent?: string | null | undefined;
     } = {},
 ): Entry[] {
+    return read_entries_with_refs(options).map((p) => p.entry);
+}
+
+/**
+ * Like {@link read_entries} but each entry carries its `ref` — the 0-based
+ * ordinal in the file's FULL chronological entry list (header excluded,
+ * counted BEFORE any session/agent/last filter), so a ref from an index row
+ * stays valid regardless of the filters a later call applies. Refs are
+ * stable for the append-only log; file rotation invalidates them (documented
+ * — a ref is a within-file locator, not a durable id).
+ * (road-to-memory-retrieval-economy Phase 3.)
+ */
+export function read_entries_with_refs(
+    options: {
+        last?: number | null | undefined;
+        path?: string | null | undefined;
+        session?: string | null | undefined;
+        agent?: string | null | undefined;
+    } = {},
+): Array<{ entry: Entry; ref: number }> {
     const target = options.path ?? file_path();
     const last = options.last ?? null;
     const session = options.session ?? null;
@@ -715,8 +737,9 @@ export function read_entries(
     if (!_isFile(target)) {
         return [];
     }
-    let entries: Entry[] = [];
+    let pairs: Array<{ entry: Entry; ref: number }> = [];
     const lines = _readLines(target);
+    let ref = 0;
     for (let i = 0; i < lines.length; i++) {
         const line = _strip(lines[i] ?? '');
         if (!line) {
@@ -732,23 +755,72 @@ export function read_entries(
             continue;
         }
         if (_isPlainObject(obj)) {
-            entries.push(obj);
+            pairs.push({ entry: obj, ref });
+            ref += 1;
         }
     }
     if (session !== null) {
-        entries = entries.filter((e) => e.s === session);
+        pairs = pairs.filter((p) => p.entry.s === session);
     }
     if (agent !== null) {
         if (agent === AGENT_UNKNOWN) {
-            entries = entries.filter((e) => !e.agent);
+            pairs = pairs.filter((p) => !p.entry.agent);
         } else {
-            entries = entries.filter((e) => e.agent === agent);
+            pairs = pairs.filter((p) => p.entry.agent === agent);
         }
     }
     if (last !== null && last >= 0) {
-        entries = entries.slice(entries.length - last);
+        pairs = pairs.slice(pairs.length - last);
+    }
+    return pairs;
+}
+
+/**
+ * Timeline anchor: the entries around `ref` in the FULL chronological list —
+ * `before`/`after` neighbours plus the anchor itself. JSONL is chronological,
+ * so this is slicing, not indexing (road-to-memory-retrieval-economy P3).
+ * An out-of-range ref returns [].
+ */
+export function slice_around(
+    path_: string | null,
+    ref: number,
+    before = 3,
+    after = 3,
+): Array<{ entry: Entry; ref: number }> {
+    const all = read_entries_with_refs({ path: path_ });
+    if (ref < 0 || ref >= all.length) {
+        return [];
+    }
+    const start = Math.max(0, ref - Math.max(0, before));
+    const end = Math.min(all.length, ref + Math.max(0, after) + 1);
+    return all.slice(start, end);
+}
+
+/**
+ * Compact index row for a history entry: ref + type tag + timestamp-ish
+ * fields when present + a ~100-char preview + the real-tokenizer cost of
+ * fetching the full entry (same lazy-tokenizer contract as memory_lookup's
+ * index rows).
+ */
+export function history_index_row(pair: { entry: Entry; ref: number }): Record<string, unknown> {
+    const e = pair.entry;
+    const text = typeof e.text === 'string' ? e.text : '';
+    const row: Record<string, unknown> = {
+        ref: pair.ref,
+        t: e.t ?? '',
+        preview: text.slice(0, 100),
+        tokens_estimate: _entry_tokens_estimate(e as Record<string, unknown>),
+    };
+    if (typeof e.s === 'string') {
+        row.s = e.s;
+    }
+    for (const tsField of ['ts', 'time', 'started']) {
+        if (typeof (e as Record<string, unknown>)[tsField] === 'string') {
+            row[tsField] = (e as Record<string, unknown>)[tsField];
+            break;
+        }
     }
-    return entries;
+    return row;
 }
 
 export function read_entries_for_current(

package/src/scripts/check_memory.ts

@@ -81,7 +81,9 @@ const CRITICAL_WARN_THRESHOLD = 10;
 const CRITICAL_STALE_DAYS = 90;
 const KNOWN_TYPES: ReadonlySet<string> = new Set([
     'domain-invariants',
+    'historical-patterns',
     'incident-learnings',
+    'ownership',
     'product-rules',
 ]);
 

package/src/scripts/check_quality_regression.ts

@@ -108,6 +108,57 @@ export function evaluatePair(
   return { id: task.id, winner, length_delta, winner_is_longer };
 }
 
+/**
+ * Cohen's Kappa — chance-corrected agreement between two raters over the same
+ * categorical labels (road-to-retrieval-substrate-hardening B7b). 1 = perfect,
+ * 0 = chance-level, <0 = worse than chance. `NaN` when there is no data.
+ */
+export function cohensKappa(labelsA: readonly string[], labelsB: readonly string[]): number {
+  const n = Math.min(labelsA.length, labelsB.length);
+  if (n === 0) return Number.NaN;
+  const cats = new Set<string>();
+  for (let i = 0; i < n; i++) {
+    cats.add(labelsA[i] as string);
+    cats.add(labelsB[i] as string);
+  }
+  let observedAgree = 0;
+  const countA = new Map<string, number>();
+  const countB = new Map<string, number>();
+  for (let i = 0; i < n; i++) {
+    const a = labelsA[i] as string;
+    const b = labelsB[i] as string;
+    if (a === b) observedAgree += 1;
+    countA.set(a, (countA.get(a) ?? 0) + 1);
+    countB.set(b, (countB.get(b) ?? 0) + 1);
+  }
+  const po = observedAgree / n;
+  let pe = 0;
+  for (const c of cats) pe += ((countA.get(c) ?? 0) / n) * ((countB.get(c) ?? 0) / n);
+  if (pe === 1) return 1; // both raters unanimous on one label → perfect by convention
+  return Math.round(((po - pe) / (1 - pe)) * 10000) / 10000;
+}
+
+/**
+ * Second-independent-judge validation: Cohen's Kappa over the two judges'
+ * per-pair winner labels (aligned by task id). A LOW kappa means the win-rate
+ * verdict rests on an unreliable grader — the trustworthiness gap the
+ * token-saving live run surfaced (33% judge-inconsistency), distinct from the
+ * effect-significance the Wilcoxon/McNemar gates already test.
+ */
+export function judgeKappa(resultsA: readonly PairResult[], resultsB: readonly PairResult[]): number {
+  const byIdB = new Map(resultsB.map((r) => [r.id, r.winner]));
+  const a: string[] = [];
+  const b: string[] = [];
+  for (const r of resultsA) {
+    const bw = byIdB.get(r.id);
+    if (bw !== undefined) {
+      a.push(r.winner);
+      b.push(bw);
+    }
+  }
+  return cohensKappa(a, b);
+}
+
 export interface QualityAggregate {
   total: number;
   thin_wins: number;

package/src/scripts/check_roadmap_trackable.ts

@@ -37,10 +37,11 @@ const ROADMAP_ROOT = 'agents/roadmaps';
 // CHECKBOX_RE = re.compile(r"^\s*[-*]\s+\[([ xX~\-])\]\s", re.MULTILINE)
 const CHECKBOX_RE = /^[ \t]*[-*][ \t]+\[([ xX~\-])\][ \t\f\v]/m;
 // PHASE_RE = re.compile(
-//   r"^(#{2,3})\s+Phase\s+(\d+[a-z]?|[IVX]+|[A-Z](?:\d+)?)"
+//   r"^(#{2,3})\s+Phase\s+(\d+(?:\.\d+)*[a-z]?|[IVX]+|[A-Z](?:\d+)?)"
 //   r"(?:[\s:—\-]+(.*?))?\s*$", re.MULTILINE)
+// Numeric ids accept dotted sub-phases ("1.0", "4.1") — mirrors the dashboard's PHASE_RE.
 const PHASE_RE =
-    /^(#{2,3})[ \t\f\v]+Phase[ \t\f\v]+(\d+[a-z]?|[IVX]+|[A-Z](?:\d+)?)(?:[\s:—\-]+(.*?))?[ \t\f\v]*$/gm;
+    /^(#{2,3})[ \t\f\v]+Phase[ \t\f\v]+(\d+(?:\.\d+)*[a-z]?|[IVX]+|[A-Z](?:\d+)?)(?:[\s:—\-]+(.*?))?[ \t\f\v]*$/gm;
 // FRONTMATTER_RE = re.compile(r"\A---\n(.*?)\n---\s*\n", re.DOTALL)
 const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\s*\n/;
 const DRAFT_VALUES: ReadonlySet<string> = new Set(['draft']);

package/src/scripts/condense.ts

@@ -40,6 +40,7 @@ import {
     strip_source_prefix,
 } from './_lib/agent_src.js';
 import { build_claude_hook_matrix } from './_lib/claude_settings_hooks.js';
+import { is_claude_builtin_name } from './_lib/claude_builtin_names.js';
 import { project_settings_path, load_agent_settings } from './_lib/agent_settings.js';
 import { info, success, flush_summary, resolve_level } from './_lib/script_output.js';
 import {
@@ -1529,6 +1530,7 @@ export function generate_claude_commands(active_command_slugs: ReadonlySet<strin
     const current_slugs = new Set<string>();
     let count = 0;
     let skipped = 0;
+    let reserved = 0;
     let rendered = 0;
     const auto = _read_model_auto_switch() === 'auto';
     for (const [source_file, slug] of iterCommands()) {
@@ -1539,6 +1541,15 @@ export function generate_claude_commands(active_command_slugs: ReadonlySet<strin
             skipped += 1;
             continue;
         }
+        // Never claim a `/name` that is a Claude Code built-in command or
+        // bundled skill — a same-name entry shadows the built-in (e.g. a
+        // `review` entry hides Claude Code's own /review). Nested
+        // `/cluster:sub` slugs are hyphen-joined and cannot collide.
+        // See src/scripts/_lib/claude_builtin_names.ts.
+        if (is_claude_builtin_name(slug)) {
+            reserved += 1;
+            continue;
+        }
         current_slugs.add(slug);
 
         const skill_dir = path.join(MODULE_STATE.CLAUDE_SKILLS_DIR, slug);
@@ -1588,6 +1599,9 @@ export function generate_claude_commands(active_command_slugs: ReadonlySet<strin
     if (skipped) {
         msg += ` (${skipped} skipped — same-name skill exists)`;
     }
+    if (reserved) {
+        msg += ` (${reserved} withheld — Claude Code built-in name)`;
+    }
     if (removed_dirs) {
         msg += ` (${removed_dirs} stale dirs removed)`;
     }

package/src/scripts/domain_soundness_status.ts

@@ -0,0 +1,236 @@
+#!/usr/bin/env tsx
+/**
+ * Domain-soundness validation status + ratchet
+ * (road-to-domain-soundness Phase 1 + Phase 3).
+ *
+ * The four non-coding profiles (finance, founder, ops, content_creator) SELL
+ * concrete domain value (DCF, runway, RICE, incident command, messaging), but
+ * the skills are forged on TS/PHP — "promising, not proven" off those stacks.
+ * A disclaimer floor bounds liability, NOT correctness. This tool makes the
+ * provenance honest and machine-checkable: it enumerates the default-surface
+ * domain skills those profiles ship (from source — each profile's
+ * `skills_hint`, never hardcoded) and reports each as:
+ *
+ *   - `validated`   — ships `evals/domain-truth.json` (a sourced answer key,
+ *                     authored by domain competence, distinct from behavioural
+ *                     evals.json). Presence is the machine signal; a passing
+ *                     run against it is the maintainer's Phase-3 gate.
+ *   - `unvalidated` — no domain-truth fixture: general-purpose scaffold, domain
+ *                     correctness not independently validated.
+ *
+ * A domain skill can pass a format/behavioural eval AND carry a disclaimer AND
+ * still embed a wrong domain assumption — this axis is the one that catches it.
+ *
+ * Modes:
+ *   (default)      human report.
+ *   --json         machine-readable.
+ *   --check        ratchet gate (CI): the count of `validated` skills may not
+ *                  drop below the pinned floor (internal/evals/domain-soundness-floor.json);
+ *                  a missing floor is an all-zero floor (bootstrap-inert). The
+ *                  floor only rises via --write-floor after a fixture lands and
+ *                  passes. This is the enforced-honesty gate: it makes a claimed
+ *                  validation impossible to assert without the fixture on disk.
+ *   --write-floor  pin the current validated count as the floor (maintainer
+ *                  action after authoring + running a domain-truth fixture).
+ *
+ * Exit codes: 0 ok / 1 ratchet regression / 2 usage error.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { parse as parseYaml } from 'yaml';
+
+const _HERE = fileURLToPath(import.meta.url);
+export const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+
+/** The non-coding profiles whose default surface this tool scopes. */
+export const NON_CODING_PROFILES: readonly string[] = [
+    'finance',
+    'founder',
+    'ops',
+    'content_creator',
+];
+
+export interface StatusOptions {
+    skillsDir?: string;
+    profilesDir?: string;
+    floorPath?: string;
+}
+
+export interface SkillStatus {
+    skill: string;
+    status: 'validated' | 'unvalidated';
+}
+
+export interface SoundnessReport {
+    validationSet: SkillStatus[];
+    validated: number;
+    unvalidated: number;
+    total: number;
+}
+
+function _skillsDir(o: StatusOptions): string {
+    return o.skillsDir ?? path.join(REPO_ROOT, 'src', 'skills');
+}
+function _profilesDir(o: StatusOptions): string {
+    return o.profilesDir ?? path.join(REPO_ROOT, 'src', 'agent-src', 'profiles');
+}
+export function _floorPath(o: StatusOptions = {}): string {
+    return (
+        o.floorPath ??
+        path.join(REPO_ROOT, 'internal', 'evals', 'domain-soundness-floor.json')
+    );
+}
+
+/** Union of the non-coding profiles' `skills_hint`, restricted to real skills. */
+export function validationSet(o: StatusOptions = {}): string[] {
+    const profilesDir = _profilesDir(o);
+    const skillsDir = _skillsDir(o);
+    const out = new Set<string>();
+    for (const p of NON_CODING_PROFILES) {
+        const f = path.join(profilesDir, `${p}.yml`);
+        let doc: unknown;
+        try {
+            doc = parseYaml(fs.readFileSync(f, 'utf-8'));
+        } catch {
+            continue;
+        }
+        const profile = (doc as { profile?: unknown } | null)?.profile;
+        const defaults = (profile as { defaults?: unknown } | null)?.defaults;
+        const hint = (defaults as { skills_hint?: unknown } | null)?.skills_hint;
+        if (Array.isArray(hint)) {
+            for (const s of hint) {
+                if (typeof s === 'string' && fs.existsSync(path.join(skillsDir, s, 'SKILL.md'))) {
+                    out.add(s);
+                }
+            }
+        }
+    }
+    return [...out].sort();
+}
+
+function _isValidated(skillsDir: string, skill: string): boolean {
+    return fs.existsSync(path.join(skillsDir, skill, 'evals', 'domain-truth.json'));
+}
+
+export function computeStatus(o: StatusOptions = {}): SoundnessReport {
+    const skillsDir = _skillsDir(o);
+    const set = validationSet(o);
+    const validationSetStatus: SkillStatus[] = set.map((skill) => ({
+        skill,
+        status: _isValidated(skillsDir, skill) ? 'validated' : 'unvalidated',
+    }));
+    const validated = validationSetStatus.filter((s) => s.status === 'validated').length;
+    return {
+        validationSet: validationSetStatus,
+        validated,
+        unvalidated: validationSetStatus.length - validated,
+        total: validationSetStatus.length,
+    };
+}
+
+function _readFloor(floorPath: string): number {
+    try {
+        const raw = JSON.parse(fs.readFileSync(floorPath, 'utf-8')) as { validated?: number };
+        return raw.validated ?? 0;
+    } catch {
+        return 0;
+    }
+}
+
+export function writeFloor(o: StatusOptions = {}): SoundnessReport {
+    const report = computeStatus(o);
+    const p = _floorPath(o);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(
+        p,
+        JSON.stringify(
+            {
+                _comment:
+                    'Domain-soundness ratchet floor (road-to-domain-soundness Phase 3). ' +
+                    'domain_soundness_status --check fails if the validated count drops below this. ' +
+                    'Regenerate with --write-floor ONLY after a domain-truth fixture lands and passes.',
+                validated: report.validated,
+            },
+            null,
+            2,
+        ) + '\n',
+    );
+    return report;
+}
+
+export function checkRatchet(o: StatusOptions = {}): { ok: boolean; message: string } {
+    const report = computeStatus(o);
+    const floor = _readFloor(_floorPath(o));
+    if (report.validated < floor) {
+        return {
+            ok: false,
+            message: `validated domain skills ${report.validated} < floor ${floor}`,
+        };
+    }
+    return { ok: true, message: `validated ${report.validated}/${report.total} (floor ${floor})` };
+}
+
+function _renderHuman(r: SoundnessReport): string {
+    const lines = [
+        'Domain-soundness status — non-coding default-surface skills',
+        `  validated:   ${r.validated}/${r.total}`,
+        `  unvalidated: ${r.unvalidated}/${r.total}`,
+        '',
+    ];
+    for (const s of r.validationSet) {
+        const mark = s.status === 'validated' ? '✅' : '·';
+        lines.push(`  ${mark} ${s.skill.padEnd(28)} ${s.status}`);
+    }
+    return lines.join('\n');
+}
+
+export function main(argv: readonly string[] = process.argv.slice(2)): number {
+    const known = new Set(['--json', '--check', '--write-floor']);
+    for (const a of argv) {
+        if (!known.has(a)) {
+            process.stderr.write('usage: domain_soundness_status [--json | --check | --write-floor]\n');
+            return 2;
+        }
+    }
+    if (argv.includes('--write-floor')) {
+        const r = writeFloor();
+        process.stdout.write(`✅  domain-soundness floor pinned: validated ${r.validated}/${r.total}\n`);
+        return 0;
+    }
+    if (argv.includes('--check')) {
+        const { ok, message } = checkRatchet();
+        if (!ok) {
+            process.stdout.write(`❌  domain-soundness ratchet regressed: ${message}\n`);
+            return 1;
+        }
+        process.stdout.write(`✅  domain-soundness ratchet: ${message}.\n`);
+        return 0;
+    }
+    const report = computeStatus();
+    if (argv.includes('--json')) {
+        process.stdout.write(JSON.stringify(report, null, 2) + '\n');
+        return 0;
+    }
+    process.stdout.write(_renderHuman(report) + '\n');
+    return 0;
+}
+
+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;
+    try {
+        return (
+            fs.realpathSync(fileURLToPath(import.meta.url)) ===
+            fs.realpathSync(path.resolve(process.argv[1]))
+        );
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry()) {
+    process.exit(main());
+}

package/src/scripts/external_sources_denylist.json

@@ -54,7 +54,10 @@
     "gztchan",
     "amaancoderx",
     "npxskillui",
-    "\\bskillui\\b"
+    "\\bskillui\\b",
+    "\\bgraphify\\b",
+    "graphify-labs",
+    "penpax"
   ],
   "skip_paths": [
     "src/scripts/check_no_external_sources.py",

package/src/scripts/generate_index.ts

@@ -24,6 +24,7 @@ import {
     iter_commands,
     strip_source_prefix,
 } from './_lib/agent_src.js';
+import { computeStatus as domainSoundnessStatus } from './domain_soundness_status.js';
 
 const _HERE = fileURLToPath(import.meta.url);
 
@@ -398,6 +399,7 @@ export function _render_catalog(
     const publicRules = rules.filter((r) => !INTERNAL_RULES.has(r.name));
     const publicCommands = commands.filter((c) => c.kind === 'command');
     const total = skills.length + publicRules.length + publicCommands.length + guidelines.length;
+    const ds = domainSoundnessStatus();
     const parts = [
         '# agent-config — Public Catalog',
         '',
@@ -410,6 +412,21 @@ export function _render_catalog(
         '',
         `## Skills (${skills.length})`,
         '',
+        '> **Behavioural-eval coverage is measured, not implied.** A skill is',
+        '> behaviourally evaluated only if it ships `evals/evals.json`; most do',
+        '> not yet. Coverage is reported per tier (`./scripts-run',
+        '> src/scripts/skill_eval_coverage`) and CI-ratcheted so it can only rise.',
+        '> Listing here never implies a skill is behaviourally tested — the',
+        '> current coverage and its gap are published on [the proof page](proof.md).',
+        '',
+        '> **Non-coding domain correctness is scoped, not proven.** The',
+        '> `finance` / `founder` / `ops` / `content` skills are forged on TS/PHP',
+        `> codebases; ${ds.validated} of ${ds.total} default-surface domain skills carry a sourced`,
+        '> `evals/domain-truth.json` fixture (deterministic targets, keys from',
+        '> cited formulas); the rest are labeled `unvalidated` until they pass one',
+        '> (`./scripts-run src/scripts/domain_soundness_status`). A disclaimer',
+        '> floor bounds liability, not correctness — see [the proof page](proof.md).',
+        '',
         _render_table(skills, ['kind', 'name', 'extra', 'description'], '../', _to_shipped_path),
         '',
         `## Rules (${publicRules.length})`,