@event4u/agent-config 7.5.0 → 8.1.0

package/src/scripts/degrade_to_pointer.ts

@@ -0,0 +1,136 @@
+#!/usr/bin/env tsx
+/**
+ * Pointer degradation — road-to-knowledge-system Phase 4 (self-learning
+ * wiring). After `learning-to-rule-or-skill` promotes a knowledge-page
+ * entry into a real skill/rule/guideline, the SOURCE entry is rewritten to
+ * a pointer stub instead of staying as full duplicated prose. This is the
+ * staging → promotion → pointer lifecycle: it prevents double-maintenance
+ * between the knowledge page and the new artifact, and keeps
+ * `agents/knowledge/INDEX.md` honest about what still needs attention.
+ *
+ * Two source shapes:
+ *   - Whole page: `--source agents/knowledge/concepts/x.md` — the page
+ *     BODY (below frontmatter) is replaced with a pointer line;
+ *     frontmatter (and its provenance) is preserved untouched.
+ *   - Named section: `--source agents/knowledge/procedures/skill-candidates.md#<topic>`
+ *     — only the matching `## <topic>` section's body is replaced; the
+ *     heading and every other section stay untouched.
+ *
+ * Usage:
+ *   degrade_to_pointer.ts --source <path[#anchor]> --artifact <path> --date <YYYY-MM-DD>
+ *
+ * Exit codes: 0 = degraded, 1 = usage error / source not found, 3 = internal error.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+import { main as generateIndexMain } from './generate_knowledge_index.js';
+
+const PROG = 'degrade_to_pointer.ts';
+const FRONTMATTER_RE = /^(---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*\r?\n)/;
+
+export function pointerLine(artifact: string, date: string): string {
+    return `> Promoted to \`${artifact}\` on ${date}; see that artifact for current guidance.`;
+}
+
+/** Replace a whole page's body (below frontmatter, if any) with a pointer line. Preserves frontmatter and the first H1 heading, if present, so the page stays a resolvable link target. */
+export function degradeWholeFile(content: string, artifact: string, date: string): string {
+    const fmMatch = FRONTMATTER_RE.exec(content);
+    const frontmatter = fmMatch?.[1] ?? '';
+    const rest = fmMatch ? content.slice(frontmatter.length) : content;
+
+    const headingMatch = /^(#\s+.+)$/m.exec(rest);
+    const heading = headingMatch?.[1] !== undefined ? `${headingMatch[1]}\n\n` : '';
+
+    return `${frontmatter}${heading}${pointerLine(artifact, date)}\n`;
+}
+
+/** Replace one `## <anchor>` section's body (up to the next `## ` heading or EOF) with a pointer line, byte-for-byte outside that span. Throws if the anchor is not found. */
+export function degradeSection(content: string, anchor: string, artifact: string, date: string): string {
+    const headingLine = `## ${anchor}`;
+    const lines = content.split('\n');
+    const startIdx = lines.findIndex((l) => l.trim() === headingLine);
+    if (startIdx === -1) {
+        throw new Error(`section "${anchor}" not found`);
+    }
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        if (/^##\s/.test(lines[i] ?? '')) {
+            endIdx = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, startIdx + 1);
+    const after = lines.slice(endIdx);
+    const body = ['', pointerLine(artifact, date), ''];
+    return [...before, ...body, ...after].join('\n');
+}
+
+function printUsage(): void {
+    process.stdout.write(`usage: ${PROG} --source PATH[#ANCHOR] --artifact PATH --date YYYY-MM-DD\n`);
+}
+
+export function main(argv: string[]): number {
+    let source: string | null = null;
+    let artifact: string | null = null;
+    let date: string | null = null;
+
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '-h' || arg === '--help') {
+            printUsage();
+            return 0;
+        } else if (arg === '--source') {
+            source = argv[++i] ?? null;
+        } else if (arg === '--artifact') {
+            artifact = argv[++i] ?? null;
+        } else if (arg === '--date') {
+            date = argv[++i] ?? null;
+        } else {
+            process.stderr.write(`${PROG}: error: unrecognized argument: ${arg}\n`);
+            printUsage();
+            return 1;
+        }
+    }
+
+    if (!source || !artifact || !date) {
+        process.stderr.write(`${PROG}: error: --source, --artifact, and --date are required\n`);
+        printUsage();
+        return 1;
+    }
+
+    const [filePath = '', anchor] = source.split('#');
+
+    let content: string;
+    try {
+        content = fs.readFileSync(filePath, 'utf8');
+    } catch {
+        process.stderr.write(`${PROG}: error: source file not found: ${filePath}\n`);
+        return 1;
+    }
+
+    let updated: string;
+    try {
+        updated = anchor ? degradeSection(content, anchor, artifact, date) : degradeWholeFile(content, artifact, date);
+    } catch (err) {
+        process.stderr.write(`${PROG}: error: ${(err as Error).message}\n`);
+        return 1;
+    }
+
+    fs.writeFileSync(filePath, updated, 'utf8');
+    process.stdout.write(`${PROG}: degraded ${source} → pointer to ${artifact}.\n`);
+
+    // Regenerate the index so the pointer's new one-line summary is
+    // reflected immediately, not left stale until the next unrelated write.
+    // Assumes the standard invocation cwd (repo root), matching every other
+    // script in this package (generate_knowledge_index.ts defaults the same way).
+    generateIndexMain(['--dir', process.cwd(), '--quiet']);
+
+    return 0;
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] ?? '')) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/design_slop_rules.test.ts

@@ -93,6 +93,13 @@ const FIXTURES: Record<string, { ext: string; positive: string; negative: string
     positive: "We streamline and empower your robust, world-class workflow.",
     negative: "We cut page load by 40% and remove three steps from checkout.",
   },
+  "slop-cp5-emoji-ui": {
+    ext: "html",
+    positive: '<h1>🚀 Get Started</h1><button>✅ Track progress</button>',
+    // Functional placements stay clean: mid-sentence emoji, status-cell emoji.
+    negative:
+      '<h1>Get Started</h1><p>Deploys are marked ✅ when healthy.</p><td>✅</td><button>Track progress</button>',
+  },
   "slop-lock-shape": {
     ext: "css",
     positive: ".a{border-radius:4px}.b{border-radius:8px}.c{border-radius:12px}.d{border-radius:20px}",
@@ -171,6 +178,14 @@ describe("context gates suppress when DESIGN.md declares intent", () => {
     ).toBe(0);
   });
 
+  it("cp5 emoji-ui is suppressed when DESIGN.md declares an emoji strategy", () => {
+    const fx = FIXTURES["slop-cp5-emoji-ui"]!;
+    expect(findingsFor("slop-cp5-emoji-ui", fx.positive, "html", NO_CTX).length).toBeGreaterThan(0);
+    expect(
+      findingsFor("slop-cp5-emoji-ui", fx.positive, "html", ctxWith("Voice: playful; emoji are part of the brand voice in headings and CTAs")).length,
+    ).toBe(0);
+  });
+
   it("c5 cream-palette is suppressed under a declared warm-neutral language", () => {
     const fx = FIXTURES["slop-c5-cream-palette"]!;
     expect(findingsFor("slop-c5-cream-palette", fx.positive, "css", NO_CTX).length).toBeGreaterThan(0);

package/src/scripts/design_slop_rules.ts

@@ -408,6 +408,34 @@ export const SLOP_RULES: SlopRule[] = [
       return [];
     },
   },
+  {
+    id: "slop-cp5-emoji-ui",
+    catalogId: "CP5",
+    severity: "P2",
+    engines: ["html", "jsx"],
+    description: "Emoji-decoration prepending headings, buttons, list items, or CTAs",
+    message:
+      "Emoji-prepended UI text (🚀 Get Started) is the default-startup-template tell — no emoji beats decorative emoji (CP5). Functional status/category emojis and brand-declared emoji strategies are exempt.",
+    gated: (ctx) => ctx.has("emoji"),
+    detect: ({ content }) => {
+      // Emoji as the FIRST visible character inside a heading, button, list
+      // item, or link — decoration position. Emojis elsewhere (mid-sentence,
+      // table cells, status chips) are not matched: those are the functional
+      // placements CP5 explicitly exempts.
+      const re =
+        /<(h[1-6]|button|li|a)\b[^>]*>\s*(?:<(?!\/)[^>]*>\s*)*(\p{Extended_Pictographic})/giu;
+      const hits: RawHit[] = [];
+      let m: RegExpExecArray | null;
+      while ((m = re.exec(content)) !== null) {
+        const before = content.slice(0, m.index);
+        hits.push({
+          line: (before.match(/\n/g) ?? []).length + 1,
+          snippet: content.slice(m.index, m.index + 60).replace(/\n/g, " "),
+        });
+      }
+      return hits;
+    },
+  },
   {
     id: "slop-lock-shape",
     catalogId: "V8",

package/src/scripts/emit_knowledge_event.ts

@@ -0,0 +1,158 @@
+#!/usr/bin/env tsx
+/**
+ * CLI wrapper for `appendEvent` (src/scripts/_lib/knowledge_events.ts) —
+ * road-to-knowledge-system Phase 5. This is the actual command an agent
+ * runs to append a typed observation event; the `_lib` module holds the
+ * pure schema + validation logic only (this repo's convention: `_lib/`
+ * files are never directly invoked).
+ *
+ * Usage (one flag set per event type — see --help for the full list):
+ *   emit_knowledge_event.ts --type convention_detected --pattern "<p>" --evidence "file:line" [--evidence "file:line" ...] --sample-size N --scope project|global
+ *   emit_knowledge_event.ts --type mistake_made --error-category "<c>" --context-source "<path>|null" --correction "<text>" --recurrence-key "<key>"
+ *   emit_knowledge_event.ts --type api_shape_learned --endpoint "<path>" --method "<verb>" --request-schema "<json>" --response-schema "<json>"
+ *   emit_knowledge_event.ts --type context_stale --page-path "<path>" --field "<field>" --expected "<text>" --actual "<text>" --evidence "<text>"
+ *
+ * Exit codes: 0 = appended, 1 = usage / validation error.
+ */
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+
+import { appendEvent, type KnowledgeEvent } from './_lib/knowledge_events.js';
+
+const PROG = 'emit_knowledge_event.ts';
+
+function printUsage(): void {
+    process.stdout.write(
+        [
+            `usage: ${PROG} --type TYPE [type-specific flags]`,
+            '',
+            '  --type convention_detected --pattern P --evidence E [--evidence E ...] --sample-size N --scope project|global',
+            '  --type mistake_made --error-category C --context-source PATH|null --correction TEXT --recurrence-key KEY',
+            '  --type api_shape_learned --endpoint PATH --method VERB --request-schema JSON --response-schema JSON',
+            '  --type context_stale --page-path PATH --field FIELD --expected TEXT --actual TEXT --evidence TEXT',
+            '',
+        ].join('\n'),
+    );
+}
+
+function parseFlags(argv: string[]): Map<string, string[]> {
+    const flags = new Map<string, string[]>();
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === undefined || !arg.startsWith('--')) continue;
+        const key = arg.slice(2);
+        const value = argv[++i] ?? '';
+        const existing = flags.get(key) ?? [];
+        existing.push(value);
+        flags.set(key, existing);
+    }
+    return flags;
+}
+
+function one(flags: Map<string, string[]>, key: string): string | null {
+    return flags.get(key)?.[0] ?? null;
+}
+
+export function main(argv: string[]): number {
+    if (argv.includes('-h') || argv.includes('--help')) {
+        printUsage();
+        return 0;
+    }
+
+    const flags = parseFlags(argv);
+    const type = one(flags, 'type');
+    const ts = new Date().toISOString();
+
+    let event: KnowledgeEvent;
+    try {
+        switch (type) {
+            case 'convention_detected': {
+                const pattern = one(flags, 'pattern');
+                const evidence = flags.get('evidence') ?? [];
+                const sampleSizeRaw = one(flags, 'sample-size');
+                const scope = one(flags, 'scope');
+                if (!pattern || evidence.length === 0 || !sampleSizeRaw || (scope !== 'project' && scope !== 'global')) {
+                    throw new Error('missing/invalid --pattern, --evidence, --sample-size, or --scope');
+                }
+                event = {
+                    type: 'convention_detected',
+                    ts,
+                    pattern,
+                    evidence,
+                    sampleSize: Number.parseInt(sampleSizeRaw, 10),
+                    scope,
+                };
+                break;
+            }
+            case 'mistake_made': {
+                const errorCategory = one(flags, 'error-category');
+                const contextSourceRaw = one(flags, 'context-source');
+                const correction = one(flags, 'correction');
+                const recurrenceKey = one(flags, 'recurrence-key');
+                if (!errorCategory || contextSourceRaw === null || !correction || !recurrenceKey) {
+                    throw new Error('missing --error-category, --context-source, --correction, or --recurrence-key');
+                }
+                event = {
+                    type: 'mistake_made',
+                    ts,
+                    errorCategory,
+                    contextSource: contextSourceRaw === 'null' ? null : contextSourceRaw,
+                    correction,
+                    recurrenceKey,
+                };
+                break;
+            }
+            case 'api_shape_learned': {
+                const endpoint = one(flags, 'endpoint');
+                const method = one(flags, 'method');
+                const requestSchemaRaw = one(flags, 'request-schema');
+                const responseSchemaRaw = one(flags, 'response-schema');
+                if (!endpoint || !method || requestSchemaRaw === null || responseSchemaRaw === null) {
+                    throw new Error('missing --endpoint, --method, --request-schema, or --response-schema');
+                }
+                event = {
+                    type: 'api_shape_learned',
+                    ts,
+                    endpoint,
+                    method,
+                    requestSchema: JSON.parse(requestSchemaRaw),
+                    responseSchema: JSON.parse(responseSchemaRaw),
+                };
+                break;
+            }
+            case 'context_stale': {
+                const pagePath = one(flags, 'page-path');
+                const field = one(flags, 'field');
+                const expected = one(flags, 'expected');
+                const actual = one(flags, 'actual');
+                const evidence = one(flags, 'evidence');
+                if (!pagePath || !field || expected === null || actual === null || !evidence) {
+                    throw new Error('missing --page-path, --field, --expected, --actual, or --evidence');
+                }
+                event = { type: 'context_stale', ts, pagePath, field, expected, actual, evidence };
+                break;
+            }
+            default:
+                throw new Error(`--type must be one of convention_detected|mistake_made|api_shape_learned|context_stale (got "${type}")`);
+        }
+    } catch (err) {
+        process.stderr.write(`${PROG}: error: ${(err as Error).message}\n`);
+        printUsage();
+        return 1;
+    }
+
+    try {
+        appendEvent(event);
+    } catch (err) {
+        process.stderr.write(`${PROG}: error: ${(err as Error).message}\n`);
+        return 1;
+    }
+
+    process.stdout.write(`${PROG}: appended ${type} event to agents/knowledge/intake/.\n`);
+    return 0;
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] ?? '')) {
+    process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/export_replay_corpus.ts

@@ -0,0 +1,187 @@
+#!/usr/bin/env tsx
+/**
+ * Field-corpus exporter for router-telemetry replays
+ * (road-to-token-proof-and-story Phase 2).
+ *
+ * Reads one or more `.agent-chat-history` JSONL logs (schema: one JSON object
+ * per line; user turns are `{"t": "user", "text": "..."}`), extracts real
+ * prompts, applies a built-in redaction pass, and emits a
+ * `router_telemetry`-compatible corpus (`prompts:` entries with
+ * `{id, text, command}`), so the three/four replay arms run on
+ * consumer-shaped traffic instead of synthetic tasks.
+ *
+ * PRIVACY GATE (operator, non-optional): the built-in redaction is a
+ * mechanical first pass — emails, home paths, key-shaped tokens, long hex,
+ * URLs with credentials. The exported file MUST be human-reviewed under the
+ * low-impact-corpus privacy floor BEFORE it is stored, committed, or fed to
+ * any report that leaves the machine. The tool prints this reminder and
+ * defaults to a `.local.yaml` output name so an unreviewed export cannot be
+ * committed silently (gitignored pattern).
+ *
+ * Usage:
+ *   ./scripts-run src/scripts/export_replay_corpus \
+ *     --history agents/runtime/.agent-chat-history \
+ *     [--history <other-repo>/agents/runtime/.agent-chat-history ...] \
+ *     [--out internal/bench/corpora/field-prompts.local.yaml] \
+ *     [--limit 200] [--min-chars 20]
+ *
+ * Exit codes: 0 written · 1 usage/file error.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+const DEFAULT_OUT = path.join(REPO_ROOT, 'internal/bench/corpora/field-prompts.local.yaml');
+
+export interface FieldPrompt {
+  id: string;
+  text: string;
+  command: string | null;
+}
+
+const REDACTIONS: Array<[RegExp, string]> = [
+  // emails
+  [/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, '<EMAIL>'],
+  // API-key-shaped tokens (sk-…, ghp_…, xox…, AKIA…, long base64-ish runs)
+  [/\b(?:sk-[A-Za-z0-9_-]{10,}|ghp_[A-Za-z0-9]{20,}|gho_[A-Za-z0-9]{20,}|xox[a-z]-[A-Za-z0-9-]{10,}|AKIA[A-Z0-9]{12,})\b/g, '<KEY>'],
+  // credentials embedded in URLs
+  [/(https?:\/\/)[^\s/@]+:[^\s/@]+@/g, '$1<CREDENTIALS>@'],
+  // absolute home paths (macOS/Linux)
+  [/(?:\/Users|\/home)\/[A-Za-z0-9._-]+/g, '<HOME>'],
+  // long hex blobs (hashes, tokens)
+  [/\b[a-f0-9]{32,}\b/gi, '<HEX>'],
+  // IPv4
+  [/\b(?:\d{1,3}\.){3}\d{1,3}\b/g, '<IP>'],
+];
+
+/** Mechanical first-pass redaction — NOT a substitute for the operator review. */
+export function redact(text: string): string {
+  let out = text;
+  for (const [re, sub] of REDACTIONS) {
+    out = out.replace(re, sub);
+  }
+  return out;
+}
+
+/** Extract user prompts from one .agent-chat-history JSONL file. */
+export function extract_prompts(jsonlText: string, minChars: number): string[] {
+  const out: string[] = [];
+  for (const line of jsonlText.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let obj: Record<string, unknown>;
+    try {
+      obj = JSON.parse(trimmed) as Record<string, unknown>;
+    } catch {
+      continue; // tolerate partial/corrupt lines — logs are append-only
+    }
+    if (obj['t'] !== 'user' || typeof obj['text'] !== 'string') continue;
+    const text = (obj['text'] as string).trim();
+    if (text.length < minChars) continue;
+    out.push(text);
+  }
+  return out;
+}
+
+/** First `/token` of a prompt that looks like a slash command. */
+export function detect_command(text: string): string | null {
+  const m = /^\/([a-z0-9:_-]+)/i.exec(text.trim());
+  return m ? `/${(m[1] as string).toLowerCase()}` : null;
+}
+
+/** Build the corpus entries: redacted, de-duplicated, capped. */
+export function build_corpus(rawPrompts: string[], limit: number): FieldPrompt[] {
+  const seen = new Set<string>();
+  const out: FieldPrompt[] = [];
+  for (const raw of rawPrompts) {
+    const text = redact(raw);
+    const key = text.slice(0, 200);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({
+      id: `field-${String(out.length + 1).padStart(3, '0')}`,
+      text,
+      command: detect_command(text),
+    });
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+function _yamlQuote(s: string): string {
+  return JSON.stringify(s); // JSON string is valid YAML double-quoted scalar
+}
+
+export function to_yaml(prompts: FieldPrompt[]): string {
+  const lines: string[] = [
+    '# Field replay corpus — exported by export_replay_corpus.',
+    '# PRIVACY: operator review REQUIRED before this file is stored/committed',
+    '# (low-impact-corpus privacy floor). Redaction here is a mechanical first',
+    '# pass only. Replay caveat: intent triggers are informational-only in',
+    '# router_telemetry — replay UNDERCOUNTS intent-triggered rule loads.',
+    'prompts:',
+  ];
+  for (const p of prompts) {
+    lines.push(`  - id: ${p.id}`);
+    lines.push(`    text: ${_yamlQuote(p.text)}`);
+    if (p.command) lines.push(`    command: ${_yamlQuote(p.command)}`);
+  }
+  return lines.join('\n') + '\n';
+}
+
+export function main(argv: string[]): number {
+  const histories: string[] = [];
+  let out = DEFAULT_OUT;
+  let limit = 200;
+  let minChars = 20;
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i] as string;
+    if (a === '--history') histories.push(String(argv[(i += 1)] ?? ''));
+    else if (a === '--out') out = path.resolve(String(argv[(i += 1)] ?? ''));
+    else if (a === '--limit') limit = Number(argv[(i += 1)]);
+    else if (a === '--min-chars') minChars = Number(argv[(i += 1)]);
+    else if (a === '-h' || a === '--help') {
+      process.stdout.write(
+        'usage: export_replay_corpus --history <jsonl> [--history ...] [--out FILE] [--limit N] [--min-chars N]\n',
+      );
+      return 0;
+    } else {
+      process.stderr.write(`error: unknown argument: ${a}\n`);
+      return 1;
+    }
+  }
+  if (histories.length === 0 || !Number.isFinite(limit) || limit <= 0) {
+    process.stderr.write('error: at least one --history <path> is required\n');
+    return 1;
+  }
+  const raw: string[] = [];
+  for (const h of histories) {
+    let text: string;
+    try {
+      text = fs.readFileSync(h, 'utf-8');
+    } catch (e) {
+      process.stderr.write(`error: cannot read ${h}: ${(e as Error).message}\n`);
+      return 1;
+    }
+    raw.push(...extract_prompts(text, minChars));
+  }
+  const corpus = build_corpus(raw, limit);
+  fs.mkdirSync(path.dirname(out), { recursive: true });
+  fs.writeFileSync(out, to_yaml(corpus), 'utf-8');
+  process.stdout.write(
+    `wrote ${corpus.length} prompt(s) → ${path.relative(REPO_ROOT, out)}\n` +
+      '⚠️  PRIVACY GATE: operator review required before this corpus is stored,\n' +
+      '   committed, or used in any report (low-impact-corpus privacy floor).\n',
+  );
+  return 0;
+}
+
+const _IS_MAIN =
+  process.argv[1] !== undefined &&
+  import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+if (_IS_MAIN) {
+  process.exit(main(process.argv.slice(2)));
+}

package/src/scripts/external_sources_denylist.json

@@ -82,14 +82,19 @@
     "internal/workers/mcp/content.json.gz",
     "internal/workers/mcp/manifest.json",
     "src/rules/source-confidentiality.md",
-    "dist/agent-src/rules/source-confidentiality.md"
+    "dist/agent-src/rules/source-confidentiality.md",
+    "agents/roadmaps/archive/road-to-final-state-and-market-readiness.md",
+    "agents/roadmaps/archive/road-to-image-brand-typography.md",
+    "agents/roadmaps/archive/road-to-subagent-value-realization.md",
+    "agents/roadmap-assets/road-to-image-brand-typography.assets.md"
   ],
   "skip_reason": {
     "vendored_cluster": "design-intelligence/corpus-grounding/design-tokens/react-shadcn-ui/tailwind-engineer + cost/*.mjs ship vendored Apache/MIT code; their upstream attribution is license-required and must NOT be stripped (ADR-061).",
     "recommendation_docs": "mcp.md, mcp-registries.md, DISTRIBUTION_CHECKLIST.md, ADR-086, marketing-copy.yml reference registries (Smithery/Glama) as recommendations/distribution targets — allowed.",
     "generated_bundles": "content.json* bundle the vendored-cluster skill bodies above.",
     "self": "the linter + its denylist + the source-confidentiality rule necessarily contain the deny tokens as data.",
-    "validate_safe_paths": "telegraph-derived (MIT) ported code; upstream attribution is license-required."
+    "validate_safe_paths": "telegraph-derived (MIT) ported code; upstream attribution is license-required.",
+    "archived_roadmaps_newly_tracked": "Archived roadmaps (and their assets) that predate the source-confidentiality sweep became tracked via the 2026-07 agents-dir gitignore hygiene change. They are frozen historical records; the claudekit mentions are ADR-061 license-attribution work and the remaining names are historical planning references. New roadmaps stay subject to the gate."
   },
   "_excluded_tokens": {
     "agent-os": "collides with our own coined 'Agent-OS primitive' term (universal-skills) — too FP-prone to auto-deny; scrub external 'agent-os' mentions by review.",