@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/artifacts/corpus-tools/integrity-scan.js

@@ -0,0 +1,202 @@
+/**
+ * Corpus integrity / submission-risk scan (#1506). TS-native port of section9
+ * `scripts/corpus/llm_artifact_scan.py`.
+ *
+ * Conservative triage: flags artifacts carrying LLM residue, placeholder/
+ * template markers, unresolved citation markers, or non-final experiment
+ * language so they get human review before induction/scoring/synthesis. It
+ * does NOT decide misconduct. Reports by default; `--quarantine` writes a
+ * per-REF report under `.aiwg/research/quarantine/` (source files untouched).
+ *
+ * The regex catalog is externalized (epic #1496 principle #3): the built-in
+ * `DEFAULT_INTEGRITY_PATTERNS` is overridable per-corpus via
+ * `documentation/integrity-patterns.yaml`.
+ *
+ * @source historical: corpus/llm_artifact_scan.py
+ * @tests @test/unit/artifacts/integrity-scan.test.ts
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { load as loadYaml } from 'js-yaml';
+const TEXT_SUFFIXES = new Set(['.md', '.txt', '.tex', '.bib', '.yaml', '.yml', '.html', '.htm']);
+const SKIP_DIRS = new Set(['.git', '__pycache__', 'node_modules']);
+const DEFAULT_TARGET_DIRS = [
+    ['documentation', 'references'],
+    ['documentation', 'citations'],
+    ['documentation', 'radar'],
+];
+const PATTERNS_FILE = ['documentation', 'integrity-patterns.yaml'];
+/** Built-in pattern catalog. Ports the section9 PATTERNS list. */
+export const DEFAULT_INTEGRITY_PATTERNS = [
+    { category: 'llm-meta-comment', severity: 'critical', weight: 35, regex: "\\b(as an ai language model|i cannot|i can(?:not|'t) browse|here is a \\d+\\s+word summary)\\b", description: 'Visible assistant/system meta-comment' },
+    { category: 'llm-meta-comment', severity: 'critical', weight: 35, regex: '\\b(would you like me to|let me know if you want|i hope this helps|i have provided)\\b', description: 'Conversational assistant residue' },
+    { category: 'placeholder-data', severity: 'critical', weight: 40, regex: '\\b(fill (?:in|this) with (?:the )?real (?:numbers|data|results)|replace with actual|insert actual)\\b', description: 'Explicit instruction to replace fabricated or illustrative data' },
+    { category: 'placeholder-data', severity: 'high', weight: 25, regex: '\\b(placeholder|dummy data|sample data|illustrative only|synthetic example values?)\\b', description: 'Placeholder or illustrative data language' },
+    { category: 'template-residue', severity: 'high', weight: 25, regex: '(\\[to be filled\\]|\\[todo\\]|\\btodo:\\s*(add|fill|insert|replace)|tbd\\b|xxx)', description: 'Template residue or unfinished TODO marker' },
+    { category: 'citation-risk', severity: 'high', weight: 25, regex: '(\\[(citation|reference|source) needed\\]|\\b(citation needed|reference needed|source needed|add citation here)\\b)', description: 'Unresolved citation verification marker' },
+    { category: 'experiment-risk', severity: 'high', weight: 25, regex: '\\b(results? (?:are|is) (?:simulated|fabricated|mock|not final)|numbers? (?:are|is) (?:made up|illustrative))\\b', description: 'Experiment or table result is not final/real' },
+    { category: 'submission-risk', severity: 'low', weight: 5, regex: '\\b(position paper|survey paper|review article|literature review)\\b', description: 'Content type may need venue/peer-review check before submission' },
+    { category: 'ai-disclosure', severity: 'low', weight: 2, regex: '\\b(chatgpt|claude|gemini|copilot|large language model|llm-generated|ai-generated)\\b', description: 'AI/tooling disclosure or generated-content mention' },
+];
+/** Load the pattern catalog (corpus override → built-in default), compiled. */
+export function loadIntegrityPatterns(root) {
+    let patterns = DEFAULT_INTEGRITY_PATTERNS;
+    const file = path.join(root, ...PATTERNS_FILE);
+    if (fs.existsSync(file)) {
+        try {
+            const raw = loadYaml(fs.readFileSync(file, 'utf-8'));
+            if (Array.isArray(raw) && raw.length)
+                patterns = raw;
+        }
+        catch {
+            /* malformed override → fall back to defaults */
+        }
+    }
+    return patterns.map((p) => ({ ...p, re: new RegExp(p.regex, 'i') }));
+}
+const SEVERITY_RANK = { none: 0, low: 1, medium: 2, high: 3, critical: 4 };
+function refFromPath(p) {
+    const m = p.match(/REF-\d{3,}[a-z]?/);
+    return m ? m[0] : 'NO-REF';
+}
+function excerpt(line, limit = 220) {
+    const compact = line.trim().split(/\s+/).join(' ');
+    return compact.length <= limit ? compact : compact.slice(0, limit - 3) + '...';
+}
+function* iterFiles(targets) {
+    for (const target of targets) {
+        if (!fs.existsSync(target))
+            continue;
+        const stat = fs.statSync(target);
+        if (stat.isFile()) {
+            if (TEXT_SUFFIXES.has(path.extname(target).toLowerCase()))
+                yield target;
+            continue;
+        }
+        const stack = [target];
+        while (stack.length) {
+            const dir = stack.pop();
+            for (const entry of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+                if (entry.isDirectory()) {
+                    if (!SKIP_DIRS.has(entry.name))
+                        stack.push(path.join(dir, entry.name));
+                }
+                else if (TEXT_SUFFIXES.has(path.extname(entry.name).toLowerCase())) {
+                    yield path.join(dir, entry.name);
+                }
+            }
+        }
+    }
+}
+function scanFile(root, file, patterns) {
+    const findings = [];
+    const ref = refFromPath(file);
+    const rel = path.relative(root, file);
+    let lines;
+    try {
+        lines = fs.readFileSync(file, 'utf-8').split('\n');
+    }
+    catch (e) {
+        return [{ ref, path: rel, line: 0, category: 'read-error', severity: 'high', weight: 20, description: `Could not read file: ${String(e)}`, excerpt: '' }];
+    }
+    for (let i = 0; i < lines.length; i++) {
+        for (const p of patterns) {
+            if (p.re.test(lines[i])) {
+                findings.push({ ref, path: rel, line: i + 1, category: p.category, severity: p.severity, weight: p.weight, description: p.description, excerpt: excerpt(lines[i]) });
+            }
+        }
+    }
+    return findings;
+}
+function recommendation(score, highest) {
+    if (highest === 'critical')
+        return 'quarantine';
+    if (score >= 50 && SEVERITY_RANK[highest] >= SEVERITY_RANK.high)
+        return 'quarantine';
+    if (score >= 20 || SEVERITY_RANK[highest] >= SEVERITY_RANK.high)
+        return 'review';
+    return 'pass';
+}
+function scoreFindings(findings) {
+    const byRef = {};
+    for (const f of findings) {
+        const rec = (byRef[f.ref] ??= { ref: f.ref, score: 0, highestSeverity: 'none', findingCount: 0, categories: {}, recommendation: 'pass' });
+        rec.score += f.weight;
+        rec.findingCount += 1;
+        rec.categories[f.category] = (rec.categories[f.category] ?? 0) + 1;
+        if (SEVERITY_RANK[f.severity] > SEVERITY_RANK[rec.highestSeverity])
+            rec.highestSeverity = f.severity;
+    }
+    for (const rec of Object.values(byRef)) {
+        rec.score = Math.min(100, rec.score);
+        rec.recommendation = recommendation(rec.score, rec.highestSeverity);
+    }
+    return byRef;
+}
+export function scanCorpus(root, opts = {}) {
+    const patterns = loadIntegrityPatterns(root);
+    const targets = opts.targets && opts.targets.length
+        ? opts.targets.map((t) => (path.isAbsolute(t) ? t : path.join(root, t)))
+        : DEFAULT_TARGET_DIRS.map((parts) => path.join(root, ...parts));
+    const findings = [];
+    for (const file of iterFiles(targets)) {
+        if (opts.ref && !file.includes(opts.ref))
+            continue;
+        findings.push(...scanFile(root, file, patterns));
+    }
+    return { findings, summary: scoreFindings(findings) };
+}
+export function renderScan(result) {
+    const out = [];
+    out.push('LLM Artifact / Integrity Scan');
+    out.push(`Findings: ${result.findings.length}`);
+    const recs = Object.values(result.summary);
+    out.push(`REFs flagged: ${recs.length}`);
+    out.push('');
+    if (!recs.length) {
+        out.push('No suspect patterns found.');
+        return out.join('\n') + '\n';
+    }
+    out.push(`${'REF'.padEnd(12)} ${'score'.padEnd(6)} ${'severity'.padEnd(10)} ${'rec'.padEnd(11)} findings  categories`);
+    for (const rec of recs.sort((a, b) => b.score - a.score || a.ref.localeCompare(b.ref))) {
+        const cats = Object.entries(rec.categories).sort().map(([k, v]) => `${k}=${v}`).join(', ');
+        out.push(`${rec.ref.padEnd(12)} ${String(rec.score).padEnd(6)} ${rec.highestSeverity.padEnd(10)} ${rec.recommendation.padEnd(11)} ${String(rec.findingCount).padEnd(8)} ${cats}`);
+    }
+    return out.join('\n') + '\n';
+}
+/** Write per-REF quarantine reports for `quarantine`-recommended REFs. Returns relative paths written. */
+export function writeQuarantineReports(root, result) {
+    const dir = path.join(root, '.aiwg', 'research', 'quarantine');
+    const byRef = {};
+    for (const f of result.findings)
+        (byRef[f.ref] ??= []).push(f);
+    const written = [];
+    for (const rec of Object.values(result.summary).sort((a, b) => a.ref.localeCompare(b.ref))) {
+        if (rec.recommendation !== 'quarantine')
+            continue;
+        fs.mkdirSync(dir, { recursive: true });
+        const lines = [
+            '---', `ref: ${rec.ref}`, 'type: llm-artifact-scan', `score: ${rec.score}`,
+            `highest-severity: ${rec.highestSeverity}`, `recommendation: ${rec.recommendation}`, '---', '',
+            `# ${rec.ref} LLM Artifact Scan`, '',
+            'Triage artifact (possible LLM residue / placeholders / submission risk) — not a misconduct determination.', '',
+            '## Summary', '',
+            `- Score: ${rec.score}/100`, `- Highest severity: ${rec.highestSeverity}`,
+            `- Findings: ${rec.findingCount}`, `- Recommendation: ${rec.recommendation}`, '',
+            '## Findings', '', '| Severity | Category | File | Line | Excerpt |', '|---|---|---|---:|---|',
+        ];
+        for (const f of byRef[rec.ref] ?? []) {
+            lines.push(`| ${f.severity} | ${f.category} | ${f.path} | ${f.line} | ${f.excerpt.replace(/\|/g, '\\|')} |`);
+        }
+        lines.push('', '## Required Triage', '', '- Confirm each finding is source-authored text, OCR noise, or generated-note residue.', '- Source-authored residue → downgrade trust/grade until externally verified.', '- Generated-note residue → fix the note and rerun the scan.', '- Do not use this REF in synthesis until the quarantine recommendation clears.');
+        const file = path.join(dir, `${rec.ref}-llm-artifact-scan.md`);
+        fs.writeFileSync(file, lines.join('\n') + '\n');
+        written.push(path.relative(root, file));
+    }
+    return written;
+}
+/** True if any REF reaches the fail threshold (quarantine, or review+quarantine when threshold=review). */
+export function failsThreshold(result, threshold) {
+    return Object.values(result.summary).some((r) => r.recommendation === threshold || (threshold === 'review' && r.recommendation === 'quarantine'));
+}
+//# sourceMappingURL=integrity-scan.js.map

package/dist/src/artifacts/corpus-tools/profile-communities.js

@@ -0,0 +1,166 @@
+/**
+ * profile-communities — co-author community detection (#1501).
+ *
+ * Label-propagation communities (deterministic variant: sorted node order,
+ * lexicographic tie-break — no python-louvain dependency, the graceful fallback
+ * the issue calls for) + modularity Q + bridge-node detection (high betweenness).
+ *
+ * @source historical: profiles/community_detection.py
+ */
+import { loadCorpus } from '../corpus-views/ref-parser.js';
+import { buildCoauthorGraph, betweenness } from './corpus-graph.js';
+/** Deterministic label propagation: each node adopts the highest-weight neighbour label. */
+function labelPropagation(g, maxIter = 100) {
+    const nodes = [...g.keys()].sort();
+    const labels = new Map(nodes.map((n) => [n, n]));
+    for (let iter = 0; iter < maxIter; iter++) {
+        let changed = false;
+        for (const v of nodes) {
+            const nbrs = g.get(v);
+            if (nbrs.size === 0)
+                continue;
+            const weight = new Map();
+            for (const [w, ew] of nbrs) {
+                const lab = labels.get(w);
+                weight.set(lab, (weight.get(lab) ?? 0) + ew);
+            }
+            // Highest weight; tie-break to the lexicographically smallest label.
+            let best = labels.get(v);
+            let bestW = -1;
+            for (const [lab, wgt] of [...weight.entries()].sort((a, b) => (a[0] < b[0] ? -1 : 1))) {
+                if (wgt > bestW) {
+                    bestW = wgt;
+                    best = lab;
+                }
+            }
+            if (best !== labels.get(v)) {
+                labels.set(v, best);
+                changed = true;
+            }
+        }
+        if (!changed)
+            break;
+    }
+    return labels;
+}
+/** Newman modularity Q for a labelled undirected weighted graph. */
+function modularity(g, labels) {
+    const deg = new Map();
+    let twoM = 0;
+    for (const [v, nbrs] of g) {
+        let d = 0;
+        for (const w of nbrs.values())
+            d += w;
+        deg.set(v, d);
+        twoM += d;
+    }
+    if (twoM === 0)
+        return 0;
+    const nodes = [...g.keys()];
+    let q = 0;
+    for (const i of nodes) {
+        const nbrs = g.get(i);
+        for (const j of nodes) {
+            if (labels.get(i) !== labels.get(j))
+                continue;
+            const a = nbrs.get(j) ?? 0;
+            q += a - (deg.get(i) * deg.get(j)) / twoM;
+        }
+    }
+    return Math.round((q / twoM) * 1e4) / 1e4;
+}
+/** Detect co-author communities + modularity + bridge nodes. */
+export function detectCommunities(corpusRoot, minModularity = 0.3) {
+    const { records } = loadCorpus(corpusRoot);
+    const g = buildCoauthorGraph(records);
+    const labels = labelPropagation(g);
+    const byLabel = new Map();
+    for (const [node, lab] of labels)
+        (byLabel.get(lab) ?? byLabel.set(lab, []).get(lab)).push(node);
+    const communities = [...byLabel.entries()]
+        .map(([label, members]) => ({ label, members: members.sort() }))
+        .sort((a, b) => b.members.length - a.members.length);
+    const q = modularity(g, labels);
+    // Bridge nodes: top betweenness (span communities).
+    const bc = betweenness(g);
+    const bridges = [...bc.entries()]
+        .filter(([, v]) => v > 0)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([node, v]) => ({ node, betweenness: Math.round(v * 1e6) / 1e6 }));
+    const result = { communities, modularity: q, bridges };
+    if (q < minModularity)
+        result.warning = `modularity ${q} < ${minModularity} — weak community structure (sparse co-author graph)`;
+    return result;
+}
+/** Render communities + modularity + bridges as markdown. */
+export function renderCommunities(r) {
+    const lines = [
+        '# Co-author communities',
+        '',
+        `${r.communities.length} communities · modularity Q = ${r.modularity}`,
+        ...(r.warning ? ['', `> ⚠ ${r.warning}`] : []),
+        '',
+        '| Community | Size | Members (top 8) |',
+        '|---|---:|---|',
+    ];
+    let i = 1;
+    for (const c of r.communities) {
+        if (c.members.length < 2)
+            continue; // skip singletons in the table
+        lines.push(`| C${i++} | ${c.members.length} | ${c.members.slice(0, 8).join(', ')}${c.members.length > 8 ? ' …' : ''} |`);
+    }
+    lines.push('', '## Bridge authors (top betweenness)', '', '| Author | Betweenness |', '|---|---:|');
+    for (const b of r.bridges)
+        lines.push(`| ${b.node} | ${b.betweenness} |`);
+    return lines.join('\n') + '\n';
+}
+/** Group Fortemi v2 records by extracted SKOS concept id/prefLabel (#1720). */
+export function detectSkosCommunities(exported) {
+    const labels = new Map();
+    const membersByConcept = new Map();
+    let recordsWithConcepts = 0;
+    for (const item of exported.items) {
+        const concepts = item.skos_concepts ?? [];
+        if (concepts.length > 0)
+            recordsWithConcepts++;
+        const member = item.title || item.name || item.source.path;
+        for (const concept of concepts) {
+            labels.set(concept.id, concept.prefLabel);
+            if (!membersByConcept.has(concept.id))
+                membersByConcept.set(concept.id, new Set());
+            membersByConcept.get(concept.id).add(member);
+        }
+    }
+    const communities = [...membersByConcept.entries()]
+        .map(([id, members]) => ({
+        label: labels.get(id) ?? id,
+        members: [...members].sort(),
+    }))
+        .sort((a, b) => b.members.length - a.members.length || a.label.localeCompare(b.label));
+    return {
+        communities,
+        coverage: {
+            recordsWithConcepts,
+            totalRecords: exported.items.length,
+            ratio: exported.items.length === 0
+                ? 1
+                : Math.round((recordsWithConcepts / exported.items.length) * 10000) / 10000,
+        },
+    };
+}
+export function renderSkosCommunities(r) {
+    const lines = [
+        '# SKOS concept communities',
+        '',
+        `${r.communities.length} concepts · SKOS coverage ${r.coverage.recordsWithConcepts}/${r.coverage.totalRecords} (${r.coverage.ratio})`,
+        '',
+        '| Concept | Size | Records (top 8) |',
+        '|---|---:|---|',
+    ];
+    for (const c of r.communities) {
+        lines.push(`| ${c.label} | ${c.members.length} | ${c.members.slice(0, 8).join(', ')}${c.members.length > 8 ? ' …' : ''} |`);
+    }
+    return lines.join('\n') + '\n';
+}
+//# sourceMappingURL=profile-communities.js.map

package/dist/src/artifacts/corpus-tools/profile-edges.js

@@ -0,0 +1,72 @@
+/**
+ * Profile→REF edges as first-class graph data (#1501, reassigned from #1502).
+ *
+ * TS-native port of section9 `scripts/profiles/build_profile_edges.py`. Builds
+ * the entity-profile → reference edge graph from `loadProfiles` (PROF-{P,O,G,F,S}
+ * `corpus-refs`), reconciled against the citation graph so only edges to REFs
+ * that actually exist in the corpus are kept (the source script emitted synthetic
+ * `documentation/profiles/edges/` files; per the issue these are first-class
+ * graph adjacency objects instead, reconcilable with the #727 graph backends).
+ *
+ * @source historical: profiles/build_profile_edges.py
+ * @tests @test/unit/artifacts/profile-edges.test.ts
+ */
+import { loadProfiles, loadCorpus } from '../corpus-views/ref-parser.js';
+/** Build the profile→REF edge graph, keeping only edges to REFs present in the corpus. */
+export function buildProfileEdges(corpusRoot) {
+    const profiles = loadProfiles(corpusRoot);
+    const knownRefs = new Set(loadCorpus(corpusRoot).records.map((r) => r.refId));
+    const edges = [];
+    const byProfile = new Map();
+    const byRef = new Map();
+    const danglingRefs = [];
+    for (const p of profiles) {
+        const type = p.type ?? 'unknown';
+        const refs = [];
+        for (const ref of p.corpusRefs) {
+            if (!knownRefs.has(ref)) {
+                danglingRefs.push({ profId: p.profId, ref });
+                continue;
+            }
+            edges.push({ profId: p.profId, profileType: type, ref });
+            refs.push(ref);
+            (byRef.get(ref) ?? byRef.set(ref, []).get(ref)).push(p.profId);
+        }
+        byProfile.set(p.profId, { name: p.name, type, refs });
+    }
+    return {
+        edges,
+        byProfile,
+        byRef,
+        danglingRefs,
+        stats: { profiles: profiles.length, edges: edges.length, refsCovered: byRef.size },
+    };
+}
+export function renderProfileEdges(g) {
+    const out = [];
+    out.push('Profile→REF edge graph');
+    out.push(`Profiles: ${g.stats.profiles}  Edges: ${g.stats.edges}  REFs covered: ${g.stats.refsCovered}  Dangling: ${g.danglingRefs.length}`);
+    out.push('');
+    // Top profiles by edge count.
+    const topProfiles = [...g.byProfile.entries()].sort((a, b) => b[1].refs.length - a[1].refs.length).slice(0, 15);
+    out.push('Top profiles by linked REFs:');
+    for (const [profId, info] of topProfiles) {
+        if (!info.refs.length)
+            continue;
+        out.push(`  ${profId} (${info.type})${info.name ? ` — ${info.name}` : ''}: ${info.refs.length}`);
+    }
+    out.push('');
+    // Top REFs by profile in-degree.
+    const topRefs = [...g.byRef.entries()].sort((a, b) => b[1].length - a[1].length).slice(0, 15);
+    out.push('Top REFs by linked-profile count:');
+    for (const [ref, profs] of topRefs)
+        out.push(`  ${ref}: ${profs.length} profiles`);
+    if (g.danglingRefs.length) {
+        out.push('');
+        out.push(`Dangling profile→REF edges (REF doc missing): ${g.danglingRefs.length}`);
+        for (const d of g.danglingRefs.slice(0, 10))
+            out.push(`  ${d.profId} → ${d.ref}`);
+    }
+    return out.join('\n') + '\n';
+}
+//# sourceMappingURL=profile-edges.js.map

package/dist/src/artifacts/corpus-tools/profile-embed.js

@@ -0,0 +1,113 @@
+/**
+ * Profile text embeddings → researcher similarity + collaboration prediction (#1501).
+ *
+ * The #1501 "node2vec embeddings" slot, implemented (per operator decision) by
+ * reusing the text-embedding backend (#1493) instead of a heavy graph-embedding
+ * stack: each person profile is embedded from its name + the titles of its
+ * corpus-refs, then cosine similarity gives nearest researchers and
+ * collaboration link-prediction (highly-similar people who have NOT co-authored —
+ * corpus-refs overlap is the co-authorship proxy).
+ *
+ * Opt-in: requires `@xenova/transformers` (and `hnswlib-node` is not needed here —
+ * similarity is an in-memory cosine over the ~hundreds of person profiles).
+ * Degrades gracefully when the optional dep is absent.
+ *
+ * @source historical: profiles/graph_embeddings.py (node2vec → text-embedding here)
+ * @tests @test/unit/artifacts/profile-embed.test.ts
+ */
+import { loadProfiles, loadCorpus } from '../corpus-views/ref-parser.js';
+import { checkEmbeddingDeps, DEFAULT_EMBEDDING_MODEL } from '../embedding-index.js';
+function cosine(a, b) {
+    let dot = 0;
+    // Vectors are L2-normalized at embed time (normalize: true), so dot == cosine.
+    for (let i = 0; i < a.length; i++)
+        dot += a[i] * b[i];
+    return dot;
+}
+/**
+ * Build text embeddings for person profiles. Text = profile name + the titles of
+ * its corpus-refs. Requires `@xenova/transformers`; throws a clear error when absent.
+ */
+export async function buildProfileEmbeddings(corpusRoot, model = DEFAULT_EMBEDDING_MODEL) {
+    const deps = await checkEmbeddingDeps();
+    if (!deps.available) {
+        throw new Error(`profile embeddings need optional deps: ${deps.missing.join(', ')} (npm install @xenova/transformers)`);
+    }
+    const titleByRef = new Map();
+    for (const r of loadCorpus(corpusRoot).records)
+        titleByRef.set(r.refId, r.title);
+    const people = loadProfiles(corpusRoot).filter((p) => (p.type ?? '') === 'person');
+    const profIds = [];
+    const names = [];
+    const texts = [];
+    const refs = [];
+    for (const p of people) {
+        const titles = p.corpusRefs.map((r) => titleByRef.get(r)).filter(Boolean);
+        // Skip profiles with no usable text signal.
+        const text = `${p.name ?? p.profId}. ${titles.join('. ')}`.trim();
+        if (!titles.length && !p.name)
+            continue;
+        profIds.push(p.profId);
+        names.push(p.name);
+        texts.push(text);
+        refs.push(new Set(p.corpusRefs));
+    }
+    const transformersMod = await (new Function('m', 'return import(m)'))('@xenova/transformers');
+    const embed = await transformersMod.pipeline('feature-extraction', model);
+    const vectors = [];
+    for (const t of texts) {
+        const res = await embed(t, { pooling: 'mean', normalize: true });
+        vectors.push(Array.from(res.data));
+    }
+    return { profIds, names, vectors, refs };
+}
+/** Nearest researchers to a profile by embedding cosine (excludes self). */
+export function profileSimilar(emb, profId, topK = 10) {
+    const i = emb.profIds.indexOf(profId);
+    if (i === -1)
+        throw new Error(`profile '${profId}' not in the embedding set`);
+    const hits = [];
+    for (let j = 0; j < emb.profIds.length; j++) {
+        if (j === i)
+            continue;
+        hits.push({ profId: emb.profIds[j], name: emb.names[j], score: cosine(emb.vectors[i], emb.vectors[j]) });
+    }
+    return hits.sort((a, b) => b.score - a.score).slice(0, topK);
+}
+/**
+ * Collaboration link-prediction: pairs of people with embedding similarity ≥
+ * threshold who share NO corpus-refs (i.e. have not co-authored). Ranked desc.
+ */
+export function collaborationPredictions(emb, threshold = 0.8, limit = 50) {
+    const preds = [];
+    for (let i = 0; i < emb.profIds.length; i++) {
+        for (let j = i + 1; j < emb.profIds.length; j++) {
+            // Already co-authored if their corpus-refs intersect.
+            let shared = false;
+            for (const r of emb.refs[i])
+                if (emb.refs[j].has(r)) {
+                    shared = true;
+                    break;
+                }
+            if (shared)
+                continue;
+            const score = cosine(emb.vectors[i], emb.vectors[j]);
+            if (score >= threshold)
+                preds.push({ a: emb.profIds[i], b: emb.profIds[j], score });
+        }
+    }
+    return preds.sort((x, y) => y.score - x.score).slice(0, limit);
+}
+export function renderSimilar(profId, hits) {
+    const out = [`Researchers similar to ${profId} (${hits.length}):`, ''];
+    for (const h of hits)
+        out.push(`  ${h.score.toFixed(3)}  ${h.profId}${h.name ? ` — ${h.name}` : ''}`);
+    return out.join('\n') + '\n';
+}
+export function renderCollabPredictions(preds, threshold) {
+    const out = [`Collaboration predictions (cosine ≥ ${threshold}, not yet co-authored): ${preds.length}`, ''];
+    for (const p of preds)
+        out.push(`  ${p.score.toFixed(3)}  ${p.a} ↔ ${p.b}`);
+    return out.join('\n') + '\n';
+}
+//# sourceMappingURL=profile-embed.js.map