@cspeach/cli 1.1.30 → 1.1.32

package/dist/register/xref.js

@@ -0,0 +1,117 @@
+/**
+ * The where-used index, turned into calling objects (spec §5.3).
+ *
+ * WBCROSSGT and CROSS name the INCLUDE that uses an object. A caller is the
+ * object that include belongs to: a class (its pool includes follow a fixed
+ * naming scheme), an interface pool, a function group (SAPL<fg>, or an L<fg>…
+ * include through its D010INC master), or a report (its master, or itself).
+ * Anything that resolves to nothing is counted as unmapped — never guessed.
+ *
+ * Namespaced names (`/ACME/CL_THING======CP`, `/ACME/SAPLZFG`) follow the
+ * same rules; the namespace stays part of the object name.
+ */
+/** Class-pool includes: name padded with '=' then CP/CU/CI/CO/CT/CS, CMnnn, CCDEF/CCIMP/CCMAC/CCAU. */
+const CLASS_INCLUDE = /^([^=]{1,30})=+(C[A-Z]{1,2}|CM[0-9A-Z]{3}|CCDEF|CCIMP|CCMAC|CCAU)$/;
+/** Interface-pool includes. */
+const INTF_INCLUDE = /^([^=]{1,30})=+I[PU]$/;
+/**
+ * The same pool includes read at fixed width: the object name is the first 30
+ * characters, padded with '='. A name of exactly 30 characters has no '=' at
+ * all, which the patterns above cannot see.
+ */
+const CLASS_SUFFIX = /^(C[A-Z]{1,2}|CM[0-9A-Z]{3}|CCDEF|CCIMP|CCMAC|CCAU)$/;
+const INTF_SUFFIX = /^I[PU]$/;
+/** Function-group main program, optionally namespaced: SAPLZFG, /ACME/SAPLZFG. */
+const FUGR_MAIN = /^(\/[A-Z0-9_]+\/)?SAPL(.+)$/;
+/** Pattern-only mapping: what an include or main program name says by itself. */
+function byPattern(include) {
+    let m = CLASS_INCLUDE.exec(include);
+    if (m)
+        return { type: 'CLAS', name: m[1] };
+    m = INTF_INCLUDE.exec(include);
+    if (m)
+        return { type: 'INTF', name: m[1] };
+    if (include.length > 30) {
+        const name = include.slice(0, 30).replace(/=+$/, '');
+        const suffix = include.slice(30);
+        if (name && !name.includes('=')) {
+            if (CLASS_SUFFIX.test(suffix))
+                return { type: 'CLAS', name };
+            if (INTF_SUFFIX.test(suffix))
+                return { type: 'INTF', name };
+        }
+    }
+    m = FUGR_MAIN.exec(include);
+    if (m)
+        return { type: 'FUGR', name: `${m[1] ?? ''}${m[2]}` };
+    return null;
+}
+/**
+ * The object an include belongs to. `masters` maps include → main program
+ * (from D010INC); a report known from TADIR is entered as mapping to itself.
+ */
+export function objectOfInclude(include, masters) {
+    const inc = (include ?? '').trim().toUpperCase();
+    if (!inc)
+        return null;
+    const direct = byPattern(inc);
+    if (direct)
+        return direct;
+    const master = masters.get(inc);
+    if (!master)
+        return null;
+    return byPattern(master) ?? { type: 'PROG', name: master };
+}
+/**
+ * Callers per referenced object name. Index names can carry a component
+ * (`ZCL_X\ME:RUN`); the part before the backslash is the object. `selfOf(name)`
+ * gives that object's own key (`TYPE|NAME`) so a self-reference is dropped.
+ * `includesUnmapped` counts distinct includes CSPeach could not map.
+ */
+export function callersFromIndex(rows, masters, selfOf) {
+    const out = new Map();
+    const unmapped = new Map();
+    for (const row of rows) {
+        const name = (row.name ?? '').trim().toUpperCase().split('\\')[0];
+        if (!name)
+            continue;
+        const include = (row.include ?? '').trim().toUpperCase();
+        let entry = out.get(name);
+        if (!entry) {
+            entry = { objects: new Set(), includesUnmapped: 0 };
+            out.set(name, entry);
+        }
+        const ref = objectOfInclude(include, masters);
+        if (!ref) {
+            let seen = unmapped.get(name);
+            if (!seen) {
+                seen = new Set();
+                unmapped.set(name, seen);
+            }
+            if (include)
+                seen.add(include);
+            entry.includesUnmapped = seen.size;
+            continue;
+        }
+        const key = `${ref.type}|${ref.name}`;
+        if (key === selfOf(name))
+            continue;
+        entry.objects.add(key);
+    }
+    return out;
+}
+/** The REPOSRC program name that carries an object's change date, or null for other types. */
+export function reposrcNameFor(type, name) {
+    const t = type.toUpperCase();
+    const n = name.toUpperCase();
+    switch (t) {
+        case 'PROG': return n;
+        case 'CLAS': return `${n.padEnd(30, '=')}CP`;
+        case 'INTF': return `${n.padEnd(30, '=')}IP`;
+        case 'FUGR': {
+            const m = /^(\/[A-Z0-9_]+\/)(.+)$/.exec(n);
+            return m ? `${m[1]}SAPL${m[2]}` : `SAPL${n}`;
+        }
+        default: return null;
+    }
+}

package/dist/renderer/startup-lines.js

@@ -12,6 +12,7 @@ import { formatAttention } from './notice-shape.js';
 import { truncateToWidth, uiWidth, frameWidth } from './ui-width.js';
 import { sanitizeControlChars } from './sanitize.js';
 import { holdBrand } from './brand-settled.js';
+import { formatTimeAgo } from '../session/time-ago.js';
 export { brandSettled } from './brand-settled.js';
 /** Folder budget on the panels status line (controller ruling R2). */
 const STATUS_PATH_MAX = 20;
@@ -131,6 +132,16 @@ export function panelsResumeLine(last, priorTurns) {
     const fact = last ?? `${priorTurns} prior turn${priorTurns === 1 ? '' : 's'}`;
     return '   ' + paint('dim', truncateToWidth(sanitizeControlChars(`resumed · ${fact}`), Math.max(20, uiWidth() - 3)));
 }
+/** 2026-10-08 (sessions/folders) — the dim start line pointing at this folder's
+ *  latest session. Quotes the user's prompt, so control characters are neutralised. */
+export function lastSessionHereLine(s, now = new Date()) {
+    const when = formatTimeAgo(s.lastTurnAt, now);
+    const what = [
+        s.skill ? `/${s.skill}` : null,
+        s.promptSnippet ? `"${truncateToWidth(sanitizeControlChars(s.promptSnippet), 40)}"` : null,
+    ].filter(Boolean).join(', ');
+    return '   ' + paint('dim', `Last session here: ${when}${what ? ` (${what})` : ''} — cspeach --continue picks it up.`);
+}
 /** A "!" line for the start screen (no Next: line → exactly one line). */
 export function panelsInterruptedNote(n) {
     return formatAttention({ text: `${n} unfinished session${n === 1 ? '' : 's'}`, fact: 'cspeach --resume' }).trimEnd();

package/dist/renderer/tool-labels.js

@@ -161,6 +161,8 @@ const RULES = {
     cap_link_smoke: (a) => ({ verb: 'S/4 link check', object: str(a['s4']?.['entitySet']) ?? '' }),
     app_lane_resolve: (a) => ({ verb: 'Chose lane', object: shortLeft(str(a['specPath']) ?? '') }),
     team_findings: (a) => ({ verb: 'Read team findings', object: str(a['lane']) ?? str(a['packages']) ?? 'all objects' }),
+    rules_propose: () => ({ verb: 'Check a proposed decision rule', object: 'nothing is saved' }),
+    team_estate: (a) => ({ verb: 'Read estate inventory', object: str(a['packages']) ?? 'all packages' }),
     sap_badi_list: (a) => ({ verb: 'Searched BAdIs', object: shortRight(`"${str(a['query']) ?? ''}"`) }),
     sap_snapshot_list: (a) => ({ verb: 'Listed snapshots', object: shortRight(str(a['name']) ?? '') }),
     sap_snapshot_read: sapObject('Read snapshot'),
@@ -266,7 +268,7 @@ const PRESENT = {
     Preview: 'Preview', 'Searched samples': 'Searching samples', 'Read sample': 'Reading sample',
     'Audited metadata': 'Auditing metadata', 'Extended model': 'Extending model',
     'Checked capability': 'Checking capability',
-    'Read texts of': 'Reading texts of', 'Read team findings': 'Reading team findings', 'Wrote texts': 'Writing texts',
+    'Read texts of': 'Reading texts of', 'Read team findings': 'Reading team findings', 'Check a proposed decision rule': 'Checking a proposed decision rule', 'Read estate inventory': 'Reading estate inventory', 'Wrote texts': 'Writing texts',
 };
 export function toolActivityLabel(name, args) {
     const l = toolLabel(name, args);

package/dist/renderer/tool-widget.js

@@ -402,6 +402,18 @@ function approvalDeclined(content) {
         return undefined;
     }
 }
+/** 1.1.31 — true when request_approval approved by the user's auto_approve setting, not by a person. */
+function approvalAutoApproved(content) {
+    if (!content || !content.trim().startsWith('{'))
+        return false;
+    try {
+        const r = JSON.parse(content);
+        return r.approved === true && r.auto_approved === true;
+    }
+    catch {
+        return false;
+    }
+}
 function panelsRow(p) {
     const width = Math.max(20, getEffectiveBodyWidth());
     const label = toolLabel(p.name, p.args, p.isError ? undefined : p.resultContent);
@@ -410,7 +422,9 @@ function panelsRow(p) {
     const declined = !p.isError && p.name === 'request_approval' ? approvalDeclined(p.resultContent) : undefined;
     const icon = p.isError ? paint('bad', '✗') : declined ? paint('warn', '·') : paint('ok', '✓');
     const timing = p.durationMs >= 1000 ? formatDuration(p.durationMs) : '';
-    const tail = [declined ?? label.detail, timing].filter(Boolean).join(' · ');
+    // 1.1.31: a setting said yes, not a person — the row says so.
+    const auto = !p.isError && !declined && p.name === 'request_approval' && approvalAutoApproved(p.resultContent);
+    const tail = [declined ?? (auto ? 'auto-approved' : label.detail), timing].filter(Boolean).join(' · ');
     const verb = label.verb.padEnd(VERB_COL);
     // Budget: "✓ " + verb + " " + object + "  " + tail must fit the width.
     const budget = width - 2 - verb.length - 1 - (tail ? tail.length + 2 : 0);

package/dist/repl/at-completer.js

@@ -17,7 +17,7 @@
  * The cache TTL is short enough that newly-saved files appear within a
  * few seconds of their save without manual refresh.
  */
-import { ensureWorkspaceSync, listProjectFilesSync } from '../projects/workspace.js';
+import { ensureWorkspaceSync, listLegacyFilesSync, listProjectFilesSync } from '../projects/workspace.js';
 const CACHE_TTL_MS = 3000;
 let cache = null;
 function getCachedFiles() {
@@ -25,7 +25,11 @@ function getCachedFiles() {
     if (!cache || now - cache.at > CACHE_TTL_MS) {
         try {
             const ws = ensureWorkspaceSync();
-            cache = { files: listProjectFilesSync(ws), at: now };
+            const files = listProjectFilesSync(ws);
+            // Task 11 — old save locations stay readable for one release; their
+            // files follow the new folder's, same names skipped.
+            const legacy = listLegacyFilesSync(process.cwd(), files.map((f) => f.filename));
+            cache = { files: [...files, ...legacy], at: now };
         }
         catch {
             cache = { files: [], at: now };

package/dist/repl/at-picker.js

@@ -48,7 +48,7 @@ export function listWorkspaceFileChoices(opts) {
     const seen = new Set();
     // Workspace half (takes precedence on name collisions).
     try {
-        const ws = opts?.workspace ?? ensureWorkspaceSync();
+        const ws = opts?.workspace ?? ensureWorkspaceSync(opts?.cwd);
         for (const f of listProjectFilesSync(ws)) {
             if (seen.has(f.filename))
                 continue;

package/dist/repl/builtin-commands.js

@@ -9,6 +9,8 @@
  * inquirer, so the router can import it.
  */
 import { creditsActive } from '../cost/credits.js';
+// Pure generated data (type-only import inside), so this file stays light.
+import { BUNDLED_RUNS } from '../runs/bundled-runs.js';
 export const COST_DESCRIPTION_USD = 'Show this session\'s spend so far ($ and tokens)';
 export const COST_DESCRIPTION_CREDITS = 'Show the credits this session has used so far';
 /** Piece 2 §10: managed customers see credits, never "$" (cost/display-mode.ts). */
@@ -34,6 +36,8 @@ export const BUILTIN_ENTRIES = [
     { name: '/ui', description: 'View or change rendering mode (auto / ink), or the look: /ui look panels|legacy' },
     { name: '/reroute', description: 'Re-dispatch the previous prompt to a different skill' },
     { name: '/transport', description: 'View or set the active transport for this session' },
+    { name: '/rules', description: 'View or change the decision rules of the joined team project (the lead changes them)' },
+    { name: '/run', description: `Start a guided run — ${BUNDLED_RUNS.map((r) => r.entry).join(' or ')}` },
     { name: '/safety-mode', description: 'Toggle structured Forge Rule confirmation cards (on / off / status)' },
 ];
 /**

package/dist/repl/journey-entry.js

@@ -0,0 +1,27 @@
+import { enterJourney, journeyStoppedOnError } from '../journey/chain.js';
+import { openStatusPage } from '../util/open-in-browser.js';
+export async function runJourneyEntry(trigger, a) {
+    const hooks = {
+        session: a.session,
+        cwd: a.cwd,
+        headless: a.headless,
+        emit: a.emit,
+        ...(a.queueNext && !a.headless ? { queueNext: a.queueNext } : {}),
+        ...(!a.standalone && a.adt ? { adt: a.adt } : {}),
+        sapAlias: a.sapAlias,
+        ...(a.standalone ? { noSap: true } : {}),
+        signal: a.signal,
+        // Task 6 — the status page opens in the browser after Yes on its card.
+        openFile: (file) => openStatusPage(file),
+    };
+    try {
+        await enterJourney(trigger, hooks);
+    }
+    catch (err) {
+        if (process.env['CSPEACH_DEBUG'] === '1')
+            throw err;
+        // Audit M-1: paused (not ended), so the line's "carry on" works; the error
+        // is logged, and a second stop at the same step says so (follow-up a).
+        a.emit(journeyStoppedOnError(a.session, a.cwd, err));
+    }
+}

package/dist/repl/plan-hop.js

@@ -1,17 +1,10 @@
-// src/repl/plan-hop.ts
-//
-// Task 13 fix round (2026-10-04) — an "in-run hop" is a plan-resume the plan
-// chain ITSELF queued (runPostPhaseChain / runReauditPass /
-// runContinuationChain: the next step, the re-run after a failed check).
-// Marked at the source, never inferred from the command shape: the first step
-// of an /abap-app run (lane/app-chain.ts) and a typed resume are NOT hops, so
-// they show the board and the guarded notice once.
+const PLAN_ORIGIN = { by: 'plan' };
 export function createPlanHopTracker(slot) {
     let chainQueued = null;
     return {
         queue(cmd) {
             chainQueued = cmd;
-            slot.set(cmd);
+            slot.set(cmd, PLAN_ORIGIN);
         },
         take(cmd) {
             const hop = chainQueued !== null && chainQueued === cmd;

package/dist/repl/rules-menu.js

@@ -0,0 +1,177 @@
+import { DEFAULTS_PINNED_LINE, refuseUnreadable, requireRulesLead, rulesNow, rulesRefusal, saveRuleEdit, stampFor } from '../commands/team-rules.js';
+import { activeProject, RegisterError } from '../register/store.js';
+import { addFromTemplate, addProposed, removeRule, resetRules, ruleWords, rulesTableLines, setOutcome, setThreshold, toggleRule, RULE_TEMPLATES, } from '../register/rules-edit.js';
+import { clearRuleProposal, ruleProposalFor } from '../register/rule-proposal.js';
+export const NOT_JOINED_LINE = 'This laptop has not joined a team project. Run: cspeach team join <folder>';
+const NOTHING_SAVED = 'Nothing was saved.';
+/** A menu that never ends would hold the session; a lead does a handful of changes at a sitting. */
+const MAX_ROUNDS = 100;
+const DISPOSITION_CHOICES = [
+    { value: 'keep', label: 'Keep' }, { value: 'fix', label: 'Fix' }, { value: 'rebuild', label: 'Rebuild' }, { value: 'retire-candidate', label: 'Retire candidate' },
+];
+let cardSeq = 0;
+const card = (title, choices, aliases = {}, facts) => ({
+    id: `rules-${(cardSeq += 1)}`, tag: 'QUESTION', title, choices, initial: 0, aliases, ...(facts ? { facts } : {}),
+});
+const pick = async (o, req) => {
+    const res = await o.confirm(req);
+    return res.cancelled ? null : res.value;
+};
+/** The change for one rule, from its own menu; null = back, or nothing to save. */
+async function ruleChange(o, rule, rules) {
+    const stamp = stampFor(o.deps);
+    const what = await pick(o, card(`Rule ${rule.id}: ${ruleWords(rule)}`, [
+        { value: 'toggle', label: rule.on ? 'Turn off' : 'Turn on' },
+        { value: 'threshold', label: 'Change threshold' },
+        { value: 'outcome', label: 'Change outcome' },
+        { value: 'remove', label: 'Remove' },
+        { value: 'back', label: 'Back' },
+    ], { '1': 'toggle', '2': 'threshold', '3': 'outcome', '4': 'remove', b: 'back' }, rule.note ? [`Why: ${rule.note}`] : undefined));
+    switch (what) {
+        case 'toggle': return toggleRule(rules, rule.id, !rule.on, stamp);
+        case 'remove': return removeRule(rules, rule.id);
+        case 'threshold': {
+            // A rule that only caps the count is changed at its cap; any other at its floor.
+            const atMost = rule.when.maxFindings !== undefined && rule.when.minFindings === undefined;
+            const counts = rule.when.maxFindings !== undefined || rule.when.minFindings !== undefined;
+            const answer = (await o.ask(atMost ? 'At most how many findings?'
+                : counts ? 'More than how many findings?' : 'Add a condition: more than how many findings?')).trim();
+            if (!/^\d+$/.test(answer)) {
+                if (answer)
+                    o.print('✗ The number of findings needs a whole number of 0 or more, for example 15.');
+                return null;
+            }
+            const n = Number(answer);
+            return setThreshold(rules, rule.id, atMost ? { maxFindings: n } : { minFindings: n + 1 }, stamp);
+        }
+        case 'outcome': {
+            const choices = [...DISPOSITION_CHOICES.filter((d) => d.value !== rule.then.disposition), { value: 'cancel', label: 'Cancel' }];
+            const to = await pick(o, card(`Rule ${rule.id}: what should it propose?`, choices));
+            return !to || to === 'cancel' ? null : setOutcome(rules, rule.id, to, stamp);
+        }
+        default: return null;
+    }
+}
+async function addChange(o, rules) {
+    const names = Object.keys(RULE_TEMPLATES);
+    const choices = [
+        ...names.map((n) => ({ value: n, label: `${n}: ${ruleWords({ id: '', on: true, ...RULE_TEMPLATES[n] })}` })),
+        { value: 'cancel', label: 'Cancel' },
+    ];
+    const name = await pick(o, card('Add which rule? It goes last: rules are tried in order.', choices));
+    return !name || name === 'cancel' ? null : addFromTemplate(rules, name, stampFor(o.deps));
+}
+export async function runRulesMenu(o) {
+    const joined = activeProject();
+    if (!joined) {
+        o.print(NOT_JOINED_LINE);
+        return;
+    }
+    for (let round = 0; round < MAX_ROUNDS; round++) {
+        const now = rulesNow(joined.projectDir);
+        for (const line of rulesTableLines(now.rules, now.from, now.warning))
+            o.print(line);
+        try {
+            requireRulesLead(now.project, o.deps);
+        }
+        catch (e) {
+            if (!(e instanceof RegisterError))
+                throw e;
+            o.print(rulesRefusal(now.project.lead.name));
+            return;
+        }
+        // A rule proposed from words (rules_propose) waits here until the person saves it.
+        const proposed = ruleProposalFor(joined.projectId);
+        const choices = [
+            ...now.rules.map((r) => ({ value: `rule:${r.id}`, label: `${r.id} · ${ruleWords(r)}${r.on ? '' : ' (off)'}` })),
+            ...(proposed ? [{ value: 'proposed', label: `Add the proposed rule: ${proposed.words}` }] : []),
+            { value: 'add', label: 'Add a rule' }, { value: 'reset', label: 'Restore defaults' }, { value: 'done', label: 'Done' },
+        ];
+        const aliases = Object.fromEntries(choices.map((c, i) => [String(i + 1), c.value]));
+        aliases.d = 'done';
+        const choice = await pick(o, card('Decision rules: pick a rule to change it, or', choices, aliases));
+        if (!choice || choice === 'done')
+            return;
+        let edit = null;
+        try {
+            if (choice === 'add')
+                edit = await addChange(o, now.rules);
+            else if (choice === 'proposed' && proposed)
+                edit = addProposed(now.rules, proposed.proposal, stampFor(o.deps));
+            else if (choice === 'reset') {
+                if (now.from === 'default' && !now.warning) {
+                    o.print('The rules are the defaults already.');
+                    continue;
+                }
+                edit = resetRules(now.rules);
+            }
+            else {
+                const rule = now.rules.find((r) => `rule:${r.id}` === choice);
+                if (rule)
+                    edit = await ruleChange(o, rule, now.rules);
+            }
+            if (edit)
+                refuseUnreadable(now.warning, edit.change);
+        }
+        catch (e) {
+            if (!(e instanceof RegisterError))
+                throw e;
+            o.print(`✗ ${e.message}`);
+            continue;
+        }
+        if (!edit)
+            continue;
+        // The first save of a project on the defaults writes every rule into its file: said on the card.
+        const pins = now.from === 'default' && edit.rules !== null;
+        const save = await pick(o, card(edit.card, [{ value: 'save', label: 'Save' }, { value: 'cancel', label: 'Cancel' }], { s: 'save', c: 'cancel' }, pins ? [DEFAULTS_PINNED_LINE] : undefined));
+        if (save !== 'save') {
+            o.print(NOTHING_SAVED);
+            continue;
+        }
+        try {
+            for (const line of saveRuleEdit(joined.projectDir, edit, o.deps))
+                o.print(line);
+            if (choice === 'proposed')
+                clearRuleProposal();
+        }
+        catch (e) {
+            if (!(e instanceof RegisterError))
+                throw e;
+            o.print(`✗ ${e.message}`);
+        }
+    }
+}
+/**
+ * The REPL's `/rules`: both submit paths (Ink and classic) call this. The card
+ * is the Ink card slot when it has a listener, else a typed line (classic); the
+ * number question the same. Headless shows the table and no card.
+ */
+export async function runRulesSlash(trimmed, a) {
+    if (trimmed !== '/rules') {
+        a.emit('/rules takes no arguments — it opens the decision rules of the team project this laptop has joined');
+        return;
+    }
+    const { sessionTeamDeps } = await import('../journey/session-deps.js');
+    const { journeyAsk, journeyCardConfirm } = await import('../journey/chain.js');
+    const { deps } = a.headless ? await sessionTeamDeps({ headless: true }) : await sessionTeamDeps({ headless: false, signal: a.signal });
+    const ask = journeyAsk();
+    try {
+        await runRulesMenu({
+            deps: { ...deps, print: a.emit },
+            confirm: a.headless ? async () => ({ value: null, cancelled: true }) : journeyCardConfirm(a.emit),
+            // Esc on the question puts it away: nothing changes, the menu goes on.
+            ask: async (q) => { try {
+                return await ask(q);
+            }
+            catch {
+                return '';
+            } },
+            print: a.emit,
+        });
+    }
+    catch (e) {
+        if (process.env['CSPEACH_DEBUG'] === '1')
+            throw e;
+        a.emit(`✗ ${(e instanceof Error ? e.message : String(e)).split('\n')[0]}`);
+    }
+}

package/dist/repl/slash-completer.js

@@ -36,6 +36,7 @@ const BUILTIN_COMMANDS = [
     '/ui',
     '/reroute',
     '/transport',
+    '/rules',
 ];
 /**
  * Build the full slash-command list once at module load. Skill commands

package/dist/repl/slash-picker.js

@@ -25,11 +25,12 @@ import { SKILL_CATALOG, SKILL_ALIASES } from '../skill-catalog.js';
 // 2026-06-11 — builtin list extracted to builtin-commands.ts (pure data)
 // so the router layer can check builtin heads without importing inquirer.
 import { BUILTIN_ENTRIES } from './builtin-commands.js';
+import { partOfRun } from '../runs/runs.js';
 function buildCatalogue() {
-    const skillEntries = SKILL_CATALOG.map((s) => ({
-        name: `/${s.name}`,
-        description: s.description,
-    }));
+    const skillEntries = SKILL_CATALOG.map((s) => {
+        const part = partOfRun(s.name);
+        return { name: `/${s.name}`, description: part ? `${s.description} · part of ${part}` : s.description };
+    });
     return [...BUILTIN_ENTRIES, ...skillEntries].sort((a, b) => a.name.localeCompare(b.name));
 }
 const ALL_ENTRIES = buildCatalogue();