@cspeach/cli 1.1.13 → 1.1.15

package/dist/register/store.js

@@ -0,0 +1,227 @@
+/**
+ * Project Register on disk (spec §3, §3a).
+ *
+ * Two places, both chosen by a person, never by the model:
+ *   - the TEAM PROJECT FOLDER the lead creates: cspeach-team.json, baseline/,
+ *     lanes.json, rulings/. Collected records sit under writers/.
+ *   - this laptop's OUTBOX: where this machine's records are written. It mirrors
+ *     the project-folder layout (writers/<id>/records/…) so that handing records
+ *     in is a plain folder copy. By default it lives under ~/.cspeach; a developer
+ *     may point it inside their own OneDrive-synced folder instead.
+ *
+ * CSPeach writes only to paths on this list. It never writes to a network
+ * location on its own initiative.
+ */
+import { createHash, randomBytes } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { cspeachRoot } from '../config/paths.js';
+export const TEAM_FILE = 'cspeach-team.json';
+export const BASELINE_FILE = path.join('baseline', 'objects.json');
+export const LANES_FILE = 'lanes.json';
+export class RegisterError extends Error {
+}
+export const defaultRand = (bytes) => randomBytes(bytes).toString('hex');
+const stateFile = () => path.join(cspeachRoot(), 'register.json');
+export function loadState() {
+    try {
+        const s = JSON.parse(stripBom(fs.readFileSync(stateFile(), 'utf8')));
+        if (s && typeof s === 'object' && s.projects)
+            return { active: s.active ?? null, projects: s.projects };
+    }
+    catch { /* first use, or unreadable: start empty */ }
+    return { active: null, projects: {} };
+}
+export function saveState(state) {
+    fs.mkdirSync(cspeachRoot(), { recursive: true });
+    fs.writeFileSync(stateFile(), `${JSON.stringify(state, null, 2)}\n`);
+}
+/** The team project this laptop is recording against, or null. Cheap: one small file read. */
+export function activeProject() {
+    const s = loadState();
+    if (!s.active || !s.projects[s.active])
+        return null;
+    return { projectId: s.active, ...s.projects[s.active] };
+}
+export function defaultOutboxDir(projectId) {
+    return path.join(cspeachRoot(), 'register', projectId, 'outbox');
+}
+/** `mike-khan-7f3a`: the person plus this machine, so one file never has two writers. */
+export function writerIdFor(name, machine = os.hostname()) {
+    const slug = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'writer';
+    return `${slug}-${createHash('sha256').update(machine.toLowerCase()).digest('hex').slice(0, 4)}`;
+}
+export function projectIdFor(name, rand = defaultRand) {
+    const slug = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40) || 'project';
+    return `${slug}-${rand(2)}`;
+}
+export const sha256 = (text) => createHash('sha256').update(text).digest('hex');
+/**
+ * A byte-order mark, taken off by NUMBER. Notepad, Excel and a few sync tools
+ * put one in front of a file they save as UTF-8; `JSON.parse` then refuses the
+ * whole file. Written as a character in a regex it is invisible in the source —
+ * which is how two of these were copied around and a third was forgotten — so
+ * this is the one place that knows about it, and it names the code point.
+ */
+export const stripBom = (text) => (text.charCodeAt(0) === 0xfeff ? text.slice(1) : text);
+function readJson(file) {
+    let text;
+    try {
+        text = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        throw new RegisterError(`Cannot read ${file}`);
+    }
+    try {
+        return JSON.parse(stripBom(text));
+    }
+    catch {
+        throw new RegisterError(`${file} is not valid JSON`);
+    }
+}
+export function readProjectFile(projectDir) {
+    const p = readJson(path.join(projectDir, TEAM_FILE));
+    if (p?.kind !== 'team-project' || typeof p.projectId !== 'string' || typeof p.lead?.name !== 'string') {
+        throw new RegisterError(`${path.join(projectDir, TEAM_FILE)} is not a CSPeach team project file`);
+    }
+    return p;
+}
+/**
+ * What SAP accepts as a check variant name. Checked by every caller BEFORE a
+ * run, not only at the moment of writing: a name that cannot be written must
+ * not be measured with either.
+ */
+export const VARIANT_NAME = /^[A-Z0-9_/]{1,40}$/;
+/**
+ * The one field of the team project file that is set after `init`: which ATC
+ * check variant this team project measures with. Written whole, then renamed,
+ * like a record — a sync tool must never pick up half a team project file.
+ */
+export function writeProjectVariant(projectDir, variant) {
+    if (!VARIANT_NAME.test(variant))
+        throw new RegisterError(`"${variant}" is not an ATC check variant name.`);
+    const file = path.join(projectDir, TEAM_FILE);
+    const next = { ...readProjectFile(projectDir), atcVariant: variant };
+    fs.writeFileSync(`${file}.tmp`, `${JSON.stringify(next, null, 2)}\n`);
+    fs.renameSync(`${file}.tmp`, file);
+}
+/**
+ * One read, one sentence. `existsSync` then `readFileSync` answers only the
+ * easy failure: a folder halfway through a sync also gives EISDIR (a folder
+ * where the file goes), EBUSY and EPERM (a file the sync tool still holds, or
+ * one OneDrive has not fetched). None of those may reach a person as a stack.
+ */
+function readTextOrSay(file, missing) {
+    try {
+        return fs.readFileSync(file, 'utf8');
+    }
+    catch (e) {
+        if (e?.code === 'ENOENT')
+            throw new RegisterError(missing);
+        throw new RegisterError(`${file} could not be read. It may still be syncing.`);
+    }
+}
+export function readBaseline(projectDir) {
+    const project = readProjectFile(projectDir);
+    const file = path.join(projectDir, project.baseline?.file ?? BASELINE_FILE);
+    const text = readTextOrSay(file, `The baseline file is missing: ${file}`);
+    if (project.baseline?.sha256 && sha256(text) !== project.baseline.sha256) {
+        throw new RegisterError(`${file} does not match the checksum in the team project file. It was changed or only partly copied.`);
+    }
+    // A folder halfway through a sync is the everyday reason this file is not
+    // whole JSON. A person reads a sentence about their own folder here, never a
+    // parser's stack trace about a position in a byte stream.
+    let b;
+    try {
+        b = JSON.parse(stripBom(text));
+    }
+    catch {
+        throw new RegisterError(`${file} could not be read. It may still be syncing.`);
+    }
+    if (b?.kind !== 'baseline' || !Array.isArray(b.objects))
+        throw new RegisterError(`${file} is not a baseline file`);
+    // Every caller reads `o.type` and `o.name` straight away. One hand-edited or
+    // half-copied entry that is not an object would come out as a TypeError with
+    // a stack, from whichever command happened to touch it first.
+    if (b.objects.some((o) => !o || typeof o.type !== 'string' || typeof o.name !== 'string')) {
+        throw new RegisterError(`${file} could not be read. It may still be syncing.`);
+    }
+    return b.objects;
+}
+export function readLanes(projectDir) {
+    const file = path.join(projectDir, LANES_FILE);
+    if (!fs.existsSync(file))
+        return [];
+    const l = readJson(file);
+    return Array.isArray(l?.lanes) ? l.lanes : [];
+}
+export function writeLanes(projectDir, projectId, lanes) {
+    fs.writeFileSync(path.join(projectDir, LANES_FILE), `${JSON.stringify({ kind: 'lanes', formatVersion: 1, projectId, lanes }, null, 2)}\n`);
+}
+/**
+ * A record is a short list of object names. Anything this big is a dump, a log
+ * or something that is not a record at all, and reading it would cost a
+ * gigabyte of memory before `JSON.parse` could say so.
+ */
+const MAX_RECORD_BYTES = 64 * 1024 * 1024;
+/** One record file, or nothing. Counted as unreadable rather than thrown, whatever is wrong with it. */
+function readRecord(file) {
+    try {
+        if (fs.statSync(file).size > MAX_RECORD_BYTES)
+            return { ok: false };
+        return { ok: true, value: JSON.parse(stripBom(fs.readFileSync(file, 'utf8'))) };
+    }
+    catch {
+        // A file can be listed before the sync tool has finished writing it, or be a
+        // folder, or be held open: skip and count, never fail.
+        return { ok: false };
+    }
+}
+/** Every record-shaped JSON under a folder: writers/<id>/records, rulings, baseline/measurement-*.json. */
+export function collectRecords(root) {
+    const records = [];
+    let unreadable = 0;
+    let files = 0;
+    const take = (file) => {
+        files += 1;
+        const read = readRecord(file);
+        if (read.ok)
+            records.push(read.value);
+        else
+            unreadable += 1;
+    };
+    const readDir = (dir) => {
+        let names = [];
+        try {
+            names = fs.readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            if (!name.toLowerCase().endsWith('.json'))
+                continue;
+            take(path.join(dir, name));
+        }
+    };
+    let writers = [];
+    try {
+        writers = fs.readdirSync(path.join(root, 'writers'));
+    }
+    catch { /* none handed in yet */ }
+    for (const w of writers)
+        readDir(path.join(root, 'writers', w, 'records'));
+    readDir(path.join(root, 'rulings'));
+    try {
+        for (const name of fs.readdirSync(path.join(root, 'baseline'))) {
+            if (!/^measurement-.*\.json$/i.test(name))
+                continue;
+            // Measurement zero lands here, written by the lead and then synced: the
+            // same hazards as any other record, read the same way.
+            take(path.join(root, 'baseline', name));
+        }
+    }
+    catch { /* no baseline folder here (an outbox has none) */ }
+    return { records, unreadable, files };
+}

package/dist/repl.js

@@ -2482,8 +2482,16 @@ export async function runRepl(opts) {
                 // user re-submits the empty pre-fill, just silently re-fill
                 // without re-spamming the hint line. Tracked via lastEmptyPrefill.
                 if (lastEmptyPrefill !== head) {
-                    console.log(chalk.dim(`↪ ${head} — type your prompt and press Enter ` +
-                        chalk.dim(`(or "/cancel" to abandon)`)));
+                    // 2026-09-23 (Glenn's first run): "type your prompt" never said WHAT
+                    // to type, and our own skills suggest a bare next command
+                    // ("/abap-estimate next"), so the user is told to run something and
+                    // then asked an unanswerable question. Every skill now carries an
+                    // `asks` line with an example (skill-catalog.ts).
+                    const asks = SKILL_CATALOG.find((e) => `/${e.name}` === head)?.asks;
+                    console.log(chalk.dim(asks
+                        ? `↪ ${head} — ${asks}`
+                        : `${'↪'} ${head} — type your prompt and press Enter`));
+                    console.log(chalk.dim('  Enter to send · /cancel to abandon'));
                     lastEmptyPrefill = head;
                 }
                 // 2026-05-02: bake the pre-fill into the next prompt string

package/dist/rewind/candidates.js

@@ -24,6 +24,7 @@
  *   - sap_delete_object ⇒ restorable when a pre-delete snapshot exists (the
  *     snapshot IS the prior source; the executor recreates it).
  */
+import { includeSnapshotType } from '../tools/include-snapshot.js';
 /** The five write tools whose effects can (potentially) be rewound. */
 const WRITE_TOOLS = new Set([
     'sap_set_source',
@@ -116,7 +117,19 @@ function extractIdentity(tool, rawArgs) {
     const args = (rawArgs ?? {});
     if (IMPLICIT_CLASS_TOOLS.has(tool)) {
         const object = pickString(args, 'className') ?? pickString(args, 'class_name');
-        return object ? { object: object.toUpperCase(), objType: 'CLAS' } : null;
+        if (!object)
+            return null;
+        // An include write is rewound from the INCLUDE's own snapshot
+        // (type CLAS.<INCLUDE>), never from the class main source — restoring the
+        // main source would report success while the include change stayed.
+        // No includeType recorded ⇒ unknown target ⇒ not rewindable.
+        if (tool === 'sap_set_class_include') {
+            const includeType = pickString(args, 'includeType');
+            return includeType
+                ? { object: object.toUpperCase(), objType: includeSnapshotType(includeType) }
+                : null;
+        }
+        return { object: object.toUpperCase(), objType: 'CLAS' };
     }
     const object = pickString(args, 'name') ?? pickString(args, 'object_name');
     if (!object)

package/dist/rewind/restore.js

@@ -27,6 +27,7 @@ import { getEffectiveWriteMode } from '../repl/mode-cycle.js';
 import { effectiveRisk } from '../approvals/risk-floor.js';
 import { verifySyntax, verifyActive } from '../tools/verify.js';
 import { renderDiff } from '../repl/diff-display.js';
+import { parseIncludeSnapshotType } from '../tools/include-snapshot.js';
 /** Compact single-line failure text for receipts / error envelopes. */
 function shortError(err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -55,6 +56,10 @@ export async function restoreSnapshot(c, deps) {
     if (c.snapshotId === null) {
         return { ok: false, steps, error: 'no snapshot to restore from' };
     }
+    // A class-include candidate (objType CLAS.<INCLUDE>) restores that include;
+    // syntax check / activation / verify then run on the CLASS.
+    const include = parseIncludeSnapshotType(c.objType);
+    const repoType = include ? 'CLAS' : c.objType;
     // ── Step 2: Read the snapshot source (the content we will restore) ────────
     let snapshotSource;
     try {
@@ -67,12 +72,23 @@ export async function restoreSnapshot(c, deps) {
     // A 404 means the object was deleted this session; current = null and we
     // will recreate it. Any OTHER read failure is NOT proof of absence — stop
     // rather than blindly treat it as a create.
+    // Class include candidates (objType CLAS.<INCLUDE>) read and write the
+    // include itself; there is no delete-restore for an include, so a 404 stops.
     let currentSource;
     try {
-        currentSource = await deps.adt.getSource(c.objType, c.object);
+        if (include) {
+            const inc = await deps.adt.classIncludes(c.object, include);
+            if (typeof inc !== 'string') {
+                return { ok: false, steps, error: 'could not read current include source' };
+            }
+            currentSource = inc;
+        }
+        else {
+            currentSource = await deps.adt.getSource(c.objType, c.object);
+        }
     }
     catch (err) {
-        if (err instanceof SapError && err.httpStatus === 404) {
+        if (err instanceof SapError && err.httpStatus === 404 && !include) {
             currentSource = null;
         }
         else {
@@ -87,7 +103,7 @@ export async function restoreSnapshot(c, deps) {
     const change = {
         op,
         object: c.object,
-        type: c.objType,
+        type: repoType,
         diff: renderDiff(currentSource ?? '', snapshotSource, {
             label: `${c.objType}/${c.object}`,
             syntaxHighlight: false,
@@ -143,20 +159,38 @@ export async function restoreSnapshot(c, deps) {
             return { ok: false, steps, error: `recreate failed: ${created.error ?? `HTTP ${created.httpStatus}`}` };
         }
     }
-    let writeResult;
-    try {
-        writeResult = await deps.adt.setSource(c.objType, c.object, snapshotSource, deps.transport);
-    }
-    catch (err) {
-        record('② written ✗');
-        return { ok: false, steps, error: `write failed: ${shortError(err)}` };
+    if (include) {
+        // Include restore: write the include back. setClassInclude reads its own
+        // write back and returns written:false on a discarded or refused PUT.
+        let incResult;
+        try {
+            incResult = await deps.adt.setClassInclude(c.object, include, snapshotSource, deps.transport);
+        }
+        catch (err) {
+            record('② written ✗');
+            return { ok: false, steps, error: `write failed: ${shortError(err)}` };
+        }
+        if (!incResult.written) {
+            record('② written ✗');
+            return { ok: false, steps, error: `write failed: ${incResult.error ?? `HTTP ${incResult.httpStatus}`}` };
+        }
     }
-    // setSource RETURNS (does not throw) on HTTP 4xx — check the return value,
-    // exactly as sap_set_source does.
-    if (writeResult.error || (writeResult.writeStatus !== undefined && writeResult.writeStatus >= 400)) {
-        const detail = writeResult.error ?? `HTTP ${writeResult.writeStatus}`;
-        record('② written ✗');
-        return { ok: false, steps, error: `write failed: ${detail}` };
+    else {
+        let writeResult;
+        try {
+            writeResult = await deps.adt.setSource(c.objType, c.object, snapshotSource, deps.transport);
+        }
+        catch (err) {
+            record('② written ✗');
+            return { ok: false, steps, error: `write failed: ${shortError(err)}` };
+        }
+        // setSource RETURNS (does not throw) on HTTP 4xx — check the return value,
+        // exactly as sap_set_source does.
+        if (writeResult.error || (writeResult.writeStatus !== undefined && writeResult.writeStatus >= 400)) {
+            const detail = writeResult.error ?? `HTTP ${writeResult.writeStatus}`;
+            record('② written ✗');
+            return { ok: false, steps, error: `write failed: ${detail}` };
+        }
     }
     record('② written ✓');
     // ── Step 7: Syntax check (Rule 10) — errors ⇒ STOP, do NOT activate ───────
@@ -167,7 +201,7 @@ export async function restoreSnapshot(c, deps) {
     // WRITE HAPPENED; only the verification/activation call failed to run.
     let syntax;
     try {
-        syntax = await verifySyntax(deps.adt, c.object, c.objType);
+        syntax = await verifySyntax(deps.adt, c.object, repoType);
     }
     catch (err) {
         record(`③ syntax — check failed to run: ${shortError(err)}`);
@@ -191,7 +225,7 @@ export async function restoreSnapshot(c, deps) {
     // ── Step 8: Activate + verify (Rule 10) ───────────────────────────────────
     let activation;
     try {
-        activation = await deps.adt.activate(c.objType, c.object);
+        activation = await deps.adt.activate(repoType, c.object);
     }
     catch (err) {
         record(`④ activate — call failed: ${shortError(err)}`);
@@ -217,7 +251,7 @@ export async function restoreSnapshot(c, deps) {
     // past the receipt.
     let active;
     try {
-        active = await verifyActive(deps.adt, c.object, c.objType);
+        active = await verifyActive(deps.adt, c.object, repoType);
     }
     catch (err) {
         active = { active: false, verifyError: shortError(err) };

package/dist/skill-catalog.js

@@ -19,36 +19,42 @@ export const SKILL_CATALOG = [
         category: 'Read / Analyze',
         description: 'Impact analysis before changes — traces usage, callers, transports',
         whenToUse: 'pick this for blast radius before a change (not /abap-explain — explain = teach the code)',
+        asks: 'which object? e.g. "ZCL_ORDER_UTILS" or "what breaks if I change ZSD_ORDER_RELEASE"',
     },
     {
         name: 'abap-explain',
         category: 'Read / Analyze',
         description: 'Understand an object — plain-language (default) or `technical` orientation (deps, tables, risks)',
         whenToUse: `plain teaching, or technical=fast orientation (not /abap-impact = blast radius)`,
+        asks: 'which object, plain or technical? e.g. "ZFI_DUNNING_SELECT in plain words"',
     },
     {
         name: 'abap-review',
         category: 'Read / Analyze',
         description: 'Read-only review across lenses: quality (default), performance, cloud-readiness',
         whenToUse: `grade source: quality (default) + performance/cloud lenses`,
+        asks: 'which object, and which lens? e.g. "ZCL_CREDIT_SVC for performance"',
     },
     {
         name: 'abap-clean-core',
         category: 'Read / Analyze',
         description: 'Clean-core decision & defense — recommend the clean-core-correct approach, classify the level (A/B/C/D), produce citable evidence; verifies live when connected. Read-only.',
         whenToUse: `pick this for "is this clean-core-OK?" decisions + defendable evidence (not /abap-review cloud lens — that grades code)`,
+        asks: 'which object or requirement? e.g. "can I add a field to VBAK the clean way"',
     },
     {
         name: 'abap-handover',
         category: 'Read / Analyze',
         description: 'Documentation for one object (`object` scope) or a whole package (`package` scope)',
         whenToUse: `object doc OR full package handover dossier`,
+        asks: 'which object or package? e.g. "package ZTEST_LAS, full handover"',
     },
     {
         name: 'abap-dump',
         category: 'Read / Analyze',
         description: 'Diagnose ABAP short dumps (ST22) and fix them — root cause, call stack, fix with approval; ask for "triage" for ranked read-only hypotheses',
         whenToUse: `pick this for any ST22 dump — diagnose + fix by default, say "triage" for read-only ranking (not /abap-incident — that's the full dump-to-transport pipeline)`,
+        asks: 'which dump? e.g. "the dump in ZFIN_DOC_JOURNAL this morning"',
     },
     // ── Modify / Fix ─────────────────────────────────────────────────────────
     {
@@ -56,48 +62,56 @@ export const SKILL_CATALOG = [
         category: 'Modify / Fix',
         description: 'Run ATC checks against an object and auto-fix findings with safety gates',
         whenToUse: `pick this for ad-hoc ATC fix on one object (not /abap-upgrade-fix — that's worklist-driven)`,
+        asks: 'which object or package? e.g. "ZCL_ORDER_UTILS, fix what is safe"',
     },
     {
         name: 'abap-refactor',
         category: 'Modify / Fix',
         description: 'Refactor a Z object in place — FORM→method, SELECT *→specific fields, guard clauses, inline DATA. Same architecture, cleaner code.',
         whenToUse: `pick this to clean up YOUR Z code, same architecture (not /abap-modernize — that rebuilds as RAP/Fiori)`,
+        asks: 'which object and what change? e.g. "ZLEGACY_FI_REPORT — add a net amount column"',
     },
     {
         name: 'abap-enhance',
         category: 'Modify / Fix',
         description: 'Extend SAP standard via BAdI implementations, enhancement spots, user exits',
         whenToUse: `pick this to hook into SAP-STANDARD code via BAdI/exit (not /abap-refactor — that's for YOUR Z code)`,
+        asks: 'which SAP object and what behaviour? e.g. "block goods issue when the credit check fails"',
     },
     {
         name: 'abap-extend-model',
         category: 'Modify / Fix',
         description: 'Add a field or @UI column to an EXISTING custom CDS view / DDLX metadata extension in place — anchored insertion, snapshot, syntax-check, activate, republish-if-needed. The Fiori Elements column-add.',
         whenToUse: `pick this to add a field/column to an EXISTING custom CDS/DDLX in place (not /abap-rap — that's a new stack; not /abap-refactor — that's ABAP code, not CDS)`,
+        asks: 'which view or BO, and what to add? e.g. "add ShippingPoint to the ZC_Delivery list"',
     },
     {
         name: 'abap-incident',
         category: 'Modify / Fix',
         description: 'End-to-end incident pipeline — dump to fix deployed to transport in one skill',
         whenToUse: `pick this for full ST22-to-transport pipeline with formal report (not /abap-dump — single fix only)`,
+        asks: 'the incident. e.g. "dump in ZOPEN_ORDER_REPORT, users blocked"',
     },
     {
         name: 'abap-test',
         category: 'Modify / Fix',
         description: 'Generate ABAP Unit test classes for existing code with dependency injection',
         whenToUse: `pick this to generate + run ABAP Unit tests (not /abap-eml — EML body only)`,
+        asks: 'which class? e.g. "unit tests for ZCL_CREDIT_SVC"',
     },
     {
         name: 'abap-eml',
         category: 'Modify / Fix',
         description: 'Write and test EML (Entity Manipulation Language) for RAP business objects',
         whenToUse: `pick this for EML inside a RAP context (not /abap-test — that's the test class)`,
+        asks: 'what the EML should do. e.g. "create a draft inspection and activate it"',
     },
     {
         name: 'abap-segw',
         category: 'Modify / Fix',
         description: 'Implement SEGW OData DPC_EXT method bodies — reads generated MPC/DPC base classes. SEGW project itself created in transaction SEGW. For S/4 1909+ RAP services use /abap-rap.',
         whenToUse: `pick this for DPC_EXT method bodies on an EXISTING SEGW project (ECC / older S/4; not /abap-rap — that's S/4 1909+ RAP; SEGW project + MPC/DPC must already exist)`,
+        asks: 'which project and operation? e.g. "GET_ENTITYSET for ZORDER_SRV"',
     },
     // ── Create / Generate ────────────────────────────────────────────────────
     {
@@ -105,30 +119,35 @@ export const SKILL_CATALOG = [
         category: 'Create / Generate',
         description: 'Generate ONE ABAP class / program / include from a clear scope — asks clarifying questions first per Forge Rule 1. For a full RAP stack use /abap-rap; for DDIC only use /abap-data-model.',
         whenToUse: `pick this for ONE class/program/include from clear scope (not /abap-rap — that's a full RAP stack; not /abap-data-model — that's DDIC only)`,
+        asks: 'what to build, or the scope. e.g. "all changes" after a design, or "a report of open orders by plant"',
     },
     {
         name: 'abap-rap',
         category: 'Create / Generate',
         description: 'Scaffold a complete RAP stack on S/4HANA 1909+ — table, CDS interface, projection, BDEF, BP class, SRVD, SRVB, DDLX, DCL. ECC/older S/4 → use /abap-segw.',
         whenToUse: `pick this for a full RAP stack on S/4 1909+ (10 objects, table → SRVB; not /abap-segw — that's ECC/older S/4 OData; not /abap-generate — that's one object)`,
+        asks: 'the business object. e.g. "maintenance requests with draft and an approve action"',
     },
     {
         name: 'abap-fiori-build',
         category: 'Create / Generate',
         description: 'Build a working freestyle SAPUI5 app on the laptop from a published OData service — scaffold, pages, dialogs, chart, value help, local preview. Freestyle only, not Fiori Elements.',
         whenToUse: `pick this for a freestyle UI5 frontend on a published OData service (not /abap-rap — that's the backend; produces local files, not ADT objects)`,
+        asks: 'which service and what UI? e.g. "list + object page on ZUI_LAS_INSPECTIONLOG_O4"',
     },
     {
         name: 'abap-data-model',
         category: 'Create / Generate',
         description: 'Design and create DDIC objects — domains, data elements, tables, structures',
         whenToUse: `pick this for DDIC ONLY — domain/data element/table/structure (step after /abap-design; embedded inside /abap-rap step 1 — call standalone when you don't need the rest of the stack)`,
+        asks: 'the tables and fields. e.g. "inspection results, header and items"',
     },
     {
         name: 'abap-modernize',
         category: 'Create / Generate',
         description: 'Transform classic ABAP to the best modern architecture for the target release (ECC→SEGW, S/4→RAP)',
         whenToUse: `pick this to rebuild a WRITE/dynpro/FM as Fiori/RAP (not /abap-upgrade-fix — that's syntax patches)`,
+        asks: 'which program? e.g. "ZLEGACY_SD_PROCESS onto a modern stack"',
     },
     // ── Upgrade / Migrate ────────────────────────────────────────────────────
     {
@@ -136,42 +155,49 @@ export const SKILL_CATALOG = [
         category: 'Upgrade / Migrate',
         description: 'Custom code analysis pipeline for S/4 upgrade — whole-estate inventory + tier classification + ATC findings + report. Multi-session project with state file.',
         whenToUse: `pick this to discover + classify the whole custom estate (not /abap-migrate — that's per object)`,
+        asks: 'which package or namespace? e.g. "Z*" or "package ZTEST_LAS"',
     },
     {
         name: 'abap-upgrade-scan',
         category: 'Upgrade / Migrate',
         description: 'Scan custom ABAP code for S/4HANA upgrade findings via ATC readiness variant',
         whenToUse: 'pick this to baseline ATC for one package + S/4 release (step 1 of 3 — feeds /abap-upgrade-fix)',
+        asks: 'the scope. e.g. "package ZTEST_LAS" or "Z* with the S/4 readiness variant"',
     },
     {
         name: 'abap-upgrade-fix',
         category: 'Upgrade / Migrate',
         description: 'AI-guided upgrade remediation — fixes ATC findings one object at a time with approval gates',
         whenToUse: 'pick this to fix the upgrade-scan baseline object-by-object (step 2 of 3 — needs /abap-upgrade-scan first)',
+        asks: 'which findings. e.g. "@upgrade-progress" or "the API findings in ZCL_ORDER_UTILS"',
     },
     {
         name: 'abap-upgrade-verify',
         category: 'Upgrade / Migrate',
         description: 'Verify remediation results — re-runs ATC with same variant, compares before/after finding counts',
         whenToUse: 'pick this for the customer sign-off report after fixing (step 3 of 3 — re-runs ATC vs baseline)',
+        asks: 'which scan to verify against. e.g. "@upgrade-progress from the first scan"',
     },
     {
         name: 'abap-upgrade-merge',
         category: 'Upgrade / Migrate',
         description: 'Reconcile multiple parallel /abap-upgrade-fix progress files into one consolidated upgrade-progress',
         whenToUse: 'pick this when a multi-dev team ran scoped fix slices in parallel — merges N progress files for /abap-upgrade-verify',
+        asks: 'which progress files. e.g. "merge the three @upgrade-progress files here"',
     },
     {
         name: 'abap-cca-merge',
         category: 'Upgrade / Migrate',
         description: 'Reconcile multiple parallel /abap-cca assessment files into one consolidated cca-assessment',
         whenToUse: 'pick this when multiple consultants ran scoped /abap-cca slices — merges N assessments into one team view',
+        asks: 'which assessments. e.g. "merge the ZFI and ZSD cca files"',
     },
     {
         name: 'abap-migrate',
         category: 'Upgrade / Migrate',
         description: 'ECC to S/4HANA migration assessment — API analysis, clean-core alignment, migration path',
         whenToUse: `pick this to pick retire/replace/refactor per object (not /abap-cca — cca discovers them)`,
+        asks: 'which objects. e.g. "package ZLEGACY, ECC to S/4"',
     },
     // ── Ship / Release ───────────────────────────────────────────────────────
     {
@@ -179,18 +205,21 @@ export const SKILL_CATALOG = [
         category: 'Ship / Release',
         description: 'Transport management — create, list, validate, release transport requests',
         whenToUse: `pick this to CREATE/LIST/RELEASE a TR (inspect-only? use /abap-transport-analysis)`,
+        asks: 'what to do. e.g. "create a transport for this session" or "release S4HK903449"',
     },
     {
         name: 'abap-transport-analysis',
         category: 'Ship / Release',
         description: 'Pre-release transport analysis — objects, ATC scan, activation status, conflict check',
         whenToUse: `pick this if you have a TR NUMBER and want a read-only safety scan`,
+        asks: 'which transport. e.g. "S4HK903449 before it goes to QA"',
     },
     {
         name: 'abap-preflight',
         category: 'Ship / Release',
         description: 'Pre-release checklist — ATC, syntax, inactive objects, transport conflicts',
         whenToUse: `pick this for a full ship-readiness package on a CHANGE SET (no TR# needed)`,
+        asks: 'what is going out. e.g. "the objects in S4HK903449"',
     },
     // ── Pre-Coding ───────────────────────────────────────────────────────────
     {
@@ -198,24 +227,28 @@ export const SKILL_CATALOG = [
         category: 'Pre-Coding',
         description: 'Find missing requirements before coding — business questions, technical gaps, assumptions',
         whenToUse: `pick this for missing business + technical questions on a vague spec (step 1 of 3 — feeds /abap-design)`,
+        asks: 'the requirement. e.g. paste the ticket text, or "@spec.pdf"',
     },
     {
         name: 'abap-design',
         category: 'Pre-Coding',
         description: 'Solution architecture — object list, dependency sequence, patterns, transport strategy. Plans the build, does not generate code.',
         whenToUse: `pick this for the object list + dependency sequence + pattern choices (step 2 of 3 — needs /abap-spec-gap done, feeds /abap-estimate or /abap-generate)`,
+        asks: 'the requirement, once the gaps are closed. e.g. "the inspection log from the spec above"',
     },
     {
         name: 'abap-estimate',
         category: 'Pre-Coding',
         description: 'Effort estimation for ABAP tickets — component breakdown with hour ranges (optimistic / realistic / pessimistic) + risk adjustments',
         whenToUse: `pick this for hour ranges + risk adjustments on a confirmed object list (step 3 of 3 — needs /abap-design first; high uncertainty without it)`,
+        asks: 'what to estimate. e.g. "the objects from the design above" or "all changes in this ticket"',
     },
     {
         name: 'abap-plan',
         category: 'Pre-Coding',
         description: 'Multi-session project plan — phase envelope holds state across sessions; create from a goal or spec-gap file, resume one bounded phase per session',
         whenToUse: `pick this when the work spans multiple sessions or components (not /abap-design — that's one design in one session; plan calls design per phase)`,
+        asks: 'the goal, or a plan to resume. e.g. "build the inspection log end to end"',
     },
 ];
 /**

package/dist/skills/bundled-skills.js

@@ -1,6 +1,6 @@
 // GENERATED FILE — bundled skills for local mode.
 // Source: https://manifest.cspeach.dev/v1.json
-// Generated: 2026-09-17T21:24:04.334Z
+// Generated: 2026-09-23T17:28:19.737Z
 // Manifest signature verified at build time.
 export const BUNDLED_SKILLS = {
     "abap-atc-fix": {