@event4u/agent-config 7.1.0 → 7.3.0

package/src/scripts/lint_pack_risk_class.ts

@@ -0,0 +1,79 @@
+/**
+ * Lint the `risk_class` invariant on packs (road-to-capability-governance Phase 2).
+ *
+ * `risk_class: high` is the regulated-advice-adjacent tier. A high-risk pack MUST
+ * ship conservatively — off by default, consent-gated, lab-tier — or it is a
+ * governance hole. This linter makes that invariant a hard CI failure.
+ *
+ *   high  ⇒ default_install: false  AND  requires_explicit_consent: true  AND  surface_tier: lab
+ *
+ * `medium` / `low` carry no structural requirement here (their disclaimers live
+ * in the domain safety floors). Absent `risk_class` = `low`.
+ *
+ * Pure core (`riskClassViolations`) takes the packs.yml text so it is unit-testable
+ * without the filesystem. Exit 0 = clean, 1 = at least one violation.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const QUIET = process.argv.includes('--quiet');
+const _HERE = fileURLToPath(import.meta.url);
+const REPO = path.resolve(path.dirname(_HERE), '..', '..');
+const PACKS_YML = path.join(REPO, 'src', 'config', 'discovery', 'packs.yml');
+
+export interface RiskViolation {
+    pack: string;
+    msg: string;
+}
+
+function _field(block: string, key: string): string | undefined {
+    return new RegExp(`(^|\\n)\\s*${key}:\\s*([^\\n#]+)`).exec(block)?.[2]?.trim();
+}
+
+/** Pure invariant check over packs.yml text. */
+export function riskClassViolations(packsYml: string): RiskViolation[] {
+    const out: RiskViolation[] = [];
+    // Split into per-pack blocks on top-level `- id:` entries.
+    const re = /(^|\n)- id:\s*([^\n#]+?)\s*\n([\s\S]*?)(?=\n- id:|\n*$)/g;
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(packsYml)) !== null) {
+        const id = (m[2] ?? '').trim();
+        const block = m[3] ?? '';
+        const risk = _field(block, 'risk_class') ?? 'low';
+        if (risk !== 'high') continue;
+        const checks: Array<[string, string, string]> = [
+            ['default_install', 'false', `${id}: risk_class high requires default_install: false`],
+            ['requires_explicit_consent', 'true', `${id}: risk_class high requires requires_explicit_consent: true`],
+            ['surface_tier', 'lab', `${id}: risk_class high requires surface_tier: lab`],
+        ];
+        for (const [key, want, msg] of checks) {
+            if (_field(block, key) !== want) out.push({ pack: id, msg });
+        }
+    }
+    return out;
+}
+
+function _print(s: string): void {
+    if (!QUIET) process.stdout.write(`${s}\n`);
+}
+
+export function main(): number {
+    if (!fs.existsSync(PACKS_YML)) {
+        _print('⚠️  packs.yml not found — skipping risk_class lint');
+        return 0;
+    }
+    const violations = riskClassViolations(fs.readFileSync(PACKS_YML, 'utf-8'));
+    if (violations.length === 0) {
+        _print('✅  risk_class invariant OK — every high-risk pack is off-by-default + consent + lab');
+        return 0;
+    }
+    _print(`❌  risk_class invariant — ${violations.length} violation(s):`);
+    for (const v of violations) _print(`  - ${v.msg}`);
+    return 1;
+}
+
+if (process.argv[1] !== undefined && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+    process.exit(main());
+}

package/src/scripts/run_skill_evals.ts

@@ -97,6 +97,39 @@ export function _spawn_subagent(
     );
 }
 
+/**
+ * Count "findings" in an eval output for the `finding_floor` assertion
+ * (roadmap `road-to-operator-runtime-harvest`, Phase 1). With an explicit
+ * `pattern`, counts non-overlapping global regex matches; without one, counts
+ * markdown list-item lines (the default shape a skill's findings take).
+ *
+ * Deterministic on purpose: this only *counts*. The substantive judgement —
+ * is each match a real finding, and what should `n` be per host — is the
+ * calibration layer (Phase 1 gold set + per-host floor), which is gated on the
+ * P0 cross-model distributions and therefore NOT wired here yet. So
+ * `finding_floor` is available as a mechanism and exercised by fixtures, but is
+ * not an enforcing CI gate until calibrated.
+ */
+export function _count_findings(output: string, pattern?: string): number {
+    if (pattern !== undefined && pattern !== '') {
+        let re: RegExp;
+        try {
+            re = new RegExp(pattern, 'g');
+        } catch {
+            return 0;
+        }
+        const m = output.match(re);
+        return m ? m.length : 0;
+    }
+    let count = 0;
+    for (const line of output.split('\n')) {
+        if (/^\s*(?:[-*+]|\d+[.)])\s+\S/.test(line)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+
 export function _grade_assertions(
     output: string,
     run_dir: string,
@@ -119,6 +152,11 @@ export function _grade_assertions(
                 pass: null,
                 note: 'rubric grading requires sub-agent — fill in manually or via grader',
             });
+        } else if (kind === 'finding_floor') {
+            const n = (a['n'] as number | undefined) ?? 1;
+            const pattern = a['pattern'] as string | undefined;
+            const count = _count_findings(output, pattern);
+            results.push({ kind, n, count, pass: count >= n });
         } else {
             results.push({ kind: kind ?? null, pass: false, note: `unknown assertion kind ${_pyRepr(kind)}` });
         }

package/src/scripts/schemas/agent-settings.schema.json

@@ -83,6 +83,18 @@
           "description": "How strictly the agent must follow a user-provided prototype / mockup / design system. Consumed by the design-fidelity rule. strict = build 1:1, every visible deviation needs confirmation; structural = structure locked, silent gaps fillable with a stated assumption; hard-floor = any deviation is never autonomous."
         }
       }
+    },
+    "tokens": {
+      "type": "object",
+      "additionalProperties": true,
+      "description": "Token-spend governance for skills marked token_budget_class: rich. See token-budget-discipline rule.",
+      "properties": {
+        "rich_skills": {
+          "type": "string",
+          "enum": ["on", "ask", "off"],
+          "description": "Controls whether skills marked token_budget_class: rich may load in full (exempt from telegraph-speak and thin-projector trimming). on = allowed (default); off = fall back to standard condensed behavior; ask = surface an estimated token delta (tokens, not dollars) and ask the user once per session before loading."
+        }
+      }
     }
   }
 }

package/src/scripts/schemas/skill.schema.json

@@ -182,6 +182,11 @@
         "removable": {"type": "boolean", "default": false}
       },
       "description": "ADR-013 install hints (default-on at consumer install; user-removable)."
+    },
+    "token_budget_class": {
+      "type": "string",
+      "enum": ["lean", "standard", "rich"],
+      "description": "Token-cost class for this skill. `lean` (default): subject to telegraph-speak condensation and thin-projector trimming; optimize for <500 tokens. `standard`: balanced guidance, normal condensation. `rich`: exempt from telegraph-speak and thin-projector trimming; detailed examples preserved; eager-load eligible; ≤15% of skills in a suite may be `rich` (CI-enforced). A `rich` skill MUST carry a '## Why this skill is rich' section explaining the irreducible complexity that makes condensation harmful. Governed by `token-budget-discipline` rule + `tokens.rich_skills` consumer setting. See docs/guidelines/token-budget-governance.md."
     }
   }
 }

package/src/scripts/skill_linter.ts

@@ -1667,7 +1667,7 @@ export function validate_evals_json(skillPath: string): Issue[] {
         );
         return issues;
     }
-    const validKinds = ['contains', 'file_exists', 'rubric'];
+    const validKinds = ['contains', 'file_exists', 'rubric', 'finding_floor'];
     const validKindsSet = new Set(validKinds);
     scenarios.forEach((scenario, idx) => {
         const loc = `scenarios[${idx}]`;
@@ -1709,15 +1709,31 @@ export function validate_evals_json(skillPath: string): Issue[] {
                 );
                 return;
             }
-            const requiredField = { contains: 'value', file_exists: 'path', rubric: 'criterion' }[kind] as string;
-            if (!(requiredField in a) || typeof a[requiredField] !== 'string') {
-                issues.push(
-                    new Issue(
-                        'warning',
-                        'evals_json_assertion_missing_field',
-                        `${aLoc} (kind=${kind}) missing required string field '${requiredField}'`,
-                    ),
-                );
+            if (kind === 'finding_floor') {
+                // finding_floor (run_skill_evals): `n` (number; runtime-defaults to
+                // 1) and `pattern` (regex string) are both OPTIONAL — validate type
+                // only when present, require neither.
+                if ('n' in a && typeof a.n !== 'number') {
+                    issues.push(
+                        new Issue('warning', 'evals_json_assertion_field_type', `${aLoc} (kind=finding_floor) 'n' must be a number`),
+                    );
+                }
+                if ('pattern' in a && typeof a.pattern !== 'string') {
+                    issues.push(
+                        new Issue('warning', 'evals_json_assertion_field_type', `${aLoc} (kind=finding_floor) 'pattern' must be a string`),
+                    );
+                }
+            } else {
+                const requiredField = { contains: 'value', file_exists: 'path', rubric: 'criterion' }[kind] as string;
+                if (!(requiredField in a) || typeof a[requiredField] !== 'string') {
+                    issues.push(
+                        new Issue(
+                            'warning',
+                            'evals_json_assertion_missing_field',
+                            `${aLoc} (kind=${kind}) missing required string field '${requiredField}'`,
+                        ),
+                    );
+                }
             }
         });
     });