@cspeach/cli 0.6.0

package/dist/project-context/render.js

@@ -0,0 +1,308 @@
+/**
+ * Token-budgeted prompt rendering for ProjectContext.
+ *
+ * Phase 2's hook (`maybeBuildProjectContext` in agent/loop.ts) will
+ * inject this string verbatim into the system prompt when the
+ * CSPEACH_PROJECT_CONTEXT flag is on. We must therefore stay within
+ * a tight budget — too much context displaces the actual skill body.
+ *
+ * Targets:
+ *   ~3,000 tokens TOTAL on a medium-sized project
+ *   header / conventions: ~200 tokens
+ *   sap connection: ~200 tokens
+ *   git: ~150 tokens
+ *   file index: ~600 tokens (capped sample of paths)
+ *   domain objects: ~1,800 tokens (per-category caps)
+ *
+ * We don't have a tokenizer at hand and don't want to ship one for this
+ * render alone. We approximate via character budgets calibrated against
+ * a 4-chars-per-token rough rule. Anything that overshoots gets
+ * truncation markers like `... (47 more — search via glob)` so the
+ * model knows there's more it can pull on demand.
+ */
+const CAP_CONVENTION_CHARS = 1500;
+const CAP_PATH_LIST = 60;
+const CAP_FIORI_CONTROLLERS = 25;
+const CAP_FIORI_VIEWS = 25;
+const CAP_FIORI_ROUTES = 40;
+const CAP_FIORI_I18N_KEYS = 40;
+const CAP_CAP_SERVICES = 30;
+const CAP_CAP_ENTITIES = 60;
+const CAP_ABAP_OBJECTS = 80;
+const CAP_GIT_COMMITS = 5;
+const CAP_RECENT_OBJECTS = 10;
+/**
+ * Render a ProjectContext as prompt text. The result is a self-contained
+ * <project_context> XML-ish block ready to splice into a system prompt.
+ * Empty / null contexts render to an empty string — callers can compose
+ * unconditionally.
+ */
+export function renderProjectContext(ctx) {
+    if (!ctx)
+        return '';
+    const parts = [];
+    parts.push(`<project_context type="${ctx.type}">`);
+    parts.push(`  <root>${escapeXml(ctx.root)}</root>`);
+    parts.push(`  <detected_at>${ctx.detectedAt}</detected_at>`);
+    parts.push(renderConventions(ctx.conventions));
+    if (ctx.sapConnection)
+        parts.push(renderSapConnection(ctx.sapConnection));
+    parts.push(renderGit(ctx.git));
+    parts.push(renderFileIndex(ctx));
+    parts.push(renderDomainObjects(ctx.domainObjects));
+    parts.push(`</project_context>`);
+    return parts.filter((p) => p.length > 0).join('\n');
+}
+/* ── Section renderers ─────────────────────────────────────────────── */
+function renderConventions(c) {
+    const lines = ['  <conventions>'];
+    // Human-readable form: "2 spaces", "1 tab", etc. The earlier "2sp" /
+    // "4tab" packed-token form was ambiguous to the model — observed
+    // during 2026-05-10 dogfooding: "2sp" was parsed as "1-space indent"
+    // because there's no separator between count and unit.
+    const indentUnit = c.style.indentChar === 'tab' ? 'tab' : 'space';
+    const indentDesc = `${c.style.indentSize} ${indentUnit}${c.style.indentSize === 1 ? '' : 's'}`;
+    lines.push(`    <style indent="${indentDesc}" eol="${c.style.eol.toUpperCase()}" />`);
+    if (c.namingPatterns.classes.length || c.namingPatterns.interfaces.length || c.namingPatterns.cdsViews.length) {
+        lines.push('    <naming>');
+        if (c.namingPatterns.classes.length) {
+            lines.push(`      <classes>${escapeXml(c.namingPatterns.classes.join(', '))}</classes>`);
+        }
+        if (c.namingPatterns.interfaces.length) {
+            lines.push(`      <interfaces>${escapeXml(c.namingPatterns.interfaces.join(', '))}</interfaces>`);
+        }
+        if (c.namingPatterns.cdsViews.length) {
+            lines.push(`      <cds_views>${escapeXml(c.namingPatterns.cdsViews.join(', '))}</cds_views>`);
+        }
+        lines.push('    </naming>');
+    }
+    if (c.freeText) {
+        const truncated = truncateText(c.freeText, CAP_CONVENTION_CHARS);
+        lines.push('    <freeText>');
+        // CLAUDE.md / CSPEACH.md frequently contains literal XML snippets
+        // (this very repo's CLAUDE.md has <asx:values>, <atc:run>, etc).
+        // Escape unconditionally so the system-prompt block stays well-formed.
+        lines.push(indent(escapeXml(truncated.text), '      '));
+        if (truncated.truncated) {
+            lines.push('      ... (truncated — read CLAUDE.md / CSPEACH.md for full text)');
+        }
+        lines.push('    </freeText>');
+    }
+    lines.push('  </conventions>');
+    return lines.join('\n');
+}
+function renderSapConnection(s) {
+    const lines = [`  <sap_connection alias="${escapeAttr(s.alias)}">`];
+    lines.push(`    <system sid="${escapeAttr(s.system.sid ?? '?')}" release="${escapeAttr(s.system.release ?? '?')}" abap_version="${escapeAttr(s.system.abapVersion ?? '?')}" platform="${s.system.platform}" />`);
+    if (s.currentTransport) {
+        lines.push(`    <current_transport>${escapeXml(s.currentTransport)}</current_transport>`);
+    }
+    if (s.activeScope) {
+        if (s.activeScope.package) {
+            lines.push(`    <active_package>${escapeXml(s.activeScope.package)}</active_package>`);
+        }
+        if (s.activeScope.object) {
+            lines.push(`    <active_object name="${escapeAttr(s.activeScope.object.name)}" type="${escapeAttr(s.activeScope.object.type)}" />`);
+        }
+    }
+    if (s.recentObjects.length) {
+        lines.push('    <recent_objects>');
+        for (const ref of s.recentObjects.slice(0, CAP_RECENT_OBJECTS)) {
+            lines.push(`      <object name="${escapeAttr(ref.name)}" type="${escapeAttr(ref.type)}" action="${escapeAttr(ref.lastAction)}" />`);
+        }
+        if (s.recentObjects.length > CAP_RECENT_OBJECTS) {
+            lines.push(`      <!-- ... ${s.recentObjects.length - CAP_RECENT_OBJECTS} more -->`);
+        }
+        lines.push('    </recent_objects>');
+    }
+    lines.push('  </sap_connection>');
+    return lines.join('\n');
+}
+function renderGit(g) {
+    if (!g.isRepo) {
+        return '  <git is_repo="false" />';
+    }
+    const lines = ['  <git is_repo="true">'];
+    lines.push(`    <branch>${escapeXml(g.branch ?? '')}</branch>`);
+    lines.push(`    <head_sha>${escapeXml(g.headSha ?? '')}</head_sha>`);
+    lines.push(`    <dirty_files>${g.dirtyFileCount}</dirty_files>`);
+    if (g.recentCommits.length) {
+        lines.push('    <recent_commits>');
+        for (const line of g.recentCommits.slice(0, CAP_GIT_COMMITS)) {
+            lines.push(`      ${escapeXml(line)}`);
+        }
+        lines.push('    </recent_commits>');
+    }
+    lines.push('  </git>');
+    return lines.join('\n');
+}
+function renderFileIndex(ctx) {
+    const idx = ctx.index;
+    const lines = [
+        `  <file_index total="${idx.totalFiles}"${idx.truncated ? ' truncated="true"' : ''}>`,
+    ];
+    if (idx.topLevelDirs.length) {
+        lines.push(`    <top_level_dirs>${escapeXml(idx.topLevelDirs.join(', '))}</top_level_dirs>`);
+    }
+    const extEntries = Object.entries(idx.byExtension).sort((a, b) => b[1] - a[1]);
+    if (extEntries.length) {
+        const summary = extEntries
+            .slice(0, 12)
+            .map(([ext, n]) => `${ext}=${n}`)
+            .join(', ');
+        lines.push(`    <by_extension>${escapeXml(summary)}</by_extension>`);
+    }
+    if (idx.paths.length) {
+        const sample = idx.paths.slice(0, CAP_PATH_LIST);
+        lines.push('    <paths>');
+        for (const p of sample)
+            lines.push(`      ${escapeXml(p)}`);
+        if (idx.paths.length > CAP_PATH_LIST) {
+            lines.push(`      ... (${idx.paths.length - CAP_PATH_LIST} more — search via glob)`);
+        }
+        lines.push('    </paths>');
+    }
+    lines.push('  </file_index>');
+    return lines.join('\n');
+}
+function renderDomainObjects(d) {
+    switch (d.type) {
+        case 'fiori-ui5':
+            return renderFiori(d);
+        case 'cap-node':
+            return renderCap(d);
+        case 'abapgit':
+            return renderAbapList('abapgit', d.objects);
+        case 'abap-cloud':
+            return renderAbapCloud(d.objects, d.behaviorDefinitions);
+        case 'mixed':
+            return `  <domain_objects type="mixed" modules="${d.modules.length}" />`;
+        case 'unknown':
+        default:
+            return '  <domain_objects type="unknown" />';
+    }
+}
+function renderFiori(d) {
+    const lines = ['  <domain_objects type="fiori-ui5">'];
+    if (d.routes.length) {
+        lines.push('    <routes>');
+        for (const r of d.routes.slice(0, CAP_FIORI_ROUTES)) {
+            lines.push(`      <route name="${escapeAttr(r.name)}" pattern="${escapeAttr(r.pattern)}" targets="${escapeAttr(r.targets.join(','))}" />`);
+        }
+        if (d.routes.length > CAP_FIORI_ROUTES) {
+            lines.push(`      <!-- ... ${d.routes.length - CAP_FIORI_ROUTES} more routes -->`);
+        }
+        lines.push('    </routes>');
+    }
+    if (d.controllers.length) {
+        lines.push('    <controllers>');
+        for (const c of d.controllers.slice(0, CAP_FIORI_CONTROLLERS)) {
+            const view = c.viewPath ? ` view="${escapeAttr(c.viewPath)}"` : '';
+            const i18n = c.i18nKeys.length ? ` i18n_keys="${c.i18nKeys.length}"` : '';
+            lines.push(`      <controller name="${escapeAttr(c.name)}" path="${escapeAttr(c.path)}"${view}${i18n} />`);
+        }
+        if (d.controllers.length > CAP_FIORI_CONTROLLERS) {
+            lines.push(`      <!-- ... ${d.controllers.length - CAP_FIORI_CONTROLLERS} more controllers -->`);
+        }
+        lines.push('    </controllers>');
+    }
+    if (d.views.length) {
+        lines.push('    <views>');
+        for (const v of d.views.slice(0, CAP_FIORI_VIEWS)) {
+            const ctl = v.controllerPath ? ` controller="${escapeAttr(v.controllerPath)}"` : '';
+            lines.push(`      <view name="${escapeAttr(v.name)}" path="${escapeAttr(v.path)}"${ctl} />`);
+        }
+        if (d.views.length > CAP_FIORI_VIEWS) {
+            lines.push(`      <!-- ... ${d.views.length - CAP_FIORI_VIEWS} more views -->`);
+        }
+        lines.push('    </views>');
+    }
+    if (d.i18nKeys.length) {
+        const sample = d.i18nKeys.slice(0, CAP_FIORI_I18N_KEYS).join(', ');
+        const more = d.i18nKeys.length > CAP_FIORI_I18N_KEYS
+            ? ` ... (+${d.i18nKeys.length - CAP_FIORI_I18N_KEYS} more)`
+            : '';
+        lines.push(`    <i18n_keys>${escapeXml(sample)}${more}</i18n_keys>`);
+    }
+    lines.push('  </domain_objects>');
+    return lines.join('\n');
+}
+function renderCap(d) {
+    const lines = ['  <domain_objects type="cap-node">'];
+    if (d.services.length) {
+        lines.push('    <services>');
+        for (const s of d.services.slice(0, CAP_CAP_SERVICES)) {
+            const entities = s.entities.length ? ` entities="${escapeAttr(s.entities.join(','))}"` : '';
+            lines.push(`      <service name="${escapeAttr(s.name)}" path="${escapeAttr(s.path)}"${entities} />`);
+        }
+        if (d.services.length > CAP_CAP_SERVICES) {
+            lines.push(`      <!-- ... ${d.services.length - CAP_CAP_SERVICES} more services -->`);
+        }
+        lines.push('    </services>');
+    }
+    if (d.entities.length) {
+        lines.push('    <entities>');
+        for (const e of d.entities.slice(0, CAP_CAP_ENTITIES)) {
+            const src = e.source ? ` source="${escapeAttr(e.source)}"` : '';
+            lines.push(`      <entity name="${escapeAttr(e.name)}" path="${escapeAttr(e.path)}"${src} />`);
+        }
+        if (d.entities.length > CAP_CAP_ENTITIES) {
+            lines.push(`      <!-- ... ${d.entities.length - CAP_CAP_ENTITIES} more entities -->`);
+        }
+        lines.push('    </entities>');
+    }
+    lines.push('  </domain_objects>');
+    return lines.join('\n');
+}
+function renderAbapList(type, objects) {
+    const lines = [`  <domain_objects type="${type}" total="${objects.length}">`];
+    for (const o of objects.slice(0, CAP_ABAP_OBJECTS)) {
+        const pkg = o.package ? ` package="${escapeAttr(o.package)}"` : '';
+        lines.push(`    <object name="${escapeAttr(o.name)}" type="${escapeAttr(o.type)}"${pkg} />`);
+    }
+    if (objects.length > CAP_ABAP_OBJECTS) {
+        lines.push(`    <!-- ... ${objects.length - CAP_ABAP_OBJECTS} more objects — search via glob -->`);
+    }
+    lines.push('  </domain_objects>');
+    return lines.join('\n');
+}
+function renderAbapCloud(objects, bdefs) {
+    const lines = [
+        `  <domain_objects type="abap-cloud" total="${objects.length}" behavior_definitions="${bdefs.length}">`,
+    ];
+    if (bdefs.length) {
+        const sample = bdefs.slice(0, 20).join(', ');
+        const more = bdefs.length > 20 ? ` ... (+${bdefs.length - 20} more)` : '';
+        lines.push(`    <bdefs>${escapeXml(sample)}${more}</bdefs>`);
+    }
+    for (const o of objects.slice(0, CAP_ABAP_OBJECTS)) {
+        const pkg = o.package ? ` package="${escapeAttr(o.package)}"` : '';
+        lines.push(`    <object name="${escapeAttr(o.name)}" type="${escapeAttr(o.type)}"${pkg} />`);
+    }
+    if (objects.length > CAP_ABAP_OBJECTS) {
+        lines.push(`    <!-- ... ${objects.length - CAP_ABAP_OBJECTS} more objects — search via glob -->`);
+    }
+    lines.push('  </domain_objects>');
+    return lines.join('\n');
+}
+/* ── Helpers ───────────────────────────────────────────────────────── */
+function escapeXml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+function escapeAttr(text) {
+    return escapeXml(text).replace(/"/g, '&quot;');
+}
+function truncateText(text, charBudget) {
+    if (text.length <= charBudget)
+        return { text, truncated: false };
+    return { text: text.slice(0, charBudget), truncated: true };
+}
+function indent(text, prefix) {
+    return text
+        .split('\n')
+        .map((line) => prefix + line)
+        .join('\n');
+}

package/dist/project-context/types.js

@@ -0,0 +1,14 @@
+/**
+ * Project context types — the structured model of whatever project the
+ * user is in. Phase 1 of Track B (the agentic CSPeach rebuild).
+ *
+ * The full ProjectContext is computed at session start (lazily, on
+ * demand, via getProjectContext from ./index.ts) and ideally cached for
+ * the session. Phase 2 wires it into the agent's system prompt behind
+ * a feature flag; Phase 4's intent-driven loop relies on it heavily.
+ *
+ * Today (Phase 1), nothing in the existing CLI imports this module.
+ * It exists in code, has its own tests, but doesn't affect runtime
+ * behavior. Risk to existing CSPeach: zero by construction.
+ */
+export {};

package/dist/projects/build.js

@@ -0,0 +1,20 @@
+import { randomUUID } from 'node:crypto';
+export function buildEnvelope(args) {
+    const now = new Date().toISOString();
+    return {
+        schemaVersion: '1.0',
+        artefactType: args.artefactType,
+        id: randomUUID(),
+        title: args.extract.title,
+        createdAt: now,
+        createdBy: args.author,
+        lastEditedAt: now,
+        lastEditedBy: args.author,
+        version: 1,
+        source: args.source,
+        promotedFrom: args.promotedFrom ?? null,
+        content: args.extract.content,
+        interaction: { items: args.extract.items },
+        history: [{ at: now, by: args.author, action: 'created' }],
+    };
+}

package/dist/projects/canonicalize.js

@@ -0,0 +1,39 @@
+import { createHash } from 'node:crypto';
+/**
+ * Canonical SHA-256 of an envelope.
+ * Strips fields that change on every save without changing semantic content.
+ * Keys are lex-sorted recursively.
+ */
+export async function canonicalSha256(env) {
+    const stripped = stripVolatileFields(env);
+    const canonical = canonicalJson(stripped);
+    return createHash('sha256').update(canonical, 'utf8').digest('hex');
+}
+function stripVolatileFields(env) {
+    const copy = JSON.parse(JSON.stringify(env));
+    delete copy.lastEditedAt;
+    if (Array.isArray(copy.history)) {
+        copy.history = copy.history.map((h) => {
+            const { at: _omit, ...rest } = h;
+            return rest;
+        });
+    }
+    return copy;
+}
+function canonicalJson(value) {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'boolean' || typeof value === 'number')
+        return JSON.stringify(value);
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    if (Array.isArray(value)) {
+        return '[' + value.map(canonicalJson).join(',') + ']';
+    }
+    if (typeof value === 'object') {
+        const keys = Object.keys(value).sort();
+        const parts = keys.map((k) => JSON.stringify(k) + ':' + canonicalJson(value[k]));
+        return '{' + parts.join(',') + '}';
+    }
+    throw new Error(`canonicalJson: unsupported value type ${typeof value}`);
+}

package/dist/projects/email-template.js

@@ -0,0 +1,54 @@
+const EDITOR_URL = process.env.CSPEACH_EDITOR_URL ?? 'https://cspeach.dev/edit';
+const SUBJECT_BY_TYPE = {
+    'spec-gap': (t) => `Gap analysis — ${t}`,
+    'design': (t) => `Design — ${t}`,
+    'estimate': (t) => `Estimate — ${t}`,
+    'cca': (t) => `Custom code analysis — ${t}`,
+    'incident': (t) => `Incident report — ${t}`,
+    'upgrade-scan': (t) => `S/4HANA upgrade scan — ${t}`,
+    'upgrade-progress': (t) => `Upgrade remediation progress — ${t}`,
+    'upgrade-report': (t) => `Upgrade remediation report — ${t}`,
+    'cca-assessment': (t) => `Custom code assessment — ${t}`,
+    'modernize-result': (t) => `Modernization result — ${t}`,
+    'test-coverage': (t) => `Test coverage report — ${t}`,
+};
+const BODY_BY_TYPE = {
+    'spec-gap': (a) => `Attached is the gap analysis for the ${a.title}.\n${a.itemCount} ${a.itemNoun} across business / data / authorisation / edge cases.`,
+    'design': (a) => `Attached is the architecture design for the ${a.title}.\n${a.itemCount} ${a.itemNoun} to review (keep / redesign / defer).`,
+    'estimate': (a) => `Attached is the effort estimate for the ${a.title}.\n${a.itemCount} ${a.itemNoun} to review (confirm / dispute / defer).`,
+    'cca': (a) => `Attached is the custom code analysis for the ${a.title}.\n${a.itemCount} ${a.itemNoun} classified.`,
+    'incident': (a) => `Attached is the incident report for the ${a.title}.`,
+    'upgrade-scan': (a) => `Attached is the S/4HANA upgrade scan baseline for ${a.title}.\n${a.itemCount} ${a.itemNoun} to remediate.`,
+    'upgrade-progress': (a) => `Attached is the upgrade remediation progress for ${a.title}.\n${a.itemCount} ${a.itemNoun} attempted.`,
+    'upgrade-report': (a) => `Attached is the upgrade remediation report for ${a.title}.\n${a.itemCount} ${a.itemNoun} listed (regressions to address before sign-off).`,
+    'cca-assessment': (a) => `Attached is the custom code assessment for ${a.title}.\n${a.itemCount} ${a.itemNoun} classified — review keep / fix / retire / redesign per object.`,
+    'modernize-result': (a) => `Attached is the modernization result for ${a.title}.\n${a.itemCount} ${a.itemNoun} attempted — review applied / skipped / failed per object before sign-off.`,
+    'test-coverage': (a) => `Attached is the test coverage report for ${a.title}.\n${a.itemCount} test ${a.itemNoun} generated — review the targets + method counts before merging.`,
+};
+export function renderEmailTemplate(a) {
+    const subject = SUBJECT_BY_TYPE[a.artefactType](a.title);
+    const body = BODY_BY_TYPE[a.artefactType](a);
+    return [
+        '─────────────────────────────────────────────────────────────────',
+        'Suggested email — copy from below the line, edit, send',
+        '─────────────────────────────────────────────────────────────────',
+        `Subject: ${subject}`,
+        '',
+        'Hi,',
+        '',
+        body,
+        '',
+        'To review:',
+        `  1. Open  ${EDITOR_URL}`,
+        `  2. Drag the attached ${a.filename} onto the page`,
+        '  3. Click each item, mark its status, add comments',
+        '  4. Click "Download updated file"',
+        '  5. Email me the downloaded file',
+        '',
+        'If your email blocks .json, rename it to .cspeach.json.txt before sending —',
+        'the editor accepts both.',
+        '',
+        'Thanks,',
+        a.author,
+    ].join('\n');
+}

package/dist/projects/extract-cca.js

@@ -0,0 +1,139 @@
+/**
+ * Parser for the `<!-- csforge:cca-manifest ... -->` block that
+ * /abap-cca and /abap-cca-merge emit at the end of their markdown
+ * output. Hidden from human renderers, structured enough for a
+ * deterministic extractor.
+ *
+ * Format mirrors the upgrade-manifest pattern (see extract-upgrade.ts):
+ *
+ *   <!-- csforge:cca-manifest
+ *   artefact: cca-assessment
+ *   title: ZFI / ZSD — S/4HANA 2023 estate
+ *   detail_path: .abapforge/cca/projects/zfi-zsd-2026-04/project.json
+ *   project_id: zfi-zsd-2026-04
+ *   scope: ZFI* + ZSD*
+ *   atc_variant: S4HANA_READINESS_2023
+ *   total_objects: 1842
+ *   keep: 421
+ *   fix: 738
+ *   retire: 124
+ *   redesign: 312
+ *   uncategorized: 247
+ *   classifications:
+ *     item-001 | ZFI_BP_SYNC      | PROG | fix      | high
+ *     item-002 | ZCL_FI_DOC       | CLAS | redesign | medium
+ *   -->
+ *
+ * The classifications table is capped at 50 rows in the manifest; the
+ * full per-object detail lives in the project.json at `detail_path`.
+ *
+ * Parsing is permissive — missing optional fields produce defaults; a
+ * missing manifest block throws so callers know to surface the error.
+ */
+const MANIFEST_RE = /<!--\s*csforge:cca-manifest\s*\n([\s\S]*?)\n\s*-->/;
+function parseManifestBlock(markdown) {
+    const m = MANIFEST_RE.exec(markdown);
+    if (!m) {
+        throw new Error('No <!-- csforge:cca-manifest --> block found in skill output');
+    }
+    const body = m[1] ?? '';
+    const kv = {};
+    const tables = {};
+    let currentTable = null;
+    for (const rawLine of body.split('\n')) {
+        const line = rawLine.replace(/\r$/, '');
+        if (line.trim().length === 0) {
+            currentTable = null;
+            continue;
+        }
+        if (currentTable !== null && /^\s+/.test(line)) {
+            const cells = line.trim().split('|').map((c) => c.trim());
+            if (cells.length > 0) {
+                if (!tables[currentTable])
+                    tables[currentTable] = [];
+                tables[currentTable].push(cells);
+            }
+            continue;
+        }
+        const colon = line.indexOf(':');
+        if (colon === -1)
+            continue;
+        const key = line.slice(0, colon).trim();
+        const value = line.slice(colon + 1).trim();
+        if (value.length === 0) {
+            currentTable = key;
+            tables[key] = [];
+        }
+        else {
+            kv[key] = value;
+            currentTable = null;
+        }
+    }
+    return { kv, tables };
+}
+function intOr(kv, key, fallback) {
+    const v = kv[key];
+    if (v === undefined)
+        return fallback;
+    const n = Number.parseInt(v, 10);
+    return Number.isFinite(n) ? n : fallback;
+}
+const CLASSIFICATIONS = ['keep', 'fix', 'retire', 'redesign'];
+const CONFIDENCES = ['high', 'medium', 'low'];
+function asClassification(raw) {
+    const v = raw.toLowerCase();
+    return CLASSIFICATIONS.includes(v)
+        ? v
+        : 'keep';
+}
+function asConfidence(raw) {
+    const v = raw.toLowerCase();
+    return CONFIDENCES.includes(v)
+        ? v
+        : 'medium';
+}
+export function extractCcaAssessment(markdown) {
+    const { kv, tables } = parseManifestBlock(markdown);
+    if (kv.artefact !== 'cca-assessment') {
+        throw new Error(`Manifest artefact mismatch: expected 'cca-assessment', got '${kv.artefact}'`);
+    }
+    if (!kv.detail_path) {
+        throw new Error("cca-assessment manifest missing required 'detail_path'");
+    }
+    if (!kv.project_id) {
+        throw new Error("cca-assessment manifest missing required 'project_id'");
+    }
+    const classifications = (tables.classifications ?? []).map((row, i) => ({
+        id: row[0] ?? `item-${String(i + 1).padStart(3, '0')}`,
+        objectName: row[1] ?? '',
+        objectType: row[2] ?? '',
+        classification: asClassification(row[3] ?? 'keep'),
+        confidence: asConfidence(row[4] ?? 'medium'),
+    }));
+    const content = {
+        detailPath: kv.detail_path,
+        projectId: kv.project_id,
+        scope: kv.scope ?? '',
+        atcVariant: kv.atc_variant ?? '',
+        summary: {
+            totalObjects: intOr(kv, 'total_objects', classifications.length),
+            keep: intOr(kv, 'keep', 0),
+            fix: intOr(kv, 'fix', 0),
+            retire: intOr(kv, 'retire', 0),
+            redesign: intOr(kv, 'redesign', 0),
+            uncategorized: intOr(kv, 'uncategorized', 0),
+        },
+        classifications,
+    };
+    // One InteractionItem per classification entry, default status 'open'
+    // (auto-classified by the AI, awaiting human review).
+    const items = classifications.map((c) => ({
+        id: c.id,
+        status: 'open',
+        answer: null,
+        answeredBy: null,
+        answeredAt: null,
+        comments: [],
+    }));
+    return { title: kv.title ?? 'CCA Assessment', content, items };
+}