@north-light/crouter 0.3.192 → 0.3.194

package/dist/core/keybindings/catalog.d.ts

@@ -1,6 +1,6 @@
 import type { BindingDefinition, SafetyRequirement } from './types.js';
 import type { AttachBindingId, AttachMenuBindingId } from './attach-control.js';
-type TmuxMenuAction = 'open' | 'attach' | 'show' | 'view-settings' | 'fold-tools' | 'metadata' | 'promote' | 'resume' | 'fork' | 'demote' | 'detach' | 'close-subtree' | 'background-bash' | 'file-review' | 'pin' | 'reload-viewer' | 'recap' | 'context' | 'providers' | 'plugins' | 'graph' | 'focus-manager' | 'copy-id' | 'issues';
+type TmuxMenuAction = 'open' | 'attach' | 'show' | 'view-settings' | 'fold-tools' | 'metadata' | 'promote' | 'demote-mode' | 'resume' | 'fork' | 'demote' | 'make-resident' | 'detach' | 'close-subtree' | 'background-bash' | 'file-review' | 'pin' | 'reload-viewer' | 'recap' | 'context' | 'providers' | 'plugins' | 'graph' | 'focus-manager' | 'copy-id' | 'issues';
 type TmuxMenuEntryAction = Exclude<TmuxMenuAction, 'open' | 'attach'> | `issue.${'idea' | 'bug'}`;
 type GraphAction = 'down' | 'up' | 'first' | 'last' | 'collapse-or-manager' | 'expand-or-child' | 'focus' | 'revive' | 'focus-manager' | 'close-subtree' | 'dismiss';
 type BrowseAction = 'quit' | 'down' | 'up' | 'first' | 'last' | 'expand-or-child' | 'collapse-or-parent' | 'toggle-fold' | 'tab-next' | 'tab-previous' | `tab.${1 | 2 | 3 | 4 | 5}` | 'close-subtree' | 'confirm-close' | 'sort' | 'scope' | 'profile' | 'residents' | 'preview' | 'search' | 'revive-now' | 'focus' | 'focus-background';

package/dist/core/keybindings/catalog.js

@@ -38,10 +38,12 @@ const SETUP_TAB_CONTEXTS = ['setup.login', 'setup.list', 'setup.keybindings', 's
 export const BINDING_CATALOG = Object.freeze([
     b('crtr.tmux.menu.open', 'Global tmux', 'Open crouter menu', 'Open the crouter action menu.', ['alt+c'], 'host-global', ['tmux.root']),
     b('crtr.tmux.menu.attach', 'Global tmux', 'Attach actions', 'Open the attach-viewer action submenu.', ['a'], 'tmux-menu-selector', ['tmux.menu']),
-    ...menuEntry('promote', 'Promote node', 'Promote the focused node to orchestrator.', ['o'], ['tmux.menu']),
+    ...menuEntry('promote', 'Promote to orchestrator', 'Promote the focused node to orchestrator — it holds a roadmap and delegates.', ['o'], ['tmux.menu']),
+    ...menuEntry('demote-mode', 'Demote to base node', 'Demote the focused orchestrator back to a base node — hands-on again in its own window, no roadmap to drive.', ['shift+o'], ['tmux.menu']),
     ...menuEntry('resume', 'Find node', 'Open the canvas navigator and go to the chosen node.', ['/'], ['tmux.menu']),
     ...menuEntry('fork', 'Fork node', 'Fork the focused node into an independent idle root.', ['f'], ['tmux.menu']),
-    ...menuEntry('demote', 'Demote node', 'Demote the focused node to terminal — it keeps running, owes a final up the spine, and reaps when done.', ['d'], ['tmux.menu']),
+    ...menuEntry('demote', 'Demote to terminal', 'Demote the focused node to terminal — it keeps running, owes a final up the spine, and reaps when done.', ['d'], ['tmux.menu']),
+    ...menuEntry('make-resident', 'Make resident', 'Flip the focused node to resident — interactable, never forced to submit a final, and wakeable while attached or awaiting something live.', ['shift+r'], ['tmux.menu']),
     ...menuEntry('detach', 'Demote and close viewer', 'Demote the focused node and close its viewer; its broker keeps running off-screen.', ['shift+d'], ['tmux.menu']),
     ...menuEntry('close-subtree', 'Close subtree', 'Close the focused node and its subtree.', ['x'], ['tmux.menu']),
     ...menuEntry('background-bash', 'Background running bash', 'Hand the focused node’s running bash command to its background job system.', ['b'], ['tmux.menu']),

package/dist/core/preview-registry.js

@@ -110,7 +110,6 @@ const LEAF_ICON_CP = {
     'human show': 0xf108,
     'human cancel': 0xf00d,
     'human list': 0xf03a,
-    'human deck': 0xf0db,
     'human resolve': 0xf00c,
     'memory list': 0xf03a,
     'memory read': 0xf02d,

package/dist/core/review/ticket-filter.d.ts

@@ -12,6 +12,6 @@ import type { TicketSummary } from '../human/types.js';
 export declare function isReviewTicketVisible(bridgeNodeId: string): boolean;
 /**
  * Filters a ticket summary array to remove hidden terminal-review tickets.
- * Deck tickets pass through unchanged. Review tickets are filtered by state.
+ * Page tickets pass through unchanged. Review tickets are filtered by state.
  */
 export declare function filterTerminalReviewTickets(items: TicketSummary[]): TicketSummary[];

package/dist/core/review/ticket-filter.js

@@ -19,14 +19,8 @@ export function isReviewTicketVisible(bridgeNodeId) {
 }
 /**
  * Filters a ticket summary array to remove hidden terminal-review tickets.
- * Deck tickets pass through unchanged. Review tickets are filtered by state.
+ * Page tickets pass through unchanged. Review tickets are filtered by state.
  */
 export function filterTerminalReviewTickets(items) {
-    return items.filter((item) => {
-        // Deck tickets always pass through
-        if (item.kind === 'deck')
-            return true;
-        // Review tickets are filtered by visibility
-        return isReviewTicketVisible(item.id);
-    });
+    return items.filter((item) => (item.kind === 'review' ? isReviewTicketVisible(item.id) : true));
 }

package/dist/core/runtime/broker/read-ops.js

@@ -117,6 +117,7 @@ export function buildSettingsData(id, session) {
         terminalTheme: 'dark',
         availableThemes,
         hideThinkingBlock: manager.getHideThinkingBlock(),
+        mermaidRenderingMode: manager.getMermaidRenderingMode(),
         collapseChangelog: manager.getCollapseChangelog(),
         enableInstallTelemetry: manager.getEnableInstallTelemetry(),
         doubleEscapeAction: manager.getDoubleEscapeAction(),
@@ -127,6 +128,8 @@ export function buildSettingsData(id, session) {
         quietStartup: manager.getQuietStartup(),
         clearOnShrink: manager.getClearOnShrink(),
         showTerminalProgress: manager.getShowTerminalProgress(),
+        tuiMode: manager.getTuiMode(),
+        fullscreenScrollbar: manager.getFullscreenScrollbar(),
         warnings: manager.getWarnings(),
         defaultProjectTrust: manager.getDefaultProjectTrust(),
         showCacheMissNotices: manager.getShowCacheMissNotices(),

package/dist/core/runtime/broker.js

@@ -722,14 +722,20 @@ async function resolveLaunchModel(services, cfg) {
 /**
  * Wrap a live ModelRuntime so a model-less `createAgentSessionFromServices`
  * call can't have the SDK's own `findInitialModel` silently pick a model
- * behind crouter's launch policy. Both `getModel()` (step 3: settingsManager's
- * durable `defaultProvider`/`defaultModel` — persisted into a GLOBAL
- * settings.json by every `session.setModel()` call the broker itself already
- * makes at broker.ts:609/675/1606/1650, so this is a live bypass on any
- * machine that has ever picked a model, not a theoretical corner case) and
- * `getAvailable()` (step 4: registry default) must both be intercepted —
- * wrapping only `getAvailable()` leaves `getModel()`'s step-3 path (and the
- * resume path's model restore, sdk.js:88) wide open. Everything else
+ * behind crouter's launch policy. Every model-list read the SDK performs during
+ * construction must be intercepted:
+ *   - `getModel()` — findInitialModel step 3 (settingsManager's durable
+ *     `defaultProvider`/`defaultModel`, persisted into a GLOBAL settings.json by
+ *     every `session.setModel()` call the broker itself already makes, so this
+ *     is a live bypass on any machine that has ever picked a model, not a
+ *     theoretical corner case) and the resume path's model restore.
+ *   - `getAvailableSnapshot()` — findInitialModel step 4 and
+ *     restoreModelFromSession's fallback both take the registry default off this
+ *     SYNCHRONOUS snapshot (model-resolver.js:511/556).
+ *   - `getAvailable()` — the async refresh-and-list sibling, masked alongside it
+ *     so no construction-time list read can reach the real registry through
+ *     either accessor.
+ * Masking any one of them alone leaves the others wide open. Everything else
  * (`getModels`, `hasConfiguredAuth`, `refresh`, …) passes through untouched via
  * `Reflect.get`. Used ONLY
  * for the one model-less construction call; the `services` returned to every
@@ -739,7 +745,7 @@ async function resolveLaunchModel(services, cfg) {
  * CONSTRUCTION-ONLY MASK: the SDK stores `options.services.modelRuntime` as the
  * session's private `_modelRuntime` for its ENTIRE lifetime and never replaces
  * it (agent-session-services.js:104-119, sdk.js:253). A permanent mask would
- * leave list_models (getAvailable→[]), cycle_model, and provider-rotation
+ * leave list_models (the available list→[]), cycle_model, and provider-rotation
  * fallback (getModel()→undefined) broken forever for any model-less-booted node,
  * even after a later /login selects a model. Model selection can only happen
  * DURING construction, so this proxy self-heals: it masks while `masked`, then
@@ -750,7 +756,10 @@ function modelLessRegistry(real) {
     let masked = true;
     const runtime = new Proxy(real, {
         get(target, prop, receiver) {
-            // `getAvailable` is async on ModelRuntime; findInitialModel awaits it.
+            // `getAvailableSnapshot` is the sync list findInitialModel reads; its
+            // async sibling `getAvailable` refreshes first and returns the same set.
+            if (masked && prop === 'getAvailableSnapshot')
+                return () => [];
             if (masked && prop === 'getAvailable')
                 return async () => [];
             if (masked && prop === 'getModel')

package/dist/core/runtime/package-health.js

@@ -23,7 +23,7 @@ import { expandTilde } from '../fs-utils.js';
 export function rendererWarning() {
     if (isRendererReady())
         return null;
-    return 'crtr: the pinned termrender renderer is not provisioned — decks, reviews, and inline diagrams render as plaintext.\n' +
+    return 'crtr: the pinned termrender renderer is not provisioned — pages, reviews, and inline diagrams render as plaintext.\n' +
         '  Fix: run `crtr sys setup` (requires `uv`: curl -LsSf https://astral.sh/uv/install.sh | sh).';
 }
 /**

package/dist/core/runtime/persona.js

@@ -4,7 +4,8 @@
 //   • mode      — base (hands-on; yields mode-preservingly when another window is needed) ↔ orchestrator
 //                 (delegates, holds a roadmap, survives refresh cycles + yields)
 //   • lifecycle — terminal (owes a final up the spine, reaps when done) ↔
-//                 resident (interactable, stays dormant, never forced to submit)
+//                 resident (interactable, never forced to submit; unattended
+//                 obligation-free conversations complete after the daemon grace)
 //
 // Whenever EITHER axis changes from the value the node was last GIVEN guidance
 // for, the node must be prompt-injected with guidance for its new state —

package/dist/core/runtime/tmux-bindings.js

@@ -19,7 +19,12 @@ const LEAF_MENU_ACTIONS = {
     'crtr.tmux.menu.promote': { description: 'promote to orchestrator', action: { kind: 'keys', keys: '/promote' } },
     'crtr.tmux.menu.resume': { description: 'find node', action: { kind: 'keys', keys: '/resume-node' } },
     'crtr.tmux.menu.fork': { description: 'fork into idle root', action: { kind: 'direct', run: 'node fork --pane {pane}' } },
-    'crtr.tmux.menu.demote': { description: 'demote (finish when done)', action: { kind: 'command', run: 'node lifecycle demote --pane {pane}' } },
+    // Mode demote is the mirror of `/promote`: `node config` is the durable
+    // attribute setter, and the persona injector delivers the hands-on-again
+    // guidance at the node's next turn boundary.
+    'crtr.tmux.menu.demote-mode': { description: 'demote to base node', action: { kind: 'command', run: 'node config --mode base --pane {pane}' } },
+    'crtr.tmux.menu.demote': { description: 'demote to terminal (finish when done)', action: { kind: 'command', run: 'node lifecycle demote --pane {pane}' } },
+    'crtr.tmux.menu.make-resident': { description: 'make resident (interactable)', action: { kind: 'command', run: 'node config --lifecycle resident --pane {pane}' } },
     'crtr.tmux.menu.detach': { description: 'demote + close viewer', action: { kind: 'command', run: 'node lifecycle demote --pane {pane} --detach' } },
     'crtr.tmux.menu.close-subtree': { description: 'close agent + subtree', action: { kind: 'command', run: 'node lifecycle close --pane {pane}' } },
     'crtr.tmux.menu.background-bash': { description: 'background running bash', action: { kind: 'direct', run: 'node bash background --pane {pane}' } },
@@ -296,7 +301,9 @@ function menuItems(bindings, entries) {
     addGroup('Lifecycle', boundItems([
         'crtr.tmux.menu.fork',
         'crtr.tmux.menu.promote',
+        'crtr.tmux.menu.demote-mode',
         'crtr.tmux.menu.demote',
+        'crtr.tmux.menu.make-resident',
         'crtr.tmux.menu.detach',
         'crtr.tmux.menu.close-subtree',
     ]));

package/dist/core/termrender/termrender.d.ts

@@ -41,7 +41,7 @@ export declare function renderMarkdownWithMap(md: string, width: number): Render
  * The shared block-aware mapped render: prose blocks keep the readability cap
  * (`proseWidth`), while diagram blocks are re-rendered at the pane's full
  * `paneWidth` and spliced back in by block index. Both surfaces (terminal
- * review and the ask deck) go through this, so "which blocks may be wide" is
+ * review and the ask page) go through this, so "which blocks may be wide" is
  * decided once, from the renderer's own block types, never by heuristics on
  * the emitted rows.
  *

package/dist/core/termrender/termrender.js

@@ -611,7 +611,7 @@ export function renderMarkdownWithMap(md, width) {
  * The shared block-aware mapped render: prose blocks keep the readability cap
  * (`proseWidth`), while diagram blocks are re-rendered at the pane's full
  * `paneWidth` and spliced back in by block index. Both surfaces (terminal
- * review and the ask deck) go through this, so "which blocks may be wide" is
+ * review and the ask page) go through this, so "which blocks may be wide" is
  * decided once, from the renderer's own block types, never by heuristics on
  * the emitted rows.
  *
@@ -664,7 +664,7 @@ export function renderMarkdownBlockAwareLines(md, proseWidth, paneWidth) {
 export function checkMarkdown(md) {
     ensureRenderer();
     // Renderer unavailable → don't block validation; the body just renders as
-    // plaintext later. Bricking deck validation here would be the wrong default.
+    // plaintext later. Bricking page validation here would be the wrong default.
     if (rendererState !== 'ready')
         return { ok: true };
     const result = spawnSync(VENV_BIN, ['doc', 'check'], {

package/dist/core/termrender/version.d.ts

@@ -1 +1 @@
-export declare const TERMRENDER_VERSION = "4.12.6";
+export declare const TERMRENDER_VERSION = "4.12.7";

package/dist/core/termrender/version.js

@@ -1 +1 @@
-export const TERMRENDER_VERSION = '4.12.6';
+export const TERMRENDER_VERSION = '4.12.7';

package/dist/core/tui/page-host.d.ts

@@ -1,4 +1,4 @@
-import { ProcessTerminal, TUI, type Component, type Focusable } from "@earendil-works/pi-tui";
+import { ProcessTerminal, type Component, type Focusable, type TUI } from "@earendil-works/pi-tui";
 import { readRawScopeConfig } from "../config.js";
 import { type BindingId, type BindingResolution } from "../keybindings/index.js";
 /** A full-screen page: a focusable TUI component that cleans up after itself. */

package/dist/core/tui/page-host.js

@@ -6,7 +6,7 @@
 // restore path that survives an exception, a signal, and process exit. Anything
 // a single page needs beyond that — pi's model runtime, a canvas client — the
 // page's own runner builds and closes over before calling in here.
-import { ProcessTerminal, TUI, } from "@earendil-works/pi-tui";
+import { ProcessTerminal, TuiMainScreen, } from "@earendil-works/pi-tui";
 import { applyTheme } from "../../clients/attach/config.js";
 import { readRawScopeConfig } from "../config.js";
 import { resolveKeybindings, } from "../keybindings/index.js";
@@ -20,7 +20,7 @@ export async function runTuiPage(createSurface, interceptCancel) {
     const rawUserConfig = readRawScopeConfig("user");
     const bindings = resolveKeybindings(rawUserConfig?.keybindings);
     const terminal = new ProcessTerminal();
-    const tui = new TUI(terminal, true);
+    const tui = new TuiMainScreen(terminal, true);
     return new Promise((resolve, reject) => {
         let surface;
         let restored = false;

package/dist/core/user-settings.d.ts

@@ -196,6 +196,21 @@ export declare const CONFIG_SETTINGS_COVERAGE: {
             setFromString: (config: ScopeConfig, raw: string) => string | null;
         };
     };
+    html_pages: {
+        surface: "settings";
+        setting: {
+            key: "html_pages";
+            label: string;
+            description: string;
+            valueConstraint: string;
+            applies: string;
+            group: "display";
+            order: number;
+            format: (config: ScopeConfig) => "on" | "off";
+            cycle: (config: ScopeConfig) => void;
+            setFromString: (config: ScopeConfig, raw: string) => string | null;
+        };
+    };
     fold_finished_tools: {
         surface: "settings";
         setting: {
@@ -265,6 +280,10 @@ export declare const CONFIG_SETTINGS_COVERAGE: {
         surface: "specialized";
         owner: string;
     };
+    page_components: {
+        surface: "specialized";
+        owner: string;
+    };
     remoteCanvas: {
         surface: "specialized";
         owner: string;

package/dist/core/user-settings.js

@@ -254,6 +254,27 @@ export const CONFIG_SETTINGS_COVERAGE = {
             },
         },
     },
+    html_pages: {
+        surface: 'settings',
+        setting: {
+            key: 'html_pages',
+            label: 'HTML pages',
+            description: 'Teach agent help the HTML page-authoring dialect. Off keeps page authoring Markdown-only.',
+            valueConstraint: 'true|false',
+            applies: 'Applies on the next help request.',
+            group: 'display',
+            order: 70,
+            format: (config) => config.html_pages ? 'on' : 'off',
+            cycle: (config) => { config.html_pages = !config.html_pages; },
+            setFromString: (config, raw) => {
+                const value = booleanFromString(raw, 'html_pages');
+                if (typeof value === 'string')
+                    return value;
+                config.html_pages = value;
+                return null;
+            },
+        },
+    },
     fold_finished_tools: {
         surface: 'settings',
         setting: {
@@ -323,6 +344,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
     modelRoutes: { surface: 'specialized', owner: 'Models route declarations' },
     modelRouting: { surface: 'specialized', owner: 'Models route declarations' },
     kinds: { surface: 'specialized', owner: 'Models tab and kind registry' },
+    page_components: { surface: 'specialized', owner: 'Page component catalog: product-registered page slot kinds' },
     remoteCanvas: { surface: 'specialized', owner: 'canvas config commands' },
     spawnEnv: { surface: 'specialized', owner: 'spawn environment allow-list' },
 };

package/dist/daemon/api/handlers/bash-jobs.d.ts

@@ -0,0 +1,2 @@
+import type { RouteTable } from '../router.js';
+export declare const bashJobRoutes: RouteTable;

package/dist/daemon/api/handlers/bash-jobs.js

@@ -0,0 +1,90 @@
+// Daemon-owned read and stop surfaces for one node's file-backed background
+// bash jobs. The attach roster continues to read the same directory directly;
+// these routes exist for remote presenters that cannot see the node host.
+import { appendInbox } from '../../../core/feed/inbox.js';
+import { contextDir, isSafeNodeId } from '../../../core/canvas/paths.js';
+import { getNode } from '../../../core/canvas/canvas.js';
+import { isBrokerLive } from '../../../core/runtime/model-swap.js';
+import { assertNotFinalized } from '../../../core/runtime/reopen.js';
+import { reviveNode } from '../../../core/runtime/revive.js';
+import { activeBackgroundBashJobs, bashJobPaths, isBashJobProcessGroupAlive, readJobPgid, isSafeBashJobId as isSafeCoreBashJobId, stopBackgroundBashJob, } from '../../../core/bash-jobs.js';
+import { ApiError } from '../../../api/index.js';
+import { notFound } from '../../../core/errors.js';
+function requireTarget(ctx) {
+    const nodeId = ctx.params['id'];
+    if (nodeId === undefined || !isSafeNodeId(nodeId)) {
+        throw new ApiError(400, 'invalid_node_id', `invalid node id: ${JSON.stringify(nodeId)}`);
+    }
+    const node = getNode(nodeId);
+    if (node === null)
+        throw notFound(`unknown node: ${nodeId}`, { received: nodeId });
+    const rawJobId = ctx.params['jobId'];
+    if (rawJobId !== undefined) {
+        if (!isSafeCoreBashJobId(rawJobId)) {
+            throw new ApiError(400, 'invalid_job_id', `invalid background job id: ${JSON.stringify(rawJobId)}`);
+        }
+        return { nodeId, jobId: rawJobId, dir: contextDir(nodeId) };
+    }
+    return { nodeId, dir: contextDir(nodeId) };
+}
+function handleList(ctx) {
+    const { nodeId, dir } = requireTarget(ctx);
+    const now = Date.now();
+    const body = activeBackgroundBashJobs(dir).map((job) => {
+        const pgid = readJobPgid(dir, job.jobId) ?? null;
+        return {
+            job_id: job.jobId,
+            command: job.command,
+            purpose: job.purpose,
+            started_at: new Date(job.startedAtMs).toISOString(),
+            elapsed_ms: Math.max(0, now - job.startedAtMs),
+            pgid,
+            pgid_alive: pgid !== null && isBashJobProcessGroupAlive(pgid),
+        };
+    });
+    return { status: 200, body };
+}
+async function handleStop(ctx) {
+    const { nodeId, jobId, dir } = requireTarget(ctx);
+    if (jobId === undefined)
+        throw new ApiError(400, 'invalid_request', 'a job id is required');
+    const stopped = await stopBackgroundBashJob(dir, jobId);
+    if (stopped.kind === 'missing') {
+        throw new ApiError(404, 'job_not_found', `no background job ${jobId} for ${nodeId}`);
+    }
+    // A presenter's roster can be a snapshot; a row whose job has since finished
+    // (or was already stopped) is gone, not stoppable.
+    if (stopped.kind === 'retired') {
+        throw new ApiError(404, 'job_not_found', `background job ${jobId} for ${nodeId} is no longer running`, { log_path: stopped.logPath });
+    }
+    if (stopped.kind === 'not-stoppable') {
+        throw new ApiError(409, 'job_not_stoppable', `job ${jobId} recorded no process group`, { log_path: stopped.logPath });
+    }
+    // Match `crtr node bash kill`: retire the job, then send an urgent durable
+    // notice to the owning node. The terminal path sends that notice through the
+    // message endpoint, whose finalized-node gate runs before append; preserve
+    // that same fail-loud behavior here after the job control-plane mutation.
+    assertNotFinalized(nodeId);
+    const paths = bashJobPaths(dir, jobId);
+    const body = `Background bash job ${jobId} was stopped by the human before it finished. Log: ${paths.jobLog}  Command: ${paths.cmdSh}`;
+    appendInbox(nodeId, {
+        from: null,
+        tier: 'urgent',
+        kind: 'message',
+        label: body.split('\n')[0].slice(0, 120),
+        data: { body },
+    });
+    const node = getNode(nodeId);
+    if (node !== null && !isBrokerLive(node)) {
+        try {
+            reviveNode(nodeId, { resume: true });
+        }
+        catch { /* the notice remains durable */ }
+    }
+    const result = { node_id: nodeId, job_id: jobId, signaled: stopped.signaled };
+    return { status: 200, body: result };
+}
+export const bashJobRoutes = [
+    { method: 'GET', pattern: '/v1/nodes/:id/jobs', handler: handleList },
+    { method: 'DELETE', pattern: '/v1/nodes/:id/jobs/:jobId', handler: handleStop },
+];

package/dist/daemon/api/handlers/human.js

@@ -4,13 +4,14 @@
 import { existsSync } from 'node:fs';
 import { ApiError } from '../../../api/index.js';
 import { isSafeNodeId } from '../../../core/canvas/paths.js';
-import { deckPath, reviewPath } from '../../../core/human/convention.js';
+import { pageManifestPath, reviewPath } from '../../../core/human/convention.js';
 import { ticketDir } from '../../../core/human/root.js';
-import { readTicketResult, validateDeckTicketResponses } from '../../../core/human/tickets.js';
+import { readTicketResult, validatePageTicketResponses } from '../../../core/human/tickets.js';
+import { readConfig } from '../../../core/config.js';
 import { getReviewByBridge } from '../../../core/review/store.js';
 import { ReviewOperationError } from '../../../core/review/types.js';
 import { spawnNode } from '../../../core/runtime/nodes.js';
-import { cancelHumanTicket, resolveDeckTicket } from '../../human/finish.js';
+import { cancelHumanTicket, resolvePageTicket } from '../../human/finish.js';
 import { cancelReview } from '../../review/finish.js';
 function requireTicketNodeId(ctx) {
     const nodeId = ctx.params['node_id'];
@@ -52,7 +53,7 @@ function handleCreateBridge(ctx) {
 function reviewSubmitGuidance() {
     return new ApiError(400, 'invalid_request', 'review approvals use POST /v1/human/reviews/:review_id/submit');
 }
-/** The ticket resolve route accepts only a deck response body. */
+/** The ticket resolve route accepts only a page response body. */
 function requireResolveRequest(ctx) {
     const request = ctx.body;
     if (request === undefined || request === null || typeof request !== 'object' || Array.isArray(request)) {
@@ -66,13 +67,13 @@ function requireResolveRequest(ctx) {
         throw reviewSubmitGuidance();
     throw new ApiError(400, 'invalid_request', 'ticket resolve body requires exactly `responses`');
 }
-function requireDeckTicket(dir) {
-    const deck = existsSync(deckPath(dir));
+function requirePageTicket(dir) {
+    const page = existsSync(pageManifestPath(dir));
     const review = existsSync(reviewPath(dir));
-    if (review && !deck)
+    if (review && !page)
         throw reviewSubmitGuidance();
-    if (!deck || review) {
-        throw new ApiError(400, 'invalid_request', 'ticket has no unambiguous deck kind');
+    if (!page || review) {
+        throw new ApiError(400, 'invalid_request', 'ticket has no unambiguous page kind');
     }
 }
 function invalidResolveRequest(error) {
@@ -91,13 +92,14 @@ async function handleResolve(ctx) {
     const nodeId = requireTicketNodeId(ctx);
     const request = requireResolveRequest(ctx);
     const dir = ticketDir(nodeId);
-    requireDeckTicket(dir);
-    const responses = preflightResolve(() => validateDeckTicketResponses(dir, request.responses));
-    await resolveDeckTicket(nodeId, responses);
-    return { status: 200, body: { delivered: true, kind: 'deck' } };
+    requirePageTicket(dir);
+    const productKinds = readConfig('user').page_components ?? [];
+    const responses = preflightResolve(() => validatePageTicketResponses(dir, request.responses, productKinds));
+    await resolvePageTicket(nodeId, responses, productKinds);
+    return { status: 200, body: { delivered: true, kind: 'page' } };
 }
 function hasPublishedTicket(dir) {
-    return existsSync(deckPath(dir)) || existsSync(reviewPath(dir)) || readTicketResult(dir) !== null;
+    return existsSync(pageManifestPath(dir)) || existsSync(reviewPath(dir)) || readTicketResult(dir) !== null;
 }
 async function handleCancel(ctx) {
     const nodeId = requireTicketNodeId(ctx);