pmx-canvas 0.8.2 → 0.9.0

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

@@ -1,48 +1,113 @@
+import type { MemoryTarget } from '../../shared/memory-graph.js';
+import type { RelationDefinition } from '../../shared/relations.js';
 /**
  * Many boards (plan 012): the workspace's boards and which one is open. The
  * server is the authority; this mirrors GET /api/canvas/boards and the
- * `boards-changed` SSE frame. `activeBoardId === null` is Home.
+ * `boards-changed` SSE frame. Null means no server board is open; browsingMemory
+ * separately keeps a human in the library while agents open boards.
  */
 export interface BoardSummary {
     id: string;
     name: string;
-    category: string | null;
+    folder: string | null;
     createdAt: string;
     lastOpenedAt: string | null;
     nodeCount: number;
     readmeNodeId?: string | null;
+    mapPosition?: {
+        x: number;
+        y: number;
+    } | null;
+    previousBoardId?: string | null;
+    relationVocabulary?: RelationDefinition[];
     summary?: string | null;
     pinnedTitles?: Array<{
         nodeId: string;
         title: string;
     }>;
     links?: Array<{
+        id?: string;
         nodeId: string;
         boardId: string;
+        cardId?: string;
+        cardTitle?: string | null;
         title: string | null;
         missing: boolean;
+        kind?: string;
     }>;
     backlinks?: Array<{
+        id?: string;
         boardId: string;
         title: string;
         nodeId: string;
+        cardId?: string;
+        kind?: string;
     }>;
+    /** Home thumbnail (docs/design/Home.dc.html): cards as 0–1 rectangles of the board's extent. */
+    preview?: Array<{
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        pinned?: true;
+    }>;
+    /** Roughly what this board's map costs in the brief when pinned (README + pinned card summaries). */
+    mapChars?: number;
+    /** In the agent's working set (vision move 0a); null when not pinned. */
+    pin?: {
+        pinnedBy: {
+            actor: string;
+            source: string;
+            agentId?: string;
+        };
+        pinnedAt: string;
+        reason?: string;
+    } | null;
 }
 export declare const boardList: import("@preact/signals-core").Signal<BoardSummary[]>;
 export declare const activeBoardId: import("@preact/signals-core").Signal<string | null>;
+/** An explicitly opened library view stays visible while agents switch boards. */
+export declare const browsingMemory: import("@preact/signals-core").Signal<boolean>;
+/** Review belongs to this navigation incarnation, never merely a reused card ID. */
+export declare const lifecycleTarget: import("@preact/signals-core").Signal<{
+    boardId: string;
+    nodeId: string;
+    incarnation: number;
+} | null>;
+export declare const lifecycleFilter: import("@preact/signals-core").Signal<"All" | "To review" | "Retired">;
+/** Layout/pin/reconnect invalidation for the library's shared graph projection. */
+export declare const memoryGraphRevision: import("@preact/signals-core").Signal<number>;
 /** False until the first list arrives — Home must not flash before the server answers. */
 export declare const boardsLoaded: import("@preact/signals-core").Signal<boolean>;
+export declare let catalogEpoch: string | null;
+export declare let boardGeneration: number | null;
+/** Invalidates suspended writes when the canonical board/library is replaced. */
+export declare let boardIncarnation: number;
+/** Invalidates lifecycle UI work across suspension, including an off/on round trip. */
+export declare let lifecycleUiGeneration: number;
+/** Only the current transport's connected handshake may replace the server epoch. */
+export declare function connectBoardCatalog(epoch: string): void;
 /** The SSE bridge resyncs the canvas when the open board changes under it. */
-export declare function setBoardSwitchHandler(handler: (() => void) | null): void;
+export declare function setBoardSwitchHandler(handler: ((initial: boolean) => void) | null): void;
 export declare function applyBoards(data: {
     activeBoardId?: unknown;
     boards?: unknown;
-    reloaded?: unknown;
+    catalogEpoch?: unknown;
+    catalogRevision?: unknown;
+    reloadRevision?: unknown;
+    boardGeneration?: unknown;
 } | null): void;
 export declare function loadBoards(): Promise<void>;
+/** Reserve navigation before an async save; later navigation cancels the pending jump. */
+export declare function claimNavigation(): () => boolean;
 /** Open a board, or Home with null. */
 export declare function openBoard(id: string | null): Promise<void>;
-export declare function createAndOpenBoard(name: string): Promise<void>;
+/** Used by wiki links, graph nodes and qualified library hits; never focus a stale board's same-ID card. */
+export declare function openMemoryTarget(target: MemoryTarget, options?: {
+    review?: boolean;
+}): Promise<boolean>;
+/** Create a board (filed in `folder` when given) and open it. */
+export declare function createAndOpenBoard(name: string, folder?: string | null): Promise<void>;
 export interface BoardCopyCard {
     id: string;
     type: string;
@@ -64,16 +129,23 @@ export declare function previewBoardCopy(sourceBoardId: string): Promise<BoardCo
 export declare function createBoardFrom(opts: {
     sourceBoardId: string;
     name: string;
-    category?: string;
+    folder?: string;
     nodeIds: string[];
     includeReadme: boolean;
     includeStructure: boolean;
 }): Promise<BoardSummary | null>;
-/** Rename and/or re-file a board; `category: null` removes it from its category. */
+/** Rename and/or re-file a board; `folder: null` unfiles it. */
 export declare function updateBoard(id: string, patch: {
     name?: string;
-    category?: string | null;
-}): Promise<void>;
+    folder?: string | null;
+    mapPosition?: {
+        x: number;
+        y: number;
+    } | null;
+    relationVocabulary?: RelationDefinition[];
+}): Promise<boolean>;
+/** Pin a board into the agent's working set, or unpin it. */
+export declare function setBoardPinned(id: string, pinned: boolean): Promise<void>;
 export declare function setBoardReadme(id: string, readmeNodeId: string | null): Promise<void>;
 export declare function deleteBoard(id: string): Promise<void>;
 export declare function activeBoard(): BoardSummary | null;

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

@@ -85,10 +85,15 @@ 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 let contextPinsRevision: number;
+export declare let contextPinsPendingWrites: number;
 export declare function toggleContextPin(id: string): void;
 export declare function addContextPins(ids: string[]): void;
+export declare function removeContextPins(ids: string[]): void;
 export declare function clearContextPins(): void;
 export declare function replaceContextPinsFromServer(ids: string[]): void;
+/** Reconcile dropped frames and refused/normalized writes without replaying old pins. */
+export declare function refreshContextPins(): Promise<void>;
 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;
@@ -119,7 +124,9 @@ export declare function bringToFront(id: string): void;
 export declare function toggleCollapsed(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;
+export declare function commitViewport(next: ViewportState, options?: {
+    recordHistory?: boolean;
+}): void;
 export declare function applyServerCanvasLayout(layout: Pick<CanvasLayout, 'nodes' | 'edges'> & {
     viewport?: ViewportState;
     annotations?: CanvasAnnotation[];
@@ -144,6 +151,12 @@ export declare function zoomByFactor(factor: number, duration?: number): void;
 export declare function animateViewport(target: ViewportState, duration?: number, options?: {
     recordHistory?: boolean;
 }): void;
+/**
+ * Drive the camera along `frameAt(t)`, t in [0, 1], over `duration` ms — the
+ * tour/camera-move path. Shares animateViewport's slot, so a pan gesture or a
+ * capture frame (cancelViewportAnimation) interrupts it. Duration 0 jumps.
+ */
+export declare function animateCameraPath(frameAt: (t: number) => ViewportState, duration: number, onDone?: (end: ViewportState) => void): void;
 /** Cancel any in-flight viewport animation (e.g. when user starts dragging). */
 export declare function cancelViewportAnimation(): void;
 export declare function persistLayout(options?: {

package/dist/types/client/state/context-chip-store.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The context chip (docs/design/ContextChip.dc.html): what the agent's brief
+ * costs in tokens, and when each pinned board was last read. The brief fetch is a measurement, not a delivery: it says so with
+ * `x-pmx-proxied-read`, so it is never booked as an agent read — not even from
+ * an `?agent=` tab, whose requests carry no workbench marker. Otherwise the
+ * recorded read would announce itself and refetch the chip in a loop.
+ */
+export interface BriefSize {
+    chars: number;
+}
+export interface BoardRead {
+    lastReadAt: string;
+    lastReadBy: string;
+}
+export declare const briefSize: import("@preact/signals-core").Signal<BriefSize | null>;
+export declare const pinnedBoardReads: import("@preact/signals-core").Signal<Map<string, BoardRead | null>>;
+/** A token count for display: 873, 1.1k. */
+export declare function formatTokens(tokens: number): string;
+/** ≈ tokens for a character count (about four characters per token). */
+export declare function approxTokens(chars: number): string;
+/** Debounced: pins, reads and board changes arrive in bursts; content edits wait longer. */
+export declare function refreshContextChip(delayMs?: number): void;

package/dist/types/client/state/context-status-store.d.ts

@@ -25,10 +25,13 @@ interface ContextStatusResponse {
     ok?: boolean;
     boardId?: string | null;
     nodes?: NodeReadStatus[];
+    /** Per node, the newest links revision an agent read carried. */
+    links?: Record<string, number>;
     pins?: Record<string, ContextPinMeta>;
 }
 export declare const nodeReadStatus: import("@preact/signals-core").Signal<Map<string, NodeReadStatus>>;
 export declare const contextPinMeta: import("@preact/signals-core").Signal<Record<string, ContextPinMeta>>;
+export declare const seenLinks: import("@preact/signals-core").Signal<Record<string, number>>;
 export declare function applyContextStatus(response: ContextStatusResponse): void;
 export declare function refreshContextStatus(): Promise<void>;
 /** How an agent's context relates to one pinned node — the mark its header shows. */
@@ -45,6 +48,38 @@ export type PinnedReadState = {
     at: string;
 };
 export declare function pinnedReadState(nodeId: string, currentRevision: number): PinnedReadState;
+/**
+ * The marks a link's pill carries (docs/design/LinkAuthorship.dc.html):
+ * - `agent`: the agent that drew or last relabelled it — a ✦ that stays until
+ *   a person edits, retypes or relabels the link. A read never clears it.
+ * - `notSeen`: a person's new or edited link that no read has carried yet —
+ *   temporary, cleared by the agent's next read of either end. Quiet until an
+ *   agent has read this board at all. An agent's link is never "not seen".
+ * The board's only person draws without a mark (another person's initial is
+ * Part 3, shared boards).
+ */
+export interface LinkMarks {
+    agent: string | null;
+    notSeen: boolean;
+}
+export declare function linkMarks(edge: {
+    from: string;
+    to: string;
+    toBoardId?: string;
+    revision?: number;
+    changedBy?: {
+        actor: string;
+        source: string;
+        agentId?: string;
+    };
+}): LinkMarks;
+/**
+ * A card whose links changed after the last read that carried them (shown
+ * neutral, never amber). A link an agent drew does not count — that agent
+ * made it, and the link itself says "by <agent>". A removed link has no
+ * author left to check, so it counts.
+ */
+export declare function linksChanged(nodeId: string, linksRevision: number): boolean;
 /** Display name for an attributed writer: its agent id, else its transport label. */
 export declare function writerName(actor: {
     source: string;

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

@@ -1,4 +1,5 @@
 import type { AgentPresenceSnapshot } from '../../shared/agent-presence.js';
+import type { CanvasNodeState } from '../types';
 /**
  * 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
@@ -26,17 +27,12 @@ export declare function vetoGhostIntent(intent: {
     reason?: string;
 }): Promise<boolean>;
 /** Fetch rendered markdown HTML from the server. */
-export declare function renderMarkdown(markdown: string): Promise<string>;
+export declare function renderMarkdown(markdown: string, nodeId?: string, expectedBoardId?: string | null): Promise<string | null>;
 /** Fetch file content from the server. */
 export declare function fetchFile(path: string): Promise<{
     content: string;
     provenance?: unknown;
 }>;
-/** Save file content to the server. */
-export declare function saveFile(path: string, content: string): Promise<{
-    ok: boolean;
-    updatedAt?: string;
-}>;
 /** Fetch current workbench state. */
 export declare function fetchWorkbenchState(): Promise<Record<string, unknown>>;
 /** Open a markdown file in the workbench/canvas. */
@@ -44,7 +40,7 @@ export declare function openWorkbenchFile(path: string): Promise<{
     ok: boolean;
 }>;
 /** Fetch canvas state from server. */
-export declare function fetchCanvasState(): Promise<Record<string, unknown>>;
+export declare function fetchCanvasState(expectedBoardId: string | null): Promise<Record<string, unknown>>;
 export declare function saveCanvasTheme(theme: string): Promise<{
     ok: boolean;
     theme?: string;
@@ -85,7 +81,10 @@ export declare function pushCanvasUpdate(updates: Array<{
     recordHistory?: boolean;
 }): Promise<void>;
 /** Render the server-confirmed edge immediately, without waiting for SSE/polling. */
-export declare function createEdgeFromClient(from: string, to: string, type: string, label?: string): Promise<{
+export declare function createEdgeFromClient(from: string, to: string, type: string, label?: string, options?: {
+    toBoardId?: string;
+    expectedBoardId?: string | null;
+}): Promise<{
     ok: boolean;
     id?: string;
 }>;
@@ -122,10 +121,12 @@ export declare function updateNodeFromClient(id: string, patch: {
     children?: string[];
     expectedContentRevision?: number;
     expectedBoardId?: string | null;
+    persistFile?: boolean;
 }): Promise<{
     ok: boolean;
     id?: string;
     contentRevision?: number;
+    lastEditedBy?: CanvasNodeState['lastEditedBy'];
 }>;
 /** Refresh a webpage node from its persisted URL on the server. */
 export declare function refreshWebpageNodeFromClient(id: string, url?: string): Promise<{
@@ -232,6 +233,8 @@ export declare function deleteSnapshot(id: string): Promise<{
 }>;
 /** Patch an edge in place (label/type/style/animated) via the server. */
 export declare function updateEdgeFromClient(edgeId: string, patch: {
+    kind?: string | null;
+    reason?: string | null;
     label?: string;
     type?: string;
     style?: string;

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

@@ -0,0 +1,22 @@
+export { lifecycleFilter, lifecycleTarget } from './boards-store';
+export declare const knowledge: import("@preact/signals-core").Signal<{
+    ok: true;
+    categories: import("../../server").KnowledgeCategory[];
+    folders: import("../../server").FolderProperties[];
+    relationPresets: import("../../shared/relations").RelationPreset[];
+    cards: Record<string, import("../../shared/lifecycle-status").LifecycleQualification>;
+    reviewCards: import("../../server/knowledge-lifecycle.js").ReviewCardSummary[];
+    resolvedFolders: Record<string, ReturnType<import("../../server/knowledge-lifecycle.js").KnowledgeLifecycle["resolve"]>>;
+} | null>;
+export declare const knowledgeUnavailable: import("@preact/signals-core").Signal<boolean>;
+export declare const effectiveLifecycleFilter: import("@preact/signals-core").ReadonlySignal<"All" | "To review" | "Retired">;
+export declare const retirementUndo: import("@preact/signals-core").Signal<{
+    boardId: string;
+    nodeId: string;
+    incarnation: number;
+} | null>;
+export declare function refreshKnowledge(): Promise<void>;
+export declare function cardQualification(nodeId: string): import("../../shared/lifecycle-status").LifecycleQualification | undefined;
+/** Raw pin membership survives retirement, but retired cards are not delivered. */
+export declare const activeContextPinnedNodeIds: import("@preact/signals-core").ReadonlySignal<Set<string>>;
+export declare function openLifecycle(nodeId: string): void;

package/dist/types/client/state/near-pin-store.d.ts

@@ -1,6 +1,6 @@
 /**
  * Near a pin (docs/design/NearPin.dc.html): each pinned node pulls up to five
- * unpinned nodes within 600 px into the agent's brief as title + short
+ * unpinned nodes within a 600 px edge-to-edge gap into the agent's brief as title + short
  * summary. Same rule as the server's brief (`findNeighborhoods`), so the mark
  * claims exactly what the agent receives.
  */
@@ -14,3 +14,46 @@ export interface NearPin {
  * changes: the chips subscribed to it re-render only when a neighbourhood does.
  */
 export declare const nearPins: import("@preact/signals-core").ReadonlySignal<Map<string, NearPin[]>>;
+/** Pin id → its neighbours' ids: the tether layer looks a pin up, never scans the near map. */
+export declare const neighboursByPin: import("@preact/signals-core").ReadonlySignal<Map<string, string[]>>;
+/** The node under the pointer: a hovered pin draws its neighbours (NearPin.dc.html §2). */
+export declare const hoveredNodeId: import("@preact/signals-core").Signal<string | null>;
+/** A near node whose pins the human asked to see from its chip ("Show pins"). */
+export declare const shownPinsFor: import("@preact/signals-core").Signal<string | null>;
+/**
+ * Pins drawn with tethers and the 600 px boundary around their edges: the pin being dragged,
+ * hovered or selected, or the pins of the near node whose chip said "Show
+ * pins". Dragging an unpinned node rings only its nearest pin (§3).
+ */
+export declare const tetherFocus: import("@preact/signals-core").ReadonlySignal<{
+    pinIds: string[];
+    ringOnly: boolean;
+}>;
+/** The moment it changes (§3): the chip pulses once on a drop inside, fades on a drop outside. */
+export declare const nearChange: import("@preact/signals-core").Signal<{
+    nodeId: string;
+    kind: "in" | "out";
+    pins: NearPin[];
+} | null>;
+export declare function noteNearAtGrab(nodeId: string): void;
+export declare function settleNearAfterDrop(nodeId: string): void;
+export declare function clearNearChange(nodeId: string): void;
+/**
+ * The open near chip's card (§2), drawn over the canvas because a node paints
+ * contained. `at` is the chip's screen rect when it opened; the card closes
+ * when the view moves rather than chase a stale anchor.
+ */
+export declare const nearCard: import("@preact/signals-core").Signal<{
+    nodeId: string;
+    at: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    view: string;
+} | null>;
+export declare function openNearCard(nodeId: string, chip: Element, view: string): void;
+/** Leaving the chip for the card must not close it: close after a short grace. */
+export declare function closeNearCardSoon(): void;
+export declare function keepNearCard(): void;

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

@@ -1,5 +1,5 @@
 import type { PmxAxIntent } from '../../shared/ax-intent.js';
-import { type AgentActivityEntry, type AgentPresence, type AgentPresenceSnapshot, type ContextBudget } from '../../shared/agent-presence.js';
+import { type AgentActivityEntry, type AgentPresence, type AgentPresenceSnapshot } 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,
@@ -9,7 +9,6 @@ import { type AgentActivityEntry, type AgentPresence, type AgentPresenceSnapshot
  * 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. */
@@ -27,9 +26,10 @@ export declare function writerColor(sessionId: string): string;
 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. */
+/** Attachment state is independent of whether the human opted into its UI. */
 export declare const sessionActive: import("@preact/signals-core").ReadonlySignal<boolean>;
-/** Live writers with no attached session — the External Steering mode. */
+export declare const sessionChromeActive: import("@preact/signals-core").ReadonlySignal<boolean>;
+/** With session UI off, attached agents still appear as ordinary live writers. */
 export declare const externalWriterPresences: import("@preact/signals-core").ReadonlySignal<AgentPresence[]>;
 /**
  * Connected agents the human can ADDRESS from the composer: every live

package/dist/types/client/state/presentation.d.ts

@@ -1,3 +1,31 @@
+import { type TourStop } from '../../shared/tour.js';
+import type { ViewportState } from '../types';
 export declare const presenting: import("@preact/signals-core").Signal<boolean>;
 export declare const recordingCamera: import("@preact/signals-core").Signal<boolean>;
+/** Why the current stop cannot be shown (missing target, no stops, server unreachable). */
+export declare const presentationError: import("@preact/signals-core").Signal<string>;
 export declare function ownsCamera(): boolean;
+/**
+ * Ease this viewer's camera to a stop: log-space zoom, optional pull-back.
+ * Reduced motion jumps straight to the end. Throws when the target is missing.
+ */
+export declare function playStop(stop: TourStop, onDone?: (end: ViewportState) => void): void;
+/**
+ * Show a tour stop, entering presentation if needed. Entering hides the
+ * chrome, so the canvas area is measured only after that layout has
+ * committed (two frames); the latest step always wins.
+ */
+export declare function presentStop(stop: TourStop): void;
+/**
+ * Move the server's shared tour cursor. The `canvas-tour-step` echo does the
+ * animating, here and in every other presenting viewer, so a human's keys and
+ * an agent's `tour.go` always agree on where the tour is.
+ */
+export declare function stepTour(to: {
+    stop: number;
+} | {
+    step: 'next' | 'previous';
+}): Promise<void>;
+/** Present from the first stop, or resume where the tour already is (`?present=1`). */
+export declare function startPresentation(resume?: boolean): Promise<void>;
+export declare function endPresentation(): void;

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

@@ -0,0 +1,10 @@
+export declare const relationFilter: import("@preact/signals-core").Signal<{
+    boardId: string;
+    kind: string;
+} | null>;
+export declare const relationFocus: import("@preact/signals-core").ReadonlySignal<string | null>;
+/** View-only highlights. They never infer evidence, change a decision or execute a flow. */
+export declare const relationHighlight: import("@preact/signals-core").ReadonlySignal<{
+    cards: Set<string>;
+    links: Set<string>;
+} | null>;

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

@@ -1,4 +1,6 @@
 import type { AxApprovalStatus, AxEventKind, AxWorkItemStatus } from '../../shared/ax-kinds.js';
+/** Explicit panel expansion, shared by the panel handle and the agent popover. */
+export declare const sessionPanelOpened: import("@preact/signals-core").Signal<boolean>;
 export type WorkItemStatus = AxWorkItemStatus;
 export interface WorkItemView {
     id: string;
@@ -159,6 +161,8 @@ export interface SessionReceipt {
     labels: string[];
     /** Endings folded into this card (see applySessionReceipt). */
     sessions: number;
+    /** When the session attached (the receipt's "This session · start–end"); null if unknown. */
+    startedAt: string | null;
     endedAt: string;
     /** Why it ended — the receipt should answer this, not leave the human asking. */
     endedBy?: 'human' | 'agent' | 'idle-timeout';
@@ -177,6 +181,7 @@ export interface SessionReceipt {
     snapshot: {
         id: string;
         name: string;
+        boardId: string | null;
     } | null;
     /** What the session did with context (docs/design/AgentContext.dc.html receipt). */
     context: SessionContextActivity;
@@ -184,8 +189,17 @@ export interface SessionReceipt {
 export interface ReceiptNode {
     id: string;
     title: string;
+    /** The board where this touch was recorded, for reopening a change's card. */
+    boardId?: string;
     reason?: string;
+    /** Edited cards: what the edit did ("rewrote the second paragraph"). */
+    change?: string;
+    /** Edited cards: the text before and at the session's end, cut around the first difference. */
+    before?: string;
+    after?: string;
 }
+/** Card ids are local to a board; receipts can remain open across board switches. */
+export declare const receiptNodeKey: (node: ReceiptNode) => string;
 export interface SessionContextActivity {
     read: ReceiptNode[];
     pinned: ReceiptNode[];
@@ -197,8 +211,25 @@ export interface SessionContextActivity {
  * The agent-activity lens: while on, nodes the last session did not touch
  * (read, pin, create, edit) are dimmed. Null when off.
  */
-export declare const activityLensNodeIds: import("@preact/signals-core").Signal<Set<string> | null>;
-export declare function setActivityLens(on: boolean): void;
+/**
+ * The activity lens ("Dim untouched nodes"): off, one live session's touches
+ * (the chip that was pressed), or the receipt's. A live lens hands over to the
+ * receipt when that session ends, and switches off if its ending has none.
+ */
+export type ActivityLens = {
+    kind: 'live';
+    sessionId: string;
+} | {
+    kind: 'receipt';
+} | null;
+export declare const activityLens: import("@preact/signals-core").Signal<ActivityLens>;
+export declare const activityLensNodeIds: import("@preact/signals-core").ReadonlySignal<Set<string> | null>;
+/** Cards an agent edited in a live session or in the receipt's session: they carry the violet bar. */
+export declare const sessionEditedIds: import("@preact/signals-core").ReadonlySignal<Set<string>>;
+/** Turn the lens on for a live session (from its chip) or the receipt, or off. */
+export declare function setActivityLens(on: boolean, live?: {
+    sessionId: string;
+}): void;
 /** The last ended session's receipt (design item 2); client-side, cleared on dismiss. */
 export declare const sessionReceipt: import("@preact/signals-core").Signal<SessionReceipt | null>;
 /**
@@ -209,5 +240,13 @@ export declare const sessionReceipt: import("@preact/signals-core").Signal<Sessi
  * extend an open receipt. Qualifying endings while one is up merge into it.
  */
 export declare function applySessionReceipt(data: Record<string, unknown>): void;
+/**
+ * Undo on the receipt's Edited row (AgentContext.dc.html): each card back to
+ * its content in the pre-session snapshot — the rest of the board stays.
+ */
+export declare function undoSessionEdits(snapshotId: string, edits: ReceiptNode[]): Promise<{
+    ok: boolean;
+    restored: string[];
+}>;
 export declare function dismissSessionReceipt(): void;
 export declare function resetSessionStore(): void;

package/dist/types/client/state/workspace-settings.d.ts

@@ -0,0 +1,7 @@
+export declare const workspaceSettings: import("@preact/signals-core").Signal<{
+    agentSessions: boolean;
+    knowledgeLifecycle: boolean;
+} | null>;
+export declare const agentSessionsEnabled: import("@preact/signals-core").ReadonlySignal<boolean>;
+export declare const knowledgeLifecycleEnabled: import("@preact/signals-core").ReadonlySignal<boolean>;
+export declare function applyWorkspaceSettings(value: unknown): void;

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

@@ -19,6 +19,8 @@ export interface CanvasNodeState {
     collapsed: boolean;
     pinned: boolean;
     contentRevision?: number;
+    /** Revision of this node's latest link change, kept apart from its text. */
+    linksRevision?: number;
     /** Who created / last edited the node's content (server attribution). */
     createdBy?: NodeActor;
     lastEditedBy?: NodeActor;
@@ -33,10 +35,20 @@ export interface CanvasEdge {
     id: string;
     from: string;
     to: string;
+    toBoardId?: string;
     type: 'relation' | 'depends-on' | 'flow' | 'references';
+    kind?: string;
+    reason?: string;
     label?: string;
     style?: 'solid' | 'dashed' | 'dotted';
     animated?: boolean;
+    /** Board revision of this link's latest add, retype or relabel. */
+    revision?: number;
+    changedBy?: NodeActor;
+    changedAt?: string;
+    /** Who first drew the link, and when (LinkAuthorship.dc.html). */
+    createdBy?: NodeActor;
+    createdAt?: string;
 }
 export interface CanvasAnnotationPoint {
     x: number;
@@ -63,7 +75,7 @@ export type AnnotationTool = 'pen' | 'eraser' | 'text' | null;
 export type ConnectionStatus = 'connecting' | 'connected' | 'disconnected';
 export declare const TYPE_LABELS: Record<CanvasNodeState['type'], string>;
 /** Node types that support the full-viewport expand/focus overlay. */
-export declare const EXPANDABLE_TYPES: Set<"file" | "group" | "html" | "markdown" | "mcp-app" | "webpage" | "json-render" | "graph" | "board" | "prompt" | "response" | "status" | "context" | "ledger" | "trace" | "diff" | "mermaid" | "image">;
+export declare const EXPANDABLE_TYPES: Set<"image" | "board" | "file" | "markdown" | "mcp-app" | "webpage" | "json-render" | "graph" | "prompt" | "response" | "status" | "context" | "ledger" | "trace" | "diff" | "mermaid" | "html" | "group">;
 export declare const EXCALIDRAW_SERVER_NAME = "Excalidraw";
 export declare const EXCALIDRAW_CREATE_VIEW_TOOL = "create_view";
 export declare function isExcalidrawNode(node: CanvasNodeState): boolean;

package/dist/types/client/utils/keyboard.d.ts

@@ -0,0 +1,2 @@
+/** Overlays and text editors get Escape before the underlying view selection. */
+export declare function isSelectionEscape(event: KeyboardEvent): boolean;

package/dist/types/client/utils/time-ago.d.ts

@@ -0,0 +1,4 @@
+/** How long ago, compact: "just now", "5m", "3h", "2d". */
+export declare function age(iso: string): string;
+/** "just now", "5m ago", "3h ago", "2d ago". */
+export declare function timeAgo(iso: string): string;

package/dist/types/mcp/context-uri-template.d.ts

@@ -1,6 +1,8 @@
 import { UriTemplate } from '@modelcontextprotocol/sdk/shared/uriTemplate.js';
 /** SDK v1 matches {?a,b} as two required, ordered parameters, unlike its expansion. */
 export declare class ContextUriTemplate extends UriTemplate {
-    constructor();
+    private readonly host;
+    private readonly parameters;
+    constructor(host?: string, parameters?: string[]);
     match(uri: string): Record<string, string> | null;
 }