@dexto/tools-plan 1.5.8 → 1.6.1

package/dist/plan-service.js

@@ -1,227 +1,213 @@
-/**
- * Plan Service
- *
- * Handles storage and retrieval of implementation plans.
- * Plans are stored in .dexto/plans/{sessionId}/ with:
- * - plan.md: The plan content
- * - plan-meta.json: Metadata (status, checkpoints, timestamps)
- */
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { existsSync } from 'node:fs';
-import { PlanMetaSchema } from './types.js';
-import { PlanError } from './errors.js';
-const PLAN_FILENAME = 'plan.md';
-const META_FILENAME = 'plan-meta.json';
-/**
- * Service for managing implementation plans.
- */
-export class PlanService {
-    basePath;
-    logger;
-    constructor(options, logger) {
-        this.basePath = options.basePath;
-        this.logger = logger;
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { existsSync } from "node:fs";
+import { PlanMetaSchema } from "./types.js";
+import { PlanError } from "./errors.js";
+const PLAN_FILENAME = "plan.md";
+const META_FILENAME = "plan-meta.json";
+class PlanService {
+  basePath;
+  logger;
+  constructor(options, logger) {
+    this.basePath = options.basePath;
+    this.logger = logger;
+  }
+  /**
+   * Resolves and validates a session directory path.
+   * Prevents path traversal attacks by ensuring the resolved path stays within basePath.
+   */
+  resolveSessionDir(sessionId) {
+    const base = path.resolve(this.basePath);
+    const resolved = path.resolve(base, sessionId);
+    const rel = path.relative(base, resolved);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+      throw PlanError.invalidSessionId(sessionId);
     }
-    /**
-     * Resolves and validates a session directory path.
-     * Prevents path traversal attacks by ensuring the resolved path stays within basePath.
-     */
-    resolveSessionDir(sessionId) {
-        const base = path.resolve(this.basePath);
-        const resolved = path.resolve(base, sessionId);
-        const rel = path.relative(base, resolved);
-        // Check for path traversal (upward traversal)
-        if (rel.startsWith('..') || path.isAbsolute(rel)) {
-            throw PlanError.invalidSessionId(sessionId);
-        }
-        return resolved;
+    return resolved;
+  }
+  /**
+   * Gets the directory path for a session's plan
+   */
+  getPlanDir(sessionId) {
+    return this.resolveSessionDir(sessionId);
+  }
+  /**
+   * Gets the path to the plan content file.
+   * Public accessor for tools that need to display the path.
+   */
+  getPlanPath(sessionId) {
+    return path.join(this.getPlanDir(sessionId), PLAN_FILENAME);
+  }
+  /**
+   * Gets the path to the plan metadata file
+   */
+  getMetaPath(sessionId) {
+    return path.join(this.getPlanDir(sessionId), META_FILENAME);
+  }
+  /**
+   * Checks if a plan exists for the given session
+   */
+  async exists(sessionId) {
+    const planPath = this.getPlanPath(sessionId);
+    return existsSync(planPath);
+  }
+  /**
+   * Creates a new plan for the session
+   *
+   * @throws PlanError.planAlreadyExists if plan already exists
+   * @throws PlanError.storageError on filesystem errors
+   */
+  async create(sessionId, content, options) {
+    if (await this.exists(sessionId)) {
+      throw PlanError.planAlreadyExists(sessionId);
     }
-    /**
-     * Gets the directory path for a session's plan
-     */
-    getPlanDir(sessionId) {
-        return this.resolveSessionDir(sessionId);
+    const planDir = this.getPlanDir(sessionId);
+    const now = Date.now();
+    const meta = {
+      sessionId,
+      status: "draft",
+      title: options?.title,
+      createdAt: now,
+      updatedAt: now
+    };
+    try {
+      await fs.mkdir(planDir, { recursive: true });
+      await Promise.all([
+        fs.writeFile(this.getPlanPath(sessionId), content, "utf-8"),
+        fs.writeFile(this.getMetaPath(sessionId), JSON.stringify(meta, null, 2), "utf-8")
+      ]);
+      this.logger.debug(`Created plan for session ${sessionId}`);
+      return { content, meta };
+    } catch (error) {
+      throw PlanError.storageError("create", sessionId, error);
     }
-    /**
-     * Gets the path to the plan content file.
-     * Public accessor for tools that need to display the path.
-     */
-    getPlanPath(sessionId) {
-        return path.join(this.getPlanDir(sessionId), PLAN_FILENAME);
+  }
+  /**
+   * Reads the plan for the given session
+   *
+   * @returns The plan or null if not found
+   */
+  async read(sessionId) {
+    if (!await this.exists(sessionId)) {
+      return null;
     }
-    /**
-     * Gets the path to the plan metadata file
-     */
-    getMetaPath(sessionId) {
-        return path.join(this.getPlanDir(sessionId), META_FILENAME);
-    }
-    /**
-     * Checks if a plan exists for the given session
-     */
-    async exists(sessionId) {
-        const planPath = this.getPlanPath(sessionId);
-        return existsSync(planPath);
-    }
-    /**
-     * Creates a new plan for the session
-     *
-     * @throws PlanError.planAlreadyExists if plan already exists
-     * @throws PlanError.storageError on filesystem errors
-     */
-    async create(sessionId, content, options) {
-        // Check if plan already exists
-        if (await this.exists(sessionId)) {
-            throw PlanError.planAlreadyExists(sessionId);
-        }
-        const planDir = this.getPlanDir(sessionId);
-        const now = Date.now();
-        // Create metadata
-        const meta = {
+    try {
+      const [content, metaContent] = await Promise.all([
+        fs.readFile(this.getPlanPath(sessionId), "utf-8"),
+        fs.readFile(this.getMetaPath(sessionId), "utf-8")
+      ]);
+      const metaParsed = JSON.parse(metaContent);
+      const metaResult = PlanMetaSchema.safeParse(metaParsed);
+      if (!metaResult.success) {
+        this.logger.warn(`Invalid plan metadata for session ${sessionId}, using defaults`);
+        return {
+          content,
+          meta: {
             sessionId,
-            status: 'draft',
-            title: options?.title,
-            createdAt: now,
-            updatedAt: now,
+            status: "draft",
+            createdAt: Date.now(),
+            updatedAt: Date.now()
+          }
         };
-        try {
-            // Ensure directory exists
-            await fs.mkdir(planDir, { recursive: true });
-            // Write plan content and metadata
-            await Promise.all([
-                fs.writeFile(this.getPlanPath(sessionId), content, 'utf-8'),
-                fs.writeFile(this.getMetaPath(sessionId), JSON.stringify(meta, null, 2), 'utf-8'),
-            ]);
-            this.logger?.debug(`Created plan for session ${sessionId}`);
-            return { content, meta };
-        }
-        catch (error) {
-            throw PlanError.storageError('create', sessionId, error);
-        }
+      }
+      return { content, meta: metaResult.data };
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        return null;
+      }
+      if (error instanceof SyntaxError) {
+        this.logger.error(`Failed to read plan for session ${sessionId}: ${error.message}`);
+        return null;
+      }
+      this.logger.error(
+        `Failed to read plan for session ${sessionId}: ${err.message ?? String(err)}`
+      );
+      throw PlanError.storageError("read", sessionId, err);
     }
-    /**
-     * Reads the plan for the given session
-     *
-     * @returns The plan or null if not found
-     */
-    async read(sessionId) {
-        if (!(await this.exists(sessionId))) {
-            return null;
-        }
-        try {
-            const [content, metaContent] = await Promise.all([
-                fs.readFile(this.getPlanPath(sessionId), 'utf-8'),
-                fs.readFile(this.getMetaPath(sessionId), 'utf-8'),
-            ]);
-            const metaParsed = JSON.parse(metaContent);
-            const metaResult = PlanMetaSchema.safeParse(metaParsed);
-            if (!metaResult.success) {
-                this.logger?.warn(`Invalid plan metadata for session ${sessionId}, using defaults`);
-                // Return with minimal metadata if parsing fails
-                return {
-                    content,
-                    meta: {
-                        sessionId,
-                        status: 'draft',
-                        createdAt: Date.now(),
-                        updatedAt: Date.now(),
-                    },
-                };
-            }
-            return { content, meta: metaResult.data };
-        }
-        catch (error) {
-            const err = error;
-            // ENOENT means file doesn't exist - return null (expected case)
-            if (err.code === 'ENOENT') {
-                return null;
-            }
-            // JSON parse errors (SyntaxError) mean corrupted data - treat as not found
-            // but log for debugging
-            if (error instanceof SyntaxError) {
-                this.logger?.error(`Failed to read plan for session ${sessionId}: ${error.message}`);
-                return null;
-            }
-            // For real I/O errors (permission denied, disk issues), throw to surface the issue
-            this.logger?.error(`Failed to read plan for session ${sessionId}: ${err.message ?? String(err)}`);
-            throw PlanError.storageError('read', sessionId, err);
-        }
+  }
+  /**
+   * Updates the plan content for the given session
+   *
+   * @throws PlanError.planNotFound if plan doesn't exist
+   * @throws PlanError.storageError on filesystem errors
+   */
+  async update(sessionId, content) {
+    const existing = await this.read(sessionId);
+    if (!existing) {
+      throw PlanError.planNotFound(sessionId);
     }
-    /**
-     * Updates the plan content for the given session
-     *
-     * @throws PlanError.planNotFound if plan doesn't exist
-     * @throws PlanError.storageError on filesystem errors
-     */
-    async update(sessionId, content) {
-        const existing = await this.read(sessionId);
-        if (!existing) {
-            throw PlanError.planNotFound(sessionId);
-        }
-        const oldContent = existing.content;
-        const now = Date.now();
-        // Update metadata
-        const updatedMeta = {
-            ...existing.meta,
-            updatedAt: now,
-        };
-        try {
-            await Promise.all([
-                fs.writeFile(this.getPlanPath(sessionId), content, 'utf-8'),
-                fs.writeFile(this.getMetaPath(sessionId), JSON.stringify(updatedMeta, null, 2), 'utf-8'),
-            ]);
-            this.logger?.debug(`Updated plan for session ${sessionId}`);
-            return {
-                oldContent,
-                newContent: content,
-                meta: updatedMeta,
-            };
-        }
-        catch (error) {
-            throw PlanError.storageError('update', sessionId, error);
-        }
+    const oldContent = existing.content;
+    const now = Date.now();
+    const updatedMeta = {
+      ...existing.meta,
+      updatedAt: now
+    };
+    try {
+      await Promise.all([
+        fs.writeFile(this.getPlanPath(sessionId), content, "utf-8"),
+        fs.writeFile(
+          this.getMetaPath(sessionId),
+          JSON.stringify(updatedMeta, null, 2),
+          "utf-8"
+        )
+      ]);
+      this.logger.debug(`Updated plan for session ${sessionId}`);
+      return {
+        oldContent,
+        newContent: content,
+        meta: updatedMeta
+      };
+    } catch (error) {
+      throw PlanError.storageError("update", sessionId, error);
     }
-    /**
-     * Updates the plan metadata (status, title)
-     *
-     * @throws PlanError.planNotFound if plan doesn't exist
-     * @throws PlanError.storageError on filesystem errors
-     */
-    async updateMeta(sessionId, updates) {
-        const existing = await this.read(sessionId);
-        if (!existing) {
-            throw PlanError.planNotFound(sessionId);
-        }
-        const updatedMeta = {
-            ...existing.meta,
-            ...updates,
-            updatedAt: Date.now(),
-        };
-        try {
-            await fs.writeFile(this.getMetaPath(sessionId), JSON.stringify(updatedMeta, null, 2), 'utf-8');
-            this.logger?.debug(`Updated plan metadata for session ${sessionId}`);
-            return updatedMeta;
-        }
-        catch (error) {
-            throw PlanError.storageError('update metadata', sessionId, error);
-        }
+  }
+  /**
+   * Updates the plan metadata (status, title)
+   *
+   * @throws PlanError.planNotFound if plan doesn't exist
+   * @throws PlanError.storageError on filesystem errors
+   */
+  async updateMeta(sessionId, updates) {
+    const existing = await this.read(sessionId);
+    if (!existing) {
+      throw PlanError.planNotFound(sessionId);
+    }
+    const updatedMeta = {
+      ...existing.meta,
+      ...updates,
+      updatedAt: Date.now()
+    };
+    try {
+      await fs.writeFile(
+        this.getMetaPath(sessionId),
+        JSON.stringify(updatedMeta, null, 2),
+        "utf-8"
+      );
+      this.logger.debug(`Updated plan metadata for session ${sessionId}`);
+      return updatedMeta;
+    } catch (error) {
+      throw PlanError.storageError("update metadata", sessionId, error);
+    }
+  }
+  /**
+   * Deletes the plan for the given session
+   *
+   * @throws PlanError.planNotFound if plan doesn't exist
+   * @throws PlanError.storageError on filesystem errors
+   */
+  async delete(sessionId) {
+    if (!await this.exists(sessionId)) {
+      throw PlanError.planNotFound(sessionId);
     }
-    /**
-     * Deletes the plan for the given session
-     *
-     * @throws PlanError.planNotFound if plan doesn't exist
-     * @throws PlanError.storageError on filesystem errors
-     */
-    async delete(sessionId) {
-        if (!(await this.exists(sessionId))) {
-            throw PlanError.planNotFound(sessionId);
-        }
-        try {
-            await fs.rm(this.getPlanDir(sessionId), { recursive: true, force: true });
-            this.logger?.debug(`Deleted plan for session ${sessionId}`);
-        }
-        catch (error) {
-            throw PlanError.storageError('delete', sessionId, error);
-        }
+    try {
+      await fs.rm(this.getPlanDir(sessionId), { recursive: true, force: true });
+      this.logger.debug(`Deleted plan for session ${sessionId}`);
+    } catch (error) {
+      throw PlanError.storageError("delete", sessionId, error);
     }
+  }
 }
+export {
+  PlanService
+};

package/dist/plan-service.test.cjs

@@ -0,0 +1,227 @@
+"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_service = require("./plan-service.js");
+var import_errors = require("./errors.js");
+var import_core = require("@dexto/core");
+const createMockLogger = () => ({
+  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().mockReturnThis(),
+  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)
+});
+(0, import_vitest.describe)("PlanService", () => {
+  let mockLogger;
+  let tempDir;
+  let planService;
+  (0, import_vitest.beforeEach)(async () => {
+    mockLogger = createMockLogger();
+    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-plan-test-"));
+    tempDir = await fs.realpath(rawTempDir);
+    planService = new import_plan_service.PlanService({ basePath: tempDir }, mockLogger);
+    import_vitest.vi.clearAllMocks();
+  });
+  (0, import_vitest.afterEach)(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  (0, import_vitest.describe)("exists", () => {
+    (0, import_vitest.it)("should return false for non-existent plan", async () => {
+      const exists = await planService.exists("non-existent-session");
+      (0, import_vitest.expect)(exists).toBe(false);
+    });
+    (0, import_vitest.it)("should return true for existing plan", async () => {
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Test Plan");
+      const exists = await planService.exists(sessionId);
+      (0, import_vitest.expect)(exists).toBe(true);
+    });
+  });
+  (0, import_vitest.describe)("create", () => {
+    (0, import_vitest.it)("should create a new plan with content and metadata", async () => {
+      const sessionId = "test-session";
+      const content = "# Implementation Plan\n\n## Steps\n1. First step";
+      const title = "Test Plan";
+      const plan = await planService.create(sessionId, content, { title });
+      (0, import_vitest.expect)(plan.content).toBe(content);
+      (0, import_vitest.expect)(plan.meta.sessionId).toBe(sessionId);
+      (0, import_vitest.expect)(plan.meta.status).toBe("draft");
+      (0, import_vitest.expect)(plan.meta.title).toBe(title);
+      (0, import_vitest.expect)(plan.meta.createdAt).toBeGreaterThan(0);
+      (0, import_vitest.expect)(plan.meta.updatedAt).toBeGreaterThan(0);
+    });
+    (0, import_vitest.it)("should throw error when plan already exists", async () => {
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# First Plan");
+      try {
+        await planService.create(sessionId, "# Second Plan");
+        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_ALREADY_EXISTS);
+      }
+    });
+    (0, import_vitest.it)("should store plan files on disk", async () => {
+      const sessionId = "test-session";
+      const content = "# Test Plan";
+      await planService.create(sessionId, content);
+      const planPath = path.join(tempDir, sessionId, "plan.md");
+      const storedContent = await fs.readFile(planPath, "utf-8");
+      (0, import_vitest.expect)(storedContent).toBe(content);
+      const metaPath = path.join(tempDir, sessionId, "plan-meta.json");
+      const metaContent = await fs.readFile(metaPath, "utf-8");
+      const meta = JSON.parse(metaContent);
+      (0, import_vitest.expect)(meta.sessionId).toBe(sessionId);
+    });
+  });
+  (0, import_vitest.describe)("read", () => {
+    (0, import_vitest.it)("should return null for non-existent plan", async () => {
+      const plan = await planService.read("non-existent-session");
+      (0, import_vitest.expect)(plan).toBeNull();
+    });
+    (0, import_vitest.it)("should read existing plan with content and metadata", async () => {
+      const sessionId = "test-session";
+      const content = "# Test Plan";
+      const title = "My Plan";
+      await planService.create(sessionId, content, { title });
+      const plan = await planService.read(sessionId);
+      (0, import_vitest.expect)(plan).not.toBeNull();
+      (0, import_vitest.expect)(plan.content).toBe(content);
+      (0, import_vitest.expect)(plan.meta.sessionId).toBe(sessionId);
+      (0, import_vitest.expect)(plan.meta.title).toBe(title);
+    });
+    (0, import_vitest.it)("should handle invalid metadata schema gracefully", async () => {
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Test");
+      const metaPath = path.join(tempDir, sessionId, "plan-meta.json");
+      await fs.writeFile(metaPath, JSON.stringify({ invalidField: "value" }));
+      const plan = await planService.read(sessionId);
+      (0, import_vitest.expect)(plan).not.toBeNull();
+      (0, import_vitest.expect)(plan.meta.sessionId).toBe(sessionId);
+      (0, import_vitest.expect)(plan.meta.status).toBe("draft");
+      (0, import_vitest.expect)(mockLogger.warn).toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should return null for corrupted JSON metadata", async () => {
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Test");
+      const metaPath = path.join(tempDir, sessionId, "plan-meta.json");
+      await fs.writeFile(metaPath, "{ invalid json }");
+      const plan = await planService.read(sessionId);
+      (0, import_vitest.expect)(plan).toBeNull();
+      (0, import_vitest.expect)(mockLogger.error).toHaveBeenCalled();
+    });
+  });
+  (0, import_vitest.describe)("update", () => {
+    (0, import_vitest.it)("should update plan content", async () => {
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Original Content");
+      const result = await planService.update(sessionId, "# Updated Content");
+      (0, import_vitest.expect)(result.oldContent).toBe("# Original Content");
+      (0, import_vitest.expect)(result.newContent).toBe("# Updated Content");
+      (0, import_vitest.expect)(result.meta.updatedAt).toBeGreaterThan(0);
+    });
+    (0, import_vitest.it)("should preserve metadata when updating content", async () => {
+      const sessionId = "test-session";
+      const plan = await planService.create(sessionId, "# Original", { title: "My Title" });
+      const originalCreatedAt = plan.meta.createdAt;
+      await planService.update(sessionId, "# Updated");
+      const updatedPlan = await planService.read(sessionId);
+      (0, import_vitest.expect)(updatedPlan.meta.title).toBe("My Title");
+      (0, import_vitest.expect)(updatedPlan.meta.createdAt).toBe(originalCreatedAt);
+    });
+    (0, import_vitest.it)("should throw error when plan does not exist", async () => {
+      try {
+        await planService.update("non-existent", "# Content");
+        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.describe)("updateMeta", () => {
+    (0, import_vitest.it)("should update plan status", async () => {
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Plan");
+      const meta = await planService.updateMeta(sessionId, { status: "approved" });
+      (0, import_vitest.expect)(meta.status).toBe("approved");
+    });
+    (0, import_vitest.it)("should update plan title", async () => {
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Plan");
+      const meta = await planService.updateMeta(sessionId, { title: "New Title" });
+      (0, import_vitest.expect)(meta.title).toBe("New Title");
+    });
+    (0, import_vitest.it)("should throw error when plan does not exist", async () => {
+      try {
+        await planService.updateMeta("non-existent", { status: "approved" });
+        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.describe)("delete", () => {
+    (0, import_vitest.it)("should delete existing plan", async () => {
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Plan");
+      await planService.delete(sessionId);
+      const exists = await planService.exists(sessionId);
+      (0, import_vitest.expect)(exists).toBe(false);
+    });
+    (0, import_vitest.it)("should throw error when plan does not exist", async () => {
+      try {
+        await planService.delete("non-existent");
+        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 remove plan directory from disk", async () => {
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Plan");
+      const planDir = path.join(tempDir, sessionId);
+      await planService.delete(sessionId);
+      try {
+        await fs.access(planDir);
+        import_vitest.expect.fail("Directory should not exist");
+      } catch {
+      }
+    });
+  });
+});