ai-devkit 0.12.0 → 0.14.0

package/dist/templates/templates/commands/update-planning.md

@@ -1,65 +1,10 @@
 ---
-description: Assist in updating planning documentation to reflect current implementation progress for a feature.
+description: Update planning docs to reflect implementation progress.
 ---
 
-# Planning Update Assistant
-
-Please help me reconcile the current implementation progress with our planning documentation.
-
-## Step 1: Gather Context
-Ask me for:
-- Feature/branch name and brief status
-- Tasks completed since last update
-- Any new tasks discovered
-- Current blockers or risks
-- Relevant planning docs (e.g., `docs/ai/planning/feature-{name}.md`)
-
-## Step 2: Review Planning Doc
-If a planning doc exists:
-- Summarize existing milestones and task breakdowns
-- Note expected sequencing and dependencies
-- Identify outstanding tasks in the plan
-
-## Step 3: Reconcile Progress
-For each planned task:
-- Mark status (done / in progress / blocked / not started)
-- Note actual work completed vs. planned scope
-- Record blockers or changes in approach
-- Identify tasks that were skipped or added
-
-## Step 4: Update Task List
-Help me produce an updated checklist such as:
-```
-### Current Status: [Feature Name]
-
-#### Done
-- [x] Task A - short note on completion or link to commit/pr
-- [x] Task B
-
-#### In Progress
-- [ ] Task C - waiting on [dependency]
-
-#### Blocked
-- [ ] Task D - blocked by [issue/owner]
-
-#### Newly Discovered Work
-- [ ] Task E - reason discovered
-- [ ] Task F - due by [date]
-```
-
-## Step 5: Next Steps & Priorities
-- Suggest the next 2-3 actionable tasks
-- Highlight risky areas needing attention
-- Recommend coordination (design changes, stakeholder sync, etc.)
-- List documentation updates needed
-
-## Step 6: Summary for Planning Doc
-Prepare a summary paragraph to copy into the planning doc, covering:
-- Current state and progress
-- Major risks/blockers
-- Upcoming focus items
-- Any changes to scope or timeline
-
----
-Let me know when you're ready to begin the planning update.
+Help me reconcile current implementation progress with the planning documentation.
 
+1. **Gather Context** — If not already provided, ask for: feature/branch name and brief status, tasks completed since last update, new tasks discovered, current blockers or risks, and planning doc path (default `docs/ai/planning/feature-{name}.md`).
+2. **Review & Reconcile** — Summarize existing milestones, task breakdowns, and dependencies from the planning doc. For each planned task: mark status (done / in progress / blocked / not started), note scope changes, record blockers, identify skipped or added tasks.
+3. **Produce Updated Task List** — Generate an updated checklist grouped by: Done, In Progress, Blocked, Newly Discovered Work — with short notes per task.
+4. **Next Steps & Summary** — Suggest the next 2-3 actionable tasks and highlight risky areas. Prepare a summary paragraph for the planning doc covering: current state, major risks/blockers, upcoming focus, and any scope/timeline changes.

package/dist/templates/templates/commands/writing-test.md

@@ -4,45 +4,9 @@ description: Add tests for a new feature.
 
 Review `docs/ai/testing/feature-{name}.md` and ensure it mirrors the base template before writing tests.
 
-## Step 1: Gather Context
-Ask me for:
-- Feature name and branch
-- Summary of what changed (link to design & requirements docs)
-- Target environment (backend, frontend, full-stack)
-- Existing automated test suites (unit, integration, E2E)
-- Any flaky or slow tests to avoid
-
-## Step 2: Analyze Testing Template
-- Identify required sections from `docs/ai/testing/feature-{name}.md` (unit, integration, manual verification, coverage targets)
-- Confirm success criteria and edge cases from requirements & design docs
-- Note any mocks/stubs or fixtures already available
-
-## Step 3: Unit Tests (Aim for 100% coverage)
-For each module/function:
-1. List behavior scenarios (happy path, edge cases, error handling)
-2. Generate concrete test cases with assertions and inputs
-3. Reference existing utilities/mocks to accelerate implementation
-4. Provide pseudocode or actual test snippets
-5. Highlight potential missing branches preventing full coverage
-
-## Step 4: Integration Tests
-1. Identify critical flows that span multiple components/services
-2. Define setup/teardown steps (databases, APIs, queues)
-3. Outline test cases validating interaction boundaries, data contracts, and failure modes
-4. Suggest instrumentation/logging to debug failures
-
-## Step 5: Coverage Strategy
-- Recommend tooling commands (e.g., `npm run test -- --coverage`)
-- Call out files/functions that still need coverage and why
-- Suggest additional tests if coverage <100%
-
-## Step 6: Manual & Exploratory Testing
-- Propose manual test checklist covering UX, accessibility, and error handling
-- Identify exploratory scenarios or chaos/failure injection tests if relevant
-
-## Step 7: Update Documentation & TODOs
-- Summarize which tests were added or still missing
-- Update `docs/ai/testing/feature-{name}.md` sections with links to test files and results
-- Flag follow-up tasks for deferred tests (with owners/dates)
-
-Let me know when you have the latest code changes ready; we'll write tests together until we hit 100% coverage.
+1. **Gather Context** — If not already provided, ask for: feature name/branch, summary of changes (link to design & requirements docs), target environment, existing test suites, and any flaky/slow tests to avoid.
+2. **Analyze Testing Template** — Identify required sections from `docs/ai/testing/feature-{name}.md`. Confirm success criteria and edge cases from requirements & design docs. Note available mocks/stubs/fixtures.
+3. **Unit Tests (aim for 100% coverage)** — For each module/function: list behavior scenarios (happy path, edge cases, error handling), generate test cases with assertions using existing utilities/mocks, and highlight missing branches preventing full coverage.
+4. **Integration Tests** — Identify critical cross-component flows. Define setup/teardown steps and test cases for interaction boundaries, data contracts, and failure modes.
+5. **Coverage Strategy** — Recommend coverage tooling commands. Call out files/functions still needing coverage and suggest additional tests if <100%.
+6. **Update Documentation** — Summarize tests added or still missing. Update `docs/ai/testing/feature-{name}.md` with links to test files and results. Flag deferred tests as follow-up tasks.

package/dist/templates/templates/env/base.md

@@ -57,7 +57,7 @@ The AI assistant should proactively use knowledge memory throughout all interact
 
 **How to search**:
 - Use `memory.searchKnowledge` MCP tool with relevant keywords, tags, and scope
-- If MCP tools are unavailable, use `npx ai-devkit memory search` CLI command (see memory skill for details)
+- If MCP tools are unavailable, use `npx ai-devkit@latest memory search` CLI command (see memory skill for details)
 - Example: Search for "authentication patterns" when implementing auth features
 
 ### When to Store Memory
@@ -68,7 +68,7 @@ The AI assistant should proactively use knowledge memory throughout all interact
 
 **How to store**:
 - Use `memory.storeKnowledge` MCP tool
-- If MCP tools are unavailable, use `npx ai-devkit memory store` CLI command (see memory skill for details)
+- If MCP tools are unavailable, use `npx ai-devkit@latest memory store` CLI command (see memory skill for details)
 - Include clear title, detailed content, relevant tags, and appropriate scope
 - Make knowledge specific and actionable, not generic advice
 

package/dist/util/git.d.ts

@@ -1,3 +1,8 @@
+export type GitExecFileSync = (file: string, args: readonly string[], options?: {
+    cwd?: string;
+    stdio?: 'ignore' | 'pipe';
+    encoding?: BufferEncoding;
+}) => string | Buffer;
 /**
  * Checks if git is installed and available in PATH
  * @throws Error if git is not installed
@@ -31,4 +36,7 @@ export declare function pullRepository(repoPath: string): Promise<void>;
  * @throws Error if fetch fails or cannot parse output
  */
 export declare function fetchGitHead(gitUrl: string): Promise<string>;
+export declare function isInsideGitWorkTreeSync(cwd: string, execFileSyncFn?: GitExecFileSync): boolean;
+export declare function localBranchExistsSync(cwd: string, branchName: string, execFileSyncFn?: GitExecFileSync): boolean;
+export declare function getWorktreePathsForBranchSync(cwd: string, branchName: string, execFileSyncFn?: GitExecFileSync): string[];
 //# sourceMappingURL=git.d.ts.map

package/dist/util/git.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../src/util/git.ts"],"names":[],"mappings":"AAOA;;;GAGG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAQxD;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAoB1G;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGvE;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAUpE;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAalE"}
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../src/util/git.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,eAAe,GAAG,CAC5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,cAAc,CAAA;CAAE,KAC7E,MAAM,GAAG,MAAM,CAAC;AAQrB;;;GAGG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAQxD;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAoB1G;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAGvE;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAUpE;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAalE;AAMD,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,GAAE,eAAqC,GAAG,OAAO,CAYnH;AAED,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,cAAc,GAAE,eAAqC,GACpD,OAAO,CAUT;AAED,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,cAAc,GAAE,eAAqC,GACpD,MAAM,EAAE,CA0CV"}

package/dist/util/git.js

@@ -38,11 +38,15 @@ exports.cloneRepository = cloneRepository;
 exports.isGitRepository = isGitRepository;
 exports.pullRepository = pullRepository;
 exports.fetchGitHead = fetchGitHead;
+exports.isInsideGitWorkTreeSync = isInsideGitWorkTreeSync;
+exports.localBranchExistsSync = localBranchExistsSync;
+exports.getWorktreePathsForBranchSync = getWorktreePathsForBranchSync;
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const fs = __importStar(require("fs-extra"));
 const path = __importStar(require("path"));
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const defaultExecFileSync = (file, args, options) => (0, child_process_1.execFileSync)(file, args, options);
 /**
  * Checks if git is installed and available in PATH
  * @throws Error if git is not installed
@@ -127,4 +131,69 @@ async function fetchGitHead(gitUrl) {
         throw new Error(`Failed to fetch git HEAD: ${error.message}`);
     }
 }
+function normalizeExecResult(result) {
+    return Buffer.isBuffer(result) ? result.toString('utf8').trim() : result.trim();
+}
+function isInsideGitWorkTreeSync(cwd, execFileSyncFn = defaultExecFileSync) {
+    try {
+        const result = execFileSyncFn('git', ['rev-parse', '--is-inside-work-tree'], {
+            cwd,
+            stdio: 'pipe',
+            encoding: 'utf8'
+        });
+        return normalizeExecResult(result) === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+function localBranchExistsSync(cwd, branchName, execFileSyncFn = defaultExecFileSync) {
+    try {
+        execFileSyncFn('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branchName}`], {
+            cwd,
+            stdio: 'ignore'
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getWorktreePathsForBranchSync(cwd, branchName, execFileSyncFn = defaultExecFileSync) {
+    try {
+        const raw = execFileSyncFn('git', ['worktree', 'list', '--porcelain'], {
+            cwd,
+            stdio: 'pipe',
+            encoding: 'utf8'
+        });
+        const output = normalizeExecResult(raw);
+        const lines = output.split('\n');
+        const matches = [];
+        let currentPath = '';
+        let currentBranch = '';
+        for (const line of lines) {
+            if (!line.trim()) {
+                if (currentBranch === `refs/heads/${branchName}` && currentPath) {
+                    matches.push(currentPath);
+                }
+                currentPath = '';
+                currentBranch = '';
+                continue;
+            }
+            if (line.startsWith('worktree ')) {
+                currentPath = line.slice('worktree '.length).trim();
+            }
+            if (line.startsWith('branch ')) {
+                currentBranch = line.slice('branch '.length).trim();
+            }
+        }
+        if (currentBranch === `refs/heads/${branchName}` && currentPath) {
+            matches.push(currentPath);
+        }
+        return matches;
+    }
+    catch {
+        return [];
+    }
+}
 //# sourceMappingURL=git.js.map

package/dist/util/git.js.map

@@ -1 +1 @@
-{"version":3,"file":"git.js","sourceRoot":"","sources":["../../src/util/git.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA,gDAQC;AAUD,0CAoBC;AAOD,0CAGC;AAOD,wCAUC;AAQD,oCAaC;AAjGD,iDAAqC;AACrC,+BAAiC;AACjC,6CAA+B;AAC/B,2CAA6B;AAE7B,MAAM,SAAS,GAAG,IAAA,gBAAS,EAAC,oBAAI,CAAC,CAAC;AAElC;;;GAGG;AACI,KAAK,UAAU,kBAAkB;IACtC,IAAI,CAAC;QACH,MAAM,SAAS,CAAC,eAAe,CAAC,CAAC;IACnC,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,KAAK,CACb,wFAAwF,CACzF,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACI,KAAK,UAAU,eAAe,CAAC,SAAiB,EAAE,QAAgB,EAAE,MAAc;IACvF,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAEhD,IAAI,MAAM,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAClC,OAAO,CAAC,GAAG,CAAC,OAAO,SAAS,IAAI,QAAQ,4BAA4B,CAAC,CAAC;QACtE,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,eAAe,QAAQ,8BAA8B,CAAC,CAAC;IACnE,MAAM,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IAE3C,IAAI,CAAC;QACH,MAAM,SAAS,CAAC,wCAAwC,MAAM,MAAM,QAAQ,GAAG,EAAE;YAC/E,OAAO,EAAE,KAAK;SACf,CAAC,CAAC;QACH,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;QAClC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,qBAAqB,KAAK,CAAC,OAAO,uCAAuC,CAAC,CAAC;IAC7F,CAAC;AACH,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,eAAe,CAAC,OAAe;IACnD,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC1C,OAAO,MAAM,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;AACrC,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,cAAc,CAAC,QAAgB;IACnD,IAAI,CAAC;QACH,MAAM,SAAS,CAAC,UAAU,EAAE;YAC1B,GAAG,EAAE,QAAQ;YACb,OAAO,EAAE,KAAK;SACf,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,IAAI,eAAe,CAAC;QACjD,MAAM,IAAI,KAAK,CAAC,oBAAoB,OAAO,EAAE,CAAC,CAAC;IACjD,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,YAAY,CAAC,MAAc;IAC/C,IAAI,CAAC;QACH,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,SAAS,CAAC,iBAAiB,MAAM,OAAO,CAAC,CAAC;QACnE,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAE3D,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAChE,CAAC;QAED,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,6BAA6B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;IAChE,CAAC;AACH,CAAC"}
+{"version":3,"file":"git.js","sourceRoot":"","sources":["../../src/util/git.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-devkit",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "A CLI toolkit for AI-assisted software development with phase templates and environment setup",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,7 +27,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@ai-devkit/memory": "0.4.0",
+    "@ai-devkit/memory": "0.6.0",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "fs-extra": "^11.2.0",

package/templates/commands/capture-knowledge.md

@@ -1,50 +1,12 @@
 ---
-description: Capture structured knowledge about a code entry point and save it to the knowledge docs.
+description: Document a code entry point in knowledge docs.
 ---
 
-# Knowledge Capture Assistant
-
 Guide me through creating a structured understanding of a code entry point and saving it to the knowledge docs.
 
-## Step 1: Gather Context
-- Entry point (file, folder, function, API)
-- Why this entry point matters (feature, bug, investigation)
-- Relevant requirements/design docs (if any)
-- Desired depth or focus areas (logic, dependencies, data flow)
-
-## Step 2: Validate Entry Point
-- Determine entry point type and confirm it exists
-- Surface ambiguity (multiple matches) and ask for clarification
-- If not found, suggest likely alternatives or spelling fixes
-
-## Step 3: Collect Source Context
-- Read the primary file/module and summarize purpose, exports, key patterns
-- For folders: list structure, highlight key modules
-- For functions/APIs: capture signature, parameters, return values, error handling
-- Extract essential snippets (avoid large dumps)
-
-## Step 4: Analyze Dependencies
-- Build a dependency view up to depth 3
-- Track visited nodes to avoid loops
-- Categorize dependencies (imports, function calls, services, external packages)
-- Note important external systems or generated code that should be excluded
-
-## Step 5: Synthesize Explanation
-- Draft an overview (purpose, language, high-level behavior)
-- Detail core logic, key components, execution flow, patterns
-- Highlight error handling, performance, security considerations
-- Identify potential improvements or risks discovered during analysis
-
-## Step 6: Create Documentation
-- Normalize entry point name to kebab-case (`calculateTotalPrice` → `calculate-total-price`)
-- Create `docs/ai/implementation/knowledge-{name}.md` using the headings implied in Step 5 (Overview, Implementation Details, Dependencies, Visual Diagrams, Additional Insights, Metadata, Next Steps)
-- Populate sections with findings, diagrams, and metadata (analysis date, depth, files touched)
-- Include mermaid diagrams when they clarify flows or relationships
-
-## Step 7: Review & Next Actions
-- Summarize key insights and open questions for follow-up
-- Suggest related areas for deeper dives or refactors
-- Confirm the knowledge file path and remind to commit it
-- Encourage running `/capture-knowledge` again for related entry points if needed
-
-Let me know the entry point and goals when you’re ready to begin the knowledge capture.
+1. **Gather & Validate Entry Point** — If not already provided, ask for: entry point (file, folder, function, API), why it matters (feature, bug, investigation), and desired depth or focus areas. Confirm the entry point exists; if ambiguous or not found, clarify or suggest alternatives.
+2. **Collect Source Context** — Read the primary file/module and summarize purpose, exports, key patterns. For folders: list structure, highlight key modules. For functions/APIs: capture signature, parameters, return values, error handling. Extract essential snippets (avoid large dumps).
+3. **Analyze Dependencies** — Build a dependency view up to depth 3, tracking visited nodes to avoid loops. Categorize: imports, function calls, services, external packages. Note external systems or generated code to exclude.
+4. **Synthesize Explanation** — Draft overview (purpose, language, high-level behavior). Detail core logic, execution flow, key patterns. Highlight error handling, performance, security considerations. Identify potential improvements or risks.
+5. **Create Documentation** — Normalize name to kebab-case (`calculateTotalPrice` → `calculate-total-price`). Create `docs/ai/implementation/knowledge-{name}.md` with sections: Overview, Implementation Details, Dependencies, Visual Diagrams, Additional Insights, Metadata, Next Steps. Include mermaid diagrams when they clarify flows or relationships. Add metadata (analysis date, depth, files touched).
+6. **Review & Next Actions** — Summarize key insights and open questions. Suggest related areas for deeper dives. Confirm file path and remind to commit.

package/templates/commands/check-implementation.md

@@ -2,24 +2,9 @@
 description: Compare implementation with design and requirements docs to ensure alignment.
 ---
 
-Compare the current implementation with the design in docs/ai/design/ and requirements in docs/ai/requirements/. Please follow this structured review:
-
-1. Ask me for:
-   - Feature/branch description
-   - List of modified files
-   - Relevant design doc(s) (feature-specific and/or project-level)
-   - Any known constraints or assumptions
-
-2. For each design doc:
-   - Summarize key architectural decisions and constraints
-   - Highlight components, interfaces, and data flows that must be respected
-
-3. File-by-file comparison:
-   - Confirm implementation matches design intent
-   - Note deviations or missing pieces
-   - Flag logic gaps, edge cases, or security issues
-   - Suggest simplifications or refactors
-   - Identify missing tests or documentation updates
+Compare the current implementation with the design in docs/ai/design/ and requirements in docs/ai/requirements/.
 
+1. If not already provided, ask for: feature/branch description, list of modified files, relevant design doc(s), and any known constraints or assumptions.
+2. For each design doc: summarize key architectural decisions and constraints, highlight components, interfaces, and data flows that must be respected.
+3. File-by-file comparison: confirm implementation matches design intent, note deviations or missing pieces, flag logic gaps, edge cases, or security issues, suggest simplifications or refactors, and identify missing tests or documentation updates.
 4. Summarize findings with recommended next steps.
-

package/templates/commands/code-review.md

@@ -1,85 +1,11 @@
 ---
-description: Perform a local code review before pushing changes, ensuring alignment with design docs and best practices.
+description: Pre-push code review against design docs.
 ---
 
-# Local Code Review Assistant
+Perform a local code review **before** pushing changes.
 
-You are helping me perform a local code review **before** I push changes. Please follow this structured workflow.
-
-## Step 1: Gather Context
-Ask me for:
-- Brief feature/branch description
-- List of modified files (with optional summaries)
-- Relevant design doc(s) (e.g., `docs/ai/design/feature-{name}.md` or project-level design)
-- Any known constraints or risky areas
-- Any open bugs or TODOs linked to this work
-- Which tests have already been run
-
-If possible, request the latest diff:
-```bash
-git status -sb
-git diff --stat
-```
-
-## Step 2: Understand Design Alignment
-For each provided design doc:
-- Summarize the architectural intent
-- Note critical requirements, patterns, or constraints the design mandates
-
-## Step 3: File-by-File Review
-For every modified file:
-1. Highlight deviations from the referenced design or requirements
-2. Spot potential logic or flow issues and edge cases
-3. Identify redundant or duplicate code
-4. Suggest simplifications or refactors (prefer clarity over cleverness)
-5. Flag security concerns (input validation, secrets, auth, data handling)
-6. Check for performance pitfalls or scalability risks
-7. Ensure error handling, logging, and observability are appropriate
-8. Note any missing comments or docs
-9. Flag missing or outdated tests related to this file
-
-## Step 4: Cross-Cutting Concerns
-- Verify naming consistency and adherence to project conventions
-- Confirm documentation/comments are updated where the behavior changed
-- Identify missing tests (unit, integration, E2E) needed to cover the changes
-- Ensure configuration/migration updates are captured if applicable
-
-## Step 5: Summarize Findings
-Provide results in this structure:
-```
-### Summary
-- Blocking issues: [count]
-- Important follow-ups: [count]
-- Nice-to-have improvements: [count]
-
-### Detailed Notes
-1. **[File or Component]**
-   - Issue/Observation: ...
-   - Impact: (e.g., blocking / important / nice-to-have)
-   - Recommendation: ...
-   - Design reference: [...]
-
-2. ... (repeat per finding)
-
-### Recommended Next Steps
-- [ ] Address blocking issues
-- [ ] Update design/implementation docs if needed
-- [ ] Add/adjust tests:
-      - Unit:
-      - Integration:
-      - E2E:
-- [ ] Rerun local test suite
-- [ ] Re-run code review command after fixes
-```
-
-## Step 6: Final Checklist
-Confirm whether each item is complete (yes/no/needs follow-up):
-- Implementation matches design & requirements
-- No obvious logic or edge-case gaps remain
-- Redundant code removed or justified
-- Security considerations addressed
-- Tests cover new/changed behavior
-- Documentation/design notes updated
-
----
-Let me know when you're ready to begin the review.
+1. **Gather Context** — If not already provided, ask for: feature/branch description, list of modified files, relevant design doc(s) (e.g., `docs/ai/design/feature-{name}.md`), known constraints or risky areas, and which tests have been run. Also review the latest diff via `git status` and `git diff --stat`.
+2. **Understand Design Alignment** — For each design doc, summarize architectural intent and critical constraints.
+3. **File-by-File Review** — For every modified file: check alignment with design/requirements and flag deviations, spot logic issues/edge cases/redundant code, flag security concerns (input validation, secrets, auth, data handling), check error handling/performance/observability, and identify missing or outdated tests.
+4. **Cross-Cutting Concerns** — Verify naming consistency and project conventions. Confirm docs/comments updated where behavior changed. Identify missing tests (unit, integration, E2E). Check for needed configuration/migration updates.
+5. **Summarize Findings** — Categorize each finding as **blocking**, **important**, or **nice-to-have** with: file, issue, impact, recommendation, and design reference.

package/templates/commands/debug.md

@@ -1,49 +1,11 @@
 ---
-description: Guide me through debugging a code issue by clarifying expectations, identifying gaps, and agreeing on a fix plan before changing code.
+description: Debug an issue with structured root-cause analysis before changing code.
 ---
 
-# Local Debugging Assistant
-
-Help me debug an issue by clarifying expectations, identifying gaps, and agreeing on a fix plan before changing code.
-
-## Step 1: Gather Context
-Ask me for:
-- Brief issue description (what is happening?)
-- Expected behavior or acceptance criteria (what should happen?)
-- Current behavior and any error messages/logs
-- Recent related changes or deployments
-- Scope of impact (users, services, environments)
-
-## Step 2: Clarify Reality vs Expectation
-- Restate the observed behavior vs the expected outcome
-- Confirm relevant requirements, tickets, or docs that define the expectation
-- Identify acceptance criteria for the fix (how we know it is resolved)
-
-## Step 3: Reproduce & Isolate
-- Determine reproducibility (always, intermittent, environment-specific)
-- Capture reproduction steps or commands
-- Note any available tests that expose the failure
-- List suspected components, services, or modules
-
-## Step 4: Analyze Potential Causes
-- Brainstorm plausible root causes (data, config, code regressions, external dependencies)
-- Gather supporting evidence (logs, metrics, traces, screenshots)
-- Highlight gaps or unknowns that need investigation
-
-## Step 5: Surface Options
-- Present possible resolution paths (quick fix, deeper refactor, rollback, feature flag, etc.)
-- For each option, list pros/cons, risks, and verification steps
-- Consider required approvals or coordination
-
-## Step 6: Confirm Path Forward
-- Ask which option we should pursue
-- Summarize chosen approach, required pre-work, and success criteria
-- Plan validation steps (tests, monitoring, user sign-off)
-
-## Step 7: Next Actions & Tracking
-- Document tasks, owners, and timelines for the selected option
-- Note follow-up actions after deployment (monitoring, comms, postmortem if needed)
-- Encourage updating relevant docs/tests once resolved
-
-Let me know when you're ready to walk through the debugging flow.
+Help me debug an issue. Clarify expectations, identify gaps, and agree on a fix plan before changing code.
 
+1. **Gather Context** — If not already provided, ask for: issue description (what is happening vs what should happen), error messages/logs/screenshots, recent related changes or deployments, and scope of impact.
+2. **Clarify Reality vs Expectation** — Restate observed vs expected behavior. Confirm relevant requirements or docs that define the expectation. Define acceptance criteria for the fix.
+3. **Reproduce & Isolate** — Determine reproducibility (always, intermittent, environment-specific). Capture reproduction steps. List suspected components or modules.
+4. **Analyze Potential Causes** — Brainstorm root causes (data, config, code regressions, external dependencies). Gather supporting evidence (logs, metrics, traces). Highlight unknowns needing investigation.
+5. **Resolve** — Present resolution options (quick fix, refactor, rollback, etc.) with pros/cons and risks. Ask which option to pursue. Summarize chosen approach, pre-work, success criteria, and validation steps.

package/templates/commands/execute-plan.md

@@ -1,75 +1,11 @@
 ---
-description: Execute a feature plan interactively, guiding me through each task while referencing relevant docs and updating status.
+description: Execute a feature plan task by task.
 ---
 
-# Feature Plan Execution Assistant
-
 Help me work through a feature plan one task at a time.
 
-## Step 1: Gather Context
-Ask me for:
-- Feature name (kebab-case, e.g., `user-authentication`)
-- Brief feature/branch description
-- Relevant planning doc path (default `docs/ai/planning/feature-{name}.md`)
-- Any supporting design/implementation docs (design, requirements, implementation)
-- Current branch and latest diff summary (`git status -sb`, `git diff --stat`)
-
-## Step 2: Load the Plan
-- Request the planning doc contents or offer commands like:
-  ```bash
-  cat docs/ai/planning/feature-<name>.md
-  ```
-- Parse sections that represent task lists (look for headings + checkboxes `[ ]`, `[x]`).
-- Build an ordered queue of tasks grouped by section (e.g., Foundation, Core Features, Testing).
-
-## Step 3: Present Task Queue
-Show an overview:
-```
-### Task Queue: <Feature Name>
-1. [status] Section • Task title
-2. ...
-```
-Status legend: `todo`, `in-progress`, `done`, `blocked` (based on checkbox/notes if present).
-
-## Step 4: Interactive Task Execution
-For each task in order:
-1. Display the section/context, full bullet text, and any existing notes.
-2. Suggest relevant docs to reference (requirements/design/implementation).
-3. Ask: "Plan for this task?" Offer to outline sub-steps using the design doc.
-4. Prompt to mark status (`done`, `in-progress`, `blocked`, `skipped`) and capture short notes/next steps.
-5. Encourage code/document edits inside Cursor; offer commands/snippets when useful.
-6. If blocked, record blocker info and move task to the end or into a "Blocked" list.
-
-## Step 5: Update Planning Doc
-After each status change, generate a Markdown snippet the user can paste back into the planning doc, e.g.:
-```
-- [x] Task: Implement auth service (Notes: finished POST /auth/login, tests added)
-```
-Remind the user to keep the source doc updated.
-
-## Step 6: Check for Newly Discovered Work
-After each section, ask if new tasks were discovered. If yes, capture them in a "New Work" list with status `todo` and include in the summary.
-
-## Step 7: Session Summary
-Produce a summary table:
-```
-### Execution Summary
-- Completed: (list)
-- In Progress: (list + owners/next steps)
-- Blocked: (list + blockers)
-- Skipped / Deferred: (list + rationale)
-- New Tasks: (list)
-```
-
-## Step 8: Next Actions
-Remind the user to:
-- Update `docs/ai/planning/feature-{name}.md` with the new statuses
-- Sync related docs (requirements/design/implementation/testing) if decisions changed
-- Run `/check-implementation` to validate changes against design docs
-- Run `/writing-test` to produce unit/integration tests targeting 100% coverage
-- Run `/update-planning` to reconcile the planning doc with the latest status
-- Run `/code-review` when ready for final review
-- Run test suites relevant to completed tasks
-
----
-Let me know when you're ready to start executing the plan. Provide the feature name and planning doc first.
+1. **Gather Context** — If not already provided, ask for: feature name (kebab-case, e.g., `user-authentication`), brief feature/branch description, planning doc path (default `docs/ai/planning/feature-{name}.md`), and any supporting docs (design, requirements, implementation).
+2. **Load & Present Plan** — Read the planning doc and parse task lists (headings + checkboxes). Present an ordered task queue grouped by section, with status: `todo`, `in-progress`, `done`, `blocked`.
+3. **Interactive Task Execution** — For each task in order: display context and full bullet text, reference relevant design/requirements docs, offer to outline sub-steps before starting, prompt for status update (`done`, `in-progress`, `blocked`, `skipped`) with short notes after work, and if blocked record blocker and move to a "Blocked" list.
+4. **Update Planning Doc** — After each status change, generate a markdown snippet to paste back into the planning doc. After each section, ask if new tasks were discovered.
+5. **Session Summary** — Produce a summary: Completed, In Progress (with next steps), Blocked (with blockers), Skipped/Deferred, and New Tasks. Remind to update `docs/ai/planning/feature-{name}.md` and sync related docs if decisions changed.