@cspeach/cli 0.6.0

package/dist/session/resume.js

@@ -0,0 +1,77 @@
+import { select } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { listSessions, loadSession } from './store.js';
+import { formatTimeAgo } from './time-ago.js';
+import { runRepl } from '../repl.js';
+export async function runResume(id) {
+    let targetId = id;
+    if (!targetId) {
+        const sessions = await listSessions(20);
+        if (sessions.length === 0) {
+            console.log('No recent sessions.');
+            return 0;
+        }
+        // Promote interrupted sessions to the top of the list — they're the
+        // ones the user is most likely looking for after a crash.
+        const sorted = [...sessions].sort((a, b) => {
+            if (a.interrupted !== b.interrupted)
+                return a.interrupted ? -1 : 1;
+            return b.lastTurnAt.localeCompare(a.lastTurnAt);
+        });
+        targetId = await select({
+            message: 'Pick a session to resume:',
+            choices: sorted.map((s) => {
+                const flag = s.interrupted ? chalk.yellow('⚠ ') : '  ';
+                const idCol = chalk.cyan(s.id.padEnd(8));
+                const timeCol = chalk.gray(formatTimeAgo(s.lastTurnAt).padEnd(10));
+                const sapCol = chalk.gray((s.sapSystem ?? '-').padEnd(8));
+                const skillCol = chalk.gray(`/${s.skill ?? '-'}`.padEnd(22));
+                const turns = chalk.gray(`${s.userTurnCount}t`.padStart(3));
+                const snippet = s.promptSnippet ?? chalk.dim('(no prompt)');
+                return {
+                    value: s.id,
+                    name: `${flag}${idCol} ${timeCol} ${sapCol} ${skillCol} ${turns}  ${snippet}`,
+                    description: s.interrupted
+                        ? `Interrupted (${s.interruptedReason ?? 'unknown'}) — type "continue" after resume`
+                        : `${s.userTurnCount} prior turn(s) — pick up from where you left off`,
+                };
+            }),
+        });
+    }
+    let session;
+    try {
+        session = await loadSession(targetId);
+    }
+    catch (err) {
+        console.error(chalk.red(`\n[error] ${err.message}\n`));
+        return 1;
+    }
+    const unfinished = session.toolCalls.filter((c) => !c.completed);
+    if (unfinished.length > 0) {
+        console.log(chalk.yellow(`\n⚠  ${unfinished.length} pending mutation(s) from the previous session:\n`));
+        for (const u of unfinished) {
+            console.log(`  ${u.tool} ${JSON.stringify(u.args)}`);
+        }
+        const action = await select({
+            message: 'Reconcile how?',
+            choices: [
+                { value: 'reconcile', name: 'Query SAP to find out what actually happened (requires SAP reachable)' },
+                { value: 'continue', name: 'Leave as unresolved, continue (risky)' },
+                { value: 'abandon', name: 'Abandon this session (file is kept on disk)' },
+            ],
+        });
+        if (action === 'abandon')
+            return 0;
+        if (action === 'reconcile') {
+            console.log(chalk.gray('Reconciliation queries will run on the first turn of the resumed session.'));
+            console.log(chalk.gray('If SAP is unreachable, the pending entries remain and you can retry later.'));
+        }
+    }
+    // v0.6 — actually feed the loaded SessionState into the REPL so the agent
+    // loop sees prior messages, usage counters, and the turnInterrupted flag.
+    // Previously this dropped into a fresh REPL and only the on-disk file was
+    // kept (a stub from v0.1). Now resume genuinely picks up where the prior
+    // turn left off — including mid-turn-interrupted ones recoverable thanks
+    // to the persistence work in agent/loop.ts.
+    return runRepl({ resumedSession: session });
+}

package/dist/session/schema.js

@@ -0,0 +1,20 @@
+export const SCHEMA_VERSION = 1;
+export function newSession(id, sapSystem, skill, model) {
+    const now = new Date().toISOString();
+    return {
+        schema_version: SCHEMA_VERSION,
+        id,
+        started_at: now,
+        last_turn_at: now,
+        sap_system: sapSystem,
+        skill,
+        model,
+        messages: [],
+        toolCalls: [],
+        usage: { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0 },
+        last_skill: null,
+        last_object: null,
+        lastUserPrompt: null,
+        awaitingSkillAnswer: false,
+    };
+}

package/dist/session/store.js

@@ -0,0 +1,147 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { sessionsDir, pinnedSessionsDir } from '../config/paths.js';
+import { SCHEMA_VERSION } from './schema.js';
+export function makeSessionId() {
+    return crypto.randomBytes(4).toString('hex');
+}
+function sessionPath(id, startedAt) {
+    const dir = sessionsDir();
+    const stamp = startedAt.replace(/[:.]/g, '-');
+    return path.join(dir, `${stamp}-${id}.json`);
+}
+export async function saveSession(session) {
+    const dir = sessionsDir();
+    await fs.mkdir(dir, { recursive: true });
+    const filePath = sessionPath(session.id, session.started_at);
+    const tmp = filePath + '.tmp';
+    await fs.writeFile(tmp, JSON.stringify(session, null, 2), 'utf-8');
+    await fs.rename(tmp, filePath);
+}
+export async function loadSession(id) {
+    const dir = sessionsDir();
+    const files = await fs.readdir(dir).catch(() => []);
+    const match = files.find((f) => f.endsWith(`-${id}.json`));
+    if (!match) {
+        // Try pinned dir too
+        const pinnedDir = pinnedSessionsDir();
+        const pinned = await fs.readdir(pinnedDir).catch(() => []);
+        const pinnedMatch = pinned.find((f) => f.endsWith(`-${id}.json`));
+        if (!pinnedMatch)
+            throw new Error(`Session not found: ${id}`);
+        const raw = await fs.readFile(path.join(pinnedDir, pinnedMatch), 'utf-8');
+        return validateSchema(JSON.parse(raw));
+    }
+    const raw = await fs.readFile(path.join(dir, match), 'utf-8');
+    return validateSchema(JSON.parse(raw));
+}
+function validateSchema(parsed) {
+    if (parsed.schema_version > SCHEMA_VERSION) {
+        throw new Error(`SCHEMA_VERSION_MISMATCH: session v${parsed.schema_version} is newer than this CLI (v${SCHEMA_VERSION}). Run: cspeach --upgrade`);
+    }
+    if (parsed.schema_version < SCHEMA_VERSION) {
+        throw new Error(`Session schema is older (v${parsed.schema_version}). Auto-migration not yet implemented. Run: cspeach session export ${parsed.id} | wipe`);
+    }
+    // v0.3.1: `lastUserPrompt` added as a required field but older session
+    // files saved at this same SCHEMA_VERSION don't have it. Default
+    // undefined → null so the type contract (string | null) holds.
+    parsed.lastUserPrompt ??= null;
+    // 2026-05-01: heal sessions corrupted by interrupted streaming. A
+    // tool_use block that still has `partial_json` was mid-stream when the
+    // turn ended; replaying it to the API fails with HTTP 400
+    // "messages.N.content.M.tool_use.partial_json: Extra inputs are not
+    // permitted". Strip the field on load and parse it into `input` so the
+    // session becomes usable again instead of erroring on every next turn.
+    for (const msg of parsed.messages ?? []) {
+        if (!Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (block?.type === 'tool_use' && typeof block.partial_json === 'string') {
+                if (block.input === undefined) {
+                    try {
+                        block.input = JSON.parse(block.partial_json);
+                    }
+                    catch {
+                        block.input = {};
+                    }
+                }
+                delete block.partial_json;
+            }
+        }
+    }
+    return parsed;
+}
+export async function listSessions(limit = 10) {
+    const dir = sessionsDir();
+    const files = await fs.readdir(dir).catch(() => []);
+    const results = [];
+    for (const f of files) {
+        if (!f.endsWith('.json'))
+            continue;
+        try {
+            const raw = await fs.readFile(path.join(dir, f), 'utf-8');
+            const parsed = JSON.parse(raw);
+            const messages = parsed.messages ?? [];
+            // First user message that's a plain string (not a tool_result array) — the
+            // most recent prompt text that initiated a turn. We pick the LAST such
+            // message because the picker wants the freshest turn's prompt, not the
+            // first one of the session.
+            let promptSnippet = null;
+            for (let i = messages.length - 1; i >= 0; i--) {
+                const m = messages[i];
+                if (m && m.role === 'user' && typeof m.content === 'string') {
+                    // Strip <session_context>...</session_context> wrapper that the
+                    // first turn injects, leaving only the user-typed prompt visible
+                    // in the picker.
+                    const stripped = m.content.replace(/<session_context>[\s\S]*?<\/session_context>\s*/g, '').trim();
+                    promptSnippet = (stripped || '<empty>').slice(0, 80);
+                    break;
+                }
+            }
+            const userTurnCount = messages.filter((m) => m?.role === 'user' && typeof m.content === 'string').length;
+            results.push({
+                id: parsed.id,
+                startedAt: parsed.started_at,
+                lastTurnAt: parsed.last_turn_at,
+                skill: parsed.skill,
+                sapSystem: parsed.sap_system,
+                filename: f,
+                interrupted: parsed.turnInterrupted === true,
+                interruptedReason: parsed.turnInterruptedReason ?? null,
+                promptSnippet,
+                userTurnCount,
+            });
+        }
+        catch { /* skip corrupt */ }
+    }
+    results.sort((a, b) => b.lastTurnAt.localeCompare(a.lastTurnAt));
+    return results.slice(0, limit);
+}
+/**
+ * Count interrupted sessions for the startup banner. Reads only enough of each
+ * file to find the turnInterrupted flag, so it scales to many sessions without
+ * a full parse + sort pass. Returns 0 on any IO failure (best-effort discovery).
+ */
+export async function countInterruptedSessions() {
+    try {
+        const dir = sessionsDir();
+        const files = await fs.readdir(dir).catch(() => []);
+        let count = 0;
+        for (const f of files) {
+            if (!f.endsWith('.json'))
+                continue;
+            try {
+                const raw = await fs.readFile(path.join(dir, f), 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (parsed.turnInterrupted === true)
+                    count++;
+            }
+            catch { /* skip corrupt */ }
+        }
+        return count;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/session/time-ago.js

@@ -0,0 +1,41 @@
+/**
+ * Compact "time ago" formatter for session-picker rows.
+ *
+ * Produces strings like:
+ *   "12s ago"
+ *   "5m ago"
+ *   "3h ago"
+ *   "yesterday"
+ *   "3d ago"
+ *   "2w ago"
+ *
+ * Output stays under 12 characters so it fits cleanly in a fixed-width column.
+ */
+export function formatTimeAgo(then, now = new Date()) {
+    const t = typeof then === 'string' ? new Date(then) : then;
+    if (isNaN(t.getTime()))
+        return '?';
+    const diffMs = Math.max(0, now.getTime() - t.getTime());
+    const sec = Math.floor(diffMs / 1000);
+    if (sec < 60)
+        return `${sec}s ago`;
+    const min = Math.floor(sec / 60);
+    if (min < 60)
+        return `${min}m ago`;
+    const hr = Math.floor(min / 60);
+    if (hr < 24)
+        return `${hr}h ago`;
+    // 24h–47h59m ago = "yesterday"; 2-6 days = "3d ago"; 7+ = "2w ago"
+    const day = Math.floor(hr / 24);
+    if (day === 1)
+        return 'yesterday';
+    if (day < 7)
+        return `${day}d ago`;
+    const wk = Math.floor(day / 7);
+    if (wk < 5)
+        return `${wk}w ago`;
+    const mo = Math.floor(day / 30);
+    if (mo < 12)
+        return `${mo}mo ago`;
+    return `${Math.floor(day / 365)}y ago`;
+}

package/dist/skill-catalog.js

@@ -0,0 +1,222 @@
+/**
+ * Static skill catalog for CSPeach CLI v0.2.
+ *
+ * STALENESS RISK (spec §3.3): This constant is hardcoded against the 33 skills
+ * in .claude/skills/ as of 2026-04-19. It will drift if skills are added or
+ * removed. At Plan 4b kickoff decision the build-time generation option
+ * (scripts/generate-skill-catalog.ts reads SKILL.md frontmatter) or runtime
+ * fetch (/v1/skills endpoint) will be chosen to replace this file. Until then,
+ * update this file manually when the skill roster changes.
+ */
+export const SKILL_CATALOG = [
+    // ── Read / Analyze ───────────────────────────────────────────────────────
+    {
+        name: 'abap-radar',
+        category: 'Read / Analyze',
+        description: 'Understand an ABAP object quickly — dependencies, tables, risk areas, modernisation summary',
+        whenToUse: 'pick this for a 3-min cold read of an object (not /abap-review — no quality grade)',
+    },
+    {
+        name: 'abap-impact',
+        category: 'Read / Analyze',
+        description: 'Impact analysis before changes — traces usage, callers, transports',
+        whenToUse: 'pick this for blast radius before a change (not /abap-radar — radar = inside the object)',
+    },
+    {
+        name: 'abap-explain',
+        category: 'Read / Analyze',
+        description: 'Plain-language explanation of ABAP code for juniors, non-ABAP developers, or architects',
+        whenToUse: `pick this to teach code to a human (not /abap-document — that's a dev reference doc)`,
+    },
+    {
+        name: 'abap-review',
+        category: 'Read / Analyze',
+        description: 'Code review against 7 quality criteria: conventions, performance, security, error handling, tests, cloud-readiness, comments',
+        whenToUse: `pick this to grade SOURCE against 7 criteria (not a release gate — see /abap-preflight)`,
+    },
+    {
+        name: 'abap-performance',
+        category: 'Read / Analyze',
+        description: 'Identify N+1 queries, missing indexes, SELECT *, FOR ALL ENTRIES pitfalls',
+        whenToUse: 'pick this for deep SQL/loop bottleneck hunt (not /abap-review — review only skims perf)',
+    },
+    {
+        name: 'abap-cloud-check',
+        category: 'Read / Analyze',
+        description: 'ABAP Cloud / Clean Core readiness — restricted APIs, tier violations, released object alternatives',
+        whenToUse: `pick this for ABAP Cloud verdict on one object (not /abap-cca — that's whole-system)`,
+    },
+    {
+        name: 'abap-handover',
+        category: 'Read / Analyze',
+        description: 'Generate technical documentation for ABAP objects or a complete development package',
+        whenToUse: `pick this for a whole-package handover dossier (not /abap-document — that's one object)`,
+    },
+    {
+        name: 'abap-document',
+        category: 'Read / Analyze',
+        description: 'Reference doc for ONE ABAP object — purpose, interface, logic flow, dependencies, where-used',
+        whenToUse: `pick this for a reference doc on ONE object (not /abap-handover — that's whole-package)`,
+    },
+    {
+        name: 'abap-dump-analyze',
+        category: 'Read / Analyze',
+        description: 'Analyze ABAP short dumps (ST22) — root cause, call stack, fix suggestions',
+        whenToUse: `pick this to diagnose an ST22 dump AND apply the fix (not /abap-dump-triage — read-only)`,
+    },
+    {
+        name: 'abap-dump-triage',
+        category: 'Read / Analyze',
+        description: 'Structured triage of a runtime dump — ranked hypotheses, what to inspect next, read-only',
+        whenToUse: `pick this for ranked dump hypotheses, read-only (not /abap-dump-analyze — that writes a fix)`,
+    },
+    // ── Modify / Fix ─────────────────────────────────────────────────────────
+    {
+        name: 'abap-atc-fix',
+        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)`,
+    },
+    {
+        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)`,
+    },
+    {
+        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)`,
+    },
+    {
+        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-analyze — single fix only)`,
+    },
+    {
+        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)`,
+    },
+    {
+        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)`,
+    },
+    {
+        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)`,
+    },
+    // ── Create / Generate ────────────────────────────────────────────────────
+    {
+        name: 'abap-generate',
+        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)`,
+    },
+    {
+        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)`,
+    },
+    {
+        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)`,
+    },
+    {
+        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)`,
+    },
+    // ── Upgrade / Migrate ────────────────────────────────────────────────────
+    {
+        name: 'abap-cca',
+        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)`,
+    },
+    {
+        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)',
+    },
+    {
+        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)',
+    },
+    {
+        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)',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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)`,
+    },
+    // ── Ship / Release ───────────────────────────────────────────────────────
+    {
+        name: 'abap-transport',
+        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)`,
+    },
+    {
+        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`,
+    },
+    {
+        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)`,
+    },
+    // ── Pre-Coding ───────────────────────────────────────────────────────────
+    {
+        name: 'abap-spec-gap',
+        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)`,
+    },
+    {
+        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)`,
+    },
+    {
+        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)`,
+    },
+];

package/dist/skills/bundled-skills.js

@@ -0,0 +1 @@
+export const BUNDLED_SKILLS = {};

package/dist/skills/canonical.js

@@ -0,0 +1,12 @@
+// MIRROR of cspeach-proxy/src/skills/signatures.ts canonicalise().
+// If you edit this file, edit the proxy copy identically and update the
+// golden vector in ./__tests__/canonical.test.ts. Drift = "manifest signature
+// invalid" for every non-managed user.
+export function canonicalise(v) {
+    if (v === null || typeof v !== 'object')
+        return JSON.stringify(v);
+    if (Array.isArray(v))
+        return '[' + v.map(canonicalise).join(',') + ']';
+    const keys = Object.keys(v).sort();
+    return '{' + keys.map(k => JSON.stringify(k) + ':' + canonicalise(v[k])).join(',') + '}';
+}

package/dist/skills/manifest-client.js

@@ -0,0 +1,93 @@
+import * as ed from '@noble/ed25519';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha512 } from '@noble/hashes/sha512';
+import { bytesToHex, concatBytes } from '@noble/hashes/utils';
+import { MANIFEST_PUBLIC_KEYS } from './signing-public-key.js';
+import { canonicalise } from './canonical.js';
+// @noble/ed25519 v2 requires an ed25519 sha512 hook.
+ed.etc.sha512Sync = (...m) => sha512(concatBytes(...m));
+export class ManifestClient {
+    manifestUrl;
+    constructor(manifestUrl) {
+        this.manifestUrl = manifestUrl;
+    }
+    async fetchManifest() {
+        let r;
+        try {
+            r = await fetch(this.manifestUrl, { signal: AbortSignal.timeout(10_000) });
+        }
+        catch (e) {
+            throw new Error(`manifest fetch failed (${this.manifestUrl}): ${e.message}`);
+        }
+        if (r.status === 503) {
+            const body = await r.json().catch(() => ({}));
+            const raw = String(body.error ?? 'server says not ready');
+            // Cap length — an untrusted server could flood the error message.
+            const safe = raw.length > 200 ? raw.slice(0, 200) + '…' : raw;
+            throw new Error(`manifest not yet published (HTTP 503): ${safe}`);
+        }
+        if (!r.ok)
+            throw new Error(`manifest fetch: HTTP ${r.status} from ${this.manifestUrl}`);
+        return await r.json();
+    }
+    async fetchAndVerifyManifest() {
+        const m = await this.fetchManifest();
+        const { signature, ...payload } = m;
+        const canonical = canonicalise(payload);
+        const canonicalBytes = new TextEncoder().encode(canonical);
+        if (MANIFEST_PUBLIC_KEYS.length === 0) {
+            throw new Error('manifest signature invalid: no manifest public keys available — run `npm run prebuild` or set CSPEACH_MANIFEST_PUBKEY_CURRENT');
+        }
+        let sigBytes;
+        try {
+            sigBytes = base64ToBytes(signature);
+        }
+        catch (e) {
+            throw new Error(`manifest signature invalid: signature is not valid base64 (${e.message})`);
+        }
+        // ed.verifyAsync with zip215=false (strict). Mirrors the proxy side at
+        // cspeach-proxy/src/skills/signatures.ts so signer and verifier share the
+        // same verification primitive. Strict mode rejects malleable signatures
+        // and identity-point public keys — the conservative choice for a
+        // user-controlled verifier facing a potentially hostile distribution path.
+        for (const keyB64 of MANIFEST_PUBLIC_KEYS) {
+            try {
+                const pubKey = base64ToBytes(keyB64);
+                const valid = await ed.verifyAsync(sigBytes, canonicalBytes, pubKey, { zip215: false });
+                if (valid)
+                    return m;
+            }
+            catch {
+                // fall through to next key or the final throw
+            }
+        }
+        throw new Error(`manifest signature invalid (tried ${MANIFEST_PUBLIC_KEYS.length} key(s); rotation window may have ended — upgrade CLI)`);
+    }
+    async fetchSkillBody(name, bodyUrl, opts) {
+        let r;
+        try {
+            r = await fetch(bodyUrl, { signal: AbortSignal.timeout(10_000) });
+        }
+        catch (e) {
+            throw new Error(`skill body fetch failed (${bodyUrl}): ${e.message}`);
+        }
+        if (!r.ok)
+            throw new Error(`skill body fetch: HTTP ${r.status} for ${name}`);
+        const j = await r.json();
+        if (!opts?.expectedSha256) {
+            throw new Error(`skill ${name}: fetchSkillBody called without expectedSha256 — refusing (no signed anchor)`);
+        }
+        // The server-claimed sha256 field is untrusted and not consulted. Only
+        // the recomputed hash over the delivered body bytes, compared against
+        // the manifest-anchored expected value, constitutes an integrity check.
+        const actualSha = bytesToHex(sha256(new TextEncoder().encode(j.body)));
+        if (opts.expectedSha256 !== actualSha) {
+            throw new Error(`skill ${name}: sha256 mismatch with manifest (manifest=${opts.expectedSha256}, computed=${actualSha}) — body may have been tampered in transit`);
+        }
+        return { name, body: j.body, sha256: actualSha, signature: '', signedAt: j.updated_at };
+    }
+}
+function base64ToBytes(b64) {
+    return new Uint8Array(Buffer.from(b64, 'base64'));
+}
+export const DEFAULT_MANIFEST_URL = process.env.CSPEACH_MANIFEST_URL ?? 'https://manifest.cspeach.dev/v1.json';

package/dist/skills/promotion-dispatch.js

@@ -0,0 +1,24 @@
+/**
+ * Parse `--from @<path>` from a slash-command argument string. The leading `@`
+ * is the file-attach convention used elsewhere in the CLI; supports
+ * double-quoted paths for filenames containing spaces.
+ *
+ * Returns { fromPath, rest } where rest is the original args with the matched
+ * `--from @<path>` token removed. Internal spacing between other tokens is
+ * preserved (so the caller's own parser still sees its expected word
+ * boundaries); only leading and trailing whitespace is trimmed.
+ *
+ * For the unmatched-and-no-flag case we trim consistently too — same contract
+ * as the matched case so consumers do not have to special-case whitespace.
+ */
+export function parseFromFlag(args) {
+    const re = /--from\s+@(?:"([^"]+)"|(\S+))/;
+    const m = re.exec(args);
+    if (!m)
+        return { fromPath: null, rest: args.replace(/^\s+|\s+$/g, '') };
+    const fromPath = m[1] ?? m[2];
+    const before = args.slice(0, m.index);
+    const after = args.slice(m.index + m[0].length);
+    const rest = (before + after).replace(/^\s+|\s+$/g, '');
+    return { fromPath, rest };
+}

package/dist/skills/signing-public-key.js

@@ -0,0 +1,4 @@
+// GENERATED FILE — do not edit by hand.
+// Build artifact: ed25519 public key for SKILL.md body verification.
+// Regenerated by `pnpm prebuild` on each release.
+export const MANIFEST_PUBLIC_KEYS = ['a7Qj8ibfLTj49kQRTn1DOE/UAExuoBgjhaXxf33+JPY='];