@north-light/crouter 0.3.312 → 0.3.313

package/dist/clients/attach/chrome/ticket-panel.js

@@ -10,16 +10,23 @@
 // roster; Esc at the page top closes back to the editor.
 //
 // The claim lifecycle mirrors the inbox surface's detail screen: claim on
-// open, heartbeat every 10s, watch the ticket dir (page.json → reload, other
-// activity → close if resolved elsewhere), resolve through the daemon on
-// complete, release on close. Review tickets and unreadable pages fall back
-// to the full-pane inbox seated on the row.
-import { watch } from 'node:fs';
+// open, heartbeat every 10s, resolve through the daemon on complete, release
+// on close. Review tickets and unreadable pages fall back to the full-pane
+// inbox seated on the row.
+//
+// The page itself comes from the daemon, addressed by the row's opaque inbox
+// ticket id. Refresh is driven by inbox activity rather than a watch on the
+// request directory: a `--replace` revision is a NEW directory selected in SQL
+// before the activity signal fires, so the directory the panel opened on never
+// sees the replacement. Each signal re-reads the ticket once and compares its
+// revision and state — a moved revision reloads, a terminal state closes.
 import { claimTicket, heartbeatClaim, releaseClaim } from '../../../core/human/claim.js';
-import { readPageTicket, readTicketResult } from '../../../core/human/tickets.js';
+import { watchInboxActivity } from '../../../core/human/root.js';
 import { resolvePageComponents } from '../../../core/config.js';
 import { fillBar, stripSgr, truncate, REVERSE } from '../../../core/canvas/nav-render.js';
+import { cliClient } from '../../../commands/api-client.js';
 import { visibleWidth } from '../../inbox/tui/ansi.js';
+import { pageViewFromDTO, settledStatusOf } from '../../inbox/dto-adapt.js';
 import { PageAdapter } from '../../inbox/page-adapter.js';
 import { decodeInboxKey } from '../../inbox/tui/keys.js';
 import { daemonErrorMessage, resolveFailureKind, resolveTicketPage } from '../../inbox/resolve.js';
@@ -40,7 +47,7 @@ export function createTicketPanel(s, hooks) {
             return;
         session = undefined;
         clearInterval(open.heartbeat);
-        open.watcher?.close();
+        open.unwatch();
         open.adapter.close();
         if (release)
             releaseClaim(open.dir, open.token);
@@ -51,7 +58,7 @@ export function createTicketPanel(s, hooks) {
     const complete = async (open, responses) => {
         submitting = true;
         try {
-            await resolveTicketPage(open.dir, responses);
+            await resolveTicketPage(open.id, responses);
             closeSession(false);
             hooks.setNotice('Response sent');
         }
@@ -62,19 +69,45 @@ export function createTicketPanel(s, hooks) {
                 return; // keep the page open — nothing was submitted
             }
             closeSession(false);
-            hooks.setNotice(failure === 'already_resolved' ? resolvedElsewhereNotice(open.dir) : daemonErrorMessage(error));
+            hooks.setNotice(failure === 'already_settled' ? await resolvedElsewhereNotice(open.ticketId) : daemonErrorMessage(error));
         }
         finally {
             submitting = false;
         }
     };
-    const reload = (open) => {
+    /** One read per activity signal decides everything: a moved revision is a
+     *  replacement, a terminal state is a settlement somewhere else. */
+    const onActivity = async (open) => {
+        if (session !== open || submitting)
+            return;
+        let page;
+        try {
+            page = await cliClient().getHumanInboxPage(open.ticketId);
+        }
+        catch (error) {
+            if (session !== open)
+                return;
+            closeSession(true);
+            hooks.setNotice(`Ticket could not be read: ${daemonErrorMessage(error)}`);
+            return;
+        }
+        if (session !== open || submitting)
+            return;
+        if (page.state === 'resolved' || page.state === 'canceled') {
+            closeSession(true);
+            hooks.setNotice(page.state === 'canceled' ? 'Ticket was canceled by its requester' : 'Ticket was resolved elsewhere');
+            return;
+        }
+        if (page.revision === open.revision)
+            return;
+        open.revision = page.revision;
         try {
-            open.adapter.reload(readPageTicket(open.dir));
+            open.adapter.reload(pageViewFromDTO(page));
         }
         catch {
             hooks.setNotice('Page could not be read');
         }
+        tui.requestRender();
     };
     const editPageInput = (open) => {
         const buffer = open.adapter.inputBuffer();
@@ -93,7 +126,7 @@ export function createTicketPanel(s, hooks) {
             tui.requestRender();
         }
     };
-    const open = (ticket) => {
+    const open = async (ticket) => {
         if (session !== undefined)
             closeSession(true);
         if (ticket.kind !== 'page') {
@@ -105,24 +138,44 @@ export function createTicketPanel(s, hooks) {
             hooks.setNotice('Ticket is being edited by another inbox');
             return;
         }
-        let loaded;
+        let view;
+        let revision;
         try {
-            loaded = readPageTicket(ticket.dir);
+            const page = await cliClient().getHumanInboxPage(ticket.inboxTicketId);
+            // The claim is a presenter lock, not settlement authority, so a request
+            // that settled between the row being listed and this read would still
+            // claim. This projection already carries the state that decides it.
+            if (page.state === 'resolved' || page.state === 'canceled') {
+                releaseClaim(ticket.dir, claim.token);
+                hooks.setNotice(settledStatusOf(page));
+                return;
+            }
+            view = pageViewFromDTO(page);
+            revision = page.revision;
         }
         catch {
             releaseClaim(ticket.dir, claim.token);
             hooks.openInbox(ticket.dir);
             return;
         }
+        // Awaiting the read gave another open (or a close) the chance to land first;
+        // that session owns the panel, so this one releases its claim and stops.
+        if (session !== undefined) {
+            releaseClaim(ticket.dir, claim.token);
+            return;
+        }
         lastCols = Math.max(20, tui.terminal.columns - 2);
         lastRows = capRows();
         const entry = {
             dir: ticket.dir,
+            id: ticket.id,
+            ticketId: ticket.inboxTicketId,
             title: ticket.title,
             token: claim.token,
+            revision,
             adapter: new PageAdapter({
-                dir: ticket.dir,
-                ticket: loaded,
+                ticketId: ticket.inboxTicketId,
+                page: view,
                 productKinds: resolvePageComponents(),
                 cols: lastCols,
                 rows: lastRows,
@@ -131,38 +184,13 @@ export function createTicketPanel(s, hooks) {
                 onComplete: (responses) => { void complete(entry, responses); },
                 onEditorRequest: () => editPageInput(entry),
             }),
-            watcher: undefined,
+            unwatch: () => { },
             heartbeat: setInterval(() => {
                 if (session === entry)
                     heartbeatClaim(entry.dir, entry.token);
             }, 10_000),
         };
-        try {
-            entry.watcher = watch(ticket.dir, (_event, file) => {
-                if (session !== entry || submitting)
-                    return;
-                if (file === 'page.json') {
-                    reload(entry);
-                    return;
-                }
-                let result;
-                try {
-                    result = readTicketResult(entry.dir);
-                }
-                catch (error) {
-                    closeSession(true);
-                    hooks.setNotice(`ticket result is unreadable: ${error instanceof Error ? error.message : String(error)}`);
-                    return;
-                }
-                if (result !== null) {
-                    closeSession(true);
-                    hooks.setNotice(result.kind === 'canceled' ? 'Ticket was canceled by its requester' : 'Ticket was resolved elsewhere');
-                }
-            });
-        }
-        catch {
-            entry.watcher = undefined;
-        }
+        entry.unwatch = watchInboxActivity(() => { void onActivity(entry); });
         session = entry;
         hooks.syncCursor();
         hooks.refreshStrip();
@@ -210,13 +238,16 @@ export function createTicketPanel(s, hooks) {
         currentDir: () => session?.dir,
     };
 }
-function resolvedElsewhereNotice(dir) {
+/** Why a settlement was refused, in the panel's sentence case. */
+async function resolvedElsewhereNotice(ticketId) {
+    let status;
     try {
-        return readTicketResult(dir)?.kind === 'canceled' ? 'Ticket was already canceled' : 'Ticket was already resolved';
+        status = settledStatusOf(await cliClient().getHumanInboxPage(ticketId));
     }
     catch (error) {
-        return `ticket result is unreadable: ${error instanceof Error ? error.message : String(error)}`;
+        return `Ticket result is unreadable: ${daemonErrorMessage(error)}`;
     }
+    return status.charAt(0).toUpperCase() + status.slice(1);
 }
 /** The SGR opening the theme's `customMessageBg` — the background the crouter
  *  context cards use. pi shares its live theme across module loaders on this

package/dist/clients/attach/overlays/graph.js

@@ -29,14 +29,12 @@ import { execFile } from 'node:child_process';
 import { matchesKey, truncateToWidth } from '@earendil-works/pi-tui';
 import { formatBinding, matchesPiTuiInput, } from '../../../core/keybindings/index.js';
 // Pure leaf imports (NOT the canvas/index barrel or nav-model, both of which
-// reach the canvas-db): fullName from labels.js, activeFaultForDisplay from
-// render-source.js, all render/telemetry helpers from nav-render.js. The
+// reach the canvas-db): fullName from labels.js, faultSummary from
+// status-glyph.js, all render/telemetry helpers from nav-render.js. The
 // tmux-focus set (formerly nav-model's focusedNodeIds → listFocuses db read) is
 // fetched through the crtrd API (cliClient().listFocuses) so this viewer stays
 // off the canvas-db.
 import { fullName } from '../../../core/canvas/labels.js';
-import { activeFaultForDisplay } from '../../../core/canvas/render-source.js';
-import { readFault } from '../../../core/runtime/fault.js';
 import { faultSummary } from '../../../core/canvas/status-glyph.js';
 import { RemoteCanvasSource } from '../../../core/canvas/remote-canvas-source.js';
 import { cliClient } from '../../../commands/api-client.js';
@@ -349,7 +347,7 @@ export class GraphOverlay {
             return wrap(line, false);
         }
         const node = snapshot.nodes.get(r.id) ?? null;
-        const dot = nodeGlyph(node, this.remote);
+        const dot = nodeGlyph(node);
         const rawName = navLabel(node, r.id);
         const name = r.isSelf ? `${BOLD}${rawName}${RESET}` : rawName;
         const kind = `${DIM}${node?.kind ?? ''}${RESET}`;
@@ -362,10 +360,9 @@ export class GraphOverlay {
         const below = node !== null && node.status !== 'active' && (snapshot.activeBelow.get(node.node_id) ?? 0) > 0
             ? ` ${GREEN}⇣${snapshot.activeBelow.get(node.node_id) ?? 0}${RESET}`
             : '';
-        // A remote fault is a local disk read (readFault) keyed on a node id that
-        // may collide with a local one — skip it entirely rather than read-then-
-        // discard.
-        const fault = node !== null && !this.remote ? activeFaultForDisplay(node, readFault(r.id)) : null;
+        // The fault rides on the row its owning daemon projected, so a remote node
+        // shows its own canvas's fault instead of a local-id collision.
+        const fault = node?.fault ?? null;
         const faultSuffix = fault !== null ? ` · ${faultSummary(fault)}` : '';
         const line = `${r.branch}${caret}${dot} ${name} ${kind} ${tokens}${cycle}${child}${below}${askBadge(r.id, asks)}${activityCell(r.id, node, this.remote)}${faultSuffix}`;
         return wrap(line, isAttached(r.id, node, snapshot.focused, this.remote));

package/dist/clients/attach/render/chat-view.d.ts

@@ -298,16 +298,17 @@ export declare class ChatView {
      *  way assistant prose stays. Condensed history is skipped deliberately — old
      *  cycles keep only prose and cycle seams. */
     private maybeAppendPageBlock;
+    private loadPageBlock;
     /** Re-measure the tool calls still in flight. A silent long-running command
      *  emits no tool-execution update, so nothing else would evict its cached
      *  lines and its backgrounding hint would never appear. Driven by the
      *  viewer's existing low-rate chrome poll, and cheap because it touches only
      *  in-flight tools — usually one, never the transcript. */
     refreshInFlightTools(): void;
-    /** Re-read every placed page from disk. Driven by the viewer's ticket-activity
-     *  watcher, so an answer, a cancellation, or a `--replace` revision lands on
-     *  the block already anchored in the transcript. */
-    refreshPageBlocks(): void;
+    /** Re-read every placed page through the daemon. Driven by the viewer's
+     *  ticket-activity watcher, so an answer, a cancellation, or a `--replace`
+     *  revision lands on the block already anchored in the transcript. */
+    refreshPageBlocks(): Promise<void>;
     private makeLoader;
     /** Let a self-updating history child invalidate only its own cached lines. */
     private componentTui;

package/dist/clients/attach/render/chat-view.js

@@ -1454,9 +1454,18 @@ export class ChatView {
         const page = detectInlinePageResult(result);
         if (page === undefined || this.pageBlocks.has(page.pageId))
             return;
-        const block = new PageBlockComponent(page.pageId, page.dir, this.pageOpenHint);
+        const block = new PageBlockComponent(page.pageId, this.pageOpenHint);
         this.pageBlocks.set(page.pageId, block);
         this.append(block);
+        // The block is placed empty and fills itself from the daemon: reading a
+        // request is a round trip, and the transcript must not block on one.
+        void this.loadPageBlock(block);
+    }
+    async loadPageBlock(block) {
+        if (!(await block.refresh()))
+            return;
+        this.historyContainer.markDirty(block);
+        this.tui.requestRender();
     }
     /** Re-measure the tool calls still in flight. A silent long-running command
      *  emits no tool-execution update, so nothing else would evict its cached
@@ -1470,18 +1479,18 @@ export class ChatView {
             this.historyContainer.markDirty(component);
         this.tui.requestRender();
     }
-    /** Re-read every placed page from disk. Driven by the viewer's ticket-activity
-     *  watcher, so an answer, a cancellation, or a `--replace` revision lands on
-     *  the block already anchored in the transcript. */
-    refreshPageBlocks() {
-        let changed = false;
-        for (const block of this.pageBlocks.values()) {
-            if (!block.refresh())
-                continue;
-            changed = true;
-            this.historyContainer.markDirty(block);
-        }
-        if (changed)
+    /** Re-read every placed page through the daemon. Driven by the viewer's
+     *  ticket-activity watcher, so an answer, a cancellation, or a `--replace`
+     *  revision lands on the block already anchored in the transcript. */
+    async refreshPageBlocks() {
+        const blocks = [...this.pageBlocks.values()];
+        const changed = await Promise.all(blocks.map(async (block) => {
+            const moved = await block.refresh();
+            if (moved)
+                this.historyContainer.markDirty(block);
+            return moved;
+        }));
+        if (changed.some(Boolean))
             this.tui.requestRender();
     }
     makeLoader(message) {

package/dist/clients/attach/render/page-block.d.ts

@@ -1,7 +1,6 @@
 import type { Component } from '@earendil-works/pi-tui';
 export interface InlinePageRef {
     pageId: string;
-    dir: string;
 }
 /**
  * The inline page a `human send` tool result announces, or undefined for every
@@ -12,22 +11,27 @@ export interface InlinePageRef {
 export declare function detectInlinePageResult(result: unknown): InlinePageRef | undefined;
 export declare class PageBlockComponent implements Component {
     readonly pageId: string;
-    private readonly dir;
     private readonly openHint;
     private expanded;
     private generation;
+    /** `revision|state` from the last successful read. A replacement selects a
+     *  new revision and a settlement moves the state, so nothing here depends on
+     *  a file timestamp or on the directory the page was first projected into. */
     private stamp;
     private snapshot;
+    /** `loading` until the first read returns; a failed read is never presented
+     *  as the previous content still being current. */
+    private status;
     private cache;
-    constructor(pageId: string, dir: string, openHint: () => string);
-    /** Re-read the ticket when its request or its result changed on disk. */
-    refresh(): boolean;
+    constructor(pageId: string, openHint: () => string);
+    /** Re-read the request. Resolves true when the rendered content changed, so
+     *  the caller knows whether to mark the transcript dirty. */
+    refresh(): Promise<boolean>;
     /** Ctrl+O global expansion (ChatView.isExpandable duck-type). */
     setExpanded(expanded: boolean): void;
     render(width: number): string[];
     invalidate(): void;
-    private diskStamp;
-    private reload;
+    private settle;
     private compose;
     private footerLine;
 }

package/dist/clients/attach/render/page-block.js

@@ -7,17 +7,18 @@
 // queue entry at all and would otherwise be invisible here), while this block is
 // what the person actually reads.
 //
-// The block renders from the ticket directory on disk, never from the tool
-// result text, so `--replace` revisions and the answer that settles a page both
-// land on the already-placed block when `refresh()` is driven by the viewer's
-// inbox-activity watcher.
-import { readFileSync, statSync } from 'node:fs';
+// The block is identified by the request id the tool result carries, and reads
+// the request through the daemon. The directory in that tool result is a
+// historical record of where the page was projected when it was sent: a
+// `--replace` revision selects a new directory, and a page migrated from the
+// legacy layout never matched the new one at all. So identity is the request id
+// and nothing else, and the page content is whatever revision the daemon
+// currently selects for it.
 import { pageAwaitsResponse } from '../../../core/human/page-schema.js';
 import { projectPageDisplayMarkdown } from '../../../core/human/page-markdown.js';
 import { projectHtmlDocumentMarkdown } from '../../../core/human/page-html-markdown.js';
-import { parsePage } from '../../../core/human/page.js';
-import { pageManifestPath, pagePath, responsePath } from '../../../core/human/convention.js';
-import { pageTicketState, readTicketResult } from '../../../core/human/tickets.js';
+import { cliClient } from '../../../commands/api-client.js';
+import { answerDigestOf } from '../../inbox/dto-adapt.js';
 import { pageBodyLines } from '../../inbox/tui/page-body.js';
 import { BOLD, CYAN, DIM, GREEN, RESET, YELLOW, sanitize, singleLine, truncate, wrap } from '../../inbox/tui/ansi.js';
 /** Rows of page body shown while the block is folded; Ctrl+O expands it. */
@@ -45,42 +46,63 @@ export function detectInlinePageResult(result) {
         return undefined;
     const fields = payload;
     const pageId = fields['page_id'];
-    const dir = fields['dir'];
-    if (typeof pageId !== 'string' || typeof dir !== 'string')
+    if (typeof pageId !== 'string')
         return undefined;
     if (fields['placement'] !== 'inline')
         return undefined;
-    return { pageId, dir };
+    return { pageId };
 }
-function mtimeOf(path) {
-    try {
-        return String(statSync(path).mtimeMs);
-    }
-    catch {
-        return '-';
-    }
+function projectDisplay(page) {
+    return page.document_media_type === 'text/html'
+        ? projectHtmlDocumentMarkdown(page.source_document)
+        : projectPageDisplayMarkdown(page.source_document, page.page);
 }
 export class PageBlockComponent {
     pageId;
-    dir;
     openHint;
     expanded = false;
     generation = 0;
-    stamp = '';
+    /** `revision|state` from the last successful read. A replacement selects a
+     *  new revision and a settlement moves the state, so nothing here depends on
+     *  a file timestamp or on the directory the page was first projected into. */
+    stamp;
     snapshot;
+    /** `loading` until the first read returns; a failed read is never presented
+     *  as the previous content still being current. */
+    status = 'loading';
     cache;
-    constructor(pageId, dir, openHint) {
+    constructor(pageId, openHint) {
         this.pageId = pageId;
-        this.dir = dir;
         this.openHint = openHint;
-        this.reload();
     }
-    /** Re-read the ticket when its request or its result changed on disk. */
-    refresh() {
-        if (this.diskStamp() === this.stamp)
+    /** Re-read the request. Resolves true when the rendered content changed, so
+     *  the caller knows whether to mark the transcript dirty. */
+    async refresh() {
+        let page;
+        try {
+            page = (await cliClient().getHumanRequest(this.pageId)).page;
+        }
+        catch {
+            page = undefined;
+        }
+        if (page === undefined)
+            return this.settle('unavailable', undefined, undefined);
+        const stamp = `${page.revision}|${page.state}`;
+        if (this.status === 'ready' && stamp === this.stamp)
             return false;
-        this.reload();
-        return true;
+        let snapshot;
+        try {
+            snapshot = {
+                manifest: page.page,
+                displayMarkdown: projectDisplay(page),
+                state: page.state,
+                ...(page.state === 'resolved' ? withDigest(answerDigestOf(page)) : {}),
+            };
+        }
+        catch {
+            return this.settle('unavailable', undefined, stamp);
+        }
+        return this.settle('ready', snapshot, stamp);
     }
     /** Ctrl+O global expansion (ChatView.isExpandable duck-type). */
     setExpanded(expanded) {
@@ -102,38 +124,22 @@ export class PageBlockComponent {
     invalidate() {
         this.cache = undefined;
     }
-    diskStamp() {
-        return `${mtimeOf(pageManifestPath(this.dir))}|${mtimeOf(pagePath(this.dir, 'jsx'))}|${mtimeOf(pagePath(this.dir, 'html'))}|${mtimeOf(responsePath(this.dir))}`;
-    }
-    reload() {
-        this.stamp = this.diskStamp();
+    settle(status, snapshot, stamp) {
+        if (status === this.status && status === 'unavailable')
+            return false;
+        this.status = status;
+        this.snapshot = snapshot;
+        this.stamp = stamp;
         this.generation++;
         this.cache = undefined;
-        try {
-            const manifest = parsePage(this.dir);
-            const displayMarkdown = manifest.dialect === 'jsx'
-                ? projectPageDisplayMarkdown(readFileSync(pagePath(this.dir, 'jsx'), 'utf8'), manifest)
-                : projectHtmlDocumentMarkdown(readFileSync(pagePath(this.dir, 'html'), 'utf8'));
-            const state = pageTicketState(this.dir);
-            const digest = state === 'resolved' ? readTicketResult(this.dir) : null;
-            this.snapshot = {
-                manifest,
-                displayMarkdown,
-                state,
-                ...(digest?.kind === 'page' ? { answerDigest: digest.summary.replace(/\s+/g, ' ').trim() } : {}),
-            };
-        }
-        catch {
-            // A removed or half-written ticket keeps whatever was last read; a block
-            // that never read one renders its unavailable line instead.
-            if (this.snapshot === undefined)
-                this.snapshot = undefined;
-        }
+        return true;
     }
     compose(width) {
         const snapshot = this.snapshot;
-        if (snapshot === undefined)
-            return ['', `  ${DIM}[page] no longer available${RESET}`, ''];
+        if (snapshot === undefined) {
+            const line = this.status === 'loading' ? '[page] loading…' : '[page] no longer available';
+            return ['', `  ${DIM}${line}${RESET}`, ''];
+        }
         const maxW = Math.min(Math.max(20, width - 4), 100);
         const out = ['', `  ${BOLD}${CYAN}${truncate(sanitize(singleLine(snapshot.manifest.title)), maxW)}${RESET}`];
         if (snapshot.manifest.subtitle) {
@@ -172,3 +178,6 @@ export class PageBlockComponent {
         }
     }
 }
+function withDigest(digest) {
+    return digest === undefined ? {} : { answerDigest: digest };
+}