@north-light/crouter 0.3.192 → 0.3.194

package/dist/clients/inbox/__tests__/serial/inbox-controller.test.js

@@ -1,159 +1,69 @@
 import assert from 'node:assert/strict';
 import { createServer } from 'node:http';
-import { existsSync, mkdtempSync, realpathSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { claimExists } from '#core/human/claim';
 import { ticketDir } from '#core/human/root';
-import { cancelTicket, submitDeck, takeoverAndCompleteDeck } from '#core/human/tickets';
+import { submitPage, takeoverAndCompletePage, writePageProgress } from '#core/human/tickets';
 import { InboxController } from '../../controller.js';
 const key = (part = {}) => ({ ctrl: false, meta: false, upArrow: false, downArrow: false, leftArrow: false, rightArrow: false, wordLeft: false, wordRight: false, home: false, end: false, pageUp: false, pageDown: false, del: false, return: false, newline: false, escape: false, tab: false, backspace: false, ...part });
 function fakeHost() {
-    let closed = false;
-    const cleanup = [];
-    const handle = {
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            for (const fn of cleanup)
-                void fn();
-            cleanup.length = 0;
-        },
-        invalidate() { },
-        onClose(fn) {
-            if (!closed)
-                cleanup.push(fn);
-        },
-    };
-    return {
-        capabilities: { remote: false, canFocusNode: false, selfPane: undefined },
-        mount() { return handle; },
-        notice() { },
-        suspendForChild() { return () => { }; },
-        focusNode: async () => false,
-        pickReviewFile: async () => null,
-    };
+    const handle = { close() { }, invalidate() { }, onClose() { } };
+    return { capabilities: { remote: false, canFocusNode: false, selfPane: undefined }, mount: () => handle, notice() { }, suspendForChild: () => () => { }, focusNode: async () => false, pickReviewFile: async () => null };
 }
-const makeController = (options) => new InboxController({ host: fakeHost(), onDirty: () => { }, onClosed: () => { }, ...options });
-const tick = () => new Promise((resolve) => setImmediate(resolve));
-function select(controller, dir) {
-    const count = controller.snapshot().items.length;
-    const matches = () => {
-        const selected = controller.snapshot().selectedDir;
-        return selected !== undefined && realpathSync(selected) === realpathSync(dir);
-    };
-    for (let i = 0; i < count && !matches(); i++)
-        controller.handleKey('j', key());
-    assert.ok(matches(), `expected ${dir} to be selectable`);
-}
-async function waitFor(predicate, message) {
-    const deadline = Date.now() + 1_000;
-    while (!predicate()) {
-        if (Date.now() >= deadline)
-            throw new Error(message);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-}
-// The controller answers a ticket by crossing the daemon `/resolve` seam. This
-// fake daemon plays back each failure the seam can return so the controller's
-// unmount-or-retry decision is exercised against a real socket.
-let mode = 'success';
+const controller = (options = {}) => new InboxController({ host: fakeHost(), onDirty() { }, onClosed() { }, ...options });
+async function waitFor(predicate, message) { const end = Date.now() + 1000; while (!predicate()) {
+    if (Date.now() > end)
+        throw new Error(message);
+    await new Promise((r) => setTimeout(r, 10));
+} }
+const temp = mkdtempSync(join(tmpdir(), 'crtr-inbox-controller-'));
+const sources = mkdtempSync(join(tmpdir(), 'crtr-page-sources-'));
+process.env['CRTR_HOME'] = temp;
+let received;
 async function startDaemon() {
     const server = createServer(async (req, res) => {
         if (!req.url?.endsWith('/resolve')) {
             res.statusCode = 404;
-            res.end(JSON.stringify({ error: { code: 'not_found', message: 'not found' } }));
-            return;
-        }
-        if (mode === 'unreachable') {
-            res.statusCode = 503;
-            res.end(JSON.stringify({ error: { code: 'daemon_unavailable', message: 'offline' } }));
+            res.end();
             return;
         }
-        const body = await new Promise((resolve) => {
-            let text = '';
-            req.on('data', (chunk) => { text += chunk; });
-            req.on('end', () => resolve(text));
-        });
+        const body = await new Promise((resolve) => { let text = ''; req.on('data', (c) => { text += c; }); req.on('end', () => resolve(text)); });
         const nodeId = req.url.split('/').at(-2);
-        if (mode === 'already_resolved') {
-            res.statusCode = 409;
-            res.end(JSON.stringify({ error: { code: 'ticket_already_resolved', message: 'ticket already resolved' } }));
-            return;
-        }
-        const request = JSON.parse(body);
-        if (request.responses === undefined)
-            throw new Error('expected a deck resolution');
-        takeoverAndCompleteDeck(ticketDir(nodeId), request.responses, { host: 'daemon', pid: 1 });
-        if (mode === 'delivery_failed') {
-            res.statusCode = 500;
-            res.end(JSON.stringify({ error: { code: 'delivery_failed', message: 'final report delivery failed' } }));
-            return;
-        }
-        res.end(JSON.stringify({ delivered: true, kind: 'deck' }));
+        received = JSON.parse(body).responses;
+        takeoverAndCompletePage(ticketDir(nodeId), received, { host: 'daemon', pid: 1 });
+        res.end(JSON.stringify({ delivered: true, kind: 'page' }));
     });
-    await new Promise((resolve) => server.listen(join(process.env['CRTR_HOME'], 'crtrd.sock'), resolve));
+    await new Promise((resolve) => server.listen(join(temp, 'crtrd.sock'), resolve));
     return server;
 }
-const temp = mkdtempSync(join(tmpdir(), 'crtr-inbox-controller-'));
-process.env['CRTR_HOME'] = temp;
+const source = (name, body) => { const path = join(sources, name); writeFileSync(path, body); return path; };
+const ask = source('ask.md', `---\ntitle: Restored page\nsubtitle: Pick one\nplacement: panel\n---\n\nLeading prose\n\n\`\`\`slot:options\n{"id":"choice","mode":"single","options":[{"id":"yes","label":"Yes"},{"id":"no","label":"No"}]}\n\`\`\`\n`);
+const html = source('rich.html', '<!doctype html><html><head><meta name="crtr-page-title" content="Rich page"><meta name="crtr-page-subtitle" content="Browser content"></head><body><crtr-pages><crtr-page><crtr-chart><script type="application/json">{"kind":"bar","x":"day","y":[{"field":"count"}]}</script></crtr-chart></crtr-page></crtr-pages></body></html>');
 const server = await startDaemon();
-const deck = (id) => ({ title: id, source: { blockedSince: new Date().toISOString(), sessionName: 'Release planning', nodeId: 'node-private-123' }, interactions: [{ id: 'answer', title: 'Answer', subtitle: 'Answer requires your attention.', options: [{ id: 'yes', label: 'Yes', shortcut: 'y' }] }] });
 try {
-    const first = submitDeck({ dir: ticketDir('first'), deck: deck('first') });
-    const active = makeController({ cols: 100, rows: 24 });
+    const ticket = submitPage({ dir: ticketDir('page-one'), sourceFile: ask, dialect: 'md' });
+    writePageProgress(ticket.dir, { choice: { selectedOptionIds: ['yes'], comments: [] } });
+    const active = controller({ cols: 100, rows: 24 });
     active.activate();
-    active.handleKey('y', key());
-    await waitFor(() => existsSync(join(first.dir, 'response.json')), 'a deck resolution crosses the controller daemon seam');
-    await waitFor(() => active.snapshot().screen === 'list', 'a successful daemon resolution unmounts the ticket');
+    assert.equal(active.snapshot().screen, 'detail', 'page ticket opens in the page panel');
+    active.handleKey('n', key());
+    active.handleKey('', key({ return: true }));
+    await waitFor(() => existsSync(join(ticket.dir, 'response.json')), 'restored page responses cross the daemon seam');
+    assert.deepEqual(received, { choice: { selectedOptionIds: ['yes'], comments: [] } }, 'progress.json is restored into the response map');
     active.close();
-    // A ticket arriving mid-edit must not move selection or clobber the freetext
-    // the user is part way through typing.
-    const editing = submitDeck({ dir: ticketDir('editing'), deck: { title: 'Editing', interactions: [{ id: 'note', title: 'Notes', subtitle: 'Notes require your attention.', options: [], allowFreetext: true }] } });
-    const editingController = makeController({ cols: 100, rows: 24 });
-    select(editingController, editing.dir);
-    editingController.activate();
-    editingController.handleKey('r', key());
-    for (const char of 'draft')
-        editingController.handleKey(char, key());
-    submitDeck({ dir: ticketDir('arrival'), deck: deck('arrival') });
-    editingController.rescan();
-    assert.equal(realpathSync(editingController.snapshot().selectedDir), realpathSync(editing.dir), 'arrival does not steal active selection');
-    assert.equal(editingController.snapshot().inputBuffer, 'draft', 'arrival does not alter freetext input');
-    editingController.close();
-    cancelTicket(editing.dir, { reason: 'done editing' });
-    const already = submitDeck({ dir: ticketDir('already'), deck: deck('already') });
-    const alreadyController = makeController({ cols: 100, rows: 24 });
-    alreadyController.activate();
-    cancelTicket(already.dir, { reason: 'resolved elsewhere' });
-    mode = 'already_resolved';
-    alreadyController.handleKey('y', key());
-    await waitFor(() => alreadyController.snapshot().screen === 'list', 'already_resolved unmounts instead of offering a stale resubmit');
-    assert.equal(claimExists(already.dir), true, 'already_resolved retains the daemon-taken claim');
-    alreadyController.close();
-    const delivery = submitDeck({ dir: ticketDir('delivery'), deck: deck('delivery') });
-    mode = 'delivery_failed';
-    const deliveryController = makeController({ cols: 100, rows: 24 });
-    deliveryController.activate();
-    deliveryController.handleKey('y', key());
-    await waitFor(() => deliveryController.snapshot().screen === 'list', 'delivery_failed unmounts because the canonical answer is already recorded');
-    assert.equal(existsSync(join(delivery.dir, 'response.json')), true, 'delivery_failed still leaves the canonical response on disk');
-    deliveryController.close();
-    const retry = submitDeck({ dir: ticketDir('retry'), deck: deck('retry') });
-    mode = 'unreachable';
-    const retryController = makeController({ cols: 100, rows: 24 });
-    retryController.activate();
-    retryController.handleKey('y', key());
-    await tick();
-    assert.equal(retryController.snapshot().screen, 'detail', 'unreachable keeps the mounted answer available for retry');
-    assert.equal(existsSync(join(retry.dir, 'response.json')), false, 'unreachable does not manufacture a local completion');
-    retryController.close();
+    submitPage({ dir: ticketDir('rich-page'), sourceFile: html, dialect: 'html' });
+    const preview = controller({ cols: 100, rows: 24 });
+    assert.match(preview.render().join('\n'), /rich page — open in Northlight/, 'html page preview points to the rich surface');
+    preview.activate();
+    assert.match(preview.render().join('\n'), /chart — bar: day vs count/, 'html page uses the same manifest-backed terminal projection');
+    preview.close();
 }
 finally {
     server.closeAllConnections();
     await new Promise((resolve) => server.close(() => resolve()));
     rmSync(temp, { recursive: true, force: true });
+    rmSync(sources, { recursive: true, force: true });
     delete process.env['CRTR_HOME'];
 }
 console.log('inbox controller tests passed');

package/dist/clients/inbox/__tests__/serial/mount-panel.test.js

@@ -1,151 +1,75 @@
-import { mountPanel } from '../../tui/panel.js';
 import assert from 'node:assert/strict';
-// Answer-integrity regressions: every case below is a way the panel once lost or
-// invented an answer on the user's behalf.
-function mkKey(partial) {
-    return {
-        ctrl: false,
-        meta: false,
-        upArrow: false,
-        downArrow: false,
-        leftArrow: false,
-        rightArrow: false,
-        wordLeft: false,
-        wordRight: false,
-        home: false,
-        end: false,
-        pageUp: false,
-        pageDown: false,
-        del: false,
-        return: false,
-        newline: false,
-        escape: false,
-        tab: false,
-        backspace: false,
-        ...partial,
-    };
-}
-const RETURN = mkKey({ return: true });
-// ── An empty Enter in freetext-only mode records the response ─────────────────
-// Regression: an empty buffer failed a truthy guard, so the response was never
-// recorded, the deck could never reach a full response set, and onComplete
-// never fired — leaving the deck permanently unfinishable.
-const freetextOnlyDeck = {
-    title: 'Test deck',
-    interactions: [
-        { id: 'q1', title: 'Optional notes', subtitle: 'Optional notes requires your attention.', options: [], allowFreetext: true },
-    ],
-};
-let capturedFreetextEmpty = [];
-const ftPanel = mountPanel({
-    deck: freetextOnlyDeck,
-    cols: 80,
-    rows: 24,
-    onComplete: (responses) => { capturedFreetextEmpty = responses; },
-});
-// Single-item deck starts directly in item-review (no overview). 'r' opens freetext.
-ftPanel.handleKey('r', mkKey({}));
-ftPanel.handleKey('', RETURN); // submit with an empty buffer
-ftPanel.handleKey('', RETURN); // final phase → complete
-assert.deepEqual(capturedFreetextEmpty, [{ id: 'q1', freetext: '' }], 'empty freetext Enter must record response and fire onComplete');
-ftPanel.unmount();
-// ── An empty Enter in comment mode records the response ───────────────────────
-const commentDeck = {
-    title: 'Test deck',
-    interactions: [
-        {
-            id: 'c1', title: 'Approve deploy?', subtitle: 'Approve deploy? requires your attention.',
-            options: [{ id: 'yes', label: 'Yes', shortcut: 'y' }],
-            allowFreetext: true,
-        },
-    ],
-};
-let capturedCommentEmpty = [];
-const cmPanel = mountPanel({
-    deck: commentDeck,
-    cols: 80,
-    rows: 24,
-    onComplete: (responses) => { capturedCommentEmpty = responses; },
-});
-// Navigate to the [c] row WITHOUT pre-attaching an option, then comment.
-cmPanel.handleKey('j', mkKey({}));
-cmPanel.handleKey('c', mkKey({}));
-cmPanel.handleKey('', RETURN); // submit an empty comment, no option selected
-cmPanel.handleKey('', RETURN); // final phase → complete
-assert.deepEqual(capturedCommentEmpty, [{ id: 'c1', freetext: '' }], 'empty Enter in comment mode must record response and fire onComplete');
-cmPanel.unmount();
-// ── Option-shortcut letters typed in comment mode are text, never a choice ────
-// Regression: pressing an option's shortcut while commenting submitted that
-// option for the user instead of appending the character to the buffer.
-const shortcutTypingDeck = {
-    title: 'Test deck',
-    interactions: [
-        {
-            id: 'q1', title: 'Approve?', subtitle: 'Approve? requires your attention.',
-            options: [
-                { id: 'yes', label: 'Yes', shortcut: 'y' },
-                { id: 'no', label: 'No', shortcut: 'n' },
-            ],
-            allowFreetext: true,
-        },
-    ],
-};
-let capturedShortcutTyping = [];
-const stPanel = mountPanel({
-    deck: shortcutTypingDeck,
-    cols: 80,
-    rows: 24,
-    onComplete: (responses) => { capturedShortcutTyping = responses; },
-});
-stPanel.handleKey('j', mkKey({}));
-stPanel.handleKey('j', mkKey({}));
-stPanel.handleKey('c', mkKey({}));
-// 'y' and 'n' are both option shortcuts; every character must reach the buffer.
-for (const ch of 'yes no')
-    stPanel.handleKey(ch, mkKey({}));
-stPanel.handleKey('', RETURN); // submit the comment — must carry no selectedOptionId
-stPanel.handleKey('', RETURN); // final → complete
-assert.deepEqual(capturedShortcutTyping, [{ id: 'q1', freetext: 'yes no' }], 'option-shortcut letters typed in comment mode must append to buffer, not select option');
-stPanel.unmount();
-// ── Multi-select needs an explicit confirm, and an empty Enter does nothing ───
-// Two regressions on one deck: Enter with nothing toggled committed an empty
-// set and finalized, and a confirmed set auto-finalized with no chance to
-// review it.
-const multiDeck = {
-    title: 'Test deck',
-    interactions: [
-        {
-            id: 'cs1', title: 'Pick toppings', subtitle: 'Pick toppings requires your attention.', multiSelect: true,
-            options: [
-                { id: 'mush', label: 'Mushroom', shortcut: 'a' },
-                { id: 'onion', label: 'Onion', shortcut: 'b' },
-            ],
-        },
-    ],
-};
-let multiFired = false;
-let multiResponses = [];
-const multiPanel = mountPanel({
-    deck: multiDeck,
-    cols: 80,
-    rows: 24,
-    onComplete: (responses) => { multiFired = true; multiResponses = responses; },
-});
-// Nothing toggled: Enter must be an inert no-op, not an empty answer.
-multiPanel.handleKey('', RETURN);
-assert.equal(multiFired, false, 'Enter with an empty multi-select set must NOT finalize');
-const stillReview = multiPanel.render().join('\n');
-assert.ok(stillReview.includes('Pick toppings'), 'after empty Enter, still on the interaction (no advance)');
-assert.ok(!stillReview.includes('Summary'), 'after empty Enter, the deck did NOT advance to the Summary screen');
-assert.ok(stillReview.toLowerCase().includes('select at least one'), 'empty multi-select Enter surfaces an inline hint');
-// Toggle an option and confirm the set: the first Enter reviews, never submits.
-multiPanel.handleKey(' ', mkKey({}));
-multiPanel.handleKey('', RETURN);
-assert.equal(multiFired, false, 'multi-select first Enter must NOT auto-finalize (lands on the confirm screen)');
-assert.ok(multiPanel.render().join('\n').includes('Summary'), 'after confirming a multi-select set, the deck shows the Summary/confirm screen');
-// A second deliberate Enter submits exactly the toggled set.
-multiPanel.handleKey('', RETURN);
-assert.equal(multiFired, true, 'second Enter on the Summary screen finalizes the multi-select deck');
-assert.deepEqual(multiResponses, [{ id: 'cs1', selectedOptionIds: ['mush'] }], 'confirmed multi-select set returned on finalize');
+import { mountPanel } from '../../tui/panel.js';
+function key(partial = {}) { return { ctrl: false, meta: false, upArrow: false, downArrow: false, leftArrow: false, rightArrow: false, wordLeft: false, wordRight: false, home: false, end: false, pageUp: false, pageDown: false, del: false, return: false, newline: false, escape: false, tab: false, backspace: false, ...partial }; }
+const enter = key({ return: true });
+const manifest = (slots, extra = {}) => ({ schema: 'crtr.page/v1', dialect: 'md', title: 'Test page', placement: 'panel', document: 'page.md', steps: 1, slots, ...extra });
+const projection = (slots, prose = []) => prose.length > 0 ? prose : slots.map((slotIndex) => ({ kind: 'slot', slotIndex }));
+// Option comment is anchored and survives the subsequent single-select completion.
+const options = manifest([{ id: 'choice', kind: 'options', step: 0, config: { mode: 'single', options: [{ id: 'yes', label: 'Yes' }, { id: 'no', label: 'No' }] } }]);
+let optionResponses = {};
+const optionsPanel = mountPanel({ manifest: options, projection: projection([0]), cols: 80, rows: 24, onComplete: (r) => { optionResponses = r; } });
+optionsPanel.handleKey('c', key());
+for (const ch of 'ship it')
+    optionsPanel.handleKey(ch, key());
+optionsPanel.handleKey('', enter);
+optionsPanel.handleKey('y', key());
+assert.deepEqual(optionResponses, { choice: { selectedOptionIds: ['yes'], comments: [{ id: 'option:yes', anchor: { kind: 'option', optionId: 'yes' }, text: 'ship it' }] } });
+optionsPanel.unmount();
+// Multi-select empty Enter remains inert; selection confirmation lands on Summary before submit.
+const multi = manifest([{ id: 'toppings', kind: 'options', step: 0, config: { mode: 'multi', options: [{ id: 'mush', label: 'Mushroom' }, { id: 'onion', label: 'Onion' }] } }]);
+let multiResponses;
+const multiPanel = mountPanel({ manifest: multi, projection: projection([0]), cols: 80, rows: 24, onComplete: (r) => { multiResponses = r; } });
+multiPanel.handleKey('', enter);
+assert.equal(multiResponses, undefined);
+assert.match(multiPanel.render().join('\n'), /select at least one/i);
+multiPanel.handleKey(' ', key());
+multiPanel.handleKey('', enter);
+assert.match(multiPanel.render().join('\n'), /Summary/);
+assert.equal(multiResponses, undefined);
+multiPanel.handleKey('', enter);
+assert.deepEqual(multiResponses, { toppings: { selectedOptionIds: ['mush'], comments: [] } });
 multiPanel.unmount();
+// Table selection uses row ids and permits an empty committed selection by schema.
+const table = manifest([{ id: 'rows', kind: 'table', step: 0, config: { columns: [{ id: 'name', label: 'Name' }], rows: [{ id: 'a', cells: { name: 'Alpha' } }, { id: 'b', cells: { name: 'Beta' } }], rowSelect: 'multi', columnSelect: 'none' } }]);
+let tableResponses = {};
+const tablePanel = mountPanel({ manifest: table, projection: projection([0]), cols: 80, rows: 24, onComplete: (r) => { tableResponses = r; } });
+assert.match(tablePanel.render().join('\n'), /Alpha/);
+tablePanel.handleKey(' ', key());
+tablePanel.handleKey('', enter);
+tablePanel.handleKey('', enter);
+assert.deepEqual(tableResponses, { rows: { selectedRowIds: ['a'], selectedColumnIds: [], comments: [] } });
+tablePanel.unmount();
+// A display-only page is dismissed with q and completes with an empty response map.
+let displayResponses;
+const displayPanel = mountPanel({ manifest: manifest([]), projection: [{ kind: 'prose', markdown: 'FYI only' }], cols: 80, rows: 24, onComplete: (r) => { displayResponses = r; } });
+displayPanel.handleKey('q', key());
+assert.deepEqual(displayResponses, {});
+displayPanel.unmount();
+// A single-slot page opens in item-review, so its leading prose renders there.
+const lone = manifest([{ id: 'only', kind: 'options', step: 0, config: { mode: 'single', options: [{ id: 'a', label: 'Alpha' }] } }]);
+const lonePanel = mountPanel({ manifest: lone, projection: projection([], [{ kind: 'prose', markdown: 'Read this first' }, { kind: 'slot', slotIndex: 0 }]), cols: 80, rows: 24 });
+assert.match(lonePanel.render().join('\n'), /Read this first/);
+lonePanel.unmount();
+// An unvalidated slot takes no terminal input and keeps the page unsubmittable.
+const unvalidated = manifest([{ id: 'widget', kind: 'acme.widget', step: 0, config: {}, unvalidated: true }]);
+let unvalidatedResponses;
+const unvalidatedPanel = mountPanel({ manifest: unvalidated, projection: projection([0]), cols: 80, rows: 24, onComplete: (r) => { unvalidatedResponses = r; } });
+unvalidatedPanel.handleKey('c', key());
+assert.equal(unvalidatedPanel.getInputBuffer(), undefined);
+unvalidatedPanel.handleKey('n', key());
+assert.match(unvalidatedPanel.render().join('\n'), /must be answered in Northlight/);
+unvalidatedPanel.handleKey('', enter);
+assert.equal(unvalidatedResponses, undefined);
+unvalidatedPanel.unmount();
+// Overview groups slots by step, without adding a progression gate.
+const stepped = manifest([
+    { id: 'one', kind: 'options', step: 0, config: { mode: 'single', options: [{ id: 'a', label: 'Alpha' }] } },
+    { id: 'two', kind: 'options', step: 1, config: { mode: 'single', options: [{ id: 'b', label: 'Beta' }] } },
+], { dialect: 'html', document: 'page.html', steps: 2 });
+const steppedPanel = mountPanel({ manifest: stepped, projection: projection([0, 1]), cols: 80, rows: 24 });
+const overview = steppedPanel.render().join('\n');
+assert.match(overview, /Step 1\/2/);
+assert.match(overview, /Step 2\/2/);
+assert.match(overview, /rich page — open in Northlight/);
+steppedPanel.unmount();
 console.log('OK');

package/dist/clients/inbox/controller.d.ts

@@ -53,12 +53,11 @@ export declare class InboxController {
     private cancelFromInbox;
     activate(): void;
     private activateReview;
-    reloadSelectedDeck(): void;
-    private readDeck;
+    reloadSelectedPage(): void;
     close(): void;
     private complete;
     /** Edit the active buffer while the host releases the terminal to $EDITOR. */
-    private editActiveDeckInput;
+    private editActivePageInput;
     private leaveDetail;
     private select;
     private detailSize;

package/dist/clients/inbox/controller.js

@@ -4,16 +4,16 @@ import { BOLD, CYAN, DIM, GRAY, RESET, YELLOW, clipLine } from './tui/ansi.js';
 import { buildInboxLines } from './tui.js';
 import { inboxLayout } from './layout.js';
 import { scanInbox } from '../../core/human/scan.js';
+import { readConfig } from '../../core/config.js';
+import { parsePageSource } from '../../core/human/page.js';
 import { watchInboxActivity } from '../../core/human/root.js';
 import { claimTicket, heartbeatClaim, releaseClaim } from '../../core/human/claim.js';
-import { readTicketResult } from '../../core/human/tickets.js';
-import { clearProgress, deckPath } from '../../core/human/convention.js';
-import { readJsonOrNull } from '../../core/fs-utils.js';
-import { DeckAdapter } from './deck-adapter.js';
-import { validateDeck } from '../../core/human/deck-schema.js';
+import { readPageTicket, readTicketResult } from '../../core/human/tickets.js';
+import { clearProgress } from '../../core/human/convention.js';
+import { PageAdapter } from './page-adapter.js';
 import { ReviewAdapter } from './review-adapter.js';
 import { editBufferInEditor } from './review/roundtrip.js';
-import { cancelTicketViaDaemon, daemonErrorMessage, nodeIdFor, resolveFailureKind, resolveTicketDeck, } from './resolve.js';
+import { cancelTicketViaDaemon, daemonErrorMessage, nodeIdFor, resolveFailureKind, resolveTicketPage, } from './resolve.js';
 /** Host-agnostic model for scanning, stable selection, claims, and rendering. */
 export class InboxController {
     options;
@@ -40,7 +40,7 @@ export class InboxController {
     constructor(options) {
         this.options = options;
         this.host = options.host;
-        this.scan = options.scan ?? scanInbox;
+        this.scan = options.scan ?? (() => scanInbox(readConfig('user').page_components ?? []));
         this.cols = options.cols ?? 80;
         this.rows = options.rows ?? 24;
         this.rescan();
@@ -113,7 +113,7 @@ export class InboxController {
             // Hard-clip the list line to its column: an overflowing row would eat
             // the pad and push the divider out of alignment for that row alone.
             const left = clipLine(list[i] ?? '', geometry.listWidth);
-            // Clip the detail column too: a deck/preview row is only ever entitled to
+            // Clip the detail column too: a preview row is only ever entitled to
             // its own panel, so an over-wide row cannot run past the pane's edge.
             const right = clipLine(detail[i] ?? '', geometry.detailWidth);
             const pad = ' '.repeat(Math.max(0, geometry.listWidth - visibleWidth(left)));
@@ -197,7 +197,7 @@ export class InboxController {
             void this.activateReview(item);
             return;
         }
-        if (item.kind !== 'deck')
+        if (item.kind !== 'page')
             return;
         const claim = claimTicket(item.dir);
         if (claim === null) {
@@ -205,23 +205,30 @@ export class InboxController {
             return;
         }
         this.claim = { dir: item.dir, token: claim.token };
-        const deck = this.readDeck(item.dir);
-        if (deck === undefined) {
+        let loaded;
+        try {
+            const productKinds = readConfig('user').page_components ?? [];
+            const ticket = readPageTicket(item.dir, productKinds);
+            loaded = { ticket, projection: parsePageSource(ticket.document, ticket.manifest, productKinds) };
+        }
+        catch {
             releaseClaim(item.dir, claim.token);
             this.claim = undefined;
+            this.status = 'page could not be read';
             this.invalidate();
             return;
         }
-        // Notifications use the same canonical deck panel as every other deck:
-        // opening is not acknowledgement; panel completion is.
+        const productKinds = readConfig('user').page_components ?? [];
         this.screen = 'detail';
-        this.adapter = new DeckAdapter({
+        this.adapter = new PageAdapter({
             dir: item.dir,
-            deck,
+            ticket: loaded.ticket,
+            projection: loaded.projection,
+            productKinds,
             cols: this.detailSize().cols,
             rows: this.detailSize().rows,
             onDirty: () => this.markDirty(),
-            onEditorRequest: () => this.editActiveDeckInput(),
+            onEditorRequest: () => this.editActivePageInput(),
             onBack: () => { this.leaveDetail(); this.markDirty(); },
             onComplete: (responses) => { void this.complete(responses); },
         });
@@ -244,30 +251,20 @@ export class InboxController {
             this.markDirty();
         }
     }
-    reloadSelectedDeck() {
+    reloadSelectedPage() {
         if (this.adapter === undefined || this.claim === undefined) {
             this.markDirty();
             return;
         }
-        const deck = this.readDeck(this.claim.dir);
-        if (deck === undefined) {
-            this.markDirty();
-            return;
-        }
-        // Reload applies the latest deck shape before the panel preserves surviving answers.
-        this.adapter.reload(deck);
-        this.markDirty();
-    }
-    readDeck(dir) {
-        const deck = readJsonOrNull(deckPath(dir));
-        if (deck === null)
-            return undefined;
         try {
-            return validateDeck(deck);
+            const productKinds = readConfig('user').page_components ?? [];
+            const ticket = readPageTicket(this.claim.dir, productKinds);
+            this.adapter.reload(ticket, parsePageSource(ticket.document, ticket.manifest, productKinds));
         }
         catch {
-            return undefined;
+            this.status = 'page could not be read';
         }
+        this.markDirty();
     }
     close() {
         if (this.closed)
@@ -292,7 +289,7 @@ export class InboxController {
             return;
         this.submittingDir = claim.dir;
         try {
-            await resolveTicketDeck(claim.dir, responses);
+            await resolveTicketPage(claim.dir, responses);
         }
         catch (error) {
             this.submittingDir = undefined;
@@ -315,7 +312,7 @@ export class InboxController {
         this.markDirty();
     }
     /** Edit the active buffer while the host releases the terminal to $EDITOR. */
-    editActiveDeckInput() {
+    editActivePageInput() {
         const buffer = this.adapter?.inputBuffer();
         if (buffer === undefined)
             return;
@@ -359,8 +356,8 @@ export class InboxController {
         if (selected === undefined)
             return this.passiveDetailLines(width).slice(0, rows);
         const focusHint = this.focusAvailable(selected.dir) ? `  ${DIM}g${RESET} chat` : '';
-        const footer = selected.kind === 'deck'
-            ? [`  ${DIM}Enter${RESET} opens the full ticket  ${DIM}j/k${RESET} select  ${DIM}x${RESET} cancel`, `  ${DIM}Active ask:${RESET} c comment  u/d scroll${focusHint}  ${DIM}q${RESET} close`]
+        const footer = selected.kind === 'page'
+            ? [`  ${DIM}Enter${RESET} opens the full page  ${DIM}j/k${RESET} select  ${DIM}x${RESET} cancel`, `  ${DIM}Page:${RESET} c comment  u/d scroll${focusHint}  ${DIM}q${RESET} close`]
             : [`  ${DIM}Enter${RESET} opens the full review  ${DIM}j/k${RESET} select  ${DIM}x${RESET} cancel`, ` ${focusHint}  ${DIM}q${RESET} close`];
         const preview = this.passiveDetailLines(width).slice(0, Math.max(0, rows - footer.length));
         return [...preview, ...footer.map((line) => clipLine(line, width))];
@@ -394,10 +391,12 @@ export class InboxController {
         const lines = [`  ${BOLD}${CYAN}${selected.title}${RESET}`, ''];
         for (const rendered of renderMarkdown(selected.subtitle, Math.max(1, width - 2)))
             lines.push(`  ${rendered}`);
-        const count = selected.kind === 'deck'
-            ? `${selected.interactionCount} question${selected.interactionCount === 1 ? '' : 's'}`
+        const count = selected.kind === 'page'
+            ? `${selected.slotKinds.length} slot${selected.slotKinds.length === 1 ? '' : 's'}`
             : '1 file to review';
         lines.push('', `  ${DIM}${count}${RESET}`);
+        if (selected.kind === 'page' && selected.dialect === 'html')
+            lines.push(`  ${DIM}rich page — open in Northlight${RESET}`);
         return lines.map((line) => clipLine(line, width));
     }
     withStatus(lines) {
@@ -423,8 +422,8 @@ export class InboxController {
         this.selectedWatcher?.close();
         try {
             this.selectedWatcher = watch(dir, (_event, file) => {
-                if (file === 'deck.json') {
-                    this.reloadSelectedDeck();
+                if (file === 'page.json') {
+                    this.reloadSelectedPage();
                     return;
                 }
                 this.invalidate();
@@ -439,9 +438,9 @@ function visibleWidth(line) { return line.replace(/\x1b\[[0-9;]*m/g, '').length;
 function canonicalResultStatus(result) {
     if (result === null)
         return 'ticket was already resolved';
-    if (result.kind === 'deck')
-        return `ticket was already resolved: ${result.summary}`;
     if (result.kind === 'review')
         return `ticket was already resolved: ${result.result.approved ? 'approved' : 'review submitted'}`;
+    if (result.kind === 'page')
+        return 'ticket was already resolved: page submitted';
     return 'ticket was already canceled';
 }