@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/artifacts/corpus-tools/profile-generate-fm.js

@@ -0,0 +1,167 @@
+/**
+ * profile-generate-fm — PROF-P (FM authors) + PROF-G (group) profiles (#1502).
+ *
+ * Port of profiles/build_fm_profiles.py. The hardcoded FM_PAPERS + group_specs
+ * dicts are NOT ported — they are corpus-specific data and live in a
+ * corpus-local `documentation/profiles/fm-config.yaml` (absent → no-op). Reuses
+ * the shared generation context + PROF-P body builder from profile-generate.
+ *
+ * @source historical: profiles/build_fm_profiles.py
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { load as loadYaml } from 'js-yaml';
+import { loadGenContext, buildProfileBody, slugifyAuthor } from './profile-generate.js';
+/** Institutional markers excluded from FM PROF-P generation (build_fm_profiles). */
+const FM_INST_KEYWORDS = [' team', 'ai @', 'deepseek-ai', 'anthropic', 'openai', 'et al.'];
+/**
+ * Load `documentation/profiles/fm-config.yaml` (absent → empty). Shape:
+ *   fm-papers:
+ *     REF-052: { model: "GPT-3", top-authors: 5 }
+ *     REF-835: { model: "Llama 3", group: PROF-G-llama-team }
+ *   groups:
+ *     PROF-G-llama-team:
+ *       name: "Llama Team — AI @ Meta"
+ *       parent-org: "Meta AI Research"
+ *       parent-slug: PROF-O-meta-fair
+ *       refs: [REF-835]
+ */
+export function loadFmConfig(corpusRoot) {
+    const file = path.join(corpusRoot, 'documentation', 'profiles', 'fm-config.yaml');
+    let raw;
+    try {
+        raw = loadYaml(fs.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return { fmPapers: new Map(), groups: [] };
+    }
+    const obj = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+    const fmPapers = new Map();
+    const papers = obj['fm-papers'];
+    if (papers && typeof papers === 'object' && !Array.isArray(papers)) {
+        for (const [ref, v] of Object.entries(papers)) {
+            const e = (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+            fmPapers.set(ref, {
+                model: String(e.model ?? ref),
+                topAuthors: typeof e['top-authors'] === 'number' ? e['top-authors'] : 0,
+                group: e.group ? String(e.group) : undefined,
+            });
+        }
+    }
+    const groups = [];
+    const grp = obj['groups'];
+    if (grp && typeof grp === 'object' && !Array.isArray(grp)) {
+        for (const [slug, v] of Object.entries(grp)) {
+            const e = (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+            groups.push({
+                slug,
+                name: String(e.name ?? slug),
+                parentOrg: String(e['parent-org'] ?? ''),
+                parentSlug: e['parent-slug'] ? String(e['parent-slug']) : undefined,
+                refs: Array.isArray(e.refs) ? e.refs.map((r) => String(r)) : [],
+            });
+        }
+    }
+    return { fmPapers, groups };
+}
+function shortTitle(t, n = 60) {
+    const s = (t ?? '').replace(/"/g, '').trim();
+    return s.length > n ? s.slice(0, n) + '...' : s;
+}
+/** Build a PROF-G group profile body. Mirrors build_fm_profiles' group block. */
+function buildGroupBody(g, byId, today) {
+    const nextDue = new Date(new Date(`${today}T00:00:00Z`).getTime() + 180 * 86_400_000).toISOString().slice(0, 10);
+    const yamlRefs = '[' + g.refs.map((r) => `'${r}'`).join(', ') + ']';
+    const lines = [
+        '---',
+        `prof-id: ${g.slug}`,
+        `name: "${g.name}"`,
+        'type: group',
+        `parent-org: ${g.parentSlug ?? '(no PROF-O entry)'}`,
+        `aliases: ["${g.name}"]`,
+        `corpus-refs: ${yamlRefs}`,
+        'refresh-cadence: semi-annual',
+        `last-refreshed: ${today}`,
+        'last-refreshed-by: profile-generate-scaffold',
+        'grade-influence: A',
+        'grade-trajectory: rising',
+        'sources-searched: [corpus-citation-sidecars]',
+        '---',
+        '',
+        `# ${g.name} — Entity Profile`,
+        '',
+        '**Type**: Group (foundation-model release team)',
+        `**Profile ID**: \`${g.slug}\``,
+        `**Parent organization**: ${g.parentOrg}`,
+        `**Last refreshed**: ${today}`,
+        `**Next refresh due**: ${nextDue}`,
+        '',
+        '---',
+        '',
+        '## 1. Entity Summary',
+        '',
+        `The ${g.name} is the institutional collective publishing foundation-model release papers under collective authorship rather than under named individuals — typical of large open-weight launches where the contributor list is too large for first-author attribution.`,
+        '',
+        '**Research Identity**: Foundation-model release team.',
+        `**Parent**: ${g.parentOrg}.`,
+        '',
+        '---',
+        '',
+        '## 2. Corpus Presence',
+        '',
+        '| REF | Title | Year |',
+        '|---|---|---|',
+    ];
+    for (const r of g.refs) {
+        const rec = byId.get(r);
+        lines.push(`| [${r}](../../references/) | ${shortTitle(rec?.title)} | ${rec?.year ?? '—'} |`);
+    }
+    lines.push('', `**Total corpus appearances**: ${g.refs.length}`, '', '---', '', '## 3. Notes', '', '- Group profile for a foundation-model release team. Individual contributors are profiled where corpus presence supports it.', '- Generated by `aiwg corpus profile-generate --fm` from `documentation/profiles/fm-config.yaml`.', '');
+    return lines.join('\n');
+}
+/** Generate FM-author PROF-P + group PROF-G profiles from fm-config.yaml. */
+export function generateFmProfiles(corpusRoot, opts = {}) {
+    const today = opts.today || new Date().toISOString().slice(0, 10);
+    const cfg = loadFmConfig(corpusRoot);
+    const ctx = loadGenContext(corpusRoot);
+    const results = [];
+    const seen = new Set();
+    // PROF-P for unprofiled top-N authors of each FM paper.
+    for (const [ref, paper] of cfg.fmPapers) {
+        if (paper.topAuthors <= 0)
+            continue;
+        const authors = ctx.byId.get(ref)?.authors ?? [];
+        for (const a of authors.slice(0, paper.topAuthors)) {
+            if (FM_INST_KEYWORDS.some((kw) => a.toLowerCase().includes(kw)))
+                continue;
+            const slug = slugifyAuthor(a);
+            if (ctx.existing.has(slug) || seen.has(slug))
+                continue;
+            seen.add(slug);
+            const refs = [...(ctx.authorRefs.get(a) ?? [])].sort();
+            const outRel = path.join('documentation', 'profiles', 'people', `PROF-P-${slug}.md`);
+            const content = buildProfileBody(a, slug, refs, ctx.byId, ctx.inDeg, today);
+            results.push(emitProfile(corpusRoot, outRel, content, `${a} (top author of ${paper.model})`, opts.write));
+        }
+    }
+    // PROF-G for institutional/team authorship.
+    for (const g of cfg.groups) {
+        const outRel = path.join('documentation', 'profiles', 'groups', `${g.slug}.md`);
+        const content = buildGroupBody(g, ctx.byId, today);
+        results.push(emitProfile(corpusRoot, outRel, content, g.name, opts.write));
+    }
+    return results;
+}
+/** Write/skip/dry-run a profile; result `slug` is the full prof-id (PROF-P-… / PROF-G-…) from the path. */
+function emitProfile(corpusRoot, outRel, content, name, write) {
+    const id = path.basename(outRel).replace(/\.md$/, '');
+    const outAbs = path.join(corpusRoot, outRel);
+    if (!write)
+        return { slug: id, name, status: 'dry-run', message: `DRY-RUN ${id}: ${name}`, outPath: outRel, content };
+    if (fs.existsSync(outAbs))
+        return { slug: id, name, status: 'skip', message: `SKIP ${id} (exists)`, outPath: outRel };
+    fs.mkdirSync(path.dirname(outAbs), { recursive: true });
+    fs.writeFileSync(outAbs, content, 'utf-8');
+    return { slug: id, name, status: 'wrote', message: `WROTE ${id}: ${name}`, outPath: outRel, content };
+}
+//# sourceMappingURL=profile-generate-fm.js.map

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

@@ -0,0 +1,181 @@
+/**
+ * profile-generate — scaffold compact PROF-P profiles for unprofiled hub authors (#1502).
+ *
+ * Port of profiles/build_tier1_profiles.py: ranks REFs by corpus in-degree
+ * (derived from citation outgoing-edges), takes each top REF's primary author,
+ * skips institutional/group "authors" and already-profiled people, and stamps a
+ * compact 5-section PROF-P sidecar. Reuses the #1497 parser (loadCorpus gives
+ * authors + edges + titles; loadProfileSlugs gives existing profiles) rather
+ * than re-parsing citation sidecars. Dry-run unless `write`; skips existing.
+ *
+ * `corpus-refs` is written as a list of REF-id strings (matching the corpus
+ * convention + build_tier1); the #1497 parser tolerates both that and the
+ * list-of-dicts shape.
+ *
+ * @source historical: profiles/build_tier1_profiles.py
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { loadCorpus, loadProfileSlugs } from '../corpus-views/ref-parser.js';
+/** Institutional / group "author" markers — these get group profiles, not PROF-P. */
+const INST_KEYWORDS = ['team', 'labs', 'contributors', 'foundation', 'consortium', 'committee', 'anthropic alignment', 'stanford hai'];
+/** Port of build_tier1_profiles.slugify: "Last, First" / "First Last" → "last-first". */
+export function slugifyAuthor(name) {
+    let last;
+    let first;
+    if (name.includes(',')) {
+        const [l, f] = name.split(',', 2).map((s) => s.trim());
+        last = l ?? '';
+        first = f ?? '';
+    }
+    else {
+        const parts = name.trim().split(/\s+/);
+        first = parts[0] ?? '';
+        last = parts[parts.length - 1] ?? '';
+    }
+    const firstWord = first.split(/\s+/)[0] ?? '';
+    const slug = `${last}-${firstWord}`.toLowerCase().replace(/ /g, '-').replace(/\./g, '').replace(/'/g, '');
+    return slug.replace(/-+/g, '-');
+}
+function shortTitle(t, n = 70) {
+    const s = (t ?? '').replace(/"/g, '').trim();
+    return s.length > n ? s.slice(0, n) + '...' : s;
+}
+/** Compute corpus in-degree per REF from citation outgoing-edges (within corpus). */
+function inDegrees(records, byId) {
+    const inDeg = new Map();
+    for (const r of records) {
+        for (const t of r.outgoing) {
+            if (byId.has(t))
+                inDeg.set(t, (inDeg.get(t) ?? 0) + 1);
+        }
+    }
+    return inDeg;
+}
+/** Build the generation context once from the corpus (loadCorpus + in-degree + author index). */
+export function loadGenContext(corpusRoot) {
+    const { records } = loadCorpus(corpusRoot);
+    const byId = new Map(records.map((r) => [r.refId, r]));
+    const inDeg = inDegrees(records, byId);
+    const existing = loadProfileSlugs(corpusRoot);
+    const authorRefs = new Map();
+    for (const r of records)
+        for (const a of r.authors)
+            (authorRefs.get(a) ?? authorRefs.set(a, new Set()).get(a)).add(r.refId);
+    return { records, byId, inDeg, authorRefs, existing };
+}
+/** Build the compact 5-section PROF-P markdown body. Mirrors generate_profile(). */
+export function buildProfileBody(name, slug, refs, byId, inDeg, today) {
+    const refsData = refs
+        .map((r) => ({ ref: r, title: shortTitle(byId.get(r)?.title), year: byId.get(r)?.year != null ? String(byId.get(r).year) : '—', deg: inDeg.get(r) ?? 0 }))
+        .sort((a, b) => b.deg - a.deg);
+    const topRef = refsData[0] ?? { ref: '—', deg: 0, year: '—', title: '' };
+    // Co-author counts across this author's refs.
+    const coCount = new Map();
+    const coRefs = new Map();
+    for (const r of refs) {
+        for (const ca of byId.get(r)?.authors ?? []) {
+            if (ca === name)
+                continue;
+            coCount.set(ca, (coCount.get(ca) ?? 0) + 1);
+            (coRefs.get(ca) ?? coRefs.set(ca, []).get(ca)).push(r);
+        }
+    }
+    const topCo = [...coCount.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+    const yamlRefs = '[' + refs.map((r) => `'${r}'`).join(', ') + ']';
+    const nextDue = new Date(new Date(`${today}T00:00:00Z`).getTime() + 180 * 86_400_000).toISOString().slice(0, 10);
+    const summary = `${name} is the primary author of ${topRef.ref} (corpus in-degree ${topRef.deg}), ` +
+        `one of the top hubs in the corpus citation network. ${refs.length} corpus paper${refs.length !== 1 ? 's' : ''}.`;
+    const lines = [
+        '---',
+        `prof-id: PROF-P-${slug}`,
+        `name: "${name}"`,
+        'type: person',
+        'affiliation: ""',
+        `aliases: ["${name}"]`,
+        `corpus-refs: ${yamlRefs}`,
+        'refresh-cadence: semi-annual',
+        `last-refreshed: ${today}`,
+        'last-refreshed-by: profile-generate-scaffold',
+        'grade-influence: A',
+        'grade-trajectory: stable',
+        'sources-searched: [corpus-citation-sidecars]',
+        '---',
+        '',
+        `# ${name} — Entity Profile`,
+        '',
+        '**Type**: Person',
+        `**Profile ID**: \`PROF-P-${slug}\``,
+        `**Last refreshed**: ${today}`,
+        `**Next refresh due**: ${nextDue}`,
+        '',
+        '---',
+        '',
+        '## 1. Entity Summary',
+        '',
+        summary,
+        '',
+        '**Research Identity**: Foundational corpus author.',
+        `**Top hub authored**: [${topRef.ref}](../../references/) (in-degree ${topRef.deg})`,
+        `**Active in corpus since**: ${refsData[refsData.length - 1]?.year ?? '—'}`,
+        '',
+        '---',
+        '',
+        '## 2. Corpus Presence',
+        '',
+        '| REF | Title | Year | In-degree |',
+        '|---|---|---|---:|',
+    ];
+    for (const rd of refsData)
+        lines.push(`| [${rd.ref}](../../references/) | ${rd.title} | ${rd.year} | ${rd.deg} |`);
+    lines.push('', `**Total corpus appearances**: ${refs.length}`, `**Most-cited corpus paper**: ${topRef.ref} (in-degree ${topRef.deg})`, '', '---', '', '## 3. Research Focus Profile', '', 'Derived mechanically from corpus paper titles. Manual topic-classification deferred to next refresh.', '', '---', '', '## 4. Co-Author Network (Top 10)', '', '| Co-Author | Joint Papers | REFs |', '|---|---|---|');
+    if (topCo.length) {
+        for (const [ca, count] of topCo)
+            lines.push(`| ${ca} | ${count} | ${(coRefs.get(ca) ?? []).join(', ')} |`);
+    }
+    else {
+        lines.push('| (single-author papers — no co-authors recorded) | — | — |');
+    }
+    lines.push('', `_Derived mechanically from ${refs.length} corpus citation sidecar(s) on ${today}.${coCount.size ? ` Top 10 of ${coCount.size} unique collaborators.` : ''}_`, '', '---', '', '## 5. Notes', '', '- Profile generated by `aiwg corpus profile-generate` (Tier-1 hub-primary-author pass).', '- Mechanical extraction from citation-sidecar frontmatter. Affiliation intentionally blank — populate after consulting the listed REFs.', '- Refresh recommended after the next major induction wave touches this researcher.', '');
+    return lines.join('\n');
+}
+/** Generate Tier-1 PROF-P profiles for unprofiled hub primary authors. */
+export function generateTier1Profiles(corpusRoot, opts = {}) {
+    const today = opts.today || new Date().toISOString().slice(0, 10);
+    const limit = opts.limit ?? 25;
+    const scan = opts.scan ?? 60;
+    const ctx = loadGenContext(corpusRoot);
+    const ranked = [...ctx.inDeg.entries()].sort((a, b) => b[1] - a[1]).slice(0, scan);
+    const results = [];
+    const seen = new Set();
+    for (const [refId] of ranked) {
+        if (results.length >= limit)
+            break;
+        const primary = ctx.byId.get(refId)?.authors[0];
+        if (!primary)
+            continue;
+        if (INST_KEYWORDS.some((kw) => primary.toLowerCase().includes(kw)))
+            continue;
+        const slug = slugifyAuthor(primary);
+        if (ctx.existing.has(slug) || seen.has(slug))
+            continue;
+        seen.add(slug);
+        const refs = [...(ctx.authorRefs.get(primary) ?? [])].sort();
+        const outRel = path.join('documentation', 'profiles', 'people', `PROF-P-${slug}.md`);
+        const content = buildProfileBody(primary, slug, refs, ctx.byId, ctx.inDeg, today);
+        const outAbs = path.join(corpusRoot, outRel);
+        if (!opts.write) {
+            results.push({ slug, name: primary, status: 'dry-run', message: `DRY-RUN PROF-P-${slug}: ${primary} (${refs.length} refs)`, outPath: outRel, content });
+            continue;
+        }
+        if (fs.existsSync(outAbs)) {
+            results.push({ slug, name: primary, status: 'skip', message: `SKIP PROF-P-${slug} (exists)`, outPath: outRel });
+            continue;
+        }
+        fs.mkdirSync(path.dirname(outAbs), { recursive: true });
+        fs.writeFileSync(outAbs, content, 'utf-8');
+        results.push({ slug, name: primary, status: 'wrote', message: `WROTE PROF-P-${slug}: ${primary} (${refs.length} refs)`, outPath: outRel, content });
+    }
+    return results;
+}
+//# sourceMappingURL=profile-generate.js.map

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

@@ -0,0 +1,98 @@
+/**
+ * profile-metrics — corpus-local influence/centrality metrics (#1501).
+ *
+ * Port of profiles/compute_metrics.py: per-paper CD-index + PageRank, and
+ * per-PROF-P h-index / mean-CD / mean-PageRank + co-author centrality
+ * (betweenness/eigenvector/clustering) + influence grade. Reuses corpus-graph
+ * algorithms and the #1497 parser.
+ *
+ * @source historical: profiles/compute_metrics.py
+ */
+import { loadCorpus, loadProfiles } from '../corpus-views/ref-parser.js';
+import { slugifyAuthor } from './profile-generate.js';
+import { buildCitationGraph, buildCoauthorGraph, hIndex, cdIndex, pageRank, betweenness, eigenvector, clustering, } from './corpus-graph.js';
+/** h-index → influence grade (compute_metrics.grade_influence thresholds). */
+function gradeInfluence(h) {
+    if (h >= 3)
+        return 'A';
+    if (h >= 2)
+        return 'B';
+    if (h >= 1)
+        return 'C';
+    return 'D';
+}
+function mean(xs) {
+    return xs.length ? xs.reduce((a, b) => a + b, 0) / xs.length : 0;
+}
+/** Compute paper-level + person-level metrics across the corpus. */
+export function computeMetrics(corpusRoot) {
+    const { records } = loadCorpus(corpusRoot);
+    const cite = buildCitationGraph(records);
+    const coauthor = buildCoauthorGraph(records);
+    // Paper-level: CD-index + PageRank.
+    const pr = pageRank(cite);
+    const papers = records.map((r) => ({
+        refId: r.refId,
+        cdIndex: cdIndex(r.refId, cite),
+        pageRank: Math.round((pr.get(r.refId) ?? 0) * 1e6) / 1e6,
+    }));
+    const paperById = new Map(papers.map((p) => [p.refId, p]));
+    // Co-author centrality (keyed by author display name).
+    const bc = betweenness(coauthor);
+    const ec = eigenvector(coauthor);
+    const cc = clustering(coauthor);
+    // author display-name → slug (to match PROF-P).
+    const slugToAuthor = new Map();
+    for (const a of coauthor.keys())
+        slugToAuthor.set(slugifyAuthor(a), a);
+    // Per-PROF-P aggregation.
+    const people = [];
+    for (const p of loadProfiles(corpusRoot)) {
+        if (p.type !== 'person')
+            continue;
+        const refs = p.corpusRefs.filter((r) => cite.out.has(r));
+        const citationCounts = refs.map((r) => (cite.in.get(r) ?? new Set()).size);
+        const h = hIndex(citationCounts);
+        const cds = refs.map((r) => paperById.get(r)?.cdIndex).filter((x) => x != null);
+        const prs = refs.map((r) => paperById.get(r)?.pageRank ?? 0);
+        const slug = p.profId.replace(/^PROF-P-/, '');
+        const author = slugToAuthor.get(slug);
+        people.push({
+            profId: p.profId,
+            name: p.name ?? '',
+            paperCount: refs.length,
+            hIndex: h,
+            meanCdIndex: cds.length ? Math.round(mean(cds) * 1e4) / 1e4 : null,
+            meanPageRank: Math.round(mean(prs) * 1e6) / 1e6,
+            betweenness: author ? Math.round((bc.get(author) ?? 0) * 1e6) / 1e6 : 0,
+            eigenvector: author ? Math.round((ec.get(author) ?? 0) * 1e6) / 1e6 : 0,
+            clustering: author ? Math.round((cc.get(author) ?? 0) * 1e4) / 1e4 : 0,
+            gradeInfluence: gradeInfluence(h),
+        });
+    }
+    people.sort((a, b) => b.hIndex - a.hIndex || b.meanPageRank - a.meanPageRank || (a.profId < b.profId ? -1 : 1));
+    return { papers, people };
+}
+/** Render person-level metrics as a markdown table (or `--papers` for paper-level). */
+export function renderMetrics(m, mode = 'people') {
+    if (mode === 'papers') {
+        const lines = ['| REF | CD-index | PageRank |', '|---|---:|---:|'];
+        for (const p of [...m.papers].sort((a, b) => b.pageRank - a.pageRank)) {
+            lines.push(`| ${p.refId} | ${p.cdIndex ?? '—'} | ${p.pageRank} |`);
+        }
+        return lines.join('\n') + '\n';
+    }
+    const lines = [
+        '# Entity influence metrics',
+        '',
+        `${m.people.length} profiled people · ${m.papers.length} papers`,
+        '',
+        '| Profile | Papers | h-index | Mean CD | Mean PageRank | Betweenness | Eigenvector | Grade |',
+        '|---|---:|---:|---:|---:|---:|---:|---|',
+    ];
+    for (const p of m.people) {
+        lines.push(`| ${p.profId} | ${p.paperCount} | ${p.hIndex} | ${p.meanCdIndex ?? '—'} | ${p.meanPageRank} | ${p.betweenness} | ${p.eigenvector} | ${p.gradeInfluence} |`);
+    }
+    return lines.join('\n') + '\n';
+}
+//# sourceMappingURL=profile-metrics.js.map

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

@@ -0,0 +1,86 @@
+/**
+ * profile-status — entity profiles past their refresh cadence (#1502).
+ *
+ * Port of profiles/find_stale_profiles.py: reads PROF-{P,O,G,F,S} frontmatter
+ * via the shared parser, computes staleness with the shared computeStaleness
+ * helper, and reports most-overdue-first. Profile-specific semantics, faithful
+ * to the source:
+ *  - missing `refresh-cadence` defaults to `annual`; an unknown cadence word is
+ *    also treated as `annual` (find_stale's CADENCE_DAYS.get(cadence, 365));
+ *  - `on-demand` is never stale;
+ *  - stale when overdue ≥ 0 (at or past the window), vs radar's strictly-> 0.
+ *
+ * @source historical: profiles/find_stale_profiles.py
+ */
+import { loadProfiles } from '../corpus-views/ref-parser.js';
+import { computeStaleness, cadenceWindowDays } from '../corpus-views/corpus-config.js';
+function asOf(today) {
+    return new Date(`${today ?? new Date().toISOString().slice(0, 10)}T00:00:00Z`);
+}
+/** Stringify a frontmatter value; js-yaml parses bare ISO dates to Date. */
+function fmStr(v) {
+    if (typeof v === 'string')
+        return v.trim() || null;
+    if (typeof v === 'number')
+        return String(v);
+    if (v instanceof Date)
+        return v.toISOString().slice(0, 10);
+    return null;
+}
+/** One status row per profile that has a `last-refreshed`, sorted most-overdue-first. */
+export function profileStatusRows(corpusRoot, opts = {}) {
+    const today = asOf(opts.today);
+    const rows = [];
+    for (const p of loadProfiles(corpusRoot)) {
+        const lastRefreshed = fmStr(p.frontmatter['last-refreshed']);
+        if (!lastRefreshed)
+            continue; // find_stale skips profiles without last-refreshed
+        let cadence = fmStr(p.frontmatter['refresh-cadence']) ?? 'annual';
+        if (cadenceWindowDays(cadence) === undefined)
+            cadence = 'annual'; // unknown -> 365, per source
+        const s = computeStaleness(cadence, lastRefreshed, today);
+        rows.push({
+            profId: p.profId,
+            name: p.name ?? '',
+            type: p.type ?? '',
+            cadence,
+            lastRefreshed,
+            daysSince: s.daysSince,
+            overdueDays: s.overdueDays,
+            isStale: s.overdueDays !== null && s.overdueDays >= 0, // source: days_overdue >= 0
+        });
+    }
+    const filtered = opts.staleOnly ? rows.filter((r) => r.isStale) : rows;
+    return filtered.sort((a, b) => {
+        const ao = a.overdueDays ?? -Infinity;
+        const bo = b.overdueDays ?? -Infinity;
+        if (ao !== bo)
+            return bo - ao;
+        return a.profId < b.profId ? -1 : a.profId > b.profId ? 1 : 0;
+    });
+}
+/** Render profile-status rows as a markdown table, CSV, or plain list. */
+export function renderProfileStatus(rows, format = 'table') {
+    if (format === 'csv') {
+        const head = 'prof_id,type,cadence,last_refreshed,days_since,overdue_days,is_stale';
+        const body = rows.map((r) => `${r.profId},${r.type},${r.cadence},${r.lastRefreshed},${r.daysSince ?? ''},${r.overdueDays ?? ''},${r.isStale}`);
+        return [head, ...body].join('\n') + '\n';
+    }
+    if (format === 'list') {
+        return (rows
+            .map((r) => {
+            const tag = r.isStale ? `STALE +${r.overdueDays}d` : r.overdueDays === null ? 'n/a' : `ok (${-r.overdueDays}d left)`;
+            return `- ${r.profId} [${r.type}] ${r.cadence} — last ${r.lastRefreshed} — ${tag}`;
+        })
+            .join('\n') + '\n');
+    }
+    const lines = [
+        '| Profile | Type | Cadence | Last Refreshed | Days Since | Overdue (days) | Stale |',
+        '|---|---|---|---|---:|---:|---|',
+    ];
+    for (const r of rows) {
+        lines.push(`| ${r.profId} | ${r.type || '—'} | ${r.cadence} | ${r.lastRefreshed} | ${r.daysSince ?? '—'} | ${r.overdueDays ?? '—'} | ${r.isStale ? 'yes' : 'no'} |`);
+    }
+    return lines.join('\n') + '\n';
+}
+//# sourceMappingURL=profile-status.js.map

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

@@ -0,0 +1,139 @@
+/**
+ * profile-temporal — publication trajectory + hot-streak detection (#1501).
+ *
+ * Port of profiles/temporal_analysis.py (stdlib): per-year paper counts, topic
+ * drift (cosine distance between consecutive-year topic vectors), hot-streak
+ * detection (≥3 consecutive years with ≥1 A-grade paper, Fortunato 2018),
+ * career-phase classification, and trajectory trend. Reuses the #1497 parser
+ * (year + topics) + the analysis-doc GRADE reader.
+ *
+ * @source historical: profiles/temporal_analysis.py
+ */
+import { loadCorpus, loadProfiles } from '../corpus-views/ref-parser.js';
+import { readAnalysisGrade } from './radar-shared.js';
+function topicVector(topics) {
+    const counts = new Map();
+    for (const t of topics)
+        counts.set(t, (counts.get(t) ?? 0) + 1);
+    const mag = Math.sqrt([...counts.values()].reduce((a, b) => a + b * b, 0));
+    if (mag === 0)
+        return new Map();
+    const v = new Map();
+    for (const [t, c] of counts)
+        v.set(t, c / mag);
+    return v;
+}
+function cosineDistance(a, b) {
+    if (!a.size || !b.size)
+        return 0;
+    const keys = new Set([...a.keys(), ...b.keys()]);
+    let dot = 0;
+    for (const k of keys)
+        dot += (a.get(k) ?? 0) * (b.get(k) ?? 0);
+    const m1 = Math.sqrt([...a.values()].reduce((s, x) => s + x * x, 0));
+    const m2 = Math.sqrt([...b.values()].reduce((s, x) => s + x * x, 0));
+    if (m1 === 0 || m2 === 0)
+        return 0;
+    return Math.round((1 - dot / (m1 * m2)) * 1e4) / 1e4;
+}
+function detectHotStreak(annual) {
+    let best = null;
+    let start = null;
+    let len = 0;
+    const close = (active) => {
+        if (len >= 3 && (best === null || len > best.length))
+            best = { startYear: start, length: len, ...(active ? { active: true } : {}) };
+    };
+    for (const d of annual) {
+        if (d.hasAGrade) {
+            if (start === null) {
+                start = d.year;
+                len = 1;
+            }
+            else
+                len++;
+        }
+        else {
+            close(false);
+            start = null;
+            len = 0;
+        }
+    }
+    close(true);
+    return best;
+}
+/** Compute the temporal trajectory for one PROF-P/PROF-O profile. */
+export function computeTrajectory(corpusRoot, profId, asOfYear = new Date().getUTCFullYear()) {
+    const profiles = loadProfiles(corpusRoot);
+    const profile = profiles.find((p) => p.profId === profId);
+    const empty = { profId, annualData: [], hotStreak: null, careerPhase: 'unknown', trajectoryTrend: 'insufficient data', firstYear: null, lastYear: null, totalPapers: 0 };
+    if (!profile)
+        return empty;
+    const { records } = loadCorpus(corpusRoot);
+    const byId = new Map(records.map((r) => [r.refId, r]));
+    const yearly = new Map();
+    for (const ref of profile.corpusRefs) {
+        const rec = byId.get(ref);
+        if (!rec || rec.year == null)
+            continue;
+        const grade = readAnalysisGrade(corpusRoot, ref);
+        (yearly.get(rec.year) ?? yearly.set(rec.year, []).get(rec.year)).push({ grade, topics: rec.topics });
+    }
+    if (yearly.size === 0)
+        return empty;
+    const years = [...yearly.keys()].sort((a, b) => a - b);
+    const annualData = [];
+    let prev = new Map();
+    for (const year of years) {
+        const papers = yearly.get(year);
+        const topics = papers.flatMap((p) => p.topics);
+        const grades = papers.map((p) => p.grade);
+        const tv = topicVector(topics);
+        annualData.push({
+            year,
+            paperCount: papers.length,
+            grades,
+            topTopics: [...tv.keys()].slice(0, 3),
+            topicDrift: prev.size ? cosineDistance(prev, tv) : null,
+            hasAGrade: grades.some((g) => g.toUpperCase().startsWith('A')),
+        });
+        prev = tv;
+    }
+    const firstYear = years[0];
+    const careerLength = asOfYear - firstYear;
+    const careerPhase = careerLength <= 5 ? 'early' : careerLength <= 15 ? 'mid' : 'senior';
+    const recent = annualData.slice(-3);
+    const counts = recent.map((d) => d.paperCount);
+    const trend = counts.length >= 2 ? (counts[counts.length - 1] > counts[0] ? 'accelerating' : counts[counts.length - 1] < counts[0] ? 'decelerating' : 'stable') : 'insufficient data';
+    return {
+        profId,
+        annualData,
+        hotStreak: detectHotStreak(annualData),
+        careerPhase,
+        trajectoryTrend: trend,
+        firstYear,
+        lastYear: years[years.length - 1],
+        totalPapers: annualData.reduce((s, d) => s + d.paperCount, 0),
+    };
+}
+/** Render a trajectory as a markdown summary + the §7 year table. */
+export function renderTrajectory(t) {
+    if (!t.annualData.length)
+        return `${t.profId}: no dated corpus papers.\n`;
+    const hs = t.hotStreak ? `${t.hotStreak.length} years from ${t.hotStreak.startYear}${t.hotStreak.active ? ' (active)' : ''}` : 'none detected';
+    const lines = [
+        `# ${t.profId} — publication trajectory`,
+        '',
+        `Career phase: **${t.careerPhase}** · trend: **${t.trajectoryTrend}** · ${t.firstYear}–${t.lastYear} · ${t.totalPapers} papers`,
+        `Hot streak: ${hs}`,
+        '',
+        '| Year | Papers | Top Topics | Topic Drift |',
+        '|---|---:|---|---|',
+    ];
+    for (const d of t.annualData) {
+        const drift = d.topicDrift == null ? '—' : d.topicDrift > 0.3 ? `${d.topicDrift} *(pivot)*` : String(d.topicDrift);
+        lines.push(`| ${d.year} | ${d.paperCount} | ${d.topTopics.join(', ') || '—'} | ${drift} |`);
+    }
+    return lines.join('\n') + '\n';
+}
+//# sourceMappingURL=profile-temporal.js.map