@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/artifacts/corpus-views/renderers.js

@@ -0,0 +1,353 @@
+/**
+ * Research-corpus markdown-view renderers (#1490).
+ *
+ * TypeScript port of build.py's 12 renderers. Output is byte-identical to the
+ * Python source (modulo the volatile `Generated:` line). Trailing-newline and
+ * `.rstrip()` behavior is preserved per-renderer because the golden fixtures
+ * diff exactly.
+ *
+ * @source historical: corpus-index-build/build.py
+ */
+import * as path from 'path';
+import { PIPELINE_STAGES, SIZE_TIERS } from './taxonomies.js';
+import { compareRefId, refSortKey, normalizeAuthor, loadProfileSlugs } from './ref-parser.js';
+import { computeStaleness } from './corpus-config.js';
+function header(title, ctx, count) {
+    return [
+        `# ${title}`,
+        '',
+        `Generated: ${ctx.generated}`,
+        `Sources: ${count} references`,
+        `Source-Checksum: sha256:${ctx.checksum}`,
+        '',
+    ];
+}
+function refLink(r) {
+    return `**${r.refId}** — ${r.title}`;
+}
+/** Stable multi-key sort. Each key fn returns a comparable (number or string); arrays compared element-wise. */
+function sortByKeys(arr, keyFn) {
+    return [...arr].sort((a, b) => {
+        const ka = keyFn(a), kb = keyFn(b);
+        for (let i = 0; i < ka.length; i++) {
+            const x = ka[i], y = kb[i];
+            if (x < y)
+                return -1;
+            if (x > y)
+                return 1;
+        }
+        return 0;
+    });
+}
+function bySortedRefs(records) {
+    return [...records].sort((a, b) => compareRefId(a.refId, b.refId));
+}
+function renderGrouped(title, ctx, groups, trailingLabel = 'Uncategorized') {
+    const lines = header(title, ctx, ctx.records.length);
+    const names = sortByKeys([...groups.keys()], (n) => [n === trailingLabel, -groups.get(n).length, n.toLowerCase()]);
+    for (const name of names) {
+        const items = bySortedRefs(groups.get(name));
+        lines.push(`## ${name} (${items.length} papers)`, '');
+        for (const r of items)
+            lines.push(`- ${refLink(r)}`);
+        lines.push('');
+    }
+    return lines.join('\n').replace(/\s+$/, '') + '\n';
+}
+function groupBy(records, keyFn) {
+    const groups = new Map();
+    for (const r of records) {
+        for (const key of keyFn(r)) {
+            if (!groups.has(key))
+                groups.set(key, []);
+            groups.get(key).push(r);
+        }
+    }
+    return groups;
+}
+function renderByYear(ctx) {
+    const groups = groupBy(ctx.records, (r) => [r.year ? String(r.year) : 'Year Unknown']);
+    const lines = header('Index: Papers by Year', ctx, ctx.records.length);
+    const years = sortByKeys([...groups.keys()], (y) => [y === 'Year Unknown' ? -1 : -parseInt(y, 10), y]);
+    for (const year of years) {
+        const items = bySortedRefs(groups.get(year));
+        lines.push(`## ${year} (${items.length} papers)`, '');
+        for (const r of items)
+            lines.push(`- ${refLink(r)}`);
+        lines.push('');
+    }
+    return lines.join('\n').replace(/\s+$/, '') + '\n';
+}
+function renderAuthors(ctx) {
+    const groups = groupBy(ctx.records, (r) => (r.authors.length ? r.authors : ['(no authors listed)']).map(normalizeAuthor));
+    const lines = header('Index: Papers by Author', ctx, ctx.records.length);
+    lines.push('Sorted alphabetically by normalized author name.', '');
+    for (const author of [...groups.keys()].sort((a, b) => (a.toLowerCase() < b.toLowerCase() ? -1 : a.toLowerCase() > b.toLowerCase() ? 1 : 0))) {
+        const items = bySortedRefs(groups.get(author));
+        if (items.length === 1) {
+            lines.push(`- **${author}** — ${items[0].refId}: ${items[0].title}`);
+        }
+        else {
+            lines.push(`- **${author}** (${items.length} papers)`);
+            for (const r of items)
+                lines.push(`  - ${r.refId}: ${r.title}`);
+        }
+    }
+    return lines.join('\n').replace(/\s+$/, '') + '\n';
+}
+function authorSlug(author) {
+    return author.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').replace(/- /g, '-');
+}
+function renderEntityAuthors(ctx) {
+    const profiles = loadProfileSlugs(ctx.corpusRoot);
+    const counts = groupBy(ctx.records, (r) => (r.authors.length ? r.authors : ['(no authors listed)']).map(normalizeAuthor));
+    const lines = header('Authors Index (Enriched)', ctx, ctx.records.length);
+    lines.push('| Author | Papers | Top Hub Authored | Profile | REFs |', '|---|---:|---|---|---|');
+    const entries = sortByKeys([...counts.entries()], ([author, items]) => [-items.length, author.toLowerCase()]);
+    for (const [author, items] of entries) {
+        const refs = [...new Set(items.map((r) => r.refId))].sort(compareRefId);
+        const top = items.reduce((best, r) => (best === null || r.incoming.size > best.incoming.size ? r : best), null);
+        const slug = authorSlug(author);
+        const profile = profiles.has(slug) ? `[PROF-P-${slug}](../documentation/profiles/people/PROF-P-${slug}.md)` : '-';
+        const refsCol = `${refs.slice(0, 12).join(', ')}${refs.length > 12 ? '...' : ''}`;
+        lines.push(`| ${author} | ${refs.length} | ${top ? top.refId : '-'} (${top ? top.incoming.size : 0}) | ${profile} | ${refsCol} |`);
+    }
+    return lines.join('\n') + '\n';
+}
+/** Stable count of values, preserving first-seen order (mirrors Counter.most_common tie behavior). */
+function topCounted(values, n) {
+    const counts = new Map();
+    for (const v of values)
+        counts.set(v, (counts.get(v) ?? 0) + 1);
+    return sortByKeys([...counts.keys()], (k) => [-counts.get(k)]).slice(0, n);
+}
+function renderOrgs(ctx) {
+    const groups = new Map();
+    const orgAuthors = new Map();
+    for (const r of ctx.records) {
+        const org = r.primaryAffiliation || '(no affiliation listed)';
+        if (!groups.has(org)) {
+            groups.set(org, []);
+            orgAuthors.set(org, []);
+        }
+        groups.get(org).push(r);
+        for (const a of r.authors.slice(0, 3))
+            orgAuthors.get(org).push(normalizeAuthor(a));
+    }
+    const lines = header('Affiliations Index', ctx, ctx.records.length);
+    lines.push('| Affiliation | Papers | Top Authors | REFs |', '|---|---:|---|---|');
+    const entries = sortByKeys([...groups.entries()], ([org, items]) => [-items.length, org.toLowerCase()]);
+    for (const [org, items] of entries) {
+        const refs = [...new Set(items.map((r) => r.refId))].sort(compareRefId);
+        const topAuthors = topCounted(orgAuthors.get(org), 3).join(', ') || '-';
+        const refsCol = `${refs.slice(0, 12).join(', ')}${refs.length > 12 ? '...' : ''}`;
+        lines.push(`| ${org} | ${refs.length} | ${topAuthors} | ${refsCol} |`);
+    }
+    return lines.join('\n') + '\n';
+}
+function renderBridges(ctx) {
+    const authorOrgs = new Map();
+    const authorRefs = new Map();
+    for (const r of ctx.records) {
+        for (const a of r.authors) {
+            const norm = normalizeAuthor(a);
+            if (!authorOrgs.has(norm)) {
+                authorOrgs.set(norm, new Set());
+                authorRefs.set(norm, new Set());
+            }
+            if (r.primaryAffiliation)
+                authorOrgs.get(norm).add(r.primaryAffiliation);
+            authorRefs.get(norm).add(r.refId);
+        }
+    }
+    const lines = header('Bridge Authors', ctx, ctx.records.length);
+    lines.push('Authors whose corpus papers span two or more distinct affiliations.', '', '| Author | Affiliations | Papers | REFs |', '|---|---:|---:|---|');
+    const rows = [...authorOrgs.entries()].filter(([, orgs]) => orgs.size >= 2).map(([a, orgs]) => ({ a, orgs, refs: authorRefs.get(a) }));
+    const sorted = sortByKeys(rows, (row) => [-row.orgs.size, -row.refs.size, row.a.toLowerCase()]);
+    for (const { a, orgs, refs } of sorted) {
+        const sortedRefs = [...refs].sort(compareRefId);
+        const refsCol = `${sortedRefs.slice(0, 12).join(', ')}${sortedRefs.length > 12 ? '...' : ''}`;
+        lines.push(`| ${a} | ${orgs.size} | ${refs.size} | ${refsCol} |`);
+    }
+    return lines.join('\n') + '\n';
+}
+function renderUnprofiledHubs(ctx) {
+    const profileSlugs = loadProfileSlugs(ctx.corpusRoot);
+    const lines = header('Unprofiled Top Hubs', ctx, ctx.records.length);
+    lines.push('Top in-degree REFs whose primary author does not appear to have a PROF-P profile.', '', '| REF | In-deg | Primary Author | Title |', '|---|---:|---|---|');
+    const sorted = sortByKeys(ctx.records, (r) => [-r.incoming.size, ...refSortKey(r.refId)]);
+    let emitted = 0;
+    for (const r of sorted) {
+        if (!r.authors.length)
+            continue;
+        const author = normalizeAuthor(r.authors[0]);
+        const slug = author.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+        if (profileSlugs.has(slug))
+            continue;
+        lines.push(`| ${r.refId} | ${r.incoming.size} | ${author} | ${r.title.slice(0, 80)} |`);
+        if (++emitted >= 50)
+            break;
+    }
+    return lines.join('\n') + '\n';
+}
+function renderCitationNetwork(ctx) {
+    const nodes = ctx.records.length;
+    const edges = ctx.records.reduce((sum, r) => sum + r.outgoing.size, 0);
+    const lines = header('Citation Network', ctx, nodes);
+    const density = nodes > 1 ? edges / (nodes * (nodes - 1)) : 0;
+    lines.push(`Nodes: ${nodes} | Edges: ${edges} | Density: ${density.toFixed(4)}`, '', '## Top Hubs', '', '| REF | Title | In | Out | Total |', '|---|---|---:|---:|---:|');
+    const hubs = sortByKeys(ctx.records, (r) => [-(r.incoming.size + r.outgoing.size), ...refSortKey(r.refId)]).slice(0, 25);
+    for (const r of hubs) {
+        lines.push(`| ${r.refId} | ${r.title.slice(0, 80)} | ${r.incoming.size} | ${r.outgoing.size} | ${r.incoming.size + r.outgoing.size} |`);
+    }
+    const isolated = ctx.records.filter((r) => !r.incoming.size && !r.outgoing.size);
+    lines.push('', `## Isolated Nodes (${isolated.length})`, '', '| REF | Title |', '|---|---|');
+    for (const r of bySortedRefs(isolated).slice(0, 200)) {
+        lines.push(`| ${r.refId} | ${r.title.slice(0, 100)} |`);
+    }
+    return lines.join('\n') + '\n';
+}
+function renderModelSize(ctx) {
+    const groups = groupBy(ctx.records, (r) => [r.sizeTier || 'Not Applicable / No Extractable Size']);
+    const lines = header('Index: Papers by Model Size', ctx, ctx.records.length);
+    const tierOrder = [...SIZE_TIERS.map((t) => t[0]), 'Not Applicable / No Extractable Size'];
+    for (const tier of tierOrder) {
+        const items = groups.get(tier);
+        if (!items)
+            continue;
+        lines.push(`## ${tier} (${items.length} papers)`, '');
+        const sorted = sortByKeys(items, (r) => [-(r.paramsM ?? 0), ...refSortKey(r.refId)]);
+        for (const r of sorted) {
+            const size = r.paramsM && r.paramsM >= 1000 ? ` [${(r.paramsM / 1000).toFixed(1)}B]` : r.paramsM ? ` [${Math.round(r.paramsM)}M]` : '';
+            lines.push(`- **${r.refId}**${size} — ${r.title}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n').replace(/\s+$/, '') + '\n';
+}
+function renderPipeline(ctx) {
+    const available = new Set(ctx.records.map((r) => r.refId));
+    const lines = header('Index: Training Pipeline Reading Order', ctx, ctx.records.length);
+    lines.push('Stages move from data preparation through training, alignment, deployment, and monitoring.', '');
+    for (const [title, blurb, refs] of PIPELINE_STAGES) {
+        lines.push(`## ${title}`, '', `_${blurb}_`, '');
+        for (const ref of refs) {
+            lines.push(`- **${ref}${available.has(ref) ? '' : ' (not in corpus)'}**`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n').replace(/\s+$/, '') + '\n';
+}
+// ── Radar / discovery / funder views (#1492) ──────────────────────────────
+// Cadence → window math lives in corpus-config.ts (the one staleness helper, #1498/#1502).
+/** GRADE display order; unknown grades fall after, 'Ungraded' last. */
+const GRADE_ORDER = ['A', 'A-', 'B', 'B-', 'C', 'C-', 'D'];
+/** Papers grouped by current GRADE (radar `grade-current`); no-radar → Ungraded. (#1492) */
+function renderByGrade(ctx) {
+    const groups = groupBy(ctx.records, (r) => [r.radar?.gradeCurrent || 'Ungraded']);
+    const lines = header('Index: Papers by GRADE', ctx, ctx.records.length);
+    const names = [...groups.keys()].sort((a, b) => {
+        if (a === 'Ungraded')
+            return 1;
+        if (b === 'Ungraded')
+            return -1;
+        const ia = GRADE_ORDER.indexOf(a);
+        const ib = GRADE_ORDER.indexOf(b);
+        const ra = ia === -1 ? GRADE_ORDER.length : ia;
+        const rb = ib === -1 ? GRADE_ORDER.length : ib;
+        return ra !== rb ? ra - rb : a < b ? -1 : a > b ? 1 : 0;
+    });
+    for (const name of names) {
+        const items = bySortedRefs(groups.get(name));
+        lines.push(`## ${name} (${items.length} papers)`, '');
+        for (const r of items)
+            lines.push(`- ${refLink(r)}`);
+        lines.push('');
+    }
+    return lines.join('\n').replace(/\s+$/, '') + '\n';
+}
+/** Radar-tracked papers ranked by overdue-ness (cadence window vs last-refreshed). (#1492) */
+function renderStaleQueue(ctx) {
+    const today = new Date(`${ctx.generated.slice(0, 10)}T00:00:00Z`);
+    const rows = [];
+    for (const r of ctx.records) {
+        const rad = r.radar;
+        if (!rad || !rad.refreshCadence || !rad.lastRefreshed)
+            continue;
+        const { overdueDays } = computeStaleness(rad.refreshCadence, rad.lastRefreshed, today);
+        if (overdueDays === null)
+            continue; // on-demand / unknown cadence / unparseable date → not queued
+        rows.push({ r, cadence: rad.refreshCadence, last: rad.lastRefreshed, overdue: overdueDays });
+    }
+    const sorted = sortByKeys(rows, (row) => [-row.overdue, ...refSortKey(row.r.refId)]);
+    const staleCount = sorted.filter((x) => x.overdue > 0).length;
+    const lines = header('Index: Radar Stale-Refresh Queue', ctx, ctx.records.length);
+    lines.push(`Overdue = days since last refresh minus the cadence window. ${staleCount} of ${rows.length} radar-tracked papers are overdue.`, '', '| REF | Title | GRADE | Cadence | Last Refreshed | Overdue (days) | Stale |', '|---|---|---|---|---|---:|---|');
+    for (const { r, cadence, last, overdue } of sorted) {
+        lines.push(`| ${r.refId} | ${r.title.slice(0, 70)} | ${r.radar.gradeCurrent ?? '—'} | ${cadence} | ${last} | ${overdue} | ${overdue > 0 ? 'yes' : 'no'} |`);
+    }
+    return lines.join('\n') + '\n';
+}
+/** Supported renderer names — `name` in the index.graphs.indices.manifest selects one of these. */
+/**
+ * Cross-project impact (#1495): refs ranked by how many downstream projects
+ * cite them (from the "Referenced By" table). Surfaces what's load-bearing
+ * across the org.
+ */
+function renderProjectImpact(ctx) {
+    const ranked = ctx.records
+        .filter((r) => r.referencedByProjects.length > 0)
+        .sort((a, b) => b.referencedByProjects.length - a.referencedByProjects.length || compareRefId(a.refId, b.refId));
+    const lines = header('Index: Cross-Project Impact', ctx, ranked.length);
+    lines.push('Refs ranked by number of consuming projects (downstream "Referenced By").', '');
+    lines.push('| Rank | REF | Projects | Consuming projects |', '|---|---|---:|---|');
+    ranked.forEach((r, i) => {
+        lines.push(`| ${i + 1} | ${refLink(r)} | ${r.referencedByProjects.length} | ${r.referencedByProjects.join(', ')} |`);
+    });
+    return lines.join('\n').replace(/\s+$/, '') + '\n';
+}
+export const SUPPORTED_VIEWS = [
+    'by-year', 'by-topic', 'authors', 'by-venue', 'by-method', 'by-model-size',
+    'training-pipeline', 'citation-network', 'by-author', 'by-org', 'by-bridge', 'unprofiled-hubs',
+    // radar / discovery / funder views (#1492)
+    'by-grade', 'radar-stale-queue', 'by-trajectory', 'by-source', 'by-curator', 'by-funder',
+    // source-type view (#1509)
+    'by-source-type',
+    // cross-project views (#1495)
+    'by-project', 'project-impact',
+];
+/** Render one named view. Throws on an unsupported name (mirrors build.py build_graph). */
+export function renderView(name, ctx) {
+    switch (name) {
+        case 'by-year': return renderByYear(ctx);
+        case 'by-topic': return renderGrouped('Index: Papers by Topic', ctx, groupBy(ctx.records, (r) => r.topics));
+        case 'authors': return renderAuthors(ctx);
+        case 'by-venue': return renderGrouped('Index: Papers by Venue', ctx, groupBy(ctx.records, (r) => [r.venue || 'Unmatched']));
+        case 'by-method': return renderGrouped('Index: Papers by Method', ctx, groupBy(ctx.records, (r) => r.methods));
+        case 'by-model-size': return renderModelSize(ctx);
+        case 'training-pipeline': return renderPipeline(ctx);
+        case 'citation-network': return renderCitationNetwork(ctx);
+        case 'by-author': return renderEntityAuthors(ctx);
+        case 'by-org': return renderOrgs(ctx);
+        case 'by-bridge': return renderBridges(ctx);
+        case 'unprofiled-hubs': return renderUnprofiledHubs(ctx);
+        // Radar / discovery / funder views (#1492)
+        case 'by-grade': return renderByGrade(ctx);
+        case 'radar-stale-queue': return renderStaleQueue(ctx);
+        case 'by-trajectory': return renderGrouped('Index: Papers by GRADE Trajectory', ctx, groupBy(ctx.records, (r) => [r.radar?.gradeTrajectory || 'unknown']), 'unknown');
+        case 'by-source': return renderGrouped('Index: Papers by Discovery Surface', ctx, groupBy(ctx.records, (r) => [r.discovery?.surface || 'unknown-surface']), 'unknown-surface');
+        case 'by-curator': return renderGrouped('Index: Papers by Curator', ctx, groupBy(ctx.records, (r) => [r.discovery?.curatorId || 'no-curator']), 'no-curator');
+        case 'by-funder': return renderGrouped('Index: Papers by Funder', ctx, groupBy(ctx.records, (r) => (r.funders.length ? r.funders.map((f) => f.id) : ['unfunded'])), 'unfunded');
+        // Source-type view (#1509) — groups refs by the canonical source type the registry normalizes to.
+        case 'by-source-type': return renderGrouped('Index: Sources by Type', ctx, groupBy(ctx.records, (r) => [r.sourceType || 'other']), 'other');
+        // Cross-project views (#1495) — consuming-project grouping + impact ranking.
+        case 'by-project': return renderGrouped('Index: Refs by Consuming Project', ctx, groupBy(ctx.records, (r) => (r.referencedByProjects.length ? r.referencedByProjects : ['(no consuming project)'])), '(no consuming project)');
+        case 'project-impact': return renderProjectImpact(ctx);
+        default: throw new Error(`unsupported graph: ${name}`);
+    }
+}
+/** Default output path for a view: entry.output or indices/<name>.md. */
+export function outputForView(name, output) {
+    return output ? output : path.join('indices', `${name}.md`);
+}
+//# sourceMappingURL=renderers.js.map

package/dist/src/artifacts/corpus-views/taxonomies.js

@@ -0,0 +1,131 @@
+/**
+ * Corpus-view classifier taxonomies (#1490).
+ *
+ * Verbatim TypeScript port of the regex pattern tables from the retired
+ * research-complete `corpus-index-build/build.py`. Pattern order is
+ * load-bearing: `classifyFirst` returns the FIRST matching label, so reordering
+ * changes classification. All patterns are matched case-insensitively (the
+ * Python source compiled with `re.I`).
+ *
+ * @source historical: agentic/code/frameworks/research-complete/skills/corpus-index-build/build.py
+ */
+const ci = (src) => new RegExp(src, 'i');
+/** Single-label topic classifier (first match wins). */
+export const TOPIC_PATTERNS = [
+    ['Reinforcement Learning & RLHF', ci('\\b(rlhf|reinforcement learning|rlvr|reward model|ppo|dpo|grpo)\\b')],
+    ['Mechanistic Interpretability', ci('\\b(mechanistic interpret|circuit|feature attribution|sparse autoencoder|activation steering|probing)\\b')],
+    ['AI Safety & Alignment', ci('\\b(alignment|misalign|sycophan|deception|jailbreak|red team|safety|constitutional ai)\\b')],
+    ['Agentic Workflows & Multi-Agent', ci('\\b(agentic|multi-agent|multi[- ]agent|tool use|orchestrat|autogen|agent loop)\\b')],
+    ['Retrieval & RAG', ci('\\b(rag|retrieval[- ]augmented|dense retriev|reranker|bm25|colbert|hybrid retriev)\\b')],
+    ['Embeddings & Vector Search', ci('\\b(embedding|sentence-bert|hnsw|ann |vector search|matryoshka)\\b')],
+    ['Reasoning & Chain-of-Thought', ci('\\b(chain[- ]of[- ]thought|reasoning|self-refine|self-consist|cot prompt|thought)\\b')],
+    ['Code Generation & Software Engineering', ci('\\b(code generation|code llama|humaneval|mbpp|swe-bench|copilot|coding assistant)\\b')],
+    ['Fine-Tuning & PEFT', ci('\\b(lora|peft|fine[- ]tun|adapter|qlora|instruction tun)\\b')],
+    ['Pretraining & Scaling Laws', ci('\\b(scaling laws|chinchilla|pretrain|compute[- ]optimal|emergent abilit)\\b')],
+    ['Quantization & Compression', ci('\\b(quantization|pruning|gptq|awq|distillation|compression)\\b')],
+    ['Inference & Serving Systems', ci('\\b(vllm|tensorrt|inference serv|kv cache|continuous batch|paged attention|serving)\\b')],
+    ['Memory & Context', ci('\\b(long context|context window|memory augment|stateful|kv-cache memory)\\b')],
+    ['Robotics & Embodied AI', ci('\\b(robot|embodied|manipulation|locomotion|vla |vision[- ]language[- ]action)\\b')],
+    ['Multimodal', ci('\\b(multimodal|vision[- ]language|vlm|clip|image[- ]text)\\b')],
+    ['Benchmarks & Evaluation', ci('\\b(benchmark|evaluat|helm|big-bench|mt-bench|leaderboard)\\b')],
+    ['Knowledge Graphs & Symbolic', ci('\\b(knowledge graph|symbolic|ontolog|rdf|sparql)\\b')],
+    ['Streaming & Event-Driven Systems', ci('\\b(kafka|redis stream|nats|event[- ]driven|cdc|change data capt|stream process)\\b')],
+    ['Distributed Systems', ci('\\b(distributed system|consensus|raft|paxos|sharding|replicat)\\b')],
+    ['Cryptography & Security', ci('\\b(cryptograph|threshold signature|frost|schnorr|hkdf|argon2|tpm|hsm|secure enclave)\\b')],
+    ['Blockchain', ci('\\b(blockchain|proof of stake|ethereum|validator)\\b')],
+    ['HCI & Developer Experience', ci('\\b(developer productiv|hci|cognitive load|user study|ux research|developer experience)\\b')],
+    ['Theory of Mind & Social Reasoning', ci('\\b(theory of mind|tom |social reason|persuas|emotion)\\b')],
+    ['Cognitive Science & Psychology', ci("\\b(cognitive scien|psycholog|metacognit|miller'?s law)\\b")],
+    ['LLM Foundations & Surveys', ci('\\b(survey|foundation model|large language model|transformer architecture)\\b')],
+    ['LLM Evaluation & Benchmarks', ci('\\b(llm|language model|gpt|claude|gemini|llama|mistral)\\b')],
+];
+/** Multi-label method classifier (all matches). */
+export const METHOD_PATTERNS = [
+    ['Quantization', ci('\\b(quantiz|gptq|awq|int4|int8|bf16|fp4|fp8|bitnet|smoothquant)\\b')],
+    ['Pruning & Sparsity', ci('\\b(prun|sparsit|sparse model|magnitude prun|wanda|sparsegpt)\\b')],
+    ['Distillation', ci('\\b(distill|distilbert|teacher[- ]student|knowledge distill)\\b')],
+    ['PEFT / LoRA / Adapters', ci('\\b(lora|qlora|peft|adapter[- ]based|prefix tun|prompt tun|p-?tuning)\\b')],
+    ['Fine-Tuning (Full)', ci('\\b(full fine[- ]tun|sft|supervised fine[- ]tun|instruction tun)\\b')],
+    ['RLHF / DPO / RL-from-Feedback', ci('\\b(rlhf|dpo|ppo|grpo|reward model|kto|ipo|orpo|reinforcement learning from human)\\b')],
+    ['RLVR / Verifiable Rewards', ci('\\b(rlvr|verifiable reward|rule[- ]based reward|self[- ]reward)\\b')],
+    ['Alignment & Constitutional', ci('\\b(constitutional ai|alignment|rule[- ]based ai feedback|rlaif)\\b')],
+    ['Chain-of-Thought / Reasoning', ci('\\b(chain[- ]of[- ]thought|cot prompt|self[- ]refine|self[- ]consist|tree of thoughts|react)\\b')],
+    ['Self-Play / Self-Improvement', ci('\\b(self[- ]play|self[- ]improv|bootstrap|star algorithm|rstar)\\b')],
+    ['Mixture of Experts', ci('\\b(mixture of experts|\\bmoe\\b|gshard|switch transformer|expert routing)\\b')],
+    ['Retrieval-Augmented Generation', ci('\\b(retrieval[- ]augmented|\\brag\\b|fid |dense retriev|colbert)\\b')],
+    ['Embedding & Vector Search', ci('\\b(embedding|sentence-bert|hnsw|matryoshka|vector index)\\b')],
+    ['Attention Variants & Long Context', ci('\\b(flash attention|sliding window attention|sparse attention|paged attention|ring attention|alibi|rotary embedding|rope)\\b')],
+    ['KV Cache & Inference Optimization', ci('\\b(kv[- ]cache|kv cache|continuous batching|paged attention|prefill|decode optimization|speculative decoding)\\b')],
+    ['Serving & Batching Systems', ci('\\b(vllm|tensorrt|continuous batch|dynamic batch|inference serv|throughput optimization)\\b')],
+    ['Pretraining & Scaling Laws', ci('\\b(scaling laws|chinchilla|compute[- ]optimal|pretrain|data mixing)\\b')],
+    ['Data Curation & Synthesis', ci('\\b(data curation|data synthesis|synthetic data|deduplication|semdedup|dataset distill)\\b')],
+    ['Evaluation & Benchmarking', ci('\\b(benchmark|evaluat|helm|big[- ]bench|mt[- ]bench|leaderboard|holistic evaluation)\\b')],
+    ['Mechanistic Interpretability', ci('\\b(mechanistic interpret|circuit analysis|sparse autoencoder|\\bsae\\b|feature attribution|probing classifier|activation steering)\\b')],
+    ['Agentic Orchestration & Tool Use', ci('\\b(agentic|multi[- ]agent|tool use|tool[- ]calling|autogen|orchestrat|agent loop|react)\\b')],
+    ['Robotics / Embodied Learning', ci('\\b(robot|embodied|manipulation|locomotion|vla |vision[- ]language[- ]action|sim[- ]to[- ]real)\\b')],
+    ['Multimodal / Vision-Language', ci('\\b(multimodal|vision[- ]language|\\bvlm\\b|clip|image[- ]text|visual instruction)\\b')],
+    ['Diffusion / Generative Models', ci('\\b(diffusion model|ddpm|score[- ]based|latent diffusion|flow matching|stable diffusion)\\b')],
+    ['Reinforcement Learning (Foundations)', ci('\\b(reinforcement learning|markov decision|q[- ]learning|actor[- ]critic|trpo|policy gradient)\\b')],
+    ['Distributed Training & Parallelism', ci('\\b(zero|fsdp|tensor parallel|pipeline parallel|data parallel|megatron|deepspeed)\\b')],
+];
+/** Single-label venue classifier (first match wins). */
+export const VENUE_PATTERNS = [
+    ['NeurIPS', ci('\\b(neurips|nips)\\b')], ['ICML', ci('\\bicml\\b')], ['ICLR', ci('\\biclr\\b')],
+    ['ACL', ci('\\b(acl |annual meeting of the association for computational linguistics)\\b')],
+    ['EMNLP', ci('\\bemnlp\\b')], ['NAACL', ci('\\bnaacl\\b')], ['CVPR', ci('\\bcvpr\\b')],
+    ['ICCV', ci('\\biccv\\b')], ['ECCV', ci('\\beccv\\b')], ['AAAI', ci('\\baaai\\b')],
+    ['IJCAI', ci('\\bijcai\\b')], ['KDD', ci('\\b(kdd |sigkdd)\\b')], ['SIGIR', ci('\\bsigir\\b')],
+    ['WWW', ci('\\b(www conference|the web conference)\\b')], ['RSS', ci('\\b(rss |robotics: science and systems)\\b')],
+    ['CoRL', ci('\\bcorl\\b')], ['ICRA', ci('\\bicra\\b')], ['IROS', ci('\\biros\\b')],
+    ['OSDI', ci('\\bosdi\\b')], ['SOSP', ci('\\bsosp\\b')], ['NSDI', ci('\\bnsdi\\b')],
+    ['USENIX ATC', ci('\\busenix atc\\b')], ['USENIX Security', ci('\\busenix security\\b')],
+    ['IEEE S&P / Oakland', ci('\\b(ieee s&p|ieee symposium on security|oakland)\\b')],
+    ['CCS', ci("\\b(acm ccs|ccs '?\\d)\\b")], ['CHI', ci("\\b(chi conference|chi '?\\d)\\b")],
+    ['UIST', ci('\\buist\\b')], ['VLDB', ci('\\bvldb\\b')], ['SIGMOD', ci('\\bsigmod\\b')],
+    ['FAccT', ci('\\bfacct\\b')], ['TMLR', ci('\\btmlr\\b')], ['JMLR', ci('\\bjmlr\\b')],
+    ['Nature', ci('\\b(nature\\b(?! communications)|nature\\.)')], ['Science', ci('\\bscience\\b(?! advances)')],
+    ['PNAS', ci('\\bpnas\\b')], ['RFC (IETF)', ci('\\brfc \\d+\\b')], ['arXiv', ci('\\b(arxiv|preprint)\\b')],
+    ['Anthropic Research', ci('\\b(anthropic\\.com|anthropic research|transformer circuits)\\b')],
+    ['OpenAI Research', ci('\\bopenai\\.com\\b')], ['DeepMind / Google Research', ci('\\b(deepmind|google research|research\\.google)\\b')],
+    ['Meta AI / FAIR', ci('\\b(meta ai|fair |facebook ai research)\\b')], ['Microsoft Research', ci('\\bmicrosoft research\\b')],
+    ['GitHub / Documentation', ci('\\b(github\\.com|github pages|readthedocs|docs\\.\\w+)\\b')],
+    ['Blog / Web Article', ci('\\b(blog|medium\\.com|substack|dev\\.to)\\b')], ['Wikipedia', ci('\\bwikipedia\\b')],
+];
+/** Size extraction patterns: [pattern, multiplier-to-millions]. Matched globally, case-insensitive. */
+export const SIZE_PATTERNS = [
+    [/(\d+\.\d+|\d{1,4})\s*B\b(?:\s*parameters|\s*params|\s*model)?/gi, 1000],
+    [/(\d{1,4})\s*M\b(?:\s*parameters|\s*params|\s*model)?/gi, 1],
+];
+export const SIZE_TIERS = [
+    ['<1B parameters', 0, 999],
+    ['1-10B parameters', 1000, 9999],
+    ['10-100B parameters', 10000, 99999],
+    ['100B-1T parameters', 100000, 999999],
+    ['1T+ parameters', 1000000, 10 ** 12],
+];
+export const PIPELINE_STAGES = [
+    ['1. Data Curation & Preparation', 'Assembling, cleaning, and deduplicating pretraining and finetuning data.', ['REF-421', 'REF-460', 'REF-468', 'REF-471', 'REF-442']],
+    ['2. Tokenization & Architecture Foundations', 'Tokenizer choice, architecture variants, and positional encodings.', ['REF-389', 'REF-500']],
+    ['3. Pretraining at Scale', 'Compute-optimal recipes, scaling laws, and large-scale optimization.', ['REF-052', 'REF-054', 'REF-389', 'REF-437', 'REF-460']],
+    ['4. Mixture-of-Experts & Sparse Architectures', 'Sparsely activated models as a parallel pretraining strategy.', ['REF-007']],
+    ['5. Instruction Tuning & SFT', 'Supervised fine-tuning on instructions to convert base models into assistants.', ['REF-055', 'REF-435', 'REF-470']],
+    ['6. RLHF, DPO, and Preference Optimization', 'Aligning models with human and AI feedback.', ['REF-025', 'REF-055', 'REF-449']],
+    ['7. RLVR & Reasoning RL', 'Verifiable-reward RL for reasoning, math, and code.', ['REF-819', 'REF-957', 'REF-457']],
+    ['8. PEFT / LoRA / Adapter-Based Adaptation', 'Parameter-efficient fine-tuning when full SFT is impractical.', ['REF-049']],
+    ['9. Quantization, Pruning & Compression', 'Shrinking trained models for inference deployment.', ['REF-051']],
+    ['10. Inference Serving & Optimization', 'Productionizing trained models: batching, KV cache, throughput.', ['REF-101', 'REF-102', 'REF-312', 'REF-313']],
+    ['11. Evaluation, Safety & Continuous Monitoring', 'Holistic evaluation, red-teaming, and live monitoring.', ['REF-063', 'REF-064', 'REF-189', 'REF-191', 'REF-481']],
+];
+/** Return the first matching label, or null. Mirrors build.py `classify_first`. */
+export function classifyFirst(text, patterns) {
+    for (const [label, pattern] of patterns) {
+        if (pattern.test(text))
+            return label;
+    }
+    return null;
+}
+/** Return all matching labels in table order. Mirrors build.py `classify_many`. */
+export function classifyMany(text, patterns) {
+    return patterns.filter(([, pattern]) => pattern.test(text)).map(([label]) => label);
+}
+//# sourceMappingURL=taxonomies.js.map

package/dist/src/artifacts/dep-graph.js

@@ -0,0 +1,173 @@
+/**
+ * Artifact Dependency Graph
+ *
+ * Traverses the artifact dependency graph built from @-mention relationships.
+ * Shows upstream (what this depends on) and downstream (what depends on this).
+ *
+ * @implements #417
+ * @source @src/artifacts/types.ts
+ * @tests @test/unit/artifacts/dep-graph.test.ts
+ */
+import { normalizeEdges } from './types.js';
+import { loadDependencyGraph, loadGraphIndexFile } from './index-reader.js';
+import { buildFortemiCoreDependencyGraph } from './fortemi-core-query-adapter.js';
+/**
+ * Traverse the dependency graph in one direction
+ *
+ * @param edgeType - Optional filter: only follow edges of this type
+ */
+function traverse(graph, startPath, direction, maxDepth, visited = new Set(), currentDepth = 0, edgeType) {
+    if (currentDepth >= maxDepth)
+        return [];
+    const node = graph[startPath];
+    if (!node)
+        return [];
+    const rawEdges = direction === 'upstream' ? node.upstream : node.downstream;
+    // Normalize for backward compat (old indexes may have string arrays)
+    const edges = normalizeEdges(rawEdges);
+    // Filter by edge type if specified
+    const filtered = edgeType ? edges.filter(e => e.type === edgeType) : edges;
+    const results = [];
+    for (const edge of filtered) {
+        if (visited.has(edge.path))
+            continue; // Cycle detection
+        visited.add(edge.path);
+        const children = traverse(graph, edge.path, direction, maxDepth, visited, currentDepth + 1, edgeType);
+        results.push({ path: edge.path, depth: currentDepth + 1, children });
+    }
+    return results;
+}
+/**
+ * Format tree output for human readability
+ */
+function formatTree(results, prefix = '') {
+    let output = '';
+    for (let i = 0; i < results.length; i++) {
+        const isLast = i === results.length - 1;
+        const connector = isLast ? '└── ' : '├── ';
+        const childPrefix = isLast ? '    ' : '│   ';
+        output += `${prefix}${connector}${results[i].path}\n`;
+        if (results[i].children.length > 0) {
+            output += formatTree(results[i].children, prefix + childPrefix);
+        }
+    }
+    return output;
+}
+/**
+ * Flatten traversal results into a unique path list
+ */
+function flattenResults(results) {
+    const paths = [];
+    for (const r of results) {
+        paths.push(r.path);
+        paths.push(...flattenResults(r.children));
+    }
+    return [...new Set(paths)];
+}
+/**
+ * Show dependencies for an artifact
+ */
+export async function showDeps(cwd, artifactPath, options = {}) {
+    const { direction = 'both', depth = 3, json = false, graph: graphType, edgeType, backend = 'fortemi-core' } = options;
+    let depGraph = null;
+    if (backend === 'fortemi-core') {
+        const loaded = buildFortemiCoreDependencyGraph(cwd, graphType ?? 'project');
+        if (!loaded.graph) {
+            if (json) {
+                console.log(JSON.stringify({ error: 'fortemi-core-index-unavailable', hint: loaded.reason }, null, 2));
+            }
+            else {
+                console.error('Error: Fortemi Core static index is unavailable.');
+                console.log(loaded.reason ??
+                    "Run 'aiwg index sync' first, or pass '--backend local' to use the legacy local index.");
+            }
+            process.exit(1);
+        }
+        depGraph = loaded.graph;
+    }
+    else if (graphType) {
+        depGraph = loadGraphIndexFile(cwd, 'dependencies.json', graphType);
+        if (!depGraph) {
+            console.error(`Error: No artifact index found for graph '${graphType}'.`);
+            console.log("Run 'aiwg index build' first to create the index.");
+            process.exit(1);
+        }
+    }
+    else {
+        // Merge dependency graphs from project-local graphs
+        const graphTypes = ['project', 'codebase'];
+        const merged = {};
+        for (const g of graphTypes) {
+            const partial = loadGraphIndexFile(cwd, 'dependencies.json', g);
+            if (partial)
+                Object.assign(merged, partial);
+        }
+        if (Object.keys(merged).length > 0) {
+            depGraph = merged;
+        }
+        else {
+            // Legacy fallback
+            depGraph = loadDependencyGraph(cwd);
+            if (!depGraph) {
+                console.error('Error: No artifact index found.');
+                console.log("Run 'aiwg index build' first to create the index.");
+                process.exit(1);
+            }
+        }
+    }
+    if (!depGraph[artifactPath]) {
+        console.error(`Error: '${artifactPath}' not found in the dependency index.`);
+        console.log('Check the path or run `aiwg index build` to refresh.');
+        process.exit(1);
+    }
+    const showUpstream = direction === 'upstream' || direction === 'both';
+    const showDownstream = direction === 'downstream' || direction === 'both';
+    const upstreamResults = showUpstream
+        ? traverse(depGraph, artifactPath, 'upstream', depth, new Set([artifactPath]), 0, edgeType)
+        : [];
+    const downstreamResults = showDownstream
+        ? traverse(depGraph, artifactPath, 'downstream', depth, new Set([artifactPath]), 0, edgeType)
+        : [];
+    if (json) {
+        console.log(JSON.stringify({
+            artifact: artifactPath,
+            backend,
+            direction,
+            depth,
+            upstream: flattenResults(upstreamResults),
+            downstream: flattenResults(downstreamResults),
+            upstreamCount: flattenResults(upstreamResults).length,
+            downstreamCount: flattenResults(downstreamResults).length,
+        }, null, 2));
+    }
+    else {
+        console.log(`Dependencies for ${artifactPath}:`);
+        console.log('');
+        if (showUpstream) {
+            console.log('  UPSTREAM (this artifact depends on):');
+            if (upstreamResults.length === 0) {
+                console.log('    (none)');
+            }
+            else {
+                const tree = formatTree(upstreamResults, '    ');
+                process.stdout.write(tree);
+            }
+            console.log('');
+        }
+        if (showDownstream) {
+            console.log('  DOWNSTREAM (depends on this artifact):');
+            if (downstreamResults.length === 0) {
+                console.log('    (none)');
+            }
+            else {
+                const tree = formatTree(downstreamResults, '    ');
+                process.stdout.write(tree);
+            }
+            console.log('');
+        }
+        const upCount = flattenResults(upstreamResults).length;
+        const downCount = flattenResults(downstreamResults).length;
+        console.log(`  Upstream: ${upCount} | Downstream: ${downCount} | Total: ${upCount + downCount}`);
+    }
+}
+//# sourceMappingURL=dep-graph.js.map