@north-light/crouter 0.3.311 → 0.3.313

package/dist/commands/canvas-history/shared.js

@@ -46,7 +46,7 @@ export const filterParams = [
     { kind: 'flag', name: 'all-cwds', type: 'bool', required: false, constraint: 'Search every cwd on the canvas. Mutually exclusive with --cwd.' },
     { kind: 'flag', name: 'under', type: 'string', required: false, constraint: 'Restrict to a node and its subscription descendants (one initiative / sub-DAG).' },
     { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Restrict to specific node ids. Comma-separated for several.' },
-    { kind: 'flag', name: 'type', type: 'string', required: false, constraint: `Corpus to search; comma-separated for several. One of: ${TYPES.join(', ')}. report = push history; doc = context artifacts; roadmap = roadmap.md specifically; meta = node name/description/kind; inbox = raw inbox.jsonl history, cursor-independent and including full un-clipped direct-message bodies (diagnostic, not curated work). Default: report, doc, roadmap, meta \u2014 inbox is opt-in only, pass --type inbox explicitly.` },
+    { kind: 'flag', name: 'type', type: 'string', required: false, constraint: `Corpus to search; comma-separated for several. One of: ${TYPES.join(', ')}. report = push history; doc = context artifacts; roadmap = roadmap.md specifically; meta = node name/description/kind; inbox = inbox history including full un-clipped direct-message bodies (diagnostic, not curated work). Default: report, doc, roadmap, meta \u2014 inbox is opt-in only, pass --type inbox explicitly.` },
     { kind: 'flag', name: 'report-kind', type: 'enum', choices: ['final', 'update'], required: false, constraint: 'Narrow reports to outcome summaries (final) or progress (update). Implies --type report.' },
     { kind: 'flag', name: 'kind', type: 'string', required: false, constraint: `Node kind; comma-separated for several. One of: ${NODE_KINDS.join(', ')}.` },
     { kind: 'flag', name: 'status', type: 'string', required: false, constraint: `Node lifecycle status; comma-separated for several. One of: ${STATUSES.join(', ')} (e.g. done = completed work only).` },

package/dist/commands/canvas-history.js

@@ -25,7 +25,7 @@ export const historyBranch = defineBranch({
     help: {
         name: 'canvas history',
         summary: 'search and recall the cwd-wide content corpus — every node\'s reports and context docs in this cwd',
-        model: 'The accumulated record of every node that ran in a cwd and the artifacts it left — its reports (final/update outcome summaries), context docs (specs, designs, roadmaps, findings), and the conversations themselves. `search` finds by content (ranked, filtered, sorted; omit the query to browse by recency); `grep` finds by an exact ECMAScript regex over body lines (pattern required, one hit per matching line — use this over `search` when you know the literal string/pattern, not just the topic); `read` pulls one hit\'s full body by its <node-id>:<relpath> ref, `--format raw` for the verbatim bytes; `stats` counts the same filtered corpus by one dimension instead of listing hits. Corpus is a DIMENSION here, not a location: `--type` selects which record you search, and every leaf takes the same scope and filters. This is the episodic record of what was DONE — distinct from `crtr memory`, which is curated semantic knowledge. Already have a node id and want everything IT left behind (not a cwd-wide search)? Use `node inspect artifacts <node-id>` instead. Two corpora are opt-in diagnostics rather than curated work: `--type inbox` is one node\'s full cursor-independent inbox.jsonl including un-clipped message bodies, and `--type transcript` is the conversation itself, message by message, each inbound turn carrying the origin that drove it (`--origin`, `--role`, `--from`, and `stats --group-by origin` for the census). Transcripts require a narrowing flag because there is no index. To reopen a node you found, use `node lifecycle revive`; for its place in the graph, `node inspect show`.',
+        model: 'The accumulated record of every node that ran in a cwd and the artifacts it left — its reports (final/update outcome summaries), context docs (specs, designs, roadmaps, findings), and the conversations themselves. `search` finds by content (ranked, filtered, sorted; omit the query to browse by recency); `grep` finds by an exact ECMAScript regex over body lines (pattern required, one hit per matching line — use this over `search` when you know the literal string/pattern, not just the topic); `read` pulls one hit\'s full body by its <node-id>:<relpath> ref, `--format raw` for the verbatim bytes; `stats` counts the same filtered corpus by one dimension instead of listing hits. Corpus is a DIMENSION here, not a location: `--type` selects which record you search, and every leaf takes the same scope and filters. This is the episodic record of what was DONE — distinct from `crtr memory`, which is curated semantic knowledge. Already have a node id and want everything IT left behind (not a cwd-wide search)? Use `node inspect artifacts <node-id>` instead. Two corpora are opt-in diagnostics rather than curated work: `--type inbox` is one node\'s full inbox history including un-clipped message bodies, and `--type transcript` is the conversation itself, message by message, each inbound turn carrying the origin that drove it (`--origin`, `--role`, `--from`, and `stats --group-by origin` for the census). Transcripts require a narrowing flag because there is no index. To reopen a node you found, use `node lifecycle revive`; for its place in the graph, `node inspect show`.',
         dynamicState: corpusBlock,
     },
     children: [searchLeaf, grepLeaf, readLeaf, statsLeaf],

package/dist/commands/canvas-roster.js

@@ -15,7 +15,7 @@ export const canvasRosterLeaf = defineLeaf({
                 name: 'nodes',
                 type: 'object[]',
                 required: true,
-                constraint: 'Lean node rows (no per-row meta.json read) plus attention_count for the returned node set.',
+                constraint: 'Lean node rows plus attention_count for the returned node set.',
             },
             {
                 name: 'subscriptions',

package/dist/commands/canvas.js

@@ -15,7 +15,6 @@ import { reviveLeaf } from './revive.js';
 import { attentionBranch } from './attention.js';
 import { chordLeaf } from './chord.js';
 import { canvasPruneLeaf } from './canvas-prune.js';
-import { canvasRebuildIndexLeaf } from './canvas-rebuild-index.js';
 import { historyBranch } from './canvas-history.js';
 import { issueNewLeaf } from './canvas-issue.js';
 import { canvasConfigBranch } from './canvas-config.js';
@@ -45,6 +44,6 @@ export function registerCanvas() {
             summary: 'observe and supervise the whole agent graph',
             model: 'Canvas-wide operations, distinct from per-node work (`node`) and a node\'s own spine write verb (`push`). `dashboard` renders the subscription forest as a tree; `browse` opens an interactive full-screen navigator (tabs/tree/search) over the whole canvas and resumes the chosen node; `attention` aggregates pending replies from the user across the graph; `revive --all` mass-reconnects every disconnected node (bringing back ONE named node is `node lifecycle revive <id>` instead); `history` searches and recalls the content record (reports + context docs) of past work in a cwd; `prune` bounds growth by deleting terminal nodes past a TTL. `config` registers/lists remote canvas targets (preview endpoint + relay token); `use` switches remote-capable read commands such as `node inspect` onto a configured target or back to local.',
         },
-        children: [dashboardLeaf, canvasSnapshotLeaf, canvasRosterLeaf, browseLeaf, attentionBranch, reviveLeaf, historyBranch, chordLeaf, issueBranch, canvasPruneLeaf, canvasRebuildIndexLeaf, canvasConfigBranch, canvasUseLeaf],
+        children: [dashboardLeaf, canvasSnapshotLeaf, canvasRosterLeaf, browseLeaf, attentionBranch, reviveLeaf, historyBranch, chordLeaf, issueBranch, canvasPruneLeaf, canvasConfigBranch, canvasUseLeaf],
     });
 }

package/dist/commands/human/feedback.js

@@ -4,21 +4,24 @@
 // Creating comments is the person's channel (the page surface); no agent
 // authors, edits, or deletes them.
 import { envNodeId } from '../../shared/env.js';
-import { existsSync } from 'node:fs';
 import { ApiError } from '../../api/index.js';
 import { defineBranch, defineLeaf } from '../../core/command.js';
-import { pageManifestPath } from '../../core/human/convention.js';
-import { opaqueInboxTicketId, ticketDir } from '../../core/human/root.js';
 import { InputError } from '../../core/io.js';
 import { cliClient, rethrowAsCliError } from '../api-client.js';
-/** Feedback tickets are addressed by the same raw ids as `human resolve`:
- * the page_id from human send, which is also the ticket's directory name. */
-function requirePageTicketId(raw) {
-    const ticketId = raw;
-    if (!existsSync(pageManifestPath(ticketDir(ticketId)))) {
-        throw new InputError({ error: 'not_found', message: `no page ticket: ${ticketId}`, field: 'ticket_id', next: 'Pass the ticket id from your bearings, or a page ticket_id from `crtr human list`.' });
+/** Feedback tickets are addressed by request identity; crtrd returns their inbox identity. */
+async function requirePageTicketId(raw) {
+    const requestId = raw;
+    try {
+        const request = await cliClient().getHumanRequest(requestId);
+        if (request.kind !== 'page')
+            throw new InputError({ error: 'not_found', message: `no page ticket: ${requestId}`, field: 'ticket_id', next: 'Pass the ticket id from your bearings, or a page ticket_id from `crtr human list`.' });
+        return { requestId, inboxTicketId: request.inbox_ticket_id };
+    }
+    catch (error) {
+        if (error instanceof InputError)
+            throw error;
+        rethrowAsCliError(error, 'Pass the ticket id from your bearings, or a page ticket_id from `crtr human list`.');
     }
-    return ticketId;
 }
 const humanFeedbackList = defineLeaf({
     name: 'list',
@@ -39,10 +42,10 @@ const humanFeedbackList = defineLeaf({
         effects: ['None. Read-only.'],
     },
     run: async (input) => {
-        const ticketId = requirePageTicketId(input['ticket_id']);
+        const ticket = await requirePageTicketId(input['ticket_id']);
         try {
-            const page = await cliClient().getHumanInboxPage(opaqueInboxTicketId(ticketId));
-            return { ticket_id: ticketId, open_count: page.feedback.open_count, comments: page.feedback.comments };
+            const page = await cliClient().getHumanInboxPage(ticket.inboxTicketId);
+            return { ticket_id: ticket.requestId, open_count: page.feedback.open_count, comments: page.feedback.comments };
         }
         catch (e) {
             rethrowAsCliError(e);
@@ -80,14 +83,14 @@ const humanFeedbackResolve = defineLeaf({
         if (binding === undefined || binding === null || binding.kind !== 'page_feedback') {
             throw new InputError({ error: 'not_companion', message: 'this node is not a page-feedback companion — only the ticket\u2019s bound companion resolves its comments', next: 'Resolve from the companion conversation bound to the ticket.' });
         }
-        const ticketId = requirePageTicketId(binding.review_id);
+        const ticket = await requirePageTicketId(binding.review_id);
         try {
-            const result = await cliClient().resolvePageFeedbackComment(opaqueInboxTicketId(ticketId), commentId, callerNodeId);
-            return { resolved: true, ticket_id: ticketId, comment_id: commentId, open_count: result.feedback.open_count };
+            const result = await cliClient().resolvePageFeedbackComment(ticket.inboxTicketId, commentId, callerNodeId);
+            return { resolved: true, ticket_id: ticket.requestId, comment_id: commentId, open_count: result.feedback.open_count };
         }
         catch (e) {
             if (e instanceof ApiError && e.status === 409 && e.code === 'comment_already_resolved') {
-                return { resolved: false, ticket_id: ticketId, comment_id: commentId, reason: 'comment_already_resolved' };
+                return { resolved: false, ticket_id: ticket.requestId, comment_id: commentId, reason: 'comment_already_resolved' };
             }
             rethrowAsCliError(e);
         }

package/dist/commands/human/prompts.js

@@ -1,18 +1,14 @@
 import { envNodeId } from '../../shared/env.js';
 import { defineLeaf } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
-import { cliClient } from '../api-client.js';
+import { cliClient, rethrowAsCliError } from '../api-client.js';
 import { join } from 'node:path';
-import { randomBytes } from 'node:crypto';
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { 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 { bindTicketReplyRoute } from '../../core/human/convention.js';
-import { ticketDir } from '../../core/human/root.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 { preparePage } from '../../core/human/page-authoring.js';
+import { PageAuthoringError } from '../../core/human/page.js';
 import { isResponseBearingSlot, validateAuthoredPageManifest } from '../../core/human/page-schema.js';
 import { display } from '../../core/termrender/display.js';
 import { pageHelpText, resolveMaxPanes } from './shared.js';
@@ -100,18 +96,19 @@ function submitAuthoredPage(submit) {
         });
     }
 }
-/** 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.',
-        });
+/** The page a `--replace` names, read through crtrd for the routing it retains. */
+async function replacedPage(requestId) {
+    try {
+        const request = await cliClient().getHumanRequest(requestId);
+        if (request.kind !== 'page')
+            throw new InputError({ error: 'unknown_page', message: `no page ${requestId} on this canvas`, field: 'replace', next: 'Pass the page_id a previous send returned, or omit --replace to raise a new page.' });
+        return (await cliClient().getHumanInboxPage(request.inbox_ticket_id)).page;
+    }
+    catch (error) {
+        if (error instanceof InputError)
+            throw error;
+        rethrowAsCliError(error, '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-'));
@@ -184,14 +181,14 @@ export function humanSend(pageSurface = false) {
                 { name: 'dir', type: 'string', required: true, constraint: pageHelp.dirConstraint },
                 { 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: 'reply', type: 'boolean', required: true, constraint: 'Whether completion is delivered to the asking request identity. 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: [
-                '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.',
+                'Writes one durable page request. Inbox projection follows the delivery flags, except from a terminal node, which always projects; completion delivery 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.',
+                'A reply-bearing page records the asking node on the request and delivers completion directly to that node.',
                 '--replace rewrites source in place while retaining delivery and emitted time; open surfaces reload it without creating another page.',
             ],
         },
@@ -207,11 +204,12 @@ export function humanSend(pageSurface = false) {
             }
             try {
                 if (replacePage !== undefined) {
-                    const prior = replacedPage(replacePage);
+                    const prior = await 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) {
+                    const existing = await cliClient().getHumanRequest(replacePage);
+                    if (existing.state !== 'pending') {
                         throw new InputError({
                             error: 'page_settled',
                             message: `page ${replacePage} already has a terminal outcome`,
@@ -223,8 +221,8 @@ export function humanSend(pageSurface = false) {
                     // 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 updated = await cliClient().replaceHumanRequest(replacePage, { page: { dialect: revised.manifest.dialect, source: revised.document } });
+                    return { page_id: replacePage, dir: updated.request_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
@@ -247,8 +245,14 @@ export function humanSend(pageSurface = false) {
                 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);
+                    const created = await cliClient().createHumanRequest({
+                        page: { dialect: prepared.manifest.dialect, source: prepared.document },
+                        delivery,
+                        source: prepared.manifest.source,
+                        requester_node_id: null,
+                        creator_cwd: process.cwd(),
+                    });
+                    const dir = created.request_dir;
                     // 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
@@ -262,16 +266,21 @@ export function humanSend(pageSurface = false) {
                             : 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 };
+                    return { page_id: created.request_id, 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, 'requestedHumanReply');
-                return { page_id: bridgeNodeId, dir, ...delivery, follow_up: queuedFollowUp() };
+                if (originNodeId === null || originNodeId === '') {
+                    throw new InputError({ error: 'no_requester', message: 'a response-bearing page must be sent from a crouter node', field: 'page', next: 'Run `crtr human send` from the node that should receive the answer.' });
+                }
+                const created = await cliClient().createHumanRequest({
+                    page: { dialect: prepared.manifest.dialect, source: prepared.document },
+                    delivery,
+                    source: prepared.manifest.source,
+                    requester_node_id: originNodeId,
+                    creator_cwd: process.cwd(),
+                });
+                markStopSignal(originNodeId, 'requestedHumanReply');
+                return { page_id: created.request_id, dir: created.request_dir, ...delivery, follow_up: queuedFollowUp() };
             }
             finally {
                 if (tempDir !== undefined)

package/dist/commands/human/queue.js

@@ -1,38 +1,26 @@
 import { envNodeId } from '../../shared/env.js';
-import { existsSync } from 'node:fs';
 import { ApiError } from '../../api/index.js';
 import { defineLeaf } from '../../core/command.js';
-import { ticketDir } from '../../core/human/root.js';
-import { scanInbox } from '../../core/human/scan.js';
-import { pageManifestPath, isResolved, readTicketReplyRoute, reviewPath } from '../../core/human/convention.js';
 import { InputError } from '../../core/io.js';
 import { paginate } from '../../core/pagination.js';
 import { cliClient, rethrowAsCliError } from '../api-client.js';
-import { filterVisibleReviewTickets } from '../../clients/inbox/review-visibility.js';
-function toRef(n) {
-    return { node_id: n.node_id, name: n.name, cwd: n.cwd, parent: n.parent, status: n.status };
-}
-/** The canvas roster, fetched ONCE per leaf run through the API and threaded
- *  into the sync provenance helpers below (the API surface is async, so the
- *  fetch is hoisted to the leaf and the helpers read the pre-fetched
- *  array/map). */
 async function fetchNodeRefs() {
-    return (await cliClient().listNodes()).map(toRef);
+    return (await cliClient().listNodes()).map((node) => ({ node_id: node.node_id, name: node.name, cwd: node.cwd, parent: node.parent, status: node.status }));
 }
 function resolveConversation(asking, nodes) {
     if (asking === undefined)
         return undefined;
-    const byId = new Map(nodes.map((n) => [n.node_id, n]));
-    let cur = asking;
+    const byId = new Map(nodes.map((node) => [node.node_id, node]));
+    let current = asking;
     const seen = new Set();
-    while (cur.parent !== null && !seen.has(cur.node_id)) {
-        seen.add(cur.node_id);
-        const parent = byId.get(cur.parent);
+    while (current.parent !== null && !seen.has(current.node_id)) {
+        seen.add(current.node_id);
+        const parent = byId.get(current.parent);
         if (parent === undefined)
             break;
-        cur = parent;
+        current = parent;
     }
-    return cur;
+    return current;
 }
 function readableSourceLabel(source) {
     const sessionName = source?.sessionName?.trim();
@@ -41,55 +29,39 @@ function readableSourceLabel(source) {
     const askedBy = source?.askedBy?.trim();
     return askedBy === '' ? undefined : askedBy;
 }
-function askingNodeFor(jobId, byId) {
-    const bridge = byId.get(jobId);
-    if (bridge?.parent !== undefined && bridge.parent !== null)
-        return byId.get(bridge.parent) ?? bridge;
-    return bridge;
-}
-/** A missing reply route is the complete representation of a standalone page;
- * a route whose bridge disappeared is an orphaned reply-bearing ticket. */
-function replyBridgeId(dir) {
-    return readTicketReplyRoute(dir)?.bridge_node_id ?? null;
-}
 function summarizeTicket(summary, nodes, byId) {
-    const bridgeNodeId = replyBridgeId(summary.dir);
-    // A reply-bearing ticket whose bridge was reaped is stale and absent from the
-    // canvas view. A standalone page has no bridge by construction.
-    if (bridgeNodeId !== null && !byId.has(bridgeNodeId))
-        return null;
-    const asking = bridgeNodeId === null ? undefined : askingNodeFor(bridgeNodeId, byId);
+    const asking = summary.source.nodeId === undefined ? undefined : byId.get(summary.source.nodeId);
     const conversation = resolveConversation(asking, nodes);
     const sourceLabel = readableSourceLabel(summary.source);
     return {
-        ticket_id: summary.id,
-        ...(bridgeNodeId === null ? {} : { bridge_node_id: bridgeNodeId }),
-        dir: summary.dir,
+        ticket_id: summary.request_id,
+        dir: summary.request_dir,
         title: summary.title,
-        subtitle: summary.subtitle,
+        subtitle: summary.subtitle ?? '',
         kind: summary.kind,
-        ...(summary.kind === 'page' ? { emitted_at: summary.emittedAt } : { blocked_since: summary.blockedSince }),
-        ...(summary.claim !== undefined ? { claim_owner: summary.claim.owner } : {}),
-        ...(sourceLabel !== undefined ? { source_label: sourceLabel } : {}),
-        ...(asking !== undefined ? { asking_node_id: asking.node_id, asking_node_name: asking.name, cwd: asking.cwd } : {}),
-        ...(conversation !== undefined ? { conversation_id: conversation.node_id, conversation_title: conversation.name } : {}),
+        ...(summary.kind === 'page' ? { emitted_at: summary.emitted_at } : { blocked_since: summary.blocked_since }),
+        ...(sourceLabel === undefined ? {} : { source_label: sourceLabel }),
+        ...(asking === undefined ? {} : { asking_node_id: asking.node_id, asking_node_name: asking.name, cwd: asking.cwd }),
+        ...(conversation === undefined ? {} : { conversation_id: conversation.node_id, conversation_title: conversation.name }),
     };
 }
-function interactionDirForTicket(ticketId, byId) {
-    const dir = ticketDir(ticketId);
-    if (!existsSync(pageManifestPath(dir)) && !existsSync(reviewPath(dir))) {
-        throw new InputError({ error: 'not_found', message: `no interaction ticket: ${ticketId}`, field: 'ticket_id', next: 'Pass a ticket_id from `crtr human list`.' });
+async function requireInteraction(ticketId) {
+    try {
+        const request = await cliClient().getHumanRequest(ticketId);
+        return { request_id: request.request_id, kind: request.kind };
     }
-    const bridgeNodeId = replyBridgeId(dir);
-    return { dir, bridge: bridgeNodeId === null ? null : byId.get(bridgeNodeId) ?? null };
-}
-function isTerminalBridge(status) {
-    return status === 'done' || status === 'dead' || status === 'canceled';
+    catch (error) {
+        if (!(error instanceof ApiError) || error.status !== 404)
+            rethrowAsCliError(error);
+    }
+    const ticket = (await cliClient().listHumanInbox()).tickets.find((item) => item.ticket_id === ticketId);
+    if (ticket === undefined)
+        throw new InputError({ error: 'not_found', message: `no interaction ticket: ${ticketId}`, field: 'ticket_id', next: 'Pass a ticket_id from `crtr human list`.' });
+    return { request_id: ticket.request_id, kind: ticket.kind };
 }
-function isAlreadyResolvedConflict(error) {
-    return error instanceof ApiError && error.status === 409 && error.code === 'ticket_already_resolved';
+function isAlreadySettled(error) {
+    return error instanceof ApiError && error.status === 409 && (error.code === 'already_settled' || error.code === 'review_terminal_conflict');
 }
-// list (read-only, paginated)
 export const humanList = defineLeaf({
     name: 'list',
     description: 'enumerate pending interactions',
@@ -102,7 +74,7 @@ export const humanList = defineLeaf({
             { kind: 'flag', name: 'cursor', type: 'string', required: false, constraint: "Opaque token from a previous response's next_cursor. Omit on first call." },
         ],
         output: [
-            { name: 'items', type: 'object[]', required: true, constraint: 'Each: {ticket_id, dir, title, subtitle, kind, emitted_at? | blocked_since?}; pages use emitted_at, reviews use blocked_since. Enriched when derivable with bridge_node_id, claim_owner, source_label, asking_node_id/name, conversation_id/title. Oldest first.' },
+            { name: 'items', type: 'object[]', required: true, constraint: 'Each: {ticket_id, dir, title, subtitle, kind, emitted_at? | blocked_since?}; pages use emitted_at, reviews use blocked_since. Enriched when derivable with claim_owner, source_label, asking_node_id/name, conversation_id/title. Oldest first.' },
             { name: 'next_cursor', type: 'string | null', required: true, constraint: 'Pass on the next call to continue. null means no more items.' },
             { name: 'total', type: 'integer | null', required: true, constraint: 'Total pending interactions.' },
         ],
@@ -110,47 +82,35 @@ export const humanList = defineLeaf({
         effects: ['None. Read-only.'],
     },
     run: async (input) => {
-        const limitRaw = input['limit'];
-        const limit = Math.min(Math.max(1, limitRaw), 100);
-        const cursor = input['cursor'];
-        const { tickets } = await cliClient().listHumanInbox();
-        const raw = filterVisibleReviewTickets(scanInbox(), new Set(tickets.map((ticket) => ticket.ticket_id)));
+        const limit = Math.min(Math.max(1, input['limit']), 100);
         const nodes = await fetchNodeRefs();
-        const byId = new Map(nodes.map((n) => [n.node_id, n]));
-        const items = raw
-            .flatMap((s) => {
-            const item = summarizeTicket(s, nodes, byId);
-            return item === null ? [] : [item];
-        })
-            .sort((a, b) => {
-            const ka = `${a.emitted_at ?? a.blocked_since}|${a.ticket_id}`;
-            const kb = `${b.emitted_at ?? b.blocked_since}|${b.ticket_id}`;
-            return ka < kb ? -1 : ka > kb ? 1 : 0;
+        const byId = new Map(nodes.map((node) => [node.node_id, node]));
+        const items = (await cliClient().listHumanInbox()).tickets.map((summary) => summarizeTicket(summary, nodes, byId)).sort((a, b) => {
+            const left = `${a.emitted_at ?? a.blocked_since}|${a.ticket_id}`;
+            const right = `${b.emitted_at ?? b.blocked_since}|${b.ticket_id}`;
+            return left < right ? -1 : left > right ? 1 : 0;
         });
-        const page = paginate(items, { limit, cursor }, {
+        const page = paginate(items, { limit, cursor: input['cursor'] }, {
             defaultLimit: 20,
             maxLimit: 100,
-            keyOf: (i) => `${i.emitted_at ?? i.blocked_since}|${i.ticket_id}`,
+            keyOf: (item) => `${item.emitted_at ?? item.blocked_since}|${item.ticket_id}`,
             total: 'count',
         });
         return { items: page.items, next_cursor: page.next_cursor, total: page.total };
     },
 });
-// resolve — non-interactive human answer
-/** Decode the stdin envelope only; the daemon validates every response against the page manifest. */
 function parseResolveBody(raw) {
     let parsed;
     try {
         parsed = JSON.parse(raw);
     }
-    catch (e) {
-        throw new InputError({ error: 'invalid_json', message: `stdin is not valid JSON: ${String(e)}`, field: 'stdin', next: 'Pass {"responses":{"<component_id>":{...}}} on stdin.' });
+    catch (error) {
+        throw new InputError({ error: 'invalid_json', message: `stdin is not valid JSON: ${String(error)}`, field: 'stdin', next: 'Pass {"responses":{"<component_id>":{...}}} on stdin.' });
     }
-    const responses = parsed.responses;
-    if (typeof responses !== 'object' || responses === null || Array.isArray(responses)) {
+    if (typeof parsed.responses !== 'object' || parsed.responses === null || Array.isArray(parsed.responses)) {
         throw new InputError({ error: 'invalid_field', message: 'responses must be an object keyed by the id of a response-bearing component', field: 'responses', next: 'Pass {"responses":{"<component_id>":{...}}}, or {"responses":{}} to acknowledge a page with no response-bearing components.' });
     }
-    return responses;
+    return parsed.responses;
 }
 export const humanResolve = defineLeaf({
     name: 'resolve',
@@ -166,76 +126,66 @@ export const humanResolve = defineLeaf({
         ],
         output: [
             { name: 'resolved', type: 'boolean', required: true, constraint: 'True when this call completed the page.' },
-            { name: 'ticket_id', type: 'string', required: true, constraint: 'Interaction ticket id.' },
-            { name: 'reason', type: 'string', required: false, constraint: 'already_resolved or claimed when resolved is false.' },
+            { name: 'ticket_id', type: 'string', required: true, constraint: 'Interaction request id.' },
+            { name: 'reason', type: 'string', required: false, constraint: 'already_settled when resolved is false.' },
         ],
         outputKind: 'object',
-        effects: ['The daemon publishes the answer and, when the ticket has a reply route, retires its bridge and returns the completion to subscribers.'],
+        effects: ['The daemon settles the request and directly delivers a reply-bearing completion to its asking node.'],
     },
     run: async (input) => {
         const ticketId = input['ticket_id'];
-        const nodes = await fetchNodeRefs();
-        const byId = new Map(nodes.map((n) => [n.node_id, n]));
-        const { dir, bridge } = interactionDirForTicket(ticketId, byId);
-        if (!existsSync(pageManifestPath(dir))) {
-            throw new InputError({ error: 'not_found', message: `no page for interaction: ${ticketId}`, field: 'ticket_id', next: 'Pass a pending ticket_id from `crtr human list`.' });
-        }
-        const responses = parseResolveBody(input['body']);
-        // A published result on a live bridge may be an interrupted delivery. The
-        // daemon re-drives that delivery before it returns its 409. A standalone
-        // ticket or terminal bridge has nothing left to deliver.
-        if (isResolved(dir) && (bridge === null || isTerminalBridge(bridge.status))) {
-            return { resolved: false, ticket_id: ticketId, reason: 'already_resolved' };
-        }
+        const ticket = await requireInteraction(ticketId);
+        if (ticket.kind !== 'page')
+            throw new InputError({ error: 'not_found', message: `no page for interaction: ${ticketId}`, field: 'ticket_id', next: 'Pass a pending page ticket_id from `crtr human list`.' });
         try {
-            await cliClient().resolveHumanTicket(ticketId, { responses });
+            await cliClient().respondHumanRequest(ticket.request_id, { responses: parseResolveBody(input['body']), actor: envNodeId() ?? 'human' });
         }
-        catch (e) {
-            if (isAlreadyResolvedConflict(e))
-                return { resolved: false, ticket_id: ticketId, reason: 'already_resolved' };
-            rethrowAsCliError(e);
+        catch (error) {
+            if (isAlreadySettled(error))
+                return { resolved: false, ticket_id: ticketId, reason: 'already_settled' };
+            rethrowAsCliError(error);
         }
         return { resolved: true, ticket_id: ticketId };
     },
 });
-// cancel — retract a pending page/review
 export const humanCancel = defineLeaf({
     name: 'cancel',
     description: 'retract a pending page/review',
     whenToUse: 'a page or review went stale before the user completed it',
     help: {
         name: 'human cancel',
-        summary: 'retract a pending page/review — drops it from the human inbox and retires its reply bridge when one exists. Reach for this the moment an interaction goes stale so the user is not left completing something that no longer matters',
-        guide: 'Pass the page_id returned by `human send`, or a ticket_id from `human list`. Best-effort and idempotent: if the user already completed or canceled it, canceled:false with reason "already_resolved" changes nothing. Cancellation races the user\'s submit; whichever wins is authoritative. For a reply-bearing ticket, only subscribers other than the caller receive the cancellation notice.',
+        summary: 'retract a pending page or review',
         params: [
             { kind: 'positional', name: 'ticket_id', type: 'string', required: true, constraint: 'page_id returned by human send, or ticket_id returned by human list.' },
-            { kind: 'flag', name: 'reason', type: 'string', required: false, constraint: 'Optional short note delivered to subscribers explaining why it was retracted.' },
+            { kind: 'flag', name: 'reason', type: 'string', required: false, constraint: 'Optional short note delivered to the asking node explaining why it was retracted.' },
         ],
         output: [
-            { name: 'canceled', type: 'boolean', required: true, constraint: 'True when the interaction was retracted; false when there was nothing live to cancel (already answered/canceled).' },
-            { name: 'ticket_id', type: 'string', required: true, constraint: 'The interaction ticket id.' },
-            { name: 'reason', type: 'string', required: false, constraint: 'Why nothing was canceled (e.g. "already_resolved"), present when canceled is false.' },
+            { name: 'canceled', type: 'boolean', required: true, constraint: 'True when the interaction was retracted; false when it was already terminal.' },
+            { name: 'ticket_id', type: 'string', required: true, constraint: 'The interaction request id.' },
+            { name: 'reason', type: 'string', required: false, constraint: 'already_settled when canceled is false.' },
         ],
         outputKind: 'object',
-        effects: [
-            'The daemon removes the ticket from the inbox; when it has a reply bridge, the bridge retires and subscribers other than the caller are notified that no answer is coming.',
-        ],
+        effects: ['The daemon removes the request from the human inbox and directly notifies its asking node when it has one.'],
     },
     run: async (input) => {
         const ticketId = input['ticket_id'];
+        const ticket = await requireInteraction(ticketId);
         const reason = input['reason'];
-        const actor = envNodeId() ?? 'human';
+        const body = { ...(reason === undefined || reason === '' ? {} : { reason }), actor: envNodeId() ?? 'human' };
         try {
-            await cliClient().cancelHumanTicket(ticketId, { ...(reason !== undefined && reason !== '' ? { reason } : {}), actor });
+            if (ticket.kind === 'review')
+                await cliClient().cancelReview(ticket.request_id, body);
+            else
+                await cliClient().cancelHumanRequest(ticket.request_id, body);
         }
-        catch (e) {
-            if (isAlreadyResolvedConflict(e))
-                return { canceled: false, ticket_id: ticketId, reason: 'already_resolved' };
-            rethrowAsCliError(e);
+        catch (error) {
+            if (isAlreadySettled(error))
+                return { canceled: false, ticket_id: ticketId, reason: 'already_settled' };
+            rethrowAsCliError(error);
         }
         return { canceled: true, ticket_id: ticketId };
     },
-    render: (r) => r['canceled'] === true
-        ? `Canceled human interaction ${r['ticket_id']} — it left the human inbox.`
-        : `Nothing to cancel for ${r['ticket_id']} — ${r['reason'] ?? 'nothing to cancel'}.`,
+    render: (result) => result['canceled'] === true
+        ? `Canceled human interaction ${result['ticket_id']} — it left the human inbox.`
+        : `Nothing to cancel for ${result['ticket_id']} — ${result['reason'] ?? 'nothing to cancel'}.`,
 });