@cspeach/cli 0.7.1 → 0.9.0

package/dist/projects/plan-schema.js

@@ -0,0 +1,150 @@
+// cspeach-cli/src/projects/plan-schema.ts
+//
+// Deep validation for the 'plan' artefact content (/abap-plan envelope).
+//
+// Split of responsibilities, matching the rest of the store:
+//   - validate.ts      — top-level envelope shape, hand-rolled (adds 'plan'
+//                        to its known types + status enum; content is opaque)
+//   - plan-schema.ts   — Zod schema for the PlanContent payload, invoked by
+//                        the --resume path before any phase is executed
+//
+// The TS interfaces live in types.ts with the other content shapes; the
+// `z.ZodType<PlanContent>` annotation below keeps schema and interface in
+// lockstep at compile time.
+import { z } from 'zod';
+/** Keep in sync with PlanLayer in types.ts. */
+export const PLAN_LAYERS = [
+    'types', 'persistence', 'data-model', 'behavior', 'service',
+    'orchestration', 'integration', 'ui',
+];
+/**
+ * Existing skills a phase may delegate to. Keep in sync with
+ * PlanDelegateSkill in types.ts. Extending = one entry here + one in the
+ * union there. Typical per-layer defaults (guidance lives in the
+ * abap-plan SKILL.md, not enforced here):
+ *   types/persistence → abap-data-model
+ *   data-model/behavior/service → abap-rap (abap-eml for handler logic)
+ *   orchestration/integration → abap-generate (abap-segw for ECC OData)
+ */
+export const PLAN_DELEGATE_SKILLS = [
+    'abap-design', 'abap-data-model', 'abap-rap', 'abap-eml',
+    'abap-generate', 'abap-segw', 'abap-test',
+];
+/** Keep in sync with ItemStatusByType['plan'] in types.ts. */
+export const PLAN_PHASE_STATUSES = [
+    'todo', 'designing', 'building', 'verifying', 'validated', 'blocked',
+];
+const SHA256_RE = /^[0-9a-f]{64}$/;
+const planPhaseManifestSchema = z.object({
+    reads: z.array(z.string()),
+    rules: z.array(z.string()),
+    writesBack: z.array(z.string()),
+});
+// .passthrough(): live smoke showed models enrich `work` with valuable
+// extras (blockedReason, unblockPath, groundingChecks) — strip mode was
+// silently discarding them from the persisted envelope.
+const planPhaseWorkSchema = z.object({
+    generated: z.array(z.string()).optional(),
+    transport: z.string().optional(),
+    snapshot: z.string().optional(),
+    notes: z.string().optional(),
+}).passthrough();
+const planPhaseSchema = z.object({
+    id: z.string().min(1),
+    component: z.string().min(1),
+    layer: z.enum(PLAN_LAYERS),
+    entryCriteria: z.array(z.string()),
+    delegateTo: z.enum(PLAN_DELEGATE_SKILLS),
+    manifest: planPhaseManifestSchema,
+    exitGate: z.string().min(1),
+    approval: z.boolean().optional(),
+    work: planPhaseWorkSchema.optional(),
+});
+// Input type is `unknown` (third param): the `.default({})` on `from` means
+// the schema ACCEPTS input without the key while still OUTPUTTING PlanContent.
+export const planContentSchema = z
+    .object({
+    project: z.object({
+        goal: z.string().min(1),
+        source: z.string(),
+        target: z.string(),
+    }),
+    // Tolerant by lesson (2026-06-06 live smoke): the model omitted the whole
+    // `from` key for a goal-only plan and the strict schema killed the save.
+    // Missing `from` normalises to {} — only the inner specGap ref is shaped.
+    from: z
+        .object({
+        specGap: z
+            .object({
+            path: z.string().min(1),
+            sha256: z.string().regex(SHA256_RE, 'must be a lowercase hex sha256'),
+        })
+            .optional(),
+    })
+        .default({}),
+    phases: z.array(planPhaseSchema).min(1),
+    summary: z.object({
+        total: z.number().int().nonnegative(),
+        validated: z.number().int().nonnegative(),
+        blocked: z.number().int().nonnegative(),
+        next: z.string().nullable(),
+    }),
+})
+    .superRefine((content, ctx) => {
+    // Phase ids must be unique, and entryCriteria may only reference phases
+    // EARLIER in the array. Bottom-up ordering by construction — this is what
+    // guarantees resume is deterministic and the dependency graph acyclic
+    // (a forward or self reference can never form, so no cycle can either).
+    const seen = new Set();
+    content.phases.forEach((p, i) => {
+        if (seen.has(p.id)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['phases', i, 'id'],
+                message: `Duplicate phase id: ${p.id}`,
+            });
+        }
+        p.entryCriteria.forEach((dep, j) => {
+            if (!seen.has(dep)) {
+                const known = content.phases.some((q) => q.id === dep);
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['phases', i, 'entryCriteria', j],
+                    message: known
+                        ? `entryCriteria '${dep}' must reference an earlier phase (plans are ordered bottom-up)`
+                        : `entryCriteria references unknown phase: ${dep}`,
+                });
+            }
+        });
+        seen.add(p.id);
+    });
+    if (content.summary.total !== content.phases.length) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['summary', 'total'],
+            message: `summary.total (${content.summary.total}) must equal phases.length (${content.phases.length})`,
+        });
+    }
+    if (content.summary.next !== null && !seen.has(content.summary.next)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['summary', 'next'],
+            message: `summary.next references unknown phase: ${content.summary.next}`,
+        });
+    }
+});
+/**
+ * Validate an unknown value as PlanContent. Returns flattened, path-prefixed
+ * error strings suitable for printing directly in the REPL — the --resume
+ * command bails on the first failed parse rather than executing a phase
+ * against a malformed plan.
+ */
+export function parsePlanContent(input) {
+    const r = planContentSchema.safeParse(input);
+    if (r.success)
+        return { ok: true, content: r.data };
+    return {
+        ok: false,
+        errors: r.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`),
+    };
+}

package/dist/projects/promote-command.js

@@ -18,6 +18,7 @@ const PREDECESSOR_BY_TARGET = {
     'abap-upgrade-verify': 'upgrade-progress',
     'abap-modernize': 'cca-assessment', // v0.7: new chain
     'abap-test': 'cca-assessment', // v0.7: new chain
+    'abap-plan': 'spec-gap', // B3: plan consumes answered gaps
 };
 function affirmative(reply) {
     const v = reply.trim().toLowerCase();

package/dist/projects/save-command.js

@@ -5,6 +5,7 @@ import { extractUpgradeScan, extractUpgradeProgress, extractUpgradeReport } from
 import { extractCcaAssessment } from './extract-cca.js';
 import { extractModernizeResult } from './extract-modernize.js';
 import { extractTestCoverage } from './extract-test-coverage.js';
+import { extractPlan } from './extract-plan.js';
 import { buildEnvelope } from './build.js';
 import { saveProject } from './save.js';
 import { renderEmailTemplate } from './email-template.js';
@@ -69,6 +70,15 @@ const SKILL_REGISTRY = {
         extract: (md) => extractTestCoverage(md),
         itemNoun: 'tests',
     },
+    'abap-plan': {
+        // 2026-06-06 B3: Mode 1 (create) save only. Mode 2 (--resume) turns
+        // suppress this hook (RunTurnParams.suppressSaveHook) and persist a
+        // REVISION of the existing envelope via commands/plan-resume.ts.
+        artefactType: 'plan',
+        extract: (md) => extractPlan(md),
+        itemNoun: 'phases',
+        manifestMarker: 'csforge:plan-manifest',
+    },
 };
 export async function runSaveCommand(args) {
     const spec = SKILL_REGISTRY[args.skillName];
@@ -78,7 +88,13 @@ export async function runSaveCommand(args) {
     try {
         extract = spec.extract(args.skillOutput);
     }
-    catch {
+    catch (e) {
+        if (spec.manifestMarker && args.skillOutput.includes(spec.manifestMarker)) {
+            args.log('');
+            args.log(`[save] ${args.skillName}: a ${spec.manifestMarker} block IS present but failed to parse — artefact NOT saved.`);
+            args.log(`[save] ${e instanceof Error ? e.message : String(e)}`);
+            args.log(`[save] The output above is otherwise complete — re-run the skill or report this as a manifest bug.`);
+        }
         return null;
     }
     const answer = (await args.prompt('Save as project file? [y/N]: ')).trim().toLowerCase();

package/dist/projects/status.js

@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { validateEnvelope } from './validate.js';
 import { canonicalSha256 } from './canonicalize.js';
+import { statusesFromItems, computeNextPhase, renderPlanTracker } from './plan-run.js';
 export function readProjectFile(path) {
     const raw = readFileSync(path, 'utf8');
     let parsed;
@@ -22,6 +23,7 @@ const STATUS_BY_TYPE = {
     'estimate': ['confirmed', 'disputed', 'deferred'],
     'cca': ['keep', 'fix', 'retire', 'redesign'],
     'incident': ['pending', 'done'],
+    'plan': ['validated', 'todo', 'designing', 'building', 'verifying', 'blocked'],
 };
 const PRIMARY_BY_TYPE = {
     'spec-gap': 'answered',
@@ -29,6 +31,7 @@ const PRIMARY_BY_TYPE = {
     'estimate': 'confirmed',
     'cca': 'keep',
     'incident': 'done',
+    'plan': 'validated',
 };
 const PROMOTE_HINT_BY_TYPE = {
     'spec-gap': '/abap-design --from',
@@ -36,6 +39,7 @@ const PROMOTE_HINT_BY_TYPE = {
     'estimate': null,
     'cca': null,
     'incident': null,
+    'plan': '/abap-plan --resume',
 };
 export function renderStatus(env) {
     const items = env.interaction.items;
@@ -85,6 +89,22 @@ export function renderStatus(env) {
             lines.push(`  ... ${stillOpen.length - 10} more`);
         lines.push('');
     }
+    // B3 (2026-06-06): plan envelopes get the phase tracker board — the same
+    // renderer the --resume flow prints before/after each phase. Header off:
+    // title + version were already printed above.
+    if (env.artefactType === 'plan') {
+        const content = env.content;
+        const statuses = statusesFromItems(items, content.phases);
+        lines.push(renderPlanTracker({
+            title: env.title,
+            version: env.version,
+            content,
+            statuses,
+            currentId: computeNextPhase(content.phases, statuses)?.id ?? null,
+            includeHeader: false,
+        }));
+        lines.push('');
+    }
     // Promote hint fires whenever a "next phase" exists for this artefactType.
     // Unlike the v1 implementation we no longer gate on `primaryCount > 0` —
     // a design with zero `keep` items (all `redesign` / `defer`) is still a

package/dist/projects/validate.js

@@ -5,6 +5,7 @@ const KNOWN_ARTEFACT_TYPES = [
     'upgrade-scan', 'upgrade-progress', 'upgrade-report',
     'cca-assessment',
     'modernize-result', 'test-coverage',
+    'plan',
 ];
 const STATUS_BY_TYPE = {
     'spec-gap': ['open', 'answered', 'deferred', 'n-a'],
@@ -18,6 +19,7 @@ const STATUS_BY_TYPE = {
     'cca-assessment': ['open', 'reviewed', 'classified', 'archived'],
     'modernize-result': ['applied', 'skipped', 'failed', 'pending'],
     'test-coverage': ['generated', 'skipped', 'failed', 'pending'],
+    'plan': ['todo', 'designing', 'building', 'verifying', 'validated', 'blocked'],
 };
 const REQUIRED_TOP_LEVEL = [
     'schemaVersion', 'artefactType', 'id', 'title',

package/dist/renderer/question-normalizer.js

@@ -74,26 +74,36 @@ function findBalancedJson(text, from) {
  * Returns the offset where the block begins in `text`.
  */
 function findBlockStart(text, jsonStart) {
-    let pos = jsonStart;
     // Walk backward over preceding lines that are empty, the sentinel, or
     // a fence-open marker. Stop on any line that has other content.
-    while (pos > 0) {
-        const prevNewline = text.lastIndexOf('\n', pos - 1);
+    //
+    // 2026-06-06 — rewritten to guarantee forward progress. The previous
+    // version set `pos = lineStart` and looped; when the `{` sat at the
+    // start of a line (lineStart === pos — the CANONICAL widget shape),
+    // pos never moved and the loop spun forever, pegging a core. The scan
+    // position now steps over the preceding newline each iteration
+    // (strictly decreasing), and the accepted block start is tracked
+    // separately so the return value is still a line-start offset.
+    let blockStart = jsonStart;
+    let scanEnd = jsonStart; // exclusive end of the line-chunk under examination
+    while (scanEnd > 0) {
+        const prevNewline = text.lastIndexOf('\n', scanEnd - 1);
         const lineStart = prevNewline === -1 ? 0 : prevNewline + 1;
-        const line = text.slice(lineStart, pos).trim();
+        const line = text.slice(lineStart, scanEnd).trim();
         if (line === '' ||
             line === SENTINEL ||
             /^```(?:cspeach-widget:\S+)?$/.test(line) ||
             /^````(?:cspeach-widget:\S+)?$/.test(line)) {
-            pos = lineStart;
+            blockStart = lineStart;
             if (prevNewline === -1)
                 break;
+            scanEnd = prevNewline; // step over the newline — strictly decreasing
         }
         else {
             break;
         }
     }
-    return pos;
+    return blockStart;
 }
 /**
  * Walk forward from `jsonEnd` (one past the closing `}`) to include a

package/dist/renderer/syntax.js

@@ -22,10 +22,25 @@
  * that object — the shape of the API is the same.
  */
 import { highlight } from 'cli-highlight';
-import hljs from 'highlight.js';
+import { createRequire } from 'node:module';
 import abapGrammar from './highlighters/abap.js';
 import cdsGrammar from './highlighters/cds.js';
 import bdefGrammar from './highlighters/bdef.js';
+// A5 fix (2026-06-06) — registration must hit the EXACT module instance
+// cli-highlight loads, and on this pnpm/Windows layout that is NOT what a
+// plain `import hljs from 'highlight.js'` (or even a local require)
+// resolves to. Diagnosed live: our resolution lands on the top-level
+// `node_modules/highlight.js` while cli-highlight requires its nested
+// `.pnpm/highlight.js@10.7.3/...` copy — node treats them as two separate
+// modules with separate language registries, so the grammars registered
+// on ours were invisible to cli-highlight and EVERY abap/cds/bdef block
+// silently fell back to unhighlighted echo ("Could not find the language
+// 'abap'") — in production as well as tests, since the first release.
+// Fix: chain createRequire through cli-highlight's own entry point so we
+// follow its resolution and register on the instance it actually uses.
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const hljs = createRequire(require.resolve('cli-highlight'))('highlight.js');
 // Module-load-time registration. The grammar modules export plain objects
 // (shape matches highlight.js `Language` definition). Cast is safe — the
 // grammars match the runtime contract even when strict typings drift.

package/dist/renderer/thinking-heartbeat.js

@@ -29,7 +29,7 @@
  * fallback.
  */
 import chalk from 'chalk';
-const THRESHOLDS_MS = [
+const LLM_THRESHOLDS = [
     { at: 3_000, label: 'thinking…' },
     { at: 10_000, label: 'thinking… (10s)' },
     { at: 30_000, label: 'thinking… (30s)' },
@@ -39,10 +39,22 @@ const THRESHOLDS_MS = [
     { at: 180_000, label: 'thinking… (3m — Ctrl+C is recommended; the stream may have stalled)' },
     { at: 300_000, label: 'thinking… (5m — Ctrl+C and try again)' },
 ];
+/** Suffixes for labelled (tool / hook) waits — appended to opts.label. */
+const GENERIC_SUFFIXES = [
+    { at: 3_000, suffix: '' },
+    { at: 10_000, suffix: ' (10s)' },
+    { at: 30_000, suffix: ' (30s)' },
+    { at: 60_000, suffix: ' (60s — still running, hold on)' },
+    { at: 120_000, suffix: ' (2m — still running; Ctrl+C aborts the turn)' },
+    { at: 300_000, suffix: ' (5m — likely stuck; Ctrl+C and check the VPN)' },
+];
 export function startThinkingHeartbeat(opts) {
     const startedAt = Date.now();
     let nextIdx = 0;
     let stopped = false;
+    const THRESHOLDS_MS = opts?.label
+        ? GENERIC_SUFFIXES.map((t) => ({ at: t.at, label: `${opts.label}${t.suffix}` }))
+        : LLM_THRESHOLDS;
     const emitLine = (line) => {
         if (opts?.chunkEmitter) {
             // Phase A #4 — route through Ink's chunk pipeline. The Body

package/dist/repl/at-picker.js

@@ -22,6 +22,27 @@ import { withInquirer } from './inquirer-guard.js';
 import { inquirerTheme } from './inquirer-theme.js';
 import { ensureWorkspaceSync, listProjectFilesSync } from '../projects/workspace.js';
 const CANCEL_VALUE = '__cspeach_cancel__';
+/**
+ * 2026-06-06 (Ink picker parity): workspace listing + substring filter,
+ * exported so the Ink FilePalette shares the same data + seeding
+ * semantics as this classic inquirer picker.
+ */
+export function listWorkspaceFileChoices() {
+    try {
+        const ws = ensureWorkspaceSync();
+        return listProjectFilesSync(ws).map((f) => ({ filename: f.filename, mtimeMs: f.mtimeMs }));
+    }
+    catch {
+        return [];
+    }
+}
+/** Substring filter; empty prefix returns everything. */
+export function filterFileChoices(prefix, all) {
+    const lower = prefix.trim().toLowerCase();
+    return lower.length === 0
+        ? [...all]
+        : all.filter((f) => f.filename.toLowerCase().includes(lower));
+}
 /**
  * Open the at-picker pre-filtered to `prefix`. Returns the picked
  * filename (no leading @), or null on cancel / empty-workspace.
@@ -31,21 +52,11 @@ const CANCEL_VALUE = '__cspeach_cancel__';
  * (bare `@`) seeds the picker with all workspace files.
  */
 export async function openAtPicker(prefix) {
-    let allFiles;
-    try {
-        const ws = ensureWorkspaceSync();
-        allFiles = listProjectFilesSync(ws).map((f) => ({ filename: f.filename, mtimeMs: f.mtimeMs }));
-    }
-    catch {
-        allFiles = [];
-    }
+    const allFiles = listWorkspaceFileChoices();
     if (allFiles.length === 0) {
         return null;
     }
-    const lowerPrefix = prefix.trim().toLowerCase();
-    const seeded = lowerPrefix.length === 0
-        ? allFiles
-        : allFiles.filter((f) => f.filename.toLowerCase().includes(lowerPrefix));
+    const seeded = filterFileChoices(prefix, allFiles);
     // Single unique match — short-circuit, save the user a keystroke. Same
     // shortcut openSlashPicker uses.
     if (seeded.length === 1) {
@@ -95,7 +106,7 @@ export async function openAtPicker(prefix) {
  * null when the line doesn't end with an @-token or the token already
  * resolves exactly.
  */
-export function pendingAtTokenPrefix(trimmed) {
+export function pendingAtTokenPrefix(trimmed, knownFilenames) {
     // Match the rightmost @<word> at the end of the line. \S+ means
     // non-whitespace only — `@filename with space` is not auto-detected
     // (user can quote with `@"name with space"` for those, handled by
@@ -106,16 +117,24 @@ export function pendingAtTokenPrefix(trimmed) {
     const prefix = m[1] ?? '';
     // If the prefix already exactly matches a workspace filename, the
     // existing @-resolution will pick it up — don't open the picker.
+    // `knownFilenames` lets callers (Ink pipeline, tests) inject the
+    // listing instead of hitting the filesystem here.
     if (prefix.length > 0) {
-        try {
-            const ws = ensureWorkspaceSync();
-            const files = listProjectFilesSync(ws);
-            const exact = files.some((f) => f.filename === prefix);
-            if (exact)
+        if (knownFilenames) {
+            if (knownFilenames.includes(prefix))
                 return null;
         }
-        catch {
-            // Fall through — open picker as a safe default.
+        else {
+            try {
+                const ws = ensureWorkspaceSync();
+                const files = listProjectFilesSync(ws);
+                const exact = files.some((f) => f.filename === prefix);
+                if (exact)
+                    return null;
+            }
+            catch {
+                // Fall through — open picker as a safe default.
+            }
         }
     }
     return prefix;

package/dist/repl/slash-picker.js

@@ -44,6 +44,20 @@ function buildCatalogue() {
     return [...BUILTIN_ENTRIES, ...skillEntries].sort((a, b) => a.name.localeCompare(b.name));
 }
 const ALL_ENTRIES = buildCatalogue();
+/**
+ * 2026-06-06 (Ink picker parity): the full command catalogue (builtins +
+ * skills) and the substring pre-filter, exported so the Ink CommandPalette
+ * shares the exact same data + seeding semantics as the classic inquirer
+ * picker instead of maintaining a drifting copy.
+ */
+export const ALL_SLASH_ENTRIES = ALL_ENTRIES;
+/** Substring filter over the catalogue; empty prefix returns everything. */
+export function filterSlashEntries(prefix) {
+    const lower = prefix.trim().toLowerCase();
+    return lower.length === 0
+        ? [...ALL_ENTRIES]
+        : ALL_ENTRIES.filter((e) => e.name.toLowerCase().includes(lower));
+}
 /**
  * Open the slash picker. Returns the picked command WITHOUT a leading
  * slash (caller is expected to construct the full prompt) or null if
@@ -58,10 +72,7 @@ export async function openSlashPicker(prefix) {
     // contains the typed prefix as a substring — substring rather than
     // startsWith because users often remember a fragment in the middle of
     // a name (e.g. 'fix' should bring up /abap-atc-fix and /abap-upgrade-fix).
-    const lowerPrefix = prefix.trim().toLowerCase();
-    const seeded = lowerPrefix.length === 0
-        ? ALL_ENTRIES
-        : ALL_ENTRIES.filter((e) => e.name.toLowerCase().includes(lowerPrefix));
+    const seeded = filterSlashEntries(prefix);
     // If the prefix narrows down to exactly one command, just return it
     // without opening a picker — saves the user a keystroke.
     if (seeded.length === 1) {