@north-light/crouter 0.3.198 → 0.3.200

package/dist/core/human/root.d.ts

@@ -1,6 +1,10 @@
 export declare function ticketsRoot(): string;
-/** A ticket directory is the bridge node's canvas directory, the same path by construction. */
-export declare function ticketDir(nodeId: string): string;
+/** The opaque id the `/v1/human/inbox` routes address a ticket by — a hash of
+ * the canonical tickets root and the ticket directory basename. The daemon
+ * derives the same value when it resolves a route id back to a directory. */
+export declare function opaqueInboxTicketId(ticketId: string): string;
+/** Ticket directories share the canvas node root. Reply-bearing tickets may use their bridge id; standalone pages use an independent ticket id. */
+export declare function ticketDir(ticketId: string): string;
 export declare function inboxActivityPath(): string;
 /** Signal one durable ticket mutation to every open inbox without watching every ticket directory. */
 export declare function signalInboxActivity(): void;

package/dist/core/human/root.js

@@ -1,12 +1,20 @@
-import { mkdirSync, watch, writeFileSync } from 'node:fs';
+import { mkdirSync, realpathSync, watch, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { basename, dirname, join } from 'node:path';
 import { crtrHome, nodeDir, nodesRoot } from '../canvas/paths.js';
 export function ticketsRoot() {
     return nodesRoot();
 }
-/** A ticket directory is the bridge node's canvas directory, the same path by construction. */
-export function ticketDir(nodeId) {
-    return nodeDir(nodeId);
+/** The opaque id the `/v1/human/inbox` routes address a ticket by — a hash of
+ * the canonical tickets root and the ticket directory basename. The daemon
+ * derives the same value when it resolves a route id back to a directory. */
+export function opaqueInboxTicketId(ticketId) {
+    const canonicalRoot = realpathSync(ticketsRoot());
+    return createHash('sha256').update(`${canonicalRoot}\0${ticketId}`, 'utf8').digest('hex');
+}
+/** Ticket directories share the canvas node root. Reply-bearing tickets may use their bridge id; standalone pages use an independent ticket id. */
+export function ticketDir(ticketId) {
+    return nodeDir(ticketId);
 }
 export function inboxActivityPath() {
     return join(crtrHome(), 'signals', 'inbox-activity');

package/dist/core/human/scan.d.ts

@@ -1,13 +1,12 @@
-import type { ProductPageComponents } from '../../types.js';
 import type { PageTicketSummary, TicketSummary } from './types.js';
 /** Read all unresolved page/review tickets, newest first. Progress never affects visibility. */
-export declare function scanInbox(productKinds?: ProductPageComponents): TicketSummary[];
+export declare function scanInbox(): TicketSummary[];
 export interface PageHistoryEntry extends PageTicketSummary {
-    state: 'pending' | 'resolved' | 'canceled';
+    state: 'pending' | 'resolved' | 'canceled' | 'passive';
 }
 /**
  * Every page ticket raised by one node — pending, resolved or canceled — oldest
  * first. This is the durable discovery seam for transcript placement, so it is a
  * separate walk from the pending-only inbox scan and never filters on a terminal file.
  */
-export declare function scanPageHistory(nodeId: string, productKinds?: ProductPageComponents): PageHistoryEntry[];
+export declare function scanPageHistory(nodeId: string): PageHistoryEntry[];

package/dist/core/human/scan.js

@@ -25,18 +25,18 @@ function reviewSummary(dir, id) {
     }
     return { dir, id, kind: 'review', title: review.title, subtitle: review.subtitle, file: review.file, output: review.output, source: review.source, blockedSince: review.blockedSince, claim: claimSummary(dir) };
 }
-function pageSummary(dir, id, productKinds) {
+function pageSummary(dir, id) {
     let manifest;
     try {
-        manifest = parsePage(dir, productKinds);
+        manifest = parsePage(dir);
     }
     catch {
         return null;
     }
-    let blockedSince = manifest.source?.blockedSince;
-    if (blockedSince === undefined) {
+    let emittedAt = manifest.source?.emittedAt;
+    if (emittedAt === undefined) {
         try {
-            blockedSince = statSync(pageManifestPath(dir)).mtime.toISOString();
+            emittedAt = statSync(pageManifestPath(dir)).mtime.toISOString();
         }
         catch {
             return null;
@@ -49,17 +49,18 @@ function pageSummary(dir, id, productKinds) {
         title: manifest.title,
         subtitle: manifest.subtitle ?? '',
         dialect: manifest.dialect,
-        placement: manifest.placement,
+        placement: manifest.delivery.placement,
+        inbox: manifest.delivery.inbox,
         steps: manifest.steps,
         slotKinds: manifest.slots.map((slot) => slot.kind),
-        awaitsResponse: readJsonOrNull(join(dir, 'run.json'))?.mode === 'ask',
+        awaitsResponse: manifest.delivery.reply,
         source: manifest.source ?? {},
-        blockedSince,
+        emittedAt,
         claim: claimSummary(dir),
     };
 }
 /** Read all unresolved page/review tickets, newest first. Progress never affects visibility. */
-export function scanInbox(productKinds = []) {
+export function scanInbox() {
     let entries;
     try {
         entries = readdirSync(ticketsRoot());
@@ -79,18 +80,18 @@ export function scanInbox(productKinds = []) {
         }
         if (isResolved(dir))
             continue;
-        const item = reviewSummary(dir, basename(dir)) ?? pageSummary(dir, basename(dir), productKinds);
-        if (item !== null)
+        const item = reviewSummary(dir, basename(dir)) ?? pageSummary(dir, basename(dir));
+        if (item !== null && (item.kind !== 'page' || item.inbox))
             items.push(item);
     }
-    return items.sort((a, b) => b.blockedSince.localeCompare(a.blockedSince) || a.id.localeCompare(b.id));
+    return items.sort((a, b) => (b.kind === 'page' ? b.emittedAt : b.blockedSince).localeCompare(a.kind === 'page' ? a.emittedAt : a.blockedSince) || a.id.localeCompare(b.id));
 }
 /**
  * Every page ticket raised by one node — pending, resolved or canceled — oldest
  * first. This is the durable discovery seam for transcript placement, so it is a
  * separate walk from the pending-only inbox scan and never filters on a terminal file.
  */
-export function scanPageHistory(nodeId, productKinds = []) {
+export function scanPageHistory(nodeId) {
     let entries;
     try {
         entries = readdirSync(ticketsRoot());
@@ -108,12 +109,12 @@ export function scanPageHistory(nodeId, productKinds = []) {
         catch {
             continue;
         }
-        const summary = pageSummary(dir, basename(dir), productKinds);
+        const summary = pageSummary(dir, basename(dir));
         if (summary === null || summary.source.nodeId !== nodeId)
             continue;
         const state = pageTicketState(dir);
         const result = state === 'resolved' ? readTicketResult(dir) : null;
         items.push({ ...summary, state, ...(result?.kind === 'page' ? { answerDigest: result.summary.replace(/\s+/g, ' ').trim() } : {}) });
     }
-    return items.sort((a, b) => Date.parse(a.blockedSince) - Date.parse(b.blockedSince) || a.id.localeCompare(b.id));
+    return items.sort((a, b) => Date.parse(a.emittedAt) - Date.parse(b.emittedAt) || a.id.localeCompare(b.id));
 }

package/dist/core/human/summary.d.ts

@@ -1,4 +1,3 @@
-import type { ProductPageComponents } from '../../types.js';
 import type { PageManifest, PageResponses } from './page-schema.js';
 /** The stable one-line digest stored in response.json. */
-export declare function buildPageSummary(manifest: PageManifest, responses: PageResponses, productKinds?: ProductPageComponents): string;
+export declare function buildPageSummary(manifest: PageManifest, responses: PageResponses): string;

package/dist/core/human/summary.js

@@ -1,5 +1,5 @@
 import { describePageAnswer } from './answer.js';
 /** The stable one-line digest stored in response.json. */
-export function buildPageSummary(manifest, responses, productKinds) {
-    return describePageAnswer(manifest, responses, { completedAt: '', productKinds }).digest;
+export function buildPageSummary(manifest, responses) {
+    return describePageAnswer(manifest, responses, { completedAt: '' }).digest;
 }

package/dist/core/human/tickets.d.ts

@@ -1,22 +1,22 @@
 import type { ReviewDescriptor, TicketResult } from './types.js';
 import type { ProductPageComponents } from '../../types.js';
-import { type AuthoredPageDialect } from './page.js';
-import { type PageManifest, type PageResponses, type PageSource } from './page-schema.js';
+import { type PageDelivery, type PageManifest, type PageResponses, type PageSource } from './page-schema.js';
 /** Strict decoder for the only canonical final marker. */
 export declare function readTicketResult(dir: string): TicketResult | null;
 export interface SubmitPageOptions {
     dir: string;
     /** The authored page source; copied into the ticket directory as its `document`. */
     sourceFile: string;
-    dialect: AuthoredPageDialect;
     source?: PageSource;
     productKinds?: ProductPageComponents;
+    delivery?: PageDelivery;
 }
 /** One validated page, ready to publish into a ticket directory. */
 export interface PreparedPage {
-    dialect: AuthoredPageDialect;
     /** The authored source, verbatim, as the ticket's `document`. */
     document: string;
+    /** The compiled CommonJS module the Gateway evaluates for JSX pages. */
+    module?: string;
     manifest: PageManifest;
 }
 /** Validate one authored page source into publishable form. Reads only: a page
@@ -25,7 +25,12 @@ export interface PreparedPage {
  *  The source is read exactly once, so the published document is the same bytes
  *  the manifest was derived from even if the file changes underneath. */
 export declare function preparePage(opts: Omit<SubmitPageOptions, 'dir'>): PreparedPage;
-/** Publish one prepared page ticket: the authored source plus its manifest, exclusively. */
+/** Publish one prepared page ticket: the authored source plus its manifest.
+ * These writes are overwrites. A ticket's REQUEST is whatever page the agent
+ * currently wants on screen, and `crtr human send --replace` revises it in
+ * place while the human watches; only the ANSWER is write-once, which
+ * `publishJsonExclusive` still guarantees for response.json alone. The manifest
+ * switches after all new generation files exist, then stale media is removed. */
 export declare function publishPage(dir: string, prepared: PreparedPage): {
     id: string;
     dir: string;
@@ -54,26 +59,27 @@ export declare function submitReview(opts: SubmitReviewOptions): {
     kind: 'review';
 };
 /** Validate a page resolution against its canonical ticket before claim takeover. */
-export declare function validatePageTicketResponses(dir: string, responses: unknown, productKinds?: ProductPageComponents): PageResponses;
+export declare function validatePageTicketResponses(dir: string, responses: unknown): PageResponses;
 /** The three terminal states of a page ticket, derived from its published result. */
-export declare function pageTicketState(dir: string): 'pending' | 'resolved' | 'canceled';
-/** Autosave partial page work. Every supplied response is validated; omitted slots are permitted. */
-export declare function writePageProgress(dir: string, responses: unknown, productKinds?: ProductPageComponents): PageResponses;
+export declare function pageTicketState(dir: string): 'pending' | 'resolved' | 'canceled' | 'passive';
+/** Autosave partial page work. Every supplied response is validated; omitted components are permitted. */
+export declare function writePageProgress(dir: string, responses: unknown): PageResponses;
 /** Saved partial work, or null when none exists. Malformed progress is an error, never silently discarded. */
-export declare function readPageProgress(dir: string, productKinds?: ProductPageComponents): PageResponses | null;
+export declare function readPageProgress(dir: string): PageResponses | null;
 export interface PageTicket {
     dir: string;
     id: string;
     manifest: PageManifest;
-    /** The authored source document, verbatim. */
+    /** The authored TSX source document, verbatim. */
     document: string;
-    state: 'pending' | 'resolved' | 'canceled';
+    /** The compiled module the Gateway evaluates, for JSX pages. */
+    module?: string;
+    state: 'pending' | 'resolved' | 'canceled' | 'passive';
     progress: PageResponses | null;
 }
 /** Read one addressable page ticket — pending, resolved or canceled alike. */
-export declare function readPageTicket(dir: string, productKinds?: ProductPageComponents): PageTicket;
+export declare function readPageTicket(dir: string): PageTicket;
 export interface CompletePageOptions {
-    productKinds?: ProductPageComponents;
     completedAt?: string;
 }
 export declare function completePage(dir: string, responses: unknown, claimToken: string, opts?: CompletePageOptions): {

package/dist/core/human/tickets.js

@@ -3,10 +3,10 @@ import { basename, isAbsolute, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
 import { buildPageSummary } from './summary.js';
-import { atomicWriteJson, clearProgress, claimPath, pageManifestPath, pagePath, progressPath, publishJsonExclusive, requireTicket, responsePath, reviewPath } from './convention.js';
+import { atomicWriteJson, atomicWriteText, clearProgress, claimPath, pageManifestPath, pageModulePath, pagePath, progressPath, publishJsonExclusive, requireTicket, responsePath, reviewPath } from './convention.js';
 import { validateReviewDescriptor, validateReviewProjection } from './review-schema.js';
-import { derivePageManifestFromDocument, parsePage, PageAuthoringError, snapshotPageSources } from './page.js';
-import { validatePageResponses, validatePartialPageResponses } from './page-schema.js';
+import { compilePage, deriveHtmlPageManifest, derivePageManifestFromDocument, parsePage, PageAuthoringError } from './page.js';
+import { isResponseBearingSlot, validatePageResponses, validatePartialPageResponses } from './page-schema.js';
 import { signalInboxActivity } from './root.js';
 import { readTicketClaim, releaseClaimLocked, withTicketLock } from './claim.js';
 import { checkReviewableFile } from './visible-paths.js';
@@ -46,7 +46,7 @@ export function readTicketResult(dir) {
     return canceled.success ? canceled.data : null;
 }
 function hasTicketProtocolState(dir) {
-    return [pageManifestPath(dir), pagePath(dir, 'md'), pagePath(dir, 'html'), reviewPath(dir), responsePath(dir), progressPath(dir), claimPath(dir)].some(existsSync);
+    return [pageManifestPath(dir), pagePath(dir), pageModulePath(dir), reviewPath(dir), responsePath(dir), progressPath(dir), claimPath(dir)].some(existsSync);
 }
 function publishRequest(path, value) {
     if (!publishJsonExclusive(path, value))
@@ -58,28 +58,58 @@ function publishRequest(path, value) {
  *  The source is read exactly once, so the published document is the same bytes
  *  the manifest was derived from even if the file changes underneath. */
 export function preparePage(opts) {
+    const html = /\.html?$/i.test(opts.sourceFile);
+    if (!html && !opts.sourceFile.endsWith('.tsx'))
+        throw new PageAuthoringError(`page source file must be .tsx, .html, or .htm: ${opts.sourceFile}`);
     if (!existsSync(opts.sourceFile))
         throw new PageAuthoringError(`page source file does not exist: ${opts.sourceFile}`);
     const document = readFileSync(opts.sourceFile, 'utf8');
-    const stamped = { ...(opts.source ?? {}), blockedSince: opts.source?.blockedSince ?? new Date().toISOString() };
-    const authored = derivePageManifestFromDocument(document, opts.dialect, opts.productKinds ?? [], stamped);
-    const manifest = snapshotPageSources(authored, opts.productKinds ?? []);
-    return { dialect: opts.dialect, document, manifest };
+    const stamped = { ...(opts.source ?? {}), emittedAt: opts.source?.emittedAt ?? new Date().toISOString() };
+    const delivery = opts.delivery ?? { placement: 'inline', inbox: false, reply: false };
+    if (html)
+        return { document, manifest: deriveHtmlPageManifest(document, stamped, delivery) };
+    return { document, module: compilePage(document), manifest: derivePageManifestFromDocument(document, opts.productKinds ?? [], stamped, delivery) };
 }
-/** Publish one prepared page ticket: the authored source plus its manifest, exclusively. */
+/** Remove a stale generation file. The manifest always switches first, so a
+ * failed cleanup leaves one valid current record plus harmless old source. */
+function unlinkIfPresent(path) {
+    try {
+        unlinkSync(path);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+/** Publish one prepared page ticket: the authored source plus its manifest.
+ * These writes are overwrites. A ticket's REQUEST is whatever page the agent
+ * currently wants on screen, and `crtr human send --replace` revises it in
+ * place while the human watches; only the ANSWER is write-once, which
+ * `publishJsonExclusive` still guarantees for response.json alone. The manifest
+ * switches after all new generation files exist, then stale media is removed. */
 export function publishPage(dir, prepared) {
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     const ticket = realpathSync(dir);
-    if (hasTicketProtocolState(ticket))
-        throw new Error(`ticket protocol state already exists: ${ticket}`);
-    writeFileSync(pagePath(ticket, prepared.dialect), prepared.document, { flag: 'wx', mode: 0o600 });
-    publishRequest(pageManifestPath(ticket), prepared.manifest);
+    atomicWriteText(pagePath(ticket, prepared.manifest.dialect), prepared.document);
+    if (prepared.manifest.dialect === 'jsx')
+        atomicWriteText(pageModulePath(ticket), prepared.module);
+    atomicWriteJson(pageManifestPath(ticket), prepared.manifest);
+    if (prepared.manifest.dialect === 'jsx')
+        unlinkIfPresent(pagePath(ticket, 'html'));
+    else {
+        unlinkIfPresent(pagePath(ticket, 'jsx'));
+        unlinkIfPresent(pageModulePath(ticket));
+    }
+    // Unconditional: a no-inbox page still lives in an attached viewer's transcript, and
+    // --replace promises every open surface reloads it.
     signalInboxActivity();
     return { id: basename(ticket), dir: ticket, kind: 'page', manifest: prepared.manifest };
 }
 /** Validate and publish one page ticket in a single step, for callers that own
  *  the ticket directory before they have a page. */
 export function submitPage(opts) {
+    if (existsSync(opts.dir) && hasTicketProtocolState(opts.dir) && !existsSync(pageManifestPath(opts.dir)))
+        throw new Error(`ticket protocol state already exists: ${opts.dir}`);
     return publishPage(opts.dir, preparePage(opts));
 }
 export function submitReview(opts) {
@@ -104,17 +134,40 @@ function exclusiveResult(dir, result) {
     return publishJsonExclusive(responsePath(dir), result);
 }
 function requireReview(dir) { return validateReviewDescriptor(JSON.parse(readFileSync(reviewPath(dir), 'utf8'))); }
-function requirePage(dir, productKinds) {
+function requirePage(dir) {
     if (!existsSync(pageManifestPath(dir)))
         throw new Error(`not a page ticket: ${dir}`);
-    return parsePage(dir, productKinds);
+    return parsePage(dir);
+}
+function requireSettleablePage(dir) {
+    const manifest = requirePage(dir);
+    if (!manifest.delivery.inbox && !manifest.delivery.reply)
+        throw new Error('page_has_no_response_lifecycle');
+    return manifest;
+}
+function isEmptyResponseMap(responses) {
+    return typeof responses === 'object' && responses !== null && !Array.isArray(responses) && Object.keys(responses).length === 0;
+}
+/** Validate a final page response against its ticket's reply contract. */
+function validateFinalPageTicketResponses(dir, responses) {
+    const manifest = requireSettleablePage(dir);
+    // An inbox-only page accepts an empty acknowledgement without requiring an answer
+    // from every response-bearing component.
+    if (!manifest.delivery.reply && isEmptyResponseMap(responses)) {
+        return validatePartialPageResponses(manifest, responses);
+    }
+    return validatePageResponses(manifest, responses);
 }
 /** Validate a page resolution against its canonical ticket before claim takeover. */
-export function validatePageTicketResponses(dir, responses, productKinds = []) {
-    return validatePageResponses(requirePage(requireTicket(dir), productKinds), responses);
+export function validatePageTicketResponses(dir, responses) {
+    const ticket = requireTicket(dir);
+    return validateFinalPageTicketResponses(ticket, responses);
 }
 /** The three terminal states of a page ticket, derived from its published result. */
 export function pageTicketState(dir) {
+    const manifest = requirePage(dir);
+    if (!manifest.delivery.inbox && !manifest.delivery.reply)
+        return 'passive';
     const result = readTicketResult(dir);
     if (result === null)
         return 'pending';
@@ -133,33 +186,38 @@ function readPageProgressFor(dir, manifest) {
     const parsed = pageProgressSchema.safeParse(raw);
     if (!parsed.success)
         throw new Error(`page progress is malformed: ${progressPath(dir)}`);
-    // Saved work is validated on read as well as on write: a page whose manifest
-    // changed under it must fail loudly rather than hydrate an answer it no longer has.
-    return validatePartialPageResponses(manifest, parsed.data.responses);
+    // A pending page's request can be replaced under saved work, so progress may
+    // name a component the current page no longer declares. Those entries are dropped
+    // and everything still declared hydrates; what remains is validated, so a
+    // saved answer that no longer fits its own component is still an error.
+    const declared = new Set(manifest.slots.filter(isResponseBearingSlot).map((slot) => slot.id));
+    const current = Object.fromEntries(Object.entries(parsed.data.responses).filter(([id]) => declared.has(id)));
+    return validatePartialPageResponses(manifest, current);
 }
-/** Autosave partial page work. Every supplied response is validated; omitted slots are permitted. */
-export function writePageProgress(dir, responses, productKinds = []) {
+/** Autosave partial page work. Every supplied response is validated; omitted components are permitted. */
+export function writePageProgress(dir, responses) {
     const ticket = requireTicket(dir);
-    const validated = validatePartialPageResponses(requirePage(ticket, productKinds), responses);
+    const validated = validatePartialPageResponses(requireSettleablePage(ticket), responses);
     atomicWriteJson(progressPath(ticket), { kind: 'page', responses: validated, savedAt: new Date().toISOString() });
     return validated;
 }
 /** Saved partial work, or null when none exists. Malformed progress is an error, never silently discarded. */
-export function readPageProgress(dir, productKinds = []) {
+export function readPageProgress(dir) {
     const ticket = requireTicket(dir);
-    return readPageProgressFor(ticket, requirePage(ticket, productKinds));
+    return readPageProgressFor(ticket, requireSettleablePage(ticket));
 }
 /** Read one addressable page ticket — pending, resolved or canceled alike. */
-export function readPageTicket(dir, productKinds = []) {
+export function readPageTicket(dir) {
     const ticket = requireTicket(dir);
-    const manifest = requirePage(ticket, productKinds);
+    const manifest = requirePage(ticket);
     return {
         dir: ticket,
         id: basename(ticket),
         manifest,
         document: readFileSync(pagePath(ticket, manifest.dialect), 'utf8'),
+        ...(manifest.dialect === 'jsx' ? { module: readFileSync(pageModulePath(ticket), 'utf8') } : { module: undefined }),
         state: pageTicketState(ticket),
-        progress: readPageProgressFor(ticket, manifest),
+        progress: manifest.delivery.inbox || manifest.delivery.reply ? readPageProgressFor(ticket, manifest) : null,
     };
 }
 function requireClaimOwnership(dir, token) {
@@ -170,9 +228,9 @@ function clearOwnedWork(dir, claimToken) { clearProgress(dir); releaseClaimLocke
 /** Caller holds `.ticket-lock`. */
 function completePageLocked(dir, responses, claimToken, opts) {
     requireClaimOwnership(dir, claimToken);
-    const manifest = requirePage(dir, opts.productKinds ?? []);
-    const parsedResponses = validatePageResponses(manifest, responses);
-    const result = { schema: 'crtr.page-response/v1', kind: 'page', responses: parsedResponses, summary: buildPageSummary(manifest, parsedResponses, opts.productKinds), completedAt: opts.completedAt ?? new Date().toISOString() };
+    const manifest = requirePage(dir);
+    const parsedResponses = validateFinalPageTicketResponses(dir, responses);
+    const result = { schema: 'crtr.page-response/v1', kind: 'page', responses: parsedResponses, summary: buildPageSummary(manifest, parsedResponses), completedAt: opts.completedAt ?? new Date().toISOString() };
     const won = exclusiveResult(dir, result);
     clearOwnedWork(dir, claimToken);
     return { won, result: won ? result : readTicketResult(dir) ?? result };
@@ -213,6 +271,8 @@ export function takeoverAndCompletePage(dir, responses, owner, opts = {}) {
 export function cancelTicket(dir, opts = {}) {
     const ticket = requireTicket(dir);
     const canceled = withTicketLock(ticket, () => {
+        if (existsSync(pageManifestPath(ticket)))
+            requireSettleablePage(ticket);
         const result = { schema: 'humanloop.cancel/v1', kind: 'canceled', canceledAt: new Date().toISOString(), ...(opts.reason === undefined ? {} : { reason: opts.reason }), ...(opts.actor === undefined ? {} : { actor: opts.actor }) };
         const won = exclusiveResult(ticket, result);
         return { status: won ? 'canceled' : 'already_resolved', result: won ? result : readTicketResult(ticket) ?? result };

package/dist/core/human/types.d.ts

@@ -48,12 +48,20 @@ export interface ReviewTicketSummary extends TicketSummaryBase {
     output: string;
 }
 /** Page triage fields: a client picks a transcript rendering without a second fetch. */
-export interface PageTicketSummary extends TicketSummaryBase {
+export interface PageTicketSummary {
+    dir: string;
+    id: string;
     kind: 'page';
+    title: string;
+    subtitle: string;
+    source: import('./page-schema.js').PageSource;
+    emittedAt: string;
+    claim?: ClaimSummary;
     /** Present on resolved history entries; the stored one-line response digest. */
     answerDigest?: string;
-    dialect: 'md' | 'html';
+    dialect: 'jsx' | 'html';
     placement: 'inline' | 'panel';
+    inbox: boolean;
     steps: number;
     slotKinds: string[];
     awaitsResponse: boolean;

package/dist/core/preview-registry.js

@@ -104,9 +104,8 @@ const LEAF_ICON_CP = {
     'canvas issue new': 0xf188,
     'canvas prune': 0xf0c4,
     'canvas rebuild-index': 0xf0ad,
-    'human ask': 0xf059,
+    'human send': 0xf059,
     'human review': 0xf044,
-    'human notify': 0xf0f3,
     'human show': 0xf108,
     'human cancel': 0xf00d,
     'human list': 0xf03a,
@@ -304,15 +303,14 @@ function summarizeDaemon(field, active, inactive) {
         return [{ text: state ? `${active}${pid === undefined ? '' : ` · pid ${pid}`}` : inactive, tone: state ? 'success' : 'muted' }];
     };
 }
-function summarizeHumanAsk(input, tokens) {
+function summarizeHumanSend(input) {
     const value = record(input);
-    if (value === undefined || stringField(value, 'job_id') === undefined)
+    if (value === undefined || stringField(value, 'page_id') === undefined)
         return null;
-    const question = tokens.slice(2).find((token) => !token.startsWith('--'));
-    return [
-        { text: 'ask posted → waiting on human', tone: 'accent' },
-        ...(question === undefined ? [] : [{ text: truncateLine(question.split('\n')[0].trim(), 160), tone: 'muted' }]),
-    ];
+    const reply = booleanField(value, 'reply');
+    if (reply === undefined)
+        return null;
+    return [{ text: reply ? 'page sent → waiting on human' : 'announcement sent', tone: reply ? 'accent' : 'success' }];
 }
 function summarizeHumanResolve(input) {
     const value = record(input);
@@ -352,7 +350,7 @@ const SUMMARIZERS = [
     { path: 'canvas attention count', run: summarizeCount('pending asks', true) },
     { path: 'canvas attention list', run: summarizeArray('pending asks') },
     { path: 'canvas attention map', run: summarizeAttentionMap },
-    { path: 'human ask', run: summarizeHumanAsk },
+    { path: 'human send', run: summarizeHumanSend },
     { path: 'human list', run: summarizeArray('pending') },
     { path: 'human resolve', run: summarizeHumanResolve },
     { path: 'pkg plugin list', run: summarizeArray('plugins') },

package/dist/core/profiles/default-binding.d.ts

@@ -4,3 +4,7 @@ export declare function resolveBindingCwd(cwd: string): string;
 export declare function getDefaultProfileId(cwd: string): string | null;
 export declare function setDefaultProfileId(cwd: string, profileId: string): void;
 export declare function clearDefaultProfile(cwd: string): void;
+/** Every directory currently pinned to `profileId`, in deterministic order. */
+export declare function defaultProfileDirs(profileId: string): string[];
+/** Clear every per-directory default that names `profileId`. */
+export declare function clearDefaultProfileId(profileId: string): string[];

package/dist/core/profiles/default-binding.js

@@ -44,3 +44,27 @@ export function clearDefaultProfile(cwd) {
     else
         writeJson(bindingsPath(), value);
 }
+/** Every directory currently pinned to `profileId`, in deterministic order. */
+export function defaultProfileDirs(profileId) {
+    return Object.entries(bindings())
+        .filter(([, pinnedProfileId]) => pinnedProfileId === profileId)
+        .map(([dir]) => dir)
+        .sort();
+}
+/** Clear every per-directory default that names `profileId`. */
+export function clearDefaultProfileId(profileId) {
+    const value = bindings();
+    const cleared = Object.entries(value)
+        .filter(([, pinnedProfileId]) => pinnedProfileId === profileId)
+        .map(([dir]) => dir)
+        .sort();
+    if (cleared.length === 0)
+        return [];
+    for (const dir of cleared)
+        delete value[dir];
+    if (Object.keys(value).length === 0)
+        removePath(bindingsPath());
+    else
+        writeJson(bindingsPath(), value);
+    return cleared;
+}

package/dist/core/profiles/deletion-reservation.d.ts

@@ -0,0 +1,8 @@
+/** Reserve one profile identity for its complete daemon-owned deletion lifecycle.
+ * The caller must release the returned lease after completion or failure. */
+export declare function reserveProfileDeletion(profileId: string): () => void;
+/** The synchronous birth gate. spawnNode calls this immediately before the
+ * canvas row is persisted. A reservation rejects a birth that reaches the gate
+ * during deletion; the exact manifest read rejects one whose async preflight
+ * started before a fast hard deletion and resumed after its lease was released. */
+export declare function assertProfileAvailableForBirth(profileId: string | null): void;

package/dist/core/profiles/deletion-reservation.js

@@ -0,0 +1,38 @@
+import { usage } from '../errors.js';
+import { loadExactProfileManifest } from './manifest.js';
+const deletingProfileIds = new Set();
+/** Reserve one profile identity for its complete daemon-owned deletion lifecycle.
+ * The caller must release the returned lease after completion or failure. */
+export function reserveProfileDeletion(profileId) {
+    if (deletingProfileIds.has(profileId)) {
+        throw usage(`profile deletion is already in progress: ${profileId}`, {
+            error: 'profile_deletion_in_progress',
+            profile_id: profileId,
+            next: 'Wait for the accepted deletion to finish before using this profile again.',
+        });
+    }
+    deletingProfileIds.add(profileId);
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        deletingProfileIds.delete(profileId);
+    };
+}
+/** The synchronous birth gate. spawnNode calls this immediately before the
+ * canvas row is persisted. A reservation rejects a birth that reaches the gate
+ * during deletion; the exact manifest read rejects one whose async preflight
+ * started before a fast hard deletion and resumed after its lease was released. */
+export function assertProfileAvailableForBirth(profileId) {
+    if (profileId === null)
+        return;
+    if (deletingProfileIds.has(profileId)) {
+        throw usage(`cannot create a node while its profile is being deleted: ${profileId}`, {
+            error: 'profile_deletion_in_progress',
+            profile_id: profileId,
+            next: 'Choose another profile or wait for this deletion to finish.',
+        });
+    }
+    loadExactProfileManifest(profileId);
+}

package/dist/core/profiles/manifest.d.ts

@@ -30,6 +30,9 @@ export declare function listProfiles(): ProfileEntry[];
  *  function every command leaf and runtime consumer should
  *  call to turn a `<profile>` operand or `CRTR_PROFILE_ID` into a concrete,
  *  safe profile id. */
+/** Read one exact profile id without falling back to manifest-name matching.
+ * Used at persistence gates that already hold a resolved durable identity. */
+export declare function loadExactProfileManifest(profileId: string): ProfileEntry;
 export declare function loadProfileManifest(profileIdOrName: string): ProfileEntry;
 /** Hold the per-profile manifest lock for the duration of `fn`. ALL manifest
  *  mutations (create/rename/add-project/remove-project/delete/last-used)

package/dist/core/profiles/manifest.js

@@ -150,6 +150,18 @@ export function listProfiles() {
  *  function every command leaf and runtime consumer should
  *  call to turn a `<profile>` operand or `CRTR_PROFILE_ID` into a concrete,
  *  safe profile id. */
+/** Read one exact profile id without falling back to manifest-name matching.
+ * Used at persistence gates that already hold a resolved durable identity. */
+export function loadExactProfileManifest(profileId) {
+    assertSafeProfileId(profileId);
+    const manifest = readManifestFile(profileManifestPath(profileId), profileId);
+    if (manifest !== null)
+        return { profileId, manifest };
+    throw notFound(`profile not found: ${profileId}`, {
+        received: profileId,
+        next: 'Run `crtr profile list` to see available profiles.',
+    });
+}
 export function loadProfileManifest(profileIdOrName) {
     const all = listProfiles();
     if (ID_SHAPE.test(profileIdOrName)) {