@north-light/crouter 0.3.197 → 0.3.199

package/dist/commands/human/prompts.js

@@ -1,21 +1,18 @@
-/**
- * Prompt-design gap: a person opens asks from background agents without the
- * task or conversation context. Human-ask help therefore teaches agents to
- * make every interruption self-contained and answerable before its evidence.
- */
 import { defineLeaf } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
 import { cliClient } from '../api-client.js';
-import { extname, join } from 'node:path';
+import { join } from 'node:path';
 import { randomBytes } from 'node:crypto';
-import { rmSync } from 'node:fs';
-import { readConfig } from '../../core/config.js';
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { resolvePageComponents } from '../../core/config.js';
 import { markStopSignal } from '../../core/runtime/stop-signals.js';
-import { atomicWriteJson } from '../../core/human/convention.js';
+import { bindTicketReplyRoute } from '../../core/human/convention.js';
 import { ticketDir } from '../../core/human/root.js';
-import { preparePage, publishPage } from '../../core/human/tickets.js';
-import { synthesizedPageDocument, writeSynthesizedPage } from '../../core/human/page-synth.js';
-import { PageAuthoringError } from '../../core/human/page.js';
+import { preparePage, publishPage, readTicketResult } from '../../core/human/tickets.js';
+import { PageAuthoringError, parsePage } from '../../core/human/page.js';
+import { pageManifestPath } from '../../core/human/convention.js';
+import { isResponseBearingSlot, validateAuthoredPageManifest } from '../../core/human/page-schema.js';
 import { display } from '../../core/termrender/display.js';
 import { pageHelpText, resolveMaxPanes } from './shared.js';
 const PAGE_HELP = pageHelpText();
@@ -26,76 +23,63 @@ function askingNode() {
 /** Provenance for crouter tickets. Ticket *identity* comes from the bridge node
  * directory, never ticket data; `nodeId` carries the originating node so a
  * consumer can relate a ticket back to whatever that node belongs to, and
- * `sessionName` is a presentation label only. Review tickets already stamp
- * `nodeId` the same way (`core/review/realize.ts`), so pages match them.
- * `nodeId` is stamped even when the daemon is unreachable — losing the label is
- * survivable, losing machine attribution is not. */
-export async function sourceStamp() {
+ * `sessionName` is a presentation label only, while `profileName` lets product
+ * consumers resolve the applet or worker identity behind the ticket. Review
+ * tickets stamp the same provenance (`core/review/realize.ts`), so pages match
+ * them. `nodeId` is stamped even when the daemon is unreachable — losing the
+ * labels is survivable, losing machine attribution is not.
+ *
+ * The same read answers who is sending: `lifecycle` decides whether the sender
+ * has a transcript a human is plausibly reading, which is what makes skipping
+ * the inbox safe. It is null for a bare shell (no node at all) and when the
+ * daemon cannot answer — neither is a terminal sender, so neither restricts
+ * delivery. */
+export async function sender() {
     const nodeId = askingNode();
     if (nodeId === null || nodeId === '')
-        return {};
+        return { source: {}, lifecycle: null };
     try {
-        const sessionName = (await cliClient().getNode(nodeId)).name.trim();
-        return sessionName === '' ? { nodeId } : { nodeId, sessionName };
+        const client = cliClient();
+        const node = await client.getNode(nodeId);
+        const sessionName = node.name.trim();
+        const profileName = node.profile_id === null
+            ? undefined
+            : (await client.getProfile(node.profile_id)).name;
+        return {
+            source: {
+                nodeId,
+                ...(sessionName === '' ? {} : { sessionName }),
+                ...(profileName === undefined ? {} : { profileName }),
+            },
+            lifecycle: node.lifecycle,
+        };
     }
     catch {
-        return { nodeId };
+        return { source: { nodeId }, lifecycle: null };
     }
 }
-function requireAskTitle(title) {
-    if (title !== undefined)
-        return title;
-    throw new InputError({
-        error: 'missing_parameter',
-        message: 'stdin questions require a non-empty --title',
-        field: 'title',
-        next: 'Retry with a short --title naming the topic being decided.',
-    });
+function pageProductKinds() {
+    return resolvePageComponents();
 }
-function requireSubtitle(subtitle, field = 'subtitle') {
-    if (subtitle !== undefined && subtitle.trim() !== '')
-        return subtitle.trim();
-    throw new InputError({
-        error: 'missing_parameter',
-        message: 'a non-empty subtitle is required',
-        field,
-        next: 'Write one plain-English sentence stating the decision, recommendation or status, and stakes.',
-    });
-}
-function pageDialect(sourceFile) {
-    const extension = extname(sourceFile).toLowerCase();
-    if (extension === '.md')
-        return 'md';
-    if (extension === '.html' || extension === '.htm')
-        return 'html';
-    throw new InputError({
-        error: 'invalid_page_dialect',
-        message: `--page must point to a .md, .html, or .htm file; received "${sourceFile}"`,
-        field: 'page',
-        next: 'Use a Markdown page (.md) or an HTML page (.html or .htm).',
-    });
-}
-function pageProductKinds(dialect) {
-    const config = readConfig('user');
-    if (dialect === 'html' && !config.html_pages) {
-        throw new InputError({
-            error: 'page_dialect_disabled',
-            message: 'html pages are not enabled in this home; md is the dialect to use',
-            field: 'page',
-            next: 'Use a .md page, or enable html_pages in the user scope config before submitting HTML.',
-        });
-    }
-    return config.page_components;
-}
-function requireNotifyTitle(title) {
-    if (title !== undefined && title.trim() !== '')
-        return title.trim();
-    throw new InputError({
-        error: 'missing_parameter',
-        message: 'notify shorthand requires a non-empty title',
-        field: 'title',
-        next: 'Retry with a positional title, --subtitle, and optional --body, or submit a page with --page PATH.',
-    });
+/** Delivery is two authored choices and one derived fact. Placement and inbox
+ * are the sender's to pick; `reply` is not a flag, because a page routes
+ * completion back exactly when it carries response-bearing components — the
+ * page's own shape decides it, and a sender who disagreed could only be wrong
+ * (inputs with no way to submit, or a bridge no response can settle).
+ *
+ * Skipping the inbox leaves the sender's own transcript as the page's only
+ * route to a human, so a terminal sender — a node that finishes, whose
+ * transcript nobody is watching — always projects to the inbox. */
+function deliveryFrom(input, responseBearing, senderLifecycle) {
+    const inbox = senderLifecycle === 'terminal'
+        ? true
+        : input['inbox'] === true
+            ? true
+            : input['noInbox'] === true
+                ? false
+                : responseBearing;
+    const placement = input['placement'] ?? 'inline';
+    return { placement, inbox, reply: responseBearing };
 }
 function submitAuthoredPage(submit) {
     try {
@@ -108,175 +92,182 @@ function submitAuthoredPage(submit) {
             error: 'invalid_page',
             message: error.message,
             field: 'page',
-            next: 'Fix the authored page, then pre-check it with `crtr human doc check <path>` before submitting again.',
+            next: 'Fix the authored page and submit again; the reported location is in the authored `.tsx` source.',
+        });
+    }
+}
+/** The page a `--replace` names, read for the one thing a revision inherits. */
+function replacedPage(ticketId) {
+    const dir = ticketDir(ticketId);
+    if (!existsSync(pageManifestPath(dir))) {
+        throw new InputError({
+            error: 'unknown_page',
+            message: `no page ${ticketId} on this canvas`,
+            field: 'replace',
+            next: 'Pass the page_id a previous send returned, or omit --replace to raise a new page.',
         });
     }
+    return parsePage(dir);
+}
+function writePipedPage(document) {
+    const dir = mkdtempSync(join(tmpdir(), 'crtr-human-page-'));
+    const path = join(dir, 'page.tsx');
+    writeFileSync(path, document, { encoding: 'utf8', mode: 0o600 });
+    return { dir, path };
+}
+/** Resolve exactly one authored page input. Piped bytes are materialized so
+ * both input forms follow the same page preparation and validation path. */
+function pageInput(input) {
+    const file = input['page'];
+    const documentRaw = input['document'];
+    // Optional stdin arrives as an empty string when a caller redirects an empty
+    // stream. It is not a page source and must not conflict with --page.
+    const document = typeof documentRaw === 'string' && documentRaw.trim() !== '' ? documentRaw : undefined;
+    if (file !== undefined && document !== undefined) {
+        throw new InputError({
+            error: 'bad_invocation',
+            message: 'received both --page and a piped page document',
+            field: 'page, document',
+            next: 'Pass exactly one page source: --page PATH or the document on stdin.',
+        });
+    }
+    if (file === undefined && document === undefined) {
+        throw new InputError({
+            error: 'missing_parameter',
+            message: 'a page source is required',
+            field: 'page, document',
+            next: 'Pass exactly one page source: --page PATH or the document on stdin.',
+        });
+    }
+    if (file !== undefined) {
+        if (typeof file !== 'string')
+            throw new InputError({ error: 'invalid_type', message: '--page must be a path', field: 'page', next: 'Retry with --page PATH.' });
+        return { sourceFile: file };
+    }
+    if (typeof document !== 'string')
+        throw new InputError({ error: 'invalid_type', message: 'stdin must contain a page document', field: 'document', next: 'Pipe the page document on stdin.' });
+    const temp = writePipedPage(document);
+    return { sourceFile: temp.path, tempDir: temp.dir };
 }
 /** The non-blocking status peek returned by ask/review. How the human reaches
- *  their inbox is theirs, not the agent's — naming a shortcut here only teaches
- *  agents to repeat a screen-specific gesture back to a reader who may be on a
- *  different surface entirely. */
+ * their inbox is theirs, not the agent's — naming a shortcut here only teaches
+ * agents to repeat a screen-specific gesture back to a reader who may be on a
+ * different surface entirely. */
 function queuedFollowUp() {
-    return 'Queued for the human. Their answer is pushed to your inbox and wakes you when they respond — never poll, verify it opened, or block.';
+    return 'Queued for the user. Their answer is pushed to your inbox and wakes you when they respond — never poll, verify it opened, or block.';
 }
 // ---------------------------------------------------------------------------
-// ask
+// send
 // ---------------------------------------------------------------------------
-export const humanAsk = defineLeaf({
-    name: 'ask',
-    description: 'put a structured choice or open question to a person',
-    whenToUse: 'you would otherwise lay a decision, a set of options, or a question out for the user as prose — reach for this instead, for anything from a quick yes/no to a judgment-heavy call: gating a handoff, merge, deploy, destructive/irreversible operation, or real budget on an explicit human sign-off (offer Yes/No options), reviewing all the requirements before building, choosing among implementation patterns, walking a list of risks and deciding what to do about each, settling a naming or scope question, picking which of several findings to act on. Works for open-ended asks too (set `allowFreetext`, offer a few `options` as starting points).',
+export const humanSend = defineLeaf({
+    name: 'send',
+    description: 'send a durable page with explicit delivery',
+    whenToUse: 'you need to put structured TSX or HTML content in a conversation and optionally project it to the inbox; a page carrying response-bearing components routes completion back to this node.',
     help: {
-        name: 'human ask',
-        summary: "submit a decision ticket to crouter's inbox; returns a job handle immediately.",
-        guide: [
-            'Write a self-contained decision brief for a supervisor who has not followed the task: title names the topic; subtitle states the decision, your recommendation, and stakes; the body gives only the context and tradeoffs needed to decide. Put supporting evidence under `## Details`. Ask only what changes your next step, and offer genuine alternatives as `options`.',
-            PAGE_HELP.authoring,
-        ].join('\n\n'),
+        name: 'human send',
+        summary: 'send a durable TSX or HTML page',
+        guide: 'Page authoring: `crtr human -h`.',
         params: [
-            { kind: 'flag', name: 'title', type: 'string', required: false, constraint: 'Required with stdin shorthand: a short ≤~4-word inbox topic. Mutually exclusive with --page.' },
-            { kind: 'flag', name: 'subtitle', type: 'string', required: false, constraint: 'Required with stdin shorthand: one plain-English sentence stating the decision, recommendation, and stakes. Mutually exclusive with --page.' },
-            { kind: 'stdin', name: 'question', required: false, constraint: "Simple open-text ask body. Pipe markdown from a single-quoted heredoc (`<<'EOF'`) to preserve literal bytes. Requires --title and --subtitle; mutually exclusive with --page." },
-            { kind: 'flag', name: 'page', type: 'path', required: false, constraint: `${PAGE_HELP.pageHint} Mutually exclusive with shorthand.` },
+            { kind: 'stdin', name: 'document', required: false, allowPositional: false, constraint: 'The page module source (TSX) on stdin. Provide exactly one of stdin or --page PATH. HTML is file-authored.' },
+            { kind: 'flag', name: 'page', type: 'path', required: false, constraint: `${PAGE_HELP.pageHint} A .tsx file is JSX; .html/.htm is complete HTML. Provide exactly one of --page or stdin.` },
+            { kind: 'flag', name: 'placement', type: 'enum', choices: ['inline', 'panel'], required: false, default: 'inline', constraint: "Where the page is delivered. inline renders in this conversation's transcript; panel opens from the inbox beside it." },
+            { kind: 'flag', name: 'inbox', type: 'bool', required: false, constraint: 'Project this page into the inbox. Mutually exclusive with --no-inbox.' },
+            { kind: 'flag', name: 'no-inbox', type: 'bool', required: false, constraint: "Do not project this page into the inbox, leaving this conversation's transcript as its only route to the user. Mutually exclusive with --inbox, and refused from a terminal node, whose transcript nobody reads once it finishes." },
+            { kind: 'flag', name: 'replace', type: 'string', required: false, constraint: 'Page id returned by an earlier send. Rewrites source in place while retaining its delivery and transcript anchor. Refused once the page is settled or canceled. Not combinable with delivery flags.' },
         ],
         output: [
-            { name: 'job_id', type: 'string', required: true, constraint: 'Node id of this human interaction. Its answer is pushed to your inbox when the human responds.' },
-            { name: 'dir', type: 'string', required: true, constraint: 'Interaction directory holding page.md or page.html, page.json, run.json, and response.json.' },
-            { name: 'follow_up', type: 'string', required: true, constraint: 'A non-blocking status peek; the answer arrives via your inbox.' },
+            { name: 'page_id', type: 'string', required: true, constraint: 'Identifier for the page; pass it as --replace to revise source in place.' },
+            { name: 'dir', type: 'string', required: true, constraint: 'Interaction directory holding page.tsx or page.html, optional page.js, page.json, and response lifecycle files when delivery needs them.' },
+            { name: 'placement', type: 'inline | panel', required: true, constraint: 'Resolved page placement.' },
+            { name: 'inbox', type: 'boolean', required: true, constraint: 'Whether the page is projected into the inbox.' },
+            { name: 'reply', type: 'boolean', required: true, constraint: 'Whether completion is routed back through a human bridge. Not a flag: true exactly when the page has response-bearing components.' },
+            { name: 'follow_up', type: 'string', required: true, constraint: 'What happens next; never instructs the caller to poll.' },
         ],
         outputKind: 'object',
         effects: [
-            'Creates a kind:"human" node under you and enqueues a page in the human inbox.',
-            'Returns immediately; nothing opens on screen. The human answers from their inbox on their own time.',
+            'Writes one durable page record. Inbox projection follows the delivery flags, except from a terminal node, which always projects; reply routing follows the page\'s own components.',
+            "A display-only page's inbox entry is a notice, not a task: it clears itself once the person has actually seen the page, wherever they see it.",
+            'A reply-bearing page creates a kind:"human" bridge under the caller and routes completion back.',
+            '--replace rewrites source in place while retaining delivery and emitted time; open surfaces reload it without creating another page.',
         ],
     },
-    run: async (input) => {
-        // Optional stdin reaches the leaf as an empty string when omitted. Keep the
-        // raw non-empty bytes untouched so shorthand callers retain their body.
-        const titleRaw = input['title'];
-        const title = typeof titleRaw === 'string' && titleRaw.trim() !== '' ? titleRaw.trim() : undefined;
-        const questionRaw = input['question'];
-        const question = typeof questionRaw === 'string' && questionRaw !== '' ? questionRaw : undefined;
-        const subtitleRaw = input['subtitle'];
-        const subtitle = typeof subtitleRaw === 'string' && subtitleRaw.trim() !== '' ? subtitleRaw.trim() : undefined;
-        const pageInput = input['page'];
-        if (pageInput !== undefined && (question !== undefined || titleRaw !== undefined || subtitleRaw !== undefined)) {
-            throw new InputError({
-                error: 'bad_invocation',
-                message: 'use --title and --subtitle with stdin question text, or --page, not both',
-                next: 'Retry with --title, --subtitle, and a piped question body, or with --page PATH alone.',
-            });
-        }
-        if (question === undefined && pageInput === undefined) {
-            throw new InputError({
-                error: 'missing_parameter',
-                message: 'human ask needs stdin question text or --page PATH',
-                next: 'Pipe a question body with --title and --subtitle, or pass --page PATH for an authored page.',
-            });
-        }
-        const dialect = pageDialect(typeof pageInput === 'string' ? pageInput : 'page.md');
-        const productKinds = pageProductKinds(dialect);
-        let tempDir;
-        let sourceFile;
-        if (pageInput !== undefined) {
-            sourceFile = pageInput;
+    run: async (input, context) => {
+        const { sourceFile, tempDir } = pageInput(input);
+        const replacePage = input['replace'];
+        const deliveryFlags = ['placement', 'inbox', 'noInbox'];
+        if (input['inbox'] === true && input['noInbox'] === true) {
+            throw new InputError({ error: 'bad_invocation', message: 'received conflicting delivery flags', field: 'inbox', next: 'Pass at most one of --inbox and --no-inbox.' });
         }
-        else {
-            const simpleAsk = { title: requireAskTitle(title), subtitle: requireSubtitle(subtitle), question: question };
-            const synthesized = writeSynthesizedPage(synthesizedPageDocument(simpleAsk.title, simpleAsk.subtitle, simpleAsk.question, true));
-            tempDir = synthesized.dir;
-            sourceFile = synthesized.path;
+        if (replacePage !== undefined && deliveryFlags.some((flag) => context?.providedParams.has(flag) === true)) {
+            throw new InputError({ error: 'bad_invocation', message: '--replace cannot change delivery', field: 'replace', next: 'Remove delivery flags: replacement retains the page placement, inbox, reply, and emitted time.' });
         }
         try {
-            const source = await sourceStamp();
-            // The page is validated before the bridge node exists: a rejected page
-            // must create nothing, because a bridge node born for a ticket that never
-            // got published is a live terminal node no answer can ever finish.
-            const prepared = submitAuthoredPage(() => preparePage({ sourceFile, dialect, source, productKinds }));
-            const cwd = process.cwd();
-            const jobId = (await cliClient().createHumanBridge({ kind: 'human', parent: askingNode(), cwd, name: 'human-ask' })).node_id;
-            const idir = ticketDir(jobId);
-            const rc = { mode: 'ask', job_id: jobId };
-            atomicWriteJson(join(idir, 'run.json'), rc);
-            const { dir } = publishPage(ticketDir(jobId), prepared);
+            if (replacePage !== undefined) {
+                const prior = replacedPage(replacePage);
+                // The human's submit wins the race with a revision: once the ticket has
+                // any terminal outcome, replacement is refused, and that refusal is the
+                // reviser's signal that the ticket is closed.
+                if (readTicketResult(ticketDir(replacePage)) !== null) {
+                    throw new InputError({
+                        error: 'page_settled',
+                        message: `page ${replacePage} already has a terminal outcome`,
+                        field: 'replace',
+                        next: 'The page was answered or canceled; nothing on it can change now. Raise a new page if more is needed.',
+                    });
+                }
+                // A revision changes only the content. Identity, routing, and emitted
+                // time stay the original sender's, so the prior source is inherited
+                // verbatim — a fork revising the page must not repoint its provenance.
+                const revised = submitAuthoredPage(() => preparePage({ sourceFile, source: prior.source, productKinds: pageProductKinds(), delivery: prior.delivery }));
+                const { dir } = publishPage(ticketDir(replacePage), revised);
+                return { page_id: replacePage, dir, ...prior.delivery, follow_up: 'Replaced in place. Every open surface reloads it; delivery and emitted time are unchanged.' };
+            }
+            const { source, lifecycle } = await sender();
+            // A terminal node finishes and its transcript stops being read, so the
+            // inbox is the only surface its page can still reach a human on. Refuse
+            // rather than quietly overriding the flag: the caller asked for a page
+            // nobody would ever see, and that is worth knowing.
+            if (lifecycle === 'terminal' && input['noInbox'] === true) {
+                throw new InputError({
+                    error: 'invalid_page_delivery',
+                    message: 'a terminal node cannot send a page --no-inbox',
+                    field: 'inbox',
+                    next: 'Drop --no-inbox. This node finishes, and nobody reads a finished node\'s transcript, so a page kept out of the inbox reaches no one.',
+                });
+            }
+            // Static extraction is an evaluation. Derive and validate delivery from this
+            // exact manifest so authored code runs once and cannot change between passes.
+            const productKinds = pageProductKinds();
+            const prepared = submitAuthoredPage(() => preparePage({ sourceFile, source, productKinds }));
+            const responseBearing = prepared.manifest.slots.some(isResponseBearingSlot);
+            const delivery = deliveryFrom(input, responseBearing, lifecycle);
+            prepared.manifest = submitAuthoredPage(() => validateAuthoredPageManifest({ ...prepared.manifest, delivery }, productKinds));
+            if (!delivery.reply) {
+                const pageId = `page-${randomBytes(4).toString('hex')}`;
+                const { dir } = publishPage(ticketDir(pageId), prepared);
+                // A page with no reply route carries no response-bearing components, so what the
+                // follow-up must get right is where the person will meet it and how it
+                // settles: an inline page is already in this conversation, and its
+                // inbox entry is a notice that clears itself the moment the page has
+                // actually been seen — an agent that points the person at their inbox
+                // for a page on their screen sends them to an empty list.
+                const followUp = delivery.placement === 'inline' && delivery.inbox
+                    ? 'Shown in this conversation and queued in the user\'s inbox. The inbox entry clears itself the user has seen the page — someone viewing this conversation acknowledges it on sight, so do not send them to their inbox for it. They already know this, do not inform them.'
+                    : delivery.placement === 'inline'
+                        ? 'Shown in this conversation as passive page content with no inbox entry.'
+                        : delivery.inbox
+                            ? 'Queued in the inbox; it opens in the panel and waits until dismissed.'
+                            : 'Published as passive page content with no inbox or response lifecycle.';
+                return { page_id: pageId, dir, ...delivery, follow_up: followUp };
+            }
             const originNodeId = askingNode();
+            const bridgeNodeId = (await cliClient().createHumanBridge({ kind: 'human', parent: originNodeId, cwd: process.cwd(), name: 'human-page' })).node_id;
+            const idir = ticketDir(bridgeNodeId);
+            bindTicketReplyRoute(idir, bridgeNodeId);
+            const { dir } = publishPage(idir, prepared);
             if (originNodeId !== null && originNodeId !== '')
-                markStopSignal(originNodeId, 'askedHuman');
-            return { job_id: jobId, dir, follow_up: queuedFollowUp() };
-        }
-        finally {
-            if (tempDir !== undefined)
-                rmSync(tempDir, { recursive: true, force: true });
-        }
-    },
-});
-// ---------------------------------------------------------------------------
-// notify (no job)
-// ---------------------------------------------------------------------------
-export const humanNotify = defineLeaf({
-    name: 'notify',
-    description: 'fire-and-forget acknowledgement, no reply expected',
-    whenToUse: 'informing a person without blocking or expecting an answer',
-    help: {
-        name: 'human notify',
-        summary: 'enqueue a fire-and-forget acknowledgement in the human inbox; creates no job',
-        guide: [
-            'State what happened in plain words. Shorthand bodies are directive-flavored Markdown; validate authored pages with `crtr human doc check`.',
-            PAGE_HELP.authoring,
-        ].join('\n\n'),
-        params: [
-            { kind: 'positional', name: 'title', type: 'string', required: false, constraint: 'Notification headline for shorthand; required with --subtitle when --page is omitted.' },
-            { kind: 'flag', name: 'subtitle', type: 'string', required: false, constraint: 'One plain-English sentence stating the notification status and stakes; required when --page is omitted.' },
-            { kind: 'flag', name: 'body', type: 'string', required: false, constraint: 'Optional markdown body for shorthand; mutually exclusive with --page.' },
-            { kind: 'flag', name: 'page', type: 'path', required: false, constraint: `${PAGE_HELP.pageHint} Mutually exclusive with --body.` },
-        ],
-        output: [
-            { name: 'queued', type: 'boolean', required: true, constraint: 'Always true — the notify page is durable inbox state the human acknowledges from the inbox.' },
-            { name: 'dir', type: 'string', required: true, constraint: 'Interaction directory holding page.md or page.html, page.json, and run.json.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Enqueues a durable display page in the human inbox. Creates no node; nothing opens on screen.',
-        ],
-    },
-    run: async (input) => {
-        const titleRaw = input['title'];
-        const title = typeof titleRaw === 'string' && titleRaw.trim() !== '' ? titleRaw.trim() : undefined;
-        const subtitleRaw = input['subtitle'];
-        const subtitle = typeof subtitleRaw === 'string' && subtitleRaw.trim() !== '' ? subtitleRaw.trim() : undefined;
-        const body = input['body'];
-        const pageInput = input['page'];
-        if (pageInput !== undefined && body !== undefined) {
-            throw new InputError({
-                error: 'bad_invocation',
-                message: 'use --page or --body, not both',
-                next: 'Retry with --page PATH alone for an authored page, or use the title, --subtitle, and --body shorthand.',
-            });
-        }
-        const dialect = pageDialect(typeof pageInput === 'string' ? pageInput : 'page.md');
-        const productKinds = pageProductKinds(dialect);
-        let tempDir;
-        let sourceFile;
-        if (pageInput !== undefined) {
-            sourceFile = pageInput;
-        }
-        else {
-            const shorthandTitle = requireNotifyTitle(title);
-            const shorthandSubtitle = requireSubtitle(subtitle);
-            const synthesized = writeSynthesizedPage(synthesizedPageDocument(shorthandTitle, shorthandSubtitle, body ?? '', false));
-            tempDir = synthesized.dir;
-            sourceFile = synthesized.path;
-        }
-        try {
-            const source = await sourceStamp();
-            // Validate before the ticket directory exists, so a rejected page leaves
-            // no half-built ticket behind.
-            const prepared = submitAuthoredPage(() => preparePage({ sourceFile, dialect, source, productKinds }));
-            const id = `nfy-${randomBytes(4).toString('hex')}`;
-            const rc = { mode: 'notify' };
-            atomicWriteJson(join(ticketDir(id), 'run.json'), rc);
-            const { dir } = publishPage(ticketDir(id), prepared);
-            return { queued: true, dir };
+                markStopSignal(originNodeId, 'requestedHumanReply');
+            return { page_id: bridgeNodeId, dir, ...delivery, follow_up: queuedFollowUp() };
         }
         finally {
             if (tempDir !== undefined)
@@ -286,17 +277,17 @@ export const humanNotify = defineLeaf({
 });
 // ---------------------------------------------------------------------------
 // show (no job, non-blocking passthrough) — passive live document display, NOT
-// a ticket surface. Retained per the tmux-inbox cutover: `display()` puts a
-// file live in a watch pane and never enqueues anything.
+// a ticket surface. `display()` puts a file live in a watch pane and never
+// enqueues anything.
 // ---------------------------------------------------------------------------
 export const humanShow = defineLeaf({
     name: 'show',
-    description: "put a file live on the human's screen",
-    whenToUse: 'displaying a doc on screen while a human comments',
+    description: "put a file live on the user's screen",
+    whenToUse: 'displaying a doc on screen while the user comments',
     help: {
         name: 'human show',
         summary: "put a file live on screen in a tmux pane with crouter's renderer",
-        guide: 'The pane always watches the file and live-updates on every save — a displayed doc is a live view by definition, so point it at a file something keeps rewriting (a status board, a running summary) and it stays current. The file is directive-flavored markdown rendered by termrender (panels, columns, trees, callouts, mermaid) — see `crtr human doc render` before authoring one. To put a rich document in front of the human as a durable inbox page, use `crtr human notify --page PATH`.',
+        guide: 'The pane always watches the file and live-updates on every save — a displayed doc is a live view by definition, so point it at a file something keeps rewriting (a status board, a running summary) and it stays current. The file is directive-flavored markdown rendered by termrender (panels, columns, trees, callouts, mermaid). To put a rich document in front of the user as a durable inbox page, use `crtr human send --page PATH`; a page with no response-bearing components is a standalone announcement.',
         params: [
             { kind: 'positional', name: 'path', type: 'path', required: true, constraint: 'Path to the file to render.' },
             { kind: 'flag', name: 'window', type: 'enum', choices: ['auto', 'split', 'new'], required: false, default: 'auto', constraint: 'Placement. Default auto.' },