@yemi33/squad 0.1.20 → 0.1.21

package/dashboard.js

@@ -151,9 +151,32 @@ function getAgents() {
 }
 
 function getPrdInfo() {
-  // Squad-level PRD — single file at ~/.squad/prd.json
-  const prdPath = path.join(SQUAD_DIR, 'prd.json');
-  if (!fs.existsSync(prdPath)) return { progress: null, status: null };
+  // All PRD items come from plans/*.json (both manual /prd entries and agent-generated plans)
+  const plansDir = path.join(SQUAD_DIR, 'plans');
+  let allPrdItems = [];
+  let latestStat = null;
+
+  try {
+    const planFiles = fs.readdirSync(plansDir).filter(f => f.endsWith('.json'));
+    for (const pf of planFiles) {
+      try {
+        const plan = JSON.parse(fs.readFileSync(path.join(plansDir, pf), 'utf8'));
+        if (!plan.missing_features) continue;
+        const stat = fs.statSync(path.join(plansDir, pf));
+        if (!latestStat || stat.mtimeMs > latestStat.mtimeMs) latestStat = stat;
+        (plan.missing_features || []).forEach(f => allPrdItems.push({
+          ...f, _source: pf, _planStatus: plan.status || 'active',
+          _planSummary: plan.plan_summary || pf,
+        }));
+      } catch {}
+    }
+  } catch {}
+
+  // Legacy prd.json removed — all PRD items now in plans/*.json
+
+  if (allPrdItems.length === 0) return { progress: null, status: null };
+
+  const items = allPrdItems;
 
   try {
     const stat = fs.statSync(prdPath);
@@ -197,12 +220,12 @@ function getPrdInfo() {
 
     const status = {
       exists: true,
-      age: timeSince(stat.mtimeMs),
-      existing: data.existing_features?.length || 0,
-      missing: data.missing_features?.length || 0,
-      questions: data.open_questions?.length || 0,
-      summary: data.summary || '',
-      missingList: (data.missing_features || []).map(f => ({ id: f.id, name: f.name || f.title, priority: f.priority, complexity: f.estimated_complexity || f.size })),
+      age: latestStat ? timeSince(latestStat.mtimeMs) : 'unknown',
+      existing: 0,
+      missing: items.filter(i => i.status === 'missing').length,
+      questions: 0,
+      summary: '',
+      missingList: items.filter(i => i.status === 'missing').map(f => ({ id: f.id, name: f.name || f.title, priority: f.priority, complexity: f.estimated_complexity || f.size })),
     };
 
     return { progress, status };
@@ -262,29 +285,8 @@ function getPullRequests() {
 }
 
 function getArchivedPrds() {
-  const firstProject = PROJECTS[0];
-  const root = path.resolve(firstProject.localPath || path.resolve(SQUAD_DIR, '..'));
-  const prdSrc = firstProject.workSources?.prd || CONFIG.workSources?.prd || {};
-  const prdDir = path.dirname(path.resolve(root, prdSrc.path || 'docs/prd-gaps.json'));
-  const archiveDir = path.join(prdDir, 'archive');
-  return safeReadDir(archiveDir)
-    .filter(f => f.startsWith('prd-gaps') && f.endsWith('.json'))
-    .map(f => {
-      try {
-        const data = JSON.parse(fs.readFileSync(path.join(archiveDir, f), 'utf8'));
-        const items = data.missing_features || [];
-        return {
-          file: f,
-          version: data.version || f.replace('prd-gaps-', '').replace('.json', ''),
-          summary: data.summary || '',
-          total: items.length,
-          existing_features: data.existing_features || [],
-          missing_features: items,
-          open_questions: data.open_questions || [],
-        };
-      } catch { return null; }
-    })
-    .filter(Boolean);
+  // All PRD items now in plans/*.json — no separate archive needed
+  return [];
 }
 
 function getEngineState() {
@@ -788,24 +790,35 @@ const server = http.createServer(async (req, res) => {
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
 
-  // POST /api/prd-items — squad-level PRD
+  // POST /api/prd-items — create a PRD item as a plan file in plans/ (auto-approved)
   if (req.method === 'POST' && req.url === '/api/prd-items') {
     try {
       const body = await readBody(req);
       if (!body.name || !body.name.trim()) return jsonReply(res, 400, { error: 'name is required' });
-      const prdPath = path.join(SQUAD_DIR, 'prd.json');
-      let data = { missing_features: [], existing_features: [], open_questions: [] };
-      const existing = safeRead(prdPath);
-      if (existing) { try { data = JSON.parse(existing); } catch {} }
-      if (!data.missing_features) data.missing_features = [];
-      data.missing_features.push({
-        id: body.id, name: body.name, description: body.description || '',
-        priority: body.priority || 'medium', estimated_complexity: body.estimated_complexity || 'medium',
-        rationale: body.rationale || '', status: 'missing', affected_areas: [],
-        projects: body.projects || [],
-      });
-      safeWrite(prdPath, data);
-      return jsonReply(res, 200, { ok: true, id: body.id });
+
+      const plansDir = path.join(SQUAD_DIR, 'plans');
+      if (!fs.existsSync(plansDir)) fs.mkdirSync(plansDir, { recursive: true });
+
+      const id = body.id || ('M' + String(Date.now()).slice(-4));
+      const planFile = 'manual-' + Date.now() + '.json';
+      const plan = {
+        version: 'manual-' + new Date().toISOString().slice(0, 10),
+        project: body.project || (PROJECTS[0]?.name || 'Unknown'),
+        generated_by: 'dashboard',
+        generated_at: new Date().toISOString().slice(0, 10),
+        plan_summary: body.name,
+        status: 'awaiting-approval',
+        requires_approval: true,
+        branch_strategy: 'parallel',
+        missing_features: [{
+          id, name: body.name, description: body.description || '',
+          priority: body.priority || 'medium', estimated_complexity: body.estimated_complexity || 'medium',
+          status: 'missing', depends_on: [], acceptance_criteria: [],
+        }],
+        open_questions: [],
+      };
+      safeWrite(path.join(plansDir, planFile), plan);
+      return jsonReply(res, 200, { ok: true, id, file: planFile });
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
 
@@ -909,37 +922,63 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
-  // GET /api/plans — list all plan files with status
+  // GET /api/plans — list all plan files (.json PRDs + .md raw plans)
   if (req.method === 'GET' && req.url === '/api/plans') {
     const plansDir = path.join(SQUAD_DIR, 'plans');
-    const files = safeReadDir(plansDir).filter(f => f.endsWith('.json'));
-    const plans = files.map(f => {
-      const plan = JSON.parse(safeRead(path.join(plansDir, f)) || '{}');
-      return {
-        file: f,
-        project: plan.project || '',
-        summary: plan.plan_summary || '',
-        status: plan.status || 'active',
-        branchStrategy: plan.branch_strategy || 'parallel',
-        featureBranch: plan.feature_branch || '',
-        itemCount: (plan.missing_features || []).length,
-        generatedBy: plan.generated_by || '',
-        generatedAt: plan.generated_at || '',
-        requiresApproval: plan.requires_approval || false,
-        revisionFeedback: plan.revision_feedback || null,
-      };
-    }).sort((a, b) => b.generatedAt.localeCompare(a.generatedAt));
+    const allFiles = safeReadDir(plansDir).filter(f => f.endsWith('.json') || f.endsWith('.md'));
+    const plans = allFiles.map(f => {
+      const content = safeRead(path.join(plansDir, f)) || '';
+      const isJson = f.endsWith('.json');
+      if (isJson) {
+        try {
+          const plan = JSON.parse(content);
+          return {
+            file: f, format: 'prd',
+            project: plan.project || '',
+            summary: plan.plan_summary || '',
+            status: plan.status || 'active',
+            branchStrategy: plan.branch_strategy || 'parallel',
+            featureBranch: plan.feature_branch || '',
+            itemCount: (plan.missing_features || []).length,
+            generatedBy: plan.generated_by || '',
+            generatedAt: plan.generated_at || '',
+            requiresApproval: plan.requires_approval || false,
+            revisionFeedback: plan.revision_feedback || null,
+          };
+        } catch { return null; }
+      } else {
+        // .md raw plan — extract metadata from markdown
+        const titleMatch = content.match(/^#\s+(?:Plan:\s*)?(.+)/m);
+        const projectMatch = content.match(/\*\*Project:\*\*\s*(.+)/m);
+        const authorMatch = content.match(/\*\*Author:\*\*\s*(.+)/m);
+        const dateMatch = content.match(/\*\*Date:\*\*\s*(.+)/m);
+        return {
+          file: f, format: 'draft',
+          project: projectMatch ? projectMatch[1].trim() : '',
+          summary: titleMatch ? titleMatch[1].trim() : f.replace('.md', ''),
+          status: 'draft',
+          branchStrategy: '',
+          featureBranch: '',
+          itemCount: (content.match(/^\d+\.\s+\*\*/gm) || []).length,
+          generatedBy: authorMatch ? authorMatch[1].trim() : '',
+          generatedAt: dateMatch ? dateMatch[1].trim() : '',
+          requiresApproval: false,
+          revisionFeedback: null,
+        };
+      }
+    }).filter(Boolean).sort((a, b) => (b.generatedAt || '').localeCompare(a.generatedAt || ''));
     return jsonReply(res, 200, plans);
   }
 
-  // GET /api/plans/:file — read full plan JSON
+  // GET /api/plans/:file — read full plan (JSON or markdown)
   const planFileMatch = req.url.match(/^\/api\/plans\/([^?]+)$/);
   if (planFileMatch && req.method === 'GET') {
     const file = decodeURIComponent(planFileMatch[1]);
     if (file.includes('..') || file.includes('/') || file.includes('\\')) return jsonReply(res, 400, { error: 'invalid' });
     const content = safeRead(path.join(SQUAD_DIR, 'plans', file));
     if (!content) return jsonReply(res, 404, { error: 'not found' });
-    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    const contentType = file.endsWith('.json') ? 'application/json' : 'text/plain';
+    res.setHeader('Content-Type', contentType + '; charset=utf-8');
     res.setHeader('Access-Control-Allow-Origin', '*');
     res.end(content);
     return;
@@ -1107,6 +1146,250 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     } catch (e) { return jsonReply(res, 400, { error: e.message }); }
   }
 
+  // POST /api/doc-chat — unified Q&A + steering: Haiku decides whether to answer or edit
+  if (req.method === 'POST' && req.url === '/api/doc-chat') {
+    try {
+      const body = await readBody(req);
+      if (!body.message) return jsonReply(res, 400, { error: 'message required' });
+      if (!body.document) return jsonReply(res, 400, { error: 'document required' });
+
+      const canEdit = !!body.filePath;
+      const isJson = body.filePath?.endsWith('.json');
+
+      // Read current content from disk if editable (authoritative source)
+      let currentContent = body.document;
+      let fullPath = null;
+      if (canEdit) {
+        fullPath = path.resolve(SQUAD_DIR, body.filePath);
+        if (!fullPath.startsWith(path.resolve(SQUAD_DIR))) return jsonReply(res, 400, { error: 'path must be under squad directory' });
+        const diskContent = safeRead(fullPath);
+        if (diskContent !== null) currentContent = diskContent;
+      }
+
+      const prompt = `You are a document assistant for a software engineering squad. You can answer questions AND edit documents.
+
+## Document
+${body.title ? '**Title:** ' + body.title + '\n' : ''}File: ${body.filePath || '(read-only)'}
+${isJson ? 'Format: JSON' : 'Format: Markdown'}
+
+\`\`\`
+${currentContent.slice(0, 20000)}
+\`\`\`
+
+${body.selection ? '## Highlighted Selection\n> ' + body.selection.slice(0, 1500) + '\n' : ''}
+${(body.history && body.history.length > 0) ? '## Conversation So Far\n\n' + body.history.map(h => (h.role === 'user' ? 'User: ' : 'Assistant: ') + h.text).join('\n\n') + '\n' : ''}
+## User Message
+
+${body.message}
+
+## Instructions
+
+Determine what the user wants:
+
+**If they're asking a question** (e.g., "what does this mean", "why is this", "explain"):
+- Answer concisely with source citations
+- Do NOT include the ---DOCUMENT--- delimiter
+
+**If they want to edit the document** (e.g., "change", "remove", "add", "update", "rename", "fix", "reword"):
+- Briefly explain what you changed (1-2 sentences)
+- Then on a new line write exactly: ---DOCUMENT---
+- Then the COMPLETE updated document (full file, not a diff)
+${isJson ? '- The document MUST be valid JSON. No markdown code fences.' : ''}
+${!canEdit ? '\nNote: This document is READ-ONLY. Answer questions only — do not output ---DOCUMENT---.' : ''}
+
+Be concise. No preamble.`;
+
+      const sysPrompt = 'You are a precise document assistant. Determine intent (question vs edit) from the user message. Follow the output format exactly.';
+
+      const id = Date.now();
+      const promptPath = path.join(SQUAD_DIR, 'engine', 'chat-prompt-' + id + '.md');
+      const sysPath = path.join(SQUAD_DIR, 'engine', 'chat-sys-' + id + '.md');
+      safeWrite(promptPath, prompt);
+      safeWrite(sysPath, sysPrompt);
+
+      const spawnScript = path.join(SQUAD_DIR, 'engine', 'spawn-agent.js');
+      const childEnv = { ...process.env };
+      for (const key of Object.keys(childEnv)) {
+        if (key === 'CLAUDECODE' || key.startsWith('CLAUDE_CODE') || key.startsWith('CLAUDECODE_')) delete childEnv[key];
+      }
+
+      const { spawn: cpSpawn } = require('child_process');
+      const proc = cpSpawn(process.execPath, [
+        spawnScript, promptPath, sysPath,
+        '--output-format', 'text', '--max-turns', '1', '--model', 'haiku',
+        '--permission-mode', 'bypassPermissions', '--verbose',
+      ], { cwd: SQUAD_DIR, stdio: ['pipe', 'pipe', 'pipe'], env: childEnv });
+
+      let stdout = '';
+      let stderr = '';
+      proc.stdout.on('data', d => { stdout += d.toString(); });
+      proc.stderr.on('data', d => { stderr += d.toString(); });
+
+      const timeout = setTimeout(() => { try { proc.kill('SIGTERM'); } catch {} }, 90000);
+
+      proc.on('close', (code) => {
+        clearTimeout(timeout);
+        try { fs.unlinkSync(promptPath); } catch {}
+        try { fs.unlinkSync(sysPath); } catch {}
+
+        if (code === 0 && stdout.trim()) {
+          const output = stdout.trim();
+          const delimIdx = output.indexOf('---DOCUMENT---');
+
+          if (delimIdx < 0) {
+            // Q&A response — no edit
+            return jsonReply(res, 200, { ok: true, answer: output, edited: false });
+          }
+
+          // Edit response
+          const explanation = output.slice(0, delimIdx).trim();
+          let newContent = output.slice(delimIdx + '---DOCUMENT---'.length).trim();
+          newContent = newContent.replace(/^```\w*\n?/, '').replace(/\n?```$/, '').trim();
+
+          if (isJson) {
+            try { JSON.parse(newContent); } catch (e) {
+              return jsonReply(res, 200, { ok: true, answer: explanation + '\n\n(JSON invalid — not saved: ' + e.message + ')', edited: false });
+            }
+          }
+
+          if (canEdit && fullPath) {
+            safeWrite(fullPath, newContent);
+            return jsonReply(res, 200, { ok: true, answer: explanation, edited: true, content: newContent });
+          } else {
+            return jsonReply(res, 200, { ok: true, answer: explanation + '\n\n(Read-only — changes not saved)', edited: false });
+          }
+        } else {
+          return jsonReply(res, 500, { error: 'Failed (code=' + code + ')', stderr: stderr.slice(0, 200) });
+        }
+      });
+
+      proc.on('error', (err) => {
+        clearTimeout(timeout);
+        try { fs.unlinkSync(promptPath); } catch {}
+        try { fs.unlinkSync(sysPath); } catch {}
+        return jsonReply(res, 500, { error: err.message });
+      });
+      return;
+    } catch (e) { return jsonReply(res, 400, { error: e.message }); }
+  }
+
+  // POST /api/steer-document — modify a document via natural language instruction (Haiku)
+  if (req.method === 'POST' && req.url === '/api/steer-document') {
+    try {
+      const body = await readBody(req);
+      if (!body.instruction) return jsonReply(res, 400, { error: 'instruction required' });
+      if (!body.filePath) return jsonReply(res, 400, { error: 'filePath required' });
+
+      // Read current document from disk (authoritative source)
+      const fullPath = path.resolve(SQUAD_DIR, body.filePath);
+      // Security: must be under SQUAD_DIR
+      if (!fullPath.startsWith(path.resolve(SQUAD_DIR))) return jsonReply(res, 400, { error: 'path must be under squad directory' });
+      const currentContent = safeRead(fullPath);
+      if (currentContent === null) return jsonReply(res, 404, { error: 'file not found' });
+
+      const isJson = body.filePath.endsWith('.json');
+      const prompt = `You are editing a document based on a user instruction.
+
+## Current Document
+File: ${body.filePath}
+${isJson ? 'Format: JSON (you MUST output valid JSON)' : 'Format: Markdown'}
+
+\`\`\`
+${currentContent.slice(0, 20000)}
+\`\`\`
+
+${body.selection ? '## Context: User highlighted this section\n> ' + body.selection.slice(0, 1000) + '\n' : ''}
+
+## Instruction
+
+${body.instruction}
+
+## Output Format
+
+Respond with EXACTLY two sections separated by the delimiter \`---DOCUMENT---\`:
+
+1. First: A brief explanation of what you changed (1-3 sentences)
+2. Then the delimiter on its own line: \`---DOCUMENT---\`
+3. Then the COMPLETE updated document content (not a diff — the full file)
+
+Example:
+Removed item P003 and reordered remaining items.
+---DOCUMENT---
+{full updated file content here}
+
+${isJson ? 'CRITICAL: The document section must be valid JSON. Do not add markdown code fences around it.' : ''}`;
+
+      const sysPrompt = 'You are a precise document editor. Follow the output format exactly. No code fences around the document output.';
+
+      const id = Date.now();
+      const promptPath = path.join(SQUAD_DIR, 'engine', 'steer-prompt-' + id + '.md');
+      const sysPath = path.join(SQUAD_DIR, 'engine', 'steer-sys-' + id + '.md');
+      safeWrite(promptPath, prompt);
+      safeWrite(sysPath, sysPrompt);
+
+      const spawnScript = path.join(SQUAD_DIR, 'engine', 'spawn-agent.js');
+      const childEnv = { ...process.env };
+      for (const key of Object.keys(childEnv)) {
+        if (key === 'CLAUDECODE' || key.startsWith('CLAUDE_CODE') || key.startsWith('CLAUDECODE_')) delete childEnv[key];
+      }
+
+      const { spawn: cpSpawn } = require('child_process');
+      const proc = cpSpawn(process.execPath, [
+        spawnScript, promptPath, sysPath,
+        '--output-format', 'text', '--max-turns', '1', '--model', 'haiku',
+        '--permission-mode', 'bypassPermissions', '--verbose',
+      ], { cwd: SQUAD_DIR, stdio: ['pipe', 'pipe', 'pipe'], env: childEnv });
+
+      let stdout = '';
+      let stderr = '';
+      proc.stdout.on('data', d => { stdout += d.toString(); });
+      proc.stderr.on('data', d => { stderr += d.toString(); });
+
+      const timeout = setTimeout(() => { try { proc.kill('SIGTERM'); } catch {} }, 90000);
+
+      proc.on('close', (code) => {
+        clearTimeout(timeout);
+        try { fs.unlinkSync(promptPath); } catch {}
+        try { fs.unlinkSync(sysPath); } catch {}
+
+        if (code === 0 && stdout.trim()) {
+          const output = stdout.trim();
+          const delimIdx = output.indexOf('---DOCUMENT---');
+          if (delimIdx < 0) {
+            return jsonReply(res, 200, { ok: true, answer: output, updated: false, reason: 'No document delimiter found — treated as Q&A response' });
+          }
+
+          const explanation = output.slice(0, delimIdx).trim();
+          let newContent = output.slice(delimIdx + '---DOCUMENT---'.length).trim();
+
+          // Strip code fences if model added them
+          newContent = newContent.replace(/^```\w*\n?/, '').replace(/\n?```$/, '').trim();
+
+          // Validate JSON if applicable
+          if (isJson) {
+            try { JSON.parse(newContent); } catch (e) {
+              return jsonReply(res, 200, { ok: true, answer: explanation + '\n\n(Warning: JSON validation failed — document not saved: ' + e.message + ')', updated: false });
+            }
+          }
+
+          // Write back
+          safeWrite(fullPath, newContent);
+          return jsonReply(res, 200, { ok: true, answer: explanation, updated: true, content: newContent });
+        } else {
+          return jsonReply(res, 500, { error: 'Steer failed (code=' + code + ')', stderr: stderr.slice(0, 200) });
+        }
+      });
+
+      proc.on('error', (err) => {
+        clearTimeout(timeout);
+        try { fs.unlinkSync(promptPath); } catch {}
+        try { fs.unlinkSync(sysPath); } catch {}
+        return jsonReply(res, 500, { error: err.message });
+      });
+      return;
+    } catch (e) { return jsonReply(res, 400, { error: e.message }); }
+  }
+
   // POST /api/ask-about — ask a question about a document with context, answered by Haiku
   if (req.method === 'POST' && req.url === '/api/ask-about') {
     try {

package/docs/self-improvement.md

@@ -25,7 +25,7 @@ Agent completes task
 Agent finishes task
   → writes notes/inbox/<agent>-<date>.md
   → engine checks inbox on next tick (~60s)
-  → consolidateInbox() fires (threshold: 1 file)
+  → consolidateInbox() fires (threshold: 3 files)
   → spawns Claude Haiku for LLM-powered summarization
   → Haiku reads all inbox notes + existing notes.md
   → produces deduplicated, categorized digest
@@ -323,7 +323,7 @@ When a git merge or rebase produces conflicts in yarn.lock.
 
 | Setting | Default | What it controls |
 |---------|---------|-----------------|
-| `engine.inboxConsolidateThreshold` | 1 | Files needed before consolidation triggers |
+| `engine.inboxConsolidateThreshold` | 3 | Files needed before consolidation triggers |
 | Consolidation model | Haiku | LLM used for summarization (fast, cheap) |
 | Consolidation timeout | 3 min | Max time for LLM call before fallback |
 | notes.md max size | 50KB | Auto-prunes old sections above this |

package/engine.js

@@ -1784,24 +1784,28 @@ async function handlePostMerge(pr, project, config, newStatus) {
   // Only run remaining hooks for merged PRs (not abandoned)
   if (newStatus !== 'merged') return;
 
-  // 2. Update PRD item status to 'implemented' (squad-level PRD)
+  // 2. Update PRD item status to 'implemented' in plan files
   if (pr.prdItems?.length > 0) {
-    const prdPath = path.join(SQUAD_DIR, 'prd.json');
-    const prd = safeJson(prdPath);
-    if (prd?.missing_features) {
+    const plansDir = path.join(SQUAD_DIR, 'plans');
+    try {
+      const planFiles = fs.readdirSync(plansDir).filter(f => f.endsWith('.json'));
       let updated = 0;
-      for (const itemId of pr.prdItems) {
-        const feature = prd.missing_features.find(f => f.id === itemId);
-        if (feature && feature.status !== 'implemented') {
-          feature.status = 'implemented';
-          updated++;
+      for (const pf of planFiles) {
+        const plan = safeJson(path.join(plansDir, pf));
+        if (!plan?.missing_features) continue;
+        let changed = false;
+        for (const itemId of pr.prdItems) {
+          const feature = plan.missing_features.find(f => f.id === itemId);
+          if (feature && feature.status !== 'implemented') {
+            feature.status = 'implemented';
+            changed = true;
+            updated++;
+          }
         }
+        if (changed) safeWrite(path.join(plansDir, pf), plan);
       }
-      if (updated > 0) {
-        safeWrite(prdPath, prd);
-        log('info', `Post-merge: marked ${updated} PRD item(s) as implemented for ${pr.id}`);
-      }
-    }
+      if (updated > 0) log('info', `Post-merge: marked ${updated} PRD item(s) as implemented for ${pr.id}`);
+    } catch {}
   }
 
   // 3. Update agent metrics
@@ -2987,96 +2991,7 @@ function isAlreadyDispatched(key) {
   return recentCompleted.some(d => d.meta?.dispatchKey === key);
 }
 
-/**
- * Scan squad-level PRD (~/.squad/prd.json) for missing/planned items → queue implement tasks.
- * Items can span multiple projects via the `projects` array field.
- */
-function discoverFromPrd(config) {
-  const prdPath = path.join(SQUAD_DIR, 'prd.json');
-  const prd = safeJson(prdPath);
-  if (!prd) return [];
-
-  const cooldownMs = (config.workSources?.prd?.cooldownMinutes || 30) * 60 * 1000;
-  const statusFilter = config.workSources?.prd?.itemFilter?.status || ['missing', 'planned'];
-  const items = (prd.missing_features || []).filter(f => statusFilter.includes(f.status));
-  const newWork = [];
-  const skipped = { dispatched: 0, cooldown: 0, noAgent: 0, noProject: 0 };
-  const allProjects = config.projects || [];
-
-  for (const item of items) {
-    const key = `prd-squad-${item.id}`;
-    if (isAlreadyDispatched(key)) { skipped.dispatched++; continue; }
-    if (isOnCooldown(key, cooldownMs)) { skipped.cooldown++; continue; }
-
-    // Resolve target projects from item.projects array
-    const targetProjects = (item.projects || [])
-      .map(name => allProjects.find(p => p.name.toLowerCase() === name.toLowerCase()))
-      .filter(Boolean);
-    if (targetProjects.length === 0) { skipped.noProject++; continue; }
-
-    const workType = item.estimated_complexity === 'large' ? 'implement:large' : 'implement';
-    const agentId = resolveAgent(workType, config);
-    if (!agentId) { skipped.noAgent++; continue; }
-
-    // Primary project = first in the list (used for worktree, branch, PR)
-    const primary = targetProjects[0];
-    const root = path.resolve(primary.localPath);
-    const branchName = `feature/${item.id.toLowerCase()}-${item.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 40)}`;
-
-    // Build related projects context for multi-project items
-    let relatedProjects = '';
-    if (targetProjects.length > 1) {
-      relatedProjects = targetProjects.map(p =>
-        `- **${p.name}** — ${path.resolve(p.localPath)} (${p.adoOrg}/${p.adoProject}/${p.repoName}, branch: ${p.mainBranch || 'main'})`
-      ).join('\n');
-    }
 
-    const vars = {
-      agent_id: agentId,
-      agent_name: config.agents[agentId]?.name || agentId,
-      agent_role: config.agents[agentId]?.role || 'Agent',
-      item_id: item.id,
-      item_name: item.name,
-      item_priority: item.priority || 'medium',
-      item_complexity: item.estimated_complexity || 'medium',
-      item_description: item.description || '',
-      branch_name: branchName,
-      project_path: root,
-      main_branch: primary.mainBranch || 'main',
-      worktree_path: path.resolve(root, config.engine?.worktreeRoot || '../worktrees', branchName),
-      commit_message: `feat(${item.id.toLowerCase()}): ${item.name}`,
-      team_root: SQUAD_DIR,
-      repo_id: primary.repositoryId || '',
-      project_name: targetProjects.map(p => p.name).join(', '),
-      ado_org: primary.adoOrg || 'Unknown',
-      ado_project: primary.adoProject || 'Unknown',
-      repo_name: primary.repoName || 'Unknown',
-      related_projects: relatedProjects,
-    };
-
-    const prompt = renderPlaybook('implement', vars);
-    if (!prompt) continue;
-
-    newWork.push({
-      type: workType,
-      agent: agentId,
-      agentName: config.agents[agentId]?.name,
-      agentRole: config.agents[agentId]?.role,
-      task: `[${vars.project_name}] Implement ${item.id}: ${item.name}`,
-      prompt,
-      meta: { dispatchKey: key, source: 'prd', branch: branchName, item, project: { name: primary.name, localPath: primary.localPath } }
-    });
-
-    setCooldown(key);
-  }
-
-  const skipTotal = skipped.dispatched + skipped.cooldown + skipped.noAgent + skipped.noProject;
-  if (skipTotal > 0) {
-    log('debug', `PRD discovery: skipped ${skipTotal} items (${skipped.dispatched} dispatched, ${skipped.cooldown} cooldown, ${skipped.noAgent} no agent, ${skipped.noProject} no project)`);
-  }
-
-  return newWork;
-}
 
 /**
  * Scan ~/.squad/plans/ for plan-generated PRD files → queue implement tasks.
@@ -3942,7 +3857,7 @@ function discoverWork(config) {
   }
 
   // Source 2: Squad-level PRD → implements (multi-project, called once outside project loop)
-  allImplements.push(...discoverFromPrd(config));
+  // PRD items now flow through plans/*.json → materializePlansAsWorkItems → discoverFromWorkItems
 
   // Central work items (project-agnostic — agent decides where to work)
   const centralWork = discoverCentralWorkItems(config);
@@ -4474,7 +4389,7 @@ const commands = {
     });
 
     console.log(`Dispatched: ${id} → ${config.agents[agentId]?.name} (${agentId})`);
-    console.log('The agent will analyze your plan and generate docs/prd-gaps.json as a PR.');
+    console.log('The agent will analyze your plan and generate a PRD in plans/.');
 
     // Immediately dispatch if engine is running
     const control = getControl();
@@ -4619,7 +4534,7 @@ const commands = {
     console.log('\n=== Work Discovery (dry run) ===\n');
 
     materializePlansAsWorkItems(config);
-    const prdWork = discoverFromPrd(config);
+    // PRD discovery removed — all items flow through plans/*.json
     const prWork = discoverFromPrs(config);
     const workItemWork = discoverFromWorkItems(config);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/squad",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "Multi-agent AI dev team that runs from ~/.squad/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "squad": "bin/squad.js"