@dexto/tools-plan 1.6.0 → 1.6.2

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

@@ -1,88 +1,74 @@
-/**
- * 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 approval pattern (not elicitation) so the user
- * can see the full plan content before deciding.
- */
-import { z } from 'zod';
-import { defineTool } from '@dexto/core';
-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 getPlanService - Getter for the plan service
- */
-export function createPlanReviewTool(getPlanService) {
-    return defineTool({
-        id: 'plan_review',
-        displayName: 'Review Plan',
-        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 resolvedPlanService = await getPlanService(context);
-            const { summary } = input;
-            if (!context.sessionId) {
-                throw PlanError.sessionIdRequired();
-            }
-            // Read the current plan
-            const plan = await resolvedPlanService.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 = resolvedPlanService.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,
-            };
-        },
-        async execute(_input, context) {
-            const resolvedPlanService = await getPlanService(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 resolvedPlanService.read(context.sessionId);
-            if (!plan) {
-                throw PlanError.planNotFound(context.sessionId);
-            }
-            // Update plan status to approved
-            await resolvedPlanService.updateMeta(context.sessionId, { status: 'approved' });
-            return {
-                approved: true,
-                message: 'Plan approved. You may now proceed with implementation.',
-                planStatus: 'approved',
-            };
-        },
-    });
+import { z } from "zod";
+import { createLocalToolCallHeader, defineTool, truncateForHeader } from "@dexto/core";
+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();
+function createPlanReviewTool(getPlanService) {
+  return defineTool({
+    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,
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Review Plan",
+        ...input.summary ? { argsText: truncateForHeader(input.summary, 140) } : {}
+      }),
+      /**
+       * Generate preview showing the plan content for review.
+       * The ApprovalPrompt component detects plan_review and shows custom options.
+       */
+      preview: async (input, context) => {
+        const resolvedPlanService = await getPlanService(context);
+        const { summary } = input;
+        if (!context.sessionId) {
+          throw PlanError.sessionIdRequired();
+        }
+        const plan = await resolvedPlanService.read(context.sessionId);
+        if (!plan) {
+          throw PlanError.planNotFound(context.sessionId);
+        }
+        let displayContent = plan.content;
+        if (summary) {
+          displayContent = `## Summary
+${summary}
+
+---
+
+${plan.content}`;
+        }
+        const lineCount = displayContent.split("\n").length;
+        const planPath = resolvedPlanService.getPlanPath(context.sessionId);
+        return {
+          type: "file",
+          title: "Review Plan",
+          path: planPath,
+          operation: "read",
+          // 'read' indicates this is for viewing, not creating/modifying
+          content: displayContent,
+          size: Buffer.byteLength(displayContent, "utf8"),
+          lineCount
+        };
+      }
+    },
+    async execute(_input, context) {
+      const resolvedPlanService = await getPlanService(context);
+      if (!context.sessionId) {
+        throw PlanError.sessionIdRequired();
+      }
+      const plan = await resolvedPlanService.read(context.sessionId);
+      if (!plan) {
+        throw PlanError.planNotFound(context.sessionId);
+      }
+      await resolvedPlanService.updateMeta(context.sessionId, { status: "approved" });
+      return {
+        approved: true,
+        message: "Plan approved. You may now proceed with implementation.",
+        planStatus: "approved"
+      };
+    }
+  });
 }
+export {
+  createPlanReviewTool
+};

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

@@ -0,0 +1,92 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_update_tool_exports = {};
+__export(plan_update_tool_exports, {
+  createPlanUpdateTool: () => createPlanUpdateTool
+});
+module.exports = __toCommonJS(plan_update_tool_exports);
+var import_zod = require("zod");
+var import_diff = require("diff");
+var import_core = require("@dexto/core");
+var import_errors = require("../errors.js");
+const PlanUpdateInputSchema = import_zod.z.object({
+  content: import_zod.z.string().describe("Updated plan content in markdown format")
+}).strict();
+function generateDiffPreview(filePath, originalContent, newContent) {
+  const unified = (0, import_diff.createPatch)(filePath, originalContent, newContent, "before", "after", {
+    context: 3
+  });
+  const additions = (unified.match(/^\+[^+]/gm) || []).length;
+  const deletions = (unified.match(/^-[^-]/gm) || []).length;
+  return {
+    type: "diff",
+    title: "Update Plan",
+    unified,
+    filename: filePath,
+    additions,
+    deletions
+  };
+}
+function createPlanUpdateTool(getPlanService) {
+  return (0, import_core.defineTool)({
+    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,
+    presentation: {
+      describeHeader: () => (0, import_core.createLocalToolCallHeader)({
+        title: "Update Plan"
+      }),
+      /**
+       * Generate diff preview for approval UI
+       */
+      preview: async (input, context) => {
+        const resolvedPlanService = await getPlanService(context);
+        const { content: newContent } = input;
+        if (!context.sessionId) {
+          throw import_errors.PlanError.sessionIdRequired();
+        }
+        const existing = await resolvedPlanService.read(context.sessionId);
+        if (!existing) {
+          throw import_errors.PlanError.planNotFound(context.sessionId);
+        }
+        const planPath = resolvedPlanService.getPlanPath(context.sessionId);
+        return generateDiffPreview(planPath, existing.content, newContent);
+      }
+    },
+    async execute(input, context) {
+      const resolvedPlanService = await getPlanService(context);
+      const { content } = input;
+      if (!context.sessionId) {
+        throw import_errors.PlanError.sessionIdRequired();
+      }
+      const result = await resolvedPlanService.update(context.sessionId, content);
+      const planPath = resolvedPlanService.getPlanPath(context.sessionId);
+      return {
+        success: true,
+        path: planPath,
+        status: result.meta.status,
+        _display: generateDiffPreview(planPath, result.oldContent, result.newContent)
+      };
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPlanUpdateTool
+});

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

@@ -1 +1 @@
-{"version":3,"file":"plan-update-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-update-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,IAAI,EAAyC,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAGnE,QAAA,MAAM,qBAAqB;;;;;;EAId,CAAC;AAyBd;;GAEG;AACH,wBAAgB,oBAAoB,CAChC,cAAc,EAAE,iBAAiB,GAClC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAiDpC"}
+{"version":3,"file":"plan-update-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-update-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,IAAI,EAAyC,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAGnE,QAAA,MAAM,qBAAqB;;;;;;EAId,CAAC;AA0Bd;;GAEG;AACH,wBAAgB,oBAAoB,CAChC,cAAc,EAAE,iBAAiB,GAClC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAsDpC"}

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

@@ -1,76 +1,68 @@
-/**
- * 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 { defineTool } from '@dexto/core';
-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
- */
+import { z } from "zod";
+import { createPatch } from "diff";
+import { createLocalToolCallHeader, defineTool } from "@dexto/core";
+import { PlanError } from "../errors.js";
+const PlanUpdateInputSchema = z.object({
+  content: z.string().describe("Updated plan content in markdown format")
+}).strict();
 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,
-    };
+  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",
+    title: "Update Plan",
+    unified,
+    filename: filePath,
+    additions,
+    deletions
+  };
 }
-/**
- * Creates the plan_update tool
- */
-export function createPlanUpdateTool(getPlanService) {
-    return defineTool({
-        id: 'plan_update',
-        displayName: 'Update Plan',
-        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 resolvedPlanService = await getPlanService(context);
-            const { content: newContent } = input;
-            if (!context.sessionId) {
-                throw PlanError.sessionIdRequired();
-            }
-            // Read existing plan
-            const existing = await resolvedPlanService.read(context.sessionId);
-            if (!existing) {
-                throw PlanError.planNotFound(context.sessionId);
-            }
-            // Generate diff preview
-            const planPath = resolvedPlanService.getPlanPath(context.sessionId);
-            return generateDiffPreview(planPath, existing.content, newContent);
-        },
-        async execute(input, context) {
-            const resolvedPlanService = await getPlanService(context);
-            const { content } = input;
-            if (!context.sessionId) {
-                throw PlanError.sessionIdRequired();
-            }
-            const result = await resolvedPlanService.update(context.sessionId, content);
-            const planPath = resolvedPlanService.getPlanPath(context.sessionId);
-            return {
-                success: true,
-                path: planPath,
-                status: result.meta.status,
-                _display: generateDiffPreview(planPath, result.oldContent, result.newContent),
-            };
-        },
-    });
+function createPlanUpdateTool(getPlanService) {
+  return defineTool({
+    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,
+    presentation: {
+      describeHeader: () => createLocalToolCallHeader({
+        title: "Update Plan"
+      }),
+      /**
+       * Generate diff preview for approval UI
+       */
+      preview: async (input, context) => {
+        const resolvedPlanService = await getPlanService(context);
+        const { content: newContent } = input;
+        if (!context.sessionId) {
+          throw PlanError.sessionIdRequired();
+        }
+        const existing = await resolvedPlanService.read(context.sessionId);
+        if (!existing) {
+          throw PlanError.planNotFound(context.sessionId);
+        }
+        const planPath = resolvedPlanService.getPlanPath(context.sessionId);
+        return generateDiffPreview(planPath, existing.content, newContent);
+      }
+    },
+    async execute(input, context) {
+      const resolvedPlanService = await getPlanService(context);
+      const { content } = input;
+      if (!context.sessionId) {
+        throw PlanError.sessionIdRequired();
+      }
+      const result = await resolvedPlanService.update(context.sessionId, content);
+      const planPath = resolvedPlanService.getPlanPath(context.sessionId);
+      return {
+        success: true,
+        path: planPath,
+        status: result.meta.status,
+        _display: generateDiffPreview(planPath, result.oldContent, result.newContent)
+      };
+    }
+  });
 }
+export {
+  createPlanUpdateTool
+};

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

@@ -0,0 +1,203 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_vitest = require("vitest");
+var path = __toESM(require("node:path"), 1);
+var fs = __toESM(require("node:fs/promises"), 1);
+var os = __toESM(require("node:os"), 1);
+var import_plan_update_tool = require("./plan-update-tool.js");
+var import_plan_service = require("../plan-service.js");
+var import_errors = require("../errors.js");
+var import_core = require("@dexto/core");
+const createMockLogger = () => {
+  const logger = {
+    debug: import_vitest.vi.fn(),
+    silly: import_vitest.vi.fn(),
+    info: import_vitest.vi.fn(),
+    warn: import_vitest.vi.fn(),
+    error: import_vitest.vi.fn(),
+    trackException: import_vitest.vi.fn(),
+    createChild: import_vitest.vi.fn(() => logger),
+    createFileOnlyChild: import_vitest.vi.fn(() => logger),
+    setLevel: import_vitest.vi.fn(),
+    getLevel: import_vitest.vi.fn(() => "debug"),
+    getLogFilePath: import_vitest.vi.fn(() => null),
+    destroy: import_vitest.vi.fn(async () => void 0)
+  };
+  return logger;
+};
+function createToolContext(logger, overrides = {}) {
+  return { logger, ...overrides };
+}
+(0, import_vitest.describe)("plan_update tool", () => {
+  let logger;
+  let tempDir;
+  let planService;
+  (0, import_vitest.beforeEach)(async () => {
+    logger = createMockLogger();
+    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-plan-update-test-"));
+    tempDir = await fs.realpath(rawTempDir);
+    planService = new import_plan_service.PlanService({ basePath: tempDir }, logger);
+    import_vitest.vi.clearAllMocks();
+  });
+  (0, import_vitest.afterEach)(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  (0, import_vitest.describe)("generatePreview", () => {
+    (0, import_vitest.it)("should return DiffDisplayData with unified diff", async () => {
+      const tool = (0, import_plan_update_tool.createPlanUpdateTool)(async () => 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";
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
+      await planService.create(sessionId, originalContent);
+      const preview = await previewFn(
+        { content: newContent },
+        createToolContext(logger, { sessionId })
+      );
+      (0, import_vitest.expect)(preview.type).toBe("diff");
+      (0, import_vitest.expect)(preview.title).toBe("Update Plan");
+      (0, import_vitest.expect)(preview.filename).toContain(sessionId);
+      (0, import_vitest.expect)(preview.filename).toMatch(/plan\.md$/);
+      (0, import_vitest.expect)(preview.unified).toContain("-1. First step");
+      (0, import_vitest.expect)(preview.unified).toContain("+1. First step");
+      (0, import_vitest.expect)(preview.unified).toContain("+2. Second step");
+      (0, import_vitest.expect)(preview.additions).toBeGreaterThan(0);
+    });
+    (0, import_vitest.it)("should throw error when plan does not exist", async () => {
+      const tool = (0, import_plan_update_tool.createPlanUpdateTool)(async () => planService);
+      const sessionId = "test-session";
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
+      try {
+        await previewFn(
+          { content: "# New Content" },
+          createToolContext(logger, { sessionId })
+        );
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(import_errors.PlanErrorCode.PLAN_NOT_FOUND);
+      }
+    });
+    (0, import_vitest.it)("should throw error when sessionId is missing", async () => {
+      const tool = (0, import_plan_update_tool.createPlanUpdateTool)(async () => planService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
+      try {
+        await previewFn({ content: "# Content" }, createToolContext(logger));
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(import_errors.PlanErrorCode.SESSION_ID_REQUIRED);
+      }
+    });
+    (0, import_vitest.it)("should show deletions in diff", async () => {
+      const tool = (0, import_plan_update_tool.createPlanUpdateTool)(async () => planService);
+      const sessionId = "test-session";
+      const originalContent = "# Plan\n\nLine to remove\nKeep this";
+      const newContent = "# Plan\n\nKeep this";
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
+      await planService.create(sessionId, originalContent);
+      const preview = await previewFn(
+        { content: newContent },
+        createToolContext(logger, { sessionId })
+      );
+      (0, import_vitest.expect)(preview.deletions).toBeGreaterThan(0);
+      (0, import_vitest.expect)(preview.unified).toContain("-Line to remove");
+    });
+  });
+  (0, import_vitest.describe)("execute", () => {
+    (0, import_vitest.it)("should update plan content and return success", async () => {
+      const tool = (0, import_plan_update_tool.createPlanUpdateTool)(async () => 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 },
+        createToolContext(logger, { sessionId })
+      );
+      (0, import_vitest.expect)(result.success).toBe(true);
+      (0, import_vitest.expect)(result.path).toContain(sessionId);
+      (0, import_vitest.expect)(result.path).toMatch(/plan\.md$/);
+      const plan = await planService.read(sessionId);
+      (0, import_vitest.expect)(plan.content).toBe(newContent);
+    });
+    (0, import_vitest.it)("should include _display data with diff", async () => {
+      const tool = (0, import_plan_update_tool.createPlanUpdateTool)(async () => planService);
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Original");
+      const result = await tool.execute(
+        { content: "# Updated" },
+        createToolContext(logger, { sessionId })
+      );
+      (0, import_vitest.expect)(result._display).toBeDefined();
+      (0, import_vitest.expect)(result._display.type).toBe("diff");
+      (0, import_vitest.expect)(result._display.title).toBe("Update Plan");
+      (0, import_vitest.expect)(result._display.unified).toContain("-# Original");
+      (0, import_vitest.expect)(result._display.unified).toContain("+# Updated");
+    });
+    (0, import_vitest.it)("should throw error when plan does not exist", async () => {
+      const tool = (0, import_plan_update_tool.createPlanUpdateTool)(async () => planService);
+      const sessionId = "non-existent";
+      try {
+        await tool.execute(
+          { content: "# Content" },
+          createToolContext(logger, { sessionId })
+        );
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(import_errors.PlanErrorCode.PLAN_NOT_FOUND);
+      }
+    });
+    (0, import_vitest.it)("should throw error when sessionId is missing", async () => {
+      const tool = (0, import_plan_update_tool.createPlanUpdateTool)(async () => planService);
+      try {
+        await tool.execute({ content: "# Content" }, createToolContext(logger));
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(import_errors.PlanErrorCode.SESSION_ID_REQUIRED);
+      }
+    });
+    (0, import_vitest.it)("should preserve plan status after update", async () => {
+      const tool = (0, import_plan_update_tool.createPlanUpdateTool)(async () => planService);
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Plan");
+      await planService.updateMeta(sessionId, { status: "approved" });
+      await tool.execute(
+        { content: "# Updated Plan" },
+        createToolContext(logger, { sessionId })
+      );
+      const plan = await planService.read(sessionId);
+      (0, import_vitest.expect)(plan.meta.status).toBe("approved");
+    });
+  });
+});