@cspeach/cli 1.1.10 → 1.1.11

package/dist/projects/workspace.js

@@ -373,6 +373,12 @@ export function resolveAtToken(args) {
     if (matches.length === 0) {
         return { kind: 'notFound', token, workspace };
     }
+    // 2026-09-17 — an EXACT filename beats substring siblings: `@spec.md`
+    // must not be "ambiguous" just because `old-spec.md` sits beside it.
+    const exact = matches.filter((f) => f.filename.toLowerCase() === lower);
+    if (exact.length === 1) {
+        return { kind: 'path', path: exact[0].path };
+    }
     return { kind: 'ambiguous', matches };
 }
 /**
@@ -442,6 +448,11 @@ export function resolveBareTokenInCwd(token, cwd) {
         return { kind: 'path', path: matchedFiles[0].path };
     }
     if (matchedFiles.length > 1) {
+        // 2026-09-17 — exact filename wins over substring siblings (see resolveAtToken).
+        const exact = matchedFiles.filter((f) => f.filename.toLowerCase() === lower);
+        if (exact.length === 1) {
+            return { kind: 'path', path: exact[0].path };
+        }
         return { kind: 'ambiguous', matches: matchedFiles };
     }
     return null;
@@ -545,10 +556,21 @@ export async function expandTextFileAttachments(userMessage, cwd, log) {
     const matches = [];
     let m;
     while ((m = tokenRe.exec(userMessage)) !== null) {
-        const token = m[1] ?? m[2] ?? '';
+        let token = m[1] ?? m[2] ?? '';
+        let match = m[0];
         if (token.length === 0)
             continue;
-        matches.push({ match: m[0], token, index: m.index });
+        // 2026-09-17 — an unquoted token keeps the sentence punctuation that
+        // follows it ("review @spec.docx, then …"); strip it so the file still
+        // resolves, and leave it in the message by shortening the match.
+        if (m[1] === undefined) {
+            const trail = /[,;:.!?)]+$/.exec(token);
+            if (trail && trail[0].length < token.length) {
+                token = token.slice(0, -trail[0].length);
+                match = match.slice(0, -trail[0].length);
+            }
+        }
+        matches.push({ match, token, index: m.index });
     }
     if (matches.length === 0)
         return userMessage;
@@ -557,6 +579,23 @@ export async function expandTextFileAttachments(userMessage, cwd, log) {
     const substitutions = [];
     for (const { match, token, index } of matches) {
         const resolved = await resolveAtTokenAsync(token, cwd);
+        // 2026-09-17 — say so when a reference does not attach. Before, an
+        // ambiguous or missing @file was left as literal text with no message,
+        // and the model guessed. Missing-file notes only for tokens that look
+        // like a supported file, so `user@company.com` stays silent.
+        if (resolved.kind === 'ambiguous') {
+            if (log) {
+                const names = resolved.matches.map((m) => m.filename).join(', ');
+                log(`(@${token} matches ${resolved.matches.length} files: ${names} — use the full name)`);
+            }
+            continue;
+        }
+        if (resolved.kind === 'notFound') {
+            if (log && isAttachableFilename(token.split(/[\\/]/).pop() ?? token)) {
+                log(`(@${token} not found — looked in ${cwd} and the workspace)`);
+            }
+            continue;
+        }
         if (resolved.kind !== 'path')
             continue;
         const path = resolved.path;

package/dist/repl/at-picker.js

@@ -24,6 +24,8 @@ import { withInquirer } from './inquirer-guard.js';
 import { inquirerTheme } from './inquirer-theme.js';
 import { ensureWorkspaceSync, listProjectFilesSync, isAttachableFilename } from '../projects/workspace.js';
 const CANCEL_VALUE = '__cspeach_cancel__';
+/** Subfolders never worth listing in the `@` picker (generated or vendored). */
+const SKIPPED_DIRS = new Set(['node_modules', 'cspeach-out', 'dist', 'build', 'target']);
 /**
  * 2026-06-06 (Ink picker parity): workspace listing + substring filter,
  * exported so the Ink FilePalette shares the same data + seeding
@@ -57,16 +59,15 @@ export function listWorkspaceFileChoices(opts) {
     catch {
         // fall through — still return whatever the cwd half yields
     }
-    // cwd half — top-level .txt/.md/.docx/.pdf only. Never throws.
+    // cwd half — .txt/.md/.docx/.pdf at the top level AND one level of
+    // subfolders (2026-09-17: a spec in `docs\` never showed in the picker).
+    // Subfolder entries are listed as `docs/spec.docx`, which the resolver
+    // already treats as a cwd-relative path. Never throws.
     const cwd = opts?.cwd ?? process.cwd();
     try {
         for (const name of readdirSync(cwd)) {
             if (name.startsWith('.'))
                 continue; // dotfiles/dirs (incl. .cspeach)
-            if (!isAttachableFilename(name))
-                continue;
-            if (seen.has(name))
-                continue; // workspace already has it
             const full = join(cwd, name);
             let stat;
             try {
@@ -75,6 +76,42 @@ export function listWorkspaceFileChoices(opts) {
             catch {
                 continue;
             }
+            if (stat.isDirectory()) {
+                if (SKIPPED_DIRS.has(name.toLowerCase()))
+                    continue;
+                let inner;
+                try {
+                    inner = readdirSync(full);
+                }
+                catch {
+                    continue;
+                }
+                for (const child of inner) {
+                    if (child.startsWith('.'))
+                        continue;
+                    if (!isAttachableFilename(child))
+                        continue;
+                    const rel = `${name}/${child}`;
+                    if (seen.has(rel))
+                        continue;
+                    let cstat;
+                    try {
+                        cstat = statSync(join(full, child));
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!cstat.isFile())
+                        continue;
+                    seen.add(rel);
+                    out.push({ filename: rel, mtimeMs: cstat.mtimeMs });
+                }
+                continue;
+            }
+            if (!isAttachableFilename(name))
+                continue;
+            if (seen.has(name))
+                continue; // workspace already has it
             if (!stat.isFile())
                 continue;
             seen.add(name);

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-17T17:10:00.533Z
+// Generated: 2026-09-17T18:08:02.382Z
 // Manifest signature verified at build time.
 export const BUNDLED_SKILLS = {
     "abap-atc-fix": {

package/dist/standards/standards-init.js

@@ -34,47 +34,21 @@ export const STANDARDS_INTERVIEW_QUESTIONS = [
         heading: 'Packages for new objects',
         message: 'Package(s) new objects belong in, e.g. ZFI_CORE (Enter to skip):',
     },
-    {
-        key: 'naming',
-        heading: 'Naming style',
-        message: 'Naming style for classes / methods / variables — e.g. "zcl_<area>_<noun>", Hungarian lv_/ls_/lt_ (Enter to skip):',
-    },
-    {
-        key: 'forbidden',
-        heading: 'Forbidden or discouraged statements',
-        message: 'Forbidden or discouraged statements, e.g. "no SELECT *", "no CALL TRANSACTION" (Enter to skip):',
-    },
-    {
-        key: 'atc_variant',
-        heading: 'ATC check variant',
-        message: 'ATC check variant name (Enter to skip):',
-    },
+    // 2026-09-17 (Laeeq): cut from ten questions to four. Naming style,
+    // forbidden statements, ATC variant, transport process, header template
+    // and unit-test expectation were prose for the model only — nothing read
+    // them — and modern ABAP defaults already cover them. Only what the
+    // customer alone knows, and that changes the generated code, is asked.
     {
         key: 'clean_core',
         heading: 'Clean core',
         message: 'Clean-core requirement:',
         choices: ['ABAP Cloud only', 'released APIs preferred', 'classic allowed', '(skip)'],
     },
-    {
-        key: 'transport_process',
-        heading: 'Transport / change process',
-        message: 'Transport / change process, e.g. "ChaRM, one TR per ticket" (Enter to skip):',
-    },
-    {
-        key: 'header_template',
-        heading: 'Code header template',
-        message: 'Required code header / comment template (Enter to skip):',
-    },
-    {
-        key: 'unit_tests',
-        heading: 'Unit tests',
-        message: 'Unit-test expectation:',
-        choices: ['required for all classes', 'business logic only', 'none', '(skip)'],
-    },
     {
         key: 'other',
         heading: 'Anything else',
-        message: 'Anything else CSPeach should follow (Enter to skip):',
+        message: 'Anything else CSPeach should follow, one line (Enter to skip):',
     },
 ];
 /** Header written at the top of an IMPORTED standards document. */
@@ -121,6 +95,66 @@ export async function writeStandardsFile(cwd, content) {
         return homePath;
     }
 }
+/** Sentinel choice in the import dropdown: fall back to a typed path. */
+export const TYPE_A_PATH = '__type_a_path__';
+const STANDARDS_SOURCE_EXTS = ['.md', '.txt', '.docx', '.pdf'];
+const SKIPPED_DIRS = new Set(['node_modules', 'cspeach-out', 'dist', 'build', 'target']);
+function isStandardsSource(name) {
+    const lower = name.toLowerCase();
+    if (lower === 'cspeach-standards.md')
+        return false; // the file we are about to write
+    return STANDARDS_SOURCE_EXTS.some((e) => lower.endsWith(e));
+}
+/**
+ * Files a team's standards document could plausibly be, relative to `cwd`:
+ * .md/.txt/.docx/.pdf at the top level and one level of subfolders
+ * (`docs/abap-guidelines.docx`), sorted by name. Never throws.
+ */
+export async function listStandardsCandidates(cwd) {
+    const out = [];
+    let entries;
+    try {
+        entries = await fs.readdir(cwd, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        if (e.name.startsWith('.'))
+            continue;
+        if (e.isFile()) {
+            if (isStandardsSource(e.name))
+                out.push(e.name);
+            continue;
+        }
+        if (!e.isDirectory() || SKIPPED_DIRS.has(e.name.toLowerCase()))
+            continue;
+        let inner;
+        try {
+            inner = await fs.readdir(path.join(cwd, e.name), { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const c of inner) {
+            if (c.name.startsWith('.') || !c.isFile() || !isStandardsSource(c.name))
+                continue;
+            out.push(`${e.name}/${c.name}`);
+        }
+    }
+    return out.sort((a, b) => a.localeCompare(b));
+}
+/** Read a standards source as text: Word / PDF through document extraction, otherwise UTF-8. */
+export async function readStandardsSource(src) {
+    const lower = src.toLowerCase();
+    if (lower.endsWith('.docx') || lower.endsWith('.pdf')) {
+        const { extractDocument } = await import('../tools/filesystem/extract-document.js');
+        const buf = await fs.readFile(src);
+        const res = await extractDocument(buf, lower.endsWith('.pdf') ? '.pdf' : '.docx', { maxPages: 150 });
+        return res.text;
+    }
+    return fs.readFile(src, 'utf8');
+}
 async function defaultPrompts() {
     const { input, select } = await import('@inquirer/prompts');
     return {
@@ -146,12 +180,34 @@ export async function runStandardsInit(cwd, prompts) {
         default: 'defaults',
     });
     if (route === 'import') {
-        const src = (await p.input({
-            key: 'source',
-            message: 'Path to the standards document (.md or .txt):',
-        })).trim();
+        // 2026-09-17 — offer the files we can see (cwd + one level of
+        // subfolders) as a dropdown before falling back to a typed path, and
+        // accept Word / PDF standards documents, not only .md/.txt.
+        const candidates = await listStandardsCandidates(cwd);
+        let src = '';
+        if (candidates.length > 0) {
+            const picked = await p.select({
+                key: 'source-pick',
+                message: 'Which file holds your standards?',
+                choices: [
+                    ...candidates.map((f) => ({ value: f, name: f })),
+                    { value: TYPE_A_PATH, name: 'Type a path…' },
+                ],
+                default: candidates[0],
+            });
+            // Anything that is not one of the offered files (or the sentinel) falls
+            // through to the typed-path prompt — never treat a stray answer as a path.
+            if (picked !== TYPE_A_PATH && candidates.includes(picked))
+                src = path.resolve(cwd, picked);
+        }
+        if (src.length === 0) {
+            src = (await p.input({
+                key: 'source',
+                message: 'Path to the standards document (.md, .txt, .docx or .pdf):',
+            })).trim();
+        }
         try {
-            const body = await fs.readFile(src, 'utf8');
+            const body = await readStandardsSource(src);
             const content = `${importedStandardsHeader(src)}\n\n${body.trim()}\n`;
             const written = await writeStandardsFile(cwd, content);
             console.log(chalk.green(`✓ Standards imported to ${displayStandardsPath(written, cwd)}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.10",
+  "version": "1.1.11",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, 34 skills, safety gates.",
   "keywords": [
     "abap",