@north-light/crouter 0.3.191 → 0.3.193

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/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/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,89 @@
+// 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,
+            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);