@north-light/crouter 0.3.198 → 0.3.199

package/dist/core/command.js

@@ -542,7 +542,8 @@ export async function parseArgv(params, tokens, options) {
     const missing = [];
     for (const p of params) {
         const key = flagNameToKey(p.name);
-        if (p.required && (result[key] === undefined || result[key] === null)) {
+        const missingRequiredBool = p.kind === 'flag' && p.type === 'bool' && !provided.has(key);
+        if (p.required && (missingRequiredBool || result[key] === undefined || result[key] === null)) {
             const display = p.kind === 'positional'
                 ? `positional ${p.name.toUpperCase()}`
                 : p.kind === 'flag'

package/dist/core/config.d.ts

@@ -1,4 +1,4 @@
-import type { Scope, ScopeConfig, ScopeState, KindConfig, ModelLaddersConfig, ModelProvider, ModelStrength, ModelRouteConfig, ModelRoutingConfig } from '../types.js';
+import type { PageComponentRegistration, Scope, ScopeConfig, ScopeState, KindConfig, ModelLaddersConfig, ModelProvider, ModelStrength, ModelRouteConfig, ModelRoutingConfig } from '../types.js';
 import { type BindingId } from './keybindings/catalog.js';
 export declare function configPath(scope: Scope): string | null;
 export declare function statePath(scope: Scope): string | null;
@@ -26,6 +26,52 @@ export declare function ensureScopeInitialized(scope: Scope, root: string): void
 /** Normalize the user-owned list of attach actions allowed to bridge through an
  * occupied tmux root binding. Unknown and non-attach ids have no effect. */
 export declare function normalizeTmuxPassthrough(raw: unknown): BindingId[];
+/** One malformed `bin` declaration. The read path retains these as doctor
+ *  findings rather than letting malformed config break a node launch. */
+export interface BinDeclarationIssue {
+    name: string;
+    message: string;
+}
+/** Validate raw `bin` declaration shape without touching the filesystem.
+ *  Install uses these findings as a hard gate for plugin manifests; scope
+ *  resolution reports them through `crtr sys doctor` and continues. */
+export declare function binDeclarationIssues(raw: unknown): BinDeclarationIssue[];
+/** Normalize one raw `bin` block (a scope `config.json`'s or a plugin
+ *  manifest's) to name → root-relative path. Invalid entries never become
+ *  commands; `binDeclarationIssues` keeps them visible to Doctor. */
+export declare function normalizeBin(raw: unknown): Record<string, string>;
+/** STRICT install-time validation for a plugin-declared `bin` block. Target
+ *  filesystem state is checked later by Doctor because it can change after
+ *  install. */
+export declare function invalidPluginBinReasons(raw: unknown): string[];
+/** Normalize a plugin manifest's advisory executable requirements. Invalid
+ *  declarations stay out of the read path; source installs reject them through
+ *  `invalidPluginRequiresReasons`. */
+export declare function normalizeRequires(raw: unknown): Record<string, string>;
+/** STRICT install-time validation for a plugin's advisory `requires` block.
+ *  A missing executable is advisory; only malformed declarations fail install. */
+export declare function invalidPluginRequiresReasons(raw: unknown): string[];
+/** The ACTIVE page-component catalog every authoring, validation, daemon,
+ *  inbox, and TUI consumer resolves: the user scope's own `page_components`
+ *  entries plus the contributions of every ENABLED plugin installed under that
+ *  same root, plugin name-sorted for determinism (directory listing order is
+ *  filesystem-dependent). Installing, updating, or removing a plugin therefore
+ *  adds, changes, or retires its components with no config edit.
+ *
+ *  User scope only, deliberately: this catalog is read from the daemon, the
+ *  CLI, and the inbox TUI, whose ambient cwds differ, and a page slot whose
+ *  validity depended on which directory a process happened to start in would
+ *  validate in one surface and fail in another. `page_components` has always
+ *  been a user-scope block (`readConfig('user')`); its plugin channel keeps
+ *  that boundary.
+ *
+ *  Throws on a duplicate kind or derived JSX tag across sources, and on a
+ *  plugin whose block is malformed — matching the existing catalog validation
+ *  style, where a bad `page_components` block already fails config read rather
+ *  than silently dropping a component the product expects to be authorable.
+ *  Install-time validation (`invalidPageComponentsReasons`) is what keeps a
+ *  malformed block from ever reaching this path. */
+export declare function resolvePageComponents(): PageComponentRegistration[];
 /** STRICT install-time validation for a plugin-declared `kinds` block —
  *  the loud counterpart to `mergeKinds`'s silent read-time dropping. Read
  *  paths must never throw on bad config, but an INSTALL delivering a bad

package/dist/core/config.js

@@ -1,6 +1,6 @@
 import { dirname, join } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
-import { CONFIG_FILE, STATE_FILE, CONDENSED_HISTORY_MODES, MOUSE_MODE_DEFAULTS, DEFAULT_WHIP_MESSAGES, defaultScopeConfig, defaultScopeState, defaultModelLaddersConfig, defaultKindsConfig, defaultRemoteCanvasConfig } from '../types.js';
+import { CONFIG_FILE, STATE_FILE, CONDENSED_HISTORY_MODES, MOUSE_MODE_DEFAULTS, WHIP_MESSAGE_MODES, DEFAULT_WHIP_MESSAGES, defaultScopeConfig, defaultScopeState, defaultModelLaddersConfig, defaultKindsConfig, defaultRemoteCanvasConfig } from '../types.js';
 import { BINDING_CATALOG, BINDING_IDS, isAttachPaneBinding } from './keybindings/catalog.js';
 import { emitEvent } from './events/emit.js';
 import { atomicWriteJson, readJsonIfExists, writeJson, ensureDir } from './fs-utils.js';
@@ -10,7 +10,7 @@ import { profileRoot } from './profiles/manifest.js';
 import { withExclusiveDirectoryLock } from './exclusive-lock.js';
 import { SCOPE_CONFIG_KEYS } from './user-settings.js';
 import { normalizeWorkingGerunds } from '../shared/working-activity.js';
-import { normalizePageComponents } from './human/page-catalog.js';
+import { mergePageComponentLayers, normalizePageComponents } from './human/page-catalog.js';
 function configPathFor(root) {
     return join(root, CONFIG_FILE);
 }
@@ -266,6 +266,101 @@ function mergeSpawnEnv(raw, base = []) {
     }
     return { allow: [...new Set([...base, ...extra])] };
 }
+/** The one bare-command-name rule, shared by the read path (`normalizeBin`)
+ *  and the strict install gate (`invalidPluginBinReasons`): a name a shell can
+ *  invoke verbatim and a filesystem can hold as a single symlink entry — no
+ *  separator, no leading dot, no whitespace, no quoting ever required. */
+const BIN_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+/** Bare names crouter owns on every node's PATH. A contribution may not take
+ *  one: shadowing the CLI a node drives its own canvas with breaks the runtime
+ *  contract rather than extending it. */
+const RESERVED_BIN_NAMES = new Set(['crtr', 'crtrd']);
+/** The one bare-command-name validator shared by `bin` and plugin `requires`.
+ *  `bin` alone reserves crouter's own commands; a plugin may require any safe
+ *  executable name because it does not contribute or shadow that command. */
+function bareCommandNameIssue(name, field) {
+    if (field === 'bin' && RESERVED_BIN_NAMES.has(name))
+        return `${field}.${name} is reserved by crouter — pick another bare command name`;
+    if (!BIN_NAME_PATTERN.test(name))
+        return `${field}.${name} is not a safe bare command name (expected ${BIN_NAME_PATTERN.source})`;
+    return undefined;
+}
+/** Validate raw `bin` declaration shape without touching the filesystem.
+ *  Install uses these findings as a hard gate for plugin manifests; scope
+ *  resolution reports them through `crtr sys doctor` and continues. */
+export function binDeclarationIssues(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+        return [{ name: 'bin', message: 'bin must be a JSON object mapping bare command name to a relative path' }];
+    }
+    const issues = [];
+    for (const [name, target] of Object.entries(raw)) {
+        const nameIssue = bareCommandNameIssue(name, 'bin');
+        if (nameIssue !== undefined)
+            issues.push({ name, message: nameIssue });
+        if (typeof target !== 'string' || target.trim() === '') {
+            issues.push({ name, message: `bin.${name} must be a non-empty relative path to an executable inside the contributor root` });
+        }
+    }
+    return issues;
+}
+/** Normalize one raw `bin` block (a scope `config.json`'s or a plugin
+ *  manifest's) to name → root-relative path. Invalid entries never become
+ *  commands; `binDeclarationIssues` keeps them visible to Doctor. */
+export function normalizeBin(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return {};
+    const out = {};
+    for (const [name, target] of Object.entries(raw)) {
+        if (bareCommandNameIssue(name, 'bin') !== undefined)
+            continue;
+        if (typeof target !== 'string' || target.trim() === '')
+            continue;
+        out[name] = target;
+    }
+    return out;
+}
+/** STRICT install-time validation for a plugin-declared `bin` block. Target
+ *  filesystem state is checked later by Doctor because it can change after
+ *  install. */
+export function invalidPluginBinReasons(raw) {
+    return binDeclarationIssues(raw).map((issue) => issue.message);
+}
+/** Normalize a plugin manifest's advisory executable requirements. Invalid
+ *  declarations stay out of the read path; source installs reject them through
+ *  `invalidPluginRequiresReasons`. */
+export function normalizeRequires(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return {};
+    const out = {};
+    for (const [name, hint] of Object.entries(raw)) {
+        if (bareCommandNameIssue(name, 'requires') !== undefined)
+            continue;
+        if (typeof hint !== 'string' || hint.trim() === '' || /[\r\n]/.test(hint))
+            continue;
+        out[name] = hint;
+    }
+    return out;
+}
+/** STRICT install-time validation for a plugin's advisory `requires` block.
+ *  A missing executable is advisory; only malformed declarations fail install. */
+export function invalidPluginRequiresReasons(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+        return ['requires must be a JSON object mapping a bare executable name to a one-line install hint'];
+    }
+    const reasons = [];
+    for (const [name, hint] of Object.entries(raw)) {
+        const nameIssue = bareCommandNameIssue(name, 'requires');
+        if (nameIssue !== undefined)
+            reasons.push(nameIssue);
+        if (typeof hint !== 'string' || hint.trim() === '') {
+            reasons.push(`requires.${name} must be a non-empty one-line install hint`);
+        }
+        else if (/[\r\n]/.test(hint)) {
+            reasons.push(`requires.${name} must be a one-line install hint`);
+        }
+    }
+    return reasons;
+}
 /** Collect the valid `KindConfig` fields of one raw `kinds.<name>` entry —
  *  every field is optional here, `whenToUse` included; mistyped fields are
  *  dropped, never thrown (an invalid field in config.json must not break
@@ -341,6 +436,40 @@ function layerPluginKinds(scope, scopeRootPath, base) {
         out = mergeKinds(plugin.manifest.kinds, out);
     return out;
 }
+/** The ACTIVE page-component catalog every authoring, validation, daemon,
+ *  inbox, and TUI consumer resolves: the user scope's own `page_components`
+ *  entries plus the contributions of every ENABLED plugin installed under that
+ *  same root, plugin name-sorted for determinism (directory listing order is
+ *  filesystem-dependent). Installing, updating, or removing a plugin therefore
+ *  adds, changes, or retires its components with no config edit.
+ *
+ *  User scope only, deliberately: this catalog is read from the daemon, the
+ *  CLI, and the inbox TUI, whose ambient cwds differ, and a page slot whose
+ *  validity depended on which directory a process happened to start in would
+ *  validate in one surface and fail in another. `page_components` has always
+ *  been a user-scope block (`readConfig('user')`); its plugin channel keeps
+ *  that boundary.
+ *
+ *  Throws on a duplicate kind or derived JSX tag across sources, and on a
+ *  plugin whose block is malformed — matching the existing catalog validation
+ *  style, where a bad `page_components` block already fails config read rather
+ *  than silently dropping a component the product expects to be authorable.
+ *  Install-time validation (`invalidPageComponentsReasons`) is what keeps a
+ *  malformed block from ever reaching this path. */
+export function resolvePageComponents() {
+    const layers = [{ origin: 'config.json', components: readConfig('user').page_components }];
+    const root = scopeRoot('user');
+    if (root !== null) {
+        const plugins = listInstalledPluginsInRoot('user', root)
+            .filter((plugin) => plugin.enabled && plugin.manifest.page_components !== undefined)
+            .sort((a, b) => a.name.localeCompare(b.name));
+        for (const plugin of plugins) {
+            const label = `plugin "${plugin.name}" page_components`;
+            layers.push({ origin: `plugin "${plugin.name}"`, components: normalizePageComponents(plugin.manifest.page_components, label) });
+        }
+    }
+    return mergePageComponentLayers(layers);
+}
 const KIND_CONFIG_KEYS = new Set(['whenToUse', 'model', 'orchestratorModel', 'tools', 'extensions', 'availableTo']);
 /** STRICT install-time validation for a plugin-declared `kinds` block —
  *  the loud counterpart to `mergeKinds`'s silent read-time dropping. Read
@@ -480,8 +609,11 @@ function mergeConfig(partial) {
         : normalizeWorkingGerunds(partial.working_gerunds);
     const whip_mode = typeof partial.whip_mode === 'boolean' ? partial.whip_mode : defaults.whip_mode;
     const page_components = normalizePageComponents(partial.page_components);
-    const html_surface = typeof partial.html_surface === 'boolean' ? partial.html_surface : defaults.html_surface;
+    const page_surface = typeof partial.page_surface === 'boolean' ? partial.page_surface : defaults.page_surface;
     const whip_messages = normalizeWhipMessages(partial.whip_messages);
+    const whip_message_mode = WHIP_MESSAGE_MODES.includes(partial.whip_message_mode)
+        ? partial.whip_message_mode
+        : defaults.whip_message_mode;
     const mouse_mode_default = MOUSE_MODE_DEFAULTS.includes(partial.mouse_mode_default)
         ? partial.mouse_mode_default
         : defaults.mouse_mode_default;
@@ -501,7 +633,8 @@ function mergeConfig(partial) {
     const kinds = mergeKinds(partial.kinds);
     const remoteCanvas = mergeRemoteCanvas(partial.remoteCanvas);
     const spawnEnv = mergeSpawnEnv(partial.spawnEnv, defaults.spawnEnv?.allow);
-    return { schema_version, marketplaces, plugins, auto_update, max_panes_per_window, auto_open_child_viewers, brokerThresholds, completion_bell, working_gerunds, whip_mode, page_components, html_surface, whip_messages, mouse_mode_default, live_cycles, condensed_history, bash_tool_purpose, fold_finished_tools, summarize_tool_calls, detailed_tool_recaps, keybindings, tmux_passthrough, modelLadders, ...(Object.keys(modelRoutes).length > 0 ? { modelRoutes } : {}), ...(modelRouting !== undefined ? { modelRouting } : {}), kinds, remoteCanvas, spawnEnv };
+    const bin = normalizeBin(partial.bin);
+    return { bin, schema_version, marketplaces, plugins, auto_update, max_panes_per_window, auto_open_child_viewers, brokerThresholds, completion_bell, working_gerunds, whip_mode, page_components, page_surface, whip_messages, whip_message_mode, mouse_mode_default, live_cycles, condensed_history, bash_tool_purpose, fold_finished_tools, summarize_tool_calls, detailed_tool_recaps, keybindings, tmux_passthrough, modelLadders, ...(Object.keys(modelRoutes).length > 0 ? { modelRoutes } : {}), ...(modelRouting !== undefined ? { modelRouting } : {}), kinds, remoteCanvas, spawnEnv };
 }
 /** Raw (un-defaulted) partial config for one scope, or null if the scope has
  *  no root or no config.json. Used by `readMergedLaunchConfig` to layer

package/dist/core/help.js

@@ -223,7 +223,7 @@ function paramDesc(p) {
     // flag
     const f = p;
     if (f.type === 'bool')
-        return `optional boolean. Presence means true. ${f.constraint}`.trim();
+        return `${req} boolean. Presence means true. ${f.constraint}`.trim();
     const dflt = f.default !== undefined ? ` Default: ${String(f.default)}.` : '';
     const choices = f.type === 'enum' && f.choices !== undefined
         ? ` One of: ${f.choices.join(', ')}.`

package/dist/core/human/__tests__/page-catalog.test.js

@@ -14,3 +14,7 @@ test('page component registrations accept legacy names and documented objects',
     assert.throws(() => normalizePageComponents([{ kind: 'approval', display: 'yes' }]), /page_components\[0\]\.display must be a boolean/);
     assert.throws(() => normalizePageComponents([{ kind: 'approval', unexpected: true }]), /unknown field\(s\): unexpected/);
 });
+test('page component registrations reserve derived built-in and product JSX tags', () => {
+    assert.throws(() => normalizePageComponents(['user-question']), /derives JSX tag "UserQuestion", which collides with a built-in page component/);
+    assert.throws(() => normalizePageComponents(['foo-bar', 'foo--bar']), /derives JSX tag "FooBar", which duplicates another product page component/);
+});

package/dist/core/human/__tests__/page-tickets.test.js

@@ -5,67 +5,73 @@ import { join } from 'node:path';
 import test from 'node:test';
 const home = mkdtempSync(join(tmpdir(), 'crtr-page-tickets-'));
 process.env['CRTR_HOME'] = home;
-const { atomicWriteJson, pageManifestPath, pagePath, progressPath, responsePath } = await import('../convention.js');
+const { atomicWriteJson, bindTicketReplyRoute, pageManifestPath, pagePath, progressPath, responsePath } = await import('../convention.js');
 const { claimTicket } = await import('../claim.js');
 const { scanInbox, scanPageHistory } = await import('../scan.js');
 const { ticketDir } = await import('../root.js');
-const { cancelTicket, completePage, readPageProgress, readPageTicket, preparePage, readTicketResult, submitPage, takeoverAndCompletePage, writePageProgress, } = await import('../tickets.js');
+const { cancelTicket, completePage, readPageProgress, readPageTicket, preparePage, readTicketResult, submitPage, takeoverAndCompletePage, validatePageTicketResponses, writePageProgress, } = await import('../tickets.js');
 const sources = mkdtempSync(join(tmpdir(), 'crtr-page-sources-'));
 function sourceFile(name, body) {
     const path = join(sources, name);
     writeFileSync(path, body);
     return path;
 }
-const askPage = sourceFile('ask.html', '<!doctype html><html><head><meta name="crtr-page-title" content="Rollout scope"><meta name="crtr-page-subtitle" content="Pick tonight’s rollout"><meta name="crtr-page-placement" content="inline"></head><body><p>Which rollout do you want?</p><crtr-pages><crtr-page><crtr-options id="rollout"><script type="application/json">{"mode":"single","options":[{"id":"canary","label":"Canary first"},{"id":"full","label":"Full"}]}</script></crtr-options></crtr-page></crtr-pages></body></html>');
-const displayPage = sourceFile('display.html', '<!doctype html><html><head><meta name="crtr-page-title" content="Nightly report"></head><body><h1>All green</h1></body></html>');
-function submit(id, source, dialect, blockedSince, nodeId = 'node-1', mode = 'ask') {
-    const dir = submitPage({ dir: ticketDir(id), sourceFile: source, dialect, source: { nodeId, blockedSince } }).dir;
-    atomicWriteJson(join(dir, 'run.json'), { mode });
+const askPage = sourceFile('ask.tsx', `export default function Rollout() {
+  return (
+    <Page title="Rollout scope" subtitle="Pick tonight\u2019s rollout">
+      <p>Which rollout do you want?</p>
+      <UserQuestion id="rollout" label="Rollout lane" body="Canary limits the blast radius." mode="single" options={[{ id: 'canary', label: 'Canary first' }, { id: 'full', label: 'Full' }]} />
+    </Page>
+  );
+}
+`);
+const displayPage = sourceFile('display.tsx', `export default function Nightly() {
+  return (
+    <Page title="Nightly report">
+      <h1>All green</h1>
+    </Page>
+  );
+}
+`);
+function submit(id, source, emittedAt, nodeId = 'node-1', replyExpected = true) {
+    const dir = submitPage({ dir: ticketDir(id), sourceFile: source, source: { nodeId, emittedAt }, delivery: { placement: 'inline', inbox: replyExpected, reply: replyExpected } }).dir;
+    if (replyExpected)
+        bindTicketReplyRoute(dir, id);
     return dir;
 }
-test('submitPage publishes the authored source, the derived manifest and the blockedSince stamp', () => {
-    const submitted = submitPage({ dir: ticketDir('ask'), sourceFile: askPage, dialect: 'html', source: { nodeId: 'node-1' } });
+test('submitPage publishes the authored source, the derived manifest and the emittedAt stamp', () => {
+    const submitted = submitPage({ dir: ticketDir('ask'), sourceFile: askPage, source: { nodeId: 'node-1' }, delivery: { placement: 'inline', inbox: true, reply: true } });
     assert.equal(submitted.kind, 'page');
     assert.equal(submitted.id, 'ask');
-    assert.equal(readFileSync(pagePath(submitted.dir, 'html'), 'utf8'), readFileSync(askPage, 'utf8'));
+    assert.equal(readFileSync(pagePath(submitted.dir), 'utf8'), readFileSync(askPage, 'utf8'));
     const manifest = JSON.parse(readFileSync(pageManifestPath(submitted.dir), 'utf8'));
-    assert.equal(manifest['schema'], 'crtr.page/v1');
-    assert.equal(manifest['document'], 'page.html');
-    assert.equal(manifest['placement'], 'inline');
+    assert.equal(manifest['schema'], 'crtr.page/v2');
+    assert.equal(manifest['document'], 'page.tsx');
+    assert.deepEqual(manifest['delivery'], { placement: 'inline', inbox: true, reply: true });
     const source = manifest['source'];
     assert.equal(source.nodeId, 'node-1');
-    assert.ok(Date.parse(source.blockedSince) > 0, 'submission stamps blockedSince');
-    assert.throws(() => submitPage({ dir: ticketDir('ask'), sourceFile: askPage, dialect: 'html' }), /already exists/);
-    atomicWriteJson(join(submitted.dir, 'run.json'), { mode: 'ask' });
+    assert.ok(Date.parse(source.emittedAt) > 0, 'submission stamps emittedAt');
+    // A ticket's request is replaceable in place — what `human send --replace`
+    // does. Republishing over the same directory revises the page and leaves one
+    // ticket behind, rather than refusing or raising a second one.
+    const stamp = { nodeId: 'node-replace', emittedAt: '2026-01-05T00:00:00.000Z' };
+    const first = submitPage({ dir: ticketDir('revisable'), sourceFile: askPage, source: stamp });
+    const revised = submitPage({ dir: ticketDir('revisable'), sourceFile: displayPage, source: stamp });
+    assert.equal(revised.id, first.id);
+    assert.equal(revised.manifest.title, 'Nightly report');
+    assert.equal(readFileSync(pagePath(revised.dir), 'utf8'), readFileSync(displayPage, 'utf8'));
+    assert.deepEqual(scanPageHistory('node-replace').map((entry) => entry.id), ['revisable'], 'a replaced page is one ticket, not two');
+    bindTicketReplyRoute(submitted.dir, 'ask');
     const listed = scanInbox().find((item) => item.id === 'ask');
     assert.equal(listed?.kind, 'page');
     assert.equal(listed?.kind === 'page' ? listed.awaitsResponse : undefined, true);
     assert.deepEqual(listed?.kind === 'page' ? listed.slotKinds : undefined, ['options']);
 });
-function tableSourcePage(dataFile) {
-    return `<!doctype html><html><head><meta name="crtr-page-title" content="Data"><meta name="crtr-page-placement" content="inline"></head><body><crtr-pages><crtr-page><crtr-table id="rows"><script type="application/json">${JSON.stringify({ columns: [{ id: 'name', label: 'Name' }], source: dataFile, rowSelect: 'single' })}</script></crtr-table></crtr-page></crtr-pages></body></html>`;
-}
-test('source data is embedded into the submitted manifest', () => {
-    const data = sourceFile('rows.json', JSON.stringify([{ id: 'one', cells: { name: 'One' } }]));
-    const page = sourceFile('source-table.html', tableSourcePage(data));
-    const submitted = submitPage({ dir: ticketDir('source-table'), sourceFile: page, dialect: 'html' });
-    const config = submitted.manifest.slots[0].config;
-    assert.deepEqual(config.rows, [{ id: 'one', cells: { name: 'One' } }]);
-    assert.equal('source' in config, false);
-});
-test('invalid source data fails before a ticket is written', () => {
-    const cases = [
-        ['missing', join(sources, 'missing.json'), /does not exist/],
-        ['invalid-json', sourceFile('invalid.json', '{nope'), /not valid JSON/],
-        ['invalid-shape', sourceFile('invalid-shape.json', JSON.stringify([{ cells: { name: 'Missing id' } }])), /source data is invalid/],
-    ];
-    for (const [id, data, expected] of cases) {
-        const page = sourceFile(`${id}.html`, tableSourcePage(data));
-        const dir = ticketDir(`source-${id}`);
-        assert.throws(() => preparePage({ sourceFile: page, dialect: 'html' }), expected);
-        assert.throws(() => submitPage({ dir, sourceFile: page, dialect: 'html' }), expected);
-        assert.equal(existsSync(dir), false, `${id} source validation writes no ticket`);
-    }
+test('an HTML page derives a slotless manifest from declared metadata', () => {
+    const report = sourceFile('report.html', '<!doctype html><html><head><meta content="Summary" name="description"><title>Report</title></head><body>done</body></html>');
+    const prepared = preparePage({ sourceFile: report });
+    assert.equal(prepared.module, undefined);
+    assert.deepEqual(prepared.manifest, { schema: 'crtr.page/v2', dialect: 'html', title: 'Report', subtitle: 'Summary', delivery: { placement: 'inline', inbox: false, reply: false }, document: 'page.html', steps: 1, slots: [], source: prepared.manifest.source });
 });
 test('progress round-trips through validation and rejects malformed saved work', () => {
     const dir = ticketDir('ask');
@@ -76,6 +82,11 @@ test('progress round-trips through validation and rejects malformed saved work',
     assert.throws(() => writePageProgress(dir, { unknown: { selectedOptionIds: [], comments: [] } }), /unknown/);
     atomicWriteJson(progressPath(dir), { kind: 'page', responses: { rollout: 'not an object' }, savedAt: new Date().toISOString() });
     assert.throws(() => readPageProgress(dir), /malformed/, 'malformed progress is an error, never silently discarded');
+    // Saved work can outlive the slot it answered, because the agent may replace
+    // the page under it. The stale entry is dropped on read so the ticket stays
+    // readable; every entry the current page still declares hydrates.
+    atomicWriteJson(progressPath(dir), { kind: 'page', responses: { rollout: { selectedOptionIds: ['canary'], comments: [] }, retired: { selectedOptionIds: ['gone'], comments: [] } }, savedAt: new Date().toISOString() });
+    assert.deepEqual(readPageProgress(dir), { rollout: { selectedOptionIds: ['canary'], comments: [] } });
     writePageProgress(dir, { rollout: { selectedOptionIds: ['canary'], comments: [] } });
 });
 test('readPageTicket derives pending, resolved and canceled state and carries the document', () => {
@@ -101,20 +112,22 @@ test('readPageTicket derives pending, resolved and canceled state and carries th
     assert.equal(resolved.state, 'resolved');
     assert.equal(resolved.progress, null);
     assert.equal(scanInbox().some((item) => item.id === 'ask'), false, 'a resolved page leaves the pending list');
-    const canceledDir = submit('canceled', askPage, 'html', '2026-01-03T00:00:00.000Z');
+    const canceledDir = submit('canceled', askPage, '2026-01-03T00:00:00.000Z');
     cancelTicket(canceledDir, { reason: 'no longer needed' });
     assert.equal(readPageTicket(canceledDir).state, 'canceled');
 });
-test('page scan derives response expectation from the ticket mode', () => {
-    const dir = submit('display', displayPage, 'html', '2026-01-04T00:00:00.000Z');
+test('page scan derives response expectation from manifest delivery', () => {
+    const dir = submit('display', displayPage, '2026-01-04T00:00:00.000Z');
     const ticket = readPageTicket(dir);
-    assert.equal(ticket.manifest.dialect, 'html');
+    assert.equal(ticket.manifest.dialect, 'jsx');
     assert.equal(ticket.manifest.slots.length, 0);
     const display = scanInbox().find((item) => item.id === 'display');
-    assert.equal(display?.kind === 'page' ? display.awaitsResponse : undefined, true, 'an ask waits even when its page has no response-bearing slots');
-    submit('notify-with-options', askPage, 'html', '2026-01-04T00:00:01.000Z', 'node-1', 'notify');
-    const notify = scanInbox().find((item) => item.id === 'notify-with-options');
-    assert.equal(notify?.kind === 'page' ? notify.awaitsResponse : undefined, false, 'a notify never waits even when its page has a response-bearing slot');
+    assert.equal(display?.kind === 'page' ? display.awaitsResponse : undefined, true, 'a reply-bearing page waits even with no response-bearing slots');
+    const announcementDir = submit('announcement-with-options', askPage, '2026-01-04T00:00:01.000Z', 'node-1', false);
+    const announcement = scanInbox().find((item) => item.id === 'announcement-with-options');
+    assert.equal(announcement, undefined, 'a passive page stays out of the inbox');
+    assert.equal(readPageTicket(announcementDir).state, 'passive');
+    assert.throws(() => takeoverAndCompletePage(announcementDir, {}, { host: 'crtrd', pid: process.pid }), /page_has_no_response_lifecycle/);
     const acknowledged = takeoverAndCompletePage(dir, {}, { host: 'crtrd', pid: process.pid });
     assert.equal(acknowledged.won, true);
     const written = JSON.parse(readFileSync(responsePath(dir), 'utf8'));
@@ -123,11 +136,11 @@ test('page scan derives response expectation from the ticket mode', () => {
     assert.equal(written['summary'], '');
 });
 test('scanPageHistory returns every page of one node, oldest first, regardless of terminal file', () => {
-    submit('older', askPage, 'html', '2026-01-01T00:00:00.000Z');
-    submit('other-node', askPage, 'html', '2026-01-02T00:00:00.000Z', 'node-2');
+    submit('older', askPage, '2026-01-01T00:00:00.000Z');
+    submit('other-node', askPage, '2026-01-02T00:00:00.000Z', 'node-2');
     const history = scanPageHistory('node-1');
-    assert.deepEqual(history.map((entry) => entry.id), ['older', 'canceled', 'display', 'notify-with-options', 'ask']);
-    assert.deepEqual(history.map((entry) => entry.state), ['pending', 'canceled', 'resolved', 'pending', 'resolved']);
+    assert.deepEqual(history.map((entry) => entry.id), ['older', 'canceled', 'display', 'announcement-with-options', 'ask']);
+    assert.deepEqual(history.map((entry) => entry.state), ['pending', 'canceled', 'resolved', 'passive', 'resolved']);
     assert.deepEqual(scanPageHistory('node-2').map((entry) => entry.id), ['other-node']);
     assert.deepEqual(scanPageHistory('node-missing'), []);
 });