@dexto/tools-plan 1.6.0 → 1.6.2

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 {
+      }
+    });
+  });
+});

package/dist/plan-service.test.js

@@ -1,226 +1,204 @@
-/**
- * Plan Service Tests
- *
- * Tests for the PlanService CRUD operations and error handling.
- */
-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 { PlanService } from './plan-service.js';
-import { PlanErrorCode } from './errors.js';
-import { DextoRuntimeError } from '@dexto/core';
-// Create mock logger
+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 { PlanService } from "./plan-service.js";
+import { PlanErrorCode } from "./errors.js";
+import { DextoRuntimeError } from "@dexto/core";
 const createMockLogger = () => ({
-    debug: vi.fn(),
-    silly: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    trackException: vi.fn(),
-    createChild: vi.fn().mockReturnThis(),
-    setLevel: vi.fn(),
-    getLevel: vi.fn(() => 'debug'),
-    getLogFilePath: vi.fn(() => null),
-    destroy: vi.fn(async () => undefined),
+  debug: vi.fn(),
+  silly: vi.fn(),
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  trackException: vi.fn(),
+  createChild: vi.fn().mockReturnThis(),
+  setLevel: vi.fn(),
+  getLevel: vi.fn(() => "debug"),
+  getLogFilePath: vi.fn(() => null),
+  destroy: vi.fn(async () => void 0)
 });
-describe('PlanService', () => {
-    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-test-'));
-        tempDir = await fs.realpath(rawTempDir);
-        planService = new PlanService({ basePath: tempDir }, mockLogger);
-        vi.clearAllMocks();
-    });
-    afterEach(async () => {
-        // Cleanup temp directory
-        try {
-            await fs.rm(tempDir, { recursive: true, force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    });
-    describe('exists', () => {
-        it('should return false for non-existent plan', async () => {
-            const exists = await planService.exists('non-existent-session');
-            expect(exists).toBe(false);
-        });
-        it('should return true for existing plan', async () => {
-            const sessionId = 'test-session';
-            await planService.create(sessionId, '# Test Plan');
-            const exists = await planService.exists(sessionId);
-            expect(exists).toBe(true);
-        });
-    });
-    describe('create', () => {
-        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 });
-            expect(plan.content).toBe(content);
-            expect(plan.meta.sessionId).toBe(sessionId);
-            expect(plan.meta.status).toBe('draft');
-            expect(plan.meta.title).toBe(title);
-            expect(plan.meta.createdAt).toBeGreaterThan(0);
-            expect(plan.meta.updatedAt).toBeGreaterThan(0);
-        });
-        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');
-                expect.fail('Should have thrown an error');
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(DextoRuntimeError);
-                expect(error.code).toBe(PlanErrorCode.PLAN_ALREADY_EXISTS);
-            }
-        });
-        it('should store plan files on disk', async () => {
-            const sessionId = 'test-session';
-            const content = '# Test Plan';
-            await planService.create(sessionId, content);
-            // Verify plan.md exists
-            const planPath = path.join(tempDir, sessionId, 'plan.md');
-            const storedContent = await fs.readFile(planPath, 'utf-8');
-            expect(storedContent).toBe(content);
-            // Verify plan-meta.json exists
-            const metaPath = path.join(tempDir, sessionId, 'plan-meta.json');
-            const metaContent = await fs.readFile(metaPath, 'utf-8');
-            const meta = JSON.parse(metaContent);
-            expect(meta.sessionId).toBe(sessionId);
-        });
-    });
-    describe('read', () => {
-        it('should return null for non-existent plan', async () => {
-            const plan = await planService.read('non-existent-session');
-            expect(plan).toBeNull();
-        });
-        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);
-            expect(plan).not.toBeNull();
-            expect(plan.content).toBe(content);
-            expect(plan.meta.sessionId).toBe(sessionId);
-            expect(plan.meta.title).toBe(title);
-        });
-        it('should handle invalid metadata schema gracefully', async () => {
-            const sessionId = 'test-session';
-            await planService.create(sessionId, '# Test');
-            // Write valid JSON but invalid schema (missing required fields)
-            const metaPath = path.join(tempDir, sessionId, 'plan-meta.json');
-            await fs.writeFile(metaPath, JSON.stringify({ invalidField: 'value' }));
-            const plan = await planService.read(sessionId);
-            // Should return with default metadata
-            expect(plan).not.toBeNull();
-            expect(plan.meta.sessionId).toBe(sessionId);
-            expect(plan.meta.status).toBe('draft');
-            expect(mockLogger.warn).toHaveBeenCalled();
-        });
-        it('should return null for corrupted JSON metadata', async () => {
-            const sessionId = 'test-session';
-            await planService.create(sessionId, '# Test');
-            // Corrupt the metadata with invalid JSON
-            const metaPath = path.join(tempDir, sessionId, 'plan-meta.json');
-            await fs.writeFile(metaPath, '{ invalid json }');
-            const plan = await planService.read(sessionId);
-            // Should return null and log error
-            expect(plan).toBeNull();
-            expect(mockLogger.error).toHaveBeenCalled();
-        });
-    });
-    describe('update', () => {
-        it('should update plan content', async () => {
-            const sessionId = 'test-session';
-            await planService.create(sessionId, '# Original Content');
-            const result = await planService.update(sessionId, '# Updated Content');
-            expect(result.oldContent).toBe('# Original Content');
-            expect(result.newContent).toBe('# Updated Content');
-            expect(result.meta.updatedAt).toBeGreaterThan(0);
-        });
-        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);
-            expect(updatedPlan.meta.title).toBe('My Title');
-            expect(updatedPlan.meta.createdAt).toBe(originalCreatedAt);
-        });
-        it('should throw error when plan does not exist', async () => {
-            try {
-                await planService.update('non-existent', '# Content');
-                expect.fail('Should have thrown an error');
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(DextoRuntimeError);
-                expect(error.code).toBe(PlanErrorCode.PLAN_NOT_FOUND);
-            }
-        });
-    });
-    describe('updateMeta', () => {
-        it('should update plan status', async () => {
-            const sessionId = 'test-session';
-            await planService.create(sessionId, '# Plan');
-            const meta = await planService.updateMeta(sessionId, { status: 'approved' });
-            expect(meta.status).toBe('approved');
-        });
-        it('should update plan title', async () => {
-            const sessionId = 'test-session';
-            await planService.create(sessionId, '# Plan');
-            const meta = await planService.updateMeta(sessionId, { title: 'New Title' });
-            expect(meta.title).toBe('New Title');
-        });
-        it('should throw error when plan does not exist', async () => {
-            try {
-                await planService.updateMeta('non-existent', { status: 'approved' });
-                expect.fail('Should have thrown an error');
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(DextoRuntimeError);
-                expect(error.code).toBe(PlanErrorCode.PLAN_NOT_FOUND);
-            }
-        });
-    });
-    describe('delete', () => {
-        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);
-            expect(exists).toBe(false);
-        });
-        it('should throw error when plan does not exist', async () => {
-            try {
-                await planService.delete('non-existent');
-                expect.fail('Should have thrown an error');
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(DextoRuntimeError);
-                expect(error.code).toBe(PlanErrorCode.PLAN_NOT_FOUND);
-            }
-        });
-        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);
-                expect.fail('Directory should not exist');
-            }
-            catch {
-                // Expected - directory should not exist
-            }
-        });
+describe("PlanService", () => {
+  let mockLogger;
+  let tempDir;
+  let planService;
+  beforeEach(async () => {
+    mockLogger = createMockLogger();
+    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-plan-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 {
+    }
+  });
+  describe("exists", () => {
+    it("should return false for non-existent plan", async () => {
+      const exists = await planService.exists("non-existent-session");
+      expect(exists).toBe(false);
     });
+    it("should return true for existing plan", async () => {
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Test Plan");
+      const exists = await planService.exists(sessionId);
+      expect(exists).toBe(true);
+    });
+  });
+  describe("create", () => {
+    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 });
+      expect(plan.content).toBe(content);
+      expect(plan.meta.sessionId).toBe(sessionId);
+      expect(plan.meta.status).toBe("draft");
+      expect(plan.meta.title).toBe(title);
+      expect(plan.meta.createdAt).toBeGreaterThan(0);
+      expect(plan.meta.updatedAt).toBeGreaterThan(0);
+    });
+    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");
+        expect.fail("Should have thrown an error");
+      } catch (error) {
+        expect(error).toBeInstanceOf(DextoRuntimeError);
+        expect(error.code).toBe(PlanErrorCode.PLAN_ALREADY_EXISTS);
+      }
+    });
+    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");
+      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);
+      expect(meta.sessionId).toBe(sessionId);
+    });
+  });
+  describe("read", () => {
+    it("should return null for non-existent plan", async () => {
+      const plan = await planService.read("non-existent-session");
+      expect(plan).toBeNull();
+    });
+    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);
+      expect(plan).not.toBeNull();
+      expect(plan.content).toBe(content);
+      expect(plan.meta.sessionId).toBe(sessionId);
+      expect(plan.meta.title).toBe(title);
+    });
+    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);
+      expect(plan).not.toBeNull();
+      expect(plan.meta.sessionId).toBe(sessionId);
+      expect(plan.meta.status).toBe("draft");
+      expect(mockLogger.warn).toHaveBeenCalled();
+    });
+    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);
+      expect(plan).toBeNull();
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+  });
+  describe("update", () => {
+    it("should update plan content", async () => {
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Original Content");
+      const result = await planService.update(sessionId, "# Updated Content");
+      expect(result.oldContent).toBe("# Original Content");
+      expect(result.newContent).toBe("# Updated Content");
+      expect(result.meta.updatedAt).toBeGreaterThan(0);
+    });
+    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);
+      expect(updatedPlan.meta.title).toBe("My Title");
+      expect(updatedPlan.meta.createdAt).toBe(originalCreatedAt);
+    });
+    it("should throw error when plan does not exist", async () => {
+      try {
+        await planService.update("non-existent", "# Content");
+        expect.fail("Should have thrown an error");
+      } catch (error) {
+        expect(error).toBeInstanceOf(DextoRuntimeError);
+        expect(error.code).toBe(PlanErrorCode.PLAN_NOT_FOUND);
+      }
+    });
+  });
+  describe("updateMeta", () => {
+    it("should update plan status", async () => {
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Plan");
+      const meta = await planService.updateMeta(sessionId, { status: "approved" });
+      expect(meta.status).toBe("approved");
+    });
+    it("should update plan title", async () => {
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Plan");
+      const meta = await planService.updateMeta(sessionId, { title: "New Title" });
+      expect(meta.title).toBe("New Title");
+    });
+    it("should throw error when plan does not exist", async () => {
+      try {
+        await planService.updateMeta("non-existent", { status: "approved" });
+        expect.fail("Should have thrown an error");
+      } catch (error) {
+        expect(error).toBeInstanceOf(DextoRuntimeError);
+        expect(error.code).toBe(PlanErrorCode.PLAN_NOT_FOUND);
+      }
+    });
+  });
+  describe("delete", () => {
+    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);
+      expect(exists).toBe(false);
+    });
+    it("should throw error when plan does not exist", async () => {
+      try {
+        await planService.delete("non-existent");
+        expect.fail("Should have thrown an error");
+      } catch (error) {
+        expect(error).toBeInstanceOf(DextoRuntimeError);
+        expect(error.code).toBe(PlanErrorCode.PLAN_NOT_FOUND);
+      }
+    });
+    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);
+        expect.fail("Directory should not exist");
+      } catch {
+      }
+    });
+  });
 });