@event4u/agent-config 16.4.0 → 17.0.0

package/src/scripts/lint_context_spine_usage.ts

@@ -18,6 +18,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { validateBrandVoiceSlotFile } from './_lib/brand_voice_slot.js';
 import { DeadScopeError, assertScanned } from './_lib/scan_scope.js';
 
 const _HERE = fileURLToPath(import.meta.url);
@@ -43,6 +44,7 @@ const VALID_SLOTS = [
     'channel-stage',
     'funnel-stage',
     'customer-segment',
+    'brand-voice',
     'fiscal-period',
     'org-stage',
     'regulatory-regime',
@@ -116,6 +118,13 @@ function lint_skill(p: string): string[] {
     return problems;
 }
 
+/** The brand-voice slot is the one slot validated as data (adr-gtm-context-spine-brand-voice). */
+const BRAND_VOICE_SLOT = path.join('agents', 'context-spine', 'brand-voice.md');
+
+function lint_brand_voice_slot(p: string): string[] {
+    return validateBrandVoiceSlotFile(p).map((i) => `brand_voice_slot: ${i.field}: ${i.message}`);
+}
+
 /** Recursively list `SKILL.md` files under `dir`, sorted (mirrors sorted(rglob)). */
 function _rglobSkillSorted(dir: string): string[] {
     const out: string[] = [];
@@ -187,6 +196,17 @@ function main(): number {
             }
         }
     }
+    const slotPath = path.join(REPO_ROOT, BRAND_VOICE_SLOT);
+    if (fs.existsSync(slotPath)) {
+        const problems = lint_brand_voice_slot(slotPath);
+        if (problems.length) {
+            failed += 1;
+            process.stderr.write(`❌  ${_relPosix(slotPath, REPO_ROOT)}\n`);
+            for (const pb of problems) {
+                process.stderr.write(`    - ${pb}\n`);
+            }
+        }
+    }
     if (failed) {
         process.stderr.write(
             `\n❌  ${failed} skill(s) failed context-spine usage lint ` +
@@ -239,5 +259,6 @@ export {
     _read_spine,
     _slot_cited,
     lint_skill,
+    lint_brand_voice_slot,
     main,
 };

package/src/scripts/lint_design_antipattern_parity.ts

@@ -14,8 +14,9 @@
  *   A. every non-`Q*` catalog entry appears exactly once in § Detector status
  *   B. every § Detector status row names a catalog entry that exists
  *   C. the set of `backed` rows equals the registry's `catalogId` set
- *   D. every status is one of the five allowed values
+ *   D. every status is one of the six allowed values
  *   E. every non-`backed` row carries a reason
+ *   H. every `witness` row names a rule the rendered witness emits
  *
  * `Q*` entries are out of scope by construction: they are objective floors owned
  * by `lint_design_quality`, not aesthetic tells, and the status table says so.
@@ -38,8 +39,21 @@ const REPO = path.resolve(path.dirname(_HERE), '..', '..');
 const CATALOG = path.join(REPO, 'docs', 'guidelines', 'design-antipatterns.md');
 const REGISTRY = path.join(REPO, 'src', 'scripts', 'design_slop_rules.ts');
 
-/** The five statuses § Detector status may use. */
-export const STATUSES = ['backed', 'floor', 'judgment-only', 'deferred', 'candidate'] as const;
+/** The six statuses § Detector status may use. */
+export const STATUSES = ['backed', 'floor', 'judgment-only', 'deferred', 'candidate', 'witness'] as const;
+
+/**
+ * Where a `witness` row's rule must exist: the asset witness's sources
+ * (road-to-type-with-a-witness 2.1). A `witness` entry is read from the
+ * rendered asset rather than from text, so its detector lives here and not in
+ * the slop registry.
+ */
+export const WITNESS_SOURCES = [
+    'src/cli/commands/uiRenderAsset.ts',
+    'src/cli/commands/uiRenderAssetFonts.ts',
+] as const;
+
+const WITNESS_RULE = /`((?:geometry|structure|accessibility|motion)\/[a-z0-9-]+)`/;
 export type Status = (typeof STATUSES)[number];
 
 export interface ParityFinding {
@@ -119,8 +133,12 @@ export function registryCatalogIds(registryTs: string): string[] {
     return [...registryTs.matchAll(CATALOG_ID)].map((m) => m[1] as string);
 }
 
-/** Pure invariant check over both documents. */
-export function parityFindings(catalogMd: string, registryTs: string): ParityFinding[] {
+/**
+ * Pure invariant check over both documents, plus the witness source text a
+ * `witness` row is checked against. Omitting it fails every `witness` row
+ * rather than passing it unread.
+ */
+export function parityFindings(catalogMd: string, registryTs: string, witnessTs = ''): ParityFinding[] {
     const out: ParityFinding[] = [];
 
     if (STATUS_SECTION.exec(catalogMd) === null) {
@@ -166,6 +184,19 @@ export function parityFindings(catalogMd: string, registryTs: string): ParityFin
         if (row.status !== 'backed' && row.note === '') {
             out.push({ kind: 'missing-reason', id, msg: `${id}: status '${row.status}' carries no reason` });
         }
+        // H — a witness row names its rendered rule, and the witness emits it.
+        if (row.status === 'witness') {
+            const rule = WITNESS_RULE.exec(row.note)?.[1];
+            if (rule === undefined || !witnessTs.includes(`'${rule}'`)) {
+                out.push({
+                    kind: 'witness-without-rule',
+                    id,
+                    msg: rule
+                        ? `${id}: marked witness on \`${rule}\`, which the witness source does not emit`
+                        : `${id}: marked witness but its note names no witness rule (\`geometry/...\`)`,
+                });
+            }
+        }
     }
 
     // F — the census columns: present, non-empty, and from the closed vocabularies.
@@ -243,7 +274,7 @@ export function main(): number {
     try {
         assertWatchlistResolves({
             gate: 'lint_design_antipattern_parity',
-            candidates: [path.relative(REPO, CATALOG), path.relative(REPO, REGISTRY)],
+            candidates: [path.relative(REPO, CATALOG), path.relative(REPO, REGISTRY), ...WITNESS_SOURCES],
             repoRoot: REPO,
         });
     } catch (exc) {
@@ -256,7 +287,8 @@ export function main(): number {
 
     const catalogMd = fs.readFileSync(CATALOG, 'utf-8');
     const registryTs = fs.readFileSync(REGISTRY, 'utf-8');
-    const findings = parityFindings(catalogMd, registryTs);
+    const witnessTs = WITNESS_SOURCES.map((rel) => fs.readFileSync(path.join(REPO, rel), 'utf-8')).join('\n');
+    const findings = parityFindings(catalogMd, registryTs, witnessTs);
 
     const rows = statusRows(catalogMd);
     const entries = catalogEntries(catalogMd).length;

package/src/scripts/lint_design_quality.ts

@@ -13,7 +13,8 @@
  *   DQ1 contrast       — Text/background contrast < WCAG AA (4.5:1 normal, 3:1 large)
  *   DQ2 font-size      — Body font-size < 14px (floor; 16px strongly preferred)
  *   DQ3 line-length    — Prose line-length > 75ch without column constraint
- *   DQ4 reduced-motion — @keyframes / animation present without prefers-reduced-motion alt
+ *   DQ4 reduced-motion — @keyframes / animation present without prefers-reduced-motion alt,
+ *                        and (for INLINE SVG in HTML) SMIL with no route or a CSS-only one
  *   DQ5 heading-skip   — Heading levels skipped (h1 → h3 without h2)
  *   DQ6 focus-indicator— Interactive element with no :focus-visible indicator
  *
@@ -45,6 +46,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { assertScanned, DeadScopeError } from "./_lib/scan_scope.js";
+import { firstSmilLine, smilVerdict } from "./_lib/svg_motion.js";
 
 interface Finding {
   rule: string;
@@ -94,25 +96,71 @@ function checkFontSize(lines: string[], filePath: string): Finding[] {
   return findings;
 }
 
-/** DQ4: @keyframes / animation without @media (prefers-reduced-motion) */
+/**
+ * DQ4: animation without a reduced-motion route.
+ *
+ * Two halves. The CSS half is the original rule. The SMIL half (step 1.3 of
+ * `road-to-svg-with-a-witness`) covers INLINE SVG inside an HTML document and
+ * closes a measured blind spot: an HTML file whose only animation is an
+ * infinite `<animate>` read "clean — 1 file(s) checked" here, because
+ * `@keyframes` and `animation:` are the only two things the CSS half looks
+ * for, and SMIL is neither (R10).
+ *
+ * It also reports the subtler case: SMIL whose ONLY reduced-motion route is a
+ * CSS declaration. Under an emulated `reduce`, a page-level
+ * `svg * { animation: none !important }` left an `<animate>` moving `cx` from
+ * 20.2 to 76.8 in 700 ms (R4) — CSS animation properties do not reach SMIL, so
+ * the file looks covered and is not.
+ *
+ * STANDALONE `.svg` IS DELIBERATELY NOT HERE. A file cannot see its host's
+ * `<picture>` route, so judging the route from inside it would red correct
+ * assets and break this linter's zero-false-positive promise (line 12). That
+ * case belongs to `lint_svg_asset`, which knows it is reading a whole asset.
+ * Both halves read the same `_lib/svg_motion.ts`, so the two cannot drift.
+ */
 function checkReducedMotion(content: string, filePath: string, lines: string[]): Finding[] {
-  const hasAnimation = /@keyframes\s+\w+|animation\s*:/i.test(content);
-  if (!hasAnimation) return [];
+  const findings: Finding[] = [];
 
+  const hasAnimation = /@keyframes\s+\w+|animation\s*:/i.test(content);
   const hasReducedMotion = /@media\s*\([^)]*prefers-reduced-motion/i.test(content);
-  if (hasReducedMotion) return [];
-
-  // Find first animation declaration for the line number
-  const animLine = lines.findIndex((l) => /@keyframes\s+\w+|animation\s*:/.test(l));
-  return [
-    {
+  if (hasAnimation && !hasReducedMotion) {
+    const animLine = lines.findIndex((l) => /@keyframes\s+\w+|animation\s*:/.test(l));
+    findings.push({
       rule: "dq4-reduced-motion",
       file: filePath,
       line: animLine + 1,
       snippet: "@keyframes or animation present without @media (prefers-reduced-motion) alternative",
       severity: "error",
-    },
-  ];
+    });
+  }
+
+  // The SMIL half runs for documents that can HOST an inline graphic. A `.css`
+  // file cannot carry one, and a standalone `.svg` is the other linter's.
+  if (!/\.(html|htm|vue|svelte|astro)$/i.test(filePath)) return findings;
+
+  const verdict = smilVerdict(content);
+  if (verdict === "no-route") {
+    findings.push({
+      rule: "dq4-reduced-motion",
+      file: filePath,
+      line: firstSmilLine(content),
+      snippet:
+        "inline SVG animates with SMIL (<animate>/<animateTransform>/<set>) and the document carries " +
+        "no @media (prefers-reduced-motion) route at all",
+      severity: "error",
+    });
+  } else if (verdict === "css-only") {
+    findings.push({
+      rule: "dq4-reduced-motion",
+      file: filePath,
+      line: firstSmilLine(content),
+      snippet:
+        "inline SVG animates with SMIL and the only reduced-motion route is a CSS animation/transition " +
+        "declaration — CSS does not reach SMIL, so the animation keeps running under `reduce`",
+      severity: "error",
+    });
+  }
+  return findings;
 }
 
 /** DQ5: heading levels skipped (h1 → h3 without h2) in HTML */

package/src/scripts/lint_evidence_artifacts.ts

@@ -49,6 +49,8 @@ import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import { GateLedger } from './_lib/gate_ledger.js';
+import { parseClearance } from './_lib/merge_clearance_record.js';
+import { readRequiredProviders } from './_lib/ratification_artifact.js';
 import { resolveBaseRef } from './_lib/ratchet_base_ref.js';
 import { parseExecutionMode } from './_lib/repeated_run.js';
 import { reportScanned } from './_lib/scan_scope.js';
@@ -65,6 +67,8 @@ export const EVIDENCE_TYPES = [
     'analysis',
     'feel',
     'ratification',
+    'merge-clearance',
+    'bypass-record',
 ] as const;
 
 /**
@@ -202,6 +206,22 @@ export interface Finding {
     readonly reason: string;
 }
 
+const RATIFICATION_POLICY = path.join('src', 'config', 'ratification-policy.json');
+
+function clearanceProblems(root: string, contents: string): string[] {
+    let required: number | null = null;
+    try {
+        required = readRequiredProviders(fs.readFileSync(path.join(root, RATIFICATION_POLICY), 'utf8'));
+    } catch {
+        required = null;
+    }
+    if (required === null) {
+        return [`${RATIFICATION_POLICY} is missing or unreadable, so the outcome cannot be derived`];
+    }
+    const parsed = parseClearance(contents, required);
+    return Array.isArray(parsed) ? parsed : [];
+}
+
 export function checkFiles(root: string, files: readonly string[], ledger?: GateLedger): Finding[] {
     const findings: Finding[] = [];
     ledger?.plan([...files]);
@@ -248,6 +268,17 @@ export function checkFiles(root: string, files: readonly string[], ledger?: Gate
                 continue;
             }
         }
+        // A clearance decides whether a `needs-council` PR merges, so one that
+        // does not parse — or whose outcome its own seats do not support under
+        // the committed quorum policy — is a finding rather than a typed record.
+        if (res.type === 'merge-clearance') {
+            const problems = clearanceProblems(root, contents);
+            if (problems.length > 0) {
+                ledger?.fail(rel, 'merge clearance does not parse');
+                findings.push({ file: rel, reason: `merge-clearance does not parse: ${problems.join('; ')}` });
+                continue;
+            }
+        }
         if (res.type === null) {
             ledger?.fail(rel, 'no evidence type declared');
             findings.push({

package/src/scripts/lint_example_fences.ts

@@ -71,6 +71,7 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { assignmentPattern } from './_lib/egress_rules.js';
 import { GateLedger } from './_lib/gate_ledger.js';
 import { runGateCli, runSelfTest } from './_lib/gate_self_test.js';
 import { reportScanned } from './_lib/scan_scope.js';
@@ -159,8 +160,16 @@ export const PATTERNS: readonly FencePattern[] = [
         source: 'tool-safety',
         langs: 'any',
         label: 'Credential assigned a literal value in an example',
-        pattern:
-            /\b(api[_-]?key|apikey|password|passwd|secret|access[_-]?token|client[_-]?secret)\b\s*[:=]\s*["'][^"']{8,}["']/i,
+        pattern: assignmentPattern(
+            {
+                keywords: ['apiKey', 'apikey', 'password', 'passwd', 'secret', 'accessToken', 'clientSecret'],
+                before: '\\b',
+                after: '\\b',
+                capture: true,
+                value: `["'][^"']{8,}["']`,
+            },
+            'i',
+        ),
         // Placeholders are the correct way to show the shape and must not fire.
         // `secret-vcs-guard` owns real credentials; this pattern owns the
         // *teaching* of an inline literal, so anything self-evidently fake is out.

package/src/scripts/lint_ghostwriter_source.ts

@@ -36,7 +36,12 @@ const QUIET = process.argv.slice(2).includes('--quiet');
 const REPO = path.resolve(path.dirname(_HERE), '..', '..');
 // 6.0.x (ADR-051): ghostwriter fixtures live at src/agent-src/ghostwriter/.
 const PACKAGE_DIR = path.join(REPO, 'src', 'agent-src', 'ghostwriter');
-const CONSUMER_DIR = path.join(REPO, 'agents', 'ghostwriter');
+// Every ghostwriter command writes profiles to `agents/reference/ghostwriter/`
+// (docs/contracts/ghostwriter-schema.md); `agents/ghostwriter/` is the legacy
+// path. Both are linted, canonical first, so a profile at either is checked.
+const CONSUMER_DIR = path.join(REPO, 'agents', 'reference', 'ghostwriter');
+const LEGACY_CONSUMER_DIR = path.join(REPO, 'agents', 'ghostwriter');
+const CONSUMER_DIRS: readonly string[] = [CONSUMER_DIR, LEGACY_CONSUMER_DIR];
 const ALLOWLIST = path.join(REPO, 'src', 'scripts', 'ghostwriter_fixture_allowlist.txt');
 const EXEMPT_STEMS: ReadonlySet<string> = new Set(['README']);
 
@@ -86,6 +91,35 @@ function _globMdSorted(dir: string): string[] {
     return out.sort();
 }
 
+/** Sorted `*.md` files anywhere under `dir`, nested directories included. */
+function _globMdRecursiveSorted(dir: string): string[] {
+    let entries: fs.Dirent[];
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+        return [];
+    }
+    const out: string[] = [];
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(..._globMdRecursiveSorted(full));
+        } else if (entry.isFile() && entry.name.endsWith('.md')) {
+            out.push(full);
+        }
+    }
+    return out.sort();
+}
+
+/** Every consumer-side profile file, canonical path first, then legacy. */
+function consumer_profile_files(dirs: readonly string[] = CONSUMER_DIRS): string[] {
+    const out: string[] = [];
+    for (const dir of dirs) {
+        out.push(..._globMdRecursiveSorted(dir));
+    }
+    return out;
+}
+
 function _stem(p: string): string {
     const base = path.basename(p);
     const dot = base.lastIndexOf('.');
@@ -213,14 +247,11 @@ function lint_package_side(allowlist: Set<string>): string[] {
     return errors;
 }
 
-function lint_consumer_side(): string[] {
+function lint_consumer_side(dirs: readonly string[] = CONSUMER_DIRS): string[] {
     const errors: string[] = [];
-    if (!_exists(CONSUMER_DIR)) {
-        return errors;
-    }
     // (alias_ci → [source_path, source_value, source_kind])
     const seen = new Map<string, [string, string, string]>();
-    for (const p of _globMdSorted(CONSUMER_DIR)) {
+    for (const p of consumer_profile_files(dirs)) {
         if (EXEMPT_STEMS.has(_stem(p))) {
             continue;
         }
@@ -302,15 +333,13 @@ function main(): number {
     const pkg_count = _exists(PACKAGE_DIR)
         ? _globMdSorted(PACKAGE_DIR).filter((p) => !EXEMPT_STEMS.has(_stem(p))).length
         : 0;
-    const cons_count = _exists(CONSUMER_DIR)
-        ? _globMdSorted(CONSUMER_DIR).filter((p) => !EXEMPT_STEMS.has(_stem(p))).length
-        : 0;
+    const cons_count = consumer_profile_files().filter((p) => !EXEMPT_STEMS.has(_stem(p))).length;
     try {
         assertScanned({
             gate: 'lint_ghostwriter_source',
             scanned: pkg_count + cons_count,
             units: 'profile(s)',
-            roots: ['src/agent-src/ghostwriter', 'agents/ghostwriter'],
+            roots: ['src/agent-src/ghostwriter', 'agents/reference/ghostwriter', 'agents/ghostwriter'],
         });
     } catch (exc) {
         if (exc instanceof DeadScopeError) {
@@ -414,6 +443,9 @@ export {
     REPO,
     PACKAGE_DIR,
     CONSUMER_DIR,
+    LEGACY_CONSUMER_DIR,
+    CONSUMER_DIRS,
+    consumer_profile_files,
     ALLOWLIST,
     EXEMPT_STEMS,
     ALIAS_MIN_LEN,

package/src/scripts/lint_hook_manifest.ts

@@ -36,6 +36,7 @@ import { assertScanned, DeadScopeError } from "./_lib/scan_scope.js";
 import { asOf } from "./_lib/as_of.js";
 import { parseHostLowering, type HostLowering } from "./hooks/host_lowering.js";
 import { RE_ARM_EVENTS } from "./_lib/prefix_stable_surfaces.js";
+import { EXECUTION_VIEW_GRANTS } from "./hooks/egress_stage.js";
 
 // src/scripts/lint_hook_manifest.ts → two levels up is the repo root.
 const REPO_ROOT = path.resolve(
@@ -826,6 +827,97 @@ export function _check_slot_answers(table: HostLowering, errors: string[]): void
   }
 }
 
+/**
+ * Host fields that replace what a tool or the model receives. The tool-output
+ * name is assembled rather than spelled, because a test pins that no file under
+ * src/ names it until the egress stage emits it (road-to-placeholders-on-the-wire
+ * step 3.2); refusing the field is not emitting it.
+ */
+const HOST_REWRITE_FIELDS: readonly string[] = ["updatedInput", ["updated", "ToolOutput"].join("")];
+const REWRITE_DECLARATION_KEYS: readonly string[] = ["rewrite", "rewrites"];
+
+/**
+ * ADR-285 — one dispatcher stage is the only rewriter. A concern that declares
+ * a rewrite, or whose own script names a host rewrite field, is refused: two
+ * concerns rewriting one input have no composition answer, so none may try.
+ */
+function _check_no_concern_rewrites(manifest: YamlObject, errors: string[]): void {
+  const concernsRaw = manifest["concerns"];
+  if (!isObject(concernsRaw)) return;
+  for (const [name, spec] of Object.entries(concernsRaw)) {
+    if (!isObject(spec)) continue;
+    const declared = REWRITE_DECLARATION_KEYS.find((k) => spec[k] !== undefined);
+    if (declared !== undefined) {
+      errors.push(
+        `concerns.${name}: rewrite-concern-refused — declares '${declared}', but only the ` +
+          `dispatcher's egress stage may produce a rewrite (ADR-285)`,
+      );
+    }
+    const script = spec["script"];
+    if (typeof script !== "string") continue;
+    let source = "";
+    try {
+      source = fs.readFileSync(path.join(REPO_ROOT, script), "utf8");
+    } catch {
+      continue; // missing script is already reported by _check_concerns
+    }
+    // Code forms only — a key, a quoted name, a property read. A header that
+    // explains the field in backticks (rtk_wrap_hook does) produces nothing.
+    const field = HOST_REWRITE_FIELDS.find((f) =>
+      [`${f}:`, `'${f}'`, `"${f}"`, `.${f}`].some((form) => source.includes(form)),
+    );
+    if (field !== undefined) {
+      errors.push(
+        `concerns.${name}: rewrite-concern-refused — ${script} names the host rewrite ` +
+          `field '${field}'; only the dispatcher's egress stage may produce a rewrite (ADR-285)`,
+      );
+    }
+  }
+}
+
+/**
+ * The execution view is granted by the dispatcher's closed list, never
+ * requested. Refused: a concern declaring `payload_view: execution` off the
+ * list, a blocking concern the list omits (it would be served tokens instead
+ * of the value it guards), and a listed concern that is not blocking.
+ */
+function _check_execution_view_grants(manifest: YamlObject, errors: string[]): void {
+  const concernsRaw = manifest["concerns"];
+  if (!isObject(concernsRaw)) return;
+  for (const [name, spec] of Object.entries(concernsRaw)) {
+    if (!isObject(spec)) continue;
+    const view = spec["payload_view"];
+    const granted = EXECUTION_VIEW_GRANTS.has(name);
+    const blocking = spec["severity"] === "blocking";
+    if (view !== undefined && view !== "execution" && view !== "placeholder") {
+      errors.push(`concerns.${name}: 'payload_view' must be execution or placeholder, got ${JSON.stringify(view)}`);
+    } else if (view === "execution" && !granted) {
+      errors.push(
+        `concerns.${name}: execution-view-not-granted — declares 'payload_view: execution' but is not on ` +
+          `EXECUTION_VIEW_GRANTS in src/scripts/hooks/egress_stage.ts; a declaration grants nothing`,
+      );
+    }
+    if (blocking && !granted) {
+      errors.push(
+        `concerns.${name}: execution-view-not-granted — severity: blocking but missing from ` +
+          `EXECUTION_VIEW_GRANTS; under protect it would be served placeholder tokens instead of the values it guards`,
+      );
+    } else if (granted && !blocking) {
+      errors.push(
+        `concerns.${name}: execution-view-not-granted — on EXECUTION_VIEW_GRANTS but not severity: blocking; ` +
+          `the execution view is for concerns that decide whether a call runs`,
+      );
+    }
+    if (granted && spec["script"] !== EXECUTION_VIEW_GRANTS.get(name)) {
+      errors.push(
+        `concerns.${name}: execution-view-not-granted — the grant is bound to ` +
+          `${String(EXECUTION_VIEW_GRANTS.get(name))}, but the manifest runs ${JSON.stringify(spec["script"])}; ` +
+          `the dispatcher will serve it the placeholder view`,
+      );
+    }
+  }
+}
+
 export function lint(
   manifestPath: string,
   strict: boolean,
@@ -858,6 +950,8 @@ export function lint(
   const concernNames = _check_concerns(manifest, errors);
   const bound = _check_platforms(manifest, concernNames, errors, warnings);
   _check_guard_payload_bodies(manifest, errors);
+  _check_no_concern_rewrites(manifest, errors);
+  _check_execution_view_grants(manifest, errors);
   _check_roles(manifest, concernNames, errors);
   _check_aliases(manifest, errors);
   _check_orphan_trampolines(manifest, errors);

package/src/scripts/lint_marketplace_install_completeness.ts

@@ -97,6 +97,10 @@ function load_hook_commands(hooks_path: string): Array<[string, string]> {
 
 /** Pull the agent-config subcommand out of a hooks.json command line. */
 function extract_subcommand(command_line: string): string | null {
+    // What `echo` or `printf` prints is not what the line runs: the
+    // no-dispatcher branch echoes prose that names "agent-config hook". A
+    // quoted string a shell executes, as in `sh -c '…'`, is left to match.
+    command_line = command_line.replace(/\b(echo|printf)((?:\s+(?:-\w+|'[^']*'))+)/g, (_m, verb: string) => verb);
     const m = _CMD_RE.exec(command_line);
     if (m) {
         return m[1] as string;

package/src/scripts/lint_mcp_config_security.ts

@@ -23,6 +23,7 @@ import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { detect } from './_lib/egress_rules.js';
 import * as sl from './_lib/security_lint.js';
 import { assertScanned, DeadScopeError } from './_lib/scan_scope.js';
 
@@ -31,16 +32,13 @@ export const CHECK = 'mcp-config-security';
 //   Python: re.compile(r"(^|/)(\.mcp\.json|mcp\.json|claude_desktop_config\.json)")
 const _NAME_HINTS = /(^|\/)(\.mcp\.json|mcp\.json|claude_desktop_config\.json)/;
 
-// Real secret VALUES (prefix + enough key chars to be a live credential).
-//   Python (no flags):
-const _SECRET = new RegExp(
-    'sk-ant-[A-Za-z0-9_\\-]{20,}' +
-        '|sk-proj-[A-Za-z0-9_\\-]{20,}' +
-        '|AKIA[0-9A-Z]{16}' +
-        '|AIza[0-9A-Za-z_\\-]{35}' +
-        '|ghp_[0-9A-Za-z]{36}' +
-        '|eyJ[A-Za-z0-9_\\-]{10,}\\.[A-Za-z0-9_\\-]{10,}\\.[A-Za-z0-9_\\-]{10,}',
-);
+// Real secret VALUES — detected by the one rule table, which owns every
+// credential pattern (road-to-one-detector-and-the-senders-we-own 2.2). The
+// heuristic keyword assignment is not a structural credential and never was HIGH
+// here; this lint's HIGH tier stays the structural rows.
+export function hasInlineSecret(text: string): boolean {
+    return detect(text).some((span) => span.class === 'credential' && span.rule !== 'generic-assignment');
+}
 
 // Line-level smells (match on a single line).
 const _MED: ReadonlyArray<[RegExp, string]> = [
@@ -135,7 +133,7 @@ export function _scan(sf: sl.ScannedFile): sl.Finding[] {
     const out: sl.Finding[] = [];
     for (const [start, numbered] of _candidate_chunks(sf)) {
         for (const [lineno, text] of numbered) {
-            if (_SECRET.test(text)) {
+            if (hasInlineSecret(text)) {
                 out.push(
                     new sl.Finding(
                         sf.rel,

package/src/scripts/lint_motion_authority_drift.ts

@@ -325,6 +325,33 @@ interface Allowed {
 
 const norm = (s: string): string => s.replace(/\s+/g, ' ').trim();
 
+/**
+ * The reviewed statements, one verdict each.
+ *
+ * THE AUTHORITY IS NOT IN THIS TABLE, AND THAT IS THE DESIGN. The table is what
+ * the five DEPENDENTS are checked against; `design-patterns.md` § Motion is the
+ * thing they are compared TO, so it is PARSED — bands, ceiling, both curves —
+ * and never passed to {@link checkStatement}. A row keyed to it would be inert,
+ * and an inert row reads as enforcement.
+ *
+ * Measured 2026-10-11, when § Motion gained step 6b (the SVG mechanisms): of
+ * the 49 lines the authority gained, {@link carriesMotionValue} flags two when
+ * applied to them directly, and this gate reads neither, because neither
+ * reaches the scan path. Both verdicts are `permitted`, recorded here rather
+ * than left to be rediscovered by whoever next widens the scanned set:
+ *
+ *   · "Step 2's bounce prohibition already rules the intent out" — a deferral
+ *     to the prohibition, not a curve. The `keySplines` bullet states which
+ *     values the MECHANISM accepts; step 2 still owns whether to want one.
+ *   · "All of them still obey step 3's bands, step 2's single `ease-out` curve"
+ *     — the authority naming its own curve, in a sentence widened from the six
+ *     HTML mechanisms to those plus the SVG ones. No band, curve or duration
+ *     moved with it.
+ *
+ * If the authority is ever added to the scanned set, those two are the rows it
+ * needs on day one — and every band line in § Motion needs one too, which is
+ * the cost that keeps it parsed instead.
+ */
 export const PROSE_ALLOWLIST: readonly Allowed[] = [
     {
         file: CHECKLIST_REL, key: 'table:7',