agentxchain 0.6.0 → 0.7.1

package/README.md

@@ -14,60 +14,32 @@ Or run without installing:
 npx agentxchain init
 ```
 
-## Quick start — VS Code / Cursor (recommended)
-
-No API keys or cloud connection needed. Uses native VS Code custom agents.
+## Quick start
 
 ```bash
 agentxchain init                      # create project with agents + hooks
 cd my-project/ && code .              # open in VS Code / Cursor
-# Select an agent from Chat dropdown (auto-discovered from .github/agents/)
+# Select an agent from the Chat dropdown (auto-discovered from .github/agents/)
 agentxchain release                   # release human lock to begin turns
 ```
 
-The `Stop` hook acts as referee: when an agent finishes, it hands off to the next agent automatically.
-
-## Quick start — Cursor Cloud Agents
-
-```bash
-agentxchain init
-cd my-project/
-echo "CURSOR_API_KEY=your_key" >> .env # cursor.com/settings -> Cloud Agents
-# Connect GitHub in Cursor Settings -> GitHub integration
-agentxchain start --ide cursor        # launch cloud agents
-agentxchain watch                     # coordinate turns
-agentxchain release                   # begin turns (initial lock is human)
-```
-
-> `CURSOR_API_KEY` is required for Cloud commands. Your Cursor account needs GitHub access to the target repository.
+The `Stop` hook acts as referee: when an agent finishes, it determines the next agent and hands off automatically. No polling process needed.
 
 ## Commands
 
 | Command | What it does |
 |---------|-------------|
-| `init` | Create project folder with agents, protocol files, hooks, and templates |
+| `init` | Create project folder with agents, hooks, protocol files, and templates |
 | `generate` | Regenerate VS Code agent files (`.agent.md`, hooks) from `agentxchain.json` |
-| `start` | Launch agents in Cursor Cloud, Claude Code, or VS Code |
-| `watch` | The referee for cloud mode — coordinates turns, enforces TTL, wakes agents |
-| `status` | Show lock, phase, agents, Cursor session info |
-| `claim` | Human takes control (pauses Cursor agents) |
+| `start` | Show agent setup instructions for your IDE |
+| `status` | Show lock, phase, agents |
+| `claim` | Human takes control |
 | `release` | Hand lock back to agents |
-| `stop` | Terminate all running cloud agents |
-| `branch` | Show/set Cursor branch override (`cursor.ref`) |
+| `stop` | Terminate running Claude Code agent sessions |
+| `watch` | Fallback referee for non-IDE environments |
 | `config` | View/edit config, add/remove agents, change rules |
 | `update` | Self-update CLI from npm |
 
-### Branch selection
-
-By default, Cursor launches use your current local git branch.
-
-```bash
-agentxchain branch                  # show current/effective branch
-agentxchain branch develop          # pin to a specific branch
-agentxchain branch --use-current    # pin to whatever branch you're on now
-agentxchain branch --unset          # remove pin; follow active git branch
-```
-
 ### Additional flags
 
 ```bash
@@ -75,45 +47,42 @@ agentxchain watch --daemon          # run watch in background
 agentxchain release --force         # force-release non-human holder lock
 ```
 
-## VS Code plugin
+## How it works
 
 `agentxchain init` generates native VS Code agent files:
 
-- `.github/agents/*.agent.md` — custom agents (auto-discovered by VS Code Chat)
+- `.github/agents/*.agent.md` — custom agents (auto-discovered by VS Code / Cursor Chat)
 - `.github/hooks/agentxchain.json` — lifecycle hooks (Stop = referee, SessionStart = context injection)
 - `scripts/agentxchain-*.sh` — hook shell scripts
 
-VS Code extension (optional, for UI):
-- Status bar: lock holder, turn, phase (live-updated via file watcher)
-- Sidebar: agent dashboard with quick actions
-- Commands: Claim, Release, Status, Generate
-
-Install the extension:
-```bash
-code --install-extension cli/vscode-extension/agentxchain-0.1.0.vsix
-```
+When an agent finishes its response, the Stop hook reads `lock.json`, determines the next agent, and hands off automatically.
 
 ## Key features
 
 - **Native VS Code agents** — `.agent.md` files, lifecycle hooks, handoffs
-- **Claim-based coordination** — no fixed turn order; agents self-organize
-- **Stop hook referee** — deterministic turn coordination via VS Code hooks
+- **Works in any VS Code fork** — Cursor, VS Code, Windsurf, etc.
+- **Stop hook referee** — deterministic turn coordination via lifecycle hooks
 - **User-defined teams** — any number of agents, any roles
-- **Cursor Cloud Agents** — launch and manage via API (optional)
-- **Branch-safe launching** — defaults to active git branch
-- **Lock TTL** — stale locks auto-released after timeout
-- **Verify command** — agents must pass tests before releasing
+- **No API keys or cloud required** — everything runs locally
 - **Human-in-the-loop** — claim/release to intervene anytime
 - **Team templates** — SaaS MVP, Landing Page, Bug Squad, API Builder, Refactor Team
 
+## VS Code extension (optional)
+
+For a richer UI experience, install the extension:
+
+```bash
+code --install-extension cli/vscode-extension/agentxchain-0.1.0.vsix
+```
+
+Adds: status bar (lock holder, turn, phase), sidebar dashboard, command palette integration.
+
 ## Publish updates (maintainers)
 
 ```bash
 cd cli
 bash scripts/publish-npm.sh              # patch bump + publish
 bash scripts/publish-npm.sh minor        # minor bump + publish
-bash scripts/publish-npm.sh 0.5.0        # explicit version + publish
-bash scripts/publish-npm.sh patch --dry-run
 ```
 
 If `NPM_TOKEN` exists in `agentXchain.dev/.env` (project root), the script uses it automatically.

package/bin/agentxchain.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { Command } from 'commander';
 import { initCommand } from '../src/commands/init.js';
 import { statusCommand } from '../src/commands/status.js';
@@ -9,15 +12,17 @@ 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';
-import { branchCommand } from '../src/commands/branch.js';
 import { generateCommand } from '../src/commands/generate.js';
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+
 const program = new Command();
 
 program
   .name('agentxchain')
   .description('Multi-agent coordination in your IDE')
-  .version('0.4.1');
+  .version(pkg.version);
 
 program
   .command('init')
@@ -34,7 +39,7 @@ program
 program
   .command('start')
   .description('Launch agents in your IDE')
-  .option('--ide <ide>', 'Target IDE: cursor, vscode, claude-code', 'cursor')
+  .option('--ide <ide>', 'Target IDE: vscode, claude-code', 'vscode')
   .option('--agent <id>', 'Launch a specific agent only')
   .option('--dry-run', 'Print what would be launched without doing it')
   .action(startCommand);
@@ -53,13 +58,6 @@ program
   .option('-j, --json', 'Output config as JSON')
   .action(configCommand);
 
-program
-  .command('branch [name]')
-  .description('Show or set the Cursor branch used for agent launches')
-  .option('--use-current', 'Set override to the current local git branch')
-  .option('--unset', 'Remove override and follow active git branch automatically')
-  .action(branchCommand);
-
 program
   .command('generate')
   .description('Regenerate VS Code agent files (.agent.md, hooks) from agentxchain.json')

package/package.json

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

package/src/commands/claim.js

@@ -2,8 +2,6 @@ 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';
-import { getCursorApiKey, printCursorApiKeyRequired } from '../lib/cursor-api-key.js';
 
 export async function claimCommand(opts) {
   const result = loadConfig();
@@ -13,18 +11,6 @@ export async function claimCommand(opts) {
   const lock = loadLock(root);
   if (!lock) { console.log(chalk.red('  lock.json not found.')); process.exit(1); }
 
-  const apiKey = getCursorApiKey(root);
-  const session = loadSession(root);
-  const hasCursorSession = session?.ide === 'cursor' && session?.launched?.length > 0;
-  const hasCursor = hasCursorSession && apiKey;
-
-  if (hasCursorSession && !apiKey) {
-    printCursorApiKeyRequired('`agentxchain claim` with Cursor agents');
-    console.log(chalk.dim('  Claim aborted so agents are not left running unexpectedly.'));
-    console.log('');
-    process.exit(1);
-  }
-
   if (lock.holder === 'human') {
     console.log('');
     console.log(chalk.yellow('  You already hold the lock.'));
@@ -42,19 +28,6 @@ export async function claimCommand(opts) {
     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',
@@ -66,7 +39,6 @@ export async function claimCommand(opts) {
 
   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('');
 }
@@ -88,14 +60,12 @@ export async function releaseCommand(opts) {
     const name = config.agents[lock.holder]?.name || lock.holder;
     console.log('');
     console.log(chalk.red(`  Lock is held by ${chalk.bold(lock.holder)} (${name}), not human.`));
-    console.log(chalk.dim('  Refusing to release another holder without explicit override.'));
-    console.log(chalk.dim('  Use `agentxchain release --force` if you really want to break this lock.'));
+    console.log(chalk.dim('  Use `agentxchain release --force` to break this lock.'));
     console.log('');
     process.exit(1);
   }
 
   const who = lock.holder;
-  const priorLastReleasedBy = lock.last_released_by;
   const lockPath = join(root, LOCK_FILE);
   const newLock = {
     holder: null,
@@ -107,53 +77,6 @@ export async function releaseCommand(opts) {
 
   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 = getCursorApiKey(root);
-    const session = loadSession(root);
-    const hasCursorSession = session?.ide === 'cursor' && session?.launched?.length > 0;
-
-    if (hasCursorSession && !apiKey) {
-      printCursorApiKeyRequired('`agentxchain release` with Cursor agents');
-      console.log(chalk.dim('  Lock released, but wake-up followup was skipped due to missing key.'));
-      console.log(chalk.dim('  Start `agentxchain watch` after setting the key.'));
-      console.log('');
-      return;
-    }
-
-    if (session?.ide === 'cursor' && apiKey) {
-      const next = pickNextAgent(priorLastReleasedBy, config);
-      if (!next) {
-        console.log(chalk.dim('  No agents configured to wake.'));
-        console.log('');
-        return;
-      }
-      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(chalk.dim('  The Stop hook will coordinate the next agent turn in VS Code.'));
   console.log('');
 }
-
-function pickNextAgent(lastReleasedBy, config) {
-  const agentIds = Object.keys(config.agents || {});
-  if (agentIds.length === 0) return null;
-  if (!lastReleasedBy || !agentIds.includes(lastReleasedBy)) return agentIds[0];
-
-  const idx = agentIds.indexOf(lastReleasedBy);
-  return agentIds[(idx + 1) % agentIds.length];
-}

package/src/commands/init.js

@@ -206,15 +206,8 @@ export async function initCommand(opts) {
   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');
-  writeFileSync(join(dir, '.env.example'), 'CURSOR_API_KEY=\n');
-  if (!existsSync(join(dir, '.env'))) {
-    writeFileSync(
-      join(dir, '.env'),
-      '# Required for Cursor commands: start/watch/stop/claim/release\nCURSOR_API_KEY=\n'
-    );
-  }
   const gitignorePath = join(dir, '.gitignore');
-  const requiredIgnores = ['.env', '.agentxchain-session.json', '.agentxchain-trigger.json'];
+  const requiredIgnores = ['.env', '.agentxchain-trigger.json'];
   if (!existsSync(gitignorePath)) {
     writeFileSync(gitignorePath, requiredIgnores.join('\n') + '\n');
   } else {
@@ -271,9 +264,8 @@ export async function initCommand(opts) {
   console.log('');
   console.log(`  ${chalk.cyan('Next:')}`);
   console.log(`    ${chalk.bold(`cd ${folderName}`)}`);
-  console.log(`    ${chalk.bold('edit .env')}            ${chalk.dim('# set CURSOR_API_KEY (required for Cursor mode)')}`);
-  console.log(`    ${chalk.bold('agentxchain start')}    ${chalk.dim('# launch agents in Cursor')}`);
-  console.log(`    ${chalk.bold('agentxchain watch')}    ${chalk.dim('# start the referee')}`);
-  console.log(`    ${chalk.bold('agentxchain release')}  ${chalk.dim('# begin automation (initial lock is human)')}`);
+  console.log(`    ${chalk.bold('code .')}               ${chalk.dim('# open in VS Code / Cursor')}`);
+  console.log(`    ${chalk.dim('Select an agent from the Chat dropdown (auto-discovered from .github/agents/)')}`);
+  console.log(`    ${chalk.bold('agentxchain release')}  ${chalk.dim('# release human lock to begin turns')}`);
   console.log('');
 }

package/src/commands/start.js

@@ -1,7 +1,6 @@
 import chalk from 'chalk';
 import { loadConfig } from '../lib/config.js';
 import { generateSeedPrompt } from '../lib/seed-prompt.js';
-import { getCursorApiKey, printCursorApiKeyRequired } from '../lib/cursor-api-key.js';
 
 export async function startCommand(opts) {
   const result = loadConfig();
@@ -28,12 +27,11 @@ export async function startCommand(opts) {
   }
 
   console.log('');
-  console.log(chalk.bold(`  Launching ${agentCount} agents via ${ide}`));
-  console.log(chalk.dim(`  Project: ${config.project}`));
+  console.log(chalk.bold(`  ${agentCount} agents configured for ${config.project}`));
   console.log('');
 
   if (opts.dryRun) {
-    console.log(chalk.yellow('  DRY RUN — showing what would be launched:'));
+    console.log(chalk.yellow('  DRY RUN — showing agents:'));
     console.log('');
     for (const [id, agent] of Object.entries(config.agents)) {
       if (opts.agent && opts.agent !== id) continue;
@@ -45,14 +43,23 @@ export async function startCommand(opts) {
   }
 
   switch (ide) {
-    case 'cursor': {
-      const apiKey = getCursorApiKey(root);
-      if (!apiKey) {
-        printCursorApiKeyRequired('`agentxchain start --ide cursor`');
-        process.exit(1);
+    case 'vscode': {
+      console.log(chalk.green('  Agents are set up as VS Code custom agents.'));
+      console.log('');
+      console.log(chalk.dim('  Your agents in .github/agents/:'));
+      for (const [id, agent] of Object.entries(config.agents)) {
+        console.log(`    ${chalk.cyan(id)}.agent.md — ${agent.name}`);
       }
-      const { launchCursorAgents } = await import('../adapters/cursor.js');
-      await launchCursorAgents(config, root, opts);
+      console.log('');
+      console.log(`  ${chalk.bold('How to use:')}`);
+      console.log(`    1. Open this project in VS Code / Cursor`);
+      console.log(`    2. Open Chat (${chalk.bold('Cmd+L')})`);
+      console.log(`    3. Select an agent from the Chat dropdown`);
+      console.log(`    4. Run ${chalk.bold('agentxchain release')} to release the human lock`);
+      console.log(`    5. Agents coordinate via hooks — Stop hook hands off automatically`);
+      console.log('');
+      console.log(chalk.dim('  If agents don\'t appear, run: agentxchain generate'));
+      console.log('');
       break;
     }
     case 'claude-code': {
@@ -60,31 +67,8 @@ export async function startCommand(opts) {
       await launchClaudeCodeAgents(config, root, opts);
       break;
     }
-    case 'vscode': {
-      console.log(chalk.yellow('  VS Code adapter coming soon.'));
-      console.log(chalk.dim('  For now, use the seed prompts below in VS Code chat panels.'));
-      console.log('');
-      printPrompts(config, opts);
-      break;
-    }
     default:
-      console.log(chalk.red(`  Unknown IDE: ${ide}. Supported: cursor, vscode, claude-code`));
+      console.log(chalk.red(`  Unknown IDE: ${ide}. Supported: vscode, claude-code`));
       process.exit(1);
   }
 }
-
-function printPrompts(config, opts) {
-  const agents = opts.agent
-    ? { [opts.agent]: config.agents[opts.agent] }
-    : config.agents;
-
-  for (const [id, agent] of Object.entries(agents)) {
-    const prompt = generateSeedPrompt(id, agent, config);
-    console.log(chalk.dim('  ' + '─'.repeat(50)));
-    console.log(chalk.cyan(`  Agent: ${chalk.bold(id)} (${agent.name})`));
-    console.log(chalk.dim('  ' + '─'.repeat(50)));
-    console.log('');
-    console.log(prompt);
-    console.log('');
-  }
-}

package/src/commands/status.js

@@ -1,7 +1,5 @@
 import chalk from 'chalk';
 import { loadConfig, loadLock, loadState } from '../lib/config.js';
-import { getAgentStatus, loadSession } from '../adapters/cursor.js';
-import { getCursorApiKey } from '../lib/cursor-api-key.js';
 
 export async function statusCommand(opts) {
   const result = loadConfig();
@@ -31,7 +29,6 @@ export async function statusCommand(opts) {
   }
   console.log('');
 
-  // Lock
   if (lock) {
     if (lock.holder === 'human') {
       console.log(`  ${chalk.dim('Lock:')}     ${chalk.magenta('HUMAN')} — you hold the lock`);
@@ -51,45 +48,13 @@ export async function statusCommand(opts) {
   }
   console.log('');
 
-  // Cursor session info
-  const session = loadSession(root);
-  const apiKey = getCursorApiKey(root);
-  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}`);
-    if (!apiKey) {
-      console.log(`  ${chalk.dim('API key:')}  ${chalk.red('Missing')} (set CURSOR_API_KEY in .env for live statuses)`);
-    }
-    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;
-
-    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}`);
+    console.log(`    ${marker} ${label} — ${agent.name}`);
   }
 
   if (lock?.holder === 'human') {
@@ -104,17 +69,6 @@ function formatPhase(phase) {
   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]'),
-  };
-  return map[status] || chalk.dim(`[${status}]`);
-}
-
 function timeSince(iso) {
   const ms = Date.now() - new Date(iso).getTime();
   const sec = Math.floor(ms / 1000);

package/src/commands/stop.js

@@ -2,8 +2,6 @@ import { readFileSync, existsSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import chalk from 'chalk';
 import { loadConfig } from '../lib/config.js';
-import { deleteAgent, loadSession } from '../adapters/cursor.js';
-import { getCursorApiKey, printCursorApiKeyRequired } from '../lib/cursor-api-key.js';
 
 const SESSION_FILE = '.agentxchain-session.json';
 
@@ -12,44 +10,28 @@ export async function stopCommand() {
   if (!result) { console.log(chalk.red('  No agentxchain.json found.')); process.exit(1); }
 
   const { root } = result;
-  const session = loadSession(root);
+  const sessionPath = join(root, SESSION_FILE);
 
-  if (!session) {
+  if (!existsSync(sessionPath)) {
     console.log(chalk.yellow('  No active session found.'));
-    console.log(chalk.dim('  If agents are running, stop them manually.'));
+    console.log(chalk.dim('  If agents are running in VS Code / Cursor, close their chat sessions manually.'));
+    return;
+  }
+
+  let session;
+  try {
+    session = JSON.parse(readFileSync(sessionPath, 'utf8'));
+  } catch {
+    console.log(chalk.yellow('  Could not read session file.'));
     return;
   }
 
   console.log('');
-  console.log(chalk.bold(`  Stopping ${session.launched.length} agents (${session.ide})`));
+  console.log(chalk.bold(`  Stopping ${session.launched?.length || 0} agents (${session.ide || 'unknown'})`));
   console.log('');
-  let allStopped = true;
 
-  if (session.ide === 'cursor') {
-    const apiKey = getCursorApiKey(root);
-    if (!apiKey) {
-      printCursorApiKeyRequired('`agentxchain stop` for Cursor agents');
-      console.log(chalk.dim('  Session file was kept so you can retry after setting the key.'));
-      console.log('');
-      return;
-    }
-
-    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`));
-          allStopped = false;
-        }
-      } catch (err) {
-        console.log(chalk.red(`  ✗ ${agent.id}: ${err.message}`));
-        allStopped = false;
-      }
-    }
-  } else if (session.ide === 'claude-code') {
-    for (const agent of session.launched) {
+  if (session.ide === 'claude-code') {
+    for (const agent of (session.launched || [])) {
       if (agent.pid) {
         try {
           process.kill(agent.pid, 'SIGTERM');
@@ -59,22 +41,17 @@ export async function stopCommand() {
             console.log(chalk.dim(`  ${agent.id} (PID: ${agent.pid}) — already stopped`));
           } else {
             console.log(chalk.red(`  ✗ ${agent.id}: ${err.message}`));
-            allStopped = false;
           }
         }
       }
     }
+  } else {
+    console.log(chalk.dim('  For VS Code / Cursor agents, close the chat sessions manually.'));
   }
 
+  unlinkSync(sessionPath);
   console.log('');
-  const sessionPath = join(root, SESSION_FILE);
-  if (allStopped) {
-    if (existsSync(sessionPath)) unlinkSync(sessionPath);
-    console.log(chalk.dim('  Session file removed.'));
-    console.log(chalk.green('  All agents stopped.'));
-  } else {
-    console.log(chalk.yellow('  Some agents could not be stopped.'));
-    console.log(chalk.dim('  Session file was kept so you can retry `agentxchain stop`.'));
-  }
+  console.log(chalk.dim('  Session file removed.'));
+  console.log(chalk.green('  Done.'));
   console.log('');
 }

package/src/commands/watch.js

@@ -5,8 +5,6 @@ import { fileURLToPath } from 'url';
 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';
-import { getCursorApiKey, printCursorApiKeyRequired } from '../lib/cursor-api-key.js';
 
 export async function watchCommand(opts) {
   if (opts.daemon && process.env.AGENTXCHAIN_WATCH_DAEMON !== '1') {
@@ -24,17 +22,9 @@ export async function watchCommand(opts) {
   const interval = config.rules?.watch_interval_ms || 5000;
   const ttlMinutes = config.rules?.ttl_minutes || 10;
   const agentIds = Object.keys(config.agents);
+
   if (agentIds.length === 0) {
     console.log(chalk.red('  No agents configured in agentxchain.json.'));
-    console.log(chalk.dim('  Add an agent with: agentxchain config --add-agent'));
-    process.exit(1);
-  }
-  const apiKey = getCursorApiKey(root);
-  const session = loadSession(root);
-  const hasCursorSession = session?.ide === 'cursor' && session?.launched?.length > 0;
-
-  if (hasCursorSession && !apiKey) {
-    printCursorApiKeyRequired('`agentxchain watch` with a Cursor session');
     process.exit(1);
   }
 
@@ -43,13 +33,11 @@ export async function watchCommand(opts) {
   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(chalk.dim(`  Mode:    Local file watcher + trigger file`));
   console.log('');
   console.log(chalk.cyan('  Watching lock.json... (Ctrl+C to stop)'));
+  console.log(chalk.dim('  Note: In VS Code/Cursor, the Stop hook coordinates turns automatically.'));
+  console.log(chalk.dim('  This watch process is a fallback for non-IDE environments.'));
   console.log('');
 
   let lastState = null;
@@ -61,7 +49,6 @@ export async function watchCommand(opts) {
 
       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;
@@ -70,22 +57,12 @@ export async function watchCommand(opts) {
           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.');
@@ -95,45 +72,20 @@ export async function watchCommand(opts) {
         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)}.`);
-        let wakeSucceeded = false;
-
-        if (hasCursorSession && apiKey) {
-          wakeSucceeded = await wakeCursorAgent(apiKey, session, next, lock, config, root);
-        } else {
-          writeTrigger(root, next, lock, config);
-          wakeSucceeded = true;
-        }
-
-        if (wakeSucceeded) {
-          lastState = stateKey;
-        } else {
-          log('warn', `Wake for ${next} failed. Will retry next poll.`);
-        }
+        log('free', `Lock free (released by ${lock.last_released_by || 'none'}). Next: ${chalk.bold(next)}.`);
+        writeTrigger(root, next, lock, config);
+        lastState = stateKey;
       }
     } catch (err) {
       log('error', err.message);
@@ -151,40 +103,6 @@ export async function watchCommand(opts) {
   });
 }
 
-async function wakeCursorAgent(apiKey, session, agentId, lock, config, root) {
-  const cloudAgent = session.launched.find(a => a.id === agentId);
-  if (!cloudAgent) {
-    log('warn', `No Cursor cloud agent found for "${agentId}". Using trigger file.`);
-    writeTrigger(root, agentId, lock, config);
-    return true;
-  }
-
-  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})`);
-    return true;
-  } catch (err) {
-    log('error', `Failed to wake ${agentId}: ${err.message}`);
-    return false;
-  }
-}
-
 function pickNextAgent(lock, config) {
   const agentIds = Object.keys(config.agents);
   if (agentIds.length === 0) return null;
@@ -229,7 +147,6 @@ function log(type, msg) {
   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 '),

package/src/adapters/cursor.js

@@ -1,182 +0,0 @@
-import { writeFileSync, readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import chalk from 'chalk';
-import { generateSeedPrompt } from '../lib/seed-prompt.js';
-import { getRepoUrl, getCurrentBranch } from '../lib/repo.js';
-import { getCursorApiKey, printCursorApiKeyRequired } from '../lib/cursor-api-key.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 = getCursorApiKey(root);
-
-  if (!apiKey) {
-    printCursorApiKeyRequired('`agentxchain start --ide cursor`');
-    return [];
-  }
-
-  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 || getCurrentBranch(root) || 'main';
-  console.log(chalk.dim(`  Cursor source: ${repoUrl} @ ${ref}`));
-  const agents = filterAgents(config, opts.agent);
-  const launched = [];
-  let branchErrorCount = 0;
-
-  for (const [id, agent] of Object.entries(agents)) {
-    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: authHeaders(apiKey),
-        body: JSON.stringify(body)
-      });
-
-      if (!res.ok) {
-        const errBody = await res.text();
-        console.log(chalk.red(`  ✗ ${id}: ${res.status} ${errBody}`));
-        if (errBody.includes('Failed to verify existence of branch')) {
-          branchErrorCount += 1;
-        }
-        continue;
-      }
-
-      const data = await res.json();
-      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(`  ✗ ${id}: ${err.message}`));
-    }
-  }
-
-  if (launched.length > 0) {
-    saveSession(root, launched, repoUrl, ref);
-  }
-
-  if (launched.length === 0 && branchErrorCount > 0) {
-    console.log('');
-    console.log(chalk.yellow('  Launch failed because the branch ref is invalid for this repository.'));
-    console.log(chalk.dim('  Fix by setting the branch explicitly in agentxchain.json:'));
-    console.log(chalk.bold('  "cursor": { "ref": "your-default-branch" }'));
-    console.log(chalk.dim('  Or switch to the target branch locally, then re-run start.'));
-    console.log(chalk.dim('  If the branch exists on GitHub, verify your Cursor account has GitHub access'));
-    console.log(chalk.dim('  to this repository (Cursor Settings -> GitHub integration).'));
-    console.log('');
-  }
-
-  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, ref) {
-  const session = {
-    launched,
-    started_at: new Date().toISOString(),
-    ide: 'cursor',
-    repo: repoUrl,
-    ref
-  };
-  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;
-}
-
-// No prompt fallback here by design.
-// Cursor mode is strict: an API key is required.

package/src/lib/cursor-api-key.js

@@ -1,61 +0,0 @@
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import chalk from 'chalk';
-
-function parseEnvFile(raw) {
-  const out = {};
-  const lines = raw.split(/\r?\n/);
-
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-
-    const eq = trimmed.indexOf('=');
-    if (eq === -1) continue;
-
-    const key = trimmed.slice(0, eq).trim();
-    let value = trimmed.slice(eq + 1).trim();
-
-    if (
-      (value.startsWith('"') && value.endsWith('"')) ||
-      (value.startsWith("'") && value.endsWith("'"))
-    ) {
-      value = value.slice(1, -1);
-    }
-
-    if (key) out[key] = value;
-  }
-
-  return out;
-}
-
-export function hydrateEnvFromProject(root) {
-  if (!root) return;
-
-  const envPath = join(root, '.env');
-  if (!existsSync(envPath)) return;
-
-  try {
-    const parsed = parseEnvFile(readFileSync(envPath, 'utf8'));
-    for (const [k, v] of Object.entries(parsed)) {
-      if (!process.env[k] && v !== undefined) process.env[k] = v;
-    }
-  } catch {
-    // Non-fatal: commands still work with shell env vars.
-  }
-}
-
-export function getCursorApiKey(root) {
-  hydrateEnvFromProject(root);
-  const key = process.env.CURSOR_API_KEY?.trim();
-  return key || null;
-}
-
-export function printCursorApiKeyRequired(commandName = 'this command') {
-  console.log('');
-  console.log(chalk.red(`  CURSOR_API_KEY is required for ${commandName}.`));
-  console.log(chalk.dim('  Set it once in your project root .env file:'));
-  console.log(`  ${chalk.bold('CURSOR_API_KEY=your_key')}`);
-  console.log(chalk.dim('  You can get a key from: cursor.com/settings -> Cloud Agents'));
-  console.log('');
-}