@tt-a1i/hive 2.0.2 → 2.1.0

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 All notable user-facing changes will be documented in this file.
 
+## 2.1.0 - 2026-06-13
+
+Sentinel patrol role, one-click team assembly, visible memory consolidation, and remote/dispatch reliability.
+
+- Adds a built-in **Sentinel** role: a read-only patrol member that watches the
+  team and surfaces stalled or orphaned work via `team status`, without taking
+  dispatches or writing memory itself.
+- Adds **one-click scenario team assembly** — start a ready-made team from a
+  preset instead of adding members one at a time, with guiding empty-state cards
+  when a workspace has no team yet.
+- Reworks team-memory **Dream consolidation** to run through your Orchestrator
+  instead of a hidden background CLI pass: maintenance is injected as a visible
+  task (`team memory dream show` / `team memory apply`), workers may be asked to
+  review proposed changes read-only, and only the Orchestrator commits them.
+  Every run keeps a diff report and a one-step revert.
+- Adds a one-click, copyable **team recap** and a diagnostics support bundle to
+  the Action Center for faster sharing and troubleshooting.
+- Adds a **dispatch pulse** animation so `team send` visibly flows from the
+  Orchestrator to the receiving worker.
+- Guides you to install any missing CLI directly from the add-workspace dialog
+  before you start a team.
+- Makes dispatching more reliable: queued tasks replay when a worker starts,
+  delivery failures notify the issuer instead of being lost, and `team list`
+  now exposes open dispatches.
+- Adds local per-day retention signals (protocol event counters) for workspace
+  activity.
+- Fixes remote/mobile reliability: large uploads over the tunnel are chunked
+  under the relay message cap, and terminal scrolling is restored for CLIs
+  launched through wrapped or legacy commands (for example Codex on Windows).
+- Hardens prompts and the workflow runtime against prompt-injection, and
+  polishes protocol error messages, onboarding, and `team spawn` role/CLI
+  handling.
+
 ## 2.0.2 - 2026-06-10
 
 Windows Codex terminal scrolling fix.

package/README.en.md

@@ -56,10 +56,11 @@ them.
 ## Try the demo first
 
 Don't have an agent CLI installed yet? Run `hive`, open the printed URL, and
-click **Try Demo** in the first-run wizard. You get a fully client-side
-preview — fake orchestrator + two workers, prerecorded scrollback, a
-prefilled task list — without touching the server or any real CLI agent.
-Useful for deciding whether to install a real CLI.
+click **Try Demo** in the first-run wizard. The current demo is a walkthrough
+video hosted on Bilibili (network access required to play it) plus a sample
+team in the sidebar, so you can see the orchestrator dispatching and workers
+reporting without installing or signing in to any real CLI agent. Useful for
+deciding whether to install a real CLI.
 
 ## Quick Start
 
@@ -450,6 +451,14 @@ Upstream content is mirrored verbatim, license files are kept under `vendor/mark
 
 ## License
 
-Hive source is available under the Business Source License 1.1. Personal use, internal deployment, embedding, and forks are permitted — see [LICENSE.BSL](LICENSE.BSL) for the exact boundary.
+Hive is **source-available under the Business Source License 1.1 (BUSL-1.1)**. It is **not** open source as defined by the OSI, and we don't describe it as such.
 
-Forks and redistributions must preserve [NOTICE](NOTICE), [LICENSE.BSL](LICENSE.BSL), and the applicable license files. The Hive name, logo, and visual identity are not licensed by the source license; see [TRADEMARK.md](TRADEMARK.md) for brand usage boundaries.
+### License FAQ
+
+**Why isn't it OSI open source?** BUSL-1.1 places one restriction on production use (next answer), which keeps it outside the Open Source Definition — the BUSL license text itself states it "is not an Open Source license". Rather than blur that line, we say source-available plainly.
+
+**Does it affect personal or team use?** No. The Additional Use Grant in [LICENSE.BSL](LICENSE.BSL) explicitly allows production use; the only carve-out is offering Hive to third parties — hosted or embedded, on a paid basis or under any other revenue-generating arrangement (including paid support) — in a way that competes with Hive's multi-CLI-agent orchestration product. Personal use, internal deployment within your organization, embedding into a non-competitive product, and non-commercial forks are all fine.
+
+**Will it become open source later?** Yes. Each version converts to the **Apache License 2.0** on the Change Date (2030-05-16) or four years after that version's first public release, whichever comes first.
+
+See [LICENSE.BSL](LICENSE.BSL) for the exact terms. Forks and redistributions must preserve [NOTICE](NOTICE), [LICENSE.BSL](LICENSE.BSL), and the applicable license files. The Hive name, logo, and visual identity are not licensed by the source license; see [TRADEMARK.md](TRADEMARK.md) for brand usage boundaries.

package/README.md

@@ -12,6 +12,8 @@
 
 写代码、做调研、起草文档、做翻译——凡是能拆给一群人协作的脑力活，都可以让一群 Agent 合伙干。
 
+全程可以用国产 CLI 组队——Qwen Code 是内置预设，GLM 等国内模型也能通过其支持的 coding CLI 或自定义命令接入——不强制依赖境外 API。Windows 原生支持（非 WSL），详见[平台支持](#平台支持)。
+
 [![npm](https://img.shields.io/npm/v/@tt-a1i/hive.svg)](https://www.npmjs.com/package/@tt-a1i/hive)
 [![ci](https://img.shields.io/github/actions/workflow/status/tt-a1i/hive/release.yml?branch=main&label=ci)](https://github.com/tt-a1i/hive/actions/workflows/release.yml)
 [![Website](https://img.shields.io/badge/website-hivehq.dev-5a8a8a.svg)](https://hivehq.dev)
@@ -42,7 +44,7 @@ Hive 加上这一层调度，**不替换**任何 CLI。Agent 还是真实跑在
 
 ## 先看看 demo
 
-还没装任何 agent CLI？运行 `hive`、打开它打印出的本地地址、在 first-run 向导里点 **Try Demo**。你会看到一个完全跑在客户端的预览——假 orchestrator + 两个 worker、预录的终端 scrollback、一份预填的任务清单——既不会连服务器，也不需要任何真实 CLI agent。适合决定要不要继续装真 CLI。
+还没装任何 agent CLI？运行 `hive`、打开它打印出的本地地址、在 first-run 向导里点 **Try Demo**。当前的 demo 是一段 Bilibili 演示视频（需要联网才能播放），外加侧边栏里的一个示例团队，让你不安装、不登录任何真实 CLI agent 就能看到 Orchestrator 派单、Worker 干活的样子。适合决定要不要继续装真 CLI。
 
 ## 快速开始
 
@@ -58,6 +60,12 @@ npm install -g @tt-a1i/hive
 hive
 ```
 
+国内网络从 npmmirror 镜像安装更快：
+
+```bash
+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`。
@@ -168,6 +176,12 @@ Hive **不**提供 sandbox 隔离、多用户认证，也不自带任何 agent
 
 ## 平台支持
 
+| 平台 | 状态 | 说明 |
+| --- | --- | --- |
+| macOS | Tier 1 | 主要开发与发版验证平台。 |
+| Linux | Tier 1 | CI 验证。原生目录选择器依赖 `zenity`，没有也可以手动粘贴路径。 |
+| Windows | Tier 2 | **原生支持，无需 WSL**。CI 跑 Windows 测试子集（`pnpm test:windows`）和打包安装冒烟，包内含 `team.cmd`。按 best-effort 维护：每次发版前的完整 Windows 验证仍是手动步骤。 |
+
 所有平台都需要 Node.js 22+。Hive 依赖 `node-pty` 和 `better-sqlite3` 这类原生包，没有预编译二进制时需要你本机有原生构建工具链。
 
 ## 安全模型
@@ -304,7 +318,7 @@ Hive 目前处于 alpha 阶段，核心流程已可用。当前重点是继续
 
 但 **这些都是单 agent 内部的记忆**。Hive 是多 agent 协作工作台，正在把它们打通：让整支团队 **共享一座长时记忆库**——Worker A 今天踩的坑，明天 Orchestrator 派给 Worker B 时能自动调来当上下文。
 
-第一阶段先走本地优先：Hive 用 SQLite 保存协作历史和显式团队记忆，支持 `team recall` / `team memory`、派单和恢复时的自动注入、`<workspace>/.hive/memory.md` 单向导出，以及离线 Dream 整理。Dream 会按 workspace 空闲和增量阈值批处理协议消息，自动应用去重/改写/归档/新增，并保留 diff 报告和整次 run 的回滚入口。
+第一阶段先走本地优先：Hive 用 SQLite 保存协作历史和显式团队记忆，支持 `team recall` / `team memory`、派单和恢复时的自动注入、`<workspace>/.hive/memory.md` 单向导出，以及 Dream 整理。Dream 会按 workspace 空闲和增量阈值创建维护 run，把有界协议窗口注入 Orchestrator；Orchestrator 可自己整理，或派 worker 只读评审并回报建议，最后由 Orchestrator 用 `team memory apply --run <id> --stdin` 提交去重/改写/归档/新增。每次 run 保留 diff 报告和回滚入口。
 
 下一阶段再接 **[EverOS](https://github.com/EverMind-AI/EverOS)**（[EverMind](https://evermind.ai/) 出品的开源长时记忆 OS，目前在 LoCoMo / LongMemEval / HaluMem 三个记忆 benchmark 上 SOTA）这类外部 provider。EverOS 的四层架构（Agentic / Memory / Index / API+MCP）跟 Hive 的多 PTY 协作模型很搭：每个 agent 各跑各的 CLI session，团队级的事实和模式凝在 provider，Orchestrator 派单时一并喂给 worker。
 
@@ -328,6 +342,14 @@ Hive 的"模板市场"内置了两份社区角色 prompt 库的快照，两份
 
 ## License
 
-Hive 源码在 Business Source License 1.1 下提供。个人使用、内部部署、嵌入、fork 都可以；详细边界见 [LICENSE.BSL](LICENSE.BSL)。
+Hive 是 **source-available（源码可得）** 项目，以 **Business Source License 1.1（BUSL-1.1）** 提供源码。它**不是** OSI 定义的开源（open source）许可，我们也不自称开源项目。
+
+### License FAQ
+
+**为什么不是 OSI 开源？** BUSL-1.1 对生产使用附带一条限制（见下条），不满足开放源代码定义的要求——BUSL 许可文本自己也写明它 "is not an Open Source license"。与其模糊表述，我们选择如实写 source-available。
+
+**个人 / 团队日常使用受影响吗？** 不受影响。[LICENSE.BSL](LICENSE.BSL) 的 Additional Use Grant 明确允许生产使用，唯一例外是：以收费或其他营收安排（含付费支持等）向第三方提供托管 / 嵌入的 Hive、且与 Hive 的多 CLI agent 编排产品形成竞争。个人使用、组织内部部署、嵌入非竞争产品、非商业 fork 都不属于"竞争性产品"。
+
+**以后会变开源吗？** 会。每个版本在 Change Date（2030-05-16）或该版本首次公开发布满四年（以先到者为准）自动转为 **Apache License 2.0**。
 
-Fork 或再分发版本必须保留 [NOTICE](NOTICE)、[LICENSE.BSL](LICENSE.BSL) 和相关许可证文件。Hive 名称、logo 和视觉识别不随源码许可证授权；品牌使用边界见 [TRADEMARK.md](TRADEMARK.md)。
+详细条款以 [LICENSE.BSL](LICENSE.BSL) 为准。Fork 或再分发版本必须保留 [NOTICE](NOTICE)、[LICENSE.BSL](LICENSE.BSL) 和相关许可证文件。Hive 名称、logo 和视觉识别不随源码许可证授权；品牌使用边界见 [TRADEMARK.md](TRADEMARK.md)。

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

@@ -13,6 +13,10 @@ type RunHiveCommandOptions = {
     versionService?: VersionService;
     /** Seam: override the tunnel factory in tests. Defaults to the real createRemoteTunnel. */
     createRemoteTunnel?: (deps: RemoteTunnelDeps) => RemoteTunnel;
+    /** Auto-open the UI in the default browser once listening. Only the real
+     *  CLI entry sets this (with `--no-open` as the opt-out); programmatic
+     *  callers and tests default to no browser. */
+    openBrowser?: boolean;
 };
 /**
  * Signals that should drive a graceful shutdown. The interesting ones:

package/dist/src/cli/hive.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { spawn } from 'node:child_process';
 import { once } from 'node:events';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
@@ -38,11 +39,12 @@ import { runHiveUpdateCommand } from './hive-update.js';
 export const SHUTDOWN_SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGBREAK'];
 export const HIVE_USAGE = [
     'Usage:',
-    '  hive [--port <port>]',
+    '  hive [--port <port>] [--no-open]',
     '  hive update',
     '',
     'Options:',
     '  --port <port>   Bind the local runtime to a specific port (default: 3000).',
+    '  --no-open       Do not auto-open the browser after start.',
     '  -h, --help      Print this help.',
     '  -v, --version   Print the installed Hive version.',
     '',
@@ -66,6 +68,8 @@ const parsePort = (argv) => {
     for (let index = 0; index < argv.length; index += 1) {
         const arg = argv[index];
         if (arg !== '--port') {
+            if (arg === '--no-open')
+                continue; // consumed by the CLI entry's openBrowser gate
             if (arg?.startsWith('-'))
                 throw new Error(`Unknown option: ${arg}`);
             if (arg)
@@ -181,6 +185,20 @@ export const formatPortAccessDeniedMessage = (port, platform = process.platform)
         '  - Or choose another port outside the listed excluded ranges.',
     ].join('\n');
 };
+/* Best-effort default-browser launch. Failure must never affect the runtime:
+   the URL is already printed, so a missing opener (e.g. no xdg-open on a
+   headless box) silently degrades to the manual copy-paste flow. */
+const openUrlInBrowser = (url) => {
+    const child = process.platform === 'darwin'
+        ? spawn('open', [url], { detached: true, stdio: 'ignore' })
+        : process.platform === 'win32'
+            ? // `start` is a cmd built-in; the empty '' is its window-title slot so
+                // the URL is not mistaken for a title.
+                spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' })
+            : spawn('xdg-open', [url], { detached: true, stdio: 'ignore' });
+    child.on('error', () => { });
+    child.unref();
+};
 const formatListenError = (error, requestedPort) => {
     if (isListenError(error) && error.code === 'EADDRINUSE') {
         return new Error(formatPortInUseMessage(error.port ?? requestedPort));
@@ -294,7 +312,11 @@ export const runHiveCommand = async (argv, options = {}) => {
     for (const signal of SHUTDOWN_SIGNALS) {
         process.once(signal, gracefulShutdown);
     }
-    console.log(`Hive running at http://127.0.0.1:${address.port}`);
+    const url = `http://127.0.0.1:${address.port}`;
+    console.log(`Hive running at ${url}`);
+    if (options.openBrowser === true && !argv.includes('--no-open')) {
+        openUrlInBrowser(url);
+    }
     void maybePrintUpdateHint(versionService).catch(() => { });
     return {
         port: address.port,
@@ -328,7 +350,7 @@ if (isMainModule) {
         process.exit(0);
     }
     else {
-        runHiveCommand(argv).catch((error) => {
+        runHiveCommand(argv, { openBrowser: true }).catch((error) => {
             console.error(error instanceof Error ? error.message : error);
             process.exit(1);
         });

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

@@ -29,10 +29,17 @@ export declare const parseMemorySearchArgs: (args: string[]) => {
     limit?: number;
     query: string;
 };
+export declare const parseMemoryDreamShowArgs: (args: string[]) => {
+    runId: string;
+};
+export declare const parseMemoryApplyArgs: (args: string[]) => {
+    runId: string;
+};
+export declare const parseMemoryApplyPayload: (value: string) => unknown;
 export declare const parseMemoryForgetArgs: (args: string[]) => {
     memoryId: string;
 };
 export declare const decodeStdinBuffer: (buffer: Buffer) => string;
-export declare const readStdinToString: (command?: string) => Promise<string>;
+export declare const readStdinToString: (command?: string, usage?: string) => Promise<string>;
 export declare const runTeamCommand: (argv: string[]) => Promise<void>;
 export {};

package/dist/src/cli/team.js

@@ -17,15 +17,12 @@ const TEAM_USAGE = [
     '  team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--tag <tag>]',
     '  team memory show <memory-id>',
     '  team memory search "<query>" [--limit <n>]',
+    '  team memory dream show <dream-run-id>',
+    '  team memory apply --run <dream-run-id> --stdin',
     '  team memory forget <memory-id>',
     '  team send <worker-name> "<task>"',
     `  team spawn <role> [--name <name>] [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>] [--ephemeral]`,
     '  team dismiss <worker-name>',
-    "  team workflow run --stdin [--args '<JSON>']   (script from stdin — for multi-line scripts)",
-    '  team workflow run --inline "<source>" [--args \'<JSON>\']',
-    '  team workflow stop <run-id>',
-    '  team workflow show <run-id>   (full per-agent transcript for one run)',
-    '  team workflow schedule --cron "<cron>" --name <n> --stdin   (register a recurring run)',
     '  team cancel --dispatch <dispatch-id> "<reason>"',
     '  team report "<result>" [--dispatch <dispatch-id>] [--artifact <path>]',
     '  team report --stdin [--dispatch <dispatch-id>] [--artifact <path>]',
@@ -41,7 +38,7 @@ const TEAM_USAGE = [
     '  PowerShell:   Get-Content -Raw -Encoding utf8 body.txt | team report --stdin --dispatch <id>',
     '  Portable:     team report --stdin --dispatch <id> < body.txt',
     '',
-    'For role rules, workflow, and recovery instructions, see .hive/PROTOCOL.md',
+    'For role rules, recovery instructions, and enabled experimental commands, see .hive/PROTOCOL.md',
 ].join('\n');
 const getHiveEnv = () => {
     const values = Object.fromEntries(REQUIRED_ENV_KEYS.map((key) => [key, process.env[key]]));
@@ -113,6 +110,8 @@ const RECALL_USAGE = 'Usage: team recall "<query>" [--limit <n>] [--window <n>]'
 const MEMORY_ADD_USAGE = 'Usage: team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--tag <tag>]';
 const MEMORY_SHOW_USAGE = 'Usage: team memory show <memory-id>';
 const MEMORY_SEARCH_USAGE = 'Usage: team memory search "<query>" [--limit <n>]';
+const MEMORY_DREAM_SHOW_USAGE = 'Usage: team memory dream show <dream-run-id>';
+const MEMORY_APPLY_USAGE = 'Usage: team memory apply --run <dream-run-id> --stdin';
 const MEMORY_FORGET_USAGE = 'Usage: team memory forget <memory-id>';
 const usageFor = (command) => (command === 'status' ? STATUS_USAGE : REPORT_USAGE);
 const withUsage = (message, command) => `${message}\n\n${usageFor(command)}`;
@@ -356,6 +355,66 @@ export const parseMemorySearchArgs = (args) => {
         ...(limit !== undefined ? { limit } : {}),
     };
 };
+export const parseMemoryDreamShowArgs = (args) => {
+    if (args.length !== 1 || !args[0] || args[0].startsWith('--')) {
+        throw new Error(`Missing <dream-run-id>\n\n${MEMORY_DREAM_SHOW_USAGE}`);
+    }
+    return { runId: args[0] };
+};
+export const parseMemoryApplyArgs = (args) => {
+    const positionals = [];
+    let runId;
+    let useStdin = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined)
+            continue;
+        if (arg === '--run') {
+            const next = args[index + 1];
+            if (next === undefined || next.startsWith('--')) {
+                throw new Error(`--run requires a value\n\n${MEMORY_APPLY_USAGE}`);
+            }
+            runId = next;
+            index += 1;
+            continue;
+        }
+        if (arg === '--stdin') {
+            useStdin = true;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            throw new Error(`Unknown argument: ${arg}\n\n${MEMORY_APPLY_USAGE}`);
+        }
+        positionals.push(arg);
+    }
+    if (positionals.length > 0) {
+        throw new Error(`Unexpected positional argument\n\n${MEMORY_APPLY_USAGE}`);
+    }
+    if (!runId) {
+        throw new Error(`Missing --run <dream-run-id>\n\n${MEMORY_APPLY_USAGE}`);
+    }
+    if (!useStdin) {
+        throw new Error(`Missing --stdin\n\n${MEMORY_APPLY_USAGE}`);
+    }
+    return { runId };
+};
+export const parseMemoryApplyPayload = (value) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (error) {
+        throw new Error(`stdin must be valid JSON; got: ${error instanceof Error ? error.message : String(error)}\n\n${MEMORY_APPLY_USAGE}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`stdin JSON must be an object with an ops array\n\n${MEMORY_APPLY_USAGE}`);
+    }
+    const ops = parsed.ops;
+    if (!Array.isArray(ops)) {
+        throw new Error(`stdin JSON must include an ops array\n\n${MEMORY_APPLY_USAGE}`);
+    }
+    return ops;
+};
 export const parseMemoryForgetArgs = (args) => {
     if (args.length === 0 || !args[0] || args[0].startsWith('--')) {
         throw new Error(`Missing <memory-id>\n\n${MEMORY_FORGET_USAGE}`);
@@ -379,9 +438,9 @@ export const decodeStdinBuffer = (buffer) => {
     }
     return buffer.toString('utf8');
 };
-export const readStdinToString = async (command = 'report') => {
+export const readStdinToString = async (command = 'report', usage = usageFor(command)) => {
     if (process.stdin.isTTY) {
-        throw new Error(withUsage('--stdin requires piped input, but stdin is a TTY. Did you forget to pipe content in?', command));
+        throw new Error(`--stdin requires piped input, but stdin is a TTY. Did you forget to pipe content in?\n\n${usage}`);
     }
     const chunks = [];
     for await (const chunk of process.stdin) {
@@ -389,7 +448,7 @@ export const readStdinToString = async (command = 'report') => {
     }
     const content = decodeStdinBuffer(Buffer.concat(chunks));
     if (!content.trim()) {
-        throw new Error(withUsage('--stdin received empty input', command));
+        throw new Error(`--stdin received empty input\n\n${usage}`);
     }
     return content;
 };
@@ -486,6 +545,36 @@ export const runTeamCommand = async (argv) => {
             console.log(JSON.stringify(await response.json()));
             return;
         }
+        if (subcommand === 'dream') {
+            const [dreamSubcommand, ...dreamArgs] = memoryArgs;
+            if (dreamSubcommand !== 'show') {
+                throw new Error(MEMORY_DREAM_SHOW_USAGE);
+            }
+            const dream = parseMemoryDreamShowArgs(dreamArgs);
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/memory/dream/show', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                run_id: dream.runId,
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
+        if (subcommand === 'apply') {
+            const apply = parseMemoryApplyArgs(memoryArgs);
+            const ops = parseMemoryApplyPayload(await readStdinToString('memory apply', MEMORY_APPLY_USAGE));
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/memory/apply', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                run_id: apply.runId,
+                ops,
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
         if (subcommand === 'forget') {
             const memory = parseMemoryForgetArgs(memoryArgs);
             const env = getHiveEnv();
@@ -503,6 +592,8 @@ export const runTeamCommand = async (argv) => {
             `  ${MEMORY_ADD_USAGE}`,
             `  ${MEMORY_SHOW_USAGE}`,
             `  ${MEMORY_SEARCH_USAGE}`,
+            `  ${MEMORY_DREAM_SHOW_USAGE}`,
+            `  ${MEMORY_APPLY_USAGE}`,
             `  ${MEMORY_FORGET_USAGE}`,
         ].join('\n'));
     }
@@ -531,6 +622,10 @@ export const runTeamCommand = async (argv) => {
         if (payload.restarted_worker === true) {
             console.error(`Hive woke up worker "${workerName}" before dispatching.`);
         }
+        if (payload.queued === true) {
+            console.error(`Worker "${workerName}" is stopped — the dispatch is queued and will be delivered automatically when the worker is next started. ` +
+                'Tell the user to start it in the Hive UI if this should run now, or `team cancel --dispatch <id>` to reassign.');
+        }
         console.log(JSON.stringify(payload));
         return;
     }
@@ -698,19 +793,24 @@ export const runTeamCommand = async (argv) => {
             '  team workflow run --inline "<source>" [--args ...]  (one-arg form)\n' +
             '  team workflow stop <run-id>                     (cancel a running workflow)\n' +
             '  team workflow show <run-id>                     (full per-agent transcript)\n' +
-            '  team workflow schedule --cron "<cron>" --name <n> --stdin   (register a recurring run)');
+            '  team workflow schedule --cron "<cron>" --name <n> --stdin   (register a recurring run)\n' +
+            '  Note: workflow commands are experimental and may be disabled in this workspace; re-read .hive/PROTOCOL.md for the enabled command set.');
     }
     if (command === 'cancel') {
         const cancel = parseCancelArgs(args);
         const env = getHiveEnv();
         const baseUrl = getBaseUrl(env);
-        await postJson(baseUrl, '/api/team/cancel', {
+        const response = await postJson(baseUrl, '/api/team/cancel', {
             dispatch_id: cancel.dispatchId,
             project_id: env.HIVE_PROJECT_ID,
             from_agent_id: env.HIVE_AGENT_ID,
             token: env.HIVE_AGENT_TOKEN,
             reason: cancel.reason,
         });
+        const payload = (await response.json());
+        if (payload.forwarded === false && payload.forward_error) {
+            console.error(`Hive cancelled the dispatch in the ledger, but could not deliver the cancel notice to the worker: ${payload.forward_error}. The worker may still be acting on the task.`);
+        }
         return;
     }
     if (command === 'status') {

package/dist/src/server/action-center-summary.d.ts

@@ -0,0 +1,193 @@
+import type { RuntimeStore } from './runtime-store.js';
+export declare const buildActionCenterSummary: (input: {
+    includeTextEvidence?: boolean;
+    now?: number;
+    store: RuntimeStore;
+    workspaceId: string;
+}) => {
+    attention: Record<string, unknown>[];
+    generated_at: number;
+    recent_activity: ({
+        kind: string;
+        status: import("./dispatch-ledger-store.js").DispatchStatus;
+        submitted_at: number | null;
+        timestamp: number;
+        to_agent_id: string;
+        to_worker_name: string | null;
+        workflow_run_id: string | null;
+        label: string | null;
+        phase: string | null;
+        report_preview: string | null;
+        task_preview: string | null;
+        has_label?: never;
+        has_phase?: never;
+        created_at: number;
+        id: string;
+    } | {
+        kind: string;
+        status: import("./dispatch-ledger-store.js").DispatchStatus;
+        submitted_at: number | null;
+        timestamp: number;
+        to_agent_id: string;
+        to_worker_name: string | null;
+        workflow_run_id: string | null;
+        has_label: boolean;
+        has_phase: boolean;
+        label?: never;
+        phase?: never;
+        report_preview?: never;
+        task_preview?: never;
+        created_at: number;
+        id: string;
+    })[];
+    summary: {
+        idle_workers: number;
+        open_dispatches: number;
+        recent_reports: number;
+        stopped_with_queue: number;
+        stopped_workers: number;
+        total_workers: number;
+        waiting_reports: number;
+        working_workers: number;
+    };
+    workers: ({
+        terminal_hint: string | null;
+        current_dispatch: {
+            status: import("./dispatch-ledger-store.js").DispatchStatus;
+            submitted_at: number | null;
+            timestamp: number;
+            to_agent_id: string;
+            to_worker_name: string | null;
+            workflow_run_id: string | null;
+            label: string | null;
+            phase: string | null;
+            report_preview: string | null;
+            task_preview: string | null;
+            has_label?: never;
+            has_phase?: never;
+            created_at: number;
+            id: string;
+        } | {
+            status: import("./dispatch-ledger-store.js").DispatchStatus;
+            submitted_at: number | null;
+            timestamp: number;
+            to_agent_id: string;
+            to_worker_name: string | null;
+            workflow_run_id: string | null;
+            has_label: boolean;
+            has_phase: boolean;
+            label?: never;
+            phase?: never;
+            report_preview?: never;
+            task_preview?: never;
+            created_at: number;
+            id: string;
+        } | null;
+        id: string;
+        latest_report: {
+            status: import("./dispatch-ledger-store.js").DispatchStatus;
+            submitted_at: number | null;
+            timestamp: number;
+            to_agent_id: string;
+            to_worker_name: string | null;
+            workflow_run_id: string | null;
+            label: string | null;
+            phase: string | null;
+            report_preview: string | null;
+            task_preview: string | null;
+            has_label?: never;
+            has_phase?: never;
+            created_at: number;
+            id: string;
+        } | {
+            status: import("./dispatch-ledger-store.js").DispatchStatus;
+            submitted_at: number | null;
+            timestamp: number;
+            to_agent_id: string;
+            to_worker_name: string | null;
+            workflow_run_id: string | null;
+            has_label: boolean;
+            has_phase: boolean;
+            label?: never;
+            phase?: never;
+            report_preview?: never;
+            task_preview?: never;
+            created_at: number;
+            id: string;
+        } | null;
+        name: string;
+        pending_task_count: number;
+        role: import("../shared/types.js").WorkerRole;
+        status: "idle" | "working" | "stopped";
+    } | {
+        terminal_hint?: never;
+        current_dispatch: {
+            status: import("./dispatch-ledger-store.js").DispatchStatus;
+            submitted_at: number | null;
+            timestamp: number;
+            to_agent_id: string;
+            to_worker_name: string | null;
+            workflow_run_id: string | null;
+            label: string | null;
+            phase: string | null;
+            report_preview: string | null;
+            task_preview: string | null;
+            has_label?: never;
+            has_phase?: never;
+            created_at: number;
+            id: string;
+        } | {
+            status: import("./dispatch-ledger-store.js").DispatchStatus;
+            submitted_at: number | null;
+            timestamp: number;
+            to_agent_id: string;
+            to_worker_name: string | null;
+            workflow_run_id: string | null;
+            has_label: boolean;
+            has_phase: boolean;
+            label?: never;
+            phase?: never;
+            report_preview?: never;
+            task_preview?: never;
+            created_at: number;
+            id: string;
+        } | null;
+        id: string;
+        latest_report: {
+            status: import("./dispatch-ledger-store.js").DispatchStatus;
+            submitted_at: number | null;
+            timestamp: number;
+            to_agent_id: string;
+            to_worker_name: string | null;
+            workflow_run_id: string | null;
+            label: string | null;
+            phase: string | null;
+            report_preview: string | null;
+            task_preview: string | null;
+            has_label?: never;
+            has_phase?: never;
+            created_at: number;
+            id: string;
+        } | {
+            status: import("./dispatch-ledger-store.js").DispatchStatus;
+            submitted_at: number | null;
+            timestamp: number;
+            to_agent_id: string;
+            to_worker_name: string | null;
+            workflow_run_id: string | null;
+            has_label: boolean;
+            has_phase: boolean;
+            label?: never;
+            phase?: never;
+            report_preview?: never;
+            task_preview?: never;
+            created_at: number;
+            id: string;
+        } | null;
+        name: string;
+        pending_task_count: number;
+        role: import("../shared/types.js").WorkerRole;
+        status: "idle" | "working" | "stopped";
+    })[];
+    workspace_id: string;
+};