@event4u/agent-config 8.11.0 → 8.12.0

package/src/scripts/check_artefact_count_messaging.ts

@@ -113,6 +113,49 @@ export function scan_text(
     return { findings, seen };
 }
 
+/** Structured-surface totals — generated files whose counts are YAML fields,
+ * not prose, so the KIND_PATTERNS prose scan cannot see them. CAPABILITIES.yaml
+ * proved this gap: it drifted to 268/177 while every prose surface said
+ * 271/178, because only its own `--check` guarded it and a stale commit can
+ * land through parallel merges. This scan makes the messaging gate a second,
+ * independent net over the same canonical counts. */
+export const STRUCTURED_SURFACES: ReadonlyArray<{
+    file: string;
+    fields: ReadonlyArray<[kind: string, pattern: RegExp]>;
+}> = [
+    {
+        file: 'CAPABILITIES.yaml',
+        fields: [
+            ['skills', /^\s*skills_total:\s*(\d+)\s*$/m],
+            ['commands', /^\s*commands_total:\s*(\d+)\s*$/m],
+        ],
+    },
+];
+
+export function scan_structured(
+    rel: string,
+    text: string,
+    fields: ReadonlyArray<[string, RegExp]>,
+    expected: Record<string, number>,
+): { findings: Finding[]; seen: Record<string, Set<number>> } {
+    const findings: Finding[] = [];
+    const seen: Record<string, Set<number>> = {};
+    for (const [kind, pattern] of fields) {
+        const m = text.match(pattern);
+        if (m === null) {
+            continue; // absent field is the generator's own --check's problem
+        }
+        const found = Number.parseInt(m[1]!, 10);
+        (seen[kind] ??= new Set()).add(found);
+        const exp = expected[kind]!;
+        if (found !== exp) {
+            const line = text.slice(0, m.index ?? 0).split('\n').length;
+            findings.push({ file: rel, line, kind, found, expected: exp, approx: false });
+        }
+    }
+    return { findings, seen };
+}
+
 export function main(argv: readonly string[] = process.argv.slice(2)): number {
     const QUIET = argv.includes('--quiet');
     const expected: Record<string, number> = {};
@@ -140,6 +183,19 @@ export function main(argv: readonly string[] = process.argv.slice(2)): number {
         }
     }
 
+    for (const { file, fields } of STRUCTURED_SURFACES) {
+        const p = path.join(ROOT, file);
+        if (!fs.existsSync(p)) {
+            process.stderr.write(`  ⚠️  surface missing (skipped): ${file}\n`);
+            continue;
+        }
+        const { findings, seen } = scan_structured(file, fs.readFileSync(p, 'utf-8'), fields, expected);
+        allFindings.push(...findings);
+        for (const [kind, nums] of Object.entries(seen)) {
+            for (const n of nums) (global_seen[kind] ??= new Set()).add(n);
+        }
+    }
+
     // Internal-inconsistency check — the regression case this gate exists
     // for: multiple DIFFERENT numbers for one kind across the surfaces.
     const inconsistent: string[] = [];

package/src/scripts/check_knowledge_cards.ts

@@ -105,13 +105,17 @@ function _frontmatter_get(text: string, ...keys: string[]): string {
 // ---------------------------------------------------------------------------
 
 /**
- * Global-store-only checks (ADR-100): tier validity, provenance footer,
- * and a redaction-clean assertion (the secret/PII patterns must have been
- * halted/cleaned before the card was written — never present in a global card).
+ * Global-store-only checks (ADR-100 + Phase 1 sensitivity axis,
+ * road-to-feedback-8.11 / successor note to ADR-119): tier validity,
+ * sensitivity validity, provenance footer (incl. the promotion audit-trail
+ * fields), and a redaction-clean assertion (the secret/PII patterns must
+ * have been halted/cleaned before the card was written — never present in a
+ * global card).
  */
 function _check_global_card(rel: string, text: string, fm: Record<string, string>): string[] {
     const errors: string[] = [];
     const valid_tiers = _kg !== null ? _kg.TIERS : ['public', 'vendor', 'proprietary'];
+    const valid_sensitivities = _kg !== null ? _kg.SENSITIVITIES : ['prohibited', 'project', 'shareable'];
 
     // G1 — tier present and valid
     const tier = (fm['tier'] ?? '').trim();
@@ -121,7 +125,27 @@ function _check_global_card(rel: string, text: string, fm: Record<string, string
         errors.push(`${rel}:0 — G1: tier '${tier}' not in ${_pyReprList(_sorted(valid_tiers))}`);
     }
 
-    // G2 — provenance footer present with all fields
+    // G4 — sensitivity present and valid
+    const sensitivity = (fm['sensitivity'] ?? '').trim();
+    if (!sensitivity) {
+        errors.push(`${rel}:0 — G4: global card missing 'sensitivity' in frontmatter`);
+    } else if (!valid_sensitivities.includes(sensitivity)) {
+        errors.push(
+            `${rel}:0 — G4: sensitivity '${sensitivity}' not in ${_pyReprList(_sorted(valid_sensitivities))}`,
+        );
+    }
+
+    // G6 — a `prohibited` card must never be in the global store at all: it
+    // contains redaction-class content and should never have left the
+    // project. Hard error regardless of anything else on the card.
+    if (sensitivity === 'prohibited') {
+        errors.push(
+            `${rel}:0 — G6: sensitivity 'prohibited' must never be in the global store ` +
+                '(redaction-class content — this card should never have been promoted)',
+        );
+    }
+
+    // G2 + G5 — provenance footer present with all promotion audit-trail fields
     if (_kg !== null) {
         const prov = _kg.parse_provenance_footer(text);
         if (!_pyTruthyObj(prov)) {
@@ -132,6 +156,11 @@ function _check_global_card(rel: string, text: string, fm: Record<string, string
                     errors.push(`${rel}:0 — G2: provenance footer missing '${field}'`);
                 }
             }
+            for (const field of ['source_repo', 'owner', 'review_after', 'promotion_reason']) {
+                if (!prov[field]) {
+                    errors.push(`${rel}:0 — G5: provenance footer missing '${field}'`);
+                }
+            }
         }
     }
 

package/src/scripts/check_portability.ts

@@ -468,6 +468,7 @@ const _TASK_DETECTOR_SKIP = [
     // CI-shaped literals; its mechanics doc and the execution loop +
     // authoring skill enumerate the same literals to detect them.
     'rules/roadmap-ci-steps-policy.md',
+    'contexts/execution/roadmap-ci-steps-mechanics.md',
     'contexts/execution/roadmap-process-loop.md',
     'skills/roadmap-writing/SKILL.md',
 ];