PlanMyProject

Current release: v2.0.0

Planning real engineering work is usually fragmented across notes, tickets, and chat. Execution drifts, priorities blur, and tasks lose context.

PlanMyProject solves this by turning your workspace into a single planning-and-execution loop:

• Keep one implementation plan in source control (planmyproject.md / projectplan.md)
• Expand any task into actionable sub-tasks with Copilot
• Debate task scope with PlanBot before committing to implementation
• Auto-maintain an execution queue from leaf tasks
• Implement selected tasks directly into workspace files with safety checks and approvals

If you want to go from idea -> plan -> code without leaving VS Code, this extension is built for that workflow.

Build Status

Last updated: 2026-10-12T09:43:15.956Z

• Overall build status: PASS
• Test coverage: 148/148 tests passing (100.00%), failed: 0
• Code coverage (all files): lines 61.82% | branches 73.59% | functions 70.53%
• Feature coverage: 11.5/12 requirements (95.83%)

Update source: npm run build or npm run verify

Requirements

1. VS Code 1.95+
2. Trusted workspace (untrusted workspaces are not supported)
3. AI provider access for planning/implementation:
   • GitHub Copilot (default)
   • Anthropic Claude (optional API key)
   • OpenAI (optional API key)

Get Started

1. Run PlanMyProject: Open Plan
2. Add a root objective with PlanMyProject: Add Root Task
3. Select that task and run PlanMyProject: Plan Task (One Level) (or Alt+P)
4. Repeat planning on child tasks to deepen the plan
5. Run PlanMyProject: Implement Task on a leaf task to apply changes

Supported plan files in workspace root (priority order):

• planmyproject.md
• projectplan.md

Features and Examples

1) Single source-of-truth plan file

• Uses one root plan file and creates planmyproject.md if none exists
• Watches plan file changes and keeps UI in sync

Example:

Command: PlanMyProject: Open Plan
Result: /workspace/planmyproject.md is created with initial schema scaffold

2) Markdown schema with auto-generated execution queue

• Writes schema with:
  • ## Plan Tree
  • ## Execution Queue (Auto-Generated, Leaf Tasks Only)
• Queue is derived from current leaf tasks

Example:

# Project Plan

<!-- pmp:schema=v1 -->

## Plan Tree
- [ ] [T0001] Build auth system
  <!-- pmp:id=T0001;parent=ROOT -->

  - [ ] [T0002] Create login API
    <!-- pmp:id=T0002;parent=T0001 -->

## Execution Queue (Auto-Generated, Leaf Tasks Only)
1. [T0002] Create login API

3) Load root tasks from requirements markdown

• Command: PlanMyProject: Load Requirements File
• Imports top-level tasks from a root .md file
• Supports Append or Replace when plan already has tasks

Example:

requirements.md:
- Build authentication module
- Add role-based authorization

Command: PlanMyProject: Load Requirements File
Result: root tasks are added with generated IDs

4) Manual task creation

• PlanMyProject: Add Root Task creates a root task
• PlanMyProject: Add Task creates a child task under selected task
• In the tree view, the title-bar add button creates a new root task, while the item inline add action creates a child task for that item

Example:

Select [T0001] Build auth
Run: PlanMyProject: Add Task
Input: "Create login endpoint"
Result: child [T0002] appears under [T0001]

5) One-level AI planning (recursive by rerun)

• Plan Task only creates immediate children of the selected task
• If children already exist, you choose:
  • Refine existing children
  • Replace existing children
• Copilot output is streamed into the plan file

Example:

Task: [T0001] Build auth
Run: PlanMyProject: Plan Task (One Level)
Result: [T0002..T0005] created as direct children

6) Implement task with AI JSON writes

• Implement Task asks Copilot for structured JSON changes
• Applies create/update file writes in workspace
• Blocks implementation tasks that have unresolved debate threads
• Marks selected task subtree [x] on successful apply

Example response format:

{
  "summary": "Added auth routes and controller",
  "taskCompleted": true,
  "changes": [
    { "path": "src/auth/routes.ts", "content": "..." },
    { "path": "src/auth/controller.ts", "content": "..." }
  ],
  "tests": ["npm test"],
  "risks": ["Token refresh flow pending"]
}

7) Tree view, CodeLens, and drill-down workflow

• Activity Bar container: PlanMyProject -> Implementation Tree
• Tree toolbar add action creates root tasks without depending on current editor selection
• Task actions in tree context menu: Add, Plan, Implement, Drill, Delete
• While a request is running, the active task item shows live progress/status directly in that item
• Running task item exposes Cancel Active Request and hides other inline actions
• CodeLens on task lines: Plan | Drill | Implement
• Click tree item to jump to task line (Drill Down)

Example:

Click [T0005] in Implementation Tree
Result: editor jumps to [T0005] in plan file

8) Status propagation and in-item progress

• Status values: [ ], [/], [x]
• Parent status is derived from child states
• Leaf tasks get execute gutter icon; non-leaf tasks get planning icon
• Plan/Implement progress is shown on the currently processed task item (spinner/check/error/cancel icons)
• Active request can be cancelled from the task inline action or PlanMyProject: Cancel Active Request

Example:

Children: [x], [ ]
Parent becomes [/]

9) Safe delete and queue rebuild

• PlanMyProject: Delete Task removes selected subtree (with confirmation)
• PlanMyProject: Rebuild Execution Queue recalculates queue from leaves

Example:

Delete [T0003]
Result: [T0003] and descendants removed, queue updated

10) Debate with PlanBot + debate-resolution gate

• Debate panel labels assistant responses as PlanBot
• Debate prompts enforce a critical style: justify, challenge, and rationalize user suggestions
• Debate logs persist explicit action metadata (for example [action:accept]) in plan and archive entries
• Queue and tree mark implementation tasks blocked until open debate threads are resolved

Command Reference

• PlanMyProject: Open Plan
• PlanMyProject: Plan Task (One Level) (Alt+P)
• PlanMyProject: Add Task
• PlanMyProject: Add Root Task
• PlanMyProject: Drill Down Task
• PlanMyProject: Implement Task
• PlanMyProject: Delete Task
• PlanMyProject: Rebuild Execution Queue
• PlanMyProject: Refresh Tree
• PlanMyProject: Cancel Active Request
• PlanMyProject: Set Project Goal
• PlanMyProject: Import Goal Statement
• PlanMyProject: Refresh Scan
• PlanMyProject: Debate Task
• PlanMyProject: Mark Research Complete
• PlanMyProject: Show Task Rationale
• PlanMyProject: View Linked Files
• PlanMyProject: Set Task File Send Policy
• PlanMyProject: View Research Index
• PlanMyProject: View Debate Archive
• PlanMyProject: Export Plan Summary
• PlanMyProject: Scan Task
• PlanMyProject: Infer Tasks From Scan
• PlanMyProject: Set API Key
• PlanMyProject: Undo Last Change

Privacy and AI Data Flow

AI requests only happen for AI-backed actions and only after consent (planmyproject.requireAiConsent).

• Per-request approval, or one approval per session
• Prompt masking always redacts common secrets (cloud keys, GitHub/GitLab/Slack tokens, JWTs, database connection strings, quoted password/secret/token/api_key fields) before anything is sent
• Optional masking of email addresses and IP addresses: planmyproject.masking.maskEmails, planmyproject.masking.maskIpAddresses (both off by default)
• Linked files under .env*, .git/, .vscode/, .github/ and .devcontainer/ are never sent, and the warning names each refused file. Lockfiles and build configs (tsconfig*, ESLint, Prettier, etc.) can still be sent as context, and get an extra confirmation when written
• Claude and OpenAI API keys live in VS Code secure storage, never in settings files. A key found in settings.json is moved there and removed
• Safety settings cannot be weakened by a workspace: aiProvider, sendFileContentsToAI, defaultTaskFileSendPolicy and requireAiConsent ignore workspace values, and researchGate / confidenceThreshold accept a workspace value only if it is stricter than yours
• After Set Project Goal or Import Goal Statement, a wording review sends the goal text to your AI provider (with the same consent and masking) to suggest spelling fixes. Declining it keeps your text unchanged

Supported Workspace Edits

When implementation JSON is valid and approved:

• Supported:
  • create files
  • update files
  • create parent directories
• Safety:
  • workspace-relative paths only
  • rejects absolute paths and .. traversal
  • blocks writes that resolve outside workspace root (including symlink-escape ancestors)
  • if duplicate paths are returned, the last one wins
• Not supported:
  • file deletion
  • file rename/move

Troubleshooting

1. Open a workspace folder (not a single loose file).
2. Ensure VS Code is 1.95+.
3. Confirm Copilot is available for planning/implementation commands.
4. Keep plan file in root as planmyproject.md or projectplan.md.
5. Use PlanMyProject: Refresh Tree and PlanMyProject: Rebuild Execution Queue after heavy manual edits.