pmx-canvas 0.4.7 → 0.5.0

package/dist/types/client/canvas/SessionReceipt.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Session receipt (rail-chrome-v2 phase 5, design item 2): a dismissible card
+ * at the canvas region's top-right after a session ends — what the session did
+ * (items / done / vetoed), the pre-session snapshot (taken at attach, so View
+ * diff shows the session's changes and a restore undoes them), and History
+ * (the snapshots panel). Client-side state, cleared on dismiss.
+ */
+export interface DiffSummary {
+    added: number;
+    removed: number;
+    modified: number;
+}
+/** The wire shape is SnapshotDiffResult (addedNodes/removedNodes/modifiedNodes/addedEdges/removedEdges). */
+export declare function summarizeDiff(diff: unknown): DiffSummary | null;
+export declare function SessionReceipt({ onOpenSnapshots }: {
+    onOpenSnapshots: () => void;
+}): import("preact/src").JSX.Element | null;

package/dist/types/client/canvas/TextPrompt.d.ts

@@ -0,0 +1,25 @@
+/**
+ * In-canvas replacement for `window.prompt`, which embedded browser panes
+ * silently no-op (a Shift+F that "does nothing") and no test can drive. One
+ * request at a time; a new ask cancels the previous one.
+ */
+interface TextPromptRequest {
+    title: string;
+    placeholder: string;
+    /** Prefilled (and pre-selected) value — edit flows start from the current text. */
+    initial: string;
+    /** Submitting an empty field resolves '' instead of null — "clear the value" flows. */
+    allowEmpty: boolean;
+    confirm: string;
+    /** Bumped per ask so consecutive requests get a FRESH input element. */
+    seq: number;
+    resolve: (value: string | null) => void;
+}
+export declare const textPromptRequest: import("@preact/signals-core").Signal<TextPromptRequest | null>;
+export declare function askText(title: string, placeholder: string, opts?: {
+    initial?: string;
+    allowEmpty?: boolean;
+    confirm?: string;
+}): Promise<string | null>;
+export declare function TextPrompt(): import("preact/src").JSX.Element | null;
+export {};

package/dist/types/client/canvas/ToolRail.d.ts

@@ -0,0 +1,21 @@
+import type { AnnotationTool } from '../types';
+/** Prompt-driven creates for node kinds that need a source (url / path). */
+export declare function promptedCreate(kind: 'image' | 'file' | 'webpage'): void;
+/**
+ * The persistent 52px left tool rail (rail-chrome-v2 phase 1): brand → tools →
+ * node palette → utilities. Every button shows a hover/focus tooltip with its
+ * shortcut (`RailButton`) — the rail is the shortcut discovery surface.
+ */
+export declare function ToolRail({ minimapVisible, onToggleMinimap, snapshotOpen, onToggleSnapshot, snapshotBtnRef, onOpenPalette, onOpenShortcuts, annotationTool, onSetAnnotationTool, }: {
+    minimapVisible: boolean;
+    onToggleMinimap: () => void;
+    snapshotOpen: boolean;
+    onToggleSnapshot: () => void;
+    snapshotBtnRef: {
+        current: HTMLButtonElement | null;
+    };
+    onOpenPalette: () => void;
+    onOpenShortcuts: () => void;
+    annotationTool: AnnotationTool;
+    onSetAnnotationTool: (tool: AnnotationTool) => void;
+}): import("preact/src").JSX.Element;

package/dist/types/client/canvas/TopBar.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The slim 44px top bar (rail-chrome-v2 phase 1): connection state, board
+ * identity on the left, view controls on the right. `overflow:hidden` +
+ * `min-width:0` discipline throughout — the title ellipsizes, meta collapses
+ * below 1180px, and nothing ever wraps to a second row.
+ */
+export declare function TopBar(): import("preact").JSX.Element;

package/dist/types/client/canvas/canvas-area.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The canvas region's box in screen coordinates. With the rail + top-bar shell
+ * the canvas no longer spans the window, so every "centre of the view" and
+ * "how big is the view" computation must use this region — anchoring zoom at
+ * `window.innerWidth / 2` would drift the board toward the rail on every step,
+ * and reporting the window to the server makes an agent `fit` compute a scale
+ * that hides nodes under the chrome.
+ *
+ * The shell registers its canvas-region element on mount; everything else asks
+ * for the rect. The window fallback keeps unit tests and any chromeless embed
+ * working unchanged.
+ */
+export interface CanvasAreaRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare function registerCanvasArea(el: HTMLElement | null): void;
+export declare function canvasArea(): CanvasAreaRect;
+/** Screen-space centre of the canvas region — the anchor for centred zoom/focus. */
+export declare function canvasAreaCenter(): {
+    x: number;
+    y: number;
+};

package/dist/types/client/canvas/create-in-view.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A human create from the rail, keyboard, palette, or empty state lands
+ * centred in the CURRENT viewport — where the human is looking — instead of
+ * at the server's board-relative auto-placement, which on a busy board can
+ * be far off-screen (the rail's Group landed out of view). Explicit x/y win.
+ */
+export declare function createNodeInView(opts: {
+    type: string;
+    title?: string;
+    content?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+}): Promise<{
+    ok: boolean;
+    id?: string;
+}>;

package/dist/types/client/canvas/import-files.d.ts

@@ -0,0 +1,8 @@
+export declare function nodeTypeFromFilename(name: string): 'image' | 'markdown' | 'file';
+/**
+ * Turn local files into nodes laid out in a grid around a world point — the
+ * one implementation behind the viewport's drop zone and the empty state's
+ * file picker. Images become image nodes (data URI), markdown becomes
+ * markdown, everything else a file node with the text inlined.
+ */
+export declare function importFiles(files: File[], baseWx: number, baseWy: number): Promise<void>;

package/dist/types/client/canvas/kind-colors.d.ts

@@ -0,0 +1,3 @@
+import type { CanvasNodeState } from '../types';
+/** Kind color per node type, as CSS tokens so every theme keeps its palette. */
+export declare const KIND_COLOR: Record<CanvasNodeState['type'], string>;

package/dist/types/client/canvas/use-focus-trap.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Focus trap for modal overlays (rail-chrome-v2 item 18): while `active`, Tab
+ * cycles inside `ref`, the first focusable takes focus on open unless
+ * `initial` names one, and the element focused before the overlay opened gets
+ * focus back on close.
+ */
+export declare function useFocusTrap(ref: {
+    current: HTMLElement | null;
+}, active: boolean, options?: {
+    initial?: {
+        current: HTMLElement | null;
+    };
+    restoreTo?: () => HTMLElement | null;
+}): void;

package/dist/types/client/canvas/use-now.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A ticking "now" for countdowns and relative ages. `intervalMs` 0 stops the
+ * ticker (the value still reads as the mount time) — pass 0 while the surface
+ * that needs it is hidden so an idle page runs no timers.
+ */
+export declare function useNow(intervalMs?: number): number;

package/dist/types/client/icons.d.ts

@@ -5,8 +5,6 @@ interface IconProps {
 }
 /** Expand-arrows — fit all nodes */
 export declare function IconFitAll(p: IconProps): JSX.Element;
-/** Framed crosshair — reset view 1:1 */
-export declare function IconResetView(p: IconProps): JSX.Element;
 /** Magnifier with + */
 export declare function IconZoomIn(p: IconProps): JSX.Element;
 /** Magnifier with - */
@@ -35,13 +33,22 @@ export declare function IconClearTrace(p: IconProps): JSX.Element;
 export declare function IconSearch(p: IconProps): JSX.Element;
 /** Keyboard — shortcuts */
 export declare function IconShortcuts(p: IconProps): JSX.Element;
-/** Half-lit circle — theme toggle (generic). */
-export declare function IconTheme(p: IconProps): JSX.Element;
+/** Speech bubble — steer the agent (command bar composer). */
+export declare function IconSteer(p: IconProps): JSX.Element;
 /** Framed pin — context pinning. */
 export declare function IconPin(p: IconProps): JSX.Element;
 /** Focus Field — PMX Canvas brand mark (concentric rounded squares → lit core). */
 export declare function IconLogo({ size, class: className }: IconProps): JSX.Element;
 /** Framed document with lines — markdown */
+export declare function IconCursorTool({ size }: {
+    size?: number;
+}): JSX.Element;
+export declare function IconHandTool({ size }: {
+    size?: number;
+}): JSX.Element;
+export declare function IconNodeHtml({ size }: {
+    size?: number;
+}): JSX.Element;
 export declare function IconNodeMarkdown(p: IconProps): JSX.Element;
 /** Framed prompt with chevron and reply tail — prompt */
 export declare function IconNodePrompt(p: IconProps): JSX.Element;

package/dist/types/client/nodes/ExtAppFrame.d.ts

@@ -18,6 +18,38 @@ interface ExtAppHostDimensionsTarget {
  * everywhere we can test (Chrome / Codex / Playwright).
  */
 export declare function isWebKitOnlyHost(userAgent: string): boolean;
+/**
+ * Finding N (0.4.7 report): the GitHub Copilot panel's WKWebView reports
+ * `document.visibilityState === 'hidden'` CONTINUOUSLY — the workbench document
+ * never transitions to 'visible' even with the panel open and on-screen. Two
+ * things break as a result: the `visibilitychange` re-arm below can never fire
+ * (there is no transition to listen for), and `paint-ok` becomes a false green —
+ * the app document happily answers the double-rAF paint probe while the
+ * compositor still shows black. The instrumented trail from that session carries
+ * `visibility: "hidden"` on essentially every recovery event.
+ *
+ * So: when the document CLAIMS hidden but the frame is demonstrably on-screen,
+ * do not trust the claim — spend one more recovery round as if visible. A host
+ * that ever reports 'visible' has a working signal and is left to the
+ * visibilitychange path, which keeps a genuinely backgrounded panel quiet.
+ */
+export declare function shouldAssumeVisibleRearm(options: {
+    userAgent: string;
+    visibilityState: string;
+    rect: {
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+        width: number;
+        height: number;
+    };
+    viewport: {
+        width: number;
+        height: number;
+    };
+    alreadyRearmed: boolean;
+}): boolean;
 export declare const WEBKIT_REMOUNT_SETTLE_MS = 1000;
 export interface WebkitRemountTask {
     /** Perform the remount. Return false if the node no longer needs it (skips the boot wait). */

package/dist/types/client/nodes/GroupNode.d.ts

@@ -2,5 +2,10 @@ import type { CanvasNodeState } from '../types';
 interface GroupNodeProps {
     node: CanvasNodeState;
 }
-export declare function GroupNode({ node }: GroupNodeProps): import("preact/src").JSX.Element;
+/**
+ * Group frame body (rail-chrome-v2 groups v2): the children live in the world
+ * layer and the name/count/actions sit on the frame edge, so the body is just
+ * the wash — plus a hint while the group is empty.
+ */
+export declare function GroupNode({ node }: GroupNodeProps): import("preact/src").JSX.Element | null;
 export {};

package/dist/types/client/nodes/MarkdownNode.d.ts

@@ -1,5 +1,7 @@
 import type { JSX } from 'preact';
 import type { CanvasNodeState } from '../types';
+/** Flip the index-th GFM task marker in the source (document order matches the rendered boxes). */
+export declare function toggleTaskMarker(markdown: string, index: number): string;
 export declare function MarkdownNode({ node, expanded }: {
     node: CanvasNodeState;
     expanded?: boolean;

package/dist/types/client/nodes/inline-editor-commands.d.ts

@@ -1,9 +1,8 @@
-/** Shared contentEditable command helpers used by both the inline editor
- *  and its floating toolbar. Kept in a module that neither component
- *  depends on transitively so we don't get a circular import. */
 /** Prompt for a URL and insert it as a link on the current selection.
  *  Rejects `javascript:` and `data:` schemes so a link can't execute script
- *  when clicked. */
+ *  when clicked. Uses the in-canvas prompt (`window.prompt` is a silent no-op
+ *  in embedded panes); the selection is saved before the dialog takes focus
+ *  and restored before inserting. */
 export declare function promptAndInsertLink(): void;
 /** Wrap the current non-empty selection in an inline `<code>` element and
  *  place the caret immediately after the new element. No-op on collapsed

package/dist/types/client/state/canvas-store.d.ts

@@ -4,8 +4,17 @@ export declare const nodes: import("@preact/signals-core").Signal<Map<string, Ca
 export declare const edges: import("@preact/signals-core").Signal<Map<string, CanvasEdge>>;
 export declare const annotations: import("@preact/signals-core").Signal<Map<string, CanvasAnnotation>>;
 export declare const activeNodeId: import("@preact/signals-core").Signal<string | null>;
+/** Click-selected edge — Delete removes it, Escape/background click clears it. */
+export declare const selectedEdgeId: import("@preact/signals-core").Signal<string | null>;
 export declare const connectionStatus: import("@preact/signals-core").Signal<ConnectionStatus>;
 export declare const workbenchConnectionEpoch: import("@preact/signals-core").Signal<number>;
+/**
+ * Degraded-connection detail (rail-chrome-v2 phase 7, design item 14):
+ * the reconnect attempt and the delay before the next try while the stream is
+ * down. Both reset to 0 when a transport is back.
+ */
+export declare const reconnectAttempt: import("@preact/signals-core").Signal<number>;
+export declare const reconnectDelay: import("@preact/signals-core").Signal<number>;
 export declare const sessionId: import("@preact/signals-core").Signal<string>;
 export declare const traceEnabled: import("@preact/signals-core").Signal<boolean>;
 export declare const canvasTheme: import("@preact/signals-core").Signal<string>;
@@ -22,21 +31,60 @@ export declare const draggingEdge: import("@preact/signals-core").Signal<{
     fromY: number;
     cursorX: number;
     cursorY: number;
+    /** Node under the cursor that would receive the edge on release (item 15). */
+    targetId?: string | null;
+    /** L was pressed during the drag: ask for a label on release. */
+    withLabel?: boolean;
 } | null>;
 export declare const searchHighlightIds: import("@preact/signals-core").Signal<Set<string> | null>;
 export declare const selectedNodeIds: import("@preact/signals-core").Signal<Set<string>>;
 export declare const contextPinnedNodeIds: import("@preact/signals-core").Signal<Set<string>>;
+/** `connect` (rail-chrome-v2 item 15): drag from anywhere on a node to draw an edge. */
+export type CanvasTool = 'select' | 'pan' | 'connect';
+export declare const canvasTool: import("@preact/signals-core").Signal<CanvasTool>;
+/** Held-Space temporary pan — same semantics as the pan tool while held. */
+export declare const spacePanHeld: import("@preact/signals-core").Signal<boolean>;
+export declare function isPanModeActive(): boolean;
 export declare function getNeighborNodeIds(nodeId: string | null, edgeMap: Map<string, CanvasEdge>): Set<string>;
 export declare const activeNeighborNodeIds: import("@preact/signals-core").ReadonlySignal<Set<string>>;
 export declare function toggleSelected(id: string): void;
 export declare function selectNodes(ids: string[]): void;
 export declare function clearSelection(): void;
+/**
+ * Membership feedback while a node is being dragged: the group it would join
+ * on release (`add`), or the parent it would leave (`remove`). Membership
+ * changes ONLY on release while this is set — never silently by geometry.
+ * Esc during the drag clears it and keeps it cleared for that drag.
+ */
+export declare const dragDropTarget: import("@preact/signals-core").Signal<{
+    nodeId: string;
+    groupId: string;
+    mode: "add" | "remove";
+} | null>;
+export declare function suppressDropForDrag(): void;
+export declare function endDropTracking(): void;
+/**
+ * Called on every drag move of `nodeId`: updates the drop target and grows a
+ * fit-mode parent frame live so a child dragged against it never clips
+ * (the server re-fits on persist; shrinking happens there).
+ */
+export declare function trackDragMembership(nodeId: string): void;
+/** Children of collapsed groups are hidden; edges to them point at the chip. */
+export declare const hiddenByCollapsedGroup: import("@preact/signals-core").ReadonlySignal<Map<string, string>>;
+/** The node that stands in for `id` on the canvas: itself, or its collapsed group's chip. */
+export declare function visibleNodeFor(id: string): CanvasNodeState | undefined;
+/** Collapsed groups render as a chip; children keep their positions for restore. */
+export declare function groupsOfSelection(): string[];
+export declare function alignSelection(edge: 'left' | 'top'): void;
+/** Even horizontal gaps between the selected nodes, first and last staying put. */
+export declare function distributeSelection(): void;
+/** Grid the selection in reading order from its own top-left corner. */
+export declare function arrangeSelection(gap?: number): void;
 export declare function getSelectedNodes(): CanvasNodeState[];
 export declare function toggleContextPin(id: string): void;
 export declare function addContextPins(ids: string[]): void;
 export declare function clearContextPins(): void;
 export declare function replaceContextPinsFromServer(ids: string[]): void;
-export declare function getContextPinnedNodes(): CanvasNodeState[];
 export declare function addNode(node: CanvasNodeState): void;
 export declare function updateNode(id: string, patch: Partial<CanvasNodeState>): void;
 export declare function updateNodeData(id: string, dataPatch: Record<string, unknown>): void;
@@ -65,10 +113,6 @@ export declare function resizeNode(id: string, size: {
 }): void;
 export declare function bringToFront(id: string): void;
 export declare function toggleCollapsed(id: string): void;
-export declare function collapseDockedContextNodes(): void;
-export declare const hasOpenDockedContextPanel: import("@preact/signals-core").ReadonlySignal<boolean>;
-export declare function dockNode(id: string, position: 'left' | 'right'): void;
-export declare function undockNode(id: string): void;
 export declare function setViewport(v: Partial<ViewportState>): void;
 export declare function replaceViewport(next: ViewportState): void;
 export declare function commitViewport(next: ViewportState): void;

package/dist/types/client/state/human-store.d.ts

@@ -0,0 +1,26 @@
+import { type HumanPresence, type HumanPresenceSnapshot } from '../../shared/human-presence.js';
+export declare const humanClientId: string;
+export declare const humanName: import("@preact/signals-core").Signal<string>;
+export declare const humans: import("@preact/signals-core").Signal<HumanPresence[]>;
+export declare const otherHumans: import("@preact/signals-core").ReadonlySignal<HumanPresence[]>;
+/** Nodes a human took over mid-edit → that human's name, shown as the yield pill for a moment. */
+export declare const yieldedNodes: import("@preact/signals-core").Signal<Map<string, string>>;
+export declare function applyHumanSnapshot(snapshot: Partial<HumanPresenceSnapshot> | null | undefined): void;
+/** Report the pointer in world coordinates (throttled); null when it leaves the canvas. */
+export declare function reportHumanCursor(cursor: {
+    x: number;
+    y: number;
+} | null): void;
+/** Hold / release a node (drag, rename): the edit lock agents must respect. */
+export declare function reportHumanGrab(nodeId: string | null): void;
+export declare function markYielded(nodeId: string, name: string): void;
+/**
+ * User wins (item 6): the human grabbed a node the agent is mid-edit on. Every
+ * explicit intent targeting it is vetoed through the normal veto path (the
+ * agent hears it as steering), a Yield entry lands in the timeline, and the
+ * node wears a "took over — agent yielded" pill for a moment.
+ */
+export declare function takeOverNode(nodeId: string, title: string): void;
+/** Announce this tab and keep it alive; renews a held grab. Call once per connection. */
+export declare function startHumanPresence(): () => void;
+export declare function resetHumanPresence(): void;

package/dist/types/client/state/iframe-mode.d.ts

@@ -21,6 +21,7 @@ export declare function probeSrcIframes(timeoutMs?: number): Promise<boolean>;
 export declare function resolveIframeMode(opts?: {
     embedded?: boolean;
     ampOrb?: boolean;
+    probeTimeoutMs?: number;
 }): Promise<IframeMode>;
 /** Test hook: clear the memoized probe so each test starts unresolved. */
 export declare function resetIframeModeForTests(): void;

package/dist/types/client/state/intent-bridge.d.ts

@@ -1,3 +1,16 @@
+import type { AgentPresenceSnapshot } from '../../shared/agent-presence.js';
+/**
+ * Per-tab identity: an AGENT driving the workbench UI from its own pane opens
+ * `/workbench?agent=<key>` and every write from that tab is booked as that
+ * agent — before this, UI-driven agent tests carried the human marker and the
+ * human was told "you rejected a gate" they never saw (0.5.0 readiness).
+ */
+export declare const tabAgentKey: string | null;
+export declare function requestJson<T>(action: string, url: string, fallback: T, init?: RequestInit): Promise<T>;
+export declare function requestOk(action: string, url: string, init?: RequestInit): Promise<{
+    ok: boolean;
+}>;
+export declare function requestBestEffort(action: string, url: string, init?: RequestInit): Promise<void>;
 /** Dispatch user intents from the canvas to the server (for TUI consumption). */
 export declare function sendIntent(type: string, payload?: Record<string, unknown>): Promise<{
     ok: boolean;
@@ -68,7 +81,6 @@ export declare function pushCanvasUpdate(updates: Array<{
         height: number;
     };
     collapsed?: boolean;
-    dockPosition?: 'left' | 'right' | null;
 }>, options?: {
     recordHistory?: boolean;
 }): Promise<void>;
@@ -102,10 +114,11 @@ export declare function updateNodeFromClient(id: string, patch: {
     };
     collapsed?: boolean;
     pinned?: boolean;
-    dockPosition?: 'left' | 'right' | null;
     title?: string;
     content?: string;
     data?: Record<string, unknown>;
+    /** Groups: replace the membership list (positions preserved). */
+    children?: string[];
 }): Promise<{
     ok: boolean;
     id?: string;
@@ -138,6 +151,8 @@ export interface AxInteractionResponse {
 }
 /** Fetch the compact AX state snapshot pushed into AX-enabled surfaces. */
 export declare function fetchAxSurfaceState(): Promise<unknown>;
+/** Connect-time agent-presence read; live updates arrive as `agent-presence` SSE frames. */
+export declare function fetchAgentPresence(): Promise<Partial<AgentPresenceSnapshot> | null>;
 /** Ask the server to open a node's surface in the system browser. */
 export declare function openNodeInSystemBrowserRequest(nodeId: string, url?: string): Promise<{
     ok: boolean;
@@ -177,11 +192,19 @@ export declare function createGroupFromClient(opts: {
     ok: boolean;
     id?: string;
 }>;
-/** Add nodes to an existing group. */
-export declare function addToGroupFromClient(groupId: string, childIds: string[]): Promise<{
+/** Add nodes to an existing group; `childLayout` packs the children (the header's auto-arrange). */
+export declare function addToGroupFromClient(groupId: string, childIds: string[], childLayout?: 'grid' | 'column' | 'flow'): Promise<{
     ok: boolean;
 }>;
-/** Ungroup all children from a group. */
+/** Replace a group's membership (positions preserved) — how a single child leaves. */
+export declare function setGroupChildrenFromClient(groupId: string, children: string[]): Promise<{
+    ok: boolean;
+}>;
+/**
+ * Ungroup = dissolve (children released, frame removed). The SAME server op
+ * an agent's `canvas_group { action: "ungroup" }` runs, so both sides get the
+ * identical board and one undo step.
+ */
 export declare function ungroupFromClient(groupId: string): Promise<{
     ok: boolean;
 }>;
@@ -203,6 +226,15 @@ export declare function restoreSnapshot(id: string): Promise<{
 export declare function deleteSnapshot(id: string): Promise<{
     ok: boolean;
 }>;
+/** Patch an edge in place (label/type/style/animated) via the server. */
+export declare function updateEdgeFromClient(edgeId: string, patch: {
+    label?: string;
+    type?: string;
+    style?: string;
+    animated?: boolean;
+}): Promise<{
+    ok: boolean;
+}>;
 /** Remove a canvas edge via the server. */
 export declare function removeEdgeFromClient(edgeId: string): Promise<{
     ok: boolean;

package/dist/types/client/state/node-factory.d.ts

@@ -25,5 +25,4 @@ export declare function makeNodeState(id: string, type: CanvasNodeState['type'],
         width: number;
         height: number;
     };
-    dockPosition?: 'left' | 'right' | null;
 }): CanvasNodeState;

package/dist/types/client/state/presence-store.d.ts

@@ -0,0 +1,78 @@
+import type { PmxAxIntent } from '../../shared/ax-intent.js';
+import { type AgentActivityEntry, type AgentPresence, type AgentPresenceSnapshot, type ContextBudget } from '../../shared/agent-presence.js';
+/**
+ * Agent presence (rail-chrome-v2 phase 2). Fed by the server's `agent-presence`
+ * SSE snapshot (every change, including TTL expiry) and the connect-time read,
+ * so this store never runs its own expiry ticker.
+ *
+ * `sessionActive` is the ONE selector every agent surface reads — the session
+ * panel, command bar, presence layer, and top-bar chip all mount on it.
+ */
+export declare const agentPresences: import("@preact/signals-core").Signal<AgentPresence[]>;
+export declare const contextBudget: import("@preact/signals-core").Signal<ContextBudget>;
+/** Recent agent writes, newest first — the External Steering activity feed. */
+export declare const agentActivity: import("@preact/signals-core").Signal<AgentActivityEntry[]>;
+/** External Steering chrome (phase 6): the feed popover and the writers sheet. */
+export declare const activityFeedOpen: import("@preact/signals-core").Signal<boolean>;
+export declare const writersSheetOpen: import("@preact/signals-core").Signal<boolean>;
+/** Feed filter: a writer's sessionId, or null for all. */
+export declare const activityFilter: import("@preact/signals-core").Signal<string | null>;
+export declare function writerColor(sessionId: string): string;
+/** Avatar initial: first letter of the label, upper-cased. */
+export declare function writerInitial(label: string): string;
+/** Compact relative age for feed rows and the writers sheet: now · 12s · 4m · 2h. */
+export declare function relativeAge(iso: string, now?: number): string;
+/** Master gate for every agent surface: an attached session exists. */
+export declare const sessionActive: import("@preact/signals-core").ReadonlySignal<boolean>;
+/** Live writers with no attached session — the External Steering mode. */
+export declare const externalWriterPresences: import("@preact/signals-core").ReadonlySignal<AgentPresence[]>;
+/**
+ * Connected agents the human can ADDRESS from the composer: every live
+ * presence (attached sessions first). `label` is the display name; `value` is
+ * the CONSUMER key the steer must be targeted at — the identity the agent
+ * claims deliveries with. For an adapter session that is its source key
+ * (Copilot attaches as source "copilot" labelled "GitHub Copilot"); for an
+ * adopted human-started session the sessionId is "browser", so the writer's
+ * label IS its consumer key. Addressing the display label instead would
+ * produce steering nobody can ever claim. The un-adopted placeholder is
+ * excluded: no consumer will ever claim as "Agent session".
+ */
+export declare const steerableAgents: import("@preact/signals-core").ReadonlySignal<{
+    value: string;
+    label: string;
+    attached: boolean;
+    steerable: boolean;
+    pendingSteers: number;
+    polling: boolean;
+}[]>;
+/** The attached session's presence (first if several hosts attached). */
+/** Every attached session, in presence order — the top bar shows one chip each. */
+export declare const attachedSessions: import("@preact/signals-core").ReadonlySignal<AgentPresence[]>;
+export declare const activeSession: import("@preact/signals-core").ReadonlySignal<AgentPresence | null>;
+/**
+ * Nodes an agent is mutating RIGHT NOW — drives the shimmer. Derived from the
+ * intent store's in-flight ghosts (move / edit / remove target an existing
+ * node) rather than a parallel source; gated on `sessionActive` at the use
+ * site so the quiet board never shimmers.
+ */
+export declare function mutatingNodeIdsFrom(intentList: Iterable<Pick<PmxAxIntent, 'kind' | 'nodeId'>>): Set<string>;
+export declare const mutatingNodeIds: import("@preact/signals-core").ReadonlySignal<Set<string>>;
+/**
+ * Where a presence's cursor sits in WORLD coordinates: an explicit cursor
+ * wins; otherwise the node the agent last touched (anchored near its title
+ * bar's right end, like a collaborator hovering the node); otherwise null.
+ */
+export declare function presenceWorldPosition(presence: Pick<AgentPresence, 'cursor' | 'focusNodeId'>, nodeById: (id: string) => {
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+    };
+} | undefined): {
+    x: number;
+    y: number;
+} | null;
+export declare function applyPresenceSnapshot(snapshot: Partial<AgentPresenceSnapshot> | null | undefined): void;
+export declare function resetPresence(): void;