@event4u/agent-config 16.1.0 → 16.3.0

package/dist/scripts/_lib/rule_consequence_class.js

@@ -0,0 +1,45 @@
+/**
+ * The high-consequence rule class — one reader for the config, the projector
+ * and the test.
+ *
+ * The criterion itself is prose and lives where an author meets it: the
+ * `consequence_class` property of `src/scripts/schemas/rule.schema.json`. This
+ * module does not restate it. It reads the list the criterion produced
+ * (`src/config/rule-consequence-class.json`), joins it to what each rule file
+ * actually declares, and answers the one question `project_thin_rules` asks:
+ * may this rule's stub carry its own law, and if not, has that been declared?
+ *
+ * WHY A DECLARED `no_stub` SUBSET RATHER THAN A SHORTER CLASS. A member whose
+ * law section is missing or over the ceiling cannot ship as stub-plus-law —
+ * there is nothing short enough to copy. Two ways to handle that: drop it from
+ * the class, or keep it in the class and record why it cannot stand. Dropping
+ * it makes the class shrinkable by NOT writing a law, which is the incentive a
+ * criterion must not create. Keeping it leaves the obligation visible and costs
+ * only a full-bodied projection, which is what those rules get today anyway.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export const CLASS_CONFIG_REL = 'src/config/rule-consequence-class.json';
+export const CLAUSES = ['irreversible-external', 'security-boundary', 'authority-bypass'];
+export function readConsequenceClass(repoRoot) {
+    const raw = JSON.parse(fs.readFileSync(path.join(repoRoot, CLASS_CONFIG_REL), 'utf-8'));
+    return {
+        criterion_ref: raw.criterion_ref ?? '',
+        members: raw.members ?? {},
+        no_stub: raw.no_stub ?? {},
+        excluded: raw.excluded ?? {},
+    };
+}
+/** Ids whose stub carries their law — members minus the declared `no_stub` set. */
+export function stubLawIds(cfg) {
+    return new Set(Object.keys(cfg.members).filter((id) => cfg.no_stub[id] === undefined));
+}
+/** The `consequence_class:` value a rule file declares, or `null`. */
+export function declaredClause(ruleText) {
+    const m = /^consequence_class:\s*"?([a-z-]+)"?\s*$/m.exec(ruleText);
+    if (m === null)
+        return null;
+    const v = m[1];
+    return CLAUSES.includes(v) ? v : null;
+}
+//# sourceMappingURL=rule_consequence_class.js.map

package/dist/scripts/_lib/rule_injection.js

@@ -55,8 +55,51 @@ import * as path from 'node:path';
 import { match_prompt } from './router_match.js';
 /** Kinds of trigger a prompt alone can never fire. */
 export const PATH_TRIGGER_KINDS = ['path_prefix', 'file_pattern'];
+/**
+ * Set by `dispatch_hook` to its own resolved package root. Read here rather
+ * than threaded through every caller — see `ruleSourceDirs`.
+ */
+export const PACKAGE_ROOT_ENV = 'AGENT_CONFIG_PACKAGE_ROOT';
+function statKind(p) {
+    try {
+        const s = fs.statSync(p);
+        return s.isDirectory() ? 'dir' : s.isFile() ? 'file' : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve the body dirs, the router and the gap wording in ONE filesystem pass. */
+export function ruleSources(repoRoot) {
+    const env = (process.env[PACKAGE_ROOT_ENV] ?? '').trim();
+    const pkg = env ? path.resolve(env) : null;
+    const dirs = [];
+    const add = (d) => {
+        if (statKind(d) === 'dir' && !dirs.includes(d))
+            dirs.push(d);
+    };
+    add(path.join(repoRoot, 'agents', 'overrides'));
+    add(path.join(repoRoot, 'dist', 'agent-src', 'rules'));
+    if (pkg !== null)
+        add(path.join(pkg, 'dist', 'agent-src', 'rules'));
+    const local = path.join(repoRoot, 'dist', 'router.json');
+    let router = statKind(local) === 'file' ? local : null;
+    if (router === null && pkg !== null) {
+        const shipped = path.join(pkg, 'dist', 'router.json');
+        if (statKind(shipped) === 'file')
+            router = shipped;
+    }
+    let gap = null;
+    if (router === null || dirs.length === 0) {
+        const miss = pkg === null
+            ? `${PACKAGE_ROOT_ENV} unset`
+            : `no ${router === null ? 'dist/router.json' : 'dist/agent-src/rules'} under ${repoRoot} or ${pkg}`;
+        gap = `rule-inject: no rule source — ${miss}`;
+    }
+    return { dirs, pkg, router, gap };
+}
 export function loadRouter(repoRoot) {
-    const p = path.join(repoRoot, 'dist', 'router.json');
+    const p = ruleSources(repoRoot).router ?? path.join(repoRoot, 'dist', 'router.json');
     return JSON.parse(fs.readFileSync(p, 'utf8'));
 }
 /** Kernel rule ids, as declared by the router. */
@@ -137,16 +180,30 @@ export function matchTierRules(router, prompt, openFiles, command) {
     }
     return out;
 }
-/** Where the projected body of a rule lives. */
-export function ruleBodyPath(repoRoot, id) {
-    return path.join(repoRoot, 'dist', 'agent-src', 'rules', `${id}.md`);
-}
-/** The projected body, or `null` when the rule has no projected file. */
+/**
+ * The projected body from the highest-precedence tree carrying it, or `null`.
+ *
+ * `ruleBodyPath` used to sit in front of this and is gone: it returned the
+ * single-root path unconditionally, this diff changed its contract to "the
+ * first tree that has the file", and nothing outside this module ever called
+ * it. An exported helper whose last caller disappeared in the same diff is an
+ * own-orphan, and the composed hook bundle charges for it on every dispatch
+ * (`src/config/hook-bundle-budget.json`), so it is removed rather than left as
+ * a wrapper nobody uses.
+ */
 export function loadRuleBody(repoRoot, id) {
-    const p = ruleBodyPath(repoRoot, id);
-    if (!fs.existsSync(p))
-        return null;
-    return fs.readFileSync(p, 'utf8');
+    for (const dir of ruleSources(repoRoot).dirs) {
+        const p = path.join(dir, `${id}.md`);
+        if (statKind(p) === 'file') {
+            try {
+                return fs.readFileSync(p, 'utf8');
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    return null;
 }
 /**
  * UTF-8 byte length — the runtime measure, dependency-free by design.

package/dist/scripts/_lib/rule_law_section.js

@@ -0,0 +1,122 @@
+/**
+ * One spelling of "a rule's law section" — the unit three gates and one
+ * projector all price.
+ *
+ * A **law section** is a heading whose title matches `\biron\s+laws?\b` plus
+ * everything under it up to the next heading of the same or a shallower depth.
+ * A rule may carry several (`direct-answers` has three, `no-cheap-questions`
+ * six); the rule's law is all of them, joined by a blank line, because each one
+ * states an obligation and a stub carrying only the first would ship a rule
+ * whose other laws silently vanished.
+ *
+ * WHY A SHARED MODULE RATHER THAN A REGEX PER CALLER. The projector
+ * (`project_thin_rules.ts`) byte-copies this text into a stub and digests it;
+ * the lint (`lint_rule_law_section.ts`) holds it under a ceiling. If those two
+ * disagreed about where a section ends, the lint would certify a length the
+ * projection does not carry — the exact drift `THIN_ENTRY_MARKER`'s own comment
+ * argues against one file over.
+ *
+ * The heading regex is deliberately the SAME one `check_iron_law_prominence.ts`
+ * uses, so "has a law section" here and "is an Iron Law heading" there cannot
+ * diverge. That gate owns prominence (H2, near the top); this module owns
+ * extent and size.
+ *
+ * WHAT THIS DOES NOT CLAIM. Not that the extracted text IS the rule's obligation. A rule can state its
+ * law in bold prose or a bare fence under no heading at all — several of the 35
+ * routed rules without a heading match do exactly that. A heading match is a
+ * STRUCTURAL property, checkable; "this sentence is the obligation" is not, and
+ * `report_obligation_carriers` plus the `# obligation: line N` marker is where
+ * that question already lives.
+ */
+import * as fs from 'node:fs';
+/** Same literal as `check_iron_law_prominence.ts` — one definition, two readers. */
+export const IRON_LAW_RE = /\biron\s+laws?\b/i;
+const HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
+const FENCE_RE = /^\s*```/;
+/** Return `[frontmatter_including_fences, body]`. Empty frontmatter if none. */
+export function splitFrontmatter(text) {
+    if (text.startsWith('---\n')) {
+        const end = text.indexOf('\n---\n', 4);
+        if (end !== -1) {
+            return [text.slice(0, end + 5), text.slice(end + 5)];
+        }
+    }
+    return ['', text];
+}
+/**
+ * The body a runtime delivery carries: frontmatter removed, HTML comments
+ * removed, trimmed.
+ *
+ * Comments are stripped because they are authoring scaffolding
+ * (`<!-- risk-review: … -->`, `<!-- harvest:… -->`, `ref-ignore` markers) that
+ * no host renders to a model, so charging a rule for them would price the wrong
+ * thing. Frontmatter is excluded for the reason `check_rule_stub_ceiling` gives
+ * for the same exclusion: it is the routing surface, and a rule that gains a
+ * trigger must not trip a ceiling whose message tells the author to move prose.
+ */
+export function ruleBody(text) {
+    const [, body] = splitFrontmatter(text);
+    return body.replace(/<!--[\s\S]*?-->/g, '').trim();
+}
+/** Every law section in a rule body, in document order. */
+export function lawSections(body) {
+    const lines = body.split('\n');
+    let inFence = false;
+    const headings = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const raw = lines[i];
+        if (FENCE_RE.test(raw)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
+        const m = HEADING_RE.exec(raw);
+        if (m)
+            headings.push({ i, depth: m[1].length, title: m[2].trim() });
+    }
+    const out = [];
+    for (let k = 0; k < headings.length; k += 1) {
+        const h = headings[k];
+        if (!IRON_LAW_RE.test(h.title))
+            continue;
+        let end = lines.length;
+        for (let j = k + 1; j < headings.length; j += 1) {
+            const n = headings[j];
+            if (n.depth <= h.depth) {
+                end = n.i;
+                break;
+            }
+        }
+        out.push({
+            title: h.title,
+            depth: h.depth,
+            line: h.i + 1,
+            text: lines.slice(h.i, end).join('\n').trim(),
+        });
+    }
+    return out;
+}
+/**
+ * The rule's law, as one byte string — all sections joined by a blank line.
+ * `null` when the rule has none, which is a different answer from `''`.
+ */
+export function lawText(body) {
+    const sections = lawSections(body);
+    if (sections.length === 0)
+        return null;
+    return sections.map((s) => s.text).join('\n\n');
+}
+/** Measure one rule file. */
+export function measureRuleFile(id, filePath) {
+    const body = ruleBody(fs.readFileSync(filePath, 'utf-8'));
+    const law = lawText(body);
+    return {
+        id,
+        lawChars: law === null ? 0 : law.length,
+        sections: lawSections(body).length,
+        bodyChars: body.length,
+        law,
+    };
+}
+//# sourceMappingURL=rule_law_section.js.map