@lbruton/specflow 3.0.0

package/dist/markdown/templates/tech-template.md

@@ -0,0 +1,99 @@
+# Technology Stack
+
+## Project Type
+[Describe what kind of project this is: web application, CLI tool, desktop application, mobile app, library, API service, embedded system, game, etc.]
+
+## Core Technologies
+
+### Primary Language(s)
+- **Language**: [e.g., Python 3.11, Go 1.21, TypeScript, Rust, C++]
+- **Runtime/Compiler**: [if applicable]
+- **Language-specific tools**: [package managers, build tools, etc.]
+
+### Key Dependencies/Libraries
+[List the main libraries and frameworks your project depends on]
+- **[Library/Framework name]**: [Purpose and version]
+- **[Library/Framework name]**: [Purpose and version]
+
+### Application Architecture
+[Describe how your application is structured - this could be MVC, event-driven, plugin-based, client-server, standalone, microservices, monolithic, etc.]
+
+### Data Storage (if applicable)
+- **Primary storage**: [e.g., PostgreSQL, files, in-memory, cloud storage]
+- **Caching**: [e.g., Redis, in-memory, disk cache]
+- **Data formats**: [e.g., JSON, Protocol Buffers, XML, binary]
+
+### External Integrations (if applicable)
+- **APIs**: [External services you integrate with]
+- **Protocols**: [e.g., HTTP/REST, gRPC, WebSocket, TCP/IP]
+- **Authentication**: [e.g., OAuth, API keys, certificates]
+
+### Monitoring & Dashboard Technologies (if applicable)
+- **Dashboard Framework**: [e.g., React, Vue, vanilla JS, terminal UI]
+- **Real-time Communication**: [e.g., WebSocket, Server-Sent Events, polling]
+- **Visualization Libraries**: [e.g., Chart.js, D3, terminal graphs]
+- **State Management**: [e.g., Redux, Vuex, file system as source of truth]
+
+## Development Environment
+
+### Build & Development Tools
+- **Build System**: [e.g., Make, CMake, Gradle, npm scripts, cargo]
+- **Package Management**: [e.g., pip, npm, cargo, go mod, apt, brew]
+- **Development workflow**: [e.g., hot reload, watch mode, REPL]
+
+### Code Quality Tools
+- **Static Analysis**: [Tools for code quality and correctness]
+- **Formatting**: [Code style enforcement tools]
+- **Testing Framework**: [Unit, integration, and/or end-to-end testing tools]
+- **Documentation**: [Documentation generation tools]
+
+### Version Control & Collaboration
+- **VCS**: [e.g., Git, Mercurial, SVN]
+- **Branching Strategy**: [e.g., Git Flow, GitHub Flow, trunk-based]
+- **Code Review Process**: [How code reviews are conducted]
+
+### Dashboard Development (if applicable)
+- **Live Reload**: [e.g., Hot module replacement, file watchers]
+- **Port Management**: [e.g., Dynamic allocation, configurable ports]
+- **Multi-Instance Support**: [e.g., Running multiple dashboards simultaneously]
+
+## Deployment & Distribution (if applicable)
+- **Target Platform(s)**: [Where/how the project runs: cloud, on-premise, desktop, mobile, embedded]
+- **Distribution Method**: [How users get your software: download, package manager, app store, SaaS]
+- **Installation Requirements**: [Prerequisites, system requirements]
+- **Update Mechanism**: [How updates are delivered]
+
+## Technical Requirements & Constraints
+
+### Performance Requirements
+- [e.g., response time, throughput, memory usage, startup time]
+- [Specific benchmarks or targets]
+
+### Compatibility Requirements  
+- **Platform Support**: [Operating systems, architectures, versions]
+- **Dependency Versions**: [Minimum/maximum versions of dependencies]
+- **Standards Compliance**: [Industry standards, protocols, specifications]
+
+### Security & Compliance
+- **Security Requirements**: [Authentication, encryption, data protection]
+- **Compliance Standards**: [GDPR, HIPAA, SOC2, etc. if applicable]
+- **Threat Model**: [Key security considerations]
+
+### Scalability & Reliability
+- **Expected Load**: [Users, requests, data volume]
+- **Availability Requirements**: [Uptime targets, disaster recovery]
+- **Growth Projections**: [How the system needs to scale]
+
+## Technical Decisions & Rationale
+[Document key architectural and technology choices]
+
+### Decision Log
+1. **[Technology/Pattern Choice]**: [Why this was chosen, alternatives considered]
+2. **[Architecture Decision]**: [Rationale, trade-offs accepted]
+3. **[Tool/Library Selection]**: [Reasoning, evaluation criteria]
+
+## Known Limitations
+[Document any technical debt, limitations, or areas for improvement]
+
+- [Limitation 1]: [Impact and potential future solutions]
+- [Limitation 2]: [Why it exists and when it might be addressed]

package/dist/prompts/create-spec.d.ts

@@ -0,0 +1,3 @@
+import { PromptDefinition } from './types.js';
+export declare const createSpecPrompt: PromptDefinition;
+//# sourceMappingURL=create-spec.d.ts.map

package/dist/prompts/create-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-spec.d.ts","sourceRoot":"","sources":["../../src/prompts/create-spec.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAiG9C,eAAO,MAAM,gBAAgB,EAAE,gBAG9B,CAAC"}

package/dist/prompts/create-spec.js

@@ -0,0 +1,93 @@
+const prompt = {
+    name: 'create-spec',
+    title: 'Create Specification Document',
+    description: 'Guide for creating spec documents directly in the file system. Shows how to use templates and create requirements, design, or tasks documents at the correct paths.',
+    arguments: [
+        {
+            name: 'specName',
+            description: 'Spec name with issue prefix: {ISSUE-ID}-{kebab-title} (e.g., STAK-123-user-authentication). Must start with an issue ID pattern like STAK-123-.',
+            required: true
+        },
+        {
+            name: 'documentType',
+            description: 'Type of document to create: requirements, design, or tasks',
+            required: true
+        },
+        {
+            name: 'description',
+            description: 'Brief description of what this spec should accomplish',
+            required: false
+        }
+    ]
+};
+async function handler(args, context) {
+    const { specName, documentType, description } = args;
+    if (!specName || !documentType) {
+        throw new Error('specName and documentType are required arguments');
+    }
+    const validDocTypes = ['requirements', 'design', 'tasks'];
+    if (!validDocTypes.includes(documentType)) {
+        throw new Error(`documentType must be one of: ${validDocTypes.join(', ')}`);
+    }
+    // Build context-aware messages
+    const messages = [
+        {
+            role: 'user',
+            content: {
+                type: 'text',
+                text: `Create a ${documentType} document for the "${specName}" feature using the spec-workflow methodology.
+
+**Context:**
+- Project: ${context.projectPath}
+- Feature: ${specName}
+- Document type: ${documentType}
+${description ? `- Description: ${description}` : ''}
+${context.dashboardUrl ? `- Dashboard: ${context.dashboardUrl}` : ''}
+
+**Instructions:**
+1. First, read the template at: .spec-workflow/templates/${documentType}-template.md
+2. Follow the template structure exactly - this ensures consistency across the project
+3. Create comprehensive content that follows spec-driven development best practices
+4. Include all required sections from the template
+5. Use clear, actionable language
+6. Create the document at: .spec-workflow/specs/${specName}/${documentType}.md
+7. After creating, use approvals tool with action:'request' to get user approval
+
+**File Paths:**
+- Template location: .spec-workflow/templates/${documentType}-template.md
+- Document destination: .spec-workflow/specs/${specName}/${documentType}.md
+
+**Workflow Guidelines:**
+- Requirements documents define WHAT needs to be built
+- Design documents define HOW it will be built  
+- Tasks documents break down implementation into actionable steps
+- Each document builds upon the previous one in sequence
+- Templates are automatically updated on server start
+
+${documentType === 'tasks' ? `
+**Special Instructions for Tasks Document:**
+- For each task, generate a _Prompt field with structured AI guidance
+- Format: _Prompt: Role: [role] | Task: [description] | Restrictions: [constraints] | Success: [criteria]
+- Make prompts specific to the project context and requirements
+- Include _Leverage fields pointing to existing code to reuse
+- Include _Requirements fields showing which requirements each task implements
+- Tasks should be atomic (1-3 files each) and in logical order
+
+**Implementation Logging:**
+- When implementing tasks, developers will use the log-implementation tool to record what was done
+- Implementation logs appear in the dashboard's "Logs" tab for easy reference
+- These logs prevent implementation details from being lost in chat history
+- Good task descriptions help developers write better implementation summaries
+` : ''}
+
+Please read the ${documentType} template and create the comprehensive document at the specified path.`
+            }
+        }
+    ];
+    return messages;
+}
+export const createSpecPrompt = {
+    prompt,
+    handler
+};
+//# sourceMappingURL=create-spec.js.map

package/dist/prompts/create-spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-spec.js","sourceRoot":"","sources":["../../src/prompts/create-spec.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,GAAW;IACrB,IAAI,EAAE,aAAa;IACnB,KAAK,EAAE,+BAA+B;IACtC,WAAW,EAAE,qKAAqK;IAClL,SAAS,EAAE;QACT;YACE,IAAI,EAAE,UAAU;YAChB,WAAW,EAAE,iJAAiJ;YAC9J,QAAQ,EAAE,IAAI;SACf;QACD;YACE,IAAI,EAAE,cAAc;YACpB,WAAW,EAAE,4DAA4D;YACzE,QAAQ,EAAE,IAAI;SACf;QACD;YACE,IAAI,EAAE,aAAa;YACnB,WAAW,EAAE,uDAAuD;YACpE,QAAQ,EAAE,KAAK;SAChB;KACF;CACF,CAAC;AAEF,KAAK,UAAU,OAAO,CAAC,IAAyB,EAAE,OAAoB;IACpE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;IAErD,IAAI,CAAC,QAAQ,IAAI,CAAC,YAAY,EAAE,CAAC;QAC/B,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IAED,MAAM,aAAa,GAAG,CAAC,cAAc,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC1D,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC;QAC1C,MAAM,IAAI,KAAK,CAAC,gCAAgC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC9E,CAAC;IAED,+BAA+B;IAC/B,MAAM,QAAQ,GAAoB;QAChC;YACE,IAAI,EAAE,MAAM;YACZ,OAAO,EAAE;gBACP,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE,YAAY,YAAY,sBAAsB,QAAQ;;;aAGvD,OAAO,CAAC,WAAW;aACnB,QAAQ;mBACF,YAAY;EAC7B,WAAW,CAAC,CAAC,CAAC,kBAAkB,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE;EAClD,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,gBAAgB,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE;;;2DAGT,YAAY;;;;;kDAKrB,QAAQ,IAAI,YAAY;;;;gDAI1B,YAAY;+CACb,QAAQ,IAAI,YAAY;;;;;;;;;EASrE,YAAY,KAAK,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;CAc5B,CAAC,CAAC,CAAC,EAAE;;kBAEY,YAAY,wEAAwE;aAC/F;SACF;KACF,CAAC;IAEF,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,CAAC,MAAM,gBAAgB,GAAqB;IAChD,MAAM;IACN,OAAO;CACR,CAAC"}

package/dist/prompts/create-steering-doc.d.ts

@@ -0,0 +1,3 @@
+import { PromptDefinition } from './types.js';
+export declare const createSteeringDocPrompt: PromptDefinition;
+//# sourceMappingURL=create-steering-doc.d.ts.map

package/dist/prompts/create-steering-doc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-steering-doc.d.ts","sourceRoot":"","sources":["../../src/prompts/create-steering-doc.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AA6E9C,eAAO,MAAM,uBAAuB,EAAE,gBAGrC,CAAC"}

package/dist/prompts/create-steering-doc.js

@@ -0,0 +1,73 @@
+const prompt = {
+    name: 'create-steering-doc',
+    title: 'Create Steering Document',
+    description: 'Guide for creating project steering documents (product, tech, structure) directly in the file system. These provide high-level project guidance.',
+    arguments: [
+        {
+            name: 'docType',
+            description: 'Type of steering document: product, tech, or structure',
+            required: true
+        },
+        {
+            name: 'scope',
+            description: 'Scope of the steering document (e.g., frontend, backend, full-stack)',
+            required: false
+        }
+    ]
+};
+async function handler(args, context) {
+    const { docType, scope } = args;
+    if (!docType) {
+        throw new Error('docType is a required argument');
+    }
+    const validDocTypes = ['product', 'tech', 'structure'];
+    if (!validDocTypes.includes(docType)) {
+        throw new Error(`docType must be one of: ${validDocTypes.join(', ')}`);
+    }
+    const messages = [
+        {
+            role: 'user',
+            content: {
+                type: 'text',
+                text: `Create a ${docType} steering document for the project.
+
+**Context:**
+- Project: ${context.projectPath}
+- Steering document type: ${docType}
+${scope ? `- Scope: ${scope}` : ''}
+${context.dashboardUrl ? `- Dashboard: ${context.dashboardUrl}` : ''}
+
+**Instructions:**
+1. First, read the template at: .spec-workflow/templates/${docType}-template.md
+2. Check if steering docs exist at: .spec-workflow/steering/
+3. Create comprehensive content following the template structure
+4. Create the document at: .spec-workflow/steering/${docType}.md
+5. After creating, use approvals tool with action:'request' to get user approval
+
+**File Paths:**
+- Template location: .spec-workflow/templates/${docType}-template.md
+- Document destination: .spec-workflow/steering/${docType}.md
+
+**Steering Document Types:**
+- **product**: Defines project vision, goals, and user outcomes
+- **tech**: Documents technology decisions and architecture patterns
+- **structure**: Maps codebase organization and conventions
+
+**Key Principles:**
+- Be specific and actionable
+- Include examples where helpful
+- Consider both technical and business requirements
+- Provide clear guidance for future development
+- Templates are automatically updated on server start
+
+Please read the ${docType} template and create a comprehensive steering document at the specified path.`
+            }
+        }
+    ];
+    return messages;
+}
+export const createSteeringDocPrompt = {
+    prompt,
+    handler
+};
+//# sourceMappingURL=create-steering-doc.js.map

package/dist/prompts/create-steering-doc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-steering-doc.js","sourceRoot":"","sources":["../../src/prompts/create-steering-doc.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,GAAW;IACrB,IAAI,EAAE,qBAAqB;IAC3B,KAAK,EAAE,0BAA0B;IACjC,WAAW,EAAE,kJAAkJ;IAC/J,SAAS,EAAE;QACT;YACE,IAAI,EAAE,SAAS;YACf,WAAW,EAAE,wDAAwD;YACrE,QAAQ,EAAE,IAAI;SACf;QACD;YACE,IAAI,EAAE,OAAO;YACb,WAAW,EAAE,sEAAsE;YACnF,QAAQ,EAAE,KAAK;SAChB;KACF;CACF,CAAC;AAEF,KAAK,UAAU,OAAO,CAAC,IAAyB,EAAE,OAAoB;IACpE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;IAEhC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED,MAAM,aAAa,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;IACvD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACrC,MAAM,IAAI,KAAK,CAAC,2BAA2B,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACzE,CAAC;IAED,MAAM,QAAQ,GAAoB;QAChC;YACE,IAAI,EAAE,MAAM;YACZ,OAAO,EAAE;gBACP,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE,YAAY,OAAO;;;aAGpB,OAAO,CAAC,WAAW;4BACJ,OAAO;EACjC,KAAK,CAAC,CAAC,CAAC,YAAY,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE;EAChC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,gBAAgB,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE;;;2DAGT,OAAO;;;qDAGb,OAAO;;;;gDAIZ,OAAO;kDACL,OAAO;;;;;;;;;;;;;;kBAcvC,OAAO,+EAA+E;aACjG;SACF;KACF,CAAC;IAEF,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,CAAC,MAAM,uBAAuB,GAAqB;IACvD,MAAM;IACN,OAAO;CACR,CAAC"}

package/dist/prompts/implement-task.d.ts

@@ -0,0 +1,3 @@
+import { PromptDefinition } from './types.js';
+export declare const implementTaskPrompt: PromptDefinition;
+//# sourceMappingURL=implement-task.d.ts.map

package/dist/prompts/implement-task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"implement-task.d.ts","sourceRoot":"","sources":["../../src/prompts/implement-task.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAgM9C,eAAO,MAAM,mBAAmB,EAAE,gBAGjC,CAAC"}

package/dist/prompts/implement-task.js

@@ -0,0 +1,189 @@
+const prompt = {
+    name: 'implement-task',
+    title: 'Implement Specification Task',
+    description: 'Guide for implementing a specific task from the tasks.md document. Provides comprehensive instructions for task execution, including reading _Prompt fields, marking progress, completion criteria, and logging implementation details for the dashboard.',
+    arguments: [
+        {
+            name: 'specName',
+            description: 'Feature name in kebab-case for the task to implement',
+            required: true
+        },
+        {
+            name: 'taskId',
+            description: 'Specific task ID to implement (e.g., "1", "2.1", "3")',
+            required: false
+        }
+    ]
+};
+async function handler(args, context) {
+    const { specName, taskId } = args;
+    if (!specName) {
+        throw new Error('specName is a required argument');
+    }
+    const messages = [
+        {
+            role: 'user',
+            content: {
+                type: 'text',
+                text: `Implement ${taskId ? `task ${taskId}` : 'the next pending task'} for the "${specName}" feature.
+
+**Context:**
+- Project: ${context.projectPath}
+- Feature: ${specName}
+${taskId ? `- Task ID: ${taskId}` : ''}
+${context.dashboardUrl ? `- Dashboard: ${context.dashboardUrl}` : ''}
+
+**Implementation Workflow:**
+
+1. **Check Current Status:**
+   - Use the spec-status tool with specName "${specName}" to see overall progress
+   - Read .spec-workflow/specs/${specName}/tasks.md to see all tasks
+   - Identify ${taskId ? `task ${taskId}` : 'the next pending task marked with [ ]'}
+
+2. **Start the Task:**
+   - Edit .spec-workflow/specs/${specName}/tasks.md directly
+   - Change the task marker from [ ] to [-] for the task you're starting
+   - Only one task should be in-progress at a time
+
+3. **Read Task Guidance:**
+   - Look for the _Prompt field in the task - it contains structured guidance:
+     - Role: The specialized developer role to assume
+     - Task: Clear description with context references
+     - Restrictions: What not to do and constraints
+     - Success: Specific completion criteria
+   - Note the _Leverage fields for files/utilities to use
+   - Check _Requirements fields for which requirements this implements
+
+4. **Discover Existing Implementations (CRITICAL):**
+   - BEFORE writing any code, search implementation logs to understand existing artifacts
+   - Implementation logs are stored as markdown files in: .spec-workflow/specs/${specName}/Implementation Logs/
+
+   **Option 1: Use grep/ripgrep for fast searches**
+   \`\`\`bash
+   # Search for API endpoints
+   grep -r "GET\|POST\|PUT\|DELETE" ".spec-workflow/specs/${specName}/Implementation Logs/"
+
+   # Search for specific components
+   grep -r "ComponentName" ".spec-workflow/specs/${specName}/Implementation Logs/"
+
+   # Search for integration patterns
+   grep -r "integration\|dataFlow" ".spec-workflow/specs/${specName}/Implementation Logs/"
+   \`\`\`
+
+   **Option 2: Read markdown files directly**
+   - Use the Read tool to examine implementation log files
+   - Search for relevant sections (## API Endpoints, ## Components, ## Functions, etc.)
+   - Review artifacts from related tasks to understand established patterns
+
+   **Discovery best practices:**
+   - First: Search for "API" or "endpoint" to find existing API patterns
+   - Second: Search for "component" or specific component names to see existing UI structures
+   - Third: Search for "integration" or "dataFlow" to understand how frontend/backend connect
+   - Why this matters:
+     - ❌ Don't create duplicate API endpoints - check for similar paths
+     - ❌ Don't reimplement components/functions - verify utilities already don't exist
+     - ❌ Don't ignore established patterns - understand middleware/integration setup
+     - ✅ Reuse existing code - leverage already-implemented functions and components
+     - ✅ Follow patterns - maintain consistency with established architecture
+   - If initial search doesn't find expected results, refine your grep patterns
+   - Document any existing related implementations before proceeding
+   - If you find existing code that does what the task asks, leverage it instead of recreating
+
+5. **Implement the Task (dispatch subagent):**
+   - Dispatch a fresh subagent (Agent tool) with the full task text, _Prompt guidance, and _Leverage file paths
+   - Template: .spec-workflow/templates/implementer-prompt-template.md
+   - The subagent implements, tests, commits, and self-reviews
+   - Main context stays clean for orchestration — never write implementation code here
+
+5.5. **Spec Compliance Review (dispatch reviewer subagent):**
+   - After the implementer reports back, dispatch a reviewer subagent
+   - Reviewer reads actual code and compares to task requirements line by line
+   - Template: .spec-workflow/templates/spec-reviewer-template.md
+   - If issues found: implementer fixes them, then dispatch reviewer again
+   - Do NOT proceed to step 5.6 until spec review passes ✅
+
+5.6. **Code Quality Review (dispatch reviewer subagent):**
+   - Only dispatch AFTER spec compliance passes in step 5.5
+   - Reviewer checks: architecture, error handling, testing, production readiness
+   - Template: .spec-workflow/templates/code-quality-reviewer-template.md
+   - Issues categorized: Critical (must fix) / Important (should fix) / Minor
+   - Fix Critical and Important issues, re-review until approved ✅
+
+6. **Log Implementation (MANDATORY - must complete BEFORE marking task done):**
+   - ⚠️ **STOP: Do NOT mark the task [x] until this step succeeds.**
+   - A task without an implementation log is NOT complete. Skipping this step is the #1 workflow violation.
+   - Call log-implementation with ALL of the following:
+     - specName: "${specName}"
+     - taskId: ${taskId ? `"${taskId}"` : 'the task ID you just completed'}
+     - summary: Clear description of what was implemented (1-2 sentences)
+     - filesModified: List of files you edited
+     - filesCreated: List of files you created
+     - statistics: {linesAdded: number, linesRemoved: number}
+     - artifacts: {apiEndpoints: [...], components: [...], functions: [...], classes: [...], integrations: [...]}
+   - You MUST include artifacts (required field) to enable other agents to find your work:
+     - **apiEndpoints**: List all API endpoints created/modified with method, path, purpose, request/response formats, and location
+     - **components**: List all UI components created with name, type, purpose, props, and location
+     - **functions**: List all utility functions with signature and location
+     - **classes**: List all classes with methods and location
+     - **integrations**: Document how frontend connects to backend with data flow description
+   - Example artifacts for an API endpoint:
+     \`\`\`json
+     "apiEndpoints": [{
+       "method": "GET",
+       "path": "/api/todos/:id",
+       "purpose": "Fetch a specific todo by ID",
+       "requestFormat": "URL param: id (string)",
+       "responseFormat": "{ id: string, title: string, completed: boolean }",
+       "location": "src/server.ts:245"
+     }]
+     \`\`\`
+   - Why: Future AI agents will query logs before implementing, preventing duplicate code and ensuring architecture consistency
+   - This creates a searchable knowledge base — without it, implementation knowledge is lost when the conversation ends
+
+7. **Complete the Task (only after step 6 succeeds):**
+   - Confirm that log-implementation returned success in step 6
+   - Verify all success criteria from the _Prompt are met
+   - Run any relevant tests to ensure nothing is broken
+   - Edit .spec-workflow/specs/${specName}/tasks.md directly
+   - Change the task marker from [-] to [x] for the completed task
+   - ⚠️ If you skipped step 6, go back now — a task marked [x] without a log is incomplete
+
+**Important Guidelines:**
+- Always mark a task as in-progress before starting work
+- Follow the _Prompt field guidance for role, approach, and success criteria
+- Use existing patterns and utilities mentioned in _Leverage fields
+- Test your implementation before marking the task complete
+- **ALWAYS call log-implementation BEFORE marking a task [x]** — this is the most-skipped step and it is mandatory
+- If a task has subtasks (e.g., 4.1, 4.2), complete them in order
+- If you encounter blockers, document them and move to another task
+
+**Tools to Use:**
+- spec-status: Check overall progress
+- Bash (grep/ripgrep): CRITICAL - Search existing implementations before coding (step 4)
+- Read: Examine markdown implementation log files directly (step 4)
+- log-implementation: MANDATORY - Record implementation details with artifacts BEFORE marking task complete (step 6)
+- Edit: Directly update task markers in tasks.md file
+- Read/Write/Edit: Implement the actual code changes
+- Bash: Run tests and verify implementation
+
+**View Implementation Logs:**
+- All logged implementations appear in the "Logs" tab of the dashboard
+- Filter by spec, task ID, or search by summary
+- View detailed statistics including files changed and lines modified
+- Or search directly using grep on markdown files in .spec-workflow/specs/{specName}/Implementation Logs/
+
+**Context Budget:** This session supports ~80-100 task dispatches with reviews (~800k tokens on 1M context models).
+After completing 60+ tasks, consider using a handoff to relay to a fresh session.
+Save handoff context: spec name, completed tasks, in-progress state, next task ID.
+
+Please proceed with implementing ${taskId ? `task ${taskId}` : 'the next task'} following this workflow.`
+            }
+        }
+    ];
+    return messages;
+}
+export const implementTaskPrompt = {
+    prompt,
+    handler
+};
+//# sourceMappingURL=implement-task.js.map

package/dist/prompts/implement-task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"implement-task.js","sourceRoot":"","sources":["../../src/prompts/implement-task.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,GAAW;IACrB,IAAI,EAAE,gBAAgB;IACtB,KAAK,EAAE,8BAA8B;IACrC,WAAW,EAAE,2PAA2P;IACxQ,SAAS,EAAE;QACT;YACE,IAAI,EAAE,UAAU;YAChB,WAAW,EAAE,sDAAsD;YACnE,QAAQ,EAAE,IAAI;SACf;QACD;YACE,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,uDAAuD;YACpE,QAAQ,EAAE,KAAK;SAChB;KACF;CACF,CAAC;AAEF,KAAK,UAAU,OAAO,CAAC,IAAyB,EAAE,OAAoB;IACpE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAElC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;IACrD,CAAC;IAED,MAAM,QAAQ,GAAoB;QAChC;YACE,IAAI,EAAE,MAAM;YACZ,OAAO,EAAE;gBACP,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE,aAAa,MAAM,CAAC,CAAC,CAAC,QAAQ,MAAM,EAAE,CAAC,CAAC,CAAC,uBAAuB,aAAa,QAAQ;;;aAGtF,OAAO,CAAC,WAAW;aACnB,QAAQ;EACnB,MAAM,CAAC,CAAC,CAAC,cAAc,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE;EACpC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,gBAAgB,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE;;;;;+CAKrB,QAAQ;iCACtB,QAAQ;gBACzB,MAAM,CAAC,CAAC,CAAC,QAAQ,MAAM,EAAE,CAAC,CAAC,CAAC,uCAAuC;;;iCAGlD,QAAQ;;;;;;;;;;;;;;;iFAewC,QAAQ;;;;;4DAK7B,QAAQ;;;mDAGjB,QAAQ;;;2DAGA,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA8C/C,QAAQ;iBACX,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,GAAG,CAAC,CAAC,CAAC,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCA8BzC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAgCN,MAAM,CAAC,CAAC,CAAC,QAAQ,MAAM,EAAE,CAAC,CAAC,CAAC,eAAe,2BAA2B;aAClG;SACF;KACF,CAAC;IAEF,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,CAAC,MAAM,mBAAmB,GAAqB;IACnD,MAAM;IACN,OAAO;CACR,CAAC"}

package/dist/prompts/index.d.ts

@@ -0,0 +1,15 @@
+import { Prompt, ListPromptsResult, GetPromptResult } from '@modelcontextprotocol/sdk/types.js';
+import { ToolContext } from '../types.js';
+/**
+ * Get all registered prompts
+ */
+export declare function registerPrompts(): Prompt[];
+/**
+ * Handle prompts/list request
+ */
+export declare function handlePromptList(): Promise<ListPromptsResult>;
+/**
+ * Handle prompts/get request
+ */
+export declare function handlePromptGet(name: string, args: Record<string, any> | undefined, context: ToolContext): Promise<GetPromptResult>;
+//# sourceMappingURL=index.d.ts.map

package/dist/prompts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prompts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiB,iBAAiB,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC/G,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAuB1C;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,EAAE,CAE1C;AAED;;GAEG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAInE;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YAAK,EAC9B,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,eAAe,CAAC,CAa1B"}

package/dist/prompts/index.js

@@ -0,0 +1,49 @@
+// Import individual prompt definitions
+import { createSpecPrompt } from './create-spec.js';
+import { createSteeringDocPrompt } from './create-steering-doc.js';
+import { implementTaskPrompt } from './implement-task.js';
+import { specStatusPrompt } from './spec-status.js';
+import { injectSpecWorkflowGuidePrompt } from './inject-spec-workflow-guide.js';
+import { injectSteeringGuidePrompt } from './inject-steering-guide.js';
+import { refreshTasksPrompt } from './refresh-tasks.js';
+// Registry of all prompts
+const promptDefinitions = [
+    createSpecPrompt,
+    createSteeringDocPrompt,
+    implementTaskPrompt,
+    specStatusPrompt,
+    injectSpecWorkflowGuidePrompt,
+    injectSteeringGuidePrompt,
+    refreshTasksPrompt
+];
+/**
+ * Get all registered prompts
+ */
+export function registerPrompts() {
+    return promptDefinitions.map(def => def.prompt);
+}
+/**
+ * Handle prompts/list request
+ */
+export async function handlePromptList() {
+    return {
+        prompts: registerPrompts()
+    };
+}
+/**
+ * Handle prompts/get request
+ */
+export async function handlePromptGet(name, args = {}, context) {
+    const promptDef = promptDefinitions.find(def => def.prompt.name === name);
+    if (!promptDef) {
+        throw new Error(`Prompt not found: ${name}`);
+    }
+    try {
+        const messages = await promptDef.handler(args, context);
+        return { messages };
+    }
+    catch (error) {
+        throw new Error(`Failed to generate prompt messages: ${error.message}`);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/prompts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/prompts/index.ts"],"names":[],"mappings":"AAIA,uCAAuC;AACvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAExD,0BAA0B;AAC1B,MAAM,iBAAiB,GAAuB;IAC5C,gBAAgB;IAChB,uBAAuB;IACvB,mBAAmB;IACnB,gBAAgB;IAChB,6BAA6B;IAC7B,yBAAyB;IACzB,kBAAkB;CACnB,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,eAAe;IAC7B,OAAO,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AAClD,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,OAAO;QACL,OAAO,EAAE,eAAe,EAAE;KAC3B,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,IAAY,EACZ,OAA4B,EAAE,EAC9B,OAAoB;IAEpB,MAAM,SAAS,GAAG,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;IAE1E,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,qBAAqB,IAAI,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QACxD,OAAO,EAAE,QAAQ,EAAE,CAAC;IACtB,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,uCAAuC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;IAC1E,CAAC;AACH,CAAC"}

package/dist/prompts/inject-spec-workflow-guide.d.ts

@@ -0,0 +1,3 @@
+import { PromptDefinition } from './types.js';
+export declare const injectSpecWorkflowGuidePrompt: PromptDefinition;
+//# sourceMappingURL=inject-spec-workflow-guide.d.ts.map

package/dist/prompts/inject-spec-workflow-guide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-spec-workflow-guide.d.ts","sourceRoot":"","sources":["../../src/prompts/inject-spec-workflow-guide.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAkD9C,eAAO,MAAM,6BAA6B,EAAE,gBAG3C,CAAC"}

package/dist/prompts/inject-spec-workflow-guide.js

@@ -0,0 +1,47 @@
+import { specWorkflowGuideHandler } from '../tools/spec-workflow-guide.js';
+const prompt = {
+    name: 'inject-spec-workflow-guide',
+    title: 'Inject Spec Workflow Guide into Context',
+    description: 'Injects the complete spec-driven development workflow guide into the conversation context. This provides immediate access to all workflow phases, tools, and best practices without requiring separate tool calls.'
+};
+async function handler(args, context) {
+    // Call the spec-workflow-guide tool to get the full guide
+    const toolResponse = await specWorkflowGuideHandler({}, context);
+    // Extract the guide content from the tool response
+    const guide = toolResponse.data?.guide || '';
+    const dashboardUrl = toolResponse.data?.dashboardUrl;
+    const nextSteps = toolResponse.nextSteps || [];
+    const messages = [
+        {
+            role: 'user',
+            content: {
+                type: 'text',
+                text: `Please review and follow this comprehensive spec-driven development workflow guide:
+
+${guide}
+
+**Current Context:**
+- Project: ${context.projectPath}
+${dashboardUrl ? `- Dashboard: ${dashboardUrl}` : '- Dashboard: Please start the dashboard or use VS Code extension "Spec Workflow MCP"'}
+
+**Next Steps:**
+${nextSteps.map(step => `- ${step}`).join('\n')}
+
+**Important Instructions:**
+1. This guide has been injected into your context for immediate reference
+2. Follow the workflow sequence exactly: Requirements → Design → Tasks → Implementation
+3. Use the MCP tools mentioned in the guide to execute each phase
+4. Always request approval between phases using the approvals tool
+5. Never proceed to the next phase without successful approval cleanup
+
+Please acknowledge that you've reviewed this workflow guide and are ready to help with spec-driven development.`
+            }
+        }
+    ];
+    return messages;
+}
+export const injectSpecWorkflowGuidePrompt = {
+    prompt,
+    handler
+};
+//# sourceMappingURL=inject-spec-workflow-guide.js.map

package/dist/prompts/inject-spec-workflow-guide.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-spec-workflow-guide.js","sourceRoot":"","sources":["../../src/prompts/inject-spec-workflow-guide.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAE3E,MAAM,MAAM,GAAW;IACrB,IAAI,EAAE,4BAA4B;IAClC,KAAK,EAAE,yCAAyC;IAChD,WAAW,EAAE,oNAAoN;CAClO,CAAC;AAEF,KAAK,UAAU,OAAO,CAAC,IAAyB,EAAE,OAAoB;IACpE,0DAA0D;IAC1D,MAAM,YAAY,GAAG,MAAM,wBAAwB,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IAEjE,mDAAmD;IACnD,MAAM,KAAK,GAAG,YAAY,CAAC,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC;IAC7C,MAAM,YAAY,GAAG,YAAY,CAAC,IAAI,EAAE,YAAY,CAAC;IACrD,MAAM,SAAS,GAAG,YAAY,CAAC,SAAS,IAAI,EAAE,CAAC;IAE/C,MAAM,QAAQ,GAAoB;QAChC;YACE,IAAI,EAAE,MAAM;YACZ,OAAO,EAAE;gBACP,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE;;EAEZ,KAAK;;;aAGM,OAAO,CAAC,WAAW;EAC9B,YAAY,CAAC,CAAC,CAAC,gBAAgB,YAAY,EAAE,CAAC,CAAC,CAAC,sFAAsF;;;EAGtI,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;;;gHASiE;aACzG;SACF;KACF,CAAC;IAEF,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,CAAC,MAAM,6BAA6B,GAAqB;IAC7D,MAAM;IACN,OAAO;CACR,CAAC"}

package/dist/prompts/inject-steering-guide.d.ts

@@ -0,0 +1,3 @@
+import { PromptDefinition } from './types.js';
+export declare const injectSteeringGuidePrompt: PromptDefinition;
+//# sourceMappingURL=inject-steering-guide.d.ts.map

package/dist/prompts/inject-steering-guide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-steering-guide.d.ts","sourceRoot":"","sources":["../../src/prompts/inject-steering-guide.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAsD9C,eAAO,MAAM,yBAAyB,EAAE,gBAGvC,CAAC"}