@event4u/agent-config 16.1.0 → 16.3.0

package/src/scripts/sync_gitignore.ts

@@ -31,243 +31,37 @@ import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
-export const SECTION_HEADER = '# event4u/agent-config';
-export const SECTION_FOOTER = '# event4u/agent-config — END';
-export const DEFAULT_GITIGNORE = '.gitignore';
+export {
+    SECTION_HEADER,
+    SECTION_FOOTER,
+    DEFAULT_GITIGNORE,
+    DEFAULT_TEMPLATE,
+    LEGACY_PATTERNS,
+    TemplateNotFoundError,
+    load_template,
+    find_block,
+    block_entries,
+    template_entries,
+    build_fresh_block,
+    sync_block,
+    cleanup_legacy,
+    format_file,
+} from './_lib/gitignore_block.js';
+import {
+    DEFAULT_GITIGNORE,
+    DEFAULT_TEMPLATE,
+    TemplateNotFoundError,
+    load_template,
+    cleanup_legacy,
+    format_file,
+    sync_block,
+    template_entries,
+    _isFile,
+    _splitlines,
+    _strip,
+} from './_lib/gitignore_block.js';
 
 const _HERE = fileURLToPath(import.meta.url);
-// _HERE === <repo>/src/scripts/sync_gitignore.ts ; parents[2] of the .py file
-// is the repo root — two dirs up from src/scripts. the retired Python implementation derives
-// DEFAULT_TEMPLATE = <file>.parent.parent.parent / "src" / "config" /
-// "gitignore-block.txt".
-export const DEFAULT_TEMPLATE = path.join(
-    path.dirname(_HERE),
-    '..',
-    '..',
-    'src',
-    'config',
-    'gitignore-block.txt',
-);
-
-// Legacy patterns that lived in older versions of src/config/gitignore-block.txt
-// before runtime artefacts moved under /agents/runtime/ (May 2026). They get
-// stripped wherever they appear in the consumer's .gitignore — inside the
-// managed block or outside (older installers / hand-edits). Current canonical
-// equivalents (e.g. /agents/runtime/.agent-prices.md) come from the template
-// and are NOT affected. Leading-slash variants are matched defensively.
-//
-// Authoritative source: src/config/agents-paths.yml entries with `legacy: true`.
-// Manual sync until the generation step from the manifest is implemented
-// (road-to-agents-dir-and-gitignore-hygiene Phase 3.2 follow-on).
-export const LEGACY_PATTERNS: readonly string[] = [
-    '.agent-chat-history',
-    '.agent-chat-history.bak',
-    '.agent-chat-history.*.bak',
-    '.agent-prices.md',
-    '.council-tmp/',
-    // 2.x intermediate: prices cache lived directly under agents/ before
-    // consolidating under agents/runtime/.
-    'agents/.agent-prices.md',
-    // Budget history JSONLs — previously listed explicitly at project
-    // root or under agents/; now covered by the /agents/runtime/
-    // catch-all in the managed block.
-    '.augment-budget-history.jsonl',
-    '.rule-budget-history.jsonl',
-    'agents/.augment-budget-history.jsonl',
-    'agents/.rule-budget-history.jsonl',
-];
-
-function _strip(ln: string): string {
-    // Python: ln.rstrip("\n").rstrip() — strip a trailing newline, then strip
-    // all trailing whitespace.
-    return ln.replace(/\n+$/, '').replace(/\s+$/, '');
-}
-
-function _is_entry(ln: string): boolean {
-    // Non-empty, non-comment line = a path/pattern entry.
-    const s = _strip(ln).replace(/^\s+/, '');
-    return Boolean(s) && !s.startsWith('#');
-}
-
-/** Error raised when the template file is missing (→ exit 2 in main). */
-export class TemplateNotFoundError extends Error {
-    constructor(p: string) {
-        super(`template not found: ${p}`);
-        this.name = 'TemplateNotFoundError';
-    }
-}
-
-function _isFile(p: string): boolean {
-    try {
-        return fs.statSync(p).isFile();
-    } catch {
-        return false;
-    }
-}
-
-/** Python str.splitlines() — split on universal newlines, no trailing empty. */
-function _splitlines(text: string): string[] {
-    if (text === '') return [];
-    // str.splitlines() splits on \n, \r, \r\n (and more) and does NOT keep a
-    // trailing empty element. The targets here only ever contain \n / \r\n.
-    const parts = text.split(/\r\n|\r|\n/);
-    if (parts.length > 0 && parts[parts.length - 1] === '') parts.pop();
-    return parts;
-}
-
-export function load_template(p: string): string[] {
-    if (!_isFile(p)) {
-        throw new TemplateNotFoundError(p);
-    }
-    const text = fs.readFileSync(p, 'utf-8');
-    // Keep trailing newlines stripped; we splice explicit newlines.
-    return _splitlines(text).map(_strip);
-}
-
-/**
- * Locate the managed block; return [start_idx, end_idx_exclusive] or null.
- *
- * `start_idx` points at the SECTION_HEADER line.
- * `end_idx_exclusive` points one past the last line of the block.
- * Honors explicit SECTION_FOOTER when present; otherwise treats the
- * block as extending to EOF or to the next non-managed section.
- */
-export function find_block(lines: readonly string[]): [number, number] | null {
-    for (let i = 0; i < lines.length; i += 1) {
-        if (_strip(lines[i] as string) === SECTION_HEADER) {
-            const start = i;
-            // Explicit footer?
-            for (let j = i + 1; j < lines.length; j += 1) {
-                if (_strip(lines[j] as string) === SECTION_FOOTER) {
-                    return [start, j + 1];
-                }
-            }
-            // Legacy: extend to EOF or next non-managed section break.
-            let end = lines.length;
-            for (let j = i + 1; j < lines.length; j += 1) {
-                const s = _strip(lines[j] as string).replace(/^\s+/, '');
-                if (
-                    s.startsWith('#') &&
-                    !s.startsWith('# Agent config') &&
-                    s !== SECTION_HEADER
-                ) {
-                    end = j;
-                    while (end > i + 1 && _strip(lines[end - 1] as string) === '') {
-                        end -= 1;
-                    }
-                    break;
-                }
-            }
-            return [start, end];
-        }
-    }
-    return null;
-}
-
-/** Return entries (paths/patterns) present in the given block. */
-export function block_entries(block_lines: readonly string[]): string[] {
-    return block_lines
-        .filter((ln) => _is_entry(ln))
-        .map((ln) => _strip(ln).replace(/^\s+/, ''));
-}
-
-export function template_entries(template_lines: readonly string[]): string[] {
-    return template_lines.filter((ln) => _is_entry(ln)).map((ln) => ln.replace(/^\s+/, ''));
-}
-
-/** Return a fresh, fully-managed block with START + body + END. */
-export function build_fresh_block(template_lines: readonly string[]): string[] {
-    return [SECTION_HEADER, ...template_lines, SECTION_FOOTER];
-}
-
-/**
- * Return [new_lines, added_entries].
- *
- * - If block missing: append fresh block (preceded by a blank line if the
- *   file's last line is not already empty).
- * - If block present and replace=true: rewrite block in full.
- * - If block present and replace=false: append any missing managed entries
- *   before the END marker (adding END if absent). User-added lines inside the
- *   block are preserved.
- */
-export function sync_block(
-    existing_lines: readonly string[],
-    template_lines: readonly string[],
-    options: { replace?: boolean } = {},
-): [string[], string[]] {
-    const replace = options.replace ?? false;
-    const loc = find_block(existing_lines);
-    const fresh = build_fresh_block(template_lines);
-
-    // Missing block → append with leading blank if needed.
-    if (loc === null) {
-        const newLines = [...existing_lines];
-        if (newLines.length > 0 && _strip(newLines[newLines.length - 1] as string) !== '') {
-            newLines.push('');
-        }
-        newLines.push(...fresh);
-        return [newLines, template_entries(template_lines)];
-    }
-
-    const [start, end] = loc;
-    const head = existing_lines.slice(0, start);
-    let block = existing_lines.slice(start, end);
-    const tail = existing_lines.slice(end);
-
-    if (replace) {
-        const existing = new Set(block_entries(block));
-        const added = template_entries(template_lines).filter((e) => !existing.has(e));
-        return [[...head, ...fresh, ...tail], added];
-    }
-
-    // Append-only mode.
-    const existing_entries = new Set(block_entries(block));
-    const missing = template_entries(template_lines).filter((e) => !existing_entries.has(e));
-    if (missing.length === 0) {
-        return [[...existing_lines], []];
-    }
-
-    // Ensure block ends with SECTION_FOOTER; insert missing entries right
-    // before it.
-    let insert_at: number;
-    if (block.length > 0 && _strip(block[block.length - 1] as string) === SECTION_FOOTER) {
-        insert_at = block.length - 1;
-    } else {
-        block = [...block, SECTION_FOOTER];
-        insert_at = block.length - 1;
-    }
-    const new_block = [...block.slice(0, insert_at), ...missing, ...block.slice(insert_at)];
-    return [[...head, ...new_block, ...tail], missing];
-}
-
-/**
- * Strip legacy entries from anywhere in the file.
- *
- * A line is legacy when its stripped, leading-whitespace-trimmed content
- * matches a `LEGACY_PATTERNS` entry — with or without a leading slash.
- * Comments and blank lines are untouched; current managed entries (e.g.
- * `/agents/.agent-chat-history`) are not in the legacy set and survive.
- */
-export function cleanup_legacy(lines: readonly string[]): [string[], string[]] {
-    const legacy = new Set(LEGACY_PATTERNS);
-    const kept: string[] = [];
-    const removed: string[] = [];
-    for (const ln of lines) {
-        const s = _strip(ln).replace(/^\s+/, '');
-        if (legacy.has(s) || (s.startsWith('/') && legacy.has(s.slice(1)))) {
-            removed.push(s);
-            continue;
-        }
-        kept.push(ln);
-    }
-    return [kept, removed];
-}
-
-/** Join lines with newlines and enforce exactly one trailing newline. */
-export function format_file(lines: readonly string[]): string {
-    const text = lines.join('\n');
-    return text.replace(/\n+$/, '') + '\n';
-}
 
 /** Python difflib.unified_diff(..., n=3) over keepends-split lines. */
 export function render_diff(old_text: string, new_text: string, p: string): string {

package/src/scripts/trigger_eval_grandfather.json

@@ -5,12 +5,10 @@
     "sequential-thinking"
   ],
   "skills": [
-    "accessibility-auditor",
     "activation-design",
     "agent-docs-writing",
     "agents-md-thin-root",
     "ai-council",
-    "api-design",
     "api-endpoint",
     "api-testing",
     "artisan-commands",
@@ -45,7 +43,6 @@
     "dependency-upgrade",
     "description-assist",
     "design-review",
-    "design-system-capture",
     "devcontainer",
     "developer-like-execution",
     "discovery-interview",
@@ -154,7 +151,6 @@
     "repomix-packer",
     "requesting-code-review",
     "retention-loops",
-    "review-routing",
     "rice-prioritization",
     "risk-officer",
     "roadmap-management",
@@ -170,7 +166,6 @@
     "security",
     "sentry-integration",
     "sequential-thinking",
-    "skill-improvement-pipeline",
     "skill-management",
     "skill-reviewer",
     "song-to-script",
@@ -181,7 +176,6 @@
     "subagent-orchestration",
     "symfony-workflow",
     "systematic-debugging",
-    "tailwind-engineer",
     "tech-debt-tracker",
     "technical-specification",
     "terraform",
@@ -192,7 +186,6 @@
     "throughput-vs-morale-tradeoff",
     "token-optimizer",
     "traefik",
-    "ui-component-architect",
     "unit-economics-modeling",
     "universal-project-analysis",
     "upstream-contribute",

package/src/scripts/trigger_eval_rotation.ts

@@ -19,9 +19,11 @@
  * - `--dry-run` (MockRouter, no key, no spend) exercises the plumbing only;
  *   floors are REPORTED but never fail the run — mock routing says nothing
  *   about real trigger accuracy.
- * - Rotation is a pure function of (week index, batch size, sorted suite
- *   list): ~batch suites per week, wrapping so every suite is visited on a
- *   fixed cadence regardless of suite-count drift.
+ * - Rotation is a pure function of (week index, suite identity): a suite's
+ *   slot comes from a hash of its own name, so every suite is visited once per
+ *   `ROTATION_CYCLE_WEEKS` and adding one shifts nobody else. What floats is
+ *   how many run in a given week; `rotation_plan` reports that and the weekly
+ *   query cost it implies.
  *
  * Exit codes: 0 pass (always, in --dry-run) · 1 live floor breach ·
  * 2 usage / IO error.
@@ -48,7 +50,6 @@ const _HERE = path.dirname(fileURLToPath(import.meta.url));
 const REPO_ROOT = path.resolve(_HERE, '..', '..');
 const SKILLS_DIR = path.join(REPO_ROOT, 'src', 'skills');
 const DEFAULT_OUT_DIR = path.join(REPO_ROOT, 'internal', 'evals', 'results', 'rotation');
-const DEFAULT_BATCH = 5;
 
 /** Router that may expose an async route (fetch-based live routers). */
 type AsyncCapableRouter = TriggerRouter & {
@@ -64,23 +65,116 @@ export function week_index(d: Date): number {
 }
 
 /**
- * Deterministic rotation: batch consecutive suites starting at
- * `(week * batch) mod total`, wrapping. Every suite is visited within
- * ceil(total / batch) weeks; adding/removing suites shifts but never
- * starves the cycle.
+ * Weeks in one full rotation cycle. 12 × 7 = 84 days, inside the 90-day
+ * `MAX_AGE_DAYS` window `check_trigger_evals` enforces.
  */
-export function pick_rotation<T>(suites: readonly T[], week: number, batch: number): T[] {
-    if (suites.length === 0 || batch <= 0) {
+export const ROTATION_CYCLE_WEEKS = 12;
+
+/** Provider queries one suite's live pass costs, measured at ~9.5; rounded up. */
+export const QUERIES_PER_SUITE = 10;
+
+/**
+ * Stated weekly ceiling for the rotation's paid calls. Growth past it does not
+ * silently raise the bill — `rotation_plan` reports `withinCeiling: false` and
+ * a test asserts the live suite list stays under it, so crossing it is a red a
+ * human decides on rather than an invoice they discover.
+ *
+ * **Set from measurement, and the arithmetic is the point.** At 102 suites a
+ * full pass costs ~1020 queries; spread over a 12-week cycle that is ~85 a week
+ * on average and 140 in the busiest week (hash spread, measured 2026-09-30).
+ * 160 leaves headroom for that unevenness and reds at roughly 117 suites.
+ *
+ * The number nobody can lower by tuning: a 90-day window over N suites costs
+ * `N × QUERIES_PER_SUITE` every 90 days, whatever the schedule. The scheme this
+ * replaced looked cheaper only because it never completed a pass — `batch = 5`
+ * over 102 suites is a 21-week cycle, which misses the 90-day window by 57 days.
+ * Cheapness was the symptom of the defect, not a property worth preserving.
+ */
+export const MAX_WEEKLY_QUERIES = 160;
+
+/**
+ * FNV-1a over the suite id. Any stable hash works; what matters is that a
+ * suite's slot depends on the suite alone and on nothing about the list it
+ * sits in.
+ */
+function slot_of(id: string, cycleWeeks: number): number {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < id.length; i += 1) {
+        h ^= id.charCodeAt(i);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h % cycleWeeks;
+}
+
+/**
+ * Deterministic rotation by suite identity: a suite is due in the weeks whose
+ * `week mod cycleWeeks` equals its own slot, so worst-case staleness is exactly
+ * `cycleWeeks` for any suite present across a cycle — independent of how many
+ * suites exist.
+ *
+ * **Why not the positional window this replaces.** It selected `batch`
+ * consecutive suites from `start = (week * batch) mod total`, and that start
+ * re-bases whenever `total` changes, so a region can be skipped repeatedly.
+ * Simulated against a list growing by one suite every eight weeks over five
+ * years, worst-case staleness reached **24 weeks against a 12-week window**;
+ * `trigger_eval_rotation_growth.test.ts` is that simulation, and it was
+ * observed red against the old scheme before this replaced it. A loop over
+ * static totals cannot see the defect, which is why the earlier test suite
+ * passed while the property was false.
+ *
+ * The cost of the fix is that the batch is no longer a knob: how many suites
+ * run in a given week follows from the hash distribution, and `rotation_plan`
+ * reports it rather than leaving it to be discovered on an invoice.
+ */
+export function pick_rotation<T>(
+    suites: readonly T[],
+    week: number,
+    cycleWeeks: number = ROTATION_CYCLE_WEEKS,
+): T[] {
+    if (suites.length === 0 || cycleWeeks <= 0) {
         return [];
     }
-    const n = Math.min(batch, suites.length);
-    const total = suites.length;
-    const start = ((((week * batch) % total) + total) % total);
-    const picked: T[] = [];
-    for (let i = 0; i < n; i += 1) {
-        picked.push(suites[(start + i) % total] as T);
+    const due = (((week % cycleWeeks) + cycleWeeks) % cycleWeeks);
+    return suites.filter((s) => slot_of(String(s), cycleWeeks) === due);
+}
+
+/** What a given suite list costs and promises, derivable without running it. */
+export interface RotationPlan {
+    total: number;
+    cycleWeeks: number;
+    /** Suites in the busiest week of the cycle. */
+    peakSuitesPerWeek: number;
+    /** Provider queries in that busiest week. */
+    peakWeeklyQueries: number;
+    /** Worst-case days between two visits of one suite. */
+    worstCaseStalenessDays: number;
+    withinCeiling: boolean;
+}
+
+/**
+ * Derive the cost and staleness a suite list implies. Pure, so the weekly bill
+ * is readable from the code rather than from a run.
+ */
+export function rotation_plan(
+    suites: readonly string[],
+    cycleWeeks: number = ROTATION_CYCLE_WEEKS,
+): RotationPlan {
+    const span = Math.max(cycleWeeks, 1);
+    const counts = new Array<number>(span).fill(0);
+    for (const s of suites) {
+        const slot = slot_of(s, span);
+        counts[slot] = (counts[slot] ?? 0) + 1;
     }
-    return picked;
+    const peakSuitesPerWeek = counts.length > 0 ? Math.max(...counts) : 0;
+    const peakWeeklyQueries = peakSuitesPerWeek * QUERIES_PER_SUITE;
+    return {
+        total: suites.length,
+        cycleWeeks,
+        peakSuitesPerWeek,
+        peakWeeklyQueries,
+        worstCaseStalenessDays: cycleWeeks * 7,
+        withinCeiling: peakWeeklyQueries <= MAX_WEEKLY_QUERIES,
+    };
 }
 
 /** Enumerate skills carrying `evals/triggers.json`, sorted for determinism. */
@@ -181,7 +275,8 @@ export async function run_eval_async(
 
 export interface RotationOptions {
     week?: number;
-    batch?: number;
+    /** Weeks in a full cycle; also the worst-case staleness. Default 12. */
+    cycleWeeks?: number;
     dryRun?: boolean;
     outDir?: string;
     model?: string;
@@ -202,7 +297,7 @@ export interface RotationSuiteOutcome {
 
 export interface RotationSummary {
     week: number;
-    batch: number;
+    cycle_weeks: number;
     total_suites: number;
     dry_run: boolean;
     outcomes: RotationSuiteOutcome[];
@@ -211,14 +306,14 @@ export interface RotationSummary {
 
 export async function run_rotation(opts: RotationOptions = {}): Promise<RotationSummary> {
     const dryRun = opts.dryRun ?? false;
-    const batch = opts.batch ?? DEFAULT_BATCH;
+    const cycleWeeks = opts.cycleWeeks ?? ROTATION_CYCLE_WEEKS;
     const week = opts.week ?? week_index(new Date());
     const outDir = opts.outDir ?? DEFAULT_OUT_DIR;
     const model = opts.model ?? DEFAULT_MODEL;
     const skillsDir = opts.skillsDir ?? SKILLS_DIR;
 
     const suites = list_trigger_suites(skillsDir);
-    const picked = pick_rotation(suites, week, batch);
+    const picked = pick_rotation(suites, week, cycleWeeks);
     const catalogue = load_skill_metas();
 
     const router: AsyncCapableRouter =
@@ -257,7 +352,7 @@ export async function run_rotation(opts: RotationOptions = {}): Promise<Rotation
 
     return {
         week,
-        batch,
+        cycle_weeks: cycleWeeks,
         total_suites: suites.length,
         dry_run: dryRun,
         outcomes,
@@ -278,7 +373,7 @@ function parse_args(argv: string[]): RotationOptions & { help?: boolean } {
             return v as string;
         };
         if (a === '--week') out.week = Number(take());
-        else if (a === '--batch') out.batch = Number(take());
+        else if (a === '--cycle-weeks') out.cycleWeeks = Number(take());
         else if (a === '--dry-run') out.dryRun = true;
         else if (a === '--out-dir') out.outDir = path.resolve(take());
         else if (a === '--model') out.model = take();
@@ -292,8 +387,8 @@ function parse_args(argv: string[]): RotationOptions & { help?: boolean } {
         process.stderr.write('trigger_eval_rotation: error: --week must be an integer\n');
         process.exit(2);
     }
-    if (out.batch !== undefined && (!Number.isInteger(out.batch) || out.batch <= 0)) {
-        process.stderr.write('trigger_eval_rotation: error: --batch must be a positive integer\n');
+    if (out.cycleWeeks !== undefined && (!Number.isInteger(out.cycleWeeks) || out.cycleWeeks <= 0)) {
+        process.stderr.write('trigger_eval_rotation: error: --cycle-weeks must be a positive integer\n');
         process.exit(2);
     }
     return out;
@@ -303,7 +398,7 @@ export async function main(argv?: string[]): Promise<number> {
     const opts = parse_args(argv ?? process.argv.slice(2));
     if (opts.help) {
         process.stdout.write(
-            'usage: trigger_eval_rotation [--week N] [--batch N] [--dry-run]\n' +
+            'usage: trigger_eval_rotation [--week N] [--cycle-weeks N] [--dry-run]\n' +
                 '                             [--out-dir DIR] [--model MODEL]\n',
         );
         return 0;
@@ -316,7 +411,7 @@ export async function main(argv?: string[]): Promise<number> {
         return 2;
     }
     process.stdout.write(
-        `trigger-eval rotation · week=${summary.week} · batch=${summary.batch} · ` +
+        `trigger-eval rotation · week=${summary.week} · cycle=${summary.cycle_weeks}w · ` +
             `${summary.outcomes.length}/${summary.total_suites} suites this run` +
             `${summary.dry_run ? ' · DRY-RUN (floors advisory)' : ''}\n`,
     );