pmx-canvas 0.6.5 → 0.7.1

package/.github/extensions/pmx-canvas/extension.mjs

@@ -23,6 +23,10 @@ let managedWorkspaceRoot = null;
 let managedPort = null;
 const managedLogs = [];
 const panelServers = new Map();
+// Canvas actions are invoked separately from `open`, and their context can
+// omit the canvas input. Keep the server selected for each visible instance so
+// an action cannot fall back to the process/default port behind the panel.
+const panelTargets = new Map();
 
 function normalizeBaseUrl(value) {
     if (typeof value !== "string" || value.trim() === "") return null;
@@ -227,7 +231,7 @@ async function resolvePmxServer(ctxOrInput, options = {}) {
     const allowWorkspaceMismatch = input?.allowWorkspaceMismatch === true;
     for (const candidate of candidateBaseUrls(input)) {
         const probe = await probeServer(candidate.baseUrl, workspaceRoot, {
-            allowWorkspaceMismatch: candidate.explicit || allowWorkspaceMismatch,
+            allowWorkspaceMismatch,
         });
         if (probe.ok) return probe;
     }
@@ -245,6 +249,29 @@ async function resolvePmxServer(ctxOrInput, options = {}) {
     return await startManagedServer(workspaceRoot, input);
 }
 
+async function resolvePanelTarget(ctx, options = {}) {
+    const selected = panelTargets.get(ctx?.instanceId);
+    if (!selected) return await resolvePmxServer(ctx, options);
+
+    const probe = await probeServer(selected.baseUrl, selected.workspaceRoot, {
+        timeoutMs: options.timeoutMs ?? 2_000,
+    });
+    if (probe.ok) return probe;
+    return {
+        ...probe,
+        baseUrl: null,
+        error: `The displayed PMX Canvas target is no longer valid: ${probe.error ?? "health check failed"}. Action withheld.`,
+    };
+}
+
+function rememberPanelTarget(ctx, pmx) {
+    if (!ctx?.instanceId || !pmx?.ok || !pmx.baseUrl) return;
+    panelTargets.set(ctx.instanceId, {
+        baseUrl: pmx.baseUrl,
+        workspaceRoot: pmx.health.workspace,
+    });
+}
+
 function escapeHtml(value) {
     return String(value)
         .replaceAll("&", "&")
@@ -350,6 +377,19 @@ async function readRequestJson(req) {
     return JSON.parse(Buffer.concat(chunks).toString("utf8"));
 }
 
+async function verifiedEntryTarget(entry) {
+    if (!entry.pmx?.baseUrl) return { ok: false, baseUrl: null, error: "PMX Canvas server is unavailable." };
+    const probe = await probeServer(entry.pmx.baseUrl, entry.pmx.health.workspace, {
+        timeoutMs: 2_000,
+    });
+    if (probe.ok) return probe;
+    return {
+        ...probe,
+        baseUrl: null,
+        error: `The displayed PMX Canvas target is no longer valid: ${probe.error ?? "health check failed"}. Action withheld.`,
+    };
+}
+
 function jsonResponse(res, statusCode, body) {
     res.writeHead(statusCode, { "Content-Type": "application/json; charset=utf-8" });
     res.end(JSON.stringify(body));
@@ -377,13 +417,23 @@ async function startPanelServer(instanceId, ctx, pmx) {
                 return;
             }
             if (req.method === "GET" && url.pathname === "/context") {
-                const context = await getAxContext(entry.pmx?.baseUrl, entry.workspaceRoot, entry.input);
+                const target = await verifiedEntryTarget(entry);
+                if (!target.ok || !target.baseUrl) {
+                    jsonResponse(res, 409, target);
+                    return;
+                }
+                const context = await getAxContext(target.baseUrl, entry.workspaceRoot, entry.input);
                 jsonResponse(res, 200, context);
                 return;
             }
             if (req.method === "POST" && url.pathname === "/focus") {
                 const body = await readRequestJson(req);
-                const result = await setAxFocus(entry.pmx?.baseUrl, entry.workspaceRoot, entry.input, body.nodeIds);
+                const target = await verifiedEntryTarget(entry);
+                if (!target.ok || !target.baseUrl) {
+                    jsonResponse(res, 409, target);
+                    return;
+                }
+                const result = await setAxFocus(target.baseUrl, entry.workspaceRoot, entry.input, body.nodeIds);
                 jsonResponse(res, 200, result);
                 return;
             }
@@ -396,8 +446,9 @@ async function startPanelServer(instanceId, ctx, pmx) {
                 await copilotSession?.send({ prompt: body.prompt });
                 // Explicit user instruction from the panel → mirror onto the AX
                 // timeline as a steering message (fire-and-forget).
-                if (entry.pmx?.baseUrl) {
-                    void fetchJson(entry.pmx.baseUrl, "/api/canvas/ax/steer", {
+                const target = await verifiedEntryTarget(entry);
+                if (target.ok && target.baseUrl) {
+                    void fetchJson(target.baseUrl, "/api/canvas/ax/steer", {
                         method: "POST",
                         headers: { "Content-Type": "application/json" },
                         body: JSON.stringify({ message: body.prompt, source: "copilot" }),
@@ -418,18 +469,81 @@ async function startPanelServer(instanceId, ctx, pmx) {
     return { server, url: `http://127.0.0.1:${port}/`, entry };
 }
 
-async function getAxContext(baseUrl, workspaceRoot, input = {}) {
+async function getAxContext(baseUrl, workspaceRoot, input = {}, options = {}) {
     const resolved = baseUrl
         ? { ok: true, baseUrl }
         : await resolvePmxServer({ input, session: { workingDirectory: workspaceRoot } }, { autoStart: false });
     if (!resolved.ok || !resolved.baseUrl) {
         return { ok: false, error: resolved.error ?? "PMX Canvas server is unavailable." };
     }
-    return await fetchJson(resolved.baseUrl, "/api/canvas/ax/context", { timeoutMs: 2_000 });
+    // A proxied read is one this extension records itself with what it actually
+    // injected (after truncation), so the server does not record it again.
+    const headers = { "x-pmx-source": "copilot", ...(options.proxied ? { "x-pmx-proxied-read": "1" } : {}) };
+    return await fetchJson(resolved.baseUrl, "/api/canvas/ax/context", { headers, timeoutMs: 2_000 });
+}
+
+function deliveredPinnedIds(pinnedNodeIds, payloadText) {
+    const pinned = new Set(pinnedNodeIds);
+    const delivered = new Set();
+    const objectStarts = [];
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < payloadText.length; index += 1) {
+        const character = payloadText[index];
+        if (inString) {
+            if (escaped) escaped = false;
+            else if (character === "\\") escaped = true;
+            else if (character === '"') inString = false;
+            continue;
+        }
+        if (character === '"') {
+            inString = true;
+        } else if (character === "{") {
+            objectStarts.push(index);
+        } else if (character === "}" && objectStarts.length > 0) {
+            const start = objectStarts.pop();
+            try {
+                const value = JSON.parse(payloadText.slice(start, index + 1));
+                if (value && !Array.isArray(value) && typeof value === "object" &&
+                    Object.hasOwn(value, "id") && typeof value.id === "string" && pinned.has(value.id)) {
+                    delivered.add(value.id);
+                }
+            } catch {
+                // An inner object may be complete even when its containing object was clipped.
+            }
+        }
+    }
+    return pinnedNodeIds.filter((id) => delivered.has(id));
+}
+
+/** Records what the per-prompt hook injected, so delivery is measured on what Copilot received. */
+async function recordInjectedContext(baseUrl, context, injected) {
+    const pinnedNodeIds = Array.isArray(context?.pinned?.nodeIds) ? context.pinned.nodeIds : [];
+    const text = injected ?? "";
+    try {
+        await fetchJson(baseUrl, "/api/canvas/ax/context-reads", {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "x-pmx-source": "copilot" },
+            body: JSON.stringify({
+                channel: "adapter",
+                resource: "copilot:prompt-context",
+                source: "copilot",
+                consumer: "copilot",
+                boardId: context.boardId,
+                pinnedNodeIds,
+                // Same rule as the server (context-reads.ts): a node object with that id, not a bare id list.
+                deliveredNodeIds: deliveredPinnedIds(pinnedNodeIds, text),
+                bytes: Buffer.byteLength(text, "utf-8"),
+            }),
+            timeoutMs: 1_500,
+        });
+    } catch {
+        // Instrumentation must never block the prompt.
+    }
 }
 
 async function getAxStatus(ctx) {
-    const resolved = await resolvePmxServer(ctx, { autoStart: false });
+    const resolved = await resolvePanelTarget(ctx, { autoStart: false });
     if (!resolved.ok || !resolved.baseUrl) return { ok: false, server: resolved };
     const state = await fetchJson(resolved.baseUrl, "/api/canvas/ax", { timeoutMs: 2_000 });
     return { ok: true, server: resolved, ax: state };
@@ -454,7 +568,7 @@ async function setAxFocus(baseUrl, workspaceRoot, input = {}, nodeIds = []) {
 // Resolves the server first so the action returns an actionable error when the
 // canvas is unavailable, then maps the neutral primitive over plain HTTP.
 async function postAxRecord(ctx, path, payload) {
-    const resolved = await resolvePmxServer(ctx, { autoStart: false });
+    const resolved = await resolvePanelTarget(ctx, { autoStart: false });
     if (!resolved.ok || !resolved.baseUrl) {
         return { ok: false, error: resolved.error ?? "PMX Canvas server is unavailable." };
     }
@@ -562,7 +676,7 @@ function reportSteeringDeliveryError(error) {
 }
 
 async function getAxTimeline(ctx, limit) {
-    const resolved = await resolvePmxServer(ctx, { autoStart: false });
+    const resolved = await resolvePanelTarget(ctx, { autoStart: false });
     if (!resolved.ok || !resolved.baseUrl) return { ok: false, error: resolved.error };
     const query = typeof limit === "number" && limit > 0 ? `?limit=${limit}` : "";
     return await fetchJson(resolved.baseUrl, `/api/canvas/ax/timeline${query}`, { timeoutMs: 2_000 });
@@ -611,7 +725,7 @@ const pmxCanvas = createCanvas({
             name: "get_ax_context",
             description: "Return the current PMX Canvas AX pinned and focused context.",
             handler: async (ctx) => {
-                const resolved = await resolvePmxServer(ctx, { autoStart: false });
+                const resolved = await resolvePanelTarget(ctx, { autoStart: false });
                 if (!resolved.ok || !resolved.baseUrl) return { ok: false, error: resolved.error };
                 return await getAxContext(resolved.baseUrl, workspaceRootFrom(ctx), ctx.input ?? {});
             },
@@ -630,7 +744,13 @@ const pmxCanvas = createCanvas({
                 required: ["nodeIds"],
                 additionalProperties: false,
             },
-            handler: async (ctx) => await setAxFocus(null, workspaceRootFrom(ctx), ctx.input ?? {}, ctx.input?.nodeIds),
+            handler: async (ctx) => {
+                const resolved = await resolvePanelTarget(ctx, { autoStart: false });
+                if (!resolved.ok || !resolved.baseUrl) {
+                    throw new CanvasError("pmx_unavailable", resolved.error ?? "PMX Canvas server is unavailable.");
+                }
+                return await setAxFocus(resolved.baseUrl, workspaceRootFrom(ctx), ctx.input ?? {}, ctx.input?.nodeIds);
+            },
         },
         {
             name: "send_instruction",
@@ -772,7 +892,7 @@ const pmxCanvas = createCanvas({
                 additionalProperties: false,
             },
             handler: async (ctx) => {
-                const resolved = await resolvePmxServer(ctx, { autoStart: false });
+                const resolved = await resolvePanelTarget(ctx, { autoStart: false });
                 if (!resolved.ok || !resolved.baseUrl) {
                     return { ok: false, error: resolved.error ?? "PMX Canvas server is unavailable." };
                 }
@@ -800,6 +920,7 @@ const pmxCanvas = createCanvas({
         },
     ],
     open: async (ctx) => {
+        panelTargets.delete(ctx.instanceId);
         let pmx;
         try {
             pmx = await resolvePmxServer(ctx);
@@ -814,6 +935,7 @@ const pmxCanvas = createCanvas({
         }
 
         if (pmx.ok && pmx.baseUrl) {
+            rememberPanelTarget(ctx, pmx);
             const fallbackPanel = panelServers.get(ctx.instanceId);
             if (fallbackPanel) {
                 panelServers.delete(ctx.instanceId);
@@ -835,6 +957,7 @@ const pmxCanvas = createCanvas({
             panel.entry.workspaceRoot = workspaceRootFrom(ctx);
             panel.entry.input = ctx.input ?? {};
         }
+        rememberPanelTarget(ctx, pmx);
         return {
             title: "PMX Canvas",
             status: pmx.ok ? "Connected" : "Needs server",
@@ -842,6 +965,7 @@ const pmxCanvas = createCanvas({
         };
     },
     onClose: async (ctx) => {
+        panelTargets.delete(ctx.instanceId);
         const panel = panelServers.get(ctx.instanceId);
         if (!panel) return;
         panelServers.delete(ctx.instanceId);
@@ -860,8 +984,9 @@ copilotSession = await joinSession({
             void postPresence(workspaceRoot, { attached: true, phase: "thinking", detail: null });
             const resolved = await resolvePmxServer({ input: {}, session: { workingDirectory: workspaceRoot } }, { autoStart: false });
             if (!resolved.ok || !resolved.baseUrl) return undefined;
-            const context = await getAxContext(resolved.baseUrl, workspaceRoot, {});
+            const context = await getAxContext(resolved.baseUrl, workspaceRoot, {}, { proxied: true });
             const additionalContext = formatAdditionalContext(context, resolved.baseUrl);
+            void recordInjectedContext(resolved.baseUrl, context, additionalContext);
             return additionalContext ? { additionalContext } : undefined;
         },
     },

package/CHANGELOG.md

@@ -3,6 +3,76 @@
 All notable changes to `pmx-canvas` are documented here. This project follows
 [Semantic Versioning](https://semver.org/).
 
+## [Unreleased]
+
+## [0.7.1] - 2026-09-30
+
+### Fixed
+
+- Imported cards avoid existing content and multi-card imports form a group named after the source file.
+- Asking an agent to import now includes processing consent in one click; review actions have clearer buttons and a separate sticky footer.
+- Presentations support right-drag panning and a visible exit button; export Open and Download actions look like buttons.
+- Board navigation no longer reports removed cards or carries old session receipts onto Home.
+- Refused edits show their reason without a tooltip, keep the reason in Updates, and leave refused deletions visible.
+- Copilot panel actions use the displayed server and refuse writes if its workspace changes.
+- Inline batch JSON works with either spaced or equals-style flags.
+- CLI exports support an independent `--include-derived-text` opt-in and reject unknown flags.
+- Stopping from a different installation preserves live daemon PID files and reports the mismatch.
+- Daemon stop verifies the process on Windows and refuses to stop a live process whose installation cannot be verified.
+- Bundled skills include a retrievable tour reference, conditional browser-host checks, and eval scenarios for the new board and import workflows.
+
+## [0.7.0] - 2026-09-29
+
+### Highlights
+
+- Keep your work in named boards, organized into nested folders and connected by board links.
+- Search across your library and give agents source-labelled context from related boards.
+- Turn document attachments into reviewable Markdown using your connected agent's tools.
+- Share a board as a standalone HTML file and back up the whole library.
+
+### Breaking
+
+- The database migrates to multi-board storage and cannot be opened by older versions. Before downgrading, restore the automatic `canvas.db.pre-boards` copy or a pre-upgrade backup; changes made after migration are not in that copy.
+
+### Changed
+
+- The canvas database now stores many named boards. On first start your current board becomes a board named after the workspace, every old snapshot becomes a board of its own, and a copy of the old file is kept as `canvas.db.pre-boards` (older versions cannot open the migrated file).
+- Agent context and search now read chart values, diagram labels and structured card text instead of raw renderer configuration.
+- Questions, approvals and mode requests record who asked and answered them, including self-answers; this attribution describes the writer and does not grant permission.
+
+### Added
+
+- Sort boards into categories on Home; each category is its own section you can fold away, and boards migrated from old snapshots start in a folded "From old snapshots" section.
+- Export a board as one HTML file anyone can open without installing anything, from **Export** in the top bar or `pmx-canvas export`; the dialog lists what goes into the file first, and local file contents stay out unless you include them.
+- Back up every board with `pmx-canvas backup`, schedule server-run copies with `pmx-canvas backup schedule --every 24h`, and bring a backup back with `pmx-canvas restore` (the replaced file is kept); Home has no backup button.
+- The top bar shows the open board; click it to switch to a recent board, create a new one, or go Home, where you can open, rename, and delete boards (deleting asks first).
+- Agents can list, read and create boards with `canvas_board`, `canvas://boards`, `pmx-canvas board list|create|rename`, and the `/api/canvas/boards` routes; only you open, switch or delete a board.
+- Agent writes go to the board you have open; on Home, an agent's first write opens your most recent board, or creates one if there are none.
+- The canvas now records which context each agent reads and whether your pinned nodes were in it, readable with `pmx-canvas ax reads`, `canvas_ax_timeline { action: "reads" }`, or `GET /api/canvas/ax/context-reads`.
+- Designate a Markdown card as a board README, add text-only board-link cards, inspect outgoing links and backlinks, and search cards across the library without switching boards.
+- Preview and create an inactive board from selected reusable cards and optional groups/README; copied cards receive fresh IDs and omit pins, AX state and history.
+- Read a character-bounded cross-board brief with source IDs over MCP, HTTP, CLI or SDK; a durable cursor is used only when a stable consumer ID is supplied.
+- Attach PDF and Office originals up to 20 MiB, explicitly ask the connected agent to draft source-linked Markdown, and review it before adding it to the board; Canvas does not bundle conversion or launch an agent automatically.
+
+### Known limitations
+
+- Document extraction depends on the connected agent's available tools; remote byte transfer, OCR, unreadable charts, and some host formats may be unavailable.
+- A graph map, direct card-to-card edges across boards, and wiki-link syntax are not implemented.
+
+### Fixed
+
+- Snapshots can only be read, restored, renamed or deleted on their owning board.
+- Slow file imports no longer land on a board opened after the drop, and rapid board switches keep their intended order.
+- Recent boards remain correctly ordered when multiple opens happen within one millisecond.
+- HTTP board switching and deletion require the trusted workbench token, not just the UI marker.
+- `pmx-canvas pump` no longer crashes when its command exits without reading the steer; the exit code decides, as intended.
+- A change the server refuses in the browser now shows a toast with the reason instead of failing silently.
+- Webpage nodes refuse redirects that move a public page onto a private or loopback address, and never fetch link-local (cloud metadata) addresses.
+
+### Internal
+
+- The e2e gate now checks that every node type paints in a 600 px Chromium pane, the width of the agent-host panels the workbench lives in.
+
 ## [0.6.5] - 2026-09-26
 
 ### Added

package/Readme.md

@@ -41,6 +41,15 @@ in real time. Either side adds material; the human curates spatial structure
 `canvas://pinned-context` and acts on it. Spatial arrangement is
 communication — proximity means relatedness, pinning means *focus here*.
 
+The database holds many named boards. **Home is the library view, not a board**:
+it lists recent boards and nested category paths (up to eight 60-character
+segments). Empty folders are not independent objects; they exist only while a
+board is filed beneath them. Only a human opens/switches or deletes a board.
+Agents may list, read, create, rename, categorize, search, and create an inactive
+board from selected reusable cards without disturbing the board in view. Home
+provides a copy-preview dialog; an open board's command palette offers a
+board-link picker. Neither depends on native browser prompts.
+
 ## Main features
 
 ### 01 / Curate
@@ -73,6 +82,14 @@ the canvas is the union of its [built-in node types](docs/node-types.md) and
 **whatever your agent's harness already has access to** — MCP servers, CLIs,
 file reads, web fetch, anything on its toolbelt.
 
+Dropping a PDF or Office document attaches the original (up to 20 MiB). It does
+not bundle a converter or automatically launch an agent. Clicking **Ask agent to
+import** also authorizes processing by the connected host's tools/model provider;
+there is no separate consent confirmation. The agent returns Markdown sections
+with references and warnings for review. Multi-card imports are placed together
+in a free area, in a group named after the source file. Remote hosts may require
+manual transfer; OCR, charts, and host format support are not guaranteed.
+
 JSON-render panels support bound form state, nested repeats, watchers, and Card
 header/footer slots. Form edits remain viewer-local until explicitly submitted;
 see [JSON-render nodes](docs/node-types.md#json-render-nodes). Authored iframe cards
@@ -176,15 +193,21 @@ and the `pmx-canvas-orchestration` skill documents the choreography.
 
 Spatial state auto-saves to `.pmx-canvas/canvas.db` (debounced ~500 ms) —
 git-committable, shareable across machines, and survives both browser
-refresh and server restart. Named [snapshots](docs/mcp.md), full
+refresh and server restart. Autosave is not a backup: `pmx-canvas backup` and
+its optional server-run schedule copy the whole board library, while restore
+keeps the replaced database. Backup and scheduling are backend/CLI operations;
+there is no Home backup button. A board can also be exported as a self-contained
+HTML file. Export previews what is included, omits local file contents unless
+explicitly requested, and locks board-link cards because an exported file has
+no live target library (the target title is not embedded). Named [snapshots](docs/mcp.md), full
 undo/redo, and an auto-detected code graph (JS/TS, Python, Go, Rust) make
 the canvas durable rather than throwaway. Stop the server before committing
 the DB so SQLite WAL data is checkpointed into the file.
 
 ### 07 / Any agent
 
-Harness-agnostic. Drive the canvas from [MCP](docs/mcp.md) (22 tools,
-14 resources, change notifications), the [CLI](docs/cli.md), the
+Harness-agnostic. Drive the canvas from [MCP](docs/mcp.md) (24 tools,
+15 static canvas resources plus one context resource template, change notifications), the [CLI](docs/cli.md), the
 [HTTP API](docs/http-api.md), or the [Bun SDK](docs/sdk.md) — all
 [environment variables documented here](docs/environment.md). Works with
 Claude Code, the GitHub Copilot app and CLI, Codex, Amp, Cursor, Windsurf, or
@@ -223,7 +246,9 @@ surfaces (the core never imports a host SDK).
   session override), wakes Copilot when the board sends a steer, injects
   pinned/focused AX context on prompt submission, and exposes actions for focus,
   work items, approval gates, review annotations, the AX timeline, and
-  host-capability reporting. Install it into any repo with
+  host-capability reporting. Actions stay bound to the server shown by their
+  panel and are withheld if that server no longer matches the panel workspace.
+  Install it into any repo with
   `pmx-canvas copilot install-extension` (`--dry-run` to preview).
 - **Codex app** — native through the Codex in-app Browser (opened to
   `/workbench`) plus the PMX MCP server: agents read `canvas://ax-context` /
@@ -378,7 +403,7 @@ services:
 ```bash
 # .agents/setup — install the CLI (pin the exact version: a fresh orb running
 # @latest can silently pick up a newer release than the one you validated)
-npm install -g pmx-canvas@0.6.5
+npm install -g pmx-canvas@0.7.1
 ```
 
 The server binds the portal-assigned `$PORT` automatically (gated on the
@@ -444,7 +469,8 @@ paths, screenshots, or logs are attached automatically.
   the three-tier visual matrix (json-render → html → web-artifact)
 - **[CLI reference](docs/cli.md)** — full command surface, daemon mode,
   watch streams, WebView automation
-- **[MCP reference](docs/mcp.md)** — 22 tools, 14 core resources plus bundled
+- **[MCP reference](docs/mcp.md)** — 24 tools, 15 static canvas resources, one
+  context resource template, plus bundled
   skill resources, Skills extension, change notifications, node-type routing
 - **[HTTP API](docs/http-api.md)** — REST endpoints, SSE, batch operations
 - **[AX host-adapter contract](docs/ax-host-adapter-contract.md)** — how native