hive-am 1.9.1 → 1.10.0

package/CHANGELOG.md

@@ -6,6 +6,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 
 ## [Unreleased]
 
+## [1.10.0] - 2026-10-22
+
+### Added
+
+- **Cursor as a fourth provider.** Pick **Cursor** (`cursor-agent`) for an agent, chat with it and see its text, thinking and tool calls live; the conversation continues between messages (`--resume`) and after a restart, and is read back from Cursor's own transcripts (text and tool calls; Cursor does not store tool output, thinking or usage, which are only shown live). Models come from `cursor-agent --list-models`, and a new Cursor agent starts on `auto`, the only model a free plan runs; Cursor has no effort selector because the level is part of the model id. Agents with hive tools get them over MCP under every permission: hive-am adds a `hive` entry to the folder's `.cursor/mcp.json`, keeps your other servers there and hides the file from `git status`. Permissions are Cursor's own rules in a config folder per agent: **Read-only** writes nothing and runs no shell, **Edit files** edits the project but never `.git` or keys and runs no shell, **Full access** runs everything. With Cursor, **Edit files** cannot stop the file tool from writing outside the agent's folder. It needs `cursor-agent` installed and signed in (`cursor-agent login`).
+
 ## [1.9.1] - 2026-10-21
 
 ### Changed
@@ -277,7 +283,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 - Complete documentation in English and Spanish.
 - npm package with the `hive-am` command.
 
-[Unreleased]: https://github.com/hughcbscrt/hive-am/compare/v1.9.1...HEAD
+[Unreleased]: https://github.com/hughcbscrt/hive-am/compare/v1.10.0...HEAD
+[1.10.0]: https://github.com/hughcbscrt/hive-am/compare/v1.9.1...v1.10.0
 [1.9.1]: https://github.com/hughcbscrt/hive-am/compare/v1.9.0...v1.9.1
 [1.9.0]: https://github.com/hughcbscrt/hive-am/compare/v1.8.0...v1.9.0
 [1.8.0]: https://github.com/hughcbscrt/hive-am/compare/v1.7.0...v1.8.0

package/README.md

@@ -6,7 +6,7 @@
 
 <p align="center">
   <strong>A colony of coding agents on your machine.</strong><br />
-  Orchestrators and subagents over <b>Claude Code</b>, <b>OpenCode</b> and <b>Kiro</b>, with the real sessions of each CLI, a browser UI and Telegram.
+  Orchestrators and subagents over <b>Claude Code</b>, <b>OpenCode</b>, <b>Kiro</b> and <b>Cursor</b>, with the real sessions of each CLI, a browser UI and Telegram.
 </p>
 
 <p align="center">
@@ -26,7 +26,7 @@ have installed; it does not replace them and it never copies your conversations
 
 ## Highlights
 
-- **Three providers, one place.** Claude Code, OpenCode and Kiro agents side by side, each with its own model.
+- **Four providers, one place.** Claude Code, OpenCode, Kiro and Cursor agents side by side, each with its own model.
 - **Real sessions.** An agent stores only a pointer (`provider`, `session_id`, `cwd`). The transcript lives in the CLI's own store and is read back from there. After a restart every agent resumes its real session.
 - **Orchestration.** An orchestrator delegates to the workers connected to it on the Relations canvas. Every delegation runs in a fresh native session of the worker, and the rule is enforced on the server, not just requested.
 - **Colonies.** Group agents on a honeycomb map and lend them defaults: working folder, permissions, skills and a shared prompt. Each agent can opt out per field.
@@ -35,7 +35,7 @@ have installed; it does not replace them and it never copies your conversations
 - **Telegram.** Link a bot to an agent: private chats, groups and topics, one shared session across all of them. In groups the agent can listen to everything and speak only when it adds something; people can mute it per thread and bring it back.
 - **Slack.** The same over Socket Mode (no public URL): DMs and channels, the agent answers in a thread opened on the message, scheduled messages land in the channel, `/hive` slash commands.
 - **Files and images.** People send documents and photos to the agent; the agent sends files back. An optional image model can describe pictures for models that cannot see them.
-- **Permissions that hold.** *Read-only*, *Edit files* and *Full access* are enforced by the CLI itself in all three providers.
+- **Permissions that hold.** *Read-only*, *Edit files* and *Full access* are enforced by the CLI itself in all four providers. With Cursor they are `deny` rules, and *Edit files* cannot keep its file tool inside the agent's folder.
 - **Changes explorer.** A Git tab per agent: file tree with highlighting, diff viewer, history, commit, pull, push and branches. Comment on lines of the diff and send them to the agent in one message.
 - **Resources.** Servers, Docker containers, HTTP requests (`.http` files) and clusters that group them live in a colony as hexagons: start, stop, read logs, run requests; agents can look after them, and an agent with the Database management skill can look inside a database and run SQL, within its permission.
 - **Terminals.** A bottom panel (Ctrl+`) with real shells and object logs, reachable only from this machine.
@@ -68,12 +68,13 @@ More in the [user manual](docs/manual/en/README.md).
 | Claude Code | `claude -p --output-format stream-json --resume <id>` | `~/.claude/projects/*/<id>.jsonl` |
 | OpenCode | `opencode run --format json -s <id>` | `~/.local/share/opencode/opencode.db` (`session_message`) |
 | Kiro | `kiro-cli chat --no-interactive --output-format stream-json --resume-id <id>` | `~/.kiro/sessions/cli/<id>.jsonl` |
+| Cursor | `cursor-agent -p --output-format stream-json --resume <id>` | `~/.cursor/projects/<folder>/agent-transcripts/<id>/<id>.jsonl` |
 
 Plain CLI processes, one per turn, not ACP. Turns are serialized per agent.
 
 ## Quick start
 
-You need **Node 20+** (macOS or Linux) and at least one of the three CLIs installed and logged in (`claude`, `opencode` or `kiro-cli`).
+You need **Node 20+** (macOS or Linux) and at least one of the four CLIs installed and logged in (`claude`, `opencode`, `kiro-cli` or `cursor-agent`).
 
 ### From npm
 
@@ -108,13 +109,14 @@ Data lives in `~/.hive-am/hive-am.db` (override with `HIVE_AM_HOME`). The server
 
 ## Permission levels
 
-| Level | Claude Code | OpenCode | Kiro |
-|---|---|---|---|
-| **Read-only** | `--permission-mode plan` | edit, shell and subagents denied | no tool trusted |
-| **Edit files** | `acceptEdits`, `.git` and keys protected | edits (`.env` included), no shell, only inside the agent's folder | same |
-| **Full access** | `bypassPermissions` | no restrictions | `--trust-all-tools` |
+| Level | Claude Code | OpenCode | Kiro | Cursor |
+|---|---|---|---|---|
+| **Read-only** | `--permission-mode plan` | edit, shell and subagents denied | no tool trusted | `--mode plan`, writes and shell denied |
+| **Edit files** | `acceptEdits`, `.git` and keys protected | edits (`.env` included), no shell, only inside the agent's folder | same | edits (`.env` included), no shell, `.git` and keys denied |
+| **Full access** | `bypassPermissions` | no restrictions | `--trust-all-tools` | `--force` |
 
-In *Edit files* the agent cannot touch `.git` or private keys (`*.pem`, `*.key`) and cannot write outside its folder. Details and the
+In *Edit files* the agent cannot touch `.git` or private keys (`*.pem`, `*.key`) and cannot write outside its folder, except with
+Cursor: its file tool can still write outside the folder, because Cursor has no rule for that. Details and the
 few differences between providers are in [docs/06](docs/reference/en/06-providers.md) and [docs/12](docs/reference/en/12-operations-and-troubleshooting.md).
 
 ## Connections (Telegram and Slack)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hive-am",
-  "version": "1.9.1",
-  "description": "A colony of coding agents: orchestrators and subagents over Claude Code, OpenCode and Kiro, with real session resume, a browser UI and Telegram.",
+  "version": "1.10.0",
+  "description": "A colony of coding agents: orchestrators and subagents over Claude Code, OpenCode, Kiro and Cursor, with real session resume, a browser UI and Telegram.",
   "keywords": [
     "ai-agents",
     "coding-agents",

package/server/dist/connections/vision.js

@@ -1,9 +1,10 @@
 import { runners } from '../providers/index.js';
+import { isProvider } from '../services/providers.js';
 import { inboxDir } from './files.js';
 const MAX_IMAGES = 3; // per message
 const MAX_IMAGE_BYTES = 8_000_000;
 const TIMEOUT_MS = 120_000;
-export const validVision = (v) => !!v && typeof v === 'object' && ['claude', 'opencode', 'kiro'].includes(v.provider) && typeof v.model === 'string';
+export const validVision = (v) => !!v && typeof v === 'object' && isProvider(v.provider) && typeof v.model === 'string';
 async function describe(agent, cfg, path) {
     // A throwaway agent in the agent's own id (so its inbox is readable) and read-only: it can only look at the file.
     const helper = { ...agent, provider: cfg.provider, model: cfg.model, session_id: null, session_cwd: null, instr_hash: null, permission: 'plan', cwd: inboxDir(agent.id), system_prompt: '', skill_ids: [], skill_loads: {}, worker_ids: [] };

package/server/dist/efforts.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { DATA_DIR } from './db.js';
 /**
- * Reasoning effort: how hard the model thinks in a turn. Claude Code and Kiro take `--effort <level>`; OpenCode takes it as a variant of the
+ * Reasoning effort: how hard the model thinks in a turn. Claude Code and Kiro take `--effort <level>`; Cursor takes none (the level is part of its model id); OpenCode takes it as a variant of the
  * model (`provider/model#variant`) and the variants are whatever the chosen model has, so what OpenCode and Kiro report is learned and stored
  * on disk (`reasoning-efforts.json`), next to what is learned about context windows. An empty effort means the CLI's own default: no flag and no `#variant`.
  */
@@ -50,6 +50,8 @@ export const learnedEfforts = (provider, model) => load()[key(provider, model)]
 /** The levels the form offers for a provider and (for OpenCode and Kiro) a model. */
 export function effortOptions(provider, model) {
     const shared = EFFORTS.map((id) => ({ id, level: id }));
+    if (provider === 'cursor')
+        return { options: [], known: true }; // the level is part of Cursor's model id
     if (provider === 'claude')
         return { options: shared, known: true };
     if (provider === 'kiro') {
@@ -67,6 +69,8 @@ export function checkEffort(provider, model, effort) {
         return null;
     if (typeof effort !== 'string')
         return 'effort must be text';
+    if (provider === 'cursor')
+        return 'Cursor takes no effort: pick a model whose id names the level (gpt-5.3-codex-high).';
     if (provider === 'opencode') {
         if (model.includes('#'))
             return 'This model id already names its variant: leave the effort empty.';

package/server/dist/history/cursor.js

@@ -0,0 +1,91 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { stripInstructions } from '../providers/preamble.js';
+import { jsonLines } from './lines.js';
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const projectsDir = () => join(process.env.CURSOR_DATA_DIR?.trim() || join(homedir(), '.cursor'), 'projects');
+/** How Cursor names a folder under `~/.cursor/projects`: every run of characters that are not letters or digits becomes one dash. */
+export const cursorSlug = (cwd) => cwd.replace(/[^a-zA-Z0-9]/g, '-').replace(/-+/g, '-').replace(/^-+|-+$/g, '');
+/** The transcript of a conversation: under the folder's own project, else under any project (the folder may have been renamed). */
+export function cursorFile(cwd, sessionId) {
+    if (!UUID.test(sessionId))
+        return null;
+    const rel = join('agent-transcripts', sessionId, `${sessionId}.jsonl`);
+    const own = join(projectsDir(), cursorSlug(cwd), rel);
+    if (existsSync(own))
+        return own;
+    try {
+        for (const p of readdirSync(projectsDir())) {
+            const f = join(projectsDir(), p, rel);
+            if (existsSync(f))
+                return f;
+        }
+    }
+    catch { /* no projects yet */ }
+    return null;
+}
+/** Changes when the conversation changes (used to cache what is computed from it). */
+export function cursorSig(cwd, sessionId) {
+    const f = cursorFile(cwd, sessionId);
+    if (!f)
+        return null;
+    try {
+        const st = statSync(f);
+        return `${st.mtimeMs}:${st.size}`;
+    }
+    catch {
+        return null;
+    }
+}
+/** What the person wrote: Cursor wraps it as `<timestamp>…</timestamp>\n<user_query>\n…\n</user_query>`, and our instructions block comes first inside. */
+export function cursorUserText(text) {
+    const q = /<user_query>\n?([\s\S]*?)\n?<\/user_query>/.exec(text);
+    return stripInstructions((q ? q[1] : text.replace(/^<timestamp>[\s\S]*?<\/timestamp>\s*/, '')).trim()).trim();
+}
+/** A tool as hive-am shows it: a call to an MCP server (`CallDynamicTool`) is named like Claude's (`mcp__<server>__<tool>`). */
+export function cursorTool(name, input) {
+    if (name === 'CallDynamicTool' && input?.namespace && input?.toolName)
+        return { name: `mcp__${input.namespace}__${input.toolName}`, input: input.arguments ?? {} };
+    return { name, input };
+}
+/**
+ * Cursor's transcript (`~/.cursor/projects/<folder>/agent-transcripts/<id>/<id>.jsonl`): user and assistant messages with their text and tool calls.
+ * It keeps no thinking, tool results, ids, usage or times: those are only seen while the turn runs. `SendToCall` repeats the reply's text, so it is left out.
+ */
+export function readCursor(cwd, sessionId) {
+    const file = cursorFile(cwd, sessionId);
+    if (!file)
+        return [];
+    const out = [];
+    let n = 0;
+    for (const e of jsonLines(file)) {
+        const content = e.message?.content;
+        if (!Array.isArray(content))
+            continue;
+        const id = `${sessionId}:${n++}`;
+        if (e.role === 'user') {
+            const text = cursorUserText(content.filter((b) => b?.type === 'text').map((b) => b.text ?? '').join(''));
+            if (text)
+                out.push({ id, role: 'user', ts: null, blocks: [{ type: 'text', text }] });
+        }
+        else if (e.role === 'assistant') {
+            const blocks = [];
+            for (const b of content) {
+                if (b?.type === 'text' && b.text)
+                    blocks.push({ type: 'text', text: b.text });
+                else if (b?.type === 'tool_use' && b.name !== 'SendToCall')
+                    blocks.push({ type: 'tool', id: `${id}:${blocks.length}`, ...cursorTool(b.name ?? 'tool', b.input) });
+            }
+            if (!blocks.length)
+                continue;
+            // One reply arrives as several lines (one per step): they are one message, as in the live chat.
+            const prev = out[out.length - 1];
+            if (prev?.role === 'assistant')
+                prev.blocks.push(...blocks);
+            else
+                out.push({ id, role: 'assistant', ts: null, blocks });
+        }
+    }
+    return out;
+}

package/server/dist/history/index.js

@@ -1,10 +1,12 @@
 import { claudeSig, readClaude } from './claude.js';
 import { opencodeSig, readOpencode } from './opencode.js';
 import { kiroSig, readKiro } from './kiro.js';
+import { cursorSig, readCursor } from './cursor.js';
 export const historyReaders = {
     claude: { read: readClaude, sig: claudeSig },
     opencode: { read: (_cwd, id) => readOpencode(id), sig: (_cwd, id) => opencodeSig(id) },
     kiro: { read: (_cwd, id) => readKiro(id), sig: (_cwd, id) => kiroSig(id) },
+    cursor: { read: readCursor, sig: cursorSig },
 };
 export function readHistory(a, sessionId = a.session_id) {
     if (!sessionId)

package/server/dist/http/routes/types.js

@@ -3,7 +3,7 @@ import { spawnFromType } from '../../services/agents.js';
 import { body } from '../body.js';
 import { bad, notFound } from '../errors.js';
 import { route } from '../router.js';
-import { isProvider } from '../../services/providers.js';
+import { defaultModel, isProvider } from '../../services/providers.js';
 import { checkEffort } from '../../efforts.js';
 import { requireName, text, validateAgentInput } from '../validate.js';
 route('GET', '/api/types', () => types.list());
@@ -12,6 +12,8 @@ route('POST', '/api/types', async ({ req }) => {
     const name = requireName(p.name);
     if (!isProvider(p.provider))
         throw bad('Pick a provider');
+    if (p.model === undefined)
+        p.model = defaultModel(p.provider);
     const why = checkEffort(p.provider, text(p.model), p.effort);
     if (why)
         throw bad(why);

package/server/dist/instructions.js

@@ -35,8 +35,8 @@ export function mcpCaps(a) {
         caps.push('skills');
     return caps;
 }
-/** How each CLI names the tools of the `hive` MCP server. OpenCode exposes them as `tools.<server>.<tool>`, Kiro as `@<server>/<tool>`. */
-const toolName = (provider, tool) => (provider === 'opencode' ? `tools.hive.${tool}` : provider === 'kiro' ? `@hive/${tool}` : `mcp__hive__${tool}`);
+/** How each CLI names the tools of the `hive` MCP server. OpenCode exposes them as `tools.<server>.<tool>`, Kiro as `@<server>/<tool>`, Cursor as `<server>-<tool>`. */
+const toolName = (provider, tool) => (provider === 'opencode' ? `tools.hive.${tool}` : provider === 'kiro' ? `@hive/${tool}` : provider === 'cursor' ? `hive-${tool}` : `mcp__hive__${tool}`);
 export function composeInstructions(a, delegated = false) {
     const parts = [];
     // Identity first: the underlying CLI has its own persona, but inside hive-am this agent has a name and a place.

package/server/dist/mcp-config.js

@@ -21,3 +21,13 @@ export const kiroProfile = (agentId, name, caps, access = { trusted: [] }) => ({
     tools: ['*'], allowedTools: [...access.trusted, ...(caps.length ? ['@hive'] : [])], includeMcpJson: false,
     ...(access.toolsSettings ? { toolsSettings: access.toolsSettings } : {}),
 });
+/**
+ * The `hive` server in a Cursor `mcp.json` (Cursor reads it from the project folder). Every agent in the folder shares the same entry: the values
+ * come from the process env (`${env:...}`), which each turn sets for its own agent.
+ */
+export const cursorMcpServer = () => ({
+    command: process.execPath, args: [script],
+    env: { HIVE_AGENT_ID: '${env:HIVE_AGENT_ID}', HIVE_AM_API: '${env:HIVE_AM_API}', HIVE_CAPS: '${env:HIVE_CAPS}' },
+});
+/** The env a Cursor turn passes so the shared `hive` entry starts as this agent (no caps: the server offers no tools). */
+export const cursorMcpEnv = (agentId, caps) => env(agentId, caps);

package/server/dist/models.js

@@ -11,6 +11,11 @@ const CLAUDE = [
     { id: 'claude-sonnet-5-5', label: 'Sonnet 5.5' },
     { id: 'claude-haiku-4-5-20251001', label: 'Haiku 4.5' },
 ];
+/** The models `cursor-agent --list-models` prints. */
+export function parseCursorModels(stdout) {
+    return stdout.replace(/\x1b\[[0-9;]*m/g, '').split('\n').map((l) => /^([\w.\-\[\]=,]+) - (.+)$/.exec(l.trim())).filter((m) => !!m)
+        .map((m) => ({ id: m[1], label: m[2].replace(/\s*\((?:current|default)[^)]*\)\s*$/, '').replace(/[\u200b\u200c\u200d\ufeff]/g, '').trim() }));
+}
 async function discover(p) {
     try {
         if (p === 'claude')
@@ -19,6 +24,11 @@ async function discover(p) {
             const { stdout } = await run('opencode', ['models'], { timeout: 20000, maxBuffer: 4e6 });
             return stdout.split('\n').map((s) => s.trim()).filter((s) => /^[\w.-]+\/\S+/.test(s)).map((id) => ({ id, label: id }));
         }
+        if (p === 'cursor') {
+            // `id - Label`, one per line, with a "(current, default)" note on the one in use.
+            const { stdout } = await run('cursor-agent', ['--list-models'], { timeout: 20000, maxBuffer: 4e6 });
+            return parseCursorModels(stdout);
+        }
         const { stdout } = await run('kiro-cli', ['chat', '--list-models', '--format', 'json'], { timeout: 20000, maxBuffer: 4e6 });
         const j = JSON.parse(stdout);
         const list = Array.isArray(j) ? j : j.models ?? [];

package/server/dist/providers/cursor.js

@@ -0,0 +1,197 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join } from 'node:path';
+import { DATA_DIR } from '../db.js';
+import { spawnJson } from './spawn.js';
+import { asPositional, withInstructions } from './preamble.js';
+import { cursorMcpEnv, cursorMcpServer } from '../mcp-config.js';
+import { cursorTool } from '../history/cursor.js';
+/**
+ * What Cursor may do for each permission level, as the `permissions` of its config. A turn under `-p` cannot ask, and without `--force` every MCP call is
+ * refused, so every turn runs with `--force` and these rules (which `--force` does not override) set the limits: read-only writes nothing and runs no
+ * shell, even if the model switches out of plan mode; editing writes project files (including .env, never .git or keys) and runs no shell, because
+ * Cursor's sandbox lets a command write anywhere. Its file tool can still write outside the agent's folder: Cursor has no rule for that.
+ */
+export function cursorPermissions(level) {
+    if (level === 'bypassPermissions')
+        return null;
+    if (level === 'plan')
+        return { allow: [], deny: ['Write(**)', 'Shell(*)'] };
+    return { allow: [], deny: ['Shell(*)', 'Write(**/.git/**)', 'Write(**/*.pem)', 'Write(**/*.key)'] };
+}
+/** Where Cursor keeps its own config (`cli-config.json`): the person's settings are copied from there. */
+const userConfigDir = () => process.env.CURSOR_CONFIG_DIR?.trim() || (process.env.XDG_CONFIG_HOME?.trim() ? join(process.env.XDG_CONFIG_HOME, 'cursor') : join(homedir(), '.cursor'));
+/**
+ * A config folder for this agent (`CURSOR_CONFIG_DIR`): the person's own `cli-config.json` with the permission rules of the level. Rewritten every turn,
+ * so a changed permission applies to the next message. Sign-in and conversations live elsewhere and are not affected.
+ */
+function cursorConfigDir(agentId, rules) {
+    let cfg = { version: 1 };
+    try {
+        cfg = JSON.parse(readFileSync(join(userConfigDir(), 'cli-config.json'), 'utf8'));
+    }
+    catch { /* no config yet: Cursor fills in the rest */ }
+    const dir = join(DATA_DIR, 'cursor', agentId);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'cli-config.json'), JSON.stringify({ ...cfg, permissions: rules }, null, 2));
+    return dir;
+}
+const excluded = new Set();
+/** Keeps the generated `.cursor/mcp.json` out of `git status`: added once to the repository's `.git/info/exclude` (local, never committed). */
+function excludeFromGit(cwd) {
+    if (excluded.has(cwd))
+        return;
+    excluded.add(cwd);
+    try {
+        const git = (...a) => execFileSync('git', a, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 }).trim();
+        const pathOut = git('rev-parse', '--git-path', 'info/exclude');
+        const file = isAbsolute(pathOut) ? pathOut : join(cwd, pathOut);
+        const line = `/${git('rev-parse', '--show-prefix')}.cursor/mcp.json`;
+        const now = existsSync(file) ? readFileSync(file, 'utf8') : '';
+        if (now.split('\n').includes(line))
+            return;
+        mkdirSync(join(file, '..'), { recursive: true });
+        appendFileSync(file, `${now && !now.endsWith('\n') ? '\n' : ''}${line}\n`);
+    }
+    catch { /* not a repository */ }
+}
+/**
+ * Cursor reads MCP servers only from `<folder>/.cursor/mcp.json` (or the person's global one). The `hive` entry is merged into whatever servers the
+ * person has there, and the file is written only when it changes.
+ */
+export function writeCursorMcp(cwd) {
+    const dir = join(cwd, '.cursor');
+    const file = join(dir, 'mcp.json');
+    let cfg = {};
+    const before = existsSync(file) ? readFileSync(file, 'utf8') : '';
+    if (before) {
+        try {
+            cfg = JSON.parse(before);
+        }
+        catch {
+            return;
+        }
+    } // a file the person is editing is not overwritten
+    const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+    if (!isObject(cfg) || (cfg.mcpServers !== undefined && !isObject(cfg.mcpServers)))
+        return; // nor one that is not a config (`null`, a list, a number)
+    const next = JSON.stringify({ ...cfg, mcpServers: { ...(cfg.mcpServers ?? {}), hive: cursorMcpServer() } }, null, 2);
+    if (next !== before) {
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(file, next);
+    }
+    excludeFromGit(cwd);
+}
+/** A tool as hive-am shows it: the key of a `tool_call` (`shellToolCall`) is the tool, named as Cursor's transcript names it (`Shell`). */
+export function cursorStreamTool(call) {
+    const key = Object.keys(call ?? {}).find((k) => k.endsWith('ToolCall'));
+    if (!key)
+        return null;
+    const a = call[key]?.args ?? {};
+    const base = key.slice(0, -'ToolCall'.length);
+    if (base === 'mcp')
+        return cursorTool('CallDynamicTool', { namespace: a.providerIdentifier ?? a.serverIdentifier, toolName: a.toolName, arguments: a.args });
+    if (base === 'shell')
+        return { name: 'Shell', input: { command: a.command, ...(a.workingDirectory ? { cwd: a.workingDirectory } : {}), ...(a.timeout ? { timeout: a.timeout } : {}) } };
+    if (base === 'edit' && typeof a.streamContent === 'string')
+        return { name: 'Write', input: { path: a.path, contents: a.streamContent } };
+    const { toolCallId: _id, ...input } = a;
+    return { name: base.charAt(0).toUpperCase() + base.slice(1), input };
+}
+/** What a finished tool returned, and whether it failed: anything but `success` (`rejected`, `permissionDenied`, `error`…) is a failure. */
+export function cursorToolResult(call) {
+    const key = Object.keys(call ?? {}).find((k) => k.endsWith('ToolCall'));
+    const r = (key && call[key]?.result) ?? {};
+    const kind = Object.keys(r)[0] ?? '';
+    const v = r[kind] ?? {};
+    if (kind !== 'success')
+        return { output: String(v.error ?? v.reason ?? v.message ?? (kind || 'no result')), error: true };
+    if (key === 'mcpToolCall') {
+        const text = (Array.isArray(v.content) ? v.content : []).map((c) => c?.text?.text ?? c?.text ?? '').filter((t) => typeof t === 'string' && t).join('\n');
+        return { output: text, error: !!v.isError };
+    }
+    if (key === 'shellToolCall') {
+        const out = v.interleavedOutput || [v.stdout, v.stderr].filter(Boolean).join('\n');
+        return { output: `${out}${v.exitCode ? `${out ? '\n' : ''}Exit code: ${v.exitCode}` : ''}`, error: false };
+    }
+    if (typeof v.message === 'string')
+        return { output: v.message, error: false };
+    if (typeof v.content === 'string')
+        return { output: v.content, error: false };
+    return { output: JSON.stringify(v), error: false };
+}
+/** Cursor CLI: `cursor-agent -p --output-format stream-json --stream-partial-output`; the session comes in `system/init` and is resumed by id. */
+export async function* runCursor(o) {
+    const { agent } = o;
+    const args = ['-p', '--output-format', 'stream-json', '--stream-partial-output', '--trust', '--workspace', agent.cwd, '--force'];
+    if (agent.permission === 'plan')
+        args.push('--mode', 'plan');
+    const env = { ...cursorMcpEnv(agent.id, o.mcpCaps) };
+    const rules = cursorPermissions(agent.permission);
+    if (rules)
+        env.CURSOR_CONFIG_DIR = cursorConfigDir(agent.id, rules);
+    if (o.mcpCaps.length) {
+        writeCursorMcp(agent.cwd);
+        args.push('--approve-mcps');
+    }
+    if (agent.session_id)
+        args.push('--resume', agent.session_id);
+    if (agent.model)
+        args.push('--model', agent.model);
+    // No effort: the reasoning level is part of Cursor's model id (`gpt-5.3-codex-high`).
+    const prompt = withInstructions(o.prompt, o.instructions, !!agent.session_id, o.refreshInstructions);
+    // The prompt goes last; asPositional keeps a leading dash from being read as an option (see preamble.ts).
+    args.push(asPositional(prompt));
+    let sawSession = false;
+    let model;
+    // With --stream-partial-output the text comes in pieces (`timestamp_ms`, no `model_call_id`) and each stretch then once more whole: before a tool call
+    // with a `model_call_id`, at the end without `timestamp_ms`. A whole copy after pieces is skipped; without pieces before it (no partial output) it is the text.
+    let streamed = false;
+    // An unknown model is reported first and followed by the whole list of models: the start of stderr is what matters.
+    for await (const ev of spawnJson({ cmd: 'cursor-agent', args, cwd: agent.cwd, env, signal: o.signal, stderrHead: true })) {
+        if (ev.session_id && !sawSession) {
+            sawSession = true;
+            yield { t: 'session', sessionId: ev.session_id };
+        }
+        if (ev.type === 'system' && ev.subtype === 'init')
+            model = ev.model;
+        else if (ev.type === 'thinking') {
+            if (ev.subtype === 'delta' && ev.text)
+                yield { t: 'thinking', delta: ev.text };
+        }
+        else if (ev.type === 'assistant') {
+            const text = (ev.message?.content ?? []).filter((b) => b?.type === 'text').map((b) => b.text ?? '').join('');
+            const whole = ev.timestamp_ms === undefined || ev.model_call_id !== undefined;
+            if (whole && streamed)
+                streamed = false;
+            else if (text) {
+                streamed = !whole;
+                yield { t: 'text', delta: text };
+            }
+        }
+        else if (ev.type === 'tool_call') {
+            const id = String(ev.call_id ?? ev.tool_call?.toolCallId ?? '');
+            if (ev.subtype === 'started') {
+                const tool = cursorStreamTool(ev.tool_call);
+                if (tool)
+                    yield { t: 'tool', id, ...tool };
+            }
+            else if (ev.subtype === 'completed')
+                yield { t: 'tool_result', id, ...cursorToolResult(ev.tool_call) };
+        }
+        else if (ev.type === 'result') {
+            const u = ev.usage;
+            if (u)
+                yield {
+                    t: 'usage', durationMs: ev.duration_ms, model: agent.model || model,
+                    usage: { input: u.inputTokens ?? 0, output: u.outputTokens ?? 0, cacheRead: u.cacheReadTokens ?? 0, cacheWrite: u.cacheWriteTokens ?? 0 },
+                };
+            yield ev.is_error
+                ? { t: 'error', message: String(ev.result || 'Cursor returned an error') }
+                : { t: 'done', ok: true, summary: typeof ev.result === 'string' ? ev.result : undefined };
+            return;
+        }
+    }
+    yield { t: 'done', ok: true };
+}

package/server/dist/providers/index.js

@@ -1,12 +1,15 @@
 import { runClaude } from './claude.js';
 import { runOpencode } from './opencode.js';
 import { runKiro } from './kiro.js';
+import { runCursor } from './cursor.js';
 export const providers = {
     claude: { id: 'claude', run: runClaude },
     opencode: { id: 'opencode', run: runOpencode },
     kiro: { id: 'kiro', run: runKiro },
+    cursor: { id: 'cursor', run: runCursor },
 };
 /** The adapters as plain functions (what `runtime.ts` and the image reader call; tests may replace one). */
 export const runners = {
     claude: (o) => providers.claude.run(o), opencode: (o) => providers.opencode.run(o), kiro: (o) => providers.kiro.run(o),
+    cursor: (o) => providers.cursor.run(o),
 };

package/server/dist/providers/spawn.js

@@ -37,7 +37,9 @@ export async function* spawnLines(o) {
     };
     armStall();
     let stderr = '';
-    child.stderr.on('data', (d) => { stderr = (stderr + d).slice(-4000); });
+    let head = '';
+    child.stderr.on('data', (d) => { stderr = (stderr + d).slice(-4000); if (head.length < 600)
+        head = (head + d).slice(0, 600); });
     const exit = new Promise((res) => {
         child.on('error', (e) => { stderr += String(e); res(-1); });
         // 'exit' (not 'close'): a daemon the CLI forks (e.g. opencode's background service) can keep
@@ -68,8 +70,9 @@ export async function* spawnLines(o) {
     const code = await exit;
     if (stalled && !o.signal.aborted)
         throw new StalledError(`${o.cmd} stopped answering (nothing on stdout for ${quietFor(STALL_MS())})`);
+    const said = o.stderrHead ? head.trim() : stderr.trim().slice(-600);
     if (code !== 0 && !o.signal.aborted)
-        throw new Error(`${o.cmd} exited with code ${code}${stderr ? `: ${stderr.trim().slice(-600)}` : ''}`);
+        throw new Error(`${o.cmd} exited with code ${code}${said ? `: ${said}` : ''}`);
 }
 export function safeJson(line) {
     try {

package/server/dist/services/agents.js

@@ -1,6 +1,7 @@
 import { agents, colonies, db, resolved } from '../db.js';
 import { notebooks } from '../skills/notebook.js';
 import { checkEffort } from '../efforts.js';
+import { defaultModel } from './providers.js';
 import { channelPermissionError } from '../connections/rules.js';
 import { liveTurn, notifyAgentsChanged, stopAgent } from '../runtime.js';
 import { findRepo } from '../git/repo.js';
@@ -28,16 +29,17 @@ const checkAgentEffort = (provider, model, effort) => { const why = checkEffort(
 export function createAgent(p) {
     const name = trimmed(p.name);
     uniqueName(name);
+    const model = p.model ?? defaultModel(p.provider);
     if (p.effort !== undefined && p.provider)
-        checkAgentEffort(p.provider, p.model ?? '', p.effort);
-    return create({ ...p, name, cwd: p.cwd ?? '' });
+        checkAgentEffort(p.provider, model, p.effort);
+    return create({ ...p, name, model, cwd: p.cwd ?? '' });
 }
 /** A new agent that starts from a type: the type lends everything but name, description, folder and colony. */
 export function spawnFromType(t, p) {
     const name = trimmed(p.name);
     uniqueName(name);
     return create({
-        name, description: p.description ?? t.description, role: t.role, type_id: t.id, provider: t.provider, model: t.model,
+        name, description: p.description ?? t.description, role: t.role, type_id: t.id, provider: t.provider, model: t.model || defaultModel(t.provider),
         effort: checkEffort(t.provider, t.model, t.effort) === null ? t.effort : '', // a type whose level the model no longer takes starts at the default
         system_prompt: t.system_prompt, permission: t.permission, cwd: p.cwd ?? '', skill_ids: t.skill_ids, skill_loads: t.skill_loads, colony_id: p.colony_id ?? null,
     });

package/server/dist/services/providers.js

@@ -5,7 +5,10 @@ export const PROVIDERS = {
     claude: { bin: 'claude', label: 'Claude Code' },
     opencode: { bin: 'opencode', label: 'OpenCode' },
     kiro: { bin: 'kiro-cli', label: 'Kiro' },
+    cursor: { bin: 'cursor-agent', label: 'Cursor' },
 };
+/** The model a new agent, type or image model starts with: Cursor's own default (Composer) is refused on a free plan, `auto` runs on every plan. */
+export const defaultModel = (p) => (p === 'cursor' ? 'auto' : '');
 /** Own keys only: `"constructor" in PROVIDERS` is true. */
 export const isProvider = (v) => typeof v === 'string' && Object.hasOwn(PROVIDERS, v);
 let providerCache = null;

package/web/.next/BUILD_ID

@@ -1 +1 @@
-2RnNXnGqTqztT7YR1JZRD
+qv9RAZqD8Of6bH1cw6RzA