@agent-canvas/cli 0.10.0 → 0.12.0

package/dist/commands/__tests__/create-folder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/__tests__/create-folder.test.js

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createFolder } from '../create-folder';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true, category: { id: 'cat-1', name: 'Test', isCollapsed: false, order: 0 } })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('createFolder', () => {
+    describe('parameter assembly', () => {
+        it('should send correct params with folder name', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, category: { id: 'cat-1', name: 'My Folder', isCollapsed: false, order: 0 } }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await createFolder({ name: 'My Folder' }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'createFolder',
+                id: 'test-id',
+                params: { name: 'My Folder' },
+            }));
+        });
+    });
+    describe('response handling', () => {
+        it('should log success message on success', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                category: { id: 'cat-1', name: 'My Folder', isCollapsed: false, order: 0 },
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await createFolder({ name: 'My Folder' }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Folder "My Folder" created');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Folder already exists',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await createFolder({ name: 'Test' }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Folder already exists');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true, category: { id: 'cat-1', name: 'Test', isCollapsed: false, order: 0 } }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await createFolder({ name: 'Test' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after failure', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: false, error: 'error' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await createFolder({ name: 'Test' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/delete-folder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/__tests__/delete-folder.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect, vi } from 'vitest';
+import { deleteFolder } from '../delete-folder';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('deleteFolder', () => {
+    describe('parameter assembly', () => {
+        it('should send correct params with folder name', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await deleteFolder({ name: 'My Folder' }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'deleteFolder',
+                id: 'test-id',
+                params: { name: 'My Folder' },
+            }));
+        });
+    });
+    describe('response handling', () => {
+        it('should log success message on success', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await deleteFolder({ name: 'My Folder' }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Folder "My Folder" deleted');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Folder not found',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await deleteFolder({ name: 'Test' }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Folder not found');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await deleteFolder({ name: 'Test' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after failure', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: false, error: 'error' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await deleteFolder({ name: 'Test' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/__tests__/list.test.js

@@ -76,6 +76,77 @@ describe('list', () => {
             expect(lines[1]).toContain('(updated:');
         });
     });
+    describe('folder display', () => {
+        it('should display canvases grouped by folder when categories exist', () => {
+            const lines = formatCanvasList({
+                canvases: [
+                    { id: 'c1', name: 'Canvas A', createdAt: 1000, updatedAt: 2000 },
+                    { id: 'c2', name: 'Canvas B', createdAt: 1000, updatedAt: 3000 },
+                ],
+                categories: [
+                    { id: 'cat-1', name: 'Work', isCollapsed: false, order: 0 },
+                ],
+                canvasCategoryMap: { 'c1': 'cat-1' },
+            });
+            expect(lines).toContain('  [F] Work (1)');
+            const ungroupedLine = lines.find(l => l.includes('Ungrouped'));
+            expect(ungroupedLine).toContain('(1)');
+        });
+        it('should sort folders by order', () => {
+            const lines = formatCanvasList({
+                canvases: [
+                    { id: 'c1', name: 'Canvas A', createdAt: 1000, updatedAt: 2000 },
+                    { id: 'c2', name: 'Canvas B', createdAt: 1000, updatedAt: 3000 },
+                ],
+                categories: [
+                    { id: 'cat-2', name: 'Zebra', isCollapsed: false, order: 1 },
+                    { id: 'cat-1', name: 'Alpha', isCollapsed: false, order: 0 },
+                ],
+                canvasCategoryMap: { 'c1': 'cat-1', 'c2': 'cat-2' },
+            });
+            const alphaIdx = lines.findIndex(l => l.includes('Alpha'));
+            const zebraIdx = lines.findIndex(l => l.includes('Zebra'));
+            expect(alphaIdx).toBeLessThan(zebraIdx);
+        });
+        it('should indent canvases inside folders', () => {
+            const lines = formatCanvasList({
+                canvases: [
+                    { id: 'c1', name: 'Canvas A', createdAt: 1000, updatedAt: 2000 },
+                ],
+                categories: [
+                    { id: 'cat-1', name: 'Work', isCollapsed: false, order: 0 },
+                ],
+                canvasCategoryMap: { 'c1': 'cat-1' },
+            });
+            const canvasLine = lines.find(l => l.includes('Canvas A'));
+            expect(canvasLine).toMatch(/^    /);
+        });
+        it('should not show ungrouped section when all canvases are categorized', () => {
+            const lines = formatCanvasList({
+                canvases: [
+                    { id: 'c1', name: 'Canvas A', createdAt: 1000, updatedAt: 2000 },
+                ],
+                categories: [
+                    { id: 'cat-1', name: 'Work', isCollapsed: false, order: 0 },
+                ],
+                canvasCategoryMap: { 'c1': 'cat-1' },
+            });
+            const ungroupedLine = lines.find(l => l.includes('Ungrouped'));
+            expect(ungroupedLine).toBeUndefined();
+        });
+        it('should fall back to flat list when no categories', () => {
+            const lines = formatCanvasList({
+                canvases: [
+                    { id: 'c1', name: 'Canvas A', createdAt: 1000, updatedAt: 2000 },
+                    { id: 'c2', name: 'Canvas B', createdAt: 1000, updatedAt: 3000 },
+                ],
+                categories: [],
+                canvasCategoryMap: {},
+            });
+            expect(lines).toHaveLength(3);
+            expect(lines.find(l => l.includes('[F]'))).toBeUndefined();
+        });
+    });
     // ==================== Response Handling Tests ====================
     describe('response handling', () => {
         it('should log each formatted line on success', async () => {
@@ -130,5 +201,24 @@ describe('list', () => {
             await list(deps);
             expect(mockClose).toHaveBeenCalled();
         });
+        it('should pass categories and canvasCategoryMap from response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: true,
+                activeCanvasId: 'c1',
+                canvases: [
+                    { id: 'c1', name: 'Canvas A', createdAt: 1000, updatedAt: 2000 },
+                ],
+                categories: [
+                    { id: 'cat-1', name: 'Work', isCollapsed: false, order: 0 },
+                ],
+                canvasCategoryMap: { 'c1': 'cat-1' },
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await list(deps);
+            expect(deps.log).toHaveBeenCalledWith(expect.stringContaining('[F] Work'));
+        });
     });
 });

package/dist/commands/__tests__/move-to-folder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/__tests__/move-to-folder.test.js

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi } from 'vitest';
+import { moveToFolder } from '../move-to-folder';
+function createMockClient(sendFn) {
+    return {
+        send: sendFn ?? vi.fn(() => Promise.resolve({ success: true })),
+        close: vi.fn(),
+    };
+}
+function createMockDeps(overrides) {
+    return {
+        connectToCanvas: vi.fn(() => Promise.resolve(createMockClient())),
+        generateId: vi.fn(() => 'test-id'),
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+        ...overrides,
+    };
+}
+describe('moveToFolder', () => {
+    describe('parameter assembly', () => {
+        it('should send correct params when moving to a folder', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await moveToFolder({ canvasName: 'My Canvas', folderName: 'My Folder' }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                type: 'moveCanvasToFolder',
+                id: 'test-id',
+                params: { canvasName: 'My Canvas', folderName: 'My Folder' },
+            }));
+        });
+        it('should send null folderName when moving to ungrouped', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await moveToFolder({ canvasName: 'My Canvas', folderName: null }, deps);
+            expect(mockSend).toHaveBeenCalledWith(expect.objectContaining({
+                params: { canvasName: 'My Canvas', folderName: null },
+            }));
+        });
+    });
+    describe('response handling', () => {
+        it('should log success message when moved to folder', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await moveToFolder({ canvasName: 'My Canvas', folderName: 'My Folder' }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Canvas "My Canvas" moved to folder "My Folder"');
+        });
+        it('should log ungrouped message when folderName is null', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({ success: true }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await moveToFolder({ canvasName: 'My Canvas', folderName: null }, deps);
+            expect(deps.log).toHaveBeenCalledWith('Canvas "My Canvas" moved to ungrouped');
+        });
+        it('should error and exit on failure response', async () => {
+            const mockSend = vi.fn(() => Promise.resolve({
+                success: false,
+                error: 'Canvas not found',
+            }));
+            const mockClient = createMockClient(mockSend);
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await moveToFolder({ canvasName: 'Test', folderName: 'Folder' }, deps);
+            expect(deps.error).toHaveBeenCalledWith('Failed: Canvas not found');
+            expect(deps.exit).toHaveBeenCalledWith(1);
+        });
+        it('should close client after success', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: true }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await moveToFolder({ canvasName: 'Test', folderName: 'Folder' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+        it('should close client after failure', async () => {
+            const mockClose = vi.fn();
+            const mockSend = vi.fn(() => Promise.resolve({ success: false, error: 'error' }));
+            const mockClient = { send: mockSend, close: mockClose };
+            const deps = createMockDeps({
+                connectToCanvas: vi.fn(() => Promise.resolve(mockClient)),
+            });
+            await moveToFolder({ canvasName: 'Test', folderName: 'Folder' }, deps);
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/add-arrow.d.ts

@@ -11,6 +11,7 @@ export interface AddArrowOptions {
     arrowType?: 'sharp' | 'round' | 'elbow';
     via?: string;
     note?: string;
+    animated?: boolean;
 }
 export interface ArrowClient {
     send: <T>(request: {

package/dist/commands/add-arrow.js

@@ -35,6 +35,7 @@ export async function addArrow(options, deps = defaultDeps) {
         arrowType: options.arrowType,
         midpoints,
         customData: options.note ? { note: options.note } : undefined,
+        animated: options.animated,
     };
     const result = await client.send({
         type: 'addArrow',

package/dist/commands/add-line.d.ts

@@ -7,6 +7,7 @@ export interface AddLineOptions {
     strokeWidth?: number;
     strokeStyle?: 'solid' | 'dashed' | 'dotted';
     note?: string;
+    animated?: boolean;
 }
 export interface LineClient {
     send: <T>(request: {

package/dist/commands/add-line.js

@@ -18,6 +18,7 @@ export async function addLine(options, deps = defaultDeps) {
         strokeWidth: options.strokeWidth,
         strokeStyle: options.strokeStyle,
         customData: options.note ? { note: options.note } : undefined,
+        animated: options.animated,
     };
     const result = await client.send({
         type: 'addLine',

package/dist/commands/add-polygon.d.ts

@@ -6,6 +6,7 @@ export interface AddPolygonOptions {
     strokeStyle?: 'solid' | 'dashed' | 'dotted';
     fillStyle?: 'hachure' | 'cross-hatch' | 'solid' | 'zigzag';
     note?: string;
+    animated?: boolean;
 }
 export interface PolygonClient {
     send: <T>(request: {

package/dist/commands/add-polygon.js

@@ -27,6 +27,7 @@ export async function addPolygon(options, deps = defaultDeps) {
         strokeStyle: options.strokeStyle,
         fillStyle: options.fillStyle,
         customData: options.note ? { note: options.note } : undefined,
+        animated: options.animated,
     };
     const result = await client.send({
         type: 'addPolygon',

package/dist/commands/add-shape.d.ts

@@ -13,6 +13,7 @@ export interface AddShapeOptions {
     labelFontSize?: number;
     labelStrokeColor?: string;
     note?: string;
+    animated?: boolean;
 }
 export interface ShapeClient {
     send: <T>(request: {

package/dist/commands/add-shape.js

@@ -21,6 +21,7 @@ export async function addShape(options, deps = defaultDeps) {
         strokeStyle: options.strokeStyle,
         fillStyle: options.fillStyle,
         customData: options.note ? { note: options.note } : undefined,
+        animated: options.animated,
     };
     if (options.label) {
         params.label = {

package/dist/commands/add-text.d.ts

@@ -8,6 +8,7 @@ export interface AddTextOptions {
     anchor?: TextAnchor;
     strokeColor?: string;
     note?: string;
+    animated?: boolean;
 }
 export interface TextClient {
     send: <T>(request: {

package/dist/commands/add-text.js

@@ -18,6 +18,7 @@ export async function addText(options, deps = defaultDeps) {
         anchor: options.anchor,
         strokeColor: options.strokeColor,
         customData: options.note ? { note: options.note } : undefined,
+        animated: options.animated,
     };
     const result = await client.send({
         type: 'addText',

package/dist/commands/create-folder.d.ts

@@ -0,0 +1,20 @@
+export interface CreateFolderOptions {
+    name: string;
+}
+export interface CreateFolderClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface CreateFolderDeps {
+    connectToCanvas: () => Promise<CreateFolderClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: CreateFolderDeps;
+export declare function createFolder(options: CreateFolderOptions, deps?: CreateFolderDeps): Promise<void>;

package/dist/commands/create-folder.js

@@ -0,0 +1,24 @@
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function createFolder(options, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    const result = await client.send({
+        type: 'createFolder',
+        id: deps.generateId(),
+        params: { name: options.name },
+    });
+    if (result.success && result.category) {
+        deps.log(`Folder "${result.category.name}" created`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/delete-folder.d.ts

@@ -0,0 +1,20 @@
+export interface DeleteFolderOptions {
+    name: string;
+}
+export interface DeleteFolderClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface DeleteFolderDeps {
+    connectToCanvas: () => Promise<DeleteFolderClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: DeleteFolderDeps;
+export declare function deleteFolder(options: DeleteFolderOptions, deps?: DeleteFolderDeps): Promise<void>;

package/dist/commands/delete-folder.js

@@ -0,0 +1,24 @@
+import { connectToCanvas, generateId } from '../lib/ws-client.js';
+export const defaultDeps = {
+    connectToCanvas,
+    generateId,
+    log: console.log,
+    error: console.error,
+    exit: process.exit,
+};
+export async function deleteFolder(options, deps = defaultDeps) {
+    const client = await deps.connectToCanvas();
+    const result = await client.send({
+        type: 'deleteFolder',
+        id: deps.generateId(),
+        params: { name: options.name },
+    });
+    if (result.success) {
+        deps.log(`Folder "${options.name}" deleted`);
+    }
+    else {
+        deps.error(`Failed: ${result.error}`);
+        deps.exit(1);
+    }
+    client.close();
+}

package/dist/commands/list.d.ts

@@ -1,4 +1,4 @@
-import type { CanvasMetadata } from '../lib/protocol.js';
+import type { CanvasMetadata, CanvasCategory } from '../lib/protocol.js';
 export interface ListClient {
     send: <T>(request: {
         type: string;
@@ -18,6 +18,8 @@ export interface ListResult {
     activeCanvasId?: string;
     agentActiveCanvasId?: string;
     canvases: CanvasMetadata[];
+    categories?: CanvasCategory[];
+    canvasCategoryMap?: Record<string, string>;
 }
 export declare function formatCanvasList(result: ListResult): string[];
 export declare function list(deps?: ListDeps): Promise<void>;

package/dist/commands/list.js

@@ -6,23 +6,47 @@ export const defaultDeps = {
     error: console.error,
     exit: process.exit,
 };
+function getMarker(canvas, activeCanvasId, agentActiveCanvasId) {
+    const isUser = canvas.id === activeCanvasId;
+    const isAgent = canvas.id === agentActiveCanvasId;
+    if (isUser && isAgent)
+        return '[UA]';
+    if (isUser)
+        return '[U] ';
+    if (isAgent)
+        return '[A] ';
+    return '    ';
+}
+function formatCanvasLine(canvas, activeCanvasId, agentActiveCanvasId, indent = '') {
+    const marker = getMarker(canvas, activeCanvasId, agentActiveCanvasId);
+    const date = new Date(canvas.updatedAt).toLocaleString();
+    return `${indent}${marker} ${canvas.name} (updated: ${date})`;
+}
 export function formatCanvasList(result) {
     const lines = ['Canvases: ([U]=User [A]=Agent)'];
-    for (const canvas of result.canvases) {
-        const isUser = canvas.id === result.activeCanvasId;
-        const isAgent = canvas.id === result.agentActiveCanvasId;
-        let marker = '    ';
-        if (isUser && isAgent) {
-            marker = '[UA]';
+    const categories = result.categories || [];
+    const categoryMap = result.canvasCategoryMap || {};
+    if (categories.length === 0) {
+        for (const canvas of result.canvases) {
+            lines.push(formatCanvasLine(canvas, result.activeCanvasId, result.agentActiveCanvasId));
         }
-        else if (isUser) {
-            marker = '[U] ';
+        return lines;
+    }
+    const categorizedCanvasIds = new Set(Object.keys(categoryMap));
+    const sorted = [...categories].sort((a, b) => a.order - b.order);
+    for (const cat of sorted) {
+        const catCanvases = result.canvases.filter(c => categoryMap[c.id] === cat.id);
+        lines.push(`  [F] ${cat.name} (${catCanvases.length})`);
+        for (const canvas of catCanvases) {
+            lines.push(formatCanvasLine(canvas, result.activeCanvasId, result.agentActiveCanvasId, '    '));
         }
-        else if (isAgent) {
-            marker = '[A] ';
+    }
+    const ungrouped = result.canvases.filter(c => !categorizedCanvasIds.has(c.id));
+    if (ungrouped.length > 0) {
+        lines.push(`  Ungrouped (${ungrouped.length})`);
+        for (const canvas of ungrouped) {
+            lines.push(formatCanvasLine(canvas, result.activeCanvasId, result.agentActiveCanvasId, '    '));
         }
-        const date = new Date(canvas.updatedAt).toLocaleString();
-        lines.push(`${marker} ${canvas.name} (updated: ${date})`);
     }
     return lines;
 }
@@ -37,6 +61,8 @@ export async function list(deps = defaultDeps) {
             activeCanvasId: result.activeCanvasId,
             agentActiveCanvasId: result.agentActiveCanvasId,
             canvases: result.canvases,
+            categories: result.categories,
+            canvasCategoryMap: result.canvasCategoryMap,
         });
         for (const line of lines) {
             deps.log(line);

package/dist/commands/move-to-folder.d.ts

@@ -0,0 +1,21 @@
+export interface MoveToFolderOptions {
+    canvasName: string;
+    folderName: string | null;
+}
+export interface MoveToFolderClient {
+    send: <T>(request: {
+        type: string;
+        id: string;
+        params?: unknown;
+    }) => Promise<T>;
+    close: () => void;
+}
+export interface MoveToFolderDeps {
+    connectToCanvas: () => Promise<MoveToFolderClient>;
+    generateId: () => string;
+    log: (msg: string) => void;
+    error: (msg: string) => void;
+    exit: (code: number) => never | void;
+}
+export declare const defaultDeps: MoveToFolderDeps;
+export declare function moveToFolder(options: MoveToFolderOptions, deps?: MoveToFolderDeps): Promise<void>;