agentxchain 0.1.2 → 0.2.0

package/src/commands/status.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import { loadConfig, loadLock, loadState } from '../lib/config.js';
+import { getAgentStatus, loadSession } from '../adapters/cursor.js';
 
 export async function statusCommand(opts) {
   const result = loadConfig();
@@ -19,10 +20,9 @@ export async function statusCommand(opts) {
 
   console.log('');
   console.log(chalk.bold('  AgentXchain Status'));
-  console.log(chalk.dim('  ' + '─'.repeat(40)));
+  console.log(chalk.dim('  ' + '─'.repeat(44)));
   console.log('');
 
-  // Project
   console.log(`  ${chalk.dim('Project:')}  ${config.project}`);
   console.log(`  ${chalk.dim('Phase:')}    ${state ? formatPhase(state.phase) : chalk.dim('unknown')}`);
   if (state?.blocked) {
@@ -32,45 +32,83 @@ export async function statusCommand(opts) {
 
   // Lock
   if (lock) {
-    if (lock.holder) {
+    if (lock.holder === 'human') {
+      console.log(`  ${chalk.dim('Lock:')}     ${chalk.magenta('HUMAN')} — you hold the lock`);
+    } else if (lock.holder) {
       const agentName = config.agents[lock.holder]?.name || lock.holder;
       console.log(`  ${chalk.dim('Lock:')}     ${chalk.yellow('CLAIMED')} by ${chalk.bold(lock.holder)} (${agentName})`);
       if (lock.claimed_at) {
-        const ago = timeSince(lock.claimed_at);
-        console.log(`  ${chalk.dim('Claimed:')}  ${ago} ago`);
+        console.log(`  ${chalk.dim('Claimed:')}  ${timeSince(lock.claimed_at)} ago`);
       }
     } else {
       console.log(`  ${chalk.dim('Lock:')}     ${chalk.green('FREE')} — any agent can claim`);
     }
     console.log(`  ${chalk.dim('Turn:')}     ${lock.turn_number}`);
     if (lock.last_released_by) {
-      const lastName = config.agents[lock.last_released_by]?.name || lock.last_released_by;
-      console.log(`  ${chalk.dim('Last:')}     ${lock.last_released_by} (${lastName})`);
+      console.log(`  ${chalk.dim('Last:')}     ${lock.last_released_by}`);
     }
   }
   console.log('');
 
+  // Cursor session info
+  const session = loadSession(root);
+  const apiKey = process.env.CURSOR_API_KEY;
+  const hasCursor = session?.ide === 'cursor' && session?.launched?.length > 0;
+
+  if (hasCursor) {
+    console.log(`  ${chalk.dim('Cursor:')}   ${chalk.cyan('Active session')} (${session.launched.length} agents)`);
+    console.log(`  ${chalk.dim('Started:')}  ${session.started_at}`);
+    if (session.repo) console.log(`  ${chalk.dim('Repo:')}     ${session.repo}`);
+    console.log('');
+  }
+
   // Agents
   console.log(`  ${chalk.dim('Agents:')}   ${Object.keys(config.agents).length}`);
+
   for (const [id, agent] of Object.entries(config.agents)) {
     const isHolder = lock?.holder === id;
     const marker = isHolder ? chalk.yellow('●') : chalk.dim('○');
     const label = isHolder ? chalk.bold(id) : id;
-    console.log(`    ${marker} ${label} — ${agent.name}`);
+
+    let cursorStatus = '';
+    if (hasCursor && apiKey) {
+      const cloudAgent = session.launched.find(a => a.id === id);
+      if (cloudAgent) {
+        try {
+          const statusData = await getAgentStatus(apiKey, cloudAgent.cloudId);
+          if (statusData?.status) {
+            cursorStatus = ` ${formatCursorStatus(statusData.status)}`;
+          }
+        } catch {
+          cursorStatus = chalk.dim(' [API error]');
+        }
+      }
+    }
+
+    console.log(`    ${marker} ${label} — ${agent.name}${cursorStatus}`);
+  }
+
+  if (lock?.holder === 'human') {
+    console.log(`    ${chalk.magenta('●')} ${chalk.bold('human')} — You`);
   }
+
   console.log('');
 }
 
 function formatPhase(phase) {
-  const colors = {
-    discovery: chalk.blue,
-    build: chalk.green,
-    qa: chalk.yellow,
-    deploy: chalk.magenta,
-    blocked: chalk.red
+  const colors = { discovery: chalk.blue, build: chalk.green, qa: chalk.yellow, deploy: chalk.magenta, blocked: chalk.red };
+  return (colors[phase] || chalk.white)(phase);
+}
+
+function formatCursorStatus(status) {
+  const map = {
+    CREATING: chalk.dim('[creating]'),
+    RUNNING: chalk.cyan('[running]'),
+    FINISHED: chalk.green('[finished]'),
+    STOPPED: chalk.yellow('[stopped]'),
+    ERRORED: chalk.red('[errored]'),
   };
-  const fn = colors[phase] || chalk.white;
-  return fn(phase);
+  return map[status] || chalk.dim(`[${status}]`);
 }
 
 function timeSince(iso) {

package/src/commands/stop.js

@@ -2,85 +2,69 @@ import { readFileSync, existsSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import chalk from 'chalk';
 import { loadConfig } from '../lib/config.js';
+import { deleteAgent, stopAgent, loadSession } from '../adapters/cursor.js';
 
 const SESSION_FILE = '.agentxchain-session.json';
 
 export async function stopCommand() {
   const result = loadConfig();
-  if (!result) {
-    console.log(chalk.red('No agentxchain.json found.'));
-    process.exit(1);
-  }
+  if (!result) { console.log(chalk.red('  No agentxchain.json found.')); process.exit(1); }
 
   const { root } = result;
-  const sessionPath = join(root, SESSION_FILE);
+  const session = loadSession(root);
 
-  if (!existsSync(sessionPath)) {
-    console.log(chalk.yellow('  No active session found (.agentxchain-session.json missing).'));
-    console.log(chalk.dim('  If agents are running, stop them manually in the IDE.'));
+  if (!session) {
+    console.log(chalk.yellow('  No active session found.'));
+    console.log(chalk.dim('  If agents are running, stop them manually.'));
     return;
   }
 
-  const session = JSON.parse(readFileSync(sessionPath, 'utf8'));
   console.log('');
   console.log(chalk.bold(`  Stopping ${session.launched.length} agents (${session.ide})`));
   console.log('');
 
-  switch (session.ide) {
-    case 'cursor':
-      await stopCursorAgents(session);
-      break;
-    case 'claude-code':
-      stopClaudeCodeAgents(session);
-      break;
-    default:
-      console.log(chalk.yellow(`  IDE "${session.ide}" — manual stop required.`));
-  }
-
-  unlinkSync(sessionPath);
-  console.log('');
-  console.log(chalk.dim('  Session file removed.'));
-  console.log(chalk.green('  All agents stopped.'));
-  console.log('');
-}
-
-async function stopCursorAgents(session) {
-  const apiKey = process.env.CURSOR_API_KEY;
-
-  for (const agent of session.launched) {
-    if (agent.cloudId && apiKey) {
-      try {
-        const res = await fetch(`https://api.cursor.com/v0/agents/${agent.cloudId}`, {
-          method: 'DELETE',
-          headers: { 'Authorization': `Basic ${btoa(apiKey + ':')}` }
-        });
-        if (res.ok) {
-          console.log(chalk.green(`  ✓ Stopped ${agent.id} (cloud ID: ${agent.cloudId})`));
-        } else {
-          console.log(chalk.yellow(`  ⚠ Could not stop ${agent.id}: ${res.status}`));
+  if (session.ide === 'cursor') {
+    const apiKey = process.env.CURSOR_API_KEY;
+    if (!apiKey) {
+      console.log(chalk.yellow('  CURSOR_API_KEY not set. Cannot stop agents via API.'));
+      console.log(chalk.dim('  Stop them manually at cursor.com/agents'));
+    } else {
+      for (const agent of session.launched) {
+        try {
+          const deleted = await deleteAgent(apiKey, agent.cloudId);
+          if (deleted) {
+            console.log(chalk.green(`  ✓ Deleted ${chalk.bold(agent.id)} (${agent.cloudId})`));
+          } else {
+            console.log(chalk.yellow(`  ⚠ Could not delete ${agent.id} — may already be gone`));
+          }
+        } catch (err) {
+          console.log(chalk.red(`  ✗ ${agent.id}: ${err.message}`));
         }
-      } catch (err) {
-        console.log(chalk.red(`  ✗ Error stopping ${agent.id}: ${err.message}`));
       }
-    } else {
-      console.log(chalk.dim(`  ${agent.id} — no cloud ID or API key; stop manually in Cursor.`));
     }
-  }
-}
-
-function stopClaudeCodeAgents(session) {
-  for (const agent of session.launched) {
-    if (agent.pid) {
-      try {
-        process.kill(agent.pid, 'SIGTERM');
-        console.log(chalk.green(`  ✓ Sent SIGTERM to ${agent.id} (PID: ${agent.pid})`));
-      } catch (err) {
-        if (err.code === 'ESRCH') {
-          console.log(chalk.dim(`  ${agent.id} (PID: ${agent.pid}) — already stopped.`));
-        } else {
-          console.log(chalk.red(`  ✗ Error stopping ${agent.id}: ${err.message}`));
+  } else if (session.ide === 'claude-code') {
+    for (const agent of session.launched) {
+      if (agent.pid) {
+        try {
+          process.kill(agent.pid, 'SIGTERM');
+          console.log(chalk.green(`  ✓ Sent SIGTERM to ${agent.id} (PID: ${agent.pid})`));
+        } catch (err) {
+          if (err.code === 'ESRCH') {
+            console.log(chalk.dim(`  ${agent.id} (PID: ${agent.pid}) — already stopped`));
+          } else {
+            console.log(chalk.red(`  ✗ ${agent.id}: ${err.message}`));
+          }
         }
       }
     }
   }
+
+  // Remove session file
+  const sessionPath = join(root, SESSION_FILE);
+  if (existsSync(sessionPath)) unlinkSync(sessionPath);
+
+  console.log('');
+  console.log(chalk.dim('  Session file removed.'));
+  console.log(chalk.green('  All agents stopped.'));
+  console.log('');
 }

package/src/commands/watch.js

@@ -0,0 +1,210 @@
+import { readFileSync, writeFileSync, existsSync, appendFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import { loadConfig, loadLock, LOCK_FILE } from '../lib/config.js';
+import { notifyHuman as sendNotification } from '../lib/notify.js';
+import { sendFollowup, getAgentStatus, stopAgent, loadSession } from '../adapters/cursor.js';
+
+export async function watchCommand(opts) {
+  const result = loadConfig();
+  if (!result) {
+    console.log(chalk.red('  No agentxchain.json found. Run `agentxchain init` first.'));
+    process.exit(1);
+  }
+
+  const { root, config } = result;
+  const interval = config.rules?.watch_interval_ms || 5000;
+  const ttlMinutes = config.rules?.ttl_minutes || 10;
+  const agentIds = Object.keys(config.agents);
+  const apiKey = process.env.CURSOR_API_KEY;
+  const session = loadSession(root);
+  const hasCursorSession = session?.ide === 'cursor' && session?.launched?.length > 0;
+
+  console.log('');
+  console.log(chalk.bold('  AgentXchain Watch'));
+  console.log(chalk.dim(`  Project: ${config.project}`));
+  console.log(chalk.dim(`  Agents:  ${agentIds.join(', ')}`));
+  console.log(chalk.dim(`  Poll:    ${interval}ms | TTL: ${ttlMinutes}min`));
+  if (hasCursorSession) {
+    console.log(chalk.cyan(`  Mode:    Cursor Cloud Agents (${session.launched.length} agents)`));
+  } else {
+    console.log(chalk.dim(`  Mode:    Local trigger file (no Cursor session found)`));
+  }
+  console.log('');
+  console.log(chalk.cyan('  Watching lock.json... (Ctrl+C to stop)'));
+  console.log('');
+
+  let lastState = null;
+
+  const tick = async () => {
+    try {
+      const lock = loadLock(root);
+      if (!lock) { log('warn', 'lock.json not found'); return; }
+
+      const stateKey = `${lock.holder}:${lock.turn_number}`;
+
+      // TTL check — stale lock
+      if (lock.holder && lock.holder !== 'human' && lock.claimed_at) {
+        const elapsed = Date.now() - new Date(lock.claimed_at).getTime();
+        const ttlMs = ttlMinutes * 60 * 1000;
+
+        if (elapsed > ttlMs) {
+          const staleAgent = lock.holder;
+          const minutes = Math.round(elapsed / 60000);
+          log('ttl', `Lock held by ${staleAgent} for ${minutes}min. Force-releasing.`);
+
+          if (hasCursorSession && apiKey) {
+            const cloudAgent = session.launched.find(a => a.id === staleAgent);
+            if (cloudAgent) {
+              await stopAgent(apiKey, cloudAgent.cloudId);
+              log('ttl', `Stopped Cursor agent ${staleAgent}`);
+            }
+          }
+
+          forceRelease(root, lock, staleAgent, config);
+          lastState = null;
+          return;
+        }
+      }
+
+      // Human holder
+      if (lock.holder === 'human') {
+        if (stateKey !== lastState) {
+          log('human', 'Lock held by HUMAN. Run `agentxchain release` when done.');
+          sendNotification('An agent needs your help. Run: agentxchain release');
+          lastState = stateKey;
+        }
+        return;
+      }
+
+      // Agent is working
+      if (lock.holder) {
+        if (stateKey !== lastState) {
+          const name = config.agents[lock.holder]?.name || lock.holder;
+          log('claimed', `${lock.holder} (${name}) working... (turn ${lock.turn_number})`);
+          lastState = stateKey;
+
+          // Check Cursor agent status if available
+          if (hasCursorSession && apiKey) {
+            const cloudAgent = session.launched.find(a => a.id === lock.holder);
+            if (cloudAgent) {
+              const status = await getAgentStatus(apiKey, cloudAgent.cloudId);
+              if (status?.status === 'FINISHED') {
+                log('warn', `${lock.holder} Cursor agent is FINISHED but lock not released. May need TTL.`);
+              }
+            }
+          }
+        }
+        return;
+      }
+
+      // Lock is FREE — wake the next agent
+      if (stateKey !== lastState) {
+        const next = pickNextAgent(lock, config);
+        log('free', `Lock free (released by ${lock.last_released_by || 'none'}). Waking ${chalk.bold(next)}.`);
+        lastState = stateKey;
+
+        if (hasCursorSession && apiKey) {
+          await wakeCursorAgent(apiKey, session, next, lock, config);
+        } else {
+          writeTrigger(root, next, lock, config);
+        }
+      }
+    } catch (err) {
+      log('error', err.message);
+    }
+  };
+
+  await tick();
+  const timer = setInterval(tick, interval);
+
+  process.on('SIGINT', () => {
+    clearInterval(timer);
+    console.log('');
+    log('stop', 'Watch stopped.');
+    process.exit(0);
+  });
+}
+
+async function wakeCursorAgent(apiKey, session, agentId, lock, config) {
+  const cloudAgent = session.launched.find(a => a.id === agentId);
+  if (!cloudAgent) {
+    log('warn', `No Cursor cloud agent found for "${agentId}". Using trigger file.`);
+    return;
+  }
+
+  const name = config.agents[agentId]?.name || agentId;
+  const wakeMessage = `The lock is free. It's your turn.
+
+READ lock.json — if holder is null, CLAIM it by writing holder="${agentId}" and claimed_at=now.
+Then do your work per your mandate:
+- Name: ${name}
+- Mandate: ${config.agents[agentId]?.mandate || '(see agentxchain.json)'}
+
+When done:
+1. Update state.md with current project state
+2. Append one line to history.jsonl
+${config.rules?.verify_command ? `3. Run verify: ${config.rules.verify_command} — fix if it fails` : ''}
+${config.rules?.verify_command ? '4' : '3'}. RELEASE lock.json: holder=null, last_released_by="${agentId}", turn_number=${lock.turn_number + 1}, claimed_at=null
+
+This must be the last thing you write. The watch process will wake the next agent.`;
+
+  try {
+    await sendFollowup(apiKey, cloudAgent.cloudId, wakeMessage);
+    log('wake', `Sent followup to ${chalk.bold(agentId)} (${cloudAgent.cloudId})`);
+  } catch (err) {
+    log('error', `Failed to wake ${agentId}: ${err.message}`);
+  }
+}
+
+function pickNextAgent(lock, config) {
+  const agentIds = Object.keys(config.agents);
+  const lastAgent = lock.last_released_by;
+
+  if (!lastAgent || !agentIds.includes(lastAgent)) return agentIds[0];
+
+  const lastIndex = agentIds.indexOf(lastAgent);
+  return agentIds[(lastIndex + 1) % agentIds.length];
+}
+
+function forceRelease(root, lock, staleAgent, config) {
+  const lockPath = join(root, LOCK_FILE);
+  const newLock = {
+    holder: null,
+    last_released_by: `system:ttl:${staleAgent}`,
+    turn_number: lock.turn_number,
+    claimed_at: null
+  };
+  writeFileSync(lockPath, JSON.stringify(newLock, null, 2) + '\n');
+
+  const logFile = config.log || 'log.md';
+  const logPath = join(root, logFile);
+  if (existsSync(logPath)) {
+    appendFileSync(logPath, `\n---\n\n### [system] (Watch) | Turn ${lock.turn_number}\n\n**Warning:** Lock force-released from \`${staleAgent}\` (TTL expired).\n\n`);
+  }
+}
+
+function writeTrigger(root, agentId, lock, config) {
+  const triggerPath = join(root, '.agentxchain-trigger.json');
+  writeFileSync(triggerPath, JSON.stringify({
+    agent: agentId,
+    turn_number: lock.turn_number,
+    triggered_at: new Date().toISOString(),
+    project: config.project
+  }, null, 2) + '\n');
+}
+
+function log(type, msg) {
+  const time = new Date().toLocaleTimeString();
+  const tags = {
+    free: chalk.green('FREE '),
+    claimed: chalk.yellow('WORK '),
+    wake: chalk.cyan('WAKE '),
+    ttl: chalk.red(' TTL '),
+    human: chalk.magenta('HUMAN'),
+    warn: chalk.yellow('WARN '),
+    error: chalk.red('ERR  '),
+    stop: chalk.dim('STOP '),
+  };
+  console.log(`  ${chalk.dim(time)} ${tags[type] || chalk.dim(type)}  ${msg}`);
+}

package/src/lib/notify.js

@@ -0,0 +1,24 @@
+import { execSync } from 'child_process';
+
+export function notifyHuman(message, title = 'AgentXchain') {
+  // Terminal bell
+  process.stdout.write('\x07');
+
+  // macOS notification
+  if (process.platform === 'darwin') {
+    try {
+      execSync(`osascript -e 'display notification "${message}" with title "${title}"'`);
+    } catch {
+      // osascript not available or permission denied
+    }
+  }
+
+  // Linux notification
+  if (process.platform === 'linux') {
+    try {
+      execSync(`notify-send "${title}" "${message}"`);
+    } catch {
+      // notify-send not available
+    }
+  }
+}

package/src/lib/repo.js

@@ -0,0 +1,37 @@
+import { execSync } from 'child_process';
+
+export async function getRepoUrl(root) {
+  try {
+    const raw = execSync('git remote get-url origin', { cwd: root, encoding: 'utf8' }).trim();
+
+    // Convert SSH to HTTPS if needed
+    // git@github.com:user/repo.git -> https://github.com/user/repo
+    if (raw.startsWith('git@github.com:')) {
+      const path = raw.replace('git@github.com:', '').replace(/\.git$/, '');
+      return `https://github.com/${path}`;
+    }
+
+    // Already HTTPS — strip .git suffix
+    if (raw.includes('github.com')) {
+      return raw.replace(/\.git$/, '');
+    }
+
+    // Strip tokens from URL (x-access-token:TOKEN@github.com)
+    if (raw.includes('x-access-token')) {
+      const cleaned = raw.replace(/https:\/\/x-access-token:[^@]+@/, 'https://');
+      return cleaned.replace(/\.git$/, '');
+    }
+
+    return raw;
+  } catch {
+    return null;
+  }
+}
+
+export function getCurrentBranch(root) {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', { cwd: root, encoding: 'utf8' }).trim();
+  } catch {
+    return 'main';
+  }
+}

package/src/lib/seed-prompt.js

@@ -1,6 +1,35 @@
 export function generateSeedPrompt(agentId, agentDef, config) {
   const logFile = config.log || 'log.md';
   const maxClaims = config.rules?.max_consecutive_claims || 2;
+  const verifyCmd = config.rules?.verify_command || null;
+  const stateFile = config.state_file || 'state.md';
+  const historyFile = config.history_file || 'history.jsonl';
+  const useSplit = config.state_file || config.history_file;
+
+  const stateInstructions = useSplit
+    ? `- Current project state is in "${stateFile}" (read this fully each turn).
+- Turn history is in "${historyFile}" (read only the last 3 lines for recent context).`
+    : `- The message log is "${logFile}". The lock is lock.json. Project phase is in state.json.`;
+
+  const logInstructions = useSplit
+    ? `4. Update "${stateFile}" — overwrite it with the current state of the project: architecture, active bugs, next steps, open decisions. This is a living document, not append-only.
+5. Append ONE line to "${historyFile}" as JSON: {"turn": N, "agent": "${agentId}", "summary": "...", "files_changed": [...], "verify_result": "pass|fail|skipped", "timestamp": "..."}`
+    : `4. Append ONE message to ${logFile}:
+
+   ---
+   ### [${agentId}] (${agentDef.name}) | Turn N
+   **Status:** ...
+   **Decision:** ...
+   **Action:** ...
+   **Next:** ...`;
+
+  const verifyInstructions = verifyCmd
+    ? `
+VERIFY BEFORE RELEASING
+- Before releasing the lock, you MUST run: ${verifyCmd}
+- If it fails, fix the issue and run it again. Do NOT release until it passes.
+- Report the verify result in your turn summary.`
+    : '';
 
   return `You are agent "${agentId}" on an AgentXchain team.
 
@@ -10,35 +39,31 @@ YOUR IDENTITY
 
 SETUP
 - The project config is in agentxchain.json. Your entry is under agents."${agentId}".
-- The protocol spec is PROTOCOL-v3.md (in this folder or one level up).
-- The message log is "${logFile}". The lock is lock.json. Project state is state.json.
-
-YOUR LOOP (run forever, do not exit)
-1. Read lock.json. If holder is not null, wait 30 seconds and try again.
-2. When holder is null, CLAIM: write lock.json with holder="${agentId}", claimed_at=now.
-   Re-read lock.json to confirm you won. If someone else claimed, go back to step 1.
-3. You have the lock. Read state.json (phase, blocked), then read the latest messages in ${logFile}.
-   - If blocked and you can't unblock: short "Still blocked" message, release lock, go to step 1.
-   - Otherwise: do your work per your mandate.
-4. Append ONE message to ${logFile}:
+${stateInstructions}
 
-   ---
-   ### [${agentId}] (${agentDef.name}) | Turn N
-   **Status:** ...
-   **Decision:** ...
-   **Action:** ...
-   **Next:** ...
+HOW YOU WORK
+The AgentXchain Watch process manages coordination. You do NOT need to poll or wait.
+When it's your turn, a trigger file (.agentxchain-trigger.json) appears with your agent ID.
 
-5. Update state.json if phase/blocked changed.
-6. RELEASE lock.json: holder=null, last_released_by="${agentId}", turn_number=previous+1, claimed_at=null.
+YOUR TURN (when triggered):
+1. Read lock.json. Confirm holder is null or is being assigned to you.
+2. CLAIM the lock: write lock.json with holder="${agentId}", claimed_at=current timestamp.
+   Re-read to confirm you won. If someone else claimed, stop and wait for next trigger.
+3. You have the lock. Read state and recent context per the files above.
+   - If blocked and you can't unblock: short "Still blocked" message, release, done.
+   - Otherwise: do your work per your mandate. Write code, run tests, make decisions.
+${logInstructions}
+6. Update state.json if phase or blocked status changed.${verifyInstructions}
+7. RELEASE lock.json: holder=null, last_released_by="${agentId}", turn_number=previous+1, claimed_at=null.
    This MUST be the last thing you write.
-7. Go to step 1. Never exit. Never say "I'm done."
+
+After releasing, your turn is done. The watch process will trigger the next agent.
 
 RULES
-- Never write without holding the lock.
-- One message per turn. One git commit per turn: "Turn N - ${agentId} - description".
+- Never write files or code without holding the lock.
+- One message/entry per turn. One git commit per turn: "Turn N - ${agentId} - description".
 - Challenge previous work. Find at least one risk or issue. No blind agreement.
 - Stay in your lane. Do what your mandate says.
-- Max ${maxClaims} consecutive claims. If you've hit the limit, skip and let others go.
-- Always release the lock.`;
+- Max ${maxClaims} consecutive claims. If you've hit the limit, release without major work.
+- Always release the lock. A stuck lock blocks the entire team.`;
 }

package/src/templates/api-builder.json

@@ -0,0 +1,29 @@
+{
+  "label": "API Builder",
+  "description": "Design and build a REST/GraphQL API with tests and docs",
+  "project": "API service",
+  "agents": {
+    "architect": {
+      "name": "API Architect",
+      "mandate": "Define endpoints, data models, auth strategy, error handling patterns. Review for consistency and RESTful conventions."
+    },
+    "dev": {
+      "name": "Backend Developer",
+      "mandate": "Implement endpoints, write database queries, add validation. Run tests. One endpoint or feature per turn."
+    },
+    "qa": {
+      "name": "API Tester",
+      "mandate": "Write and run API tests (integration + edge cases). Test auth, validation, error responses. Report pass/fail with curl examples."
+    },
+    "docs": {
+      "name": "Documentation Writer",
+      "mandate": "Write API docs: endpoint reference, request/response examples, auth guide. Keep docs in sync with implementation."
+    }
+  },
+  "rules": {
+    "max_consecutive_claims": 2,
+    "verify_command": "npm test",
+    "ttl_minutes": 10,
+    "compress_after_words": 5000
+  }
+}

package/src/templates/bug-squad.json

@@ -0,0 +1,25 @@
+{
+  "label": "Bug Squad",
+  "description": "Triage, reproduce, fix, and verify a backlog of bugs",
+  "project": "Bug fix sprint",
+  "agents": {
+    "triage": {
+      "name": "Triage Lead",
+      "mandate": "Read bug reports, prioritize by severity and user impact. Assign clear reproduction steps and acceptance criteria for each bug."
+    },
+    "dev": {
+      "name": "Developer",
+      "mandate": "Fix bugs. Write the smallest correct change. Run tests. One bug per turn. Report what was changed and why."
+    },
+    "qa": {
+      "name": "QA Verifier",
+      "mandate": "Verify each fix: reproduce the original bug, confirm it's fixed, check for regressions. Pass or fail with evidence."
+    }
+  },
+  "rules": {
+    "max_consecutive_claims": 3,
+    "verify_command": "npm test",
+    "ttl_minutes": 8,
+    "compress_after_words": 3000
+  }
+}