@dexto/tools-plan 1.5.7

package/dist/tools/plan-create-tool.test.js

@@ -0,0 +1,118 @@
+/**
+ * Plan Create Tool Tests
+ *
+ * Tests for the plan_create tool including preview generation.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import { createPlanCreateTool } from './plan-create-tool.js';
+import { PlanService } from '../plan-service.js';
+import { PlanErrorCode } from '../errors.js';
+import { DextoRuntimeError } from '@dexto/core';
+// Create mock logger
+const createMockLogger = () => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    createChild: vi.fn().mockReturnThis(),
+});
+describe('plan_create tool', () => {
+    let mockLogger;
+    let tempDir;
+    let planService;
+    beforeEach(async () => {
+        mockLogger = createMockLogger();
+        // Create temp directory for testing
+        const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dexto-plan-create-test-'));
+        tempDir = await fs.realpath(rawTempDir);
+        planService = new PlanService({ basePath: tempDir }, mockLogger);
+        vi.clearAllMocks();
+    });
+    afterEach(async () => {
+        try {
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    describe('generatePreview', () => {
+        it('should return FileDisplayData for new plan', async () => {
+            const tool = createPlanCreateTool(planService);
+            const sessionId = 'test-session';
+            const content = '# Implementation Plan\n\n## Steps\n1. First step';
+            const preview = (await tool.generatePreview({ title: 'Test Plan', content }, { sessionId }));
+            expect(preview.type).toBe('file');
+            expect(preview.operation).toBe('create');
+            // Path is now absolute, check it ends with the expected suffix
+            expect(preview.path).toContain(sessionId);
+            expect(preview.path).toMatch(/plan\.md$/);
+            expect(preview.content).toBe(content);
+            expect(preview.lineCount).toBe(4);
+        });
+        it('should throw error when sessionId is missing', async () => {
+            const tool = createPlanCreateTool(planService);
+            try {
+                await tool.generatePreview({ title: 'Test', content: '# Plan' }, {});
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DextoRuntimeError);
+                expect(error.code).toBe(PlanErrorCode.SESSION_ID_REQUIRED);
+            }
+        });
+        it('should throw error when plan already exists', async () => {
+            const tool = createPlanCreateTool(planService);
+            const sessionId = 'test-session';
+            // Create existing plan
+            await planService.create(sessionId, '# Existing Plan');
+            try {
+                await tool.generatePreview({ title: 'New Plan', content: '# New Content' }, { sessionId });
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DextoRuntimeError);
+                expect(error.code).toBe(PlanErrorCode.PLAN_ALREADY_EXISTS);
+            }
+        });
+    });
+    describe('execute', () => {
+        it('should create plan and return success', async () => {
+            const tool = createPlanCreateTool(planService);
+            const sessionId = 'test-session';
+            const content = '# Implementation Plan';
+            const title = 'My Plan';
+            const result = (await tool.execute({ title, content }, { sessionId }));
+            expect(result.success).toBe(true);
+            // Path is now absolute, check it ends with the expected suffix
+            expect(result.path).toContain(sessionId);
+            expect(result.path).toMatch(/plan\.md$/);
+            expect(result.status).toBe('draft');
+            expect(result.title).toBe(title);
+        });
+        it('should throw error when sessionId is missing', async () => {
+            const tool = createPlanCreateTool(planService);
+            try {
+                await tool.execute({ title: 'Test', content: '# Plan' }, {});
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DextoRuntimeError);
+                expect(error.code).toBe(PlanErrorCode.SESSION_ID_REQUIRED);
+            }
+        });
+        it('should include _display data in result', async () => {
+            const tool = createPlanCreateTool(planService);
+            const sessionId = 'test-session';
+            const content = '# Plan\n## Steps';
+            const result = (await tool.execute({ title: 'Plan', content }, { sessionId }));
+            expect(result._display).toBeDefined();
+            expect(result._display.type).toBe('file');
+            expect(result._display.operation).toBe('create');
+            expect(result._display.lineCount).toBe(2);
+        });
+    });
+});

package/dist/tools/plan-read-tool.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Plan Read Tool
+ *
+ * Reads the current implementation plan for the session.
+ * No approval needed - read-only operation.
+ */
+import type { InternalTool } from '@dexto/core';
+import type { PlanService } from '../plan-service.js';
+/**
+ * Creates the plan_read tool
+ */
+export declare function createPlanReadTool(planService: PlanService): InternalTool;
+//# sourceMappingURL=plan-read-tool.d.ts.map

package/dist/tools/plan-read-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-read-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-read-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAwB,MAAM,aAAa,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAKtD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,WAAW,GAAG,YAAY,CAgCzE"}

package/dist/tools/plan-read-tool.js

@@ -0,0 +1,40 @@
+/**
+ * Plan Read Tool
+ *
+ * Reads the current implementation plan for the session.
+ * No approval needed - read-only operation.
+ */
+import { z } from 'zod';
+import { PlanError } from '../errors.js';
+const PlanReadInputSchema = z.object({}).strict();
+/**
+ * Creates the plan_read tool
+ */
+export function createPlanReadTool(planService) {
+    return {
+        id: 'plan_read',
+        description: 'Read the current implementation plan for this session. Returns the plan content and metadata including status. Use markdown checkboxes (- [ ] and - [x]) in the content to track progress.',
+        inputSchema: PlanReadInputSchema,
+        execute: async (_input, context) => {
+            if (!context?.sessionId) {
+                throw PlanError.sessionIdRequired();
+            }
+            const plan = await planService.read(context.sessionId);
+            if (!plan) {
+                return {
+                    exists: false,
+                    message: `No plan found for this session. Use plan_create to create one.`,
+                };
+            }
+            return {
+                exists: true,
+                path: `.dexto/plans/${context.sessionId}/plan.md`,
+                content: plan.content,
+                status: plan.meta.status,
+                title: plan.meta.title,
+                createdAt: new Date(plan.meta.createdAt).toISOString(),
+                updatedAt: new Date(plan.meta.updatedAt).toISOString(),
+            };
+        },
+    };
+}

package/dist/tools/plan-read-tool.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Plan Read Tool Tests
+ *
+ * Tests for the plan_read tool.
+ */
+export {};
+//# sourceMappingURL=plan-read-tool.test.d.ts.map

package/dist/tools/plan-read-tool.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-read-tool.test.d.ts","sourceRoot":"","sources":["../../src/tools/plan-read-tool.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/tools/plan-read-tool.test.js

@@ -0,0 +1,83 @@
+/**
+ * Plan Read Tool Tests
+ *
+ * Tests for the plan_read tool.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import { createPlanReadTool } from './plan-read-tool.js';
+import { PlanService } from '../plan-service.js';
+import { PlanErrorCode } from '../errors.js';
+import { DextoRuntimeError } from '@dexto/core';
+// Create mock logger
+const createMockLogger = () => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    createChild: vi.fn().mockReturnThis(),
+});
+describe('plan_read tool', () => {
+    let mockLogger;
+    let tempDir;
+    let planService;
+    beforeEach(async () => {
+        mockLogger = createMockLogger();
+        const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dexto-plan-read-test-'));
+        tempDir = await fs.realpath(rawTempDir);
+        planService = new PlanService({ basePath: tempDir }, mockLogger);
+        vi.clearAllMocks();
+    });
+    afterEach(async () => {
+        try {
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    describe('execute', () => {
+        it('should return exists: false when no plan exists', async () => {
+            const tool = createPlanReadTool(planService);
+            const sessionId = 'test-session';
+            const result = (await tool.execute({}, { sessionId }));
+            expect(result.exists).toBe(false);
+            expect(result.message).toContain('No plan found');
+        });
+        it('should return plan content and metadata when plan exists', async () => {
+            const tool = createPlanReadTool(planService);
+            const sessionId = 'test-session';
+            const content = '# My Plan\n\nSome content';
+            const title = 'My Plan Title';
+            await planService.create(sessionId, content, { title });
+            const result = (await tool.execute({}, { sessionId }));
+            expect(result.exists).toBe(true);
+            expect(result.content).toBe(content);
+            expect(result.status).toBe('draft');
+            expect(result.title).toBe(title);
+            expect(result.path).toBe(`.dexto/plans/${sessionId}/plan.md`);
+        });
+        it('should return ISO timestamps', async () => {
+            const tool = createPlanReadTool(planService);
+            const sessionId = 'test-session';
+            await planService.create(sessionId, '# Plan');
+            const result = (await tool.execute({}, { sessionId }));
+            // Should be ISO format
+            expect(result.createdAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+            expect(result.updatedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+        });
+        it('should throw error when sessionId is missing', async () => {
+            const tool = createPlanReadTool(planService);
+            try {
+                await tool.execute({}, {});
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DextoRuntimeError);
+                expect(error.code).toBe(PlanErrorCode.SESSION_ID_REQUIRED);
+            }
+        });
+    });
+});

package/dist/tools/plan-review-tool.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Plan Review Tool
+ *
+ * Requests user review of the current plan.
+ * Shows the plan content for review with approval options:
+ * - Approve: Proceed with implementation
+ * - Approve + Accept Edits: Proceed and auto-approve file edits
+ * - Request Changes: Provide feedback for iteration
+ * - Reject: Reject the plan entirely
+ *
+ * Uses the tool confirmation pattern (not elicitation) so the user
+ * can see the full plan content before deciding.
+ */
+import type { InternalTool } from '@dexto/core';
+import type { PlanService } from '../plan-service.js';
+/**
+ * Creates the plan_review tool
+ *
+ * @param planService - Service for plan operations
+ */
+export declare function createPlanReviewTool(planService: PlanService): InternalTool;
+//# sourceMappingURL=plan-review-tool.d.ts.map

package/dist/tools/plan-review-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-review-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-review-tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAyC,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AActD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,WAAW,GAAG,YAAY,CAoE3E"}

package/dist/tools/plan-review-tool.js

@@ -0,0 +1,84 @@
+/**
+ * Plan Review Tool
+ *
+ * Requests user review of the current plan.
+ * Shows the plan content for review with approval options:
+ * - Approve: Proceed with implementation
+ * - Approve + Accept Edits: Proceed and auto-approve file edits
+ * - Request Changes: Provide feedback for iteration
+ * - Reject: Reject the plan entirely
+ *
+ * Uses the tool confirmation pattern (not elicitation) so the user
+ * can see the full plan content before deciding.
+ */
+import { z } from 'zod';
+import { PlanError } from '../errors.js';
+const PlanReviewInputSchema = z
+    .object({
+    summary: z
+        .string()
+        .optional()
+        .describe('Brief summary of the plan for context (shown above the plan content)'),
+})
+    .strict();
+/**
+ * Creates the plan_review tool
+ *
+ * @param planService - Service for plan operations
+ */
+export function createPlanReviewTool(planService) {
+    return {
+        id: 'plan_review',
+        description: 'Request user review of the current plan. Shows the full plan content for review with options to approve, request changes, or reject. Use after creating or updating a plan to get user approval before implementation.',
+        inputSchema: PlanReviewInputSchema,
+        /**
+         * Generate preview showing the plan content for review.
+         * The ApprovalPrompt component detects plan_review and shows custom options.
+         */
+        generatePreview: async (input, context) => {
+            const { summary } = input;
+            if (!context?.sessionId) {
+                throw PlanError.sessionIdRequired();
+            }
+            // Read the current plan
+            const plan = await planService.read(context.sessionId);
+            if (!plan) {
+                throw PlanError.planNotFound(context.sessionId);
+            }
+            // Build content with optional summary header
+            let displayContent = plan.content;
+            if (summary) {
+                displayContent = `## Summary\n${summary}\n\n---\n\n${plan.content}`;
+            }
+            const lineCount = displayContent.split('\n').length;
+            const planPath = planService.getPlanPath(context.sessionId);
+            return {
+                type: 'file',
+                path: planPath,
+                operation: 'read', // 'read' indicates this is for viewing, not creating/modifying
+                content: displayContent,
+                size: Buffer.byteLength(displayContent, 'utf8'),
+                lineCount,
+            };
+        },
+        execute: async (_input, context) => {
+            // Tool execution means user approved the plan (selected Approve or Approve + Accept Edits)
+            // Request Changes and Reject are handled as denials in the approval flow
+            if (!context?.sessionId) {
+                throw PlanError.sessionIdRequired();
+            }
+            // Read plan to verify it still exists
+            const plan = await planService.read(context.sessionId);
+            if (!plan) {
+                throw PlanError.planNotFound(context.sessionId);
+            }
+            // Update plan status to approved
+            await planService.updateMeta(context.sessionId, { status: 'approved' });
+            return {
+                approved: true,
+                message: 'Plan approved. You may now proceed with implementation.',
+                planStatus: 'approved',
+            };
+        },
+    };
+}

package/dist/tools/plan-update-tool.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Plan Update Tool
+ *
+ * Updates the implementation plan for the current session.
+ * Shows a diff preview for approval before saving.
+ */
+import type { InternalTool } from '@dexto/core';
+import type { PlanService } from '../plan-service.js';
+/**
+ * Creates the plan_update tool
+ */
+export declare function createPlanUpdateTool(planService: PlanService): InternalTool;
+//# sourceMappingURL=plan-update-tool.d.ts.map

package/dist/tools/plan-update-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-update-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-update-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAyC,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAkCtD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,WAAW,GAAG,YAAY,CAiD3E"}

package/dist/tools/plan-update-tool.js

@@ -0,0 +1,72 @@
+/**
+ * Plan Update Tool
+ *
+ * Updates the implementation plan for the current session.
+ * Shows a diff preview for approval before saving.
+ */
+import { z } from 'zod';
+import { createPatch } from 'diff';
+import { PlanError } from '../errors.js';
+const PlanUpdateInputSchema = z
+    .object({
+    content: z.string().describe('Updated plan content in markdown format'),
+})
+    .strict();
+/**
+ * Generate diff preview for plan update
+ */
+function generateDiffPreview(filePath, originalContent, newContent) {
+    const unified = createPatch(filePath, originalContent, newContent, 'before', 'after', {
+        context: 3,
+    });
+    const additions = (unified.match(/^\+[^+]/gm) || []).length;
+    const deletions = (unified.match(/^-[^-]/gm) || []).length;
+    return {
+        type: 'diff',
+        unified,
+        filename: filePath,
+        additions,
+        deletions,
+    };
+}
+/**
+ * Creates the plan_update tool
+ */
+export function createPlanUpdateTool(planService) {
+    return {
+        id: 'plan_update',
+        description: 'Update the existing implementation plan for this session. Shows a diff preview for approval before saving. The plan must already exist (use plan_create first).',
+        inputSchema: PlanUpdateInputSchema,
+        /**
+         * Generate diff preview for approval UI
+         */
+        generatePreview: async (input, context) => {
+            const { content: newContent } = input;
+            if (!context?.sessionId) {
+                throw PlanError.sessionIdRequired();
+            }
+            // Read existing plan
+            const existing = await planService.read(context.sessionId);
+            if (!existing) {
+                throw PlanError.planNotFound(context.sessionId);
+            }
+            // Generate diff preview
+            const planPath = planService.getPlanPath(context.sessionId);
+            return generateDiffPreview(planPath, existing.content, newContent);
+        },
+        execute: async (input, context) => {
+            const { content } = input;
+            if (!context?.sessionId) {
+                throw PlanError.sessionIdRequired();
+            }
+            const result = await planService.update(context.sessionId, content);
+            const planPath = planService.getPlanPath(context.sessionId);
+            return {
+                success: true,
+                path: planPath,
+                status: result.meta.status,
+                _display: generateDiffPreview(planPath, result.oldContent, result.newContent),
+            };
+        },
+    };
+}

package/dist/tools/plan-update-tool.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Plan Update Tool Tests
+ *
+ * Tests for the plan_update tool including diff preview generation.
+ */
+export {};
+//# sourceMappingURL=plan-update-tool.test.d.ts.map

package/dist/tools/plan-update-tool.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-update-tool.test.d.ts","sourceRoot":"","sources":["../../src/tools/plan-update-tool.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/tools/plan-update-tool.test.js

@@ -0,0 +1,151 @@
+/**
+ * Plan Update Tool Tests
+ *
+ * Tests for the plan_update tool including diff preview generation.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import { createPlanUpdateTool } from './plan-update-tool.js';
+import { PlanService } from '../plan-service.js';
+import { PlanErrorCode } from '../errors.js';
+import { DextoRuntimeError } from '@dexto/core';
+// Create mock logger
+const createMockLogger = () => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    createChild: vi.fn().mockReturnThis(),
+});
+describe('plan_update tool', () => {
+    let mockLogger;
+    let tempDir;
+    let planService;
+    beforeEach(async () => {
+        mockLogger = createMockLogger();
+        const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dexto-plan-update-test-'));
+        tempDir = await fs.realpath(rawTempDir);
+        planService = new PlanService({ basePath: tempDir }, mockLogger);
+        vi.clearAllMocks();
+    });
+    afterEach(async () => {
+        try {
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    describe('generatePreview', () => {
+        it('should return DiffDisplayData with unified diff', async () => {
+            const tool = createPlanUpdateTool(planService);
+            const sessionId = 'test-session';
+            const originalContent = '# Plan\n\n## Steps\n1. First step';
+            const newContent = '# Plan\n\n## Steps\n1. First step\n2. Second step';
+            await planService.create(sessionId, originalContent);
+            const preview = (await tool.generatePreview({ content: newContent }, { sessionId }));
+            expect(preview.type).toBe('diff');
+            // Path is now absolute, check it ends with the expected suffix
+            expect(preview.filename).toContain(sessionId);
+            expect(preview.filename).toMatch(/plan\.md$/);
+            expect(preview.unified).toContain('-1. First step');
+            expect(preview.unified).toContain('+1. First step');
+            expect(preview.unified).toContain('+2. Second step');
+            expect(preview.additions).toBeGreaterThan(0);
+        });
+        it('should throw error when plan does not exist', async () => {
+            const tool = createPlanUpdateTool(planService);
+            const sessionId = 'test-session';
+            try {
+                await tool.generatePreview({ content: '# New Content' }, { sessionId });
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DextoRuntimeError);
+                expect(error.code).toBe(PlanErrorCode.PLAN_NOT_FOUND);
+            }
+        });
+        it('should throw error when sessionId is missing', async () => {
+            const tool = createPlanUpdateTool(planService);
+            try {
+                await tool.generatePreview({ content: '# Content' }, {});
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DextoRuntimeError);
+                expect(error.code).toBe(PlanErrorCode.SESSION_ID_REQUIRED);
+            }
+        });
+        it('should show deletions in diff', async () => {
+            const tool = createPlanUpdateTool(planService);
+            const sessionId = 'test-session';
+            const originalContent = '# Plan\n\nLine to remove\nKeep this';
+            const newContent = '# Plan\n\nKeep this';
+            await planService.create(sessionId, originalContent);
+            const preview = (await tool.generatePreview({ content: newContent }, { sessionId }));
+            expect(preview.deletions).toBeGreaterThan(0);
+            expect(preview.unified).toContain('-Line to remove');
+        });
+    });
+    describe('execute', () => {
+        it('should update plan content and return success', async () => {
+            const tool = createPlanUpdateTool(planService);
+            const sessionId = 'test-session';
+            const originalContent = '# Original Plan';
+            const newContent = '# Updated Plan';
+            await planService.create(sessionId, originalContent);
+            const result = (await tool.execute({ content: newContent }, { sessionId }));
+            expect(result.success).toBe(true);
+            // Path is now absolute, check it ends with the expected suffix
+            expect(result.path).toContain(sessionId);
+            expect(result.path).toMatch(/plan\.md$/);
+            // Verify content was updated
+            const plan = await planService.read(sessionId);
+            expect(plan.content).toBe(newContent);
+        });
+        it('should include _display data with diff', async () => {
+            const tool = createPlanUpdateTool(planService);
+            const sessionId = 'test-session';
+            await planService.create(sessionId, '# Original');
+            const result = (await tool.execute({ content: '# Updated' }, { sessionId }));
+            expect(result._display).toBeDefined();
+            expect(result._display.type).toBe('diff');
+            expect(result._display.unified).toContain('-# Original');
+            expect(result._display.unified).toContain('+# Updated');
+        });
+        it('should throw error when plan does not exist', async () => {
+            const tool = createPlanUpdateTool(planService);
+            const sessionId = 'non-existent';
+            try {
+                await tool.execute({ content: '# Content' }, { sessionId });
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DextoRuntimeError);
+                expect(error.code).toBe(PlanErrorCode.PLAN_NOT_FOUND);
+            }
+        });
+        it('should throw error when sessionId is missing', async () => {
+            const tool = createPlanUpdateTool(planService);
+            try {
+                await tool.execute({ content: '# Content' }, {});
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DextoRuntimeError);
+                expect(error.code).toBe(PlanErrorCode.SESSION_ID_REQUIRED);
+            }
+        });
+        it('should preserve plan status after update', async () => {
+            const tool = createPlanUpdateTool(planService);
+            const sessionId = 'test-session';
+            await planService.create(sessionId, '# Plan');
+            await planService.updateMeta(sessionId, { status: 'approved' });
+            await tool.execute({ content: '# Updated Plan' }, { sessionId });
+            const plan = await planService.read(sessionId);
+            expect(plan.meta.status).toBe('approved');
+        });
+    });
+});