@yemi33/squad 0.1.0 → 0.1.2

package/docs/engine-restart.md

@@ -0,0 +1,92 @@
+# Engine Restart & Agent Survival
+
+## The Problem
+
+When the engine restarts, it loses its in-memory process handles (`activeProcesses` Map). Claude CLI agents spawned before the restart are still running as OS processes, but the engine can't monitor their stdout, detect exit codes, or manage their lifecycle. Without protection, the heartbeat check (5-min default) would kill these agents as "orphans."
+
+## What's Persisted vs Lost
+
+| State | Storage | Survives Restart |
+|-------|---------|-----------------|
+| Dispatch queue (pending/active/completed) | `engine/dispatch.json` | Yes |
+| Agent status (working/idle/error) | `agents/*/status.json` | Yes |
+| Agent live output | `agents/*/live-output.log` | Yes (mtime used as heartbeat) |
+| Process handles (`ChildProcess`) | In-memory Map | **No** |
+| Cooldown timestamps | In-memory Map | **No** (repopulated from `engine/cooldowns.json`) |
+
+## Protection Mechanisms
+
+### 1. Grace Period on Startup (20 min default)
+
+When the engine starts and finds active dispatches from a previous session, it sets `engineRestartGraceUntil` to `now + 20 minutes`. During this window, orphan detection is completely suppressed — agents won't be killed even if the engine has no process handle for them.
+
+Configurable via `config.json`:
+```json
+{
+  "engine": {
+    "restartGracePeriod": 1200000
+  }
+}
+```
+
+### 2. Blocking Tool Detection
+
+Even after the grace period expires, the engine scans each agent's `live-output.log` for the most recent `tool_use` call. If the agent is in a known blocking tool:
+
+- **`TaskOutput` with `block: true`** — timeout extended to the task's own timeout + 1 min
+- **`Bash` with long timeout (>5 min)** — timeout extended to the bash timeout + 1 min
+
+This works for both tracked processes and orphans (no process handle).
+
+### 3. Stop Warning
+
+`engine.js stop` checks for active dispatches and warns:
+```
+WARNING: 2 agent(s) are still working:
+  - Dallas: [office-bohemia] Build & test PR PR-4959092
+  - Rebecca: [office-bohemia] Review PR PR-4964594
+
+These agents will continue running but the engine won't monitor them.
+On next start, they'll get a 20-min grace period before being marked as orphans.
+To kill them now, run: node engine.js kill
+```
+
+### 4. Exponential Backoff on Failures
+
+If an agent is killed as an orphan and the work item retries, cooldowns use exponential backoff (2^failures, max 8x) to prevent spam-retrying broken tasks.
+
+## Safe Restart Pattern
+
+```bash
+node engine.js stop       # Check the warning — are agents working?
+# If yes, decide: wait for them to finish, or accept the grace period
+# Make your code changes
+node engine.js start      # Grace period kicks in for surviving agents
+```
+
+## What the Engine Cannot Do
+
+- **Reattach to processes** — Node.js `child_process` doesn't support adopting external PIDs. Once the process handle is lost, the engine can only observe the agent indirectly via file output.
+- **Guarantee completion** — An agent that finishes during a restart will have its output saved to `live-output.log`, but the engine won't run post-completion hooks (PR sync, metrics update, learnings check). These are picked up on the next tick via output file scanning.
+- **Resume mid-task** — If an agent is killed (by orphan detection or timeout), the work item is marked failed. It can be retried but starts from scratch.
+
+## Timeline of a Restart
+
+```
+T+0s     engine.js stop (warns about active agents)
+         Engine process exits. Agents keep running as OS processes.
+
+T+30s    Code changes made. engine.js start.
+         Engine reads dispatch.json — finds 2 active items.
+         Sets grace period: 20 min from now.
+         Logs: "2 active dispatch(es) from previous session"
+
+T+0-20m  Ticks run. Orphan detection skipped (grace period).
+         If an agent finishes, output is written to live-output.log.
+         Engine detects completed output on next tick via file scan.
+
+T+20m    Grace period expires.
+         Heartbeat check resumes. Blocking tool detection still active.
+         Agent in TaskOutput block:true gets extended timeout.
+         Agent with no output for 5min+ and no blocking tool → orphaned.
+```

package/engine/ado-mcp-wrapper.js

@@ -1,49 +1,49 @@
-#!/usr/bin/env node
-/**
- * Wrapper for @azure-devops/mcp that fetches an ADO token via azureauth
- * broker (no browser popup) and sets AZURE_DEVOPS_EXT_PAT before launching
- * the MCP server.
- */
-const { execSync, spawn } = require('child_process');
-const path = require('path');
-
-// Fetch token via azureauth broker (corp tool, no browser)
-let token;
-try {
-  token = execSync('azureauth ado token --mode broker --output token --timeout 1', {
-    encoding: 'utf8',
-    timeout: 30000,
-    windowsHide: true,
-  }).trim();
-} catch (e) {
-  // Fallback: try with web mode (may open browser as last resort)
-  try {
-    token = execSync('azureauth ado token --mode web --output token --timeout 5', {
-      encoding: 'utf8',
-      timeout: 120000,
-      windowsHide: true,
-    }).trim();
-  } catch (e2) {
-    process.stderr.write('ado-mcp-wrapper: Failed to get ADO token: ' + e2.message + '\n');
-    process.exit(1);
-  }
-}
-
-// Launch the actual MCP server with the token in env
-const args = process.argv.slice(2);
-const child = spawn(process.platform === 'win32' ? 'npx.cmd' : 'npx', [
-  '-y',
-  '--registry=https://registry.npmjs.org/',
-  '@azure-devops/mcp@latest',
-  ...args
-], {
-  stdio: 'inherit',
-  env: { ...process.env, AZURE_DEVOPS_EXT_PAT: token },
-  windowsHide: true,
-});
-
-child.on('exit', (code) => process.exit(code || 0));
-child.on('error', (err) => {
-  process.stderr.write('ado-mcp-wrapper: ' + err.message + '\n');
-  process.exit(1);
-});
+#!/usr/bin/env node
+/**
+ * Wrapper for @azure-devops/mcp that fetches an ADO token via azureauth
+ * broker (no browser popup) and sets AZURE_DEVOPS_EXT_PAT before launching
+ * the MCP server.
+ */
+const { execSync, spawn } = require('child_process');
+const path = require('path');
+
+// Fetch token via azureauth broker (corp tool, no browser)
+let token;
+try {
+  token = execSync('azureauth ado token --mode broker --output token --timeout 1', {
+    encoding: 'utf8',
+    timeout: 30000,
+    windowsHide: true,
+  }).trim();
+} catch (e) {
+  // Fallback: try with web mode (may open browser as last resort)
+  try {
+    token = execSync('azureauth ado token --mode web --output token --timeout 5', {
+      encoding: 'utf8',
+      timeout: 120000,
+      windowsHide: true,
+    }).trim();
+  } catch (e2) {
+    process.stderr.write('ado-mcp-wrapper: Failed to get ADO token: ' + e2.message + '\n');
+    process.exit(1);
+  }
+}
+
+// Launch the actual MCP server with the token in env
+const args = process.argv.slice(2);
+const child = spawn(process.platform === 'win32' ? 'npx.cmd' : 'npx', [
+  '-y',
+  '--registry=https://registry.npmjs.org/',
+  '@azure-devops/mcp@latest',
+  ...args
+], {
+  stdio: 'inherit',
+  env: { ...process.env, AZURE_DEVOPS_EXT_PAT: token },
+  windowsHide: true,
+});
+
+child.on('exit', (code) => process.exit(code || 0));
+child.on('error', (err) => {
+  process.stderr.write('ado-mcp-wrapper: ' + err.message + '\n');
+  process.exit(1);
+});

package/engine.js

@@ -48,6 +48,44 @@ const IDENTITY_DIR = path.join(SQUAD_DIR, 'identity');
 //   "projects": [ { ... }, ... ] — multi-project (central .squad)
 // Each project must have "localPath" pointing to the repo root.
 
+function validateConfig(config) {
+  let errors = 0;
+  // Agents
+  if (!config.agents || Object.keys(config.agents).length === 0) {
+    console.error('FATAL: No agents defined in config.json');
+    errors++;
+  }
+  // Projects
+  const projects = config.projects || [];
+  if (projects.length === 0) {
+    console.error('FATAL: No projects configured');
+    errors++;
+  }
+  for (const p of projects) {
+    if (!p.localPath || !fs.existsSync(path.resolve(p.localPath))) {
+      console.error(`WARN: Project "${p.name}" path not found: ${p.localPath}`);
+    }
+    if (!p.repositoryId) {
+      console.warn(`WARN: Project "${p.name}" missing repositoryId — PR operations will fail`);
+    }
+  }
+  // Playbooks
+  const requiredPlaybooks = ['implement', 'review', 'fix', 'work-item'];
+  for (const pb of requiredPlaybooks) {
+    if (!fs.existsSync(path.join(PLAYBOOKS_DIR, `${pb}.md`))) {
+      console.error(`WARN: Missing playbook: playbooks/${pb}.md`);
+    }
+  }
+  // Routing
+  if (!fs.existsSync(ROUTING_PATH)) {
+    console.error('WARN: routing.md not found — agent routing will use fallbacks only');
+  }
+  if (errors > 0) {
+    console.error(`\n${errors} fatal config error(s) — exiting.`);
+    process.exit(1);
+  }
+}
+
 function getProjects(config) {
   if (config.projects && Array.isArray(config.projects)) {
     return config.projects;
@@ -525,6 +563,7 @@ function sanitizeBranch(name) {
 // ─── Agent Spawner ──────────────────────────────────────────────────────────
 
 const activeProcesses = new Map(); // dispatchId → { proc, agentId, startedAt }
+let engineRestartGraceUntil = 0; // timestamp — suppress orphan detection until this time
 
 function spawnAgent(dispatchItem, config) {
   const { id, agent: agentId, prompt: taskPrompt, type, meta } = dispatchItem;
@@ -1268,6 +1307,77 @@ async function pollPrStatus(config) {
   }
 }
 
+// ─── Post-Merge / Post-Close Hooks ───────────────────────────────────────────
+
+async function handlePostMerge(pr, project, config, newStatus) {
+  const prNum = (pr.id || '').replace('PR-', '');
+
+  // 1. Worktree cleanup
+  if (pr.branch) {
+    const root = path.resolve(project.localPath);
+    const wtRoot = path.resolve(root, config.engine?.worktreeRoot || '../worktrees');
+    const wtPath = path.join(wtRoot, pr.branch);
+    const btPath = path.join(wtRoot, `bt-${prNum}`); // build-and-test worktree
+    for (const p of [wtPath, btPath]) {
+      if (fs.existsSync(p)) {
+        try {
+          execSync(`git worktree remove "${p}" --force`, { cwd: root, stdio: 'pipe', timeout: 15000 });
+          log('info', `Cleaned up worktree: ${p}`);
+        } catch (e) { log('warn', `Failed to remove worktree ${p}: ${e.message}`); }
+      }
+    }
+  }
+
+  // Only run remaining hooks for merged PRs (not abandoned)
+  if (newStatus !== 'merged') return;
+
+  // 2. Update PRD item status to 'implemented'
+  if (pr.prdItems?.length > 0) {
+    const root = path.resolve(project.localPath);
+    const prdSrc = project.workSources?.prd || {};
+    const prdPath = path.resolve(root, prdSrc.path || 'docs/prd-gaps.json');
+    const prd = safeJson(prdPath);
+    if (prd?.missing_features) {
+      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++;
+        }
+      }
+      if (updated > 0) {
+        safeWrite(prdPath, prd);
+        log('info', `Post-merge: marked ${updated} PRD item(s) as implemented for ${pr.id}`);
+      }
+    }
+  }
+
+  // 3. Update agent metrics
+  const agentId = (pr.agent || '').toLowerCase();
+  if (agentId && config.agents?.[agentId]) {
+    const metricsPath = path.join(ENGINE_DIR, 'metrics.json');
+    const metrics = safeJson(metricsPath) || {};
+    if (!metrics[agentId]) metrics[agentId] = { tasksCompleted:0, tasksErrored:0, prsCreated:0, prsApproved:0, prsRejected:0, prsMerged:0, reviewsDone:0, lastTask:null, lastCompleted:null };
+    metrics[agentId].prsMerged = (metrics[agentId].prsMerged || 0) + 1;
+    safeWrite(metricsPath, metrics);
+  }
+
+  // 4. Teams notification
+  const teamsUrl = process.env.TEAMS_PLAN_FLOW_URL;
+  if (teamsUrl) {
+    try {
+      await fetch(teamsUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ text: `PR ${pr.id} merged: ${pr.title} (${project.name}) by ${pr.agent || 'unknown'}` })
+      });
+    } catch (e) { log('warn', `Teams post-merge notify failed: ${e.message}`); }
+  }
+
+  log('info', `Post-merge hooks completed for ${pr.id}`);
+}
+
 function checkForLearnings(agentId, agentInfo, taskDesc) {
   const today = dateStamp();
   const inboxFiles = getInboxFiles();
@@ -1621,16 +1731,43 @@ function updateSnapshot(config) {
   safeWrite(path.join(IDENTITY_DIR, 'now.md'), snapshot);
 }
 
+// ─── Idle Alert ─────────────────────────────────────────────────────────────
+
+let _lastActivityTime = Date.now();
+let _idleAlertSent = false;
+
+function checkIdleThreshold(config) {
+  const thresholdMs = (config.engine?.idleAlertMinutes || 15) * 60 * 1000;
+  const agents = Object.keys(config.agents || {});
+  const allIdle = agents.every(id => isAgentIdle(id));
+  const dispatch = getDispatch();
+  const hasPending = (dispatch.pending || []).length > 0;
+
+  if (!allIdle || hasPending) {
+    _lastActivityTime = Date.now();
+    _idleAlertSent = false;
+    return;
+  }
+
+  const idleMs = Date.now() - _lastActivityTime;
+  if (idleMs > thresholdMs && !_idleAlertSent) {
+    const mins = Math.round(idleMs / 60000);
+    log('warn', `All agents idle for ${mins} minutes — no work sources producing items`);
+    _idleAlertSent = true;
+  }
+}
+
 // ─── Timeout Checker ────────────────────────────────────────────────────────
 
 function checkTimeouts(config) {
   const timeout = config.engine?.agentTimeout || 18000000; // 5h default
   const heartbeatTimeout = config.engine?.heartbeatTimeout || 300000; // 5min — no output = dead
 
-  // 1. Check tracked processes for hard timeout
+  // 1. Check tracked processes for hard timeout (supports per-item deadline from fan-out)
   for (const [id, info] of activeProcesses.entries()) {
+    const itemTimeout = info.meta?.deadline ? Math.max(0, info.meta.deadline - new Date(info.startedAt).getTime()) : timeout;
     const elapsed = Date.now() - new Date(info.startedAt).getTime();
-    if (elapsed > timeout) {
+    if (elapsed > itemTimeout) {
       log('warn', `Agent ${info.agentId} (${id}) hit hard timeout after ${Math.round(elapsed / 1000)}s — killing`);
       try { info.proc.kill('SIGTERM'); } catch {}
       setTimeout(() => {
@@ -1707,9 +1844,10 @@ function checkTimeouts(config) {
 
     // Check if agent is in a blocking tool call (TaskOutput block:true, Bash with long timeout, etc.)
     // These tools produce no stdout for extended periods — don't kill them prematurely
+    // Check for BOTH tracked and untracked processes (orphan case after engine restart)
     let isBlocking = false;
     let blockingTimeout = heartbeatTimeout;
-    if (hasProcess && silentMs > heartbeatTimeout) {
+    if (silentMs > heartbeatTimeout) {
       try {
         const liveLog = safeRead(liveLogPath);
         if (liveLog) {
@@ -1747,9 +1885,9 @@ function checkTimeouts(config) {
 
     const effectiveTimeout = isBlocking ? blockingTimeout : heartbeatTimeout;
 
-    if (!hasProcess && silentMs > heartbeatTimeout) {
-      // No tracked process AND no recent output → orphaned
-      log('warn', `Orphan detected: ${item.agent} (${item.id}) — no process tracked, no output for ${silentSec}s`);
+    if (!hasProcess && silentMs > effectiveTimeout && Date.now() > engineRestartGraceUntil) {
+      // No tracked process AND no recent output past effective timeout AND grace period expired → orphaned
+      log('warn', `Orphan detected: ${item.agent} (${item.id}) — no process tracked, silent for ${silentSec}s${isBlocking ? ' (blocking timeout exceeded)' : ''}`);
       deadItems.push({ item, reason: `Orphaned — no process, silent for ${silentSec}s` });
     } else if (hasProcess && silentMs > effectiveTimeout) {
       // Has process but no output past effective timeout → hung
@@ -2041,15 +2179,16 @@ function discoverFromPrd(config, project) {
   const statusFilter = src.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 };
 
   for (const item of items) {
     const key = `prd-${project?.name || 'default'}-${item.id}`;
-    if (isAlreadyDispatched(key)) continue;
-    if (isOnCooldown(key, cooldownMs)) continue;
+    if (isAlreadyDispatched(key)) { skipped.dispatched++; continue; }
+    if (isOnCooldown(key, cooldownMs)) { skipped.cooldown++; continue; }
 
     const workType = item.estimated_complexity === 'large' ? 'implement:large' : 'implement';
     const agentId = resolveAgent(workType, config);
-    if (!agentId) continue;
+    if (!agentId) { skipped.noAgent++; continue; }
 
     const branchName = `feature/${item.id.toLowerCase()}-${item.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 40)}`;
     const vars = {
@@ -2090,6 +2229,11 @@ function discoverFromPrd(config, project) {
     setCooldown(key);
   }
 
+  const skipTotal = skipped.dispatched + skipped.cooldown + skipped.noAgent;
+  if (skipTotal > 0) {
+    log('debug', `PRD discovery (${project?.name}): skipped ${skipTotal} items (${skipped.dispatched} dispatched, ${skipped.cooldown} cooldown, ${skipped.noAgent} no agent)`);
+  }
+
   return newWork;
 }
 
@@ -2369,20 +2513,20 @@ function discoverFromWorkItems(config, project) {
   const items = safeJson(path.resolve(root, src.path)) || [];
   const cooldownMs = (src.cooldownMinutes || 0) * 60 * 1000;
   const newWork = [];
+  const skipped = { gated: 0, noAgent: 0 };
 
   for (const item of items) {
     if (item.status !== 'queued' && item.status !== 'pending') continue;
 
     const key = `work-${project?.name || 'default'}-${item.id}`;
-    if (isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) continue;
+    if (isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) { skipped.gated++; continue; }
 
     let workType = item.type || 'implement';
-    // Route large items to architecture agents, matching PRD/plan behavior
     if (workType === 'implement' && (item.complexity === 'large' || item.estimated_complexity === 'large')) {
       workType = 'implement:large';
     }
     const agentId = item.agent || resolveAgent(workType, config);
-    if (!agentId) continue;
+    if (!agentId) { skipped.noAgent++; continue; }
 
     const branchName = item.branch || `work/${item.id}`;
     const vars = {
@@ -2443,6 +2587,11 @@ function discoverFromWorkItems(config, project) {
     safeWrite(workItemsPath, items);
   }
 
+  const skipTotal = skipped.gated + skipped.noAgent;
+  if (skipTotal > 0) {
+    log('debug', `Work item discovery (${project?.name}): skipped ${skipTotal} items (${skipped.gated} gated, ${skipped.noAgent} no agent)`);
+  }
+
   return newWork;
 }
 
@@ -2695,7 +2844,10 @@ function discoverCentralWorkItems(config) {
           agentRole: agent.role,
           task: `[fan-out] ${item.title} → ${agent.name}${assignedProject ? ' → ' + assignedProject.name : ''}`,
           prompt,
-          meta: { dispatchKey: fanKey, source: 'central-work-item-fanout', item, parentKey: key }
+          meta: {
+            dispatchKey: fanKey, source: 'central-work-item-fanout', item, parentKey: key,
+            deadline: item.timeout ? Date.now() + item.timeout : Date.now() + (config.engine?.fanOutTimeout || config.engine?.agentTimeout || 18000000)
+          }
         });
       }
 
@@ -2838,8 +2990,9 @@ async function tickInner() {
   const config = getConfig();
   tickCount++;
 
-  // 1. Check for timed-out agents
+  // 1. Check for timed-out agents and idle threshold
   checkTimeouts(config);
+  checkIdleThreshold(config);
 
   // 2. Consolidate inbox
   consolidateInbox(config);
@@ -2931,9 +3084,24 @@ const commands = {
       }
     }
 
+    // Validate config before starting
+    validateConfig(config);
+
     // Load persistent state
     loadCooldowns();
 
+    // Grace period for agents that survived a restart
+    const dispatch = getDispatch();
+    const activeOnStart = (dispatch.active || []);
+    if (activeOnStart.length > 0) {
+      const gracePeriod = config.engine?.restartGracePeriod || 1200000; // 20min default
+      engineRestartGraceUntil = Date.now() + gracePeriod;
+      console.log(`  ${activeOnStart.length} active dispatch(es) from previous session — ${gracePeriod / 60000}min grace period before orphan detection`);
+      for (const item of activeOnStart) {
+        console.log(`    - ${item.agentName || item.agent}: ${(item.task || '').slice(0, 70)}`);
+      }
+    }
+
     // Initial tick
     tick();
 
@@ -2944,6 +3112,18 @@ const commands = {
   },
 
   stop() {
+    // Warn if agents are actively working
+    const dispatch = getDispatch();
+    const active = (dispatch.active || []);
+    if (active.length > 0) {
+      console.log(`\n  WARNING: ${active.length} agent(s) are still working:`);
+      for (const item of active) {
+        console.log(`    - ${item.agentName || item.agent}: ${(item.task || '').slice(0, 80)}`);
+      }
+      console.log('\n  These agents will continue running but the engine won\'t monitor them.');
+      console.log('  On next start, they\'ll get a 20-min grace period before being marked as orphans.');
+      console.log('  To kill them now, run: node engine.js kill\n');
+    }
     safeWrite(CONTROL_PATH, { state: 'stopped', stopped_at: ts() });
     log('info', 'Engine stopped');
     console.log('Engine stopped.');

package/package.json

@@ -1,46 +1,46 @@
-{
-  "name": "@yemi33/squad",
-  "version": "0.1.0",
-  "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"
-  },
-  "keywords": [
-    "ai",
-    "agents",
-    "claude",
-    "dev-team",
-    "automation",
-    "multi-agent",
-    "cli"
-  ],
-  "author": "yemi33",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/yemi33/squad.git"
-  },
-  "homepage": "https://github.com/yemi33/squad#readme",
-  "engines": {
-    "node": ">=18"
-  },
-  "files": [
-    "bin/",
-    "agents/*/charter.md",
-    "config.template.json",
-    "dashboard.html",
-    "dashboard.js",
-    "docs/",
-    "engine.js",
-    "engine/spawn-agent.js",
-    "engine/ado-mcp-wrapper.js",
-    "playbooks/",
-    "routing.md",
-    "skills/README.md",
-    "skills/ado-pr-status-fetch.md",
-    "squad.js",
-    "team.md",
-    "README.md",
-    "TODO.md"
-  ]
-}
+{
+  "name": "@yemi33/squad",
+  "version": "0.1.2",
+  "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"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "claude",
+    "dev-team",
+    "automation",
+    "multi-agent",
+    "cli"
+  ],
+  "author": "yemi33",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yemi33/squad.git"
+  },
+  "homepage": "https://github.com/yemi33/squad#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/",
+    "agents/*/charter.md",
+    "config.template.json",
+    "dashboard.html",
+    "dashboard.js",
+    "docs/",
+    "engine.js",
+    "engine/spawn-agent.js",
+    "engine/ado-mcp-wrapper.js",
+    "playbooks/",
+    "routing.md",
+    "skills/README.md",
+    "skills/ado-pr-status-fetch.md",
+    "squad.js",
+    "team.md",
+    "README.md",
+    "TODO.md"
+  ]
+}