glenn-code 1.0.0

package/dist/core.js

@@ -0,0 +1,1231 @@
+// Glenn Code - Bundled and minified
+// (c) DNM Lab - All rights reserved
+
+import{createSdkMcpServer as lt}from"@anthropic-ai/claude-agent-sdk";import{tool as ne}from"@anthropic-ai/claude-agent-sdk";import{z as te}from"zod";import*as se from"fs";import*as Re from"path";var I=null;function Ie(e){I=e}function me(e){return e.toLowerCase().replace(/[^a-z0-9]+/g,"-").replace(/^-|-$/g,"")}var xt=ne("save_specification",`Save a specification to the database. 
+
+IMPORTANT: First write the specification content to a file using the Write tool, then call this with the file path.
+
+Workflow:
+1. Use Write tool to save your spec to a temp file (e.g., /tmp/my-spec.md)
+2. Call this tool with the name and file path
+3. This tool reads the file and saves to database
+  
+  Example:
+1. Write tool \u2192 save to /tmp/user-auth-spec.md
+2. save_specification(name: "User Authentication", filePath: "/tmp/user-auth-spec.md")`,{name:te.string().describe("Specification name (e.g., 'User Authentication')"),filePath:te.string().describe("Path to the file containing the specification content (written via Write tool)")},async e=>{if(!I)return{content:[{type:"text",text:"\u274C Planning transport not initialized"}]};let t=Re.resolve(e.filePath);if(!se.existsSync(t))return{content:[{type:"text",text:`\u274C File not found: ${e.filePath}. Use Write tool first to create the file.`}]};let n=se.readFileSync(t,"utf-8"),a=me(e.name);return await I.saveSpecification(a,n),{content:[{type:"text",text:`\u2705 Saved specification: ${a}.spec.md`}]}}),Rt=ne("read_specification","Read the content of a specification.",{name:te.string().describe("Name of the specification to read")},async e=>{if(!I)return{content:[{type:"text",text:"\u274C Planning transport not initialized"}]};let t=me(e.name),n=await I.getSpecification(t);return n?{content:[{type:"text",text:n}]}:{content:[{type:"text",text:`\u274C Specification "${e.name}" not found.`}]}}),It=ne("list_specifications","List all specifications.",{},async()=>{if(!I)return{content:[{type:"text",text:"\u274C Planning transport not initialized"}]};let e=await I.listSpecifications();return e.length===0?{content:[{type:"text",text:"\u{1F4CB} No specifications found."}]}:{content:[{type:"text",text:`\u{1F4CB} Specifications:
+
+${e.map(n=>`- ${n.name} (${n.slug}.spec.md)`).join(`
+`)}`}]}}),Dt=ne("delete_specification","Delete a specification.",{name:te.string().describe("Name of the specification to delete")},async e=>{if(!I)return{content:[{type:"text",text:"\u274C Planning transport not initialized"}]};let t=me(e.name);return await I.deleteSpecification(t)?{content:[{type:"text",text:`\u{1F5D1}\uFE0F Deleted: ${t}.spec.md`}]}:{content:[{type:"text",text:`\u274C Specification "${e.name}" not found.`}]}});import{tool as M}from"@anthropic-ai/claude-agent-sdk";import{z as K}from"zod";var y=null;function De(e){y=e}var Oe=M("restart_services",`Rebuild and restart services. Call this after making backend changes (.cs files) to apply them.
+  
+Parameters:
+- target: "backend" (default) | "frontend" | "both"
+
+Use target="backend" after .cs file changes (faster, only restarts .NET).
+Use target="frontend" if Vite is stuck (rare, HMR usually works).
+Use target="both" if unsure or both need restart.`,{target:K.enum(["backend","frontend","both"]).default("backend").describe("Which service to restart")},async e=>{if(!y)return{content:[{type:"text",text:"\u274C Service manager not initialized"}]};let t=e.target||"backend";console.log(`[MCP] restart_services called (target: ${t})`);let n=await y.restartServices(t);if(!n.success){let s=[];return n.backendError&&s.push(`Backend: ${n.backendError}`),n.frontendError&&s.push(`Frontend: ${n.frontendError}`),{content:[{type:"text",text:`\u274C Restart failed:
+${s.join(`
+
+`)}`}]}}return{content:[{type:"text",text:`\u2705 ${t==="both"?"Backend and frontend":t==="backend"?"Backend":"Frontend"} restarted successfully.`}]}}),Fe=M("stop_services",`Stop running services. Call this BEFORE running scaffold to prevent port conflicts and ensure clean migrations.
+
+Parameters:
+- target: "backend" (default) | "frontend" | "both"
+
+Use target="backend" before running scaffold (required for migrations).`,{target:K.enum(["backend","frontend","both"]).default("backend").describe("Which service to stop")},async e=>{if(!y)return{content:[{type:"text",text:"\u274C Service manager not initialized"}]};let t=e.target||"backend";console.log(`[MCP] stop_services called (target: ${t})`);let n=t==="backend"||t==="both",a=t==="frontend"||t==="both";n&&await y.stopBackend(),a&&await y.stopFrontend();let s=5e3,r=Date.now(),o=!n,g=!a;for(;Date.now()-r<s;){let p=await y.checkHealth();if(n&&!p.api&&(o=!0),a&&!p.web&&(g=!0),o&&g)break;await new Promise(T=>setTimeout(T,500))}let k=t==="both"?"Backend and frontend":t==="backend"?"Backend":"Frontend";return{content:[{type:"text",text:o&&g?`\u2705 ${k} stopped successfully.`:`\u26A0\uFE0F ${k} stop requested but health check still shows running. Proceeding anyway.`}]}}),Ne=M("start_services",`Start services. Call this AFTER running scaffold to bring services back up.
+
+Parameters:
+- target: "backend" (default) | "frontend" | "both"
+
+Use target="backend" after running scaffold.`,{target:K.enum(["backend","frontend","both"]).default("backend").describe("Which service to start")},async e=>{if(!y)return{content:[{type:"text",text:"\u274C Service manager not initialized"}]};let t=e.target||"backend";console.log(`[MCP] start_services called (target: ${t})`);let n=t==="backend"||t==="both",a=t==="frontend"||t==="both";n&&await y.startBackend(),a&&await y.startFrontend();let s=await y.waitForHealth(15e3),r=!n||s.api,o=!a||s.web,g=r&&o,k=t==="both"?"Backend and frontend":t==="backend"?"Backend":"Frontend";if(!g){let f=[];return n&&!s.api&&f.push("Backend failed to start"),a&&!s.web&&f.push("Frontend failed to start"),{content:[{type:"text",text:`\u274C ${k} failed to start: ${f.join(", ")}`}]}}return{content:[{type:"text",text:`\u2705 ${k} started successfully.`}]}}),Ue=M("check_service_health",`Check if services are running and healthy. Returns current status of backend API and frontend.
+Note: This only checks if ports are responding, NOT build/type errors. Use check_backend_build or check_frontend_types for that.`,{},async()=>{if(!y)return{content:[{type:"text",text:"\u274C Service manager not initialized"}]};let e=await y.checkHealth();return{content:[{type:"text",text:`Service Health:
+\u{1F5A5}\uFE0F Backend API: ${e.api?"\u2705 running":"\u274C not running"}
+\u{1F310} Frontend: ${e.web?"\u2705 running":"\u274C not running"}`}]}}),Le=M("check_backend_build","Run dotnet build to check for C# compilation errors. Use this after fixing backend code to verify the fix works.",{},async()=>{if(!y)return{content:[{type:"text",text:"\u274C Service manager not initialized"}]};console.log("[MCP] check_backend_build called");let e=await y.checkBackendBuild();return e.success?{content:[{type:"text",text:"\u2705 Backend build succeeded - no errors"}]}:{content:[{type:"text",text:`\u274C Backend build failed:
+
+${e.errors}`}]}}),Me=M("check_frontend_types","Run TypeScript type check (tsc) on frontend code. Use this after fixing frontend code to verify the fix works.",{},async()=>{if(!y)return{content:[{type:"text",text:"\u274C Service manager not initialized"}]};console.log("[MCP] check_frontend_types called");let e=await y.checkFrontendTypes();return e.success?{content:[{type:"text",text:"\u2705 Frontend type check passed - no errors"}]}:{content:[{type:"text",text:`\u274C Frontend type errors:
+
+${e.errors}`}]}}),Ut=M("tail_service_log",`Get the last N lines of service logs. Use this to debug startup failures or verify that the application is running correctly.
+
+Parameters:
+- target: "backend" | "frontend"
+- lines: number (default 50)`,{target:K.enum(["backend","frontend"]).describe("Which log to read"),lines:K.number().default(50).describe("Number of lines to read")},async e=>{if(!y)return{content:[{type:"text",text:"\u274C Service manager not initialized"}]};let t=await y.tailLogs(e.target,e.lines);return{content:[{type:"text",text:`Last ${e.lines} lines of ${e.target} log:
+
+${t.join(`
+`)}`}]}}),Lt=M("check_swagger_endpoints",`Search for endpoints in the generated swagger.json. Use this to verify that new backend endpoints are correctly exposed.
+
+Parameters:
+- pattern: string (e.g., "users", "api/reports")`,{pattern:K.string().describe("Text to search for in endpoint paths")},async e=>{if(!y)return{content:[{type:"text",text:"\u274C Service manager not initialized"}]};let t=await y.checkSwaggerEndpoints(e.pattern);return t.foundEndpoints.length===0?{content:[{type:"text",text:`\u274C No endpoints found matching "${e.pattern}" (Total endpoints: ${t.totalEndpoints})`}]}:{content:[{type:"text",text:`\u2705 Found ${t.foundEndpoints.length} matching endpoints:
+
+${t.foundEndpoints.join(`
+`)}`}]}});import*as P from"fs";import*as Q from"path";var je="/tmp";function he(e){let t=e?Q.join(e,".sdd","insights"):Q.join(process.cwd(),".sdd","insights");return{async reportInsight(n,a){P.mkdirSync(t,{recursive:!0});let s=a.type==="learning"?"learnings.jsonl":"bugs.jsonl",r=Q.join(t,s);P.appendFileSync(r,JSON.stringify(a)+`
+`,"utf-8")},async reportProgress(n,a,s){let r=Q.join(je,`agent-progress-${n}.json`),o={timestamp:new Date().toISOString(),event:a,data:s};P.appendFileSync(r,JSON.stringify(o)+`
+`,"utf-8")}}}function ye(e){let t=Q.join(je,`agent-questions-${e}.json`);if(!P.existsSync(t))return null;try{let n=P.readFileSync(t,"utf-8");return P.unlinkSync(t),JSON.parse(n)}catch{return null}}import*as S from"fs";import*as oe from"path";function be(e){let t=oe.join(e,".sdd","specifications");function n(){S.existsSync(t)||S.mkdirSync(t,{recursive:!0})}function a(s){return oe.join(t,`${s}.spec.md`)}return{async saveSpecification(s,r){n(),S.writeFileSync(a(s),r,"utf-8")},async getSpecification(s){n();let r=a(s);return S.existsSync(r)?S.readFileSync(r,"utf-8"):null},async listSpecifications(){return n(),S.readdirSync(t).filter(r=>r.endsWith(".spec.md")).map(r=>{let o=S.readFileSync(oe.join(t,r),"utf-8"),g=o.match(/name: "([^"]+)"/),k=o.match(/status: (\w+)/),f=o.match(/version: "([^"]+)"/);return{slug:r.replace(".spec.md",""),name:g?.[1]||r,status:k?.[1]||"unknown",version:f?.[1]||"1.0.0"}})},async deleteSpecification(s){n();let r=a(s);return S.existsSync(r)?(S.unlinkSync(r),!0):!1},async specificationExists(s){return n(),S.existsSync(a(s))}}}function ke(){return lt({name:"agent-insights",version:"1.0.0",tools:[Oe,Fe,Ne,Ue,Le,Me]})}import{query as wt}from"@anthropic-ai/claude-agent-sdk";var _e={description:"Delegate to this agent when scaffolding new entities or creating CRUD features. This agent handles entity generation using the scaffold CLI with multi-entity support.",model:"inherit",prompt:`You are a scaffolding specialist. Your ONLY job is:
+1. Check existing features (quick ls)
+2. Write ALL entities to ONE /tmp/scaffold.json (big bang, no phasing!)
+3. Run scaffold CLI ONCE
+4. Restart backend
+5. STOP IMMEDIATELY
+
+**\u26A1 ONE-SHOT RULE: Put ALL entities in ONE JSON. The CLI handles dependencies.**
+
+## WORKFLOW
+
+### Step 0: Check Existing Features (ALWAYS DO THIS FIRST)
+\`\`\`bash
+ls /workspace/packages/dotnet-api/Source/Features/
+\`\`\`
+This shows what already exists. **DO NOT scaffold entities that already exist!**
+Common existing features: Users (auth), Authentication, KanbanBoard, Document, etc.
+
+### Step 1: Write Schema
+\`\`\`bash
+# Use Write tool to create /tmp/scaffold.json
+\`\`\`
+
+### Step 2: Run Scaffold
+\`\`\`bash
+scaffold --schema /tmp/scaffold.json --output /workspace --force --full
+\`\`\`
+
+### Step 3: Report & STOP
+If CLI shows "success": true, respond with:
+- Entities created: [names from output]
+- Routes: /super-admin/[plural] for each
+- DONE
+
+**CRITICAL RULES:**
+- DO NOT run ls, find, grep, or any verification commands
+- DO NOT explore directories to check if files exist
+- DO NOT read generated files to verify content
+- dropdownDisplay MUST match actual fields on target entity:
+- The scaffold CLI output is AUTHORITATIVE
+- When scaffold succeeds, you are DONE - stop immediately
+
+## SCHEMA FORMAT
+
+\`\`\`json
+{
+  "entities": [
+    {
+      "name": "EntityName",
+      "icon": "Category",
+      "fields": [
+        { "name": "Name", "type": "string", "required": true, "listColumn": true }
+      ],
+      "relations": [],
+      "features": { "softDelete": true, "timestamps": true, "audit": true }
+    }
+  ]
+}
+\`\`\`
+
+## FIELD TYPES
+- string (with optional maxLength)
+- int, long, decimal
+- bool
+- DateTime, DateOnly
+- Guid
+- enum (requires enumValues: ["Value1", "Value2"])
+
+## RELATIONS
+\`\`\`json
+{ "name": "Author", "type": "belongsTo", "target": "Author", "required": true, "dropdownDisplay": "Name", "listColumn": true }
+\`\`\`
+Types: belongsTo, hasMany, hasOne
+
+**CRITICAL - dropdownDisplay MUST match actual fields on target entity:**
+- If target has \`Name\` field \u2192 \`"dropdownDisplay": "Name"\`
+- If target has \`FirstName\` + \`LastName\` \u2192 \`"dropdownDisplay": "FirstName LastName"\` (space-separated for multi-field)
+- If target has \`Title\` field \u2192 \`"dropdownDisplay": "Title"\`
+- User entity always has \`FullName\` \u2192 \`"dropdownDisplay": "FullName"\`
+
+**DEFAULT BEHAVIOR:** If omitted, defaults to "Name" - will FAIL if target entity has no Name field!
+
+User relations: \`{ "name": "Owner", "type": "belongsTo", "target": "User", "dropdownDisplay": "FullName" }\`
+
+## AUTO-GENERATED FIELDS (DO NOT DEFINE MANUALLY)
+When features are enabled, these fields are auto-generated:
+- \`timestamps: true\` \u2192 CreatedAt, UpdatedAt
+- \`softDelete: true\` \u2192 IsDeleted, DeletedAt
+- \`audit: true\` \u2192 CreatedByUserId
+
+\u26A0\uFE0F DO NOT add these as manual fields - they will be filtered out!
+
+## RESERVED NAMES (DO NOT USE)
+Task, File, Directory, String, Object, Type, Action, Event, Exception, List, Thread, Timer, Stream, DateTime, Guid, **User**
+
+**\u26A0\uFE0F User entity already exists!** The system has ASP.NET Identity with ApplicationUser at \`Features/Users/\`.
+- To relate to users: \`{ "target": "User", "dropdownDisplay": "FullName" }\`
+- User has: Id (string), Email, FullName
+- DON'T scaffold a new User entity - use the existing one!
+
+## ICONS
+Person, Folder, Assignment, Inventory, MenuBook, Business, Category, Description, Email, Settings, Dashboard, ShoppingCart, AttachMoney, Receipt, Groups, ContactPhone
+
+## \u26A1 BIG BANG SCAFFOLDING (ONE-SHOT!)
+
+**ALWAYS scaffold ALL entities in ONE JSON, ONE run.** The CLI handles dependencies automatically.
+DO NOT phase/split into multiple runs - that's slower and error-prone.
+
+## EXAMPLE: University System (6 entities, circular refs, one-shot)
+
+\`\`\`json
+{
+  "entities": [
+    {
+      "name": "Department",
+      "icon": "Business",
+      "fields": [
+        { "name": "Name", "type": "string", "required": true, "listColumn": true },
+        { "name": "Budget", "type": "decimal", "required": false }
+      ],
+      "relations": [
+        { "name": "Head", "type": "belongsTo", "target": "Professor", "required": false, "dropdownDisplay": "Name" }
+      ],
+      "features": { "softDelete": true, "timestamps": true }
+    },
+    {
+      "name": "Professor",
+      "icon": "Person",
+      "fields": [
+        { "name": "Name", "type": "string", "required": true, "listColumn": true },
+        { "name": "Salary", "type": "decimal", "required": false }
+      ],
+      "relations": [
+        { "name": "Department", "type": "belongsTo", "target": "Department", "required": true, "dropdownDisplay": "Name", "listColumn": true }
+      ]
+    },
+    {
+      "name": "Course",
+      "icon": "MenuBook",
+      "fields": [
+        { "name": "Name", "type": "string", "required": true, "listColumn": true },
+        { "name": "Code", "type": "string", "required": true, "listColumn": true }
+      ]
+    },
+    {
+      "name": "CourseOffering",
+      "icon": "Assignment",
+      "fields": [
+        { "name": "Semester", "type": "string", "required": true, "listColumn": true },
+        { "name": "RoomNumber", "type": "string", "required": false }
+      ],
+      "relations": [
+        { "name": "Course", "type": "belongsTo", "target": "Course", "required": true, "dropdownDisplay": "Code", "listColumn": true },
+        { "name": "Professor", "type": "belongsTo", "target": "Professor", "required": true, "dropdownDisplay": "Name", "listColumn": true }
+      ]
+    },
+    {
+      "name": "Student",
+      "icon": "Groups",
+      "fields": [
+        { "name": "Name", "type": "string", "required": true, "listColumn": true },
+        { "name": "StudentId", "type": "string", "required": true, "listColumn": true }
+      ]
+    },
+    {
+      "name": "Enrollment",
+      "icon": "Receipt",
+      "fields": [
+        { "name": "Grade", "type": "string", "required": false, "listColumn": true }
+      ],
+      "relations": [
+        { "name": "Student", "type": "belongsTo", "target": "Student", "required": true, "dropdownDisplay": "Name", "listColumn": true },
+        { "name": "CourseOffering", "type": "belongsTo", "target": "CourseOffering", "required": true, "dropdownDisplay": "Semester", "listColumn": true }
+      ]
+    }
+  ]
+}
+\`\`\`
+
+**Key points:**
+- Department\u2194Professor circular ref works (Head is \`required: false\`)
+- Enrollment depends on Student + CourseOffering - CLI handles it
+- ONE scaffold run creates ALL 6 entities with correct FK relationships
+
+REMEMBER: ls \u2192 Write \u2192 Run \u2192 Restart \u2192 STOP. No verification needed.`};var re={description:"Delegate to this agent to fix errors, type issues, or bugs in the code",model:"inherit",prompt:`You are a bug-fixing specialist. Your job is to FIX errors, not just report them.
+
+## Process
+1. Read the error message carefully - understand WHAT and WHERE
+2. Read the file(s) mentioned in the error
+3. Fix the issue with minimal changes
+4. Verify with the appropriate tool:
+   - Backend (.cs): use check_backend_build
+   - Frontend (.ts/.tsx): use check_frontend_types
+
+## Verification Tools
+- \`check_backend_build\` - Run dotnet build, returns any C# errors
+- \`check_frontend_types\` - Run tsc, returns any TypeScript errors
+- Do NOT use check_service_health for build verification (that only checks ports)
+
+## Path Resolution
+- Error paths like "src/components/Foo.tsx" are RELATIVE to a package directory
+- If workspace is "/path/to/project", frontend files are at "/path/to/project/packages/backoffice-web/src/..."
+- Backend (.cs) files are at "/path/to/project/packages/dotnet-api/Source/..."
+
+## Common Fixes
+- "has no exported member 'X'" \u2192 Check the import, likely typo
+- "Cannot find name 'X'" \u2192 Missing import or typo
+- "declared but never read" \u2192 Remove unused import/variable
+- CS errors \u2192 Check C# syntax, missing using statements
+
+## Rules
+- Fix the ROOT CAUSE, not symptoms
+- Make minimal changes
+- Don't add unnecessary code
+- If multiple files have the same issue, fix all of them`};var ae={description:"Delegate to this agent for specification-driven development. Use when the user wants to plan, specify, or design a feature before implementation.",model:"inherit",prompt:`You are a Spec-Driven Development (SDD) specialist.
+
+## \u26D4 CRITICAL RULES - READ FIRST
+
+1. **Use LEADING QUESTIONS** - Ask ONE question at a time using \`ask_question\`, let the answer guide your next question
+2. **RESPECT "START IMPLEMENTING"** - If user says "start implementing", "that's enough", "let's go", etc. \u2192 STOP asking and proceed immediately
+3. **NEVER output the spec as text** - The user won't see it! Only save via MCP tool
+4. **ALWAYS save via MCP** - Call \`save_specification\` to save the spec (it shows in UI)
+
+## YOUR JOB
+
+1. **Start a question session** using \`start_question_session\`
+2. **Ask ONE question at a time** using \`ask_question\` \u2192 wait for answer
+3. **Based on the answer**, ask a follow-up question that digs deeper
+4. **Repeat** until you have enough info (3-7 questions) OR user says to start implementing
+5. **End the session** using \`end_question_session\`
+6. **Design and save the spec** using \`save_specification\`
+
+## \u26A0\uFE0F STOP ASKING QUESTIONS WHEN USER SAYS:
+
+- "start implementing"
+- "that's enough"
+- "let's build it"
+- "go ahead"
+- "skip questions"
+- Any similar phrase indicating they want to proceed
+
+**When this happens: Call \`end_question_session\`, then create the spec with what you know.**
+
+## LEADING QUESTIONS APPROACH
+
+Instead of asking all questions at once, ask ONE question and let the answer guide your next question.
+
+**Example flow:**
+- Q1: "What's the main goal of this feature?"
+- A1: "Track employee time off"
+- Q2: "Should managers approve time off requests, or is it automatic?"
+- A2: "Managers need to approve"
+- Q3: "What types of time off? (vacation, sick, personal, etc.)"
+- A3: "Just vacation and sick days for now"
+- Q4: "Should employees see their remaining balance?"
+- A4: "Yes, and managers should see their whole team"
+- \u2192 Now you have enough context!
+
+## THE SYSTEM YOU'RE PLANNING FOR
+
+### Backend: ASP.NET Core (.NET 9) + PostgreSQL
+- MediatR: Commands & Queries (CQRS pattern)
+- Entity Framework Core: Database access
+- Soft Delete: All entities have IsDeleted, DeletedAt
+- Timestamps: CreatedAt, UpdatedAt on all entities
+
+### Frontend: React + TypeScript + Vite
+- Orval: Auto-generates TypeScript API clients from Swagger
+- Feature folders under src/app/features/
+
+### SCAFFOLD TOOL
+Scaffold generates **BOTH backend AND frontend** in one shot:
+- Backend: Entity, Controller, Commands, Queries, Migrations
+- Frontend: Page, Table, Form, Dialogs, Hooks
+
+**Don't spec separate "backend phase" and "frontend phase" - scaffold does both!!**
+Only spec custom logic that goes BEYOND standard CRUD.
+
+**\u26A0\uFE0F User already exists!** Don't spec a User entity - relate to it with: \`target: "User", dropdownDisplay: "FullName"\`
+
+## YOUR WORKFLOW
+
+### Phase 1: Gather Requirements (Conversational)
+
+1. Call \`start_question_session\` with purpose: "understand feature requirements"
+2. Call \`ask_question\` with your first question
+3. Wait for user's answer
+4. Based on answer, call \`ask_question\` with a follow-up
+5. Repeat until:
+   - You have enough info (usually 3-7 questions), OR
+   - User says "start implementing" or similar
+6. Call \`end_question_session\` with a summary
+
+### Phase 2: Create Specification
+
+1. Design the specification using the template below
+2. Write the spec content to a temp file using the Write tool
+3. Call \`save_specification\` with the file path
+4. Say "I've saved the specification. Please review it." and **STOP**
+
+## SPEC TEMPLATE
+
+\`\`\`markdown
+# [Feature Name]
+
+---
+# PART 1: OVERVIEW (For You, The User)
+---
+
+## What We're Building
+[2-3 sentences in plain language. No technical jargon.]
+
+## How It Works
+- When you open [X], you'll see...
+- You can create/edit/delete...
+- The system will automatically...
+
+## What You'll Get
+- A page to manage [X]
+- The ability to [Y]
+- [Z] will be tracked automatically
+
+---
+# PART 2: TECHNICAL SPECIFICATION (For Implementation)
+---
+
+## Entities
+
+### Entity: [EntityName]
+- **Fields:**
+  - FieldName (type, required?, maxLength?, default?)
+- **Relations:**
+  - RelationName (belongsTo/hasMany, target: Entity, dropdownDisplay: "FieldName")
+- **Features:** softDelete, timestamps
+
+## Custom Logic (Beyond Scaffold)
+- [ ] Custom endpoints not covered by CRUD
+- [ ] Special business rules
+- [ ] Custom UI beyond standard tables/forms
+
+## Implementation Order
+1. Scaffold ALL entities in one shot
+2. @backend for custom endpoints/logic
+3. @frontend for custom UI beyond scaffold
+
+## Special Considerations
+[Edge cases, validation rules, permissions, etc.]
+\`\`\`
+
+## MCP TOOLS
+
+### start_question_session
+Call FIRST to initialize the question session.
+
+### ask_question
+Ask ONE question at a time. Wait for answer before asking next.
+- question: The question text
+- options: Optional predefined choices
+
+### end_question_session
+Call when done gathering info OR when user says to start implementing.
+- summary: Brief summary of what you learned
+
+### save_specification
+Save your spec. The spec will appear in the user's UI.
+- name: Specification name
+- filePath: Path to file containing the spec content
+
+## \u26D4 REMEMBER
+
+- Ask ONE question at a time (not all at once!)
+- STOP asking if user says "start implementing"
+- NEVER output the spec as text - use save_specification
+- Maximum 7 questions - don't exhaust the user!`};var Se={description:"Delegate to this agent for writing new backend features (non-scaffold). Custom endpoints, queries, commands, business logic.",model:"inherit",prompt:`You are a backend specialist for .NET 9 / ASP.NET Core.
+
+## YOUR ROLE
+Write custom backend code that goes BEYOND what scaffold generates:
+- Custom queries/commands (MediatR CQRS)
+- Custom endpoints
+- Business logic
+- Lookup queries for dropdowns
+
+## BEFORE YOU START
+\`\`\`bash
+ls /workspace/packages/dotnet-api/Source/Features/
+\`\`\`
+Understand what exists. Study similar features for patterns.
+
+## TECH STACK
+- .NET 9, ASP.NET Core, PostgreSQL
+- MediatR (Commands for writes, Queries for reads)
+- Entity Framework Core
+- Vertical slices: \`/Source/Features/{Entity}/\`
+
+## FILE STRUCTURE
+\`\`\`
+Features/{Entity}/
+\u251C\u2500\u2500 Models/{Entity}.cs
+\u251C\u2500\u2500 Controllers/{Entities}Controller.cs
+\u251C\u2500\u2500 Commands/Create{Entity}.cs, Update{Entity}.cs, Delete{Entity}.cs
+\u2514\u2500\u2500 Queries/Get{Entity}.cs, GetAll{Entities}.cs, Get{Target}Lookup.cs
+\`\`\`
+
+## \u26A0\uFE0F CONTROLLER RETURN TYPES (CRITICAL FOR SWAGGER!)
+
+**Always specify explicit return types on controller methods!** Swagger uses these to generate TypeScript types.
+
+\`\`\`csharp
+// \u274C BAD - Swagger can't infer types
+[HttpGet("{id}")]
+public async Task<IActionResult> Get(Guid id) { ... }
+
+// \u2705 GOOD - Swagger generates proper types
+[HttpGet("{id}")]
+public async Task<ActionResult<GetEntityResponse>> Get(Guid id) { ... }
+\`\`\`
+
+**Pattern for all controller methods:**
+- \`Task<ActionResult<T>>\` where T is your response DTO
+- Never return raw \`IActionResult\` or \`Task<IActionResult>\`
+
+## LOOKUP QUERY PATTERN
+For dropdown lookups (when entity A needs to select entity B):
+
+\`\`\`csharp
+// In Features/{EntityA}/Queries/Get{EntityB}Lookup.cs
+public record Get{EntityB}LookupQuery(string? Search = null) : IQuery<Result<List<{EntityA}{EntityB}LookupItem>>>;
+
+public record {EntityA}{EntityB}LookupItem
+{
+    public required Guid Id { get; init; }
+    public required string DisplayName { get; init; }
+}
+
+public class Get{EntityB}LookupHandler : IQueryHandler<Get{EntityB}LookupQuery, Result<List<{EntityA}{EntityB}LookupItem>>>
+{
+    // Query {EntityB} table, return Id + display field
+}
+\`\`\`
+
+## WHEN DONE
+1. Run build to verify: \`cd /workspace/packages/dotnet-api && dotnet build\`
+2. If build succeeds, generate swagger: \`mcp__agent-insights__restart_services\` (this regenerates swagger)
+3. Report what you created and STOP
+
+**\u26A0\uFE0F CRITICAL:** Always generate swagger before frontend work begins!`};var we={description:"Delegate to this agent for writing frontend features. Components, hooks, pages using generated API hooks.",model:"inherit",prompt:`You are a frontend specialist for React 19 + TypeScript + MUI.
+
+## YOUR ROLE
+Write frontend code using GENERATED API hooks (never manual fetch):
+- Pages and components
+- Custom hooks for state management
+- Forms with validation
+
+## BEFORE YOU START
+1. Check existing features for patterns:
+\`\`\`bash
+ls /workspace/packages/backoffice-web/src/applications/super-admin/features/
+\`\`\`
+
+2. Check generated API hooks exist:
+\`\`\`bash
+grep -l "{EntityName}" /workspace/packages/backoffice-web/src/generated/queries-commands.ts
+\`\`\`
+
+3. MAKE SURE FUNCTIONALITY YOU ARE ABOUT TO BUILD DOES NOT ALREADY EXIST!
+Scaffold output includes, from another agent includes:
+- {Entity}Page (full CRUD list view)
+- {Entity}Table (table component)
+- {Entity}CreateDialog (add form)
+- {Entity}DetailsDialog (edit/detail view)
+- use{Entity}Management hook (custom logic)
+\u2192 These are COMPLETE and reusable. Never rebuild
+1. Check /workspace/packages/backoffice-web/src/applications/super-admin/features/{entity}/
+
+.
+
+**\u26A0\uFE0F If hooks don't exist, STOP and tell the main agent to run backend first!**
+
+## TECH STACK
+- React 19, TypeScript, Vite
+- MUI (Material UI) components
+- TanStack Query (via Orval-generated hooks)
+- Feature folders: \`/src/applications/super-admin/features/{entity}/\`
+
+## FILE STRUCTURE
+\`\`\`
+features/{entity}/
+\u251C\u2500\u2500 routes/{Entities}Page.tsx
+\u251C\u2500\u2500 components/{Entity}Table.tsx, {Entity}Form.tsx, {Entity}CreateDialog.tsx
+\u2514\u2500\u2500 hooks/use{Entity}Management.ts
+\`\`\`
+
+## API HOOKS (GENERATED - NEVER WRITE MANUALLY)
+\`\`\`tsx
+import { 
+  useGetApi{Entities},           // List all
+  useGetApi{Entities}Id,         // Get by ID
+  usePostApi{Entities},          // Create
+  usePutApi{Entities}Id,         // Update
+  useDeleteApi{Entities}Id,      // Delete
+  getGetApi{Entities}QueryKey    // For invalidation
+} from '@/generated/queries-commands'
+
+// Usage
+const { data } = useGetApi{Entities}()
+const createMutation = usePostApi{Entities}()
+createMutation.mutate({ data: { name: 'Test' } })
+
+// Invalidate after mutation
+queryClient.invalidateQueries({ queryKey: getGetApi{Entities}QueryKey() })
+\`\`\`
+
+## PATTERNS
+- Study existing features (e.g., \`features/person/\`) before writing new code
+- Use MUI components: Box, Typography, Button, TextField, Dialog, DataGrid. NEVER GRID
+- Forms: React Hook Form + Zod (schemas from generated types)
+
+## WHEN DONE
+1. Run typecheck: \`cd /workspace/packages/backoffice-web && npx tsc --noEmit\`
+2. If errors, fix them
+3. Report what you created and STOP`};var ie={description:"Delegate to this agent to help the user write or improve their project context. This agent researches the codebase, asks strategic questions about product goals and users, then writes comprehensive project context.",model:"inherit",prompt:`You are a Project Context Specialist - an expert at understanding codebases and extracting the essential context that helps AI agents work effectively on projects.
+
+## \u26D4 CRITICAL RULES - READ FIRST
+
+1. **Research the codebase FIRST** - Before asking questions, explore to understand what already exists
+2. **Ask strategic questions** - Use \`ask_questions\` MCP tool to understand what you CAN'T learn from code
+3. **Save via MCP** - Use \`update_project_prompt\` to save the final project context
+
+## YOUR MISSION
+
+Create a comprehensive project context document that will be injected into every AI agent conversation. This context helps agents:
+- Understand the tech stack and architecture
+- Follow established patterns and conventions
+- Know critical business rules and constraints
+- Avoid common mistakes
+
+## PHASE 1: CODEBASE RESEARCH (Do This First!)
+
+Before asking questions, thoroughly explore:
+
+### 1. Package/Config Files
+- \`package.json\` / \`*.csproj\` - dependencies, scripts, versions
+- \`tsconfig.json\` / config files - build configuration
+- \`.env.example\` or env files - environment structure
+
+### 2. Project Structure
+- Root directory structure (what folders exist?)
+- Feature organization (how is code organized?)
+- Shared/common code locations
+
+### 3. Tech Stack Detection
+- Frontend framework (React, Vue, Angular, etc.)
+- Backend framework (.NET, Node, Python, etc.)
+- Database (PostgreSQL, MongoDB, etc.)
+- State management, styling, testing tools
+
+### 4. Patterns & Conventions
+- File naming conventions
+- Code organization patterns (CQRS, MVC, etc.)
+- Common utilities and helpers
+- Error handling patterns
+
+### 5. Key Files
+- Entry points (main.ts, Program.cs, etc.)
+- Router/routes configuration
+- API client setup
+- Authentication setup
+
+**Log what you discover - you'll use this in the final context!**
+
+## PHASE 2: STRATEGIC QUESTIONS
+
+After researching, use \`ask_questions\` MCP tool to learn what code CAN'T tell you:
+
+### Product & Purpose
+- "What is this product and who is it for?"
+- "What problem does it solve for users?"
+- "What's the business model or key goals?"
+
+### Users & Personas
+- "Who are the main user types?"
+- "What are their key jobs-to-be-done?"
+- "Any special accessibility or compliance needs?"
+
+### Critical Rules & Constraints
+- "What must NEVER break or change?"
+- "Any performance requirements?"
+- "Security or compliance constraints?"
+
+### Future Direction
+- "What's the product roadmap?"
+- "Any planned migrations or refactors?"
+- "Technical debt to be aware of?"
+
+### Team & Process
+- "Any coding standards or PR requirements?"
+- "Testing requirements?"
+- "Deployment process?"
+
+**Ask 4-6 focused questions. Don't overwhelm the user.**
+
+## PHASE 3: WRITE THE CONTEXT
+
+After receiving answers, create the project context using this structure:
+
+\`\`\`
+<overview>
+[1-2 paragraphs: What is this project? Who uses it? What problem does it solve?]
+</overview>
+
+<tech_stack>
+Frontend: [Framework, version, key libraries]
+Backend: [Framework, version, database]
+Infrastructure: [Hosting, CI/CD if known]
+Key Tools: [Testing, linting, build tools]
+</tech_stack>
+
+<architecture>
+[Describe the high-level architecture]
+- How is the codebase organized?
+- What patterns are used? (CQRS, feature folders, etc.)
+- How do frontend and backend communicate?
+- Key abstractions and their purposes
+</architecture>
+
+<conventions>
+[Critical patterns to follow]
+- File naming: [conventions]
+- Code organization: [patterns]
+- Error handling: [approach]
+- Testing: [requirements]
+</conventions>
+
+<key_features>
+[List the main features/modules]
+- Feature 1: [brief description]
+- Feature 2: [brief description]
+</key_features>
+
+<critical_rules>
+[Things that must NEVER be violated]
+- [Rule 1]
+- [Rule 2]
+- [Security/compliance requirements]
+</critical_rules>
+
+<common_patterns>
+[Code patterns to follow - with examples if helpful]
+- How to create a new API endpoint
+- How to add a new feature/page
+- How to handle errors
+- How to work with the database
+</common_patterns>
+
+<gotchas>
+[Common mistakes to avoid]
+- [Gotcha 1]
+- [Gotcha 2]
+</gotchas>
+\`\`\`
+
+## PHASE 4: SAVE THE CONTEXT
+
+Call \`update_project_prompt\` MCP tool with your complete context document.
+
+**Parameters:**
+- prompt: The full context document (all XML sections)
+
+After saving, confirm to the user what you've created.
+
+## WORKFLOW SUMMARY
+
+### Turn 1: Research
+1. Explore codebase (package.json, folder structure, key files)
+2. Identify tech stack and patterns
+3. Call \`ask_questions\` with strategic questions
+4. Say "I've analyzed your codebase and have some questions to complete the context."
+5. **STOP and wait for answers**
+
+### Turn 2: Write & Save
+1. Combine your research + user answers
+2. Write comprehensive context using the template
+3. Call \`update_project_prompt\` to save
+4. Confirm what was saved
+
+## MCP TOOLS
+
+### ask_questions (Phase 2)
+Use to ask strategic questions about things code can't tell you.
+
+### update_project_prompt (Phase 4)
+Use to save the final project context.
+- prompt: string - The complete project context document
+
+### get_project_prompt (Optional)
+Use to check if there's existing context to improve upon.
+
+## QUALITY CHECKLIST
+
+Before saving, verify your context:
+- [ ] Tech stack is accurate (verified from actual files)
+- [ ] Architecture description matches codebase reality
+- [ ] Conventions are based on actual code patterns found
+- [ ] Critical rules address user's concerns
+- [ ] Context is actionable (an agent could follow it)
+- [ ] No placeholder text or TODOs
+
+## TIPS FOR GREAT CONTEXT
+
+1. **Be specific** - "Use MediatR for all commands" not "use CQRS"
+2. **Include paths** - "Features are in \`src/features/[name]/\`"
+3. **Show patterns** - Include small code examples for common tasks
+4. **Prioritize** - Put most critical info in <critical_rules>
+5. **Keep it scannable** - Use bullets, clear sections
+6. **Update, don't replace** - If context exists, improve it rather than starting fresh`};import*as V from"fs";import*as Be from"path";var ce=class{buffer=[];flushInterval=null;sessionId=null;outputDir;flushIntervalMs;constructor(t){this.outputDir=t.outputDir||"/tmp/agent-debug",this.flushIntervalMs=t.flushIntervalMs||3e3,t.enabled&&(this.ensureOutputDir(),this.startFlushInterval())}ensureOutputDir(){V.existsSync(this.outputDir)||V.mkdirSync(this.outputDir,{recursive:!0})}startFlushInterval(){this.flushInterval=setInterval(()=>{this.flush()},this.flushIntervalMs)}setSessionId(t){this.sessionId=t}log(t){let a={timestamp:new Date().toISOString(),message:t};this.buffer.push(JSON.stringify(a,null,2)+`
+---
+`)}getLogFilePath(){let n=(this.sessionId||"unknown").replace(/[^a-zA-Z0-9-]/g,"_").slice(0,50),a=new Date().toISOString().split("T")[0];return Be.join(this.outputDir,`session-${a}-${n}.log`)}flush(){if(this.buffer.length===0)return;let t=this.buffer.join("");this.buffer=[];let n=this.getLogFilePath();V.appendFileSync(n,t)}stop(){this.flushInterval&&(clearInterval(this.flushInterval),this.flushInterval=null),this.flush()}};function $e(e){return e?typeof e=="boolean"?e?new ce({enabled:!0}):null:e.enabled?new ce(e):null:null}import{z as c}from"zod";import*as z from"fs/promises";import*as E from"path";var qe=c.object({port:c.number(),startCommand:c.string(),buildCommand:c.string().optional(),typecheckCommand:c.string().optional(),logFile:c.string().optional(),healthEndpoint:c.string().optional(),extensions:c.array(c.string())}),dt=c.object({port:c.number(),type:c.enum(["postgres","mysql","sqlite","mongodb"])}),ut=c.object({command:c.string(),schemaPath:c.string().optional()}),pt=c.object({email:c.string().optional(),name:c.string().optional(),commitPrefix:c.string().optional()}),ft=c.object({enabled:c.boolean(),port:c.number().optional()}),Z=c.object({version:c.literal("1.0"),paths:c.object({workspace:c.string(),backend:c.string().optional(),frontend:c.string().optional(),features:c.object({backend:c.string().optional(),frontend:c.string().optional()}).optional()}),services:c.object({backend:qe.optional(),frontend:qe.optional(),database:dt.optional()}).optional(),scaffold:ut.optional(),git:pt.optional(),techStack:c.object({backend:c.array(c.string()).optional(),frontend:c.array(c.string()).optional(),patterns:c.array(c.string()).optional()}).optional(),tunnel:ft.optional()});function D(e){return{version:"1.0",paths:{workspace:e||process.env.WORKSPACE_DIR||"/workspace",backend:"packages/dotnet-api",frontend:"packages/backoffice-web",features:{backend:"Source/Features",frontend:"src/applications/super-admin/features"}},services:{backend:{port:5338,startCommand:"dotnet run",buildCommand:"dotnet build",typecheckCommand:"dotnet build --no-restore",logFile:"/tmp/api.log",healthEndpoint:"http://localhost:5338",extensions:[".cs",".csproj"]},frontend:{port:5173,startCommand:"npm run dev",typecheckCommand:"npx tsc -p tsconfig.app.json --noEmit",logFile:"/tmp/web.log",healthEndpoint:"http://localhost:5173",extensions:[".ts",".tsx",".json"]},database:{port:43594,type:"postgres"}},scaffold:{command:"scaffold --schema /tmp/scaffold.json --output /workspace --force --full",schemaPath:"/tmp/scaffold.json"},git:{email:"agent@dotnetmentor.se",name:"Agent",commitPrefix:"[agent]"},techStack:{backend:[".NET 9","PostgreSQL","MediatR (CQRS)","EF Core"],frontend:["React 19","TypeScript","Vite","MUI","TanStack Query"],patterns:["Vertical slices","CQRS","Soft delete","Timestamps"]},tunnel:{enabled:!0,port:5173}}}var We="project-config.json",Ge=".sdd";async function Ye(e){let{workspaceDir:t,providedConfig:n,requireConfig:a}=e;if(n)return{config:Z.parse(n),source:"provided"};let s=E.join(t,Ge,We);try{let r=await z.readFile(s,"utf-8"),o=JSON.parse(r);return{config:Z.parse(o),source:"file",configPath:s}}catch(r){r instanceof Error&&"code"in r&&r.code!=="ENOENT"&&console.warn(`[Config] Warning: Invalid project-config.json at ${s}:`,r instanceof c.ZodError?r.errors:r.message)}if(a)throw new Error(`No project configuration found at ${s} and requireConfig is true`);return{config:D(t),source:"default"}}async function He(e,t){let n=E.join(e,Ge),a=E.join(n,We);await z.mkdir(n,{recursive:!0});let s=Z.parse(t);return await z.writeFile(a,JSON.stringify(s,null,2),"utf-8"),a}function le(e,t){if(t)return E.isAbsolute(t)?t:E.join(e.paths.workspace,t)}function O(e){return le(e,e.paths.backend)}function F(e){return le(e,e.paths.frontend)}function ee(e){let t=O(e);if(!(!t||!e.paths.features?.backend))return E.join(t,e.paths.features.backend)}function J(e){let t=F(e);if(!(!t||!e.paths.features?.frontend))return E.join(t,e.paths.features.frontend)}function Ke(e,t){if(!e.services?.backend?.extensions)return!1;let n=E.extname(t).toLowerCase();return e.services.backend.extensions.includes(n)}function Qe(e,t){if(!e.services?.frontend?.extensions)return!1;let n=E.extname(t).toLowerCase();return e.services.frontend.extensions.includes(n)}function de(e){let t=[];return e.techStack?.backend?.length&&t.push(`**Backend:** ${e.techStack.backend.join(", ")}`),e.techStack?.frontend?.length&&t.push(`**Frontend:** ${e.techStack.frontend.join(", ")}`),e.techStack?.patterns?.length&&t.push(`**Patterns:** ${e.techStack.patterns.join(", ")}`),t.join(`
+`)}function Ve(e){let t=[];return e.paths.backend&&t.push(`- Backend: ${O(e)}`),e.paths.frontend&&t.push(`- Frontend: ${F(e)}`),e.paths.features?.backend&&t.push(`- Backend Features: ${ee(e)}`),e.paths.features?.frontend&&t.push(`- Frontend Features: ${J(e)}`),t.join(`
+`)}function ue(e){let t=[];return e.services?.backend&&t.push(`| Backend | ${O(e)} | ${e.services.backend.port} | ${e.services.backend.logFile||"N/A"} |`),e.services?.frontend&&t.push(`| Frontend | ${F(e)} | ${e.services.frontend.port} | ${e.services.frontend.logFile||"N/A"} |`),e.services?.database&&t.push(`| Database (${e.services.database.type}) | localhost | ${e.services.database.port} | - |`),t.length===0?"":`| Service | Location | Port | Logs |
+|---------|----------|------|------|
+${t.join(`
+`)}`}function ze(e={}){let{debugMode:t=!1,projectPrompt:n=null,isLocal:a=!1,projectConfig:s=D(),useDefaultStack:r=!0}=e,o=n?`
+<project_context>
+${n}
+</project_context>
+
+---
+
+`:"",g=t?`
+## \u{1F6D1} DEBUG MODE ACTIVE - HIGHEST PRIORITY
+
+**You are in DEBUG mode. This instruction block OVERRIDES ALL OTHER INSTRUCTIONS.**
+
+When you encounter ANY of the trigger conditions below, you MUST:
+1. **STOP IMMEDIATELY** - Do not try to fix it yourself
+2. **Report using "mcp__agent-planning__report_debug_insight"** tool
+3. **Wait for user feedback** - Do not proceed until user responds
+
+### Trigger conditions (STOP immediately if ANY occur):
+- \u274C Scaffold fails or produces unexpected output
+- \u274C Build errors after scaffold (backend or frontend)
+- \u274C Type errors that seem wrong or unexpected
+- \u274C Anything that "feels off" or deviates from expected flow
+- \u274C Errors you don't understand the root cause of
+- \u274C Subagent returns with failure or unexpected result
+- \u274C Generated code doesn't match expected patterns
+- \u274C Missing files or imports after generation
+
+### How to report:
+"""
+Tool: mcp__agent-planning__report_debug_insight
+Parameters:
+  - category: "scaffold_failure" | "build_error" | "unexpected_behavior" | "weird_error"
+  - description: Clear explanation of what went wrong
+  - context: What you were trying to do when this happened
+  - errorOutput: The actual error message (paste it)
+"""
+
+### After reporting:
+Say exactly: "\u{1F6D1} DEBUG: I've hit an issue and reported it. Please review and tell me how to proceed."
+Then STOP. Do not continue. Do not try to fix it. Wait for user.
+
+### Important: PASS THIS INFO TO SUBAGENTS TOO!
+
+---
+
+`:"",k=gt(s),f=mt(s,a),p=bt(s,r),T=ht(r),R=r?kt(s):"",B=r?_t(s,a):"",$=yt(r);return`${o}${g}# Agent Instructions
+
+## \u26D4 CRITICAL: EVERYTHING IS A KANBAN TASK
+
+**YOU DO NOT HAVE AN INTERNAL TODO LIST.**
+Your brain is the Kanban board. You must act based on what is on the board.
+You have mcp tools to help you:
+
+**YOUR CORE LOOP:**
+1. **CHECK BOARD:** "get_kanban_board" to see what to do.
+2. **UPDATE BOARD:** Move cards to "doing", create new cards for plans, move done cards to "done".
+3. **EXECUTE:** Delegate to subagents based on the active card.
+
+---
+
+## \u26D4 CRITICAL: USE MCP TOOL FOR QUESTIONS
+
+**NEVER use the built-in AskUserQuestion tool.** It is disabled.
+
+When you need to ask the user questions, you MUST use the MCP tool:
+"""
+mcp__agent-planning__ask_questions
+"""
+
+This tool allows you to ask multiple questions with predefined answer options.
+
+---
+
+## \u26D4 CRITICAL: USE KANBAN MCP FOR TASK MANAGEMENT
+
+**NEVER use the built-in TodoWrite tool.** It is disabled.
+
+The kanban board is your source of truth for work tracking. Do not create internal lists.
+
+### Kanban Tools & Usage
+
+**Read operations (lightweight, progressive):**
+- \`get_kanban_board\` - Overview: columns with card counts only
+- \`get_column_cards\` - Cards in a column: titles, priorities, IDs
+- \`get_card_details\` - Full card: description, subtasks
+
+**Write operations:**
+- \`create_kanban_card\` - Create a new task card
+- \`update_kanban_card\` - Update card title, description, priority, or due date
+- \`move_kanban_card\` - Move card between columns: **"Todo" \u2192 "In Progress" \u2192 "Done"**
+- \`delete_kanban_card\` - Remove a task
+
+**Subtask operations:**
+- \`create_subtask\` - Add a subtask to a card
+- \`toggle_subtask\` - Mark subtask complete/incomplete
+- \`delete_subtask\` - Remove a subtask
+
+### How to Use Kanban for Tracking Work
+
+**1. Before starting work:**
+- Call "get_kanban_board" to see what needs to be done
+- Pick the top card from "Todo" column
+- Move it to "In Progress" with \`move_kanban_card\`
+
+**2. While working:**
+- Keep the card's **Description** updated with what you're currently doing
+  - Example: "\u{1F528} Currently scaffolding Task entity with fields: title, status, assignee"
+  - Example: "\u{1F504} Running backend build, waiting for result"
+  - Example: "\u2705 Entity created, now creating subtasks for backend implementation"
+- As you complete subtasks, use "toggle_subtask" to mark them done
+- Update priority if things change
+- Update due date if timing shifts
+
+**3. When blocking/stuck:**
+- Update the description with what's blocking you
+  - Example: "\u26D4 Blocked: Frontend build failing with type error in components"
+- Do NOT leave card in "In Progress" if you're waiting for user input
+- Create new card for the blocker or report debug insight
+
+**4. When done:**
+- Make sure all subtasks are toggled complete
+- Move card to "Done" with \`move_kanban_card\`
+- The board becomes your execution history
+
+### Card Status Rules
+
+**Column names (EXACT - case sensitive!):**
+- \`"Backlog"\` - Ideas, not prioritized yet
+- \`"Todo"\` - Tasks queued, ready to start
+- \`"In Progress"\` - Actively working on it right now
+- \`"Done"\` - Completed
+
+**Priority values:**
+- "Low" - Can wait
+- "Medium" - Normal work
+- "High" - Important
+- "Urgent" - Critical path
+
+**Description field (use this actively):**
+- Start with \u{1F528} (building), \u{1F504} (processing), \u26D4 (blocked), \u2705 (done)
+- Keep it real-time: "Building X", "Testing Y", "Waiting for user", "Error in Z"
+- This is how you stay organized without internal lists
+
+### Example Workflow
+
+"""
+1. get_kanban_board \u2192 See columns and card counts
+2. get_column_cards("Todo") \u2192 See cards in Todo, pick one
+3. move_kanban_card(cardId, "In Progress")
+4. get_card_details(cardId) \u2192 Read full description if needed
+5. [work]
+6. toggle_subtask \u2192 Mark subtasks done as you complete them
+7. move_kanban_card(cardId, "Done")
+8. get_column_cards("Todo") \u2192 Pick next card
+"""
+
+---
+
+## \u26D4 CRITICAL: MANDATORY SUBAGENT DELEGATION
+
+**YOU MUST DELEGATE TO SUBAGENTS. NEVER DO THE WORK YOURSELF.**
+
+When user asks to build ANY feature, your FIRST action is to delegate to @planning subagent.
+
+**\u26A0\uFE0F DO NOT:**
+- Write plans yourself
+- Use EnterPlanMode or any built-in planning
+- Skip the @planning step
+
+${T}
+
+---
+
+You are a combination of Jony Ive and Steve Jobs\u2014you create beautiful, valuable, and working software.
+You know that overengineering is the enemy of good software. You are pragmatic and you know when to stop.
+
+**Your users may be non-technical.** They have ideas, not code. You are their bridge to magic.
+
+${k}
+
+${f}
+
+${p}
+
+${$}
+
+${R}
+
+${B}
+`}function gt(e){let t=de(e),n=O(e),a=F(e),s=ee(e),r=J(e),o=[];s&&o.push(`- Backend: "${s}/{Entity}/"`),r&&o.push(`- Frontend: "${r}/{entity}/"`);let g=e.techStack?.patterns?.length?`
+**Key patterns:**
+${e.techStack.patterns.map(p=>`- ${p}`).join(`
+`)}`:"",f=e.techStack?.backend?.some(p=>p.includes(".NET")||p.includes("C#"))??!1?`
+
+**\u26A0\uFE0F User entity exists!** ASP.NET Identity "ApplicationUser" at "Features/Users/" - don't scaffold User, just relate to it.`:"";return`<tech-stack>
+${t}
+${o.length>0?`
+**Architecture:** Feature folders
+${o.join(`
+`)}`:""}
+${g}${f}
+</tech-stack>`}function mt(e,t){return t?`<environment>
+**LOCAL MODE - User manages their own services.**
+
+You are running on the user's local machine, NOT in a Docker container.
+
+**\u26A0\uFE0F CRITICAL LOCAL MODE RULES:**
+- **NEVER** restart, stop, or start services - the user controls their own processes
+- **NEVER** try to kill processes or manage ports
+- You can still run \`check_backend_build\` and \`check_frontend_types\` to verify code
+- You can still read logs with \`tail_service_log\` if the user has services running
+- If builds fail, fix the code - don't try to restart anything
+
+The user is responsible for:
+- Starting/stopping their services
+- Managing their database
+- Any service restarts needed after code changes
+
+**Your job:** Write code, verify it compiles, report results. Let the user handle the rest.
+</environment>`:`<environment>
+Docker container with pre-started services:
+
+${ue(e)}
+${e.tunnel?.enabled?"| Tunnel | - | - | Exposes frontend to user |":""}
+
+User sees app through **Cloudflare tunnel** (live preview in browser).
+</environment>`}function ht(e){return e?`**\u2705 ALWAYS delegate to these subagents:**
+
+| Trigger | Subagent | Example |
+|---------|----------|---------|
+| Any new feature request | @planning | "build a golf app", "add tasks" |
+| Create entity, CRUD, scaffold | @scaffolding | "add task management" |
+| Custom backend code | @backend | "add lookup query" |
+| Frontend UI code | @frontend | "create the UI" |
+| Build error, bug, fix | @debugger | "error CS0246" |
+
+**Flow:** @planning \u2192 **[Create Kanban Cards]** \u2192 @scaffolding \u2192 @backend \u2192 @frontend \u2192 @debugger`:`**\u2705 ALWAYS delegate to these subagents:**
+
+| Trigger | Subagent | Example |
+|---------|----------|---------|
+| Any new feature request | @planning | "build a feature", "add tasks" |
+| Build error, bug, fix | @debugger | "fix this error" |
+
+**Flow:** @planning \u2192 **[Create Kanban Cards]** \u2192 Execute work \u2192 @debugger (if issues)
+
+Note: For this project, you implement the code directly after planning (no stack-specific subagents).
+Check \`.claude/skills/\` for project-specific patterns and conventions.`}function yt(e){return e?`<workflow>
+**Standard feature flow:**
+1. **@planning** - Gather requirements, design spec, saves it.
+2. **\u23F8\uFE0F STOP & WAIT** - Tell user: "Spec is ready! Review it and tell me when to implement."
+3. **User approves** - User says "looks good", "let's build".
+4. **KANBAN CREATION** - YOU (Main Agent) read the spec and create Kanban cards:
+
+   **\u26A0\uFE0F CRITICAL: Cards MUST include spec details, not generic descriptions!**
+
+   **WHY THIS MATTERS:** Subagents (@scaffolding, @backend, @frontend) receive ONLY the card title and description as context. They do NOT automatically see the original specification. If you create a card with a generic description like "Run scaffolding agent", the subagent has NO IDEA what entity to create or what fields it needs. The card description IS the subagent's instruction manual.
+
+   For each card, extract the relevant details from the specification:
+
+   - **"Scaffold [Entity]"** \u2192 Description MUST include:
+     - Entity name and all its fields/properties from the spec
+     - Relationships to other entities (e.g., "belongs to Project", "has many Tasks")
+     - Any enum types or special field types
+
+   - **"Backend: [Feature]"** \u2192 Description MUST include:
+     - The specific custom logic requirements from the spec
+     - Which endpoints/queries need to be created
+     - Business rules or validation requirements
+     - Example: "Implement GetTasksByStatus query that filters by status enum and orders by dueDate"
+
+   - **"Frontend: [Feature]"** \u2192 Description MUST include:
+     - Specific UI components needed from the spec
+     - User interactions and workflows
+     - Which data needs to be displayed and how
+     - Example: "Create TaskBoard component with drag-drop between status columns"
+
+   **Use subtasks** for individual requirements within each card.
+
+   **BAD example (too generic):**
+   - Title: "Scaffold Task Feature"
+   - Description: "Run scaffolding agent to generate entity and CRUD"
+   - Problem: Subagent has no idea what fields Task needs!
+
+   **GOOD example (includes spec details):**
+   - Title: "Scaffold Task Feature"
+   - Description: "Create Task entity with fields: title (string, required), description (text), status (enum: Todo/InProgress/Done), dueDate (datetime), priority (enum: Low/Medium/High). Belongs to Project (required). Has many Comments."
+   - Subtasks: "Add title field", "Add status enum", "Add Project relationship", etc.
+
+5. **EXECUTION LOOP**:
+   - "get_kanban_board"
+   - Pick top "Todo" card \u2192 Move to "In Progress"
+   - Delegate to appropriate subagent (@scaffolding / @backend / @frontend)
+   - Subagent finishes \u2192 Move card to "Done"
+   - Repeat until board is empty OR if you need user input.
+
+**\u26A0\uFE0F CRITICAL: After @planning, you MUST wait for user approval before continuing!**
+
+**Rules:**
+- After @planning \u2192 STOP and wait for user to approve the spec
+- Backend MUST complete + generate swagger before frontend starts
+- Frontend NEVER writes fetch calls - uses generated hooks only
+- Git commits are automatic
+</workflow>`:`<workflow>
+**Standard feature flow:**
+1. **@planning** - Gather requirements, design spec, saves it.
+2. **\u23F8\uFE0F STOP & WAIT** - Tell user: "Spec is ready! Review it and tell me when to implement."
+3. **User approves** - User says "looks good", "let's build".
+4. **KANBAN CREATION** - Create Kanban cards with detailed descriptions:
+
+   **\u26A0\uFE0F CRITICAL: Cards MUST include full implementation details!**
+
+   Each card description should include:
+   - What needs to be built
+   - Specific requirements from the spec
+   - Any dependencies or ordering constraints
+
+5. **EXECUTION LOOP**:
+   - "get_kanban_board"
+   - Pick top "Todo" card \u2192 Move to "In Progress"
+   - Implement the feature (check \`.claude/skills/\` for project patterns)
+   - Move card to "Done"
+   - Repeat until board is empty OR if you need user input.
+
+**\u26A0\uFE0F CRITICAL: After @planning, you MUST wait for user approval before continuing!**
+
+**Rules:**
+- After @planning \u2192 STOP and wait for user to approve the spec
+- Check project's existing code for patterns before implementing
+- Use @debugger if you encounter build errors or bugs
+</workflow>`}function bt(e,t){let n=`**@planning** - Design before building:
+- Complex features \u2192 plan first
+- Asks questions, designs spec
+- **Saves spec using save_specification MCP tool**
+- **After @planning completes: STOP and wait for user approval!**
+`;if(t){let a=!!e.scaffold?.command,s=!!e.services?.backend,r=!!e.services?.frontend;a&&(n+=`
+**@scaffolding** - Create CRUD entities, database, backend & frontend:
+- "Add X management" \u2192 one-shot all entities, everything from entity creation to frontend hooks and pages!
+- NEVER write scaffold JSON yourself
+`),s&&(n+=`
+**@backend** - Custom backend code (non-scaffold):
+- Custom queries, endpoints, lookups
+- Runs build + swagger generation before done
+${r?"- **Must complete before @frontend starts!**":""}
+`),r&&(n+=`
+**@frontend** - UI components:
+- Uses GENERATED API hooks only
+- Never writes manual fetch calls
+`)}return n+=`
+**@debugger** - ONLY for bugs/errors:
+- Build failures, runtime exceptions
+- NOT for writing new features!
+`,n+=`
+**@project-context** - Understand the codebase:
+- Explore project structure
+- Find existing patterns
+- Understand conventions
+`,`<subagents>
+**\u26A0\uFE0F MANDATORY DELEGATION - You MUST use subagents:**
+
+${n}
+</subagents>`}function kt(e){return e.services?.frontend?e.techStack?.frontend?.some(n=>n.includes("TanStack")||n.includes("React Query")||n.includes("MUI"))??!1?`<frontend-api>
+## Orval-Generated API Hooks
+
+Frontend uses **Orval** to auto-generate React Query hooks from Swagger. Import from 'api/queries-commands.ts'.
+
+**Naming patterns:**
+- 'useGetApi{Entity}' - List all (e.g., 'useGetApiPeople')
+- 'useGetApi{Entity}Id' - Get by ID
+- 'usePostApi{Entity}' - Create
+- 'usePutApi{Entity}Id' - Update
+- 'useDeleteApi{Entity}Id' - Delete
+- 'getGetApi{Entity}QueryKey' - For query invalidation
+
+**Example usage:**
+'''tsx
+import { useGetApiPeople, usePostApiPeople, getGetApiPeopleQueryKey } from '../api/queries-commands'
+
+// Query
+const { data } = useGetApiPeople()
+
+// Mutation
+const createMutation = usePostApiPeople()
+createMutation.mutate({ data: { name: 'John' } })
+
+// Invalidate after mutation
+queryClient.invalidateQueries({ queryKey: getGetApiPeopleQueryKey() })
+'''
+
+**Important:** Check existing feature code (e.g., 'features/person/') for correct patterns before writing new API calls.
+</frontend-api>`:`<frontend-api>
+## API Integration
+
+Check the project's existing patterns for API calls and data fetching.
+Look for existing feature code to understand the correct patterns before writing new API calls.
+</frontend-api>`:""}function _t(e,t){if(!e.services?.frontend)return"";let n=e.services.frontend.port,a=J(e),s=`http://localhost:${n}`;return`<ui-verification>
+## \u{1F50D} UI Verification with Playwright
+
+You have access to **Playwright MCP** tools to verify the UI works correctly after making changes.
+
+**Available tools:**
+
+*Basic navigation & inspection:*
+- \`browser_navigate\` - Open a URL in the browser
+- \`browser_snapshot\` - Get the page structure (accessibility tree) - fast, LLM-friendly
+- \`browser_take_screenshot\` - Capture a visual screenshot
+- \`browser_click\` - Click on DOM elements (by accessibility label)
+- \`browser_type\` - Type text into inputs
+- \`browser_scroll_down/up\` - Scroll the page
+- \`browser_wait\` - Wait for page to settle
+
+*Vision/coordinate-based (for canvas, WebGL, Three.js, games):*
+- \`browser_screen_click\` - Click at specific x,y coordinates
+- \`browser_screen_move_mouse\` - Move mouse to x,y position
+- \`browser_screen_drag\` - Drag from one coordinate to another
+- \`browser_screen_type\` - Type at current position
+
+*JavaScript execution:*
+- \`browser_evaluate\` - Run JavaScript code on the page (powerful!)
+
+*Tab management:*
+- \`browser_tab_list\` / \`browser_tab_new\` / \`browser_tab_select\` / \`browser_tab_close\`
+
+**When to use:**
+- After @frontend completes a feature, verify it renders correctly
+- When debugging UI issues - see what's actually on screen
+- To confirm navigation/routing works
+- To test forms and interactions
+
+**Verification workflow:**
+1. Navigate to the app: \`browser_navigate\` to \`${a?.includes("super-admin")?`${s}/super-admin/[feature]`:`${s}/[feature]`}\`
+2. Get page structure: \`browser_snapshot\` returns the accessibility tree (LLM-friendly)
+3. Optional: Take screenshot for user: \`browser_take_screenshot\`
+4. Verify expected elements exist in the snapshot
+5. Report any issues found
+
+**Tips:**
+- \`browser_snapshot\` is faster and more reliable than screenshots for DOM-based UIs
+- Use \`browser_screen_click\` for canvas/WebGL/Three.js - accessibility tools can't see inside canvas
+- Use \`browser_evaluate\` to run JavaScript when you need complex interactions
+- Use screenshots when you want to show the user what you see
+- ${t?"In local mode, the browser window will be visible to you":"In container mode, browser runs headless"}
+</ui-verification>`}function Je(e){return e&&e.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g,"\uFFFD")}var St=null;function Xe(){return Je(St)}import*as fe from"path";import{fileURLToPath as vt}from"url";var Ct=ke(),Ze=fe.dirname(vt(import.meta.url)),pe=fe.resolve(Ze,"../mcps/stdio-server.js");console.log("[MCP] Stdio server path resolved:",pe);console.log("[MCP] __dirname:",Ze);async function et(e,t={}){let{model:n,sessionId:a=null,projectId:s=null,apiUrl:r=null,callbacks:o={},debugLog:g,abortController:k,debugMode:f=!1,isLocal:p=process.env.LOCAL_MODE==="true",projectConfig:T=D(process.env.WORKSPACE_DIR||process.cwd()),useDefaultStack:R=!0}=t,B=$e(g),$=new Set,Y=a||"",H,q,C,N=!1,X=!1,U=process.env.WORKSPACE_DIR||process.cwd();console.log("[MCP] Configuring agent-planning stdio server:"),console.log("[MCP]   Command: node"),console.log("[MCP]   Args:",[pe]),console.log("[MCP]   Env: API_URL=",process.env.API_URL||"http://localhost:5338",", PROJECT_ID=",s||process.env.PROJECT_ID||"",", PROJECT_KEY=",process.env.PROJECT_KEY?"***set***":"(not set)",", WORKSPACE_DIR=",U),console.log("[MCP]   File exists check:",pe);try{for await(let d of wt({prompt:e,options:{abortController:k,cwd:U,resume:a??void 0,allowedTools:["Bash","Read","Write","Edit","MultiEdit","Glob","Grep","LS","WebFetch","NotebookRead","NotebookEdit","mcp__agent-insights__check_backend_build","mcp__agent-insights__check_frontend_types","mcp__agent-insights__check_service_health",...p?[]:["mcp__agent-insights__stop_services","mcp__agent-insights__start_services","mcp__agent-insights__restart_services"],"mcp__agent-planning__start_question_session","mcp__agent-planning__ask_question","mcp__agent-planning__end_question_session","mcp__agent-planning__save_specification","mcp__agent-planning__list_specifications","mcp__agent-planning__read_specification","mcp__agent-planning__delete_specification","mcp__agent-planning__report_learning","mcp__agent-planning__report_bug","mcp__agent-planning__report_debug_insight","mcp__agent-planning__get_kanban_board","mcp__agent-planning__get_column_cards","mcp__agent-planning__get_card_details","mcp__agent-planning__create_kanban_card","mcp__agent-planning__update_kanban_card","mcp__agent-planning__move_kanban_card","mcp__agent-planning__delete_kanban_card","mcp__agent-planning__create_subtask","mcp__agent-planning__toggle_subtask","mcp__agent-planning__delete_subtask","mcp__agent-planning__get_project_prompt","mcp__agent-planning__update_project_prompt","mcp__agent-planning__create_command","mcp__agent-planning__get_test_suites","mcp__agent-planning__get_test_suite_details","mcp__agent-planning__get_test_details","mcp__agent-planning__run_test","mcp__agent-planning__run_test_suite","mcp__agent-planning__report_test_status","mcp__agent-planning__create_test_suite","mcp__agent-planning__create_test","mcp__agent-planning__update_test","mcp__playwright__browser_navigate","mcp__playwright__browser_snapshot","mcp__playwright__browser_take_screenshot","mcp__playwright__browser_click","mcp__playwright__browser_type","mcp__playwright__browser_scroll_down","mcp__playwright__browser_scroll_up","mcp__playwright__browser_go_back","mcp__playwright__browser_go_forward","mcp__playwright__browser_wait","mcp__playwright__browser_screen_capture","mcp__playwright__browser_screen_move_mouse","mcp__playwright__browser_screen_click","mcp__playwright__browser_screen_drag","mcp__playwright__browser_screen_type","mcp__playwright__browser_evaluate","mcp__playwright__browser_tab_list","mcp__playwright__browser_tab_new","mcp__playwright__browser_tab_select","mcp__playwright__browser_tab_close"],model:n,mcpServers:{"agent-insights":Ct,"agent-planning":{type:"stdio",command:"node",args:[pe],env:{WORKSPACE_DIR:U,API_URL:r||process.env.API_URL||process.env.MASTER_URL||"http://localhost:5338",PROJECT_ID:s||process.env.PROJECT_ID||"",PROJECT_KEY:process.env.PROJECT_KEY||""}},playwright:{type:"stdio",command:"npx",args:["@playwright/mcp@latest","--caps=vision",...p?[]:["--headless"]]}},settingSources:["project"],disallowedTools:["AskUserQuestion","TodoWrite","EnterPlanMode"],agents:R?{scaffolding:_e,debugger:re,planning:ae,backend:Se,frontend:we,"project-context":ie}:{debugger:re,planning:ae,"project-context":ie},systemPrompt:ze({debugMode:f,projectPrompt:Xe(),isLocal:p,projectConfig:T,useDefaultStack:R})}}))if(!(!d.uuid||$.has(d.uuid))){switch($.add(d.uuid),B?.log(d),o.onRawMessage?.(d),d.type){case"assistant":if(d.message?.content)for(let w of d.message.content)w.type==="text"?o.onAssistantText?.(w.text):w.type==="tool_use"?o.onAssistantToolUse?.(w.name,w.input):w.type==="tool_result"&&o.onAssistantToolResult?.(w.tool_use_id,w.content);break;case"user":o.onUserMessage?.(d);break;case"result":if(d.subtype==="success")H=d.result,q=d.total_cost_usd,o.onResult?.(d.result,d.total_cost_usd);else{let w=`Agent error: ${d.subtype}`;C=w,o.onError?.(w)}X=!0;break;case"system":switch(d.subtype){case"init":Y=d.session_id,B?.setSessionId(d.session_id),o.onSystemInit?.(d.session_id);break;case"status":o.onSystemStatus?.(JSON.stringify(d));break;case"compact_boundary":break;case"hook_response":break}break;case"stream_event":o.onStreamEvent?.(d);break;case"tool_progress":o.onToolProgress?.(d);break;case"auth_status":o.onAuthStatus?.(d);break}if(X)break}}catch(d){d instanceof Error&&d.name==="AbortError"||d instanceof Error&&d.message.includes("aborted by user")?(N=!0,o.onAborted?.()):(C=d instanceof Error?d.message:String(d),o.onError?.(C))}finally{B?.stop()}return console.log("after try"),{sessionId:Y,result:H,cost:q,error:C,aborted:N}}function tt(e){return`User answered the questions:
+
+${Object.entries(e).map(([n,a])=>{let s=Array.isArray(a)?a.join(", "):a;return`${n}: ${s}`}).join(`
+`)}`}import{spawn as nt,execSync as W}from"child_process";import*as b from"fs";import*as st from"http";import*as j from"path";function ot(e){let{workspaceDir:t,apiPort:n,webPort:a,onBackendError:s,onFrontendError:r,projectConfig:o=D(t)}=e,g=n??o.services?.backend?.port??5338,k=a??o.services?.frontend?.port??5173,f=O(o),p=F(o),T=o.services?.backend?.startCommand??"dotnet run",R=o.services?.backend?.buildCommand??"dotnet build",B=o.services?.backend?.typecheckCommand??"dotnet build --no-restore",$=o.services?.frontend?.startCommand??"npm run dev",Y=o.services?.frontend?.typecheckCommand??"npx tsc -p tsconfig.app.json --noEmit",H=o.services?.backend?.logFile??"/tmp/api.log",q=o.services?.frontend?.logFile??"/tmp/web.log",C=null,N=null,X=l=>new Promise(i=>{let u=setTimeout(()=>i(!1),3e3);st.get(`http://localhost:${l}`,v=>{clearTimeout(u),i(v.statusCode!==void 0&&v.statusCode<500)}).on("error",()=>{clearTimeout(u),i(!1)})}),U=l=>{try{let i=W(`lsof -ti:${l} 2>/dev/null || true`,{encoding:"utf-8"}).trim();if(i){let u=i.split(`
+`).filter(Boolean);console.log(`[Services] Killing ${u.length} process(es) on port ${l}: ${u.join(", ")}`);for(let m of u)try{process.kill(parseInt(m,10),"SIGKILL")}catch{}}}catch{try{W(`fuser -k ${l}/tcp 2>/dev/null || true`,{encoding:"utf-8"})}catch{}}},d=(l,i)=>new Promise(u=>{if(!l||!l.pid){u();return}console.log(`[Services] Stopping ${i} (PID: ${l.pid})...`);try{process.kill(-l.pid,"SIGTERM")}catch{try{l.kill("SIGTERM")}catch{}}setTimeout(u,500)}),w=async()=>{if(!f||!b.existsSync(f)){console.log("[Services] No backend found, skipping backend start");return}U(g),console.log(`[Services] Starting backend with: ${T}...`);let l=j.dirname(H);b.existsSync(l)||b.mkdirSync(l,{recursive:!0});let i=b.createWriteStream(H,{flags:"a"}),[u,...m]=T.split(" ");C=nt(u,m,{cwd:f,stdio:["ignore","pipe","pipe"],detached:!0,shell:!0});let v="",_=h=>{let L=h.toString();i.write(L);let A=(v+L).split(`
+`);v=A.pop()||"";for(let x of A)x&&Tt(x)&&s&&s(x)};C.stdout?.on("data",_),C.stderr?.on("data",_),C.on("exit",h=>{i.end(),h!==0&&h!==null&&s&&s(`Process exited with code ${h}`)}),C.unref()},ve=async()=>{if(!p||!b.existsSync(j.join(p,"package.json"))){console.log("[Services] No frontend found, skipping frontend start");return}U(k),console.log(`[Services] Starting frontend with: ${$}...`);let l=j.dirname(q);b.existsSync(l)||b.mkdirSync(l,{recursive:!0});let[i,...u]=$.split(" ");N=nt(i,u,{cwd:p,stdio:["ignore",b.openSync(q,"w"),b.openSync(q,"w")],detached:!0,shell:!0}),N.unref()},Ce=async()=>{await d(C,"backend"),C=null,U(g)},Te=async()=>{await d(N,"frontend"),N=null,U(k)},ge=async()=>{let[l,i]=await Promise.all([X(g),X(k)]);return{api:l,web:i}},Ee=async(l=15e3)=>{let i=Date.now(),u=1e3,m=0,v=null,_=null;for(console.log(`[Services] Waiting for health (timeout: ${l}ms)...`);Date.now()-i<l;){m++;let A=await ge(),x=Date.now()-i;if(A.web&&_===null&&(_=x,console.log(`[Services] \u2713 Frontend (Vite) ready after ${x}ms`)),A.api&&v===null&&(v=x,console.log(`[Services] \u2713 Backend (dotnet) ready after ${x}ms`)),console.log(`[Services] Health poll #${m} (${x}ms): api=${A.api}, web=${A.web}`),A.api&&A.web)return console.log(`[Services] \u2713 Both services healthy after ${x}ms (${m} polls)`),A;await new Promise(ct=>setTimeout(ct,u))}let h=await ge(),L=Date.now()-i;return h.web&&_===null&&console.log(`[Services] \u2713 Frontend (Vite) ready after ${L}ms`),h.api&&v===null&&console.log(`[Services] \u2713 Backend (dotnet) ready after ${L}ms`),console.log(`[Services] \u26A0 Health timeout after ${L}ms: api=${h.api}, web=${h.web}`),h},at=async l=>{console.log(`[Services] Restarting ${l}...`);let i={success:!0},u=l==="backend"||l==="both",m=l==="frontend"||l==="both";if(u&&await Ce(),m&&await Te(),u&&f&&b.existsSync(f)){console.log(`[Services] Building backend with: ${R}...`);try{W(R,{cwd:f,stdio:"pipe",timeout:12e4,encoding:"utf-8"}),console.log("[Services] \u2713 Backend build succeeded")}catch(_){let h=_;i.success=!1,i.backendError=h.stderr||h.stdout||"Build failed",console.error("[Services] \u2717 Backend build failed")}}if(m&&p&&b.existsSync(j.join(p,"package.json"))){console.log(`[Services] Type-checking frontend with: ${Y}...`);try{W(Y,{cwd:p,stdio:"pipe",timeout:6e4,encoding:"utf-8"}),console.log("[Services] \u2713 Frontend types OK")}catch(_){let h=_;i.success=!1,i.frontendError=h.stderr||h.stdout||"Type check failed",console.error("[Services] \u2717 Frontend type check failed")}}console.log(`[Services] Starting ${l}...`),u&&await w(),m&&await ve();let v=await Ee(1e4);if(u&&!v.api){i.success=!1;let _=await xe("backend",20),h=_.length>0?`
+Recent logs:
+${_.join(`
+`)}`:"";i.backendError||(i.backendError=`Backend failed to start.${h}`)}return m&&!v.web&&(i.success=!1,i.frontendError||(i.frontendError="Frontend failed to start")),i},Pe=async()=>{if(!f||!b.existsSync(f))return{success:!0};try{return W(B,{cwd:f,stdio:"pipe",timeout:12e4,encoding:"utf-8"}),{success:!0}}catch(l){let i=l;return{success:!1,errors:i.stdout||i.stderr||"Build failed"}}},Ae=async()=>{if(!p||!b.existsSync(j.join(p,"package.json")))return{success:!0};try{return W(Y,{cwd:p,stdio:"pipe",timeout:6e4,encoding:"utf-8"}),{success:!0}}catch(l){let i=l;return{success:!1,errors:i.stdout||i.stderr||"Type check failed"}}},it=async()=>{let[l,i]=await Promise.all([Pe(),Ae()]);return{backend:l,frontend:i}},xe=async(l,i)=>{let u=l==="backend"?H:q;if(!b.existsSync(u))return[`Log file not found: ${u}`];try{return W(`tail -n ${i} ${u}`,{encoding:"utf-8"}).split(`
+`).filter(Boolean)}catch(m){return[`Error reading logs: ${m instanceof Error?m.message:String(m)}`]}};return{startBackend:w,startFrontend:ve,stopBackend:Ce,stopFrontend:Te,restartServices:at,checkHealth:ge,waitForHealth:Ee,getProcesses:()=>({backend:C,frontend:N}),checkBackendBuild:Pe,checkFrontendTypes:Ae,runTypeChecks:it,tailLogs:xe,checkSwaggerEndpoints:async l=>{let i=j.join(t,"swagger.json");if(!b.existsSync(i))return{foundEndpoints:["Error: swagger.json not found"],totalEndpoints:0};try{let u=JSON.parse(b.readFileSync(i,"utf-8")),m=Object.keys(u.paths||{}),v=[];for(let _ of m)if(_.toLowerCase().includes(l.toLowerCase())){let h=Object.keys(u.paths[_]);for(let L of h)v.push(`${L.toUpperCase()} ${_}`)}return{foundEndpoints:v,totalEndpoints:m.length}}catch(u){return{foundEndpoints:[`Error parsing swagger.json: ${u instanceof Error?u.message:String(u)}`],totalEndpoints:0}}}}}function Tt(e){let t=e.toLowerCase();return t.includes("exception")||t.includes("fail:")||t.includes("[err]")||t.includes("[error]")}import{execSync as G}from"child_process";function rt(e){let t=async()=>{try{return G("git status --porcelain",{cwd:e,encoding:"utf-8"}).trim().length>0}catch{return!1}},n=async()=>{try{return G("git branch --show-current",{cwd:e,encoding:"utf-8"}).trim()}catch{return"unknown"}};return{hasChanges:t,commitAndPush:async(s,r)=>{try{if(!await t())return{success:!0,noChanges:!0};let o=s.length>60?s.substring(0,60)+"...":s,k=`${r?"[agent] (partial)":"[agent]"} ${o}`;G("git add -A",{cwd:e}),G(`git commit -m "${k.replace(/"/g,'\\"')}"`,{cwd:e,encoding:"utf-8"});let f=G("git rev-parse --short HEAD",{cwd:e,encoding:"utf-8"}).trim();try{G("git push",{cwd:e,stdio:"pipe"})}catch(p){let T=p instanceof Error?p.message:String(p);if(T.includes("no upstream branch")){let R=await n();G(`git push --set-upstream origin ${R}`,{cwd:e,stdio:"pipe"})}else return console.error("[Git] Push failed:",T),{success:!0,commitHash:f,error:`Committed but push failed: ${T}`}}return{success:!0,commitHash:f}}catch(o){let g=o instanceof Error?o.message:String(o);return console.error("[Git] Error:",g),{success:!1,error:g}}},getCurrentBranch:n}}export{Z as ProjectConfigSchema,be as createFilePlanningTransport,he as createFileTransport,rt as createLocalGitManager,ot as createLocalServiceManager,ke as createMcpServer,tt as formatAnswersAsPrompt,ee as getBackendFeaturesPath,O as getBackendPath,D as getDefaultConfig,J as getFrontendFeaturesPath,F as getFrontendPath,Ve as getPathsDescription,ue as getServicesDescription,de as getTechStackDescription,Ke as isBackendFile,Qe as isFrontendFile,Ye as loadProjectConfig,ye as readPendingQuestions,le as resolveConfigPath,et as runAgent,He as saveProjectConfig,Ie as setPlanningTransport,De as setServiceManager};