agentxchain 0.1.2 → 0.2.0

package/bin/agentxchain.js

@@ -7,6 +7,8 @@ import { startCommand } from '../src/commands/start.js';
 import { stopCommand } from '../src/commands/stop.js';
 import { configCommand } from '../src/commands/config.js';
 import { updateCommand } from '../src/commands/update.js';
+import { watchCommand } from '../src/commands/watch.js';
+import { claimCommand, releaseCommand } from '../src/commands/claim.js';
 
 const program = new Command();
 
@@ -49,6 +51,23 @@ program
   .option('-j, --json', 'Output config as JSON')
   .action(configCommand);
 
+program
+  .command('watch')
+  .description('Watch lock.json and coordinate agent turns (the referee)')
+  .option('--daemon', 'Run in background mode')
+  .action(watchCommand);
+
+program
+  .command('claim')
+  .description('Claim the lock as a human (take control)')
+  .option('--force', 'Force-claim even if an agent holds the lock')
+  .action(claimCommand);
+
+program
+  .command('release')
+  .description('Release the lock (hand back to agents)')
+  .action(releaseCommand);
+
 program
   .command('update')
   .description('Update agentxchain CLI to the latest version')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "CLI for AgentXchain — multi-agent coordination in your IDE",
   "type": "module",
   "bin": {

package/src/adapters/cursor.js

@@ -1,26 +1,38 @@
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { join } from 'path';
 import chalk from 'chalk';
 import { generateSeedPrompt } from '../lib/seed-prompt.js';
+import { getRepoUrl } from '../lib/repo.js';
 
 const API_BASE = 'https://api.cursor.com/v0';
 
+function authHeaders(apiKey) {
+  return {
+    'Authorization': `Basic ${Buffer.from(apiKey + ':').toString('base64')}`,
+    'Content-Type': 'application/json'
+  };
+}
+
+// --- Public API ---
+
 export async function launchCursorAgents(config, root, opts) {
   const apiKey = process.env.CURSOR_API_KEY;
 
   if (!apiKey) {
-    console.log('');
-    console.log(chalk.yellow('  Cursor Cloud Agents API key not found.'));
-    console.log('');
-    console.log('  To launch agents via Cursor Cloud API:');
-    console.log(`    1. Go to ${chalk.cyan('cursor.com/dashboard')} → Cloud Agents`);
-    console.log('    2. Create an API key');
-    console.log(`    3. Set: ${chalk.bold('export CURSOR_API_KEY=your_key')}`);
-    console.log(`    4. Run: ${chalk.bold('agentxchain start --ide cursor')}`);
-    console.log('');
-    console.log(chalk.dim('  Falling back to seed prompt output...'));
-    console.log('');
+    printApiKeyHelp();
     return fallbackPromptOutput(config, opts);
   }
 
+  const repoUrl = await getRepoUrl(root);
+  if (!repoUrl) {
+    console.log(chalk.red('  Could not detect GitHub repo URL.'));
+    console.log(chalk.dim('  Make sure this project is a git repo with a GitHub remote.'));
+    console.log(chalk.dim('  Or set source.repository manually in agentxchain.json.'));
+    return [];
+  }
+
+  const model = config.cursor?.model || 'default';
+  const ref = config.cursor?.ref || 'main';
   const agents = filterAgents(config, opts.agent);
   const launched = [];
 
@@ -28,51 +40,130 @@ export async function launchCursorAgents(config, root, opts) {
     const prompt = generateSeedPrompt(id, agent, config);
 
     try {
+      const body = {
+        prompt: { text: prompt },
+        source: { repository: repoUrl, ref },
+        target: { autoCreatePr: false }
+      };
+      if (model !== 'default') body.model = model;
+
       const res = await fetch(`${API_BASE}/agents`, {
         method: 'POST',
-        headers: {
-          'Authorization': `Basic ${btoa(apiKey + ':')}`,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({
-          prompt,
-          repository: root,
-          name: `agentxchain-${id}`
-        })
+        headers: authHeaders(apiKey),
+        body: JSON.stringify(body)
       });
 
       if (!res.ok) {
-        const body = await res.text();
-        console.log(chalk.red(`  Failed to launch ${id}: ${res.status} ${body}`));
+        const errBody = await res.text();
+        console.log(chalk.red(`  ✗ ${id}: ${res.status} ${errBody}`));
         continue;
       }
 
       const data = await res.json();
-      launched.push({ id, name: agent.name, cloudId: data.id || 'unknown' });
-      console.log(chalk.green(`  ✓ Launched ${chalk.bold(id)} (${agent.name}) — cloud ID: ${data.id || '?'}`));
+      launched.push({
+        id,
+        name: agent.name,
+        cloudId: data.id,
+        status: data.status || 'CREATING',
+        url: data.target?.url || null
+      });
+
+      const urlStr = data.target?.url ? chalk.dim(` → ${data.target.url}`) : '';
+      console.log(chalk.green(`  ✓ ${chalk.bold(id)} (${agent.name}) — ${data.id}${urlStr}`));
     } catch (err) {
-      console.log(chalk.red(`  Failed to launch ${id}: ${err.message}`));
+      console.log(chalk.red(`  ✗ ${id}: ${err.message}`));
     }
   }
 
   if (launched.length > 0) {
-    const sessionFile = JSON.stringify({ launched, started_at: new Date().toISOString(), ide: 'cursor' }, null, 2);
-    const { writeFileSync } = await import('fs');
-    const { join } = await import('path');
-    writeFileSync(join(root, '.agentxchain-session.json'), sessionFile + '\n');
-    console.log('');
-    console.log(chalk.dim(`  Session saved to .agentxchain-session.json`));
+    saveSession(root, launched, repoUrl);
   }
 
   return launched;
 }
 
+export async function sendFollowup(apiKey, cloudId, message) {
+  const res = await fetch(`${API_BASE}/agents/${cloudId}/followup`, {
+    method: 'POST',
+    headers: authHeaders(apiKey),
+    body: JSON.stringify({ prompt: { text: message } })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Followup failed (${res.status}): ${body}`);
+  }
+  return await res.json();
+}
+
+export async function getAgentStatus(apiKey, cloudId) {
+  const res = await fetch(`${API_BASE}/agents/${cloudId}`, {
+    method: 'GET',
+    headers: authHeaders(apiKey)
+  });
+  if (!res.ok) return null;
+  return await res.json();
+}
+
+export async function getAgentConversation(apiKey, cloudId) {
+  const res = await fetch(`${API_BASE}/agents/${cloudId}/conversation`, {
+    method: 'GET',
+    headers: authHeaders(apiKey)
+  });
+  if (!res.ok) return null;
+  return await res.json();
+}
+
+export async function stopAgent(apiKey, cloudId) {
+  const res = await fetch(`${API_BASE}/agents/${cloudId}/stop`, {
+    method: 'POST',
+    headers: authHeaders(apiKey)
+  });
+  return res.ok;
+}
+
+export async function deleteAgent(apiKey, cloudId) {
+  const res = await fetch(`${API_BASE}/agents/${cloudId}`, {
+    method: 'DELETE',
+    headers: authHeaders(apiKey)
+  });
+  return res.ok;
+}
+
+export function loadSession(root) {
+  const sessionPath = join(root, '.agentxchain-session.json');
+  if (!existsSync(sessionPath)) return null;
+  return JSON.parse(readFileSync(sessionPath, 'utf8'));
+}
+
+// --- Internal ---
+
+function saveSession(root, launched, repoUrl) {
+  const session = {
+    launched,
+    started_at: new Date().toISOString(),
+    ide: 'cursor',
+    repo: repoUrl
+  };
+  const sessionPath = join(root, '.agentxchain-session.json');
+  writeFileSync(sessionPath, JSON.stringify(session, null, 2) + '\n');
+  console.log(chalk.dim(`  Session saved to .agentxchain-session.json`));
+}
+
+function filterAgents(config, specificId) {
+  if (specificId) {
+    if (!config.agents[specificId]) {
+      console.log(chalk.red(`  Agent "${specificId}" not found in agentxchain.json`));
+      process.exit(1);
+    }
+    return { [specificId]: config.agents[specificId] };
+  }
+  return config.agents;
+}
+
 function fallbackPromptOutput(config, opts) {
   const agents = filterAgents(config, opts.agent);
-
-  console.log(chalk.bold('  Copy-paste these prompts into separate Cursor sessions:'));
+  console.log(chalk.bold('  No API key. Printing seed prompts for manual use:'));
   console.log('');
-
   for (const [id, agent] of Object.entries(agents)) {
     const prompt = generateSeedPrompt(id, agent, config);
     console.log(chalk.dim('  ' + '─'.repeat(50)));
@@ -82,17 +173,16 @@ function fallbackPromptOutput(config, opts) {
     console.log(prompt);
     console.log('');
   }
-
   return [];
 }
 
-function filterAgents(config, specificId) {
-  if (specificId) {
-    if (!config.agents[specificId]) {
-      console.log(chalk.red(`  Agent "${specificId}" not found in agentxchain.json`));
-      process.exit(1);
-    }
-    return { [specificId]: config.agents[specificId] };
-  }
-  return config.agents;
+function printApiKeyHelp() {
+  console.log('');
+  console.log(chalk.yellow('  CURSOR_API_KEY not found.'));
+  console.log('');
+  console.log(`  1. Go to ${chalk.cyan('cursor.com/settings')} → Cloud Agents`);
+  console.log('  2. Create an API key');
+  console.log(`  3. Add to .env: ${chalk.bold('CURSOR_API_KEY=your_key')}`);
+  console.log(`  4. Run: ${chalk.bold('source .env && agentxchain start')}`);
+  console.log('');
 }

package/src/commands/claim.js

@@ -0,0 +1,117 @@
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import { loadConfig, loadLock, LOCK_FILE } from '../lib/config.js';
+import { stopAgent, sendFollowup, loadSession } from '../adapters/cursor.js';
+
+export async function claimCommand(opts) {
+  const result = loadConfig();
+  if (!result) { console.log(chalk.red('  No agentxchain.json found.')); process.exit(1); }
+
+  const { root, config } = result;
+  const lock = loadLock(root);
+  if (!lock) { console.log(chalk.red('  lock.json not found.')); process.exit(1); }
+
+  const apiKey = process.env.CURSOR_API_KEY;
+  const session = loadSession(root);
+  const hasCursor = session?.ide === 'cursor' && apiKey;
+
+  if (lock.holder === 'human') {
+    console.log('');
+    console.log(chalk.yellow('  You already hold the lock.'));
+    console.log(`  ${chalk.dim('Release with:')} ${chalk.bold('agentxchain release')}`);
+    console.log('');
+    return;
+  }
+
+  if (lock.holder && !opts.force) {
+    const name = config.agents[lock.holder]?.name || lock.holder;
+    console.log('');
+    console.log(chalk.yellow(`  Lock held by ${chalk.bold(lock.holder)} (${name}).`));
+    console.log(chalk.dim('  Use --force to override.'));
+    console.log('');
+    return;
+  }
+
+  // Pause all Cursor agents when human claims
+  if (hasCursor && session.launched.length > 0) {
+    console.log(chalk.dim('  Pausing Cursor agents...'));
+    for (const agent of session.launched) {
+      try {
+        await stopAgent(apiKey, agent.cloudId);
+        console.log(chalk.dim(`    Paused ${agent.id}`));
+      } catch {
+        console.log(chalk.dim(`    Could not pause ${agent.id}`));
+      }
+    }
+  }
+
+  const lockPath = join(root, LOCK_FILE);
+  const newLock = {
+    holder: 'human',
+    last_released_by: lock.last_released_by,
+    turn_number: lock.turn_number,
+    claimed_at: new Date().toISOString()
+  };
+  writeFileSync(lockPath, JSON.stringify(newLock, null, 2) + '\n');
+
+  console.log('');
+  console.log(chalk.green(`  ✓ Lock claimed by ${chalk.bold('human')} (turn ${lock.turn_number})`));
+  if (hasCursor) console.log(chalk.dim('    All Cursor agents paused.'));
+  console.log(`  ${chalk.dim('Do your work, then:')} ${chalk.bold('agentxchain release')}`);
+  console.log('');
+}
+
+export async function releaseCommand() {
+  const result = loadConfig();
+  if (!result) { console.log(chalk.red('  No agentxchain.json found.')); process.exit(1); }
+
+  const { root, config } = result;
+  const lock = loadLock(root);
+  if (!lock) { console.log(chalk.red('  lock.json not found.')); process.exit(1); }
+
+  if (!lock.holder) {
+    console.log(chalk.yellow('  Lock is already free.'));
+    return;
+  }
+
+  const who = lock.holder;
+  const lockPath = join(root, LOCK_FILE);
+  const newLock = {
+    holder: null,
+    last_released_by: who,
+    turn_number: who === 'human' ? lock.turn_number : lock.turn_number + 1,
+    claimed_at: null
+  };
+  writeFileSync(lockPath, JSON.stringify(newLock, null, 2) + '\n');
+
+  console.log('');
+  console.log(chalk.green(`  ✓ Lock released by ${chalk.bold(who)} (turn ${newLock.turn_number})`));
+
+  // If releasing from human and Cursor session exists, wake the next agent
+  if (who === 'human') {
+    const apiKey = process.env.CURSOR_API_KEY;
+    const session = loadSession(root);
+
+    if (session?.ide === 'cursor' && apiKey) {
+      const agentIds = Object.keys(config.agents);
+      const next = agentIds[0];
+      const cloudAgent = session.launched.find(a => a.id === next);
+
+      if (cloudAgent) {
+        try {
+          const name = config.agents[next]?.name || next;
+          await sendFollowup(apiKey, cloudAgent.cloudId,
+            `Human released the lock. It's your turn. Read lock.json, claim it, and do your work as ${name}.`
+          );
+          console.log(chalk.cyan(`  Woke ${chalk.bold(next)} via Cursor followup.`));
+        } catch (err) {
+          console.log(chalk.dim(`  Could not wake ${next}: ${err.message}`));
+        }
+      }
+      console.log(chalk.dim('  The watch process will coordinate from here.'));
+    }
+  }
+
+  console.log('');
+}

package/src/commands/config.js

@@ -76,6 +76,7 @@ async function addAgent(config, configPath) {
       message: 'Agent ID (lowercase, no spaces):',
       validate: (val) => {
         if (!val.match(/^[a-z0-9-]+$/)) return 'Use lowercase letters, numbers, and hyphens only.';
+        if (val === 'human' || val === 'system') return `"${val}" is a reserved ID.`;
         if (config.agents[val]) return `Agent "${val}" already exists.`;
         return true;
       }

package/src/commands/init.js

@@ -1,9 +1,13 @@
-import { writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join, resolve } from 'path';
+import { writeFileSync, readFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { CONFIG_FILE, LOCK_FILE, STATE_FILE } from '../lib/config.js';
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = join(__dirname, '../templates');
+
 const DEFAULT_AGENTS = {
   pm: {
     name: 'Product Manager',
@@ -24,54 +28,93 @@ const DEFAULT_AGENTS = {
 };
 
 function slugify(name) {
-  return name
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-|-$/g, '');
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+
+function loadTemplates() {
+  const templates = [];
+  try {
+    const files = readdirSync(TEMPLATES_DIR).filter(f => f.endsWith('.json'));
+    for (const file of files) {
+      const raw = readFileSync(join(TEMPLATES_DIR, file), 'utf8');
+      const tmpl = JSON.parse(raw);
+      templates.push({ id: file.replace('.json', ''), ...tmpl });
+    }
+  } catch {}
+  return templates;
 }
 
 export async function initCommand(opts) {
-  let project, agents, folderName;
+  let project, agents, folderName, rules;
 
   if (opts.yes) {
     project = 'My AgentXchain project';
     agents = DEFAULT_AGENTS;
     folderName = slugify(project);
+    rules = { max_consecutive_claims: 2, require_message: true, compress_after_words: 5000 };
   } else {
-    const nameAnswer = await inquirer.prompt([{
-      type: 'input',
-      name: 'project',
-      message: 'Project name:',
-      default: 'My AgentXchain project'
-    }]);
-
-    project = nameAnswer.project;
-    folderName = slugify(project);
-
-    const folderAnswer = await inquirer.prompt([{
-      type: 'input',
-      name: 'folder',
-      message: 'Folder name:',
-      default: folderName
-    }]);
-
-    folderName = folderAnswer.folder;
-
-    const agentAnswer = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'useDefaults',
-      message: 'Use default agents (pm, dev, qa, ux)?',
-      default: true
+    const templates = loadTemplates();
+
+    // Template selection
+    const templateChoices = [
+      { name: `${chalk.cyan('Custom')} — define your own agents`, value: 'custom' },
+      { name: `${chalk.cyan('Default')} — PM, Dev, QA, UX (4 agents)`, value: 'default' },
+      ...templates.map(t => ({
+        name: `${chalk.cyan(t.label)} — ${t.description} (${Object.keys(t.agents).length} agents)`,
+        value: t.id
+      }))
+    ];
+
+    const { template } = await inquirer.prompt([{
+      type: 'list',
+      name: 'template',
+      message: 'Choose a team template:',
+      choices: templateChoices
     }]);
 
-    if (agentAnswer.useDefaults) {
+    if (template !== 'custom' && template !== 'default') {
+      const tmpl = templates.find(t => t.id === template);
+      agents = tmpl.agents;
+      rules = tmpl.rules || {};
+      const { projectName } = await inquirer.prompt([{
+        type: 'input',
+        name: 'projectName',
+        message: 'Project name:',
+        default: tmpl.project
+      }]);
+      project = projectName;
+    } else if (template === 'default') {
       agents = DEFAULT_AGENTS;
+      rules = { max_consecutive_claims: 2, require_message: true, compress_after_words: 5000 };
+      const { projectName } = await inquirer.prompt([{
+        type: 'input',
+        name: 'projectName',
+        message: 'Project name:',
+        default: 'My AgentXchain project'
+      }]);
+      project = projectName;
     } else {
+      const { projectName } = await inquirer.prompt([{
+        type: 'input',
+        name: 'projectName',
+        message: 'Project name:',
+        default: 'My AgentXchain project'
+      }]);
+      project = projectName;
       agents = {};
+      rules = { max_consecutive_claims: 2, require_message: true, compress_after_words: 5000 };
       let adding = true;
       while (adding) {
         const agent = await inquirer.prompt([
-          { type: 'input', name: 'id', message: 'Agent ID (lowercase, no spaces):' },
+          {
+            type: 'input', name: 'id', message: 'Agent ID (lowercase, no spaces):',
+            validate: v => {
+              if (!v.match(/^[a-z0-9-]+$/)) return 'Lowercase letters, numbers, hyphens only.';
+              if (v === 'human' || v === 'system') return `"${v}" is reserved.`;
+              if (agents[v]) return `"${v}" already added.`;
+              return true;
+            }
+          },
           { type: 'input', name: 'name', message: 'Display name:' },
           { type: 'input', name: 'mandate', message: 'Mandate (what this agent does):' },
           { type: 'confirm', name: 'more', message: 'Add another agent?', default: true }
@@ -80,72 +123,81 @@ export async function initCommand(opts) {
         adding = agent.more;
       }
     }
+
+    folderName = slugify(project);
+    const { folder } = await inquirer.prompt([{
+      type: 'input',
+      name: 'folder',
+      message: 'Folder name:',
+      default: folderName
+    }]);
+    folderName = folder;
   }
 
   const dir = resolve(process.cwd(), folderName);
 
-  if (existsSync(dir)) {
-    if (existsSync(join(dir, CONFIG_FILE))) {
-      if (!opts.yes) {
-        const { overwrite } = await inquirer.prompt([{
-          type: 'confirm',
-          name: 'overwrite',
-          message: `${folderName}/ already has an agentxchain.json. Overwrite?`,
-          default: false
-        }]);
-        if (!overwrite) {
-          console.log(chalk.yellow('  Aborted.'));
-          return;
-        }
+  if (existsSync(dir) && existsSync(join(dir, CONFIG_FILE))) {
+    if (!opts.yes) {
+      const { overwrite } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'overwrite',
+        message: `${folderName}/ already has agentxchain.json. Overwrite?`,
+        default: false
+      }]);
+      if (!overwrite) {
+        console.log(chalk.yellow('  Aborted.'));
+        return;
       }
     }
-  } else {
-    mkdirSync(dir, { recursive: true });
   }
 
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
   const config = {
     version: 3,
     project,
     agents,
     log: 'log.md',
+    state_file: 'state.md',
+    history_file: 'history.jsonl',
     rules: {
-      max_consecutive_claims: 2,
-      require_message: true,
-      compress_after_words: 5000
+      max_consecutive_claims: rules.max_consecutive_claims || 2,
+      require_message: rules.require_message !== false,
+      compress_after_words: rules.compress_after_words || 5000,
+      ttl_minutes: rules.ttl_minutes || 10,
+      watch_interval_ms: rules.watch_interval_ms || 5000,
+      ...(rules.verify_command ? { verify_command: rules.verify_command } : {})
     }
   };
 
-  const lock = {
-    holder: null,
-    last_released_by: null,
-    turn_number: 0,
-    claimed_at: null
-  };
-
-  const state = {
-    phase: 'discovery',
-    blocked: false,
-    blocked_on: null,
-    project
-  };
+  const lock = { holder: null, last_released_by: null, turn_number: 0, claimed_at: null };
+  const state = { phase: 'discovery', blocked: false, blocked_on: null, project };
 
   writeFileSync(join(dir, CONFIG_FILE), JSON.stringify(config, null, 2) + '\n');
   writeFileSync(join(dir, LOCK_FILE), JSON.stringify(lock, null, 2) + '\n');
-  writeFileSync(join(dir, STATE_FILE), JSON.stringify(state, null, 2) + '\n');
-  writeFileSync(join(dir, config.log), `# ${project} — Agent Log\n\n## COMPRESSED CONTEXT\n\n(No compressed context yet.)\n\n## MESSAGE LOG\n\n(Agents append messages below this line.)\n`);
+  writeFileSync(join(dir, 'state.json'), JSON.stringify(state, null, 2) + '\n');
+  writeFileSync(join(dir, 'state.md'), `# ${project} — Current State\n\n## Architecture\n\n(Agents update this each turn with current decisions.)\n\n## Active Work\n\n(What's in progress right now.)\n\n## Open Issues\n\n(Bugs, blockers, risks.)\n\n## Next Steps\n\n(What should happen next.)\n`);
+  writeFileSync(join(dir, 'history.jsonl'), '');
+  writeFileSync(join(dir, 'log.md'), `# ${project} — Agent Log\n\n## COMPRESSED CONTEXT\n\n(No compressed context yet.)\n\n## MESSAGE LOG\n\n(Agents append messages below this line.)\n`);
   writeFileSync(join(dir, 'HUMAN_TASKS.md'), '# Human Tasks\n\n(Agents append tasks here when they need human action.)\n');
 
+  const agentCount = Object.keys(agents).length;
   console.log('');
   console.log(chalk.green(`  ✓ Created ${chalk.bold(folderName)}/`));
   console.log('');
-  console.log(`    ${chalk.dim('├──')} ${CONFIG_FILE}`);
-  console.log(`    ${chalk.dim('├──')} ${LOCK_FILE}`);
-  console.log(`    ${chalk.dim('├──')} ${STATE_FILE}`);
-  console.log(`    ${chalk.dim('├──')} ${config.log}`);
+  console.log(`    ${chalk.dim('├──')} agentxchain.json  ${chalk.dim(`(${agentCount} agents)`)}`);
+  console.log(`    ${chalk.dim('├──')} lock.json`);
+  console.log(`    ${chalk.dim('├──')} state.json`);
+  console.log(`    ${chalk.dim('├──')} state.md`);
+  console.log(`    ${chalk.dim('├──')} history.jsonl`);
+  console.log(`    ${chalk.dim('├──')} log.md`);
   console.log(`    ${chalk.dim('└──')} HUMAN_TASKS.md`);
   console.log('');
   console.log(`  ${chalk.dim('Agents:')} ${Object.keys(agents).join(', ')}`);
   console.log('');
-  console.log(`  ${chalk.cyan('Next:')} ${chalk.bold(`cd ${folderName}`)} && ${chalk.bold('agentxchain start')}`);
+  console.log(`  ${chalk.cyan('Next:')}`);
+  console.log(`    ${chalk.bold(`cd ${folderName}`)}`);
+  console.log(`    ${chalk.bold('agentxchain watch')}    ${chalk.dim('# start the referee')}`);
+  console.log(`    ${chalk.bold('agentxchain start')}    ${chalk.dim('# launch agents in your IDE')}`);
   console.log('');
 }