@north-light/api 0.3.580 → 0.3.588

package/dist/clients/attach/chrome/canvas-panels.d.ts

@@ -0,0 +1,43 @@
+import type { CanvasSource } from '../../../core/canvas/source.js';
+import type { CronDTO } from '../../../api/dto/crons.js';
+import type { ReviewDTO } from '../../../api/dto/reviews.js';
+import type { AttachPalette } from '../config.js';
+import { type BashJobStatus } from './bash-jobs.js';
+export type CanvasPanelItem = {
+    key: string;
+    kind: 'node';
+    nodeId: string;
+    line: string;
+} | {
+    key: string;
+    kind: 'review';
+    companionNodeId: string;
+    line: string;
+} | {
+    key: 'bash';
+    kind: 'bash';
+    line: string;
+} | {
+    key: 'crons';
+    kind: 'crons';
+    line: string;
+} | {
+    key: string;
+    kind: 'object-wait';
+    objectId: string;
+    line: string;
+};
+export interface CanvasPanelLines {
+    /** Below-editor relationship and wait rows, in render order. */
+    reports: string[];
+    /** Node ids backing relationship rows. Retained for graph/remote callers. */
+    reportIds: string[];
+    /** Actionable cockpit rows. Enter swaps nodes or opens the matching wait detail surface. */
+    items: CanvasPanelItem[];
+}
+/** Build the BASE panel line stacks for `nodeId`. `asks` is the per-node
+ *  pending human-ticket count map the caller polls (page/review); pass
+ *  `{}` to omit the ⚑ badges. `crons` are this node's armed schedules.
+ *  `palette`
+ *  drives the headers + dim cells; omit it and the panels render uncolored. */
+export declare function buildCanvasPanelLines(nodeId: string, asks: Record<string, number>, palette: AttachPalette | undefined, source: CanvasSource, crons?: readonly CronDTO[], jobs?: readonly BashJobStatus[], reviews?: readonly ReviewDTO[]): Promise<CanvasPanelLines>;

package/dist/clients/attach/chrome/canvas-panels.js

@@ -0,0 +1,227 @@
+// chrome/canvas-panels.ts — the subscribed-node panel for `crtr surface attach` (Unit Q).
+//
+// Reads through the CanvasSource seam so the viewer chrome and graph overlay
+// share the same canvas read authority. Produces the line stacks the viewer paints
+// into Containers around the editor:
+//   reports   → BELOW the editor: this node's manager (↑), its live
+//               (↓, active|idle) reports, and trailing wait rows for human
+//               tickets, open document reviews, live background bash jobs, and
+//               armed crons. Backs inline scroll+open/swap.
+//
+// Pure: given a node id + the per-node ticket-count map it returns ANSI strings; the
+// caller owns the Containers and the refresh trigger.
+import { navLabel, nodeGlyph, truncate, tokensCell, cycleBadge, askBadge, activityCell, fillWidth, RESET, DIM, GREEN, } from '../../../core/canvas/nav-render.js';
+/** Columns the bash row spends on everything except the command itself:
+ *  ` ⚙ ` + `bash job · ` + elapsed + ` · ` + ` · ↵ details`. */
+const BASH_ROW_CHROME = 34;
+/** Columns the object-wait row spends on everything except the object name:
+ *  ` ◇ ` + kind + ` · ` + elapsed + ` · ` + ` · ↵ details`. */
+const OBJECT_WAIT_ROW_CHROME = 30;
+/** Columns the review row spends on everything except the file name:
+ *  ` ✎ ` + the longest state prefix + ` · ` + ` · ↵ companion`. */
+const REVIEW_ROW_CHROME = 40;
+import { RemoteCanvasSource } from '../../../core/canvas/remote-canvas-source.js';
+import { cronWaitSummary } from './cron-wait.js';
+import { bashJobsWaitSummary } from './bash-jobs.js';
+import { reviewWaitSummary } from './review-wait.js';
+import { objectWaitSummary } from './object-wait.js';
+/** Column widths for the aligned panel rows (visible columns). name is sized to
+ *  the widest label across BOTH panels (capped); kind is wide enough for the
+ *  longest persona kind (`orchestrator` = 12) so real kinds never truncate;
+ *  tokens is fixed. Both panels share one grid. */
+const KIND_W = 12;
+const TOK_W = 6;
+const NAME_CAP = 22;
+/** Pad to `w`, or ellipsize with `…` when longer (plain text — callers pass
+ *  un-styled labels). */
+function nameCell(s, w) {
+    return s.length > w ? `${s.slice(0, w - 1)}…` : s + ' '.repeat(w - s.length);
+}
+function padStartVisible(s, w) {
+    return s.length >= w ? s.slice(0, w) : ' '.repeat(w - s.length) + s;
+}
+/** Build the BASE panel line stacks for `nodeId`. `asks` is the per-node
+ *  pending human-ticket count map the caller polls (page/review); pass
+ *  `{}` to omit the ⚑ badges. `crons` are this node's armed schedules.
+ *  `palette`
+ *  drives the headers + dim cells; omit it and the panels render uncolored. */
+export async function buildCanvasPanelLines(nodeId, asks, palette, source, crons = [], jobs = [], reviews = []) {
+    // A remote source provides graph structure and node metadata. Token/activity
+    // display retains the safe remote defaults, while fault state rides the row.
+    const remote = source instanceof RemoteCanvasSource;
+    const roster = await source.panelRoster?.();
+    const rosterNodes = roster === undefined ? null : new Map(roster.nodes.map((node) => [node.node_id, node]));
+    const rosterChildren = new Map();
+    const rosterManagers = new Map();
+    if (roster !== undefined)
+        for (const edge of roster.edges) {
+            const children = rosterChildren.get(edge.from_id) ?? [];
+            children.push(edge.to_id);
+            rosterChildren.set(edge.from_id, children);
+            if (!rosterManagers.has(edge.to_id))
+                rosterManagers.set(edge.to_id, edge.from_id);
+        }
+    const nodes = new Map();
+    const children = new Map();
+    const managersOf = new Map();
+    const node = (id) => {
+        const hit = nodes.get(id);
+        if (hit !== undefined)
+            return hit;
+        const p = rosterNodes === null
+            ? source.getNode(id).catch(() => null)
+            : Promise.resolve((rosterNodes.get(id) ?? null));
+        nodes.set(id, p);
+        return p;
+    };
+    const detail = (id) => source.getNode(id).catch(() => null);
+    const convoChildIds = (id) => {
+        const hit = children.get(id);
+        if (hit !== undefined)
+            return hit;
+        const p = (async () => {
+            const ids = rosterNodes === null
+                ? (await source.subscriptionsOf(id).catch(() => [])).map((ref) => ref.node_id)
+                : rosterChildren.get(id) ?? [];
+            const out = [];
+            for (const childId of ids) {
+                if ((await node(childId))?.kind !== 'human')
+                    out.push(childId);
+            }
+            return out;
+        })();
+        children.set(id, p);
+        return p;
+    };
+    const managerOf = (id) => {
+        const hit = managersOf.get(id);
+        if (hit !== undefined)
+            return hit;
+        const p = rosterNodes === null
+            ? source.subscribersOf(id).then((refs) => refs[0]?.node_id).catch(() => undefined)
+            : Promise.resolve(rosterManagers.get(id));
+        managersOf.set(id, p);
+        return p;
+    };
+    const liveReports = async (id) => {
+        const out = [];
+        for (const cid of await convoChildIds(id)) {
+            const st = (await node(cid))?.status;
+            if (st === 'active' || st === 'idle')
+                out.push(cid);
+        }
+        return out;
+    };
+    const climbRoot = async (self) => {
+        let cur = self;
+        const seen = new Set([cur]);
+        for (;;) {
+            const mgr = await managerOf(cur);
+            if (mgr === undefined || seen.has(mgr))
+                break;
+            seen.add(mgr);
+            cur = mgr;
+        }
+        return cur;
+    };
+    const activeBelow = new Map();
+    const computeActivity = async (root) => {
+        const seen = new Set();
+        const visit = async (id) => {
+            const selfActive = (await node(id))?.status === 'active';
+            if (seen.has(id))
+                return selfActive ? 1 : 0;
+            seen.add(id);
+            let below = 0;
+            for (const c of await convoChildIds(id))
+                below += await visit(c);
+            activeBelow.set(id, below);
+            return below + (selfActive ? 1 : 0);
+        };
+        await visit(root);
+    };
+    const childBadgeFor = async (n) => {
+        if (n === null || n.mode !== 'orchestrator')
+            return '';
+        const m = (await convoChildIds(n.node_id)).length;
+        return m > 0 ? ` ${DIM}⤳${m}${RESET}` : '';
+    };
+    const liveBelowBadgeFor = (n) => {
+        if (n === null || n.status === 'active')
+            return '';
+        const count = activeBelow.get(n.node_id) ?? 0;
+        return count > 0 ? ` ${GREEN}⇣${count}${RESET}` : '';
+    };
+    const muted = palette?.muted ?? ((s) => s);
+    const faint = palette?.faint ?? ((s) => s);
+    await computeActivity(await climbRoot(nodeId));
+    const mgr = await managerOf(nodeId);
+    const live = await liveReports(nodeId);
+    // The directional rows share column widths in their single roster.
+    const gridIds = [...(mgr !== undefined ? [mgr] : []), ...live];
+    const gridNodes = await Promise.all(gridIds.map(async (id) => (await detail(id)) ?? (await node(id))));
+    const nameW = gridIds.length > 0
+        ? Math.min(NAME_CAP, Math.max(...gridIds.map((id, i) => navLabel(gridNodes[i] ?? null, id).length)))
+        : NAME_CAP;
+    const row = async (id, direction) => {
+        const n = gridNodes[gridIds.indexOf(id)] ?? null;
+        const name = nameCell(navLabel(n, id), nameW);
+        const kind = faint(nameCell(n?.kind ?? '', KIND_W));
+        const tokens = muted(padStartVisible(tokensCell(n, remote), TOK_W));
+        const badges = `${cycleBadge(n)}${await childBadgeFor(n)}${liveBelowBadgeFor(n)}${askBadge(id, asks)}${activityCell(n, remote)}`;
+        const line = ` ${direction} ${nodeGlyph(n)} ${name}  ${kind} ${tokens}${badges}`;
+        return truncate(line);
+    };
+    const reportIds = [...(mgr !== undefined ? [mgr] : []), ...live];
+    const items = [];
+    if (mgr !== undefined)
+        items.push({ key: `node:${mgr}`, kind: 'node', nodeId: mgr, line: await row(mgr, '↑') });
+    for (const id of live)
+        items.push({ key: `node:${id}`, kind: 'node', nodeId: id, line: await row(id, '↓') });
+    // Review rows: an open review is either waiting on the person or already
+    // submitted and finishing behind its companion, and either way this node
+    // resumes only when the review completes. (Pending human tickets render in
+    // the top-of-pane inbox strip, not below the editor.)
+    for (const review of reviews) {
+        const pen = palette ? palette.info('✎') : '✎';
+        const summary = reviewWaitSummary(review, Math.max(8, fillWidth() - REVIEW_ROW_CHROME));
+        items.push({
+            key: `review:${review.review_id}`,
+            kind: 'review',
+            companionNodeId: review.companion_node_id,
+            line: ` ${pen} ${muted(`${summary} · ↵ companion`)}${RESET}`,
+        });
+    }
+    // Bash wait row: attention (human) -> active-now (running background work) ->
+    // scheduled-future (armed crons). The leading glyph distinguishes the row type.
+    // `x stop` is advertised on the row because it is the roster's only
+    // destructive verb and nothing else would teach it. The command cell gets
+    // whatever the row's fixed decoration leaves, so the hints always survive.
+    const stopHint = jobs.length === 1 ? ' · x stop' : '';
+    const bashSummary = bashJobsWaitSummary(jobs, Date.now(), fillWidth() - (BASH_ROW_CHROME + stopHint.length));
+    if (bashSummary !== undefined) {
+        const gear = palette ? palette.info('⚙') : '⚙';
+        items.push({ key: 'bash', kind: 'bash', line: ` ${gear} ${muted(`${bashSummary} · ↵ details${stopHint}`)}${RESET}` });
+    }
+    const cronSummary = cronWaitSummary(crons);
+    if (cronSummary !== undefined) {
+        const clock = palette ? palette.info('◷') : '◷';
+        items.push({ key: 'crons', kind: 'crons', line: ` ${clock} ${muted(`${cronSummary} · ↵ details`)}${RESET}` });
+    }
+    // Object wait rows: one per watched canvas object whose kind declares an ending event (a workflow
+    // run until `completed`), so the person sees what the node is waiting on besides its children. The
+    // daemon settles the wait when that event lands, so the row disappears on its own.
+    for (const wait of roster?.object_waits ?? []) {
+        if (wait.node_id !== nodeId)
+            continue;
+        const eye = palette ? palette.info('◇') : '◇';
+        const summary = objectWaitSummary(wait, Date.now(), Math.max(8, fillWidth() - OBJECT_WAIT_ROW_CHROME));
+        items.push({
+            key: `object:${wait.object_id}`,
+            kind: 'object-wait',
+            objectId: wait.object_id,
+            line: ` ${eye} ${muted(`${summary} · ↵ details`)}${RESET}`,
+        });
+    }
+    return { reports: items.map((item) => item.line), reportIds, items };
+}

package/dist/clients/attach/chrome/completion-bell.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Ring the completion bell once, if enabled. Picks the best available signal
+ * for the host:
+ *   macOS  → afplay a system sound (guaranteed audible, ignores terminal bell prefs)
+ *   Linux  → paplay/aplay if CRTR_BELL_SOUND is set, else the terminal BEL
+ *   other  → terminal BEL (0x07) — the terminal's own bell / tmux bell indicator
+ *
+ * Gated on the `completion_bell` config setting (default true).
+ */
+export declare function ringCompletionBell(): void;

package/dist/clients/attach/chrome/completion-bell.js

@@ -0,0 +1,89 @@
+// chrome/completion-bell.ts — the "your agent finished" dopamine ding.
+//
+// A port of the Claude Code Stop-hook bell into the crtr attach viewer. Rings
+// once when the node you are watching stops its turn and hands control back
+// (chat-view's `agent_end`). Scoped to the viewer on purpose: the bell is for
+// the human at the terminal, so it fires ONLY inside a live viewer pane. A
+// headless/background node with no viewer attached never constructs a ChatView
+// and is therefore always silent — there is no code path that rings for it.
+//
+// Best-effort and non-blocking: spawns a detached sound process (unref'd) and
+// swallows every error. A missing player just means silence — never a crash and
+// never a blocked render.
+//
+// Controlled by the `completion_bell` config setting (default true):
+//   crtr sys config set completion_bell --value false   # mute
+//   crtr sys config set completion_bell --value true    # unmute
+// Override the macOS sound with the CRTR_BELL_SOUND env var (an absolute path to
+// any afplay-able file, or a bare name from /System/Library/Sounds, e.g. `Ping`).
+import { spawn } from 'node:child_process';
+import { readConfig } from '../../../core/config.js';
+/** Default macOS system sound — a short, pleasant "done" chime. */
+const DEFAULT_MAC_SOUND = '/System/Library/Sounds/Glass.aiff';
+function macSoundPath() {
+    const override = process.env['CRTR_BELL_SOUND'];
+    if (override === undefined || override.trim() === '')
+        return DEFAULT_MAC_SOUND;
+    const v = override.trim();
+    // Absolute path → use as-is; bare name → resolve against the system sounds dir.
+    if (v.startsWith('/'))
+        return v;
+    return `/System/Library/Sounds/${v.replace(/\.aiff$/i, '')}.aiff`;
+}
+/** True when the completion bell is enabled. Read live from the user-scope
+ *  config each time (a single small JSON read on an infrequent turn-completion
+ *  boundary) so `sys config set completion_bell` takes effect without
+ *  restarting the viewer. Any read failure defaults to the built-in `true`. */
+function bellEnabled() {
+    try {
+        return readConfig('user').completion_bell;
+    }
+    catch {
+        return true;
+    }
+}
+/** Fire a detached, best-effort audio process. Never throws, never blocks. */
+function playDetached(command, args) {
+    try {
+        const child = spawn(command, args, { stdio: 'ignore', detached: true });
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Ring the completion bell once, if enabled. Picks the best available signal
+ * for the host:
+ *   macOS  → afplay a system sound (guaranteed audible, ignores terminal bell prefs)
+ *   Linux  → paplay/aplay if CRTR_BELL_SOUND is set, else the terminal BEL
+ *   other  → terminal BEL (0x07) — the terminal's own bell / tmux bell indicator
+ *
+ * Gated on the `completion_bell` config setting (default true).
+ */
+export function ringCompletionBell() {
+    if (!bellEnabled())
+        return;
+    try {
+        if (process.platform === 'darwin') {
+            if (playDetached('afplay', [macSoundPath()]))
+                return;
+        }
+        else if (process.platform === 'linux') {
+            const override = process.env['CRTR_BELL_SOUND'];
+            if (override !== undefined && override.trim() !== '') {
+                if (playDetached('paplay', [override.trim()]) || playDetached('aplay', [override.trim()]))
+                    return;
+            }
+        }
+        // Fallback everywhere: the terminal BEL. Non-printing control char — the
+        // terminal (and tmux) interpret it without moving the cursor or disturbing
+        // the TUI render.
+        process.stdout.write('\x07');
+    }
+    catch {
+        /* the bell is pure delight; never let it break a turn */
+    }
+}

package/dist/clients/attach/chrome/cron-wait.d.ts

@@ -0,0 +1,3 @@
+import type { CronDTO } from '../../../api/dto/crons.js';
+/** Compact cockpit row: state first; the native Inspector owns details. */
+export declare function cronWaitSummary(crons: readonly CronDTO[], nowMs?: number): string | undefined;

package/dist/clients/attach/chrome/cron-wait.js

@@ -0,0 +1,34 @@
+function relativeTime(iso, nowMs) {
+    const diff = Date.parse(iso) - nowMs;
+    if (diff <= 0)
+        return 'due now';
+    const minutes = Math.ceil(diff / 60_000);
+    if (minutes < 60)
+        return `in ${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    const remMinutes = minutes % 60;
+    if (hours < 24)
+        return `in ${hours}h${remMinutes > 0 ? ` ${remMinutes}m` : ''}`;
+    const days = Math.floor(hours / 24);
+    const remHours = hours % 24;
+    return `in ${days}d${remHours > 0 ? ` ${remHours}h` : ''}`;
+}
+function nextCron(crons) {
+    return [...crons].sort((a, b) => Date.parse(a.fire_at) - Date.parse(b.fire_at))[0];
+}
+/** Compact cockpit row: state first; the native Inspector owns details. */
+export function cronWaitSummary(crons, nowMs = Date.now()) {
+    if (crons.length === 0)
+        return undefined;
+    if (crons.length > 1) {
+        const next = nextCron(crons);
+        return `${crons.length} crons armed${next ? ` · next ${relativeTime(next.fire_at, nowMs)}` : ''}`;
+    }
+    const cron = crons[0];
+    const timing = relativeTime(cron.fire_at, nowMs);
+    if (cron.cancel_on_wake)
+        return `deadline · ${timing}`;
+    if (cron.recur !== null)
+        return `recurring cron · next ${timing}`;
+    return `scheduled cron · ${timing}`;
+}

package/dist/clients/attach/chrome/git-info.d.ts

@@ -0,0 +1,20 @@
+export interface GitInfo {
+    /** Last path segment of the cwd (always present). */
+    dir: string;
+    /** Current branch (or short SHA when detached); undefined outside a repo. */
+    branch?: string;
+    /** Working tree has uncommitted changes (staged, unstaged, or untracked). */
+    dirty: boolean;
+    /** Commits ahead of upstream. */
+    ahead: number;
+    /** Commits behind upstream. */
+    behind: number;
+}
+/** Parse `git status --porcelain=v1 --branch` into {@link GitInfo} flags. The
+ *  first `## ` line carries branch + `[ahead N, behind M]`; any further line is
+ *  a changed/untracked path → dirty. Exported pure for unit tests. */
+export declare function parseGitStatus(dir: string, stdout: string): GitInfo;
+/** Fetch git context for `cwd` without blocking. On any error (not a repo, git
+ *  missing, timeout) the callback still fires with dir-only info so the border
+ *  shows the folder name regardless. */
+export declare function fetchGitInfo(cwd: string, cb: (info: GitInfo) => void): void;

package/dist/clients/attach/chrome/git-info.js

@@ -0,0 +1,44 @@
+// chrome/git-info.ts — async, non-blocking git context for the attach editor border:
+// the working dir's last path segment, current branch, and a couple of status
+// symbols (dirty / ahead / behind). Shells out via execFile (NEVER sync — the
+// viewer must never block its input pump on a subprocess) and reports a plain
+// struct the caller styles into the editor's top border.
+import { execFile } from 'node:child_process';
+import { basename } from 'node:path';
+/** Parse `git status --porcelain=v1 --branch` into {@link GitInfo} flags. The
+ *  first `## ` line carries branch + `[ahead N, behind M]`; any further line is
+ *  a changed/untracked path → dirty. Exported pure for unit tests. */
+export function parseGitStatus(dir, stdout) {
+    const lines = stdout.split('\n').filter((l) => l.length > 0);
+    const info = { dir, dirty: false, ahead: 0, behind: 0 };
+    for (const line of lines) {
+        if (line.startsWith('## ')) {
+            // `## main...origin/main [ahead 1, behind 2]`  or `## HEAD (no branch)`
+            const head = line.slice(3);
+            if (!head.startsWith('HEAD (no branch)')) {
+                const branch = head.split(/\.\.\.| /, 1)[0];
+                if (branch)
+                    info.branch = branch;
+            }
+            info.ahead = Number(/ahead (\d+)/.exec(head)?.[1] ?? 0);
+            info.behind = Number(/behind (\d+)/.exec(head)?.[1] ?? 0);
+        }
+        else {
+            info.dirty = true;
+        }
+    }
+    return info;
+}
+/** Fetch git context for `cwd` without blocking. On any error (not a repo, git
+ *  missing, timeout) the callback still fires with dir-only info so the border
+ *  shows the folder name regardless. */
+export function fetchGitInfo(cwd, cb) {
+    const dir = basename(cwd) || cwd;
+    execFile('git', ['-C', cwd, 'status', '--porcelain=v1', '--branch'], { timeout: 2_000, maxBuffer: 4 * 1024 * 1024 }, (err, stdout) => {
+        if (err) {
+            cb({ dir, dirty: false, ahead: 0, behind: 0 });
+            return;
+        }
+        cb(parseGitStatus(dir, stdout));
+    });
+}

package/dist/clients/attach/chrome/header.d.ts

@@ -0,0 +1,10 @@
+import { Container } from '@earendil-works/pi-tui';
+import type { SessionState } from '../../../core/session-model/session-state.js';
+import type { AttachSession } from '../session/context.js';
+export interface RecapHeader {
+    /** The component ViewerFrame renders as its header region. */
+    readonly component: Container;
+    /** Repaint from the live `crtr-recap` widget state. Empty widget → 0 rows. */
+    render(): void;
+}
+export declare function createRecapHeader(ctx: Pick<AttachSession, 'tui' | 'pal'>, state: () => SessionState): RecapHeader;

package/dist/clients/attach/chrome/header.js

@@ -0,0 +1,30 @@
+// chrome/header.ts — the pinned recap header above the transcript.
+//
+// Only the GOAL line of the broker's retained `crtr-recap` widget is painted
+// here, label stripped, so it stays visible while the transcript scrolls. The
+// state line rides the widget's own cockpit slot (chrome/widgets.ts).
+import { Container, Text, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { DynamicBorder } from '@earendil-works/pi-coding-agent';
+import { splitRecapLines } from './recap.js';
+export function createRecapHeader(ctx, state) {
+    const { tui, pal } = ctx;
+    const component = new Container();
+    const render = () => {
+        component.clear();
+        const widget = state().display.widgets['crtr-recap'];
+        const goal = widget === undefined ? [] : splitRecapLines(widget.lines).goal;
+        if (goal.length > 0) {
+            const span = Math.max(1, (process.stdout.columns ?? 80) - 2);
+            for (const line of goal) {
+                // Styled BEFORE wrapping (wrapTextWithAnsi carries SGR state across
+                // wraps), so a wrapped continuation stays faint.
+                for (const wrapped of wrapTextWithAnsi(pal.faint(line), span)) {
+                    component.addChild(new Text(wrapped, 1, 0));
+                }
+            }
+            component.addChild(new DynamicBorder(pal.border));
+        }
+        tui.requestRender();
+    };
+    return { component, render };
+}

package/dist/clients/attach/chrome/inbox-strip.d.ts

@@ -0,0 +1,36 @@
+import { Container } from '@earendil-works/pi-tui';
+import { type InboxRow } from '../../inbox/dto-adapt.js';
+import type { AttachSession } from '../session/context.js';
+export type StripSession = Pick<AttachSession, 'nodeId' | 'remote' | 'canvasSource' | 'tui' | 'pal'>;
+export interface InboxStripHooks {
+    /** Recompute the editor's hollow-cursor state (session/pane-focus.ts). */
+    syncCursor: () => void;
+    /** Drop the below-editor roster's highlight — the two lists are mutually exclusive. */
+    exitRoster: () => void;
+    /** Open this ticket — the inline ticket panel, or its fallbacks. */
+    openTicket: (ticket: InboxRow) => void;
+    /** True while the ticket panel is open — it IS the expanded notification,
+     *  so the strip's own rows hide rather than duplicate the flag. */
+    suppressed: () => boolean;
+    setNotice: (msg: string) => void;
+    /** A failed rescan. The strip keeps the rows it already shows; the viewer's
+     *  chrome refresh owns how the failure is presented and retried. */
+    onRefreshFailure: (cause: unknown) => void;
+}
+export interface InboxStrip {
+    /** Mounted into the frame's single header container, below the recap. */
+    readonly component: Container;
+    /** Rescan the subtree's pending tickets and repaint. Never rejects: most
+     *  callers fire it from inbox activity with nobody awaiting it, so a daemon
+     *  failure goes to `onRefreshFailure` and the last rows stay on screen. */
+    refresh(): Promise<void>;
+    /** Strip key routing, called BEFORE the editor sees the key. */
+    handleKey(data: string): boolean;
+    /** The dedicated binding: enter the strip, or leave it when already held. */
+    toggle(): void;
+    /** True while the strip holds the highlight. */
+    active(): boolean;
+    /** The cached pending tickets, for the inbox surface's scan merge. */
+    pendingTickets(): InboxRow[];
+}
+export declare function createInboxStrip(s: StripSession, hooks: InboxStripHooks): InboxStrip;