@tt-a1i/hive 2.1.10 → 2.1.12

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 All notable user-facing changes will be documented in this file.
 
+## 2.1.12 - 2026-06-25
+
+Default port and Pi agent support.
+
+- Changes Hive's default local runtime port from `3000` to `9483`, reducing
+  collisions with common local development services while keeping `--port 0`
+  available for OS-assigned ports.
+- Updates the local Supervisor MCP adapter and Vite dev proxy to follow the
+  same default port.
+- Adds Pi as a built-in agent preset with `pi --approve`, including workflow
+  CLI policy support, prompt-readiness handling, and migration support for
+  existing Hive databases.
+
+## 2.1.11 - 2026-06-25
+
+Supervisor MCP bridge and terminal input polish.
+
+- Adds a local Supervisor MCP adapter so external agents such as Codex App,
+  Claude, or Hermes can hand a goal to the Hive Orchestrator and wait on
+  durable structured goal events.
+- Adds `team goal report` for Orchestrators to report external goal progress,
+  completion, blocked states, or failures without giving external supervisors
+  direct member or PTY control.
+- Keeps the Supervisor MCP surface intentionally narrow: list/inspect
+  workspaces, start/wait/continue/cancel goals, with no direct member spawn,
+  member send, raw scrollback, or PTY write tools.
+- Improves OpenCode prompt readiness detection for completed turns and
+  interrupt-status screens, making post-start input delivery more reliable.
+- Preserves Codex prompt edit repaint frames after Backspace/Delete-style input,
+  so terminal editing stays visually in sync.
+
 ## 2.1.10 - 2026-06-23
 
 Scenario teams and terminal delivery polish.

package/README.md

@@ -8,7 +8,7 @@
   <img src="./assets/hive-hero.png" alt="Hive local-first multi-agent collaboration workspace hero image" />
 </p>
 
-**Run Claude Code, Codex, Gemini, OpenCode, Qwen, and other CLI agents as a visible local team.** Hive gives you one browser workbench where an
+**Run Claude Code, Codex, Gemini, OpenCode, Qwen, Pi, and other CLI agents as a visible local team.** Hive gives you one browser workbench where an
 Orchestrator plans and delegates while workers implement, review, test,
 research, and report back — all as real PTY processes on your laptop.
 
@@ -48,7 +48,7 @@ awkward:
 
 Hive adds the coordination layer without replacing the CLIs. The Orchestrator
 is a real `agy` / `claude` / `codex` / `opencode` / `gemini` / `hermes` /
-`qwen` process, not a scripted PM. Workers are real CLI agents too. Hive
+`qwen` / `pi` process, not a scripted PM. Workers are real CLI agents too. Hive
 injects a small `team` command into their shells, so they can dispatch,
 report, and keep a shared markdown task graph at `<workspace>/.hive/tasks.md`.
 
@@ -117,8 +117,8 @@ Those warnings usually come from npm's install-script review plus native
 binary setup for `node-pty`, `better-sqlite3`, and `esbuild`; they do not mean
 Hive failed to install. The troubleshooting section below breaks them down.
 
-Open the printed local URL, usually `http://127.0.0.1:3000/`. Use
-`hive --port 4010` when you need a specific local port.
+Open the printed local URL, usually `http://127.0.0.1:9483/`. Use
+`hive --port 0` when you want Hive to ask the OS for any free local port.
 
 To upgrade in place:
 
@@ -133,7 +133,7 @@ npm copy will shadow your existing install.
 
 Install Hive as an app (optional):
 
-Open `http://127.0.0.1:3000/` in Chrome, Edge, or Brave and click the install
+Open `http://127.0.0.1:9483/` in Chrome, Edge, or Brave and click the install
 icon at the right edge of the browser's omnibox. The PWA launches in its own
 dock-anchored window without browser chrome and shows **Add Workspace** /
 **Try Demo** shortcuts from the dock right-click menu. Firefox and Safari
@@ -143,8 +143,8 @@ only appears in Chromium-based browsers.
 The Hive daemon must still be running for the PWA to do anything; if the
 runtime isn't reachable when you launch the app, you'll see a "Hive runtime
 is not running" page that auto-reloads once `hive` is back on `127.0.0.1`.
-The PWA install scope is keyed by origin, so `hive --port 4011` installs as
-a separate app from `hive --port 3000`. To uninstall, visit `chrome://apps`,
+The PWA install scope is keyed by origin, so `hive --port 9484` installs as
+a separate app from `hive --port 9483`. To uninstall, visit `chrome://apps`,
 right-click the Hive tile, and choose **Remove from Chrome…**.
 
 Hive asks the browser to confirm before closing the tab or PWA window so an
@@ -220,6 +220,7 @@ Three details matter:
 | Gemini | `gemini` | `--yolo` | `--resume <session_id>` |
 | Hermes | `hermes` | `--yolo` | `--resume <session_id>` |
 | Qwen Code | `qwen` | `--approval-mode yolo` | `--resume <session_id>` |
+| Pi | `pi` | `--approve` | Session id capture not wired yet |
 | Cursor CLI | `cursor` | `--force` | Session id capture not wired yet |
 | Grok Build | `grok` | `--always-approve` | Session id capture not wired yet |
 | Custom | Any executable | User configured | User configured |
@@ -232,7 +233,7 @@ same shell environment you use to start Hive.
 | Tier | CLIs | Commitment |
 | --- | --- | --- |
 | Tier 1 | Claude Code, Codex | Minimum compatibility report in CI (`pnpm compat:cli:report`): Node 22, `node-pty`, `better-sqlite3`, and CLI version detection when installed. |
-| Tier 2 | Gemini, OpenCode, Qwen Code, Hermes, Cursor CLI, Grok Build, Antigravity CLI | Built-in presets and manual smoke coverage; upstream CLI changes may require user reports before Hive catches up. |
+| Tier 2 | Gemini, OpenCode, Qwen Code, Hermes, Pi, Cursor CLI, Grok Build, Antigravity CLI | Built-in presets and manual smoke coverage; upstream CLI changes may require user reports before Hive catches up. |
 | Custom | Any executable | User-maintained command, args, and auth behavior. Hive preserves the PTY/session wrapper but cannot promise CLI-specific compatibility. |
 
 ## What Hive Provides
@@ -250,7 +251,8 @@ same shell environment you use to start Hive.
 - Workflow CLI policy: choose the default CLI for workflow-created agents and
   restrict which CLIs workflow scripts may launch.
 - `.hive/tasks.md` editor with external-file conflict handling.
-- Background PTY preservation and best-effort native session resume.
+- Background PTY preservation and best-effort native session resume for presets with
+  configured session capture.
 - A What's New dialog after upgrades with curated release highlights.
 - Local SQLite metadata under `%APPDATA%\hive` on Windows and `~/.config/hive`
   on macOS / Linux by default, or `$HIVE_DATA_DIR` when set.
@@ -404,7 +406,7 @@ pnpm install
 pnpm dev
 ```
 
-Development mode runs the runtime on `127.0.0.1:4010`; Vite runs on
+Development mode runs the runtime on `127.0.0.1:9483`; Vite runs on
 `127.0.0.1:5180` and proxies API and WebSocket traffic to the runtime.
 
 Useful checks:
@@ -419,7 +421,7 @@ Production-style local run:
 
 ```bash
 pnpm build
-node dist/src/cli/hive.js --port 4010
+node dist/src/cli/hive.js --port 9483
 ```
 
 The production server serves the built web UI directly. No Vite server is

package/README.zh.md

@@ -8,7 +8,7 @@
   <img src="./assets/hive-hero.png" alt="Hive 本机多 agent 协作工作台" />
 </p>
 
-**Hive 是浏览器里的 Agent 协作工作台——一群 Agent 在你本机各自开工，一个当 Orchestrator 派活、归总进展，其余各司其职。** Orchestrator 本身就是一个真实的 `agy` / `claude` / `codex` / `opencode` / `gemini` / `hermes` / `qwen` 进程——不是你、也不是脚本——它派单的 Worker 同样是真 CLI agent。所有 agent 都是本机真实的 PTY 进程，通过 Hive 注入到 shell 里的小型 `team` 协议互相通信，共享 `<workspace>/.hive/tasks.md` 这份 markdown 任务图。
+**Hive 是浏览器里的 Agent 协作工作台——一群 Agent 在你本机各自开工，一个当 Orchestrator 派活、归总进展，其余各司其职。** Orchestrator 本身就是一个真实的 `agy` / `claude` / `codex` / `opencode` / `gemini` / `hermes` / `qwen` / `pi` 进程——不是你、也不是脚本——它派单的 Worker 同样是真 CLI agent。所有 agent 都是本机真实的 PTY 进程，通过 Hive 注入到 shell 里的小型 `team` 协议互相通信，共享 `<workspace>/.hive/tasks.md` 这份 markdown 任务图。
 
 写代码、做调研、起草文档、做翻译——凡是能拆给一群人协作的脑力活，都可以让一群 Agent 合伙干。
 
@@ -94,7 +94,7 @@ npm install -g @tt-a1i/hive --registry=https://registry.npmmirror.com
 
 安装时如果看到 `npm warn allow-scripts` 或 `prebuild-install@7.1.3 deprecated`，先看最后是否显示 `added ... packages`。这些 warning 多数来自 npm 对安装脚本的安全审查，以及 `node-pty` / `better-sqlite3` / `esbuild` 这类原生依赖的二进制安装链路；不代表 Hive 启动失败。下面的故障排查里有逐项解释。
 
-打开终端打印出来的本机地址，通常是 `http://127.0.0.1:3000/`。如果你想指定端口，可以用 `hive --port 4010`。
+打开终端打印出来的本机地址，通常是 `http://127.0.0.1:9483/`。如果你想让系统自动分配一个空闲端口，可以用 `hive --port 0`。
 
 升级到最新版本：
 
@@ -106,9 +106,9 @@ hive update
 
 把 Hive 装为应用（可选）：
 
-在 Chrome / Edge / Brave 里打开 `http://127.0.0.1:3000/`，点浏览器地址栏右侧的安装图标即可。装好后 Hive 会以独立窗口启动、有自己的 dock 图标，且 dock 右键菜单上会显示 **添加 Workspace** / **试用演示** 两个快捷入口。Firefox 和 Safari 暂未实现 PWA install-prompt 协议，浏览器地址栏的安装图标只在 Chromium 系浏览器里出现。
+在 Chrome / Edge / Brave 里打开 `http://127.0.0.1:9483/`，点浏览器地址栏右侧的安装图标即可。装好后 Hive 会以独立窗口启动、有自己的 dock 图标，且 dock 右键菜单上会显示 **添加 Workspace** / **试用演示** 两个快捷入口。Firefox 和 Safari 暂未实现 PWA install-prompt 协议，浏览器地址栏的安装图标只在 Chromium 系浏览器里出现。
 
-PWA 只是 UI 壳，Hive 后端仍需要在终端里跑着。如果启动 PWA 时后端没起，会看到 “Hive 后端未启动” 页面，等你跑起 `hive` 后会自动刷新。PWA 的 install scope 按 origin（含端口）划分，所以 `hive --port 4011` 跟 `hive --port 3000` 在浏览器看来是两个独立应用。卸载方法：浏览器地址栏访问 `chrome://apps`，右键 Hive 图标，选 **从 Chrome 中移除…**。
+PWA 只是 UI 壳，Hive 后端仍需要在终端里跑着。如果启动 PWA 时后端没起，会看到 “Hive 后端未启动” 页面，等你跑起 `hive` 后会自动刷新。PWA 的 install scope 按 origin（含端口）划分，所以 `hive --port 9484` 跟 `hive --port 9483` 在浏览器看来是两个独立应用。卸载方法：浏览器地址栏访问 `chrome://apps`，右键 Hive 图标，选 **从 Chrome 中移除…**。
 
 关闭 PWA 窗口或 tab 时 Hive 会主动请求浏览器弹原生确认对话框，避免关闭快捷键（macOS 上是 Cmd+W、Windows / Linux 上是 Ctrl+W）误关丢失会话。但现代浏览器要求你跟页面"交互过"（点击 / 滚动 / 输入）才会真的弹这个对话框——刚打开 PWA 立刻按关闭快捷键仍会直接关闭，这是浏览器策略，不是 Hive 的 bug。
 
@@ -165,6 +165,7 @@ Workspace 任务图：
 | Gemini | `gemini` | `--yolo` | `--resume <session_id>` |
 | Hermes | `hermes` | `--yolo` | `--resume <session_id>` |
 | Qwen Code | `qwen` | `--approval-mode yolo` | `--resume <session_id>` |
+| Pi | `pi` | `--approve` | 暂未自动捕获 session id |
 | Cursor CLI | `cursor` | `--force` | 暂未自动捕获 session id |
 | Grok Build | `grok` | `--always-approve` | 暂未自动捕获 session id |
 | 自定义 | 任意可执行文件 | 自己配 | 自己配 |
@@ -176,7 +177,7 @@ Hive 不替你安装这些 CLI。请在启动 Hive 的同一个 shell 环境里
 | 分级 | CLI | 承诺 |
 | --- | --- | --- |
 | Tier 1 | Claude Code、Codex | CI 生成最小兼容报告（`pnpm compat:cli:report`）：检查 Node 22、`node-pty`、`better-sqlite3`，并在本机已安装 CLI 时记录版本。 |
-| Tier 2 | Gemini、OpenCode、Qwen Code、Hermes、Cursor CLI、Grok Build、Antigravity CLI | 内置 preset + 手动 smoke 覆盖；上游 CLI 行为变化可能需要用户报告后再跟进。 |
+| Tier 2 | Gemini、OpenCode、Qwen Code、Hermes、Pi、Cursor CLI、Grok Build、Antigravity CLI | 内置 preset + 手动 smoke 覆盖；上游 CLI 行为变化可能需要用户报告后再跟进。 |
 | Custom | 任意可执行命令 | 用户自己维护命令、参数和登录状态；Hive 只保证 PTY/session 包装，不承诺 CLI 专属兼容性。 |
 
 ## Hive 提供什么
@@ -188,7 +189,7 @@ Hive 不替你安装这些 CLI。请在启动 Hive 的同一个 shell 环境里
 - Workflows（实验性，默认关闭）：Orchestrator 可以运行多阶段、多 agent 的 workflow，Hive 在 Workflows 面板里展示运行、日志、结果、定时任务和停止控制。
 - Workflow CLI 策略：为 workflow 创建的 agent 选择默认 CLI，并限制允许使用的 CLI，避免脚本误启未配置的 agent。
 - `.hive/tasks.md` 编辑器，带外部文件冲突处理。
-- PTY 后台保留 + 尽力使用各 CLI 原生 session 恢复。
+- PTY 后台保留；对已配置 session capture 的预设，尽力使用对应 CLI 的原生 session 恢复。
 - 升级后的 What's New 弹窗，用简短 release highlights 告诉你新版改了什么。
 - 元数据存在本机 SQLite，Windows 默认在 `%APPDATA%\hive`，macOS / Linux 默认在 `~/.config/hive`，也可以通过 `$HIVE_DATA_DIR` 指定。
 
@@ -294,7 +295,7 @@ pnpm install
 pnpm dev
 ```
 
-开发模式下 runtime 跑在 `127.0.0.1:4010`，Vite 跑在 `127.0.0.1:5180`，把 API 和 WebSocket 代理到 runtime。
+开发模式下 runtime 跑在 `127.0.0.1:9483`，Vite 跑在 `127.0.0.1:5180`，把 API 和 WebSocket 代理到 runtime。
 
 常用命令：
 
@@ -308,7 +309,7 @@ pnpm test
 
 ```bash
 pnpm build
-node dist/src/cli/hive.js --port 4010
+node dist/src/cli/hive.js --port 9483
 ```
 
 Production 模式下 runtime 直接服务构建好的 web UI，不需要单独的 Vite。

package/dist/src/cli/hive-defaults.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_HIVE_PORT = 9483;

package/dist/src/cli/hive-defaults.js

@@ -0,0 +1 @@
+export const DEFAULT_HIVE_PORT = 9483;

package/dist/src/cli/hive-mcp.d.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+export declare const HIVE_MCP_TOOL_NAMES: readonly ["hive.list_workspaces", "hive.inspect_workspace", "hive.start_goal", "hive.wait_goal", "hive.continue_goal", "hive.cancel_goal"];
+export declare const HIVE_MCP_TOOLS: readonly [{
+    readonly name: "hive.list_workspaces";
+    readonly description: "List local Hive workspaces available for external Supervisor goals.";
+    readonly inputSchema: {
+        additionalProperties: boolean;
+        properties: Record<string, unknown>;
+        required: string[];
+        type: string;
+    };
+}, {
+    readonly name: "hive.inspect_workspace";
+    readonly description: "Inspect a Hive workspace, its Orchestrator status, and member roster.";
+    readonly inputSchema: {
+        additionalProperties: boolean;
+        properties: Record<string, unknown>;
+        required: string[];
+        type: string;
+    };
+}, {
+    readonly name: "hive.start_goal";
+    readonly description: "Start an external Supervisor goal by delivering it to the workspace Orchestrator.";
+    readonly inputSchema: {
+        additionalProperties: boolean;
+        properties: Record<string, unknown>;
+        required: string[];
+        type: string;
+    };
+}, {
+    readonly name: "hive.wait_goal";
+    readonly description: "Wait for durable external goal events after a cursor, with a bounded timeout.";
+    readonly inputSchema: {
+        additionalProperties: boolean;
+        properties: Record<string, unknown>;
+        required: string[];
+        type: string;
+    };
+}, {
+    readonly name: "hive.continue_goal";
+    readonly description: "Append context to an external goal and deliver it to the Orchestrator.";
+    readonly inputSchema: {
+        additionalProperties: boolean;
+        properties: Record<string, unknown>;
+        required: string[];
+        type: string;
+    };
+}, {
+    readonly name: "hive.cancel_goal";
+    readonly description: "Cancel an external goal and notify the Orchestrator. Does not auto-cancel member dispatches.";
+    readonly inputSchema: {
+        additionalProperties: boolean;
+        properties: Record<string, unknown>;
+        required: string[];
+        type: string;
+    };
+}];
+export declare const callHiveMcpTool: (toolName: string, args?: Record<string, unknown>, input?: {
+    baseUrl?: string;
+    env?: NodeJS.ProcessEnv;
+}) => Promise<unknown>;
+export declare const runHiveMcpCommand: (argv?: string[], env?: NodeJS.ProcessEnv) => Promise<void>;

package/dist/src/cli/hive-mcp.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { HIVE_SUPERVISOR_TOKEN_HEADER } from '../server/external-goal-auth.js';
+import { readPackageVersion } from '../server/package-version.js';
+import { sameFilesystemPath } from '../server/path-canonicalization.js';
+import { DEFAULT_HIVE_PORT } from './hive-defaults.js';
+export const HIVE_MCP_TOOL_NAMES = [
+    'hive.list_workspaces',
+    'hive.inspect_workspace',
+    'hive.start_goal',
+    'hive.wait_goal',
+    'hive.continue_goal',
+    'hive.cancel_goal',
+];
+const jsonSchema = (properties, required = []) => ({
+    additionalProperties: false,
+    properties,
+    required,
+    type: 'object',
+});
+export const HIVE_MCP_TOOLS = [
+    {
+        name: 'hive.list_workspaces',
+        description: 'List local Hive workspaces available for external Supervisor goals.',
+        inputSchema: jsonSchema({}),
+    },
+    {
+        name: 'hive.inspect_workspace',
+        description: 'Inspect a Hive workspace, its Orchestrator status, and member roster.',
+        inputSchema: jsonSchema({
+            workspace_id: { type: 'string' },
+        }, ['workspace_id']),
+    },
+    {
+        name: 'hive.start_goal',
+        description: 'Start an external Supervisor goal by delivering it to the workspace Orchestrator.',
+        inputSchema: jsonSchema({
+            context: {},
+            goal: { type: 'string' },
+            timeout_hint_ms: { type: 'number' },
+            workspace_id: { type: 'string' },
+        }, ['workspace_id', 'goal']),
+    },
+    {
+        name: 'hive.wait_goal',
+        description: 'Wait for durable external goal events after a cursor, with a bounded timeout.',
+        inputSchema: jsonSchema({
+            cursor: { minimum: 0, type: 'integer' },
+            goal_id: { type: 'string' },
+            timeout_ms: { minimum: 0, type: 'number' },
+        }, ['goal_id']),
+    },
+    {
+        name: 'hive.continue_goal',
+        description: 'Append context to an external goal and deliver it to the Orchestrator.',
+        inputSchema: jsonSchema({
+            context: {},
+            goal_id: { type: 'string' },
+            message: { type: 'string' },
+        }, ['goal_id', 'message']),
+    },
+    {
+        name: 'hive.cancel_goal',
+        description: 'Cancel an external goal and notify the Orchestrator. Does not auto-cancel member dispatches.',
+        inputSchema: jsonSchema({
+            goal_id: { type: 'string' },
+            reason: { type: 'string' },
+        }, ['goal_id', 'reason']),
+    },
+];
+const parseBaseUrl = (argv, env) => {
+    const index = argv.indexOf('--base-url');
+    if (index !== -1) {
+        const value = argv[index + 1];
+        if (!value)
+            throw new Error('--base-url requires a value');
+        return value.replace(/\/$/u, '');
+    }
+    if (env.HIVE_MCP_BASE_URL)
+        return env.HIVE_MCP_BASE_URL.replace(/\/$/u, '');
+    if (env.HIVE_PORT)
+        return `http://127.0.0.1:${env.HIVE_PORT}`;
+    return `http://127.0.0.1:${DEFAULT_HIVE_PORT}`;
+};
+const readHttpErrorDetail = async (response) => {
+    const text = await response.text().catch(() => '');
+    if (!text.trim())
+        return `HTTP ${response.status}`;
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed.error === 'string')
+            return parsed.error;
+    }
+    catch {
+        return text.trim();
+    }
+    return text.trim();
+};
+const getSupervisorToken = async (baseUrl) => {
+    const response = await fetch(`${baseUrl}/api/external-goals/session`);
+    if (!response.ok)
+        throw new Error(await readHttpErrorDetail(response));
+    const body = (await response.json());
+    if (typeof body.token !== 'string' || body.token.length === 0) {
+        throw new Error('Hive runtime did not issue a Supervisor token');
+    }
+    return body.token;
+};
+const requestJson = async (baseUrl, path, init = {}) => {
+    const supervisorToken = await getSupervisorToken(baseUrl);
+    const response = await fetch(`${baseUrl}${path}`, {
+        ...init,
+        headers: {
+            ...(init.headers ?? {}),
+            [HIVE_SUPERVISOR_TOKEN_HEADER]: supervisorToken,
+            ...(init.body ? { 'content-type': 'application/json' } : {}),
+        },
+    });
+    if (!response.ok)
+        throw new Error(await readHttpErrorDetail(response));
+    return response.json();
+};
+const postJson = (baseUrl, path, body) => requestJson(baseUrl, path, {
+    body: JSON.stringify(body),
+    method: 'POST',
+});
+const requireStringArg = (args, key) => {
+    const value = args[key];
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`Missing ${key}`);
+    }
+    return value;
+};
+export const callHiveMcpTool = async (toolName, args = {}, input = {}) => {
+    const baseUrl = input.baseUrl ?? parseBaseUrl([], input.env ?? process.env);
+    if (toolName === 'hive.list_workspaces') {
+        return requestJson(baseUrl, '/api/external-goals/workspaces');
+    }
+    if (toolName === 'hive.inspect_workspace') {
+        const workspaceId = requireStringArg(args, 'workspace_id');
+        return requestJson(baseUrl, `/api/external-goals/workspaces/${encodeURIComponent(workspaceId)}`);
+    }
+    if (toolName === 'hive.start_goal') {
+        return postJson(baseUrl, '/api/external-goals/start', {
+            context: args.context,
+            goal: requireStringArg(args, 'goal'),
+            source: 'hive-mcp',
+            timeout_hint_ms: args.timeout_hint_ms,
+            workspace_id: requireStringArg(args, 'workspace_id'),
+        });
+    }
+    if (toolName === 'hive.wait_goal') {
+        return postJson(baseUrl, '/api/external-goals/wait', {
+            cursor: args.cursor,
+            goal_id: requireStringArg(args, 'goal_id'),
+            timeout_ms: args.timeout_ms,
+        });
+    }
+    if (toolName === 'hive.continue_goal') {
+        return postJson(baseUrl, '/api/external-goals/continue', {
+            context: args.context,
+            goal_id: requireStringArg(args, 'goal_id'),
+            message: requireStringArg(args, 'message'),
+        });
+    }
+    if (toolName === 'hive.cancel_goal') {
+        return postJson(baseUrl, '/api/external-goals/cancel', {
+            goal_id: requireStringArg(args, 'goal_id'),
+            reason: requireStringArg(args, 'reason'),
+        });
+    }
+    throw new Error(`Unknown Hive MCP tool: ${toolName}`);
+};
+const resultResponse = (id, result) => ({
+    id,
+    jsonrpc: '2.0',
+    result,
+});
+const errorResponse = (id, code, message) => ({
+    error: { code, message },
+    id: id ?? null,
+    jsonrpc: '2.0',
+});
+const toolResult = (result) => ({
+    content: [
+        {
+            text: JSON.stringify(result),
+            type: 'text',
+        },
+    ],
+    structuredContent: result,
+});
+const handleRequest = async (request, baseUrl) => {
+    if (!request.method) {
+        return errorResponse(request.id, -32600, 'Invalid JSON-RPC request');
+    }
+    if (request.method === 'initialize') {
+        return resultResponse(request.id, {
+            capabilities: { tools: {} },
+            protocolVersion: typeof request.params?.protocolVersion ===
+                'string'
+                ? request.params.protocolVersion
+                : '2025-06-18',
+            serverInfo: { name: 'hive-supervisor', version: readPackageVersion() },
+        });
+    }
+    if (request.method === 'ping')
+        return resultResponse(request.id, {});
+    if (request.method === 'tools/list')
+        return resultResponse(request.id, { tools: HIVE_MCP_TOOLS });
+    if (request.method === 'tools/call') {
+        const params = request.params;
+        if (!params?.name)
+            return errorResponse(request.id, -32602, 'Missing tool name');
+        const result = await callHiveMcpTool(params.name, params.arguments ?? {}, { baseUrl });
+        return resultResponse(request.id, toolResult(result));
+    }
+    if (request.id === undefined)
+        return null;
+    return errorResponse(request.id, -32601, `Unknown method: ${request.method}`);
+};
+const writeJsonRpc = (message) => {
+    process.stdout.write(`${JSON.stringify(message)}\n`);
+};
+export const runHiveMcpCommand = async (argv = process.argv.slice(2), env = process.env) => {
+    const baseUrl = parseBaseUrl(argv, env);
+    const rl = createInterface({ input: process.stdin, terminal: false });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let requestId;
+        try {
+            const request = JSON.parse(trimmed);
+            requestId = request.id;
+            const response = await handleRequest(request, baseUrl);
+            if (response)
+                writeJsonRpc(response);
+        }
+        catch (error) {
+            writeJsonRpc(errorResponse(requestId, -32603, error instanceof Error ? error.message : String(error)));
+        }
+    }
+};
+const isMainModule = process.argv[1]
+    ? sameFilesystemPath(fileURLToPath(import.meta.url), process.argv[1])
+    : false;
+if (isMainModule) {
+    void runHiveMcpCommand(process.argv.slice(2)).catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}

package/dist/src/cli/hive.d.ts

@@ -2,6 +2,7 @@
 import { type RemoteTunnel, type RemoteTunnelDeps } from '../server/remote-tunnel.js';
 import { type RuntimeStore } from '../server/runtime-store.js';
 import { type VersionService } from '../server/version-service.js';
+import { DEFAULT_HIVE_PORT } from './hive-defaults.js';
 interface RunHiveCommandResult {
     port: number;
     close: () => Promise<void>;
@@ -40,6 +41,7 @@ type RunHiveCommandOptions = {
  * registration is mostly about giving SQLite a chance to checkpoint.
  */
 export declare const SHUTDOWN_SIGNALS: readonly ["SIGINT", "SIGTERM", "SIGHUP", "SIGBREAK"];
+export { DEFAULT_HIVE_PORT };
 export declare const HIVE_USAGE: string;
 export declare const handleHiveInfoCommand: (argv: string[]) => boolean;
 /**

package/dist/src/cli/hive.js

@@ -13,6 +13,8 @@ import { createRemoteConfigSource } from '../server/remote-config-keys.js';
 import { createRemoteTunnel, } from '../server/remote-tunnel.js';
 import { createRuntimeStore } from '../server/runtime-store.js';
 import { createVersionService } from '../server/version-service.js';
+import { DEFAULT_HIVE_PORT } from './hive-defaults.js';
+import { runHiveMcpCommand } from './hive-mcp.js';
 import { runHiveRemoteCommand } from './hive-remote.js';
 import { runHiveUpdateCommand } from './hive-update.js';
 /**
@@ -37,18 +39,20 @@ import { runHiveUpdateCommand } from './hive-update.js';
  * registration is mostly about giving SQLite a chance to checkpoint.
  */
 export const SHUTDOWN_SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGBREAK'];
+export { DEFAULT_HIVE_PORT };
 export const HIVE_USAGE = [
     'Usage:',
     '  hive [--port <port>] [--no-open]',
     '  hive update',
     '',
     'Options:',
-    '  --port <port>   Bind the local runtime to a specific port (default: 3000).',
+    `  --port <port>   Bind the local runtime to a specific port (default: ${DEFAULT_HIVE_PORT}).`,
     '  --no-open       Do not auto-open the browser after start.',
     '  -h, --help      Print this help.',
     '  -v, --version   Print the installed Hive version.',
     '',
     'Commands:',
+    '  mcp             Run the local Supervisor MCP stdio adapter.',
     '  update          Upgrade npm-installed Hive in place; otherwise use the matching package manager.',
     '  remote          Manage remote access (login / status / logout / devices / revoke).',
 ].join('\n');
@@ -87,7 +91,7 @@ const parsePort = (argv) => {
         parsedPort = port;
         index += 1;
     }
-    return parsedPort ?? 3000;
+    return parsedPort ?? DEFAULT_HIVE_PORT;
 };
 /**
  * Resolve the directory where Hive persists its SQLite DB and supporting
@@ -350,6 +354,12 @@ if (isMainModule) {
             process.exit(1);
         });
     }
+    else if (argv[0] === 'mcp') {
+        runHiveMcpCommand(argv.slice(1)).catch((error) => {
+            console.error(error instanceof Error ? error.message : error);
+            process.exit(1);
+        });
+    }
     else if (handleHiveInfoCommand(argv)) {
         process.exit(0);
     }

package/dist/src/cli/team.d.ts

@@ -11,6 +11,14 @@ export interface ParsedReportArgs {
 }
 export declare const parseReportArgs: (args: string[], command?: string) => ParsedReportArgs;
 export declare const parseCancelArgs: (args: string[]) => ParsedCancelArgs;
+export interface ParsedGoalReportArgs {
+    artifacts: string[];
+    goalId: string;
+    result: string | null;
+    status: 'progress' | 'done' | 'blocked' | 'failed';
+    useStdin: boolean;
+}
+export declare const parseGoalReportArgs: (args: string[]) => ParsedGoalReportArgs;
 export declare const parseRecallArgs: (args: string[]) => {
     window?: number;
     limit?: number;