@uwmd/core 1.1.0 → 1.3.0

package/dist/cli.js

@@ -10,12 +10,14 @@ import { compact, diff } from './compactor.js';
 import { generateBlankUWFile } from './init.js';
 import { render } from './renderer.js';
 import { renderReportHtml } from './report.js';
-import { stringifyUWJsonWithDigest } from './uwjson.js';
-import { toUWEnvelope } from './envelope.js';
+import { stringifyUWEnvelope } from './uwjson.js';
+import { stampEnvelopeDigest, toUWEnvelope, } from './envelope.js';
 import { CORE_CODEC_REGISTRY } from './codecs.js';
 import { writeAgentBlock } from './runner.js';
 import { applyEdit } from './editor.js';
 import { verifyChain, verifyProvenance } from './integrity.js';
+import { loadModuleManifest, createModuleRegistry, ModuleRegistryError } from './modules.js';
+import { cmdLeaseValidate, cmdLeaseProject, cmdPackageCreate, cmdPackageVerify, cmdPackageList, cmdPackageToContext, cmdPackageContextValidate, cmdPackageEdges, } from './cli-packages.js';
 import { evaluateCalc } from './calc/index.js';
 import { buildAgentContext, buildAgentPrompt, isContextReady, BANCROFT_LAYERS } from './context.js';
 import { runBancroftAgent } from './agents/bancroft.js';
@@ -24,6 +26,12 @@ import { rankGaps } from './refinement.js';
 import { resolveValue } from './cascade.js';
 import { getAssetClassDefaults } from './defaults.js';
 import { MULTIFAMILY_PACK, getPackForAssetClass } from './packs/index.js';
+import { issueReceipt, verifyReceipt, assertUWReceipt } from './receipts.js';
+import { CORE_VERSION } from './version.js';
+import { detectUWSourceRepresentation, UWX_REPRESENTATION_ID, UW_LITE_SOURCE_DESCRIPTOR, UWX_SOURCE_DESCRIPTOR, UWX_EXTENSION, } from './source-representation.js';
+import { parseUWLite } from './lite.js';
+import { compileUWLite, projectUWEnvelopeToLite, stringifyUWX, } from './lite-bridge.js';
+import { UW_LITE_REPRESENTATION_ID } from './source-representation.js';
 const [, , command, ...args] = process.argv;
 function readFile(path) {
     const resolved = resolve(path);
@@ -71,6 +79,20 @@ function parseFlags(rawArgs) {
 // ─── Commands ─────────────────────────────────────────────────────────────────
 function cmdParse(file, flags) {
     const content = readFile(file);
+    const detection = detectUWSourceRepresentation(content, file);
+    if (detection.representation !== UWX_REPRESENTATION_ID) {
+        const lite = parseUWLite(content);
+        console.log(JSON.stringify({
+            representation: lite.representation,
+            representation_version: lite.representation_version,
+            frontmatter: lite.frontmatter,
+            fields: lite.fields,
+            issues: lite.issues,
+        }, null, flags['compact'] ? 0 : 2));
+        return;
+    }
+    for (const warning of detection.warnings)
+        console.warn(`Warning: ${warning}`);
     const parsed = parseUWFile(content, { strict: flags['strict'] === true });
     const output = {
         frontmatter: parsed.frontmatter,
@@ -83,6 +105,38 @@ function cmdParse(file, flags) {
 }
 function cmdValidate(file, flags) {
     const content = readFile(file);
+    const detection = detectUWSourceRepresentation(content, file);
+    if (detection.representation !== UWX_REPRESENTATION_ID) {
+        const lite = parseUWLite(content);
+        const errors = lite.issues.filter((issue) => issue.severity === 'error');
+        const warnings = lite.issues.filter((issue) => issue.severity === 'warning');
+        const result = {
+            representation: lite.representation,
+            overall_status: errors.length > 0 ? 'errors' : warnings.length > 0 ? 'warnings' : 'clean',
+            issues: lite.issues,
+            errors,
+            warnings,
+        };
+        if (flags['json']) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\n${result.overall_status.toUpperCase()} - ${basename(file)}\n`);
+        if (result.issues.length === 0) {
+            console.log('No Lite syntax issues found.');
+        }
+        else {
+            for (const issue of result.issues) {
+                const location = issue.line ? ` line ${issue.line}` : '';
+                const field = issue.field_path ? ` [${issue.field_path}]` : '';
+                console.log(`  [${issue.severity.toUpperCase()}]${location}${field} ${issue.code}: ${issue.message}`);
+            }
+        }
+        console.log('');
+        process.exit(errors.length > 0 ? 1 : 0);
+    }
+    for (const warning of detection.warnings)
+        console.warn(`Warning: ${warning}`);
     const parsed = parseUWFile(content);
     const instCfg = loadInstitutionConfig(flags['institution']);
     const result = validateUWFile(parsed, instCfg?.thresholds);
@@ -229,8 +283,13 @@ function cmdInit(flags) {
         dealStage: flags['stage'],
         tier: flags['tier'] ?? 'screener',
     });
+    // generateBlankUWFile() emits structured UWX content, so the default filename
+    // must be .uwx.md. Writing it as .uw.md produced a file the format spec
+    // forbids and detectUWSourceRepresentation() flags as legacy on the next load.
     const filename = flags['output']
-        ?? (flags['name'] ? `${flags['name'].replace(/\s+/g, '-').toLowerCase()}.uw.md` : 'new-deal.uw.md');
+        ?? (flags['name']
+            ? `${flags['name'].replace(/\s+/g, '-').toLowerCase()}${UWX_EXTENSION}`
+            : `new-deal${UWX_EXTENSION}`);
     const outPath = resolve(filename);
     writeFileSync(outPath, content, 'utf-8');
     console.log(`Created: ${outPath}`);
@@ -269,16 +328,14 @@ function cmdSummary(file) {
 `);
 }
 async function cmdExport(file, flags) {
-    const content = readFile(file);
-    const parsed = parseUWFile(content);
-    const text = await stringifyUWJsonWithDigest(parsed, {
-        // --no-superseded or --compact drops the append-only history.
-        includeSuperseded: !(flags['no-superseded'] === true || flags['compact'] === true),
-    });
+    const includeSuperseded = !(flags['no-superseded'] === true || flags['compact'] === true);
+    const loaded = await loadEnvelope(file);
+    const envelope = includeSuperseded ? loaded : { ...loaded, superseded: {} };
+    const text = stringifyUWEnvelope(await stampEnvelopeDigest(envelope));
     // Default output path: swap the .uw.md suffix for .uw.json (fall back to appending).
     const outPath = flags['output']
         ? resolve(flags['output'])
-        : resolve(file.endsWith('.uw.md') ? `${file.slice(0, -'.uw.md'.length)}.uw.json` : `${file}.uw.json`);
+        : resolve(replaceUWExtension(file, '.uw.json'));
     if (flags['stdout']) {
         process.stdout.write(text);
         return;
@@ -292,12 +349,33 @@ const FORMAT_ALIASES = {
     csv: 'uw-csv-bundle',
     'csv-bundle': 'uw-csv-bundle',
     'uw-json': 'uw-json',
+    lite: 'uw-lite-markdown',
+    uw: 'uw-lite-markdown',
+    uwx: 'uwx-markdown',
+    'uw-lite': 'uw-lite-markdown',
+    'uw-lite-markdown': 'uw-lite-markdown',
+    'uwx-markdown': 'uwx-markdown',
     'uw-xml': 'uw-xml',
     'uw-csv-bundle': 'uw-csv-bundle',
 };
 async function loadEnvelope(file) {
-    if (file.toLowerCase().endsWith('.uw.md')) {
-        return toUWEnvelope(parseUWFile(readFile(file)));
+    const lower = file.toLowerCase();
+    if (lower.endsWith('.uw.md') || lower.endsWith(UWX_EXTENSION)) {
+        const content = readFile(file);
+        const detection = detectUWSourceRepresentation(content, file);
+        if (detection.representation !== UWX_REPRESENTATION_ID) {
+            const compilation = compileUWLite(parseUWLite(content));
+            if (!compilation.ok) {
+                const issues = compilation.report.issues
+                    .map((issue) => `${issue.code}: ${issue.message}`)
+                    .join('; ');
+                throw new Error(`UW Lite compilation failed: ${issues}`);
+            }
+            return compilation.envelope;
+        }
+        for (const warning of detection.warnings)
+            console.warn(`Warning: ${warning}`);
+        return toUWEnvelope(parseUWFile(content));
     }
     const sourceCodec = CORE_CODEC_REGISTRY.findByFileName(file);
     if (!sourceCodec || !sourceCodec.descriptor.directions.includes('read')) {
@@ -308,9 +386,17 @@ async function loadEnvelope(file) {
         : readFile(file);
     return sourceCodec.decode(input);
 }
+/**
+ * Swap a known UW source extension for `extension`, appending if none matches.
+ *
+ * `.uwx.md` must be in this list. Without it a UWX input fell through to the
+ * append branch, so `uwmd export deal.uwx.md` wrote `deal.uwx.md.uw.json`
+ * rather than `deal.uw.json`. (`.uw.md` does not match a `.uwx.md` filename —
+ * the suffixes genuinely differ — so it was silently a no-op, not a mis-match.)
+ */
 function replaceUWExtension(file, extension) {
     const lower = file.toLowerCase();
-    for (const suffix of ['.uw.csv.zip', '.uw.md', '.uw.json', '.uw.xml']) {
+    for (const suffix of [UWX_EXTENSION, '.uw.csv.zip', '.uw.md', '.uw.json', '.uw.xml']) {
         if (lower.endsWith(suffix))
             return `${file.slice(0, -suffix.length)}${extension}`;
     }
@@ -319,15 +405,39 @@ function replaceUWExtension(file, extension) {
 async function cmdConvert(file, flags) {
     const requested = flags['to'];
     if (typeof requested !== 'string') {
-        throw new Error('convert requires --to uw-json|uw-xml|uw-csv-bundle.');
+        throw new Error('convert requires --to uw-lite-markdown|uwx-markdown|uw-json|uw-xml|uw-csv-bundle.');
     }
     const targetId = FORMAT_ALIASES[requested.toLowerCase()] ?? requested;
-    const target = CORE_CODEC_REGISTRY.get(targetId);
-    if (!target.descriptor.directions.includes('write')) {
-        throw new Error(`Representation ${targetId} is not writable.`);
-    }
     const envelope = await loadEnvelope(file);
-    const encoded = await target.encode(envelope);
+    let encoded;
+    let extension;
+    if (targetId === UWX_REPRESENTATION_ID) {
+        encoded = stringifyUWX(envelope);
+        extension = UWX_EXTENSION;
+    }
+    else if (targetId === UW_LITE_REPRESENTATION_ID) {
+        const projection = projectUWEnvelopeToLite(envelope);
+        encoded = projection.content;
+        extension = '.uw.md';
+        if (projection.report.lossy) {
+            console.warn(`Warning: Lite projection omitted ${projection.report.omitted_paths.length} advanced path(s).`);
+        }
+        if (typeof flags['projection-report'] === 'string') {
+            writeFileSync(resolve(flags['projection-report']), JSON.stringify(projection.report, null, 2), 'utf-8');
+        }
+    }
+    else {
+        const target = CORE_CODEC_REGISTRY.get(targetId);
+        if (!target.descriptor.directions.includes('write')) {
+            throw new Error(`Representation ${targetId} is not writable.`);
+        }
+        const targetEncoded = await target.encode(envelope);
+        if (typeof targetEncoded !== 'string' && !(targetEncoded instanceof Uint8Array)) {
+            throw new Error(`Representation ${targetId} did not produce file-compatible output.`);
+        }
+        encoded = targetEncoded;
+        extension = target.descriptor.file_extensions[0];
+    }
     if (typeof encoded !== 'string' && !(encoded instanceof Uint8Array)) {
         throw new Error(`Representation ${targetId} did not produce file-compatible output.`);
     }
@@ -335,15 +445,174 @@ async function cmdConvert(file, flags) {
         process.stdout.write(typeof encoded === 'string' ? encoded : Buffer.from(encoded));
         return;
     }
-    const extension = target.descriptor.file_extensions[0];
     const outPath = flags['output']
         ? resolve(flags['output'])
         : resolve(replaceUWExtension(file, extension));
     writeFileSync(outPath, encoded, 'utf-8');
     console.log(`Converted ${basename(file)} → ${basename(outPath)} (${targetId})`);
 }
+// ─── Receipts (RFC 0016 / spec/UW_RECEIPT_v1.md) ─────────────────────────────
+async function cmdReceiptIssue(file, flags) {
+    const receipt = await issueReceipt(readFile(file), {
+        filename: file,
+        issuer: `uwmd-cli@${CORE_VERSION}`,
+        ...(typeof flags['issued-at'] === 'string' ? { issued_at: flags['issued-at'] } : {}),
+    });
+    const serialized = `${JSON.stringify(receipt, null, 2)}\n`;
+    if (flags['stdout']) {
+        process.stdout.write(serialized);
+        return;
+    }
+    const outPath = flags['output']
+        ? resolve(flags['output'])
+        : resolve(`${file.replace(/\.(uw|uwx)\.md$/i, '')}.receipt.json`);
+    writeFileSync(outPath, serialized, 'utf-8');
+    const computed = receipt.computation.results.filter((r) => r.computed).length;
+    console.log(`Issued receipt for ${basename(file)} → ${basename(outPath)} ` +
+        `(${receipt.computation.pack}@${receipt.computation.pack_version}, ` +
+        `${computed}/${receipt.computation.results.length} outputs computed)`);
+    console.log('A receipt attests that these outputs follow from this record. It does not attest that the inputs are true.');
+}
+// ─── Modules ──────────────────────────────────────────────────────────────────
+function readManifestFile(path) {
+    try {
+        return { ok: true, manifest: JSON.parse(readFileSync(resolve(path), 'utf-8')) };
+    }
+    catch (e) {
+        return { ok: false, message: e instanceof Error ? e.message : String(e) };
+    }
+}
+function hostTierFlag(flags) {
+    const tier = flags['tier'];
+    return typeof tier === 'string' ? tier : undefined;
+}
+function cmdModulesValidate(files, flags) {
+    const hostTier = hostTierFlag(flags);
+    const reports = files.map((file) => {
+        const read = readManifestFile(file);
+        if (!read.ok) {
+            return { file, ok: false, errors: [{ category: 'module', code: 'CLI-MOD-READ', message: read.message }] };
+        }
+        const result = loadModuleManifest(read.manifest, hostTier ? { hostTier } : {});
+        return { file, ok: result.ok, errors: result.errors };
+    });
+    if (flags['json']) {
+        console.log(JSON.stringify({ modules: reports }, null, 2));
+        process.exit(reports.every((r) => r.ok) ? 0 : 1);
+    }
+    for (const report of reports) {
+        if (report.ok) {
+            console.log(`\nOK - ${basename(report.file)}`);
+            continue;
+        }
+        console.log(`\nERRORS - ${basename(report.file)}`);
+        for (const error of report.errors) {
+            // The pointer is what makes this actionable: it names the exact
+            // declaration that failed, not just the manifest.
+            const at = 'pointer' in error && error.pointer ? ` [${error.pointer}]` : '';
+            console.log(`  ${error.code}${at} ${error.message}`);
+        }
+    }
+    const failed = reports.filter((r) => !r.ok).length;
+    console.log(`\n${reports.length - failed}/${reports.length} manifest(s) loaded${hostTier ? ` against ${hostTier}` : ''}.\n`);
+    process.exit(failed > 0 ? 1 : 0);
+}
+function cmdModulesList(files, flags) {
+    const hostTier = hostTierFlag(flags);
+    const manifests = [];
+    for (const file of files) {
+        const read = readManifestFile(file);
+        if (!read.ok) {
+            console.error(`Cannot read ${basename(file)}: ${read.message}`);
+            process.exit(1);
+        }
+        manifests.push(read.manifest);
+    }
+    let registry;
+    try {
+        registry = createModuleRegistry({ modules: manifests, ...(hostTier ? { hostTier } : {}) });
+    }
+    catch (e) {
+        // Registry construction is all-or-nothing: a bad manifest means there is no
+        // registry to list, so report why rather than printing a partial one.
+        if (e instanceof ModuleRegistryError) {
+            console.error('Registry refused to load:');
+            for (const error of e.errors)
+                console.error(`  ${error.code} ${error.message}`);
+        }
+        else {
+            console.error(e instanceof Error ? e.message : String(e));
+        }
+        process.exit(1);
+    }
+    const rows = registry.modules.map((m) => ({
+        id: m.id,
+        name: m.name,
+        version: m.version,
+        requires_tier: m.requires_tier,
+        asset_classes: m.asset_classes ?? [],
+        calculations: (m.calculations ?? []).length,
+        validations: (m.validations ?? []).length,
+        sections: (m.sections ?? []).length,
+        agent_layers: (m.agent_layers ?? []).length,
+    }));
+    if (flags['json']) {
+        console.log(JSON.stringify({ modules: rows }, null, 2));
+        return;
+    }
+    console.log(`\n${rows.length} module(s) loaded\n`);
+    for (const row of rows) {
+        console.log(`  ${row.id}@${row.version} — ${row.name}`);
+        console.log(`    tier: ${row.requires_tier}`);
+        console.log(`    asset classes: ${row.asset_classes.length ? row.asset_classes.join(', ') : 'class-agnostic'}`);
+        console.log(`    contributes: ${row.calculations} calc, ${row.validations} validation, ` +
+            `${row.sections} section, ${row.agent_layers} agent layer`);
+    }
+    console.log('');
+}
+async function cmdReceiptVerify(file, receiptPath, flags) {
+    let receipt;
+    try {
+        const raw = JSON.parse(readFileSync(resolve(receiptPath), 'utf-8'));
+        assertUWReceipt(raw);
+        receipt = raw;
+    }
+    catch (e) {
+        console.error(`Not a readable receipt: ${e instanceof Error ? e.message : String(e)}`);
+        process.exit(2);
+    }
+    const result = await verifyReceipt(receipt, readFile(file), { filename: file });
+    if (flags['json']) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.log(`Verdict: ${result.verdict.toUpperCase()}`);
+        for (const issue of result.issues) {
+            const detail = issue.expected !== undefined || issue.actual !== undefined
+                ? ` (expected ${issue.expected ?? '—'}, got ${issue.actual ?? '—'})`
+                : '';
+            console.log(`  [${issue.code}] ${issue.message}${detail}`);
+        }
+        if (result.verdict === 'verified') {
+            console.log('\nThis record is unchanged since issuance and its stated outputs follow deterministically\n' +
+                'from its contents. It is NOT a statement that the inputs are true, complete, or approved.');
+        }
+        else if (result.verdict === 'unverifiable') {
+            console.log('\nThis verifier could not decide. That is not a negative result.');
+        }
+    }
+    // 0 verified, 1 failed, 3 unverifiable — so scripts can tell the third state apart.
+    if (result.verdict === 'failed')
+        process.exit(1);
+    if (result.verdict === 'unverifiable')
+        process.exit(3);
+}
 function cmdFormats(flags) {
-    const descriptors = CORE_CODEC_REGISTRY.list();
+    const descriptors = [
+        UW_LITE_SOURCE_DESCRIPTOR,
+        UWX_SOURCE_DESCRIPTOR,
+        ...CORE_CODEC_REGISTRY.list(),
+    ];
     if (flags['json']) {
         console.log(JSON.stringify(descriptors, null, 2));
         return;
@@ -360,10 +629,12 @@ function cmdReport(file, flags) {
         tier: flags['tier'],
         preparedBy: flags['prepared-by'],
     });
-    // Default output path: swap the .uw.md suffix for .report.html.
+    // Default output path: swap the source extension for .report.html. Routed
+    // through replaceUWExtension so every UW source extension is handled in one
+    // place — the inline .uw.md check this replaced missed .uwx.md entirely.
     const outPath = flags['output']
         ? resolve(flags['output'])
-        : resolve(file.endsWith('.uw.md') ? `${file.slice(0, -'.uw.md'.length)}.report.html` : `${file}.report.html`);
+        : resolve(replaceUWExtension(file, '.report.html'));
     if (flags['stdout']) {
         process.stdout.write(result.html);
         return;
@@ -759,7 +1030,7 @@ for (let _i = 0; _i < args.length; _i++) {
             break;
         case 'convert':
             if (!positional[0]) {
-                console.error('Usage: uwmd convert <file.uw.md|file.uw.json|file.uw.xml|file.uw.csv.zip> --to uw-json|uw-xml|uw-csv-bundle [--output <file>] [--stdout]');
+                console.error('Usage: uwmd convert <file.uw.md|file.uwx.md|file.uw.json|file.uw.xml|file.uw.csv.zip> --to lite|uwx|uw-json|uw-xml|uw-csv-bundle [--projection-report <file>] [--output <file>] [--stdout]');
                 process.exit(1);
             }
             await cmdConvert(positional[0], flags);
@@ -785,9 +1056,127 @@ for (let _i = 0; _i < args.length; _i++) {
             }
             cmdRefine(positional[0], flags);
             break;
+        case 'lease': {
+            const sub = positional[0];
+            if (sub === 'validate') {
+                if (!positional[1]) {
+                    console.error('Usage: uwmd lease validate <abstract.json> [--json]');
+                    process.exit(1);
+                }
+                cmdLeaseValidate(positional[1], flags);
+            }
+            else if (sub === 'project') {
+                if (!positional[1]) {
+                    console.error('Usage: uwmd lease project <abstract.json> [--compact]');
+                    process.exit(1);
+                }
+                cmdLeaseProject(positional[1], flags);
+            }
+            else {
+                console.error('Usage: uwmd lease <validate|project> <abstract.json>');
+                process.exit(1);
+            }
+            break;
+        }
+        case 'package': {
+            const sub = positional[0];
+            const target = positional[1];
+            if (sub === 'create') {
+                if (!target) {
+                    console.error('Usage: uwmd package create <manifest.json> [--output <file.uwpkg.zip>]');
+                    process.exit(1);
+                }
+                await cmdPackageCreate(target, flags);
+            }
+            else if (sub === 'verify') {
+                if (!target) {
+                    console.error('Usage: uwmd package verify <file.uwpkg.zip> [--json]');
+                    process.exit(1);
+                }
+                await cmdPackageVerify(target, flags);
+            }
+            else if (sub === 'list') {
+                if (!target) {
+                    console.error('Usage: uwmd package list <file.uwpkg.zip> [--json]');
+                    process.exit(1);
+                }
+                cmdPackageList(target, flags);
+            }
+            else if (sub === 'to-context') {
+                if (!target) {
+                    console.error('Usage: uwmd package to-context <file.uwpkg.zip> [--output <file.json>] [--stdout]');
+                    process.exit(1);
+                }
+                cmdPackageToContext(target, flags);
+            }
+            else if (sub === 'validate-context') {
+                if (!target) {
+                    console.error('Usage: uwmd package validate-context <file.uwpkg.context.json> [--json]');
+                    process.exit(1);
+                }
+                cmdPackageContextValidate(target, flags);
+            }
+            else if (sub === 'edges') {
+                if (!target) {
+                    console.error('Usage: uwmd package edges <file.uwpkg.zip>');
+                    process.exit(1);
+                }
+                cmdPackageEdges(target);
+            }
+            else {
+                console.error('Usage: uwmd package <create|verify|list|to-context|validate-context|edges> ...');
+                process.exit(1);
+            }
+            break;
+        }
+        case 'modules': {
+            const sub = positional[0];
+            const files = positional.slice(1);
+            if (sub === 'validate') {
+                if (files.length === 0) {
+                    console.error('Usage: uwmd modules validate <manifest.json...> [--tier <viewer-tier>] [--json]');
+                    process.exit(1);
+                }
+                cmdModulesValidate(files, flags);
+            }
+            else if (sub === 'list') {
+                if (files.length === 0) {
+                    console.error('Usage: uwmd modules list <manifest.json...> [--tier <viewer-tier>] [--json]');
+                    process.exit(1);
+                }
+                cmdModulesList(files, flags);
+            }
+            else {
+                console.error('Usage: uwmd modules <validate|list> <manifest.json...>');
+                process.exit(1);
+            }
+            break;
+        }
+        case 'receipt': {
+            const sub = positional[0];
+            if (sub === 'issue') {
+                if (!positional[1]) {
+                    console.error('Usage: uwmd receipt issue <file> [--output <file.receipt.json>] [--issued-at <iso>] [--stdout]');
+                    process.exit(1);
+                }
+                await cmdReceiptIssue(positional[1], flags);
+            }
+            else if (sub === 'verify') {
+                if (!positional[1] || !positional[2]) {
+                    console.error('Usage: uwmd receipt verify <file> <receipt.json> [--json]');
+                    process.exit(1);
+                }
+                await cmdReceiptVerify(positional[1], positional[2], flags);
+            }
+            else {
+                console.error('Usage: uwmd receipt <issue|verify> ...');
+                process.exit(1);
+            }
+            break;
+        }
         default:
             console.log(`
-uwmd — .uw.md underwriting file toolkit
+uwmd — UW Markdown underwriting file toolkit
 
 Commands:
   parse    <file>              Parse file and output JSON
@@ -799,14 +1188,18 @@ Commands:
   compact  <file>              Strip superseded blocks
   diff     <file-a> <file-b>  Compare two files section by section
   calc     <file> <calc.json>  Evaluate a calc declaration or inline formula (Tier-3)
-  init                         Generate a blank .uw.md file
+  init                         Generate a blank .uwx.md file
   summary  <file>              Print quick metrics to terminal
   export   <file>              Export a digested UW JSON 1.0 document
   formats                       List registered machine representations
-  convert  <file>              Convert Markdown/JSON/XML/CSV bundle representations
+  convert  <file>              Convert Lite/UWX/JSON/XML/CSV bundle representations
   report   <file>              Render the lender package / credit memo HTML (§7.1/§7.2)
   scope    <file>              Resolve every required input via the fallback cascade and emit a triage view
   refine   <file>              Rank gaps by value-of-information for stated calc targets
+  receipt  issue|verify         Issue or verify a detached verification receipt (RFC 0016)
+  modules  validate|list        Validate module manifest files, or list the registry they form
+  lease    validate|project     Validate a lease abstract, or project it to a rent-roll row (RFC 0018)
+  package  create|verify|...    Build, verify, list, or project a UW Deal Package (RFC 0018)
   layers                       List Bancroft agent layers
 
 Options:
@@ -817,7 +1210,10 @@ Options:
   --format <f>       Render format: json|csv|chat|summary (render, default: summary)
   --no-superseded    Drop append-only history from the .uw.json export (export)
   --stdout           Write export/convert output to stdout
-  --to <format>       Target representation: uw-json|uw-xml|uw-csv-bundle (convert)
+  --to <format>       Target: lite|uwx|uw-json|uw-xml|uw-csv-bundle (convert)
+  --projection-report Write the UWX-to-Lite omission report as JSON (convert)
+  --issued-at <iso>  Fix the receipt issuance timestamp (receipt issue)
+  --tier <tier>      Host viewer tier to load modules against (modules)
   --max-tokens <n>   Max tokens for chat render (default: 12000)
   --institution <f>  Path to .uw.institution.json config (validate)
   --name <n>         Deal name (init)