pmx-canvas 0.7.0 → 0.7.2

package/src/server/operations/ops/ax-presence.ts

@@ -27,13 +27,17 @@ const presenceGetOperation = defineOperation<z.infer<typeof emptySchema>, Record
 // One schema (agent-presence.ts) — only the descriptions are added here.
 const presenceSetShape = {
   source: PRESENCE_SET_SHAPE.source.describe('Host label (copilot, codex, mcp, …); defaults to the transport'),
-  agentId: PRESENCE_SET_SHAPE.agentId.describe('Per-agent identity within the host (sub-agents keep their own cursor)'),
-  label: PRESENCE_SET_SHAPE.label.describe('Display name for this writer'),
+  agentId: PRESENCE_SET_SHAPE.agentId.describe(
+    'Stable identity for a genuinely separate agent, not a task name. Omit for the main agent when a host adapter already owns its session.',
+  ),
+  label: PRESENCE_SET_SHAPE.label.describe('Display name for this writer; use detail for the current task'),
   phase: PRESENCE_SET_SHAPE.phase.describe('idle | thinking | tooling | waiting-approval'),
   detail: PRESENCE_SET_SHAPE.detail.describe('Tool / step name shown beside the phase'),
   focusNodeId: PRESENCE_SET_SHAPE.focusNodeId.describe('Node the agent is working on'),
   cursor: PRESENCE_SET_SHAPE.cursor.describe('Agent cursor in world coordinates'),
-  attached: PRESENCE_SET_SHAPE.attached.describe('true attaches a session (Focus Session chrome); false detaches it'),
+  attached: PRESENCE_SET_SHAPE.attached.describe(
+    'true attaches a session; false detaches it. Read presence first and reuse your host adapter session instead of attaching another. Only detach sessions you own.',
+  ),
   contextUsage: PRESENCE_SET_SHAPE.contextUsage.describe(
     "The agent's real token window as {used,total} — shown on the board's context meter instead of the pinned-context estimate (null clears it)",
   ),

package/src/server/operations/ops/boards.ts

@@ -2,9 +2,9 @@
  * Many boards (plan 012): board.list / board.get / board.create /
  * board.update / board.open / board.delete.
  *
- * Agents list, read and create boards. Opening, switching and deleting are the
- * human's (HUMAN_ONLY_OPS in registry.ts): an agent that wants another board
- * asks. Every change broadcasts `boards-changed` with the full list.
+ * Agents can explicitly open boards as well as list, read and create them.
+ * Deletion requires the human (HUMAN_ONLY_OPS in registry.ts).
+ * Every change broadcasts `boards-changed` with the full list.
  *
  * Route-order note: board.open (POST /api/canvas/boards/open) is registered
  * before any `/api/canvas/boards/:id` POST route so ':id' cannot swallow it.
@@ -171,7 +171,7 @@ const boardCreateOperation = defineOperation<z.infer<typeof createSchema>, Recor
   mcp: {
     toolName: 'canvas_create_board',
     description:
-      'Create a new empty board. It is NOT opened: only the human opens boards, so ask them to open it before writing to it.',
+      'Create a new empty board without opening it. Use canvas_board action "open" with the returned board id before writing to it.',
     extraShape: {
       name: z.string().describe('Board name'),
       category: z.string().optional().describe('Folder path on Home, e.g. Engineering/Canvas'),
@@ -186,7 +186,7 @@ const boardCreateOperation = defineOperation<z.infer<typeof createSchema>, Recor
   },
 });
 
-// ── board.open (human only) ───────────────────────────────────
+// ── board.open ────────────────────────────────────────────────
 
 const openShape = {
   id: z.unknown().optional().describe('Board id to open; null or omitted opens Home'),
@@ -199,6 +199,13 @@ const boardOpenOperation = defineOperation<z.infer<typeof openSchema>, Record<st
   input: openSchema,
   inputShape: openShape,
   http: { method: 'POST', path: '/api/canvas/boards/open' },
+  mcp: {
+    toolName: 'canvas_open_board',
+    description:
+      'Open a board in the shared workbench, or Home with null. Changes the visible board and the target of subsequent writes. Verify activeBoardId in the response before authoring.',
+    extraShape: { id: z.string().nullable().optional().describe('Board id to open; null or omitted opens Home') },
+    formatResult: jsonResult,
+  },
   handler: (input, ctx) => {
     const id = typeof input.id === 'string' && input.id.trim() ? input.id.trim() : null;
     if (!openCanvasBoard(id).ok) throw new OperationError(`Board "${id}" not found.`, 404);

package/src/server/operations/ops/imports.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { canvasState } from '../../canvas-state.js';
-import { addCanvasNode } from '../../canvas-operations.js';
+import { addCanvasNode, createCanvasGroup } from '../../canvas-operations.js';
+import { findOpenCanvasPosition, overlapsAny } from '../../../shared/placement.js';
+import { GROUP_PAD, GROUP_TITLEBAR_HEIGHT } from '../../placement.js';
 import {
   MAX_IMPORT_AGENT_DESCRIPTION_LENGTH,
   MAX_IMPORT_REASON_LENGTH,
@@ -192,6 +194,17 @@ const commit = defineOperation({
       throw new OperationError('Open the captured source board before committing this import.', 409);
     const a = canvasState.getAttachment(job.attachmentId);
     if (!a) throw new OperationError('Attachment not found.', 404);
+    const grouped = job.sections.length > 1;
+    const padX = grouped ? GROUP_PAD : 0;
+    const padY = grouped ? GROUP_PAD + GROUP_TITLEBAR_HEIGHT : 0;
+    const width = Math.min(job.sections.length, 2) * 440 - 40 + padX * 2;
+    const height = Math.ceil(job.sections.length / 2) * 340 - 60 + padY + padX;
+    // Reserve the whole grid, including its group frame, against current board
+    // geometry. Another import or edit may have occupied the drop-time anchor.
+    const obstacles = canvasState.getLayout().nodes;
+    const origin = overlapsAny(job.position, width, height, obstacles, 48)
+      ? findOpenCanvasPosition(obstacles, width, height, 48)
+      : job.position;
     const nodeIds = job.sections.map(
       (s, index) =>
         addCanvasNode({
@@ -201,17 +214,20 @@ const commit = defineOperation({
           data: {
             source: { attachmentId: a.id, filename: a.name, ...(s.reference ? { reference: s.reference } : {}) },
           },
-          x: job.position.x + (index % 2) * 440,
-          y: job.position.y + Math.floor(index / 2) * 340,
+          x: origin.x + padX + (index % 2) * 440,
+          y: origin.y + padY + Math.floor(index / 2) * 340,
           defaultWidth: 400,
           defaultHeight: 280,
           fileMode: 'auto',
         }).id,
     );
+    let groupId: string | undefined;
     try {
+      if (grouped) groupId = createCanvasGroup({ title: a.name, childIds: nodeIds }).id;
       const committed = canvasState.commitDocumentImport(i.id, nodeIds);
       return { ok: true, nodeIds, import: committed };
     } catch (error) {
+      if (groupId) canvasState.removeNode(groupId);
       for (const nodeId of nodeIds) canvasState.removeNode(nodeId);
       throw error;
     }

package/src/server/operations/registry.ts

@@ -405,15 +405,9 @@ export async function executeOperation(
   );
 }
 
-/** Opening, switching and deleting boards is the human's; an agent asks for another board. */
-const HUMAN_ONLY_OPS = new Set(['board.open', 'board.delete', 'import.request', 'import.cancel', 'import.commit']);
-const TRUSTED_HUMAN_ONLY_OPS = new Set([
-  'board.open',
-  'board.delete',
-  'import.request',
-  'import.cancel',
-  'import.commit',
-]);
+/** Board deletion and import review actions require the human in the workbench. */
+const HUMAN_ONLY_OPS = new Set(['board.delete', 'import.request', 'import.cancel', 'import.commit']);
+const TRUSTED_HUMAN_ONLY_OPS = new Set(['board.delete', 'import.request', 'import.cancel', 'import.commit']);
 
 /**
  * Writes that need a board beyond the layout mutations: canvas-bound AX items,
@@ -443,10 +437,7 @@ function needsOpenBoard(op: Operation): boolean {
 async function executeOperationInner(name: string, rawInput: unknown, meta: ExecuteOperationMeta): Promise<unknown> {
   const op = getOperation(name);
   if (HUMAN_ONLY_OPS.has(name) && !meta.fromWorkbench) {
-    throw new OperationError(
-      'Only the human opens or deletes boards. Ask them in the chat to open the board you need.',
-      403,
-    );
+    throw new OperationError('This action requires the human in the workbench.', 403);
   }
   if (TRUSTED_HUMAN_ONLY_OPS.has(name) && !meta.humanAuthor) {
     throw new OperationError('This action requires trusted human authority.', 403);

package/src/server/server.ts

@@ -61,6 +61,7 @@ import { normalizeExtAppToolResult } from './ext-app-tool-result.js';
 import { getMcpAppHostSnapshot } from './mcp-app-host.js';
 import { closeMcpAppSession, closeAllMcpAppSessions } from './mcp-app-runtime.js';
 import { findOpenCanvasPosition } from './placement.js';
+import { overlapsAny } from '../shared/placement.js';
 import { mutationHistory } from './mutation-history.js';
 import { buildAgentContextPreamble } from './agent-context.js';
 import { buildCanvasAxSurfaceSnapshot } from './ax-context.js';
@@ -3474,19 +3475,25 @@ export function startCanvasServer(options: CanvasServerOptions = {}): string | n
               canvasState.storeAttachment({ boardId, name, mime, bytes }),
             );
             if (!attachment) return responseJson({ ok: false, error: 'Board not found.' }, 404);
+            const obstacles = canvasState.getLayout().nodes;
+            const position = overlapsAny({ x, y }, 440, 360, obstacles, 48)
+              ? findOpenCanvasPosition(obstacles, 440, 360, 48)
+              : { x, y };
             const { node } = withCurrentActor({ actor: 'human', source: 'browser' }, () =>
               addCanvasNode({
                 type: 'file',
                 title: name,
                 data: { attachmentId: attachment.id, mime, size: attachment.size },
-                x,
-                y,
+                ...position,
                 defaultWidth: 440,
                 defaultHeight: 360,
                 fileMode: 'auto',
               }),
             );
-            const created = canvasState.createDocumentImport(attachment.id, { x, y: y + 400 });
+            const created = canvasState.createDocumentImport(attachment.id, {
+              x: node.position.x,
+              y: node.position.y + 400,
+            });
             const documentImport = created;
             emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
             return responseJson({ ok: true, attachment, nodeId: node.id, import: documentImport }, 201);

package/src/shared/delimited-text.ts

@@ -0,0 +1,75 @@
+export interface DelimitedTable {
+  header: string[];
+  /** Rectangular: every row padded (short) or truncated (long) to the header width. */
+  rows: string[][];
+}
+
+/** Column delimiter for a delimited-data path, or null when the file is not one. */
+export function delimiterForPath(path: string): string | null {
+  const lower = path.toLowerCase();
+  if (lower.endsWith('.csv')) return ',';
+  if (lower.endsWith('.tsv')) return '\t';
+  return null;
+}
+
+/**
+ * RFC4180-ish delimited-text parser. Quoted fields may contain the delimiter,
+ * newlines, and `""` escapes; CRLF, LF and lone CR all end a record; a trailing
+ * newline produces no phantom empty row. Ragged records are squared off against
+ * the header width instead of throwing.
+ */
+export function parseDelimitedText(text: string, delimiter: string): DelimitedTable {
+  const records: string[][] = [];
+  let row: string[] = [];
+  let field = '';
+  let quoted = false;
+  // Tracks whether the current record consumed anything — distinguishes a real
+  // empty-quoted record from the dangling state after a terminating newline.
+  let started = false;
+
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    started = true;
+    if (quoted) {
+      if (char === '"') {
+        if (text[i + 1] === '"') {
+          field += '"';
+          i++;
+        } else {
+          quoted = false;
+        }
+      } else if (char === '\r' && text[i + 1] === '\n') {
+        field += '\n';
+        i++;
+      } else {
+        field += char;
+      }
+      continue;
+    }
+    if (char === '"' && field === '') {
+      quoted = true;
+    } else if (char === delimiter) {
+      row.push(field);
+      field = '';
+    } else if (char === '\n' || char === '\r') {
+      if (char === '\r' && text[i + 1] === '\n') i++;
+      row.push(field);
+      field = '';
+      records.push(row);
+      row = [];
+      started = false;
+    } else {
+      field += char;
+    }
+  }
+  if (started) {
+    row.push(field);
+    records.push(row);
+  }
+
+  const header = records.shift() ?? [];
+  return {
+    header,
+    rows: records.map((record) => Array.from({ length: header.length }, (_, i) => record[i] ?? '')),
+  };
+}