@dexto/tools-plan 1.5.8 → 1.6.0

package/dist/index.d.ts

@@ -3,32 +3,8 @@
  *
  * Implementation planning tools with session-linked plans.
  * Provides tools for creating, reading, updating, and tracking plans.
- *
- * This package is a Dexto plugin that automatically registers:
- * - Custom tool provider: plan-tools
- * - Skill: plan (planning mode instructions)
- *
- * Usage:
- * 1. Install the package
- * 2. The plugin discovery will find .dexto-plugin/plugin.json
- * 3. Tools and skill are automatically registered
- */
-/**
- * Path to the plugin directory containing .dexto-plugin manifest.
- * Use this in image definitions to declare bundled plugins.
- *
- * @example
- * ```typescript
- * import { PLUGIN_PATH } from '@dexto/tools-plan';
- *
- * export default defineImage({
- *   bundledPlugins: [PLUGIN_PATH],
- *   // ...
- * });
- * ```
  */
-export declare const PLUGIN_PATH: string;
-export { planToolsProvider } from './tool-provider.js';
+export { planToolsFactory } from './tool-factory.js';
 export { PlanService } from './plan-service.js';
 export type { Plan, PlanMeta, PlanStatus, PlanServiceOptions, PlanUpdateResult } from './types.js';
 export { PlanError, PlanErrorCode, type PlanErrorCodeType } from './errors.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAOH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,QAAgC,CAAC;AAGzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAGvD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGnG,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAGrD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGnG,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -3,36 +3,9 @@
  *
  * Implementation planning tools with session-linked plans.
  * Provides tools for creating, reading, updating, and tracking plans.
- *
- * This package is a Dexto plugin that automatically registers:
- * - Custom tool provider: plan-tools
- * - Skill: plan (planning mode instructions)
- *
- * Usage:
- * 1. Install the package
- * 2. The plugin discovery will find .dexto-plugin/plugin.json
- * 3. Tools and skill are automatically registered
- */
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-/**
- * Path to the plugin directory containing .dexto-plugin manifest.
- * Use this in image definitions to declare bundled plugins.
- *
- * @example
- * ```typescript
- * import { PLUGIN_PATH } from '@dexto/tools-plan';
- *
- * export default defineImage({
- *   bundledPlugins: [PLUGIN_PATH],
- *   // ...
- * });
- * ```
  */
-export const PLUGIN_PATH = path.resolve(__dirname, '..');
-// Tool provider (for direct registration if needed)
-export { planToolsProvider } from './tool-provider.js';
+// Tool factory (image-compatible)
+export { planToolsFactory } from './tool-factory.js';
 // Service (for advanced use cases)
 export { PlanService } from './plan-service.js';
 // Error utilities

package/dist/plan-service-getter.d.ts

@@ -0,0 +1,4 @@
+import type { ToolExecutionContext } from '@dexto/core';
+import type { PlanService } from './plan-service.js';
+export type PlanServiceGetter = (context: ToolExecutionContext) => Promise<PlanService>;
+//# sourceMappingURL=plan-service-getter.d.ts.map

package/dist/plan-service-getter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-service-getter.d.ts","sourceRoot":"","sources":["../src/plan-service-getter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC"}

package/dist/plan-service-getter.js

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

package/dist/plan-service.d.ts

@@ -6,7 +6,7 @@
  * - plan.md: The plan content
  * - plan-meta.json: Metadata (status, checkpoints, timestamps)
  */
-import type { IDextoLogger } from '@dexto/core';
+import type { Logger } from '@dexto/core';
 import type { Plan, PlanMeta, PlanServiceOptions, PlanUpdateResult } from './types.js';
 /**
  * Service for managing implementation plans.
@@ -14,7 +14,7 @@ import type { Plan, PlanMeta, PlanServiceOptions, PlanUpdateResult } from './typ
 export declare class PlanService {
     private basePath;
     private logger;
-    constructor(options: PlanServiceOptions, logger?: IDextoLogger);
+    constructor(options: PlanServiceOptions, logger: Logger);
     /**
      * Resolves and validates a session directory path.
      * Prevents path traversal attacks by ensuring the resolved path stays within basePath.

package/dist/plan-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plan-service.d.ts","sourceRoot":"","sources":["../src/plan-service.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAMvF;;GAEG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,MAAM,CAA2B;gBAE7B,OAAO,EAAE,kBAAkB,EAAE,MAAM,CAAC,EAAE,YAAY;IAK9D;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;;OAGG;IACI,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAI7C;;OAEG;IACH,OAAO,CAAC,WAAW;IAInB;;OAEG;IACG,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKjD;;;;;OAKG;IACG,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAoC7F;;;;OAIG;IACG,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAmDnD;;;;;OAKG;IACG,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAqC3E;;;;;OAKG;IACG,UAAU,CACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,GACrD,OAAO,CAAC,QAAQ,CAAC;IA2BpB;;;;;OAKG;IACG,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAYjD"}
+{"version":3,"file":"plan-service.d.ts","sourceRoot":"","sources":["../src/plan-service.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAMvF;;GAEG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,MAAM,CAAS;gBAEX,OAAO,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM;IAKvD;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;;OAGG;IACI,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAI7C;;OAEG;IACH,OAAO,CAAC,WAAW;IAInB;;OAEG;IACG,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKjD;;;;;OAKG;IACG,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAoC7F;;;;OAIG;IACG,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAiDnD;;;;;OAKG;IACG,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAqC3E;;;;;OAKG;IACG,UAAU,CACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,GACrD,OAAO,CAAC,QAAQ,CAAC;IA2BpB;;;;;OAKG;IACG,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAYjD"}

package/dist/plan-service.js

@@ -92,7 +92,7 @@ export class PlanService {
                 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}`);
+            this.logger.debug(`Created plan for session ${sessionId}`);
             return { content, meta };
         }
         catch (error) {
@@ -116,7 +116,7 @@ export class PlanService {
             const metaParsed = JSON.parse(metaContent);
             const metaResult = PlanMetaSchema.safeParse(metaParsed);
             if (!metaResult.success) {
-                this.logger?.warn(`Invalid plan metadata for session ${sessionId}, using defaults`);
+                this.logger.warn(`Invalid plan metadata for session ${sessionId}, using defaults`);
                 // Return with minimal metadata if parsing fails
                 return {
                     content,
@@ -139,11 +139,11 @@ export class PlanService {
             // 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}`);
+                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)}`);
+            this.logger.error(`Failed to read plan for session ${sessionId}: ${err.message ?? String(err)}`);
             throw PlanError.storageError('read', sessionId, err);
         }
     }
@@ -170,7 +170,7 @@ export class PlanService {
                 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}`);
+            this.logger.debug(`Updated plan for session ${sessionId}`);
             return {
                 oldContent,
                 newContent: content,
@@ -199,7 +199,7 @@ export class PlanService {
         };
         try {
             await fs.writeFile(this.getMetaPath(sessionId), JSON.stringify(updatedMeta, null, 2), 'utf-8');
-            this.logger?.debug(`Updated plan metadata for session ${sessionId}`);
+            this.logger.debug(`Updated plan metadata for session ${sessionId}`);
             return updatedMeta;
         }
         catch (error) {
@@ -218,7 +218,7 @@ export class PlanService {
         }
         try {
             await fs.rm(this.getPlanDir(sessionId), { recursive: true, force: true });
-            this.logger?.debug(`Deleted plan for session ${sessionId}`);
+            this.logger.debug(`Deleted plan for session ${sessionId}`);
         }
         catch (error) {
             throw PlanError.storageError('delete', sessionId, error);

package/dist/plan-service.test.js

@@ -13,10 +13,16 @@ import { DextoRuntimeError } from '@dexto/core';
 // Create mock logger
 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),
 });
 describe('PlanService', () => {
     let mockLogger;

package/dist/tool-factory-config.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Plan Tools Factory
+ *
+ * Provides implementation planning tools:
+ * - plan_create: Create a new plan for the session
+ * - plan_read: Read the current plan
+ * - plan_update: Update the existing plan
+ * - plan_review: Request user review of the plan (shows plan content with approval options)
+ */
+import { z } from 'zod';
+/**
+ * Available plan tool names for enabledTools configuration
+ */
+export declare const PLAN_TOOL_NAMES: readonly ["plan_create", "plan_read", "plan_update", "plan_review"];
+/**
+ * Configuration schema for Plan tools factory
+ */
+export declare const PlanToolsConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"plan-tools">;
+    basePath: z.ZodDefault<z.ZodString>;
+    enabledTools: z.ZodOptional<z.ZodArray<z.ZodEnum<["plan_create", "plan_read", "plan_update", "plan_review"]>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    type: "plan-tools";
+    basePath: string;
+    enabledTools?: ("plan_create" | "plan_read" | "plan_update" | "plan_review")[] | undefined;
+}, {
+    type: "plan-tools";
+    basePath?: string | undefined;
+    enabledTools?: ("plan_create" | "plan_read" | "plan_update" | "plan_review")[] | undefined;
+}>;
+export type PlanToolsConfig = z.output<typeof PlanToolsConfigSchema>;
+//# sourceMappingURL=tool-factory-config.d.ts.map

package/dist/tool-factory-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-factory-config.d.ts","sourceRoot":"","sources":["../src/tool-factory-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,eAAe,qEAAsE,CAAC;AAEnG;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;EAcrB,CAAC;AAEd,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/tool-factory-config.js

@@ -0,0 +1,30 @@
+/**
+ * Plan Tools Factory
+ *
+ * Provides implementation planning tools:
+ * - plan_create: Create a new plan for the session
+ * - plan_read: Read the current plan
+ * - plan_update: Update the existing plan
+ * - plan_review: Request user review of the plan (shows plan content with approval options)
+ */
+import { z } from 'zod';
+/**
+ * Available plan tool names for enabledTools configuration
+ */
+export const PLAN_TOOL_NAMES = ['plan_create', 'plan_read', 'plan_update', 'plan_review'];
+/**
+ * Configuration schema for Plan tools factory
+ */
+export const PlanToolsConfigSchema = z
+    .object({
+    type: z.literal('plan-tools'),
+    basePath: z
+        .string()
+        .default('.dexto/plans')
+        .describe('Base directory for plan storage (relative to working directory)'),
+    enabledTools: z
+        .array(z.enum(PLAN_TOOL_NAMES))
+        .optional()
+        .describe(`Subset of tools to enable. If not specified, all tools are enabled. Available: ${PLAN_TOOL_NAMES.join(', ')}`),
+})
+    .strict();

package/dist/tool-factory.d.ts

@@ -0,0 +1,4 @@
+import type { ToolFactory } from '@dexto/agent-config';
+import { type PlanToolsConfig } from './tool-factory-config.js';
+export declare const planToolsFactory: ToolFactory<PlanToolsConfig>;
+//# sourceMappingURL=tool-factory.d.ts.map

package/dist/tool-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-factory.d.ts","sourceRoot":"","sources":["../src/tool-factory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAQvD,OAAO,EAGH,KAAK,eAAe,EACvB,MAAM,0BAA0B,CAAC;AAKlC,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,eAAe,CAiCzD,CAAC"}

package/dist/tool-factory.js

@@ -0,0 +1,36 @@
+import * as path from 'node:path';
+import { PlanService } from './plan-service.js';
+import { createPlanCreateTool } from './tools/plan-create-tool.js';
+import { createPlanReadTool } from './tools/plan-read-tool.js';
+import { createPlanUpdateTool } from './tools/plan-update-tool.js';
+import { createPlanReviewTool } from './tools/plan-review-tool.js';
+import { PLAN_TOOL_NAMES, PlanToolsConfigSchema, } from './tool-factory-config.js';
+export const planToolsFactory = {
+    configSchema: PlanToolsConfigSchema,
+    metadata: {
+        displayName: 'Plan Tools',
+        description: 'Create and manage implementation plans linked to sessions',
+        category: 'planning',
+    },
+    create: (config) => {
+        const basePath = path.isAbsolute(config.basePath)
+            ? config.basePath
+            : path.join(process.cwd(), config.basePath);
+        let planService;
+        const getPlanService = async (context) => {
+            if (planService) {
+                return planService;
+            }
+            planService = new PlanService({ basePath }, context.logger);
+            return planService;
+        };
+        const toolCreators = {
+            plan_create: () => createPlanCreateTool(getPlanService),
+            plan_read: () => createPlanReadTool(getPlanService),
+            plan_update: () => createPlanUpdateTool(getPlanService),
+            plan_review: () => createPlanReviewTool(getPlanService),
+        };
+        const toolsToCreate = config.enabledTools ?? PLAN_TOOL_NAMES;
+        return toolsToCreate.map((toolName) => toolCreators[toolName]());
+    },
+};

package/dist/tool-factory.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Plan Tools Factory Tests
+ *
+ * Validates the plan tools factory schema and tool creation.
+ */
+export {};
+//# sourceMappingURL=tool-factory.test.d.ts.map

package/dist/tool-factory.test.d.ts.map

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

package/dist/tool-factory.test.js

@@ -0,0 +1,100 @@
+/**
+ * Plan Tools Factory Tests
+ *
+ * Validates the plan tools factory schema and tool creation.
+ */
+import { describe, it, expect } from 'vitest';
+import { planToolsFactory } from './tool-factory.js';
+describe('planToolsFactory', () => {
+    describe('factory metadata', () => {
+        it('should have metadata', () => {
+            expect(planToolsFactory.metadata).toBeDefined();
+            expect(planToolsFactory.metadata?.displayName).toBe('Plan Tools');
+            expect(planToolsFactory.metadata?.category).toBe('planning');
+        });
+    });
+    describe('config schema', () => {
+        it('should validate minimal config', () => {
+            const result = planToolsFactory.configSchema.safeParse({
+                type: 'plan-tools',
+            });
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.basePath).toBe('.dexto/plans');
+            }
+        });
+        it('should validate config with custom basePath', () => {
+            const result = planToolsFactory.configSchema.safeParse({
+                type: 'plan-tools',
+                basePath: '/custom/path',
+            });
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.basePath).toBe('/custom/path');
+            }
+        });
+        it('should validate config with enabledTools', () => {
+            const result = planToolsFactory.configSchema.safeParse({
+                type: 'plan-tools',
+                enabledTools: ['plan_create', 'plan_read'],
+            });
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.enabledTools).toEqual(['plan_create', 'plan_read']);
+            }
+        });
+        it('should reject invalid tool names', () => {
+            const result = planToolsFactory.configSchema.safeParse({
+                type: 'plan-tools',
+                enabledTools: ['invalid_tool'],
+            });
+            expect(result.success).toBe(false);
+        });
+        it('should reject unknown properties', () => {
+            const result = planToolsFactory.configSchema.safeParse({
+                type: 'plan-tools',
+                unknownProp: 'value',
+            });
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('create', () => {
+        it('should create all tools by default', () => {
+            const config = planToolsFactory.configSchema.parse({
+                type: 'plan-tools',
+            });
+            const tools = planToolsFactory.create(config);
+            expect(tools).toHaveLength(4);
+            const toolIds = tools.map((t) => t.id);
+            expect(toolIds).toContain('plan_create');
+            expect(toolIds).toContain('plan_read');
+            expect(toolIds).toContain('plan_update');
+            expect(toolIds).toContain('plan_review');
+        });
+        it('should create only enabled tools', () => {
+            const config = planToolsFactory.configSchema.parse({
+                type: 'plan-tools',
+                enabledTools: ['plan_create', 'plan_read'],
+            });
+            const tools = planToolsFactory.create(config);
+            expect(tools).toHaveLength(2);
+            const toolIds = tools.map((t) => t.id);
+            expect(toolIds).toContain('plan_create');
+            expect(toolIds).toContain('plan_read');
+            expect(toolIds).not.toContain('plan_update');
+        });
+    });
+    describe('tool definitions', () => {
+        it('should have descriptions and input schemas for all tools', () => {
+            const config = planToolsFactory.configSchema.parse({
+                type: 'plan-tools',
+            });
+            const tools = planToolsFactory.create(config);
+            for (const tool of tools) {
+                expect(tool.description).toBeDefined();
+                expect(tool.description.length).toBeGreaterThan(0);
+                expect(tool.inputSchema).toBeDefined();
+            }
+        });
+    });
+});

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

@@ -4,10 +4,22 @@
  * Creates a new implementation plan for the current session.
  * Shows a preview for approval before saving.
  */
-import type { InternalTool } from '@dexto/core';
-import type { PlanService } from '../plan-service.js';
+import { z } from 'zod';
+import type { Tool } from '@dexto/core';
+import type { PlanServiceGetter } from '../plan-service-getter.js';
+declare const PlanCreateInputSchema: z.ZodObject<{
+    title: z.ZodString;
+    content: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    title: string;
+    content: string;
+}, {
+    title: string;
+    content: string;
+}>;
 /**
  * Creates the plan_create tool
  */
-export declare function createPlanCreateTool(planService: PlanService): InternalTool;
+export declare function createPlanCreateTool(getPlanService: PlanServiceGetter): Tool<typeof PlanCreateInputSchema>;
+export {};
 //# sourceMappingURL=plan-create-tool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"plan-create-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-create-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAyC,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAgBtD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,WAAW,GAAG,YAAY,CAgE3E"}
+{"version":3,"file":"plan-create-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-create-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAyC,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAGnE,QAAA,MAAM,qBAAqB;;;;;;;;;EASd,CAAC;AAEd;;GAEG;AACH,wBAAgB,oBAAoB,CAChC,cAAc,EAAE,iBAAiB,GAClC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CA0EpC"}

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

@@ -5,6 +5,7 @@
  * Shows a preview for approval before saving.
  */
 import { z } from 'zod';
+import { defineTool } from '@dexto/core';
 import { PlanError } from '../errors.js';
 const PlanCreateInputSchema = z
     .object({
@@ -17,9 +18,10 @@ const PlanCreateInputSchema = z
 /**
  * Creates the plan_create tool
  */
-export function createPlanCreateTool(planService) {
-    return {
+export function createPlanCreateTool(getPlanService) {
+    return defineTool({
         id: 'plan_create',
+        displayName: 'Plan',
         description: 'Create a new implementation plan for the current session. Shows the plan for approval before saving. Use markdown format for the plan content with clear steps and file references.',
         inputSchema: PlanCreateInputSchema,
         /**
@@ -27,46 +29,55 @@ export function createPlanCreateTool(planService) {
          */
         generatePreview: async (input, context) => {
             const { content } = input;
-            if (!context?.sessionId) {
+            if (!context.sessionId) {
                 throw PlanError.sessionIdRequired();
             }
+            const resolvedPlanService = await getPlanService(context);
             // Check if plan already exists
-            const exists = await planService.exists(context.sessionId);
+            const exists = await resolvedPlanService.exists(context.sessionId);
             if (exists) {
                 throw PlanError.planAlreadyExists(context.sessionId);
             }
             // Return preview for approval UI
             const lineCount = content.split('\n').length;
-            const planPath = planService.getPlanPath(context.sessionId);
+            const planPath = resolvedPlanService.getPlanPath(context.sessionId);
             return {
                 type: 'file',
                 path: planPath,
                 operation: 'create',
                 content,
-                size: content.length,
+                size: Buffer.byteLength(content, 'utf8'),
                 lineCount,
             };
         },
-        execute: async (input, context) => {
+        async execute(input, context) {
             const { title, content } = input;
-            if (!context?.sessionId) {
+            if (!context.sessionId) {
                 throw PlanError.sessionIdRequired();
             }
-            const plan = await planService.create(context.sessionId, content, { title });
-            const planPath = planService.getPlanPath(context.sessionId);
+            const resolvedPlanService = await getPlanService(context);
+            // Keep consistent with generatePreview: fail early if plan already exists.
+            // (PlanService.create also guards this, but this keeps the control flow obvious.)
+            const exists = await resolvedPlanService.exists(context.sessionId);
+            if (exists) {
+                throw PlanError.planAlreadyExists(context.sessionId);
+            }
+            const plan = await resolvedPlanService.create(context.sessionId, content, { title });
+            const planPath = resolvedPlanService.getPlanPath(context.sessionId);
+            const _display = {
+                type: 'file',
+                path: planPath,
+                operation: 'create',
+                size: Buffer.byteLength(content, 'utf8'),
+                lineCount: content.split('\n').length,
+            };
             return {
                 success: true,
                 path: planPath,
                 status: plan.meta.status,
                 title: plan.meta.title,
-                _display: {
-                    type: 'file',
-                    path: planPath,
-                    operation: 'create',
-                    size: content.length,
-                    lineCount: content.split('\n').length,
-                },
+                _display,
             };
         },
-    };
+    });
 }