@dexto/tools-plan 1.5.8 → 1.6.0

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

@@ -12,22 +12,34 @@ import { PlanService } from '../plan-service.js';
 import { PlanErrorCode } from '../errors.js';
 import { DextoRuntimeError } from '@dexto/core';
 // Create mock logger
-const createMockLogger = () => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    createChild: vi.fn().mockReturnThis(),
-});
+const createMockLogger = () => {
+    const logger = {
+        debug: vi.fn(),
+        silly: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        trackException: vi.fn(),
+        createChild: vi.fn(() => logger),
+        setLevel: vi.fn(),
+        getLevel: vi.fn(() => 'debug'),
+        getLogFilePath: vi.fn(() => null),
+        destroy: vi.fn(async () => undefined),
+    };
+    return logger;
+};
+function createToolContext(logger, overrides = {}) {
+    return { logger, ...overrides };
+}
 describe('plan_update tool', () => {
-    let mockLogger;
+    let logger;
     let tempDir;
     let planService;
     beforeEach(async () => {
-        mockLogger = createMockLogger();
+        logger = createMockLogger();
         const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dexto-plan-update-test-'));
         tempDir = await fs.realpath(rawTempDir);
-        planService = new PlanService({ basePath: tempDir }, mockLogger);
+        planService = new PlanService({ basePath: tempDir }, logger);
         vi.clearAllMocks();
     });
     afterEach(async () => {
@@ -40,12 +52,12 @@ describe('plan_update tool', () => {
     });
     describe('generatePreview', () => {
         it('should return DiffDisplayData with unified diff', async () => {
-            const tool = createPlanUpdateTool(planService);
+            const 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';
             await planService.create(sessionId, originalContent);
-            const preview = (await tool.generatePreview({ content: newContent }, { sessionId }));
+            const preview = (await tool.generatePreview({ content: newContent }, createToolContext(logger, { sessionId })));
             expect(preview.type).toBe('diff');
             // Path is now absolute, check it ends with the expected suffix
             expect(preview.filename).toContain(sessionId);
@@ -56,10 +68,10 @@ describe('plan_update tool', () => {
             expect(preview.additions).toBeGreaterThan(0);
         });
         it('should throw error when plan does not exist', async () => {
-            const tool = createPlanUpdateTool(planService);
+            const tool = createPlanUpdateTool(async () => planService);
             const sessionId = 'test-session';
             try {
-                await tool.generatePreview({ content: '# New Content' }, { sessionId });
+                await tool.generatePreview({ content: '# New Content' }, createToolContext(logger, { sessionId }));
                 expect.fail('Should have thrown an error');
             }
             catch (error) {
@@ -68,9 +80,9 @@ describe('plan_update tool', () => {
             }
         });
         it('should throw error when sessionId is missing', async () => {
-            const tool = createPlanUpdateTool(planService);
+            const tool = createPlanUpdateTool(async () => planService);
             try {
-                await tool.generatePreview({ content: '# Content' }, {});
+                await tool.generatePreview({ content: '# Content' }, createToolContext(logger));
                 expect.fail('Should have thrown an error');
             }
             catch (error) {
@@ -79,24 +91,24 @@ describe('plan_update tool', () => {
             }
         });
         it('should show deletions in diff', async () => {
-            const tool = createPlanUpdateTool(planService);
+            const tool = createPlanUpdateTool(async () => planService);
             const sessionId = 'test-session';
             const originalContent = '# Plan\n\nLine to remove\nKeep this';
             const newContent = '# Plan\n\nKeep this';
             await planService.create(sessionId, originalContent);
-            const preview = (await tool.generatePreview({ content: newContent }, { sessionId }));
+            const preview = (await tool.generatePreview({ content: newContent }, createToolContext(logger, { sessionId })));
             expect(preview.deletions).toBeGreaterThan(0);
             expect(preview.unified).toContain('-Line to remove');
         });
     });
     describe('execute', () => {
         it('should update plan content and return success', async () => {
-            const tool = createPlanUpdateTool(planService);
+            const 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 }, { sessionId }));
+            const result = (await tool.execute({ content: newContent }, createToolContext(logger, { sessionId })));
             expect(result.success).toBe(true);
             // Path is now absolute, check it ends with the expected suffix
             expect(result.path).toContain(sessionId);
@@ -106,20 +118,20 @@ describe('plan_update tool', () => {
             expect(plan.content).toBe(newContent);
         });
         it('should include _display data with diff', async () => {
-            const tool = createPlanUpdateTool(planService);
+            const tool = createPlanUpdateTool(async () => planService);
             const sessionId = 'test-session';
             await planService.create(sessionId, '# Original');
-            const result = (await tool.execute({ content: '# Updated' }, { sessionId }));
+            const result = (await tool.execute({ content: '# Updated' }, createToolContext(logger, { sessionId })));
             expect(result._display).toBeDefined();
             expect(result._display.type).toBe('diff');
             expect(result._display.unified).toContain('-# Original');
             expect(result._display.unified).toContain('+# Updated');
         });
         it('should throw error when plan does not exist', async () => {
-            const tool = createPlanUpdateTool(planService);
+            const tool = createPlanUpdateTool(async () => planService);
             const sessionId = 'non-existent';
             try {
-                await tool.execute({ content: '# Content' }, { sessionId });
+                await tool.execute({ content: '# Content' }, createToolContext(logger, { sessionId }));
                 expect.fail('Should have thrown an error');
             }
             catch (error) {
@@ -128,9 +140,9 @@ describe('plan_update tool', () => {
             }
         });
         it('should throw error when sessionId is missing', async () => {
-            const tool = createPlanUpdateTool(planService);
+            const tool = createPlanUpdateTool(async () => planService);
             try {
-                await tool.execute({ content: '# Content' }, {});
+                await tool.execute({ content: '# Content' }, createToolContext(logger));
                 expect.fail('Should have thrown an error');
             }
             catch (error) {
@@ -139,11 +151,11 @@ describe('plan_update tool', () => {
             }
         });
         it('should preserve plan status after update', async () => {
-            const tool = createPlanUpdateTool(planService);
+            const 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' }, { sessionId });
+            await tool.execute({ content: '# Updated Plan' }, createToolContext(logger, { sessionId }));
             const plan = await planService.read(sessionId);
             expect(plan.meta.status).toBe('approved');
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/tools-plan",
-  "version": "1.5.8",
+  "version": "1.6.0",
   "description": "Implementation planning tools with session-linked plans",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,14 +12,13 @@
     }
   },
   "files": [
-    "dist",
-    ".dexto-plugin",
-    "skills"
+    "dist"
   ],
   "dependencies": {
     "diff": "^7.0.0",
     "zod": "^3.24.1",
-    "@dexto/core": "1.5.8"
+    "@dexto/agent-config": "1.6.0",
+    "@dexto/core": "1.6.0"
   },
   "devDependencies": {
     "@types/diff": "^7.0.0",

package/.dexto-plugin/plugin.json

@@ -1,7 +0,0 @@
-{
-  "name": "plan-tools",
-  "version": "0.1.0",
-  "description": "Implementation planning tools with session-linked plans. Create, read, and update plans tied to your session.",
-  "author": "Dexto",
-  "customToolProviders": ["plan-tools"]
-}

package/dist/tool-provider.d.ts

@@ -1,44 +0,0 @@
-/**
- * Plan Tools Provider
- *
- * 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';
-import type { CustomToolProvider } from '@dexto/core';
-/**
- * Configuration schema for Plan tools provider
- */
-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;
-}>;
-type PlanToolsConfig = z.output<typeof PlanToolsConfigSchema>;
-/**
- * Plan tools provider
- *
- * Provides implementation planning tools:
- * - plan_create: Create a new plan with markdown content
- * - plan_read: Read the current plan
- * - plan_update: Update existing plan (shows diff preview)
- * - plan_review: Request user review of the plan (shows plan with approval options)
- *
- * Plans are stored in .dexto/plans/{sessionId}/ with:
- * - plan.md: Markdown content with checkboxes (- [ ] and - [x])
- * - plan-meta.json: Metadata (status, title, timestamps)
- */
-export declare const planToolsProvider: CustomToolProvider<'plan-tools', PlanToolsConfig>;
-export {};
-//# sourceMappingURL=tool-provider.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tool-provider.d.ts","sourceRoot":"","sources":["../src/tool-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAqC,MAAM,aAAa,CAAC;AAazF;;GAEG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;EAcd,CAAC;AAEd,KAAK,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE9D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,YAAY,EAAE,eAAe,CAwC/E,CAAC"}

package/dist/tool-provider.js

@@ -1,81 +0,0 @@
-/**
- * Plan Tools Provider
- *
- * 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 * as path from 'node:path';
-import { z } from 'zod';
-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';
-/**
- * Available plan tool names for enabledTools configuration
- */
-const PLAN_TOOL_NAMES = ['plan_create', 'plan_read', 'plan_update', 'plan_review'];
-/**
- * Configuration schema for Plan tools provider
- */
-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();
-/**
- * Plan tools provider
- *
- * Provides implementation planning tools:
- * - plan_create: Create a new plan with markdown content
- * - plan_read: Read the current plan
- * - plan_update: Update existing plan (shows diff preview)
- * - plan_review: Request user review of the plan (shows plan with approval options)
- *
- * Plans are stored in .dexto/plans/{sessionId}/ with:
- * - plan.md: Markdown content with checkboxes (- [ ] and - [x])
- * - plan-meta.json: Metadata (status, title, timestamps)
- */
-export const planToolsProvider = {
-    type: 'plan-tools',
-    configSchema: PlanToolsConfigSchema,
-    create: (config, context) => {
-        const { logger } = context;
-        // Resolve base path (relative to cwd or absolute)
-        const basePath = path.isAbsolute(config.basePath)
-            ? config.basePath
-            : path.join(process.cwd(), config.basePath);
-        logger.debug(`Creating PlanService with basePath: ${basePath}`);
-        const planService = new PlanService({ basePath }, logger);
-        // Build tool map for selective enabling
-        const toolCreators = {
-            plan_create: () => createPlanCreateTool(planService),
-            plan_read: () => createPlanReadTool(planService),
-            plan_update: () => createPlanUpdateTool(planService),
-            plan_review: () => createPlanReviewTool(planService),
-        };
-        // Determine which tools to create
-        const toolsToCreate = config.enabledTools ?? PLAN_TOOL_NAMES;
-        if (config.enabledTools) {
-            logger.debug(`Creating subset of plan tools: ${toolsToCreate.join(', ')}`);
-        }
-        // Create and return only the enabled tools
-        return toolsToCreate.map((toolName) => toolCreators[toolName]());
-    },
-    metadata: {
-        displayName: 'Plan Tools',
-        description: 'Create and manage implementation plans linked to sessions',
-        category: 'planning',
-    },
-};

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

@@ -1,7 +0,0 @@
-/**
- * Plan Tools Provider Tests
- *
- * Tests for the planToolsProvider configuration and tool creation.
- */
-export {};
-//# sourceMappingURL=tool-provider.test.d.ts.map

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

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

package/dist/tool-provider.test.js

@@ -1,185 +0,0 @@
-/**
- * Plan Tools Provider Tests
- *
- * Tests for the planToolsProvider configuration and tool creation.
- */
-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 { planToolsProvider } from './tool-provider.js';
-// Create mock logger
-const createMockLogger = () => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    createChild: vi.fn().mockReturnThis(),
-});
-// Create mock context with logger and minimal agent
-const createMockContext = (logger) => ({
-    logger: logger,
-    agent: {}, // Minimal mock - provider only uses logger
-});
-describe('planToolsProvider', () => {
-    let mockLogger;
-    let tempDir;
-    let originalCwd;
-    beforeEach(async () => {
-        mockLogger = createMockLogger();
-        // Create temp directory for testing
-        const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dexto-provider-test-'));
-        tempDir = await fs.realpath(rawTempDir);
-        // Store original cwd and mock process.cwd to return temp dir
-        originalCwd = process.cwd();
-        vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
-        vi.clearAllMocks();
-    });
-    afterEach(async () => {
-        // Restore mocked process.cwd
-        vi.mocked(process.cwd).mockRestore();
-        try {
-            await fs.rm(tempDir, { recursive: true, force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    });
-    describe('provider metadata', () => {
-        it('should have correct type', () => {
-            expect(planToolsProvider.type).toBe('plan-tools');
-        });
-        it('should have metadata', () => {
-            expect(planToolsProvider.metadata).toBeDefined();
-            expect(planToolsProvider.metadata?.displayName).toBe('Plan Tools');
-            expect(planToolsProvider.metadata?.category).toBe('planning');
-        });
-    });
-    describe('config schema', () => {
-        it('should validate minimal config', () => {
-            const result = planToolsProvider.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 = planToolsProvider.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 = planToolsProvider.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 = planToolsProvider.configSchema.safeParse({
-                type: 'plan-tools',
-                enabledTools: ['invalid_tool'],
-            });
-            expect(result.success).toBe(false);
-        });
-        it('should reject unknown properties', () => {
-            const result = planToolsProvider.configSchema.safeParse({
-                type: 'plan-tools',
-                unknownProp: 'value',
-            });
-            expect(result.success).toBe(false);
-        });
-    });
-    describe('create', () => {
-        it('should create all tools by default', () => {
-            const config = planToolsProvider.configSchema.parse({
-                type: 'plan-tools',
-            });
-            const tools = planToolsProvider.create(config, createMockContext(mockLogger));
-            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 = planToolsProvider.configSchema.parse({
-                type: 'plan-tools',
-                enabledTools: ['plan_create', 'plan_read'],
-            });
-            const tools = planToolsProvider.create(config, createMockContext(mockLogger));
-            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');
-        });
-        it('should create single tool', () => {
-            const config = planToolsProvider.configSchema.parse({
-                type: 'plan-tools',
-                enabledTools: ['plan_update'],
-            });
-            const tools = planToolsProvider.create(config, createMockContext(mockLogger));
-            expect(tools).toHaveLength(1);
-            expect(tools[0].id).toBe('plan_update');
-        });
-        it('should use relative basePath from cwd', () => {
-            const config = planToolsProvider.configSchema.parse({
-                type: 'plan-tools',
-                basePath: '.dexto/plans',
-            });
-            planToolsProvider.create(config, createMockContext(mockLogger));
-            // Verify debug log was called with resolved path
-            expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining(path.join(tempDir, '.dexto/plans')));
-        });
-        it('should use absolute basePath as-is', () => {
-            const absolutePath = '/absolute/path/to/plans';
-            const config = planToolsProvider.configSchema.parse({
-                type: 'plan-tools',
-                basePath: absolutePath,
-            });
-            planToolsProvider.create(config, createMockContext(mockLogger));
-            expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining(absolutePath));
-        });
-        it('should log when creating subset of tools', () => {
-            const config = planToolsProvider.configSchema.parse({
-                type: 'plan-tools',
-                enabledTools: ['plan_create'],
-            });
-            planToolsProvider.create(config, createMockContext(mockLogger));
-            expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining('Creating subset of plan tools'));
-        });
-    });
-    describe('tool descriptions', () => {
-        it('should have descriptions for all tools', () => {
-            const config = planToolsProvider.configSchema.parse({
-                type: 'plan-tools',
-            });
-            const tools = planToolsProvider.create(config, createMockContext(mockLogger));
-            for (const tool of tools) {
-                expect(tool.description).toBeDefined();
-                expect(tool.description.length).toBeGreaterThan(0);
-            }
-        });
-        it('should have input schemas for all tools', () => {
-            const config = planToolsProvider.configSchema.parse({
-                type: 'plan-tools',
-            });
-            const tools = planToolsProvider.create(config, createMockContext(mockLogger));
-            for (const tool of tools) {
-                expect(tool.inputSchema).toBeDefined();
-            }
-        });
-    });
-});

package/skills/plan/SKILL.md

@@ -1,102 +0,0 @@
----
-name: plan
-description: Enter planning mode to create and manage implementation plans
-user-invocable: true
----
-
-# Planning Mode - PLAN FIRST, THEN IMPLEMENT
-
-**CRITICAL**: You are in planning mode. You MUST create and get approval for a plan BEFORE writing any code or making any changes.
-
-## MANDATORY WORKFLOW
-
-**DO NOT skip these steps. DO NOT start implementing until the plan is approved.**
-
-1. **Research first** (if needed): Use the explore agent or read relevant files to understand the codebase
-2. **Check for existing plan**: Use `plan_read` to see if a plan exists
-3. **Create/update plan**: Use `plan_create` or `plan_update` to define your approach
-4. **Request review**: Use `plan_review` to get user approval
-5. **WAIT for approval**: Only proceed to implementation after user approves
-6. **Implement**: Execute the approved plan, updating checkboxes as you go
-
-## Research Phase
-
-Before creating your plan, you should understand the codebase:
-
-- **Use the explore agent** (spawn_agent with subagent_type="Explore") to search for relevant code, patterns, and existing implementations
-- **Read key files** to understand the current architecture
-- **Identify dependencies** and files that will need changes
-
-This research informs your plan and prevents wasted effort from incorrect assumptions.
-
-## Available Tools
-
-- **plan_create**: Create a new plan (REQUIRED before any implementation)
-- **plan_read**: Read the current plan
-- **plan_update**: Update the existing plan (shows diff preview)
-- **plan_review**: Request user review - returns approve/iterate/reject with feedback
-
-## WHAT YOU MUST DO NOW
-
-1. **Research**: Use the explore agent or read files to understand the relevant parts of the codebase
-2. **Check plan**: Use `plan_read` to check if a plan already exists
-3. **Create plan**: Use `plan_create` to create a comprehensive plan based on your research
-4. **Get approval**: Use `plan_review` to request user approval
-5. **STOP and WAIT** - do not write any code until the user approves via plan_review
-
-## Plan Structure
-
-```markdown
-# {Title}
-
-## Objective
-{Clear statement of what we're building/fixing}
-
-## Steps
-
-### 1. {Step Name}
-- [ ] {Task description}
-- [ ] {Task description}
-Files: `path/to/file.ts`, `path/to/other.ts`
-
-### 2. {Step Name}
-- [ ] {Task description}
-Files: `path/to/file.ts`
-
-## Considerations
-- {Edge cases to handle}
-- {Error scenarios}
-
-## Success Criteria
-- {How we know we're done}
-```
-
-## Guidelines
-
-- **Break down complex tasks** into clear, sequential steps
-- **Include specific file paths** that will be created or modified
-- **Note dependencies** between steps
-- **Keep plans concise** but complete
-
-## Handling Review Responses
-
-After calling `plan_review`, handle the response:
-
-- **approve**: User approved - proceed with implementation
-- **iterate**: User wants changes - update the plan based on feedback, then call `plan_review` again
-- **reject**: User rejected - ask what they want instead
-
-## DO NOT
-
-- ❌ Start writing code before creating a plan
-- ❌ Skip the plan_review step
-- ❌ Assume approval - wait for explicit user response
-- ❌ Make changes outside the approved plan without updating it first
-
----
-
-**START NOW**:
-1. Research the codebase using the explore agent if needed
-2. Use `plan_read` to check for an existing plan
-3. Use `plan_create` to create your plan
-4. Use `plan_review` to get approval before any implementation