@tt-a1i/hive 2.1.6 → 2.1.8

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 All notable user-facing changes will be documented in this file.
 
+## 2.1.8 - 2026-06-23
+
+Codex terminal editing and member-window polish.
+
+- Fixes Codex terminal input repainting for Chinese/CJK text so pressing
+  backspace updates the visible input line immediately instead of leaving stale
+  characters on screen.
+- Removes the visible desktop member-window close button from the terminal
+  corner and adds an outside-click close hint, giving the terminal more clean
+  space while keeping mobile's full-screen close affordance.
+
+## 2.1.7 - 2026-06-23
+
+Team delivery recovery and remote-access hardening.
+
+- Makes worker reports durable when the Orchestrator is offline or restarting,
+  so completed work is queued for redelivery instead of being silently lost.
+- Tightens cancel, worker-dismiss, and queued-dispatch recovery paths so stale
+  work gets a clear dropped/cancelled outcome instead of leaving agents waiting.
+- Makes user input delivery truthful: if the Orchestrator terminal is offline,
+  Hive rejects the input instead of recording a message that was never sent.
+- Standardizes remote-access HTTP responses on snake_case fields and keeps the
+  web UI mapping them back into its internal camelCase model.
+- Blocks remote devices from reading or approving desktop-only pairing
+  approvals through the tunnel, while preserving normal equal-authority device
+  management routes.
+
 ## 2.1.6 - 2026-06-21
 
 Team UX polish and release visibility.

package/dist/src/server/agent-runtime-contract.d.ts

@@ -23,26 +23,18 @@ export interface AgentRuntime {
     startAgent: (workspace: WorkspaceSummary, agentId: string, input: StartAgentOptions) => Promise<LiveAgentRun>;
     stopAgentRun: (runId: string) => void;
     validateAgentToken: AgentTokenRegistry['validate'];
-    writeReportPrompt: (workspaceId: string, workerName: string, workerId: string, text: string, artifacts: string[], input?: {
-        requireActiveRun?: boolean;
-    }) => void;
     writeStatusPrompt: (workspaceId: string, workerName: string, workerId: string, text: string, artifacts: string[], input?: {
         requireActiveRun?: boolean;
     }) => void;
     writeSendPrompt: (workspaceId: string, workerId: string, dispatchId: string, fromAgentName: string, workerDescription: string, text: string) => Promise<void>;
     writeCancelPrompt: (workspaceId: string, workerId: string, dispatchId: string, reason: string, input?: {
         requireActiveRun?: boolean;
-    }) => void;
+    }) => Promise<void>;
     writeUserInputPrompt: (workspaceId: string, text: string) => void;
     writeSystemMessageToAgent: (workspaceId: string, agentId: string, text: string) => void;
     deliverUserInputToOrchestrator: (workspaceId: string, text: string, input?: {
         requireActiveRun?: boolean;
     }) => Promise<void>;
-    /** Awaitable report delivery — rejects if the orchestrator PTY write fails,
-     *  so the caller can persist the report to the redelivery outbox. */
-    deliverReportToOrchestrator: (workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
-        requireActiveRun?: boolean;
-    }) => Promise<void>;
     /** Awaitable opaque delivery — used to drain the report outbox so an entry
      *  is marked delivered only after the PTY write resolves. */
     deliverSystemMessageToAgent: (workspaceId: string, agentId: string, text: string, input?: {

package/dist/src/server/agent-runtime.js

@@ -139,9 +139,6 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
             });
         },
         validateAgentToken: tokenRegistry.validate,
-        writeReportPrompt(workspaceId, workerName, _workerId, text, artifacts, input = {}) {
-            stdinDispatcher.writeReportPrompt(workspaceId, workerName, text, artifacts, input);
-        },
         writeStatusPrompt(workspaceId, workerName, _workerId, text, artifacts, input = {}) {
             stdinDispatcher.writeStatusPrompt(workspaceId, workerName, text, artifacts, input);
         },
@@ -149,7 +146,7 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
             return stdinDispatcher.writeSendPrompt(workspaceId, workerId, dispatchId, fromAgentName, workerDescription, text);
         },
         writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input = {}) {
-            stdinDispatcher.writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input);
+            return stdinDispatcher.writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input);
         },
         writeUserInputPrompt(workspaceId, text) {
             stdinDispatcher.writeUserInputPrompt(workspaceId, text);
@@ -160,9 +157,6 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
         deliverUserInputToOrchestrator(workspaceId, text, input = {}) {
             return stdinDispatcher.deliverUserInputToOrchestrator(workspaceId, text, input);
         },
-        deliverReportToOrchestrator(workspaceId, workerName, text, artifacts, input = {}) {
-            return stdinDispatcher.deliverReportToOrchestrator(workspaceId, workerName, text, artifacts, input);
-        },
         deliverSystemMessageToAgent(workspaceId, agentId, text, input = {}) {
             return stdinDispatcher.deliverSystemMessageToAgent(workspaceId, agentId, text, input);
         },

package/dist/src/server/agent-stdin-dispatcher.d.ts

@@ -16,22 +16,19 @@ interface AgentStdinDispatcherInput {
      *  Optional; omitted → all flags off. */
     getFlags?: () => FeatureFlags;
 }
-export declare const buildOrchestratorReportPayload: (workerName: string, text: string, artifacts: string[], flags?: FeatureFlags) => string;
+export declare const buildOrchestratorReportPayload: (workerName: string, text: string, artifacts: string[], flags?: FeatureFlags, dispatchId?: string) => string;
 export declare const buildOrchestratorStatusPayload: (workerName: string, text: string, artifacts: string[], flags?: FeatureFlags) => string;
 export declare const buildOrchestratorUserInputPayload: (text: string, flags?: FeatureFlags) => string;
 export declare const buildWorkerDispatchPayload: (fromAgentName: string, workerDescription: string, dispatchId: string, text: string, memoryDigest?: string | null) => string;
 export declare const buildWorkerCancelPayload: (dispatchId: string, reason: string) => string;
 export declare const createAgentStdinDispatcher: ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, memoryInjection, getFlags, }: AgentStdinDispatcherInput) => {
-    writeReportPrompt(workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
-        requireActiveRun?: boolean;
-    }): void;
     writeStatusPrompt(workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
         requireActiveRun?: boolean;
     }): void;
     writeSendPrompt(workspaceId: string, workerId: string, dispatchId: string, fromAgentName: string, workerDescription: string, text: string): Promise<void>;
     writeCancelPrompt(workspaceId: string, workerId: string, dispatchId: string, reason: string, input?: {
         requireActiveRun?: boolean;
-    }): void;
+    }): Promise<void>;
     writeUserInputPrompt(workspaceId: string, text: string): void;
     deliverUserInputToOrchestrator(workspaceId: string, text: string, input?: {
         requireActiveRun?: boolean;
@@ -40,12 +37,6 @@ export declare const createAgentStdinDispatcher: ({ agentManager, getLaunchConfi
      *  Used by the workflow runner to notify the triggering orchestrator
      *  when a run finishes (mirrors Claude Code's <task-notification>). */
     writeSystemMessageToAgent(workspaceId: string, agentId: string, text: string): void;
-    /** Awaitable report delivery — same payload as writeReportPrompt but the
-     *  promise is returned so the caller can persist the report to the
-     *  redelivery outbox if the orchestrator PTY write rejects. */
-    deliverReportToOrchestrator(workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
-        requireActiveRun?: boolean;
-    }): Promise<void>;
     /** Awaitable opaque delivery — used to drain the report outbox so an entry
      *  is marked delivered only after the PTY write actually resolves. */
     deliverSystemMessageToAgent(workspaceId: string, agentId: string, text: string, input?: {

package/dist/src/server/agent-stdin-dispatcher.js

@@ -4,9 +4,20 @@ import { buildOrchestratorReminderTail, buildWorkerReminderTail } from './hive-t
 import { PtyInactiveError } from './http-errors.js';
 import { createPostStartInputWriter } from './post-start-input-writer.js';
 import { buildDispatchMemoryDigestSafely, logMemoryDigestInjection, rollbackMemoryDigestInjection, } from './team-memory-injection.js';
-export const buildOrchestratorReportPayload = (workerName, text, artifacts, flags = FEATURE_FLAGS_ALL_OFF) => {
+export const buildOrchestratorReportPayload = (workerName, text, artifacts, flags = FEATURE_FLAGS_ALL_OFF, dispatchId) => {
+    const dispatchAttribute = dispatchId
+        ? ` dispatch="${escapeHiveEnvelopeAttribute(dispatchId)}"`
+        : '';
     const lines = [
-        `<hive-message kind="report" from="@${escapeHiveEnvelopeAttribute(workerName)}">`,
+        `<hive-message kind="report" from="@${escapeHiveEnvelopeAttribute(workerName)}"${dispatchAttribute}>`,
+        ...(dispatchId
+            ? [
+                '',
+                `dispatch_id: ${escapeHiveEnvelopeText(dispatchId)}`,
+                'If this dispatch_id report was already processed, treat this as a duplicate redelivery and ignore it.',
+                '',
+            ]
+            : []),
         escapeHiveEnvelopeText(text),
     ];
     for (const artifact of artifacts)
@@ -166,9 +177,6 @@ export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getW
         });
     };
     return {
-        writeReportPrompt(workspaceId, workerName, text, artifacts, input = {}) {
-            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorReportPayload(workerName, text, artifacts, flags()), input));
-        },
         writeStatusPrompt(workspaceId, workerName, text, artifacts, input = {}) {
             swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorStatusPayload(workerName, text, artifacts, flags()), input));
         },
@@ -206,7 +214,7 @@ export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getW
             }
         },
         writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input = {}) {
-            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, workerId, buildWorkerCancelPayload(dispatchId, reason), input));
+            return writeToActiveAgentRun(workspaceId, workerId, buildWorkerCancelPayload(dispatchId, reason), input);
         },
         writeUserInputPrompt(workspaceId, text) {
             swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorUserInputPayload(text, flags())));
@@ -220,12 +228,6 @@ export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getW
         writeSystemMessageToAgent(workspaceId, agentId, text) {
             swallowQueuedFailure(writeToActiveAgentRun(workspaceId, agentId, text));
         },
-        /** Awaitable report delivery — same payload as writeReportPrompt but the
-         *  promise is returned so the caller can persist the report to the
-         *  redelivery outbox if the orchestrator PTY write rejects. */
-        deliverReportToOrchestrator(workspaceId, workerName, text, artifacts, input = {}) {
-            return writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorReportPayload(workerName, text, artifacts, flags()), input);
-        },
         /** Awaitable opaque delivery — used to drain the report outbox so an entry
          *  is marked delivered only after the PTY write actually resolves. */
         deliverSystemMessageToAgent(workspaceId, agentId, text, input = {}) {

package/dist/src/server/hive-team-guidance.js

@@ -20,8 +20,8 @@ import { DEFAULT_WORKFLOW_CLI_POLICY } from './workflow-cli-policy.js';
  */
 export const buildOrchestratorReminderTail = ({ workflowsEnabled }) => {
     const body = 'You are the Hive Orchestrator. Reply with one of: ' +
-        '(a) `team send "<worker-name>" "<task>"` to dispatch — run `team list` first if the roster may have changed since your last view (Hive does not push membership changes; stale names fail). ' +
-        `If no worker fits, the roster is empty, or independent branches need more workers, \`team spawn <role> [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>]\` to create one (add \`--ephemeral\` for a one-shot), then dispatch; do not take a branch yourself or ask the user to add workers. ` +
+        '(a) `team list`, then `team send "<worker-name>" "<task>"` to dispatch to a suitable existing worker by name. Prefer user-created/user-managed workers already in the roster; stale names fail. ' +
+        `If no existing worker fits, a worker is stopped/queued/not prompt-ready, or independent branches need more workers, report that condition and recommend what worker the user may start or add; do not take a branch yourself. Use \`team spawn <role> [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>] [--ephemeral]\` only when the user explicitly authorizes it or workspace policy permits autonomous staffing for this task. ` +
         '(b) `team cancel --dispatch <id> "<reason>"` to close an obsolete dispatch. ' +
         (workflowsEnabled
             ? '(c) `team workflow run --stdin` to fan out across 3+ workers or run a staged review→fix — never a loop of `team send` (no barrier, no UI group, no stop button). (d) plain text only for clarification, status/final synthesis, or the explicitly allowed trivial check. '
@@ -52,16 +52,17 @@ export const buildWorkerReminderTail = (dispatchId) => '<hive-system-reminder>\n
 const CORE_ORCHESTRATOR_RULES = [
     'A Hive worker is a real CLI agent shown as a card on the right — NOT a subagent of your own CLI.',
     'Dispatch against the current roster: re-run `team list` before a `team send` whenever a user reply or one of your own dispatches/cancels has happened since your last list. Hive never pushes membership changes, so do not dispatch from a remembered roster — a renamed or removed worker fails.',
-    'Default to dispatching: parallelism, long execution, audit/review/test/validation work, multi-file code changes, test-writing, a dedicated role, or the user asking for a worker all mean `team send` or `team spawn` then `team send`. The only work you may do yourself is this closed exception: a trivial single-file read-only inspection or config value check that needs no tests, no audit/review/validation judgement, no edits, and no parallel branch. Any edit, even a typo fix, goes through a Hive worker or Hive workflow. If you would write tests, inspect a diff for correctness/security, touch files, or run a review/fix chain, dispatch it.',
-    'When work splits into independent branches and the roster lacks enough suitable workers, spawn additional workers (usually `--ephemeral`) and dispatch each branch; do not keep one branch for yourself as a way to parallelize.',
+    'Default to dispatching through the existing roster: parallelism, long execution, audit/review/test/validation work, multi-file code changes, test-writing, a dedicated role, or the user asking for a worker all mean `team list` then `team send` to suitable current workers first. The only work you may do yourself is this closed exception: a trivial single-file read-only inspection or config value check that needs no tests, no audit/review/validation judgement, no edits, and no parallel branch. Any edit, even a typo fix, goes through a Hive worker or Hive workflow. If you would write tests, inspect a diff for correctness/security, touch files, or run a review/fix chain, dispatch it.',
+    'Prefer user-created/user-managed workers. If you cannot see ownership in the current output, treat existing named workers as user-managed unless the name was just returned by your own `team spawn`.',
+    'When work splits into independent branches and the roster lacks enough suitable workers, explain the role/capacity gap and recommend additional workers the user may add or start; spawn additional workers yourself only when the user explicitly authorizes it or workspace policy permits autonomous staffing for this task; do not keep one branch for yourself as a way to parallelize.',
     'If exactly one worker is available, dispatch to it directly with `team send <worker-name> "<task>"` — do not bounce the choice back to the user.',
     'When the user says "have a worker do X", dispatch it with `team send <worker-name> "<task>"`.',
-    `If the roster is empty or lacks the role the task needs, build the team yourself: \`team spawn <role> [--name <n>] [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>]\`, then immediately dispatch. Do not stop to ask the user to add members — that call is yours. Without \`--name\` the worker is named after the bare role label when that name is free (\`team spawn researcher\` → \`team send researcher "<task>"\`); on a collision the name gets a uuid suffix — the spawn response always echoes the final \`name\`, so dispatch to the echoed name.`,
-    '`team spawn` is PERSISTENT by default (a normal member that stays in the workspace); add `--ephemeral` for a one-shot worker that auto-dismisses after its first `team report`. Rule of thumb: will you reuse this role in the next 10 minutes? Yes → persistent; no → `--ephemeral`.',
+    `If the roster is empty or lacks the role the task needs, report the gap to the user and recommend the missing worker role. Use \`team spawn <role> [--name <n>] [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>]\` only when the user explicitly asks you to create workers, the user has already granted permission for autonomous staffing, or workspace policy clearly permits it. Without \`--name\` the worker is named after the bare role label when that name is free (\`team spawn researcher\` → \`team send researcher "<task>"\`); on a collision the name gets a uuid suffix — the spawn response always echoes the final \`name\`, so dispatch to the echoed name.`,
+    '`team spawn` is PERSISTENT by default (a normal member that stays in the workspace); add `--ephemeral` for a one-shot worker that auto-dismisses after its first `team report`. If you are authorized to spawn for one task, prefer `--ephemeral` unless the user asks for persistent capacity.',
     'All Hive workers in one workspace share the same filesystem root with no per-worker isolation. Split dispatches so no two workers edit the same files/modules at the same time; if work would collide, serialize it or assign one owner.',
-    'When you spawn a reviewer to audit work another CLI produced, prefer a different `--cli` than the implementer used — cross-provider review catches blind spots a model shares with itself.',
+    'When you are authorized to spawn a reviewer to audit work another CLI produced, prefer a different `--cli` than the implementer used — cross-provider review catches blind spots a model shares with itself.',
     'When the user cancels or changes direction on an open dispatch, close it explicitly with `team cancel --dispatch <id> "<reason>"` — do not just say "cancel" in prose.',
-    'A `team send` to a user-added STOPPED worker parks the dispatch (the response carries `queued: true`): it is delivered automatically when the user starts that worker. Workers you created with `team spawn` are woken by the follow-up `team send`. If a user-added stopped worker should run now, tell the user the worker needs a start, or `team cancel` it and dispatch to a running worker.',
+    'A `team send` to a user-added STOPPED worker parks the dispatch (the response carries `queued: true`): it is delivered automatically when the user starts that worker. Treat stopped, queued, delivery-failed, or prompt-readiness-timeout states as runtime/roster conditions to report or retry against existing workers; do not treat them as proof the worker is unsuitable. Workers you created with `team spawn` are woken by the follow-up `team send`.',
     'Each `team send` opens a SEPARATE dispatch with its own pending count and its own required report — it is not a way to tack context onto a dispatch already in flight. Send the same worker twice and it owes you TWO reports; one report closes only one dispatch (the one its `--dispatch <id>` names, or the oldest open one if the flag is omitted), so the other stays open and the worker is pinned on `working`. To change or extend an in-flight task, `team cancel --dispatch <id> "<reason>"` the stale dispatch and re-send the whole task, or wait for the worker to report and dispatch the follow-up after.',
     'Only orchestrators can add memory directly; workers should report durable findings for the orchestrator or Dream to capture. Search memory before adding: use `team memory search "<query>"` to avoid duplicates. Use `team memory add "<body>"` only for rare, evidence-backed workspace facts, decisions, and pitfalls that should help future Hive agents across sessions. Nothing worth saving is a normal outcome; do not add memory just to prove you used it. Use `team memory forget <memory-id>` only to archive obsolete memory.',
     "Never substitute your CLI's own built-in background agents, exploration helpers, subagent runners, or workflow runners for Hive workers or Hive workflows — they run inside your CLI process, bypass Hive's PTY fleet, never appear in the UI or `team list`, and the stop button cannot reach them.",
@@ -89,7 +90,7 @@ const WORKFLOW_ORCHESTRATOR_RULES = [
  * workflows are available it defers one-shot batch fan-out to `team workflow
  * run` so the two experiments don't give the orchestrator competing advice.
  */
-const buildAutostaffRule = (workflowsEnabled) => 'You may size the team to the task instead of adding workers one at a time: judge what mix of roles runs it fastest (e.g. a couple of coders plus a reviewer and a tester) and issue the individual `team spawn <role> --ephemeral` commands you need up front — one command per member (there is no batch form), this call is yours, do not ask the user. Match the count to the work: more agents is not faster once they would collide or sit idle. Use `--ephemeral` so this task-scoped staff auto-dismiss after reporting and do not pile up.' +
+const buildAutostaffRule = (workflowsEnabled) => 'Auto-staff guidance is available: you may size the team to the task after checking the current roster, but existing user-created/user-managed workers still have priority. If extra parallel capacity would materially help, state the missing role/count and prefer recommending those additions to the user. Issue individual `team spawn <role> --ephemeral` commands yourself only when the user has authorized autonomous staffing or workspace policy explicitly permits it — one command per member (there is no batch form). Match the count to the work: more agents is not faster once they would collide or sit idle. Use `--ephemeral` so task-scoped staff auto-dismiss after reporting and do not pile up.' +
     (workflowsEnabled
         ? ' When the work is a one-shot fan-out across 3+ workers or a staged review→fix that runs to completion, prefer `team workflow run` (barrier, phase tree, stop button) over a batch of `team spawn`; reserve up-front staffing for a standing team you direct interactively across several turns.'
         : '');
@@ -327,8 +328,8 @@ export const buildProtocolDoc = (cliPolicy = DEFAULT_WORKFLOW_CLI_POLICY, flags
         '- `team memory apply --run <dream-run-id> --stdin` — apply strict JSON Dream ops for a pending maintenance run',
         '- `team memory forget <memory-id>` — archive obsolete memory (orchestrator only; does not physically delete evidence)',
         '- `team send "<worker-name>" "<task>"` — dispatch to a worker by name (never id)',
-        `- \`team spawn <role> [--name <name>] [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>]\` — create a PERSISTENT member when none fits (or when the roster is empty)`,
-        '- `team spawn <role> --ephemeral [other-flags]` — create a one-shot worker that auto-dismisses after its first `team report`',
+        `- \`team spawn <role> [--name <name>] [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>]\` — create a PERSISTENT member only when the user or workspace policy has authorized autonomous staffing`,
+        '- `team spawn <role> --ephemeral [other-flags]` — create an authorized one-shot worker that auto-dismisses after its first `team report`',
         '- `team dismiss <worker-name>` — remove a worker that is no longer needed (works on any worker, including persistent ones; ephemeral workers auto-dismiss after their first report)',
         '- `team cancel --dispatch <id> "<reason>"` — cancel an obsolete open dispatch',
         ...workflowCliCommands,

package/dist/src/server/post-start-input-writer.js

@@ -8,7 +8,7 @@ const MIN_SUBMIT_AFTER_PASTE_DELAY_MS = 600;
 const MAX_SUBMIT_AFTER_PASTE_DELAY_MS = 1500;
 const PASTE_CHARS_PER_DELAY_MS = 4;
 const PASTE_ACK_CHECK_INTERVAL_MS = 50;
-const PASTE_ACK_SETTLE_DELAY_MS = 100;
+const PASTE_ACK_SETTLE_DELAY_MS = 250;
 const CODEX_PASTE_ACK_SETTLE_DELAY_MS = 250;
 const PASTE_ACK_TIMEOUT_MS = 3000;
 const CLAUDE_HIVE_PASTE_ACK_TIMEOUT_MS = 10000;

package/dist/src/server/report-outbox-store.d.ts

@@ -1,15 +1,16 @@
 import type { Database } from 'better-sqlite3';
 /**
- * Durable redelivery queue for worker reports the orchestrator could not
- * receive. `team report` persists the dispatch as reported and forwards the
- * report into the orchestrator's stdin best-effort; if that write fails (the
- * PTY exited / is mid-restart, or the orchestrator was down at report time)
- * the report would otherwise be lost — the ledger says "reported" yet the
- * orchestrator waits forever, indistinguishable from a hang.
+ * Durable redelivery queue for protocol messages a live agent could not
+ * receive. The primary producer is `team report`: it persists the dispatch as
+ * reported and forwards the report into the orchestrator's stdin; if that write
+ * fails (the PTY exited / is mid-restart, or the orchestrator was down at report
+ * time) the report would otherwise be lost — the ledger says "reported" yet the
+ * orchestrator waits forever, indistinguishable from a hang. Dispatch-drop
+ * notifications use the same queue for their issuer.
  *
  * Entries are keyed by dispatch id (UNIQUE) so a report enqueues at most once,
- * and drain marks them delivered only after the orchestrator PTY write
- * actually resolves, so a failed redelivery stays pending for the next drain.
+ * and drain marks them delivered only after the target PTY write actually
+ * resolves, so a failed redelivery stays pending for the next drain.
  */
 export interface ReportOutboxEntry {
     id: number;
@@ -27,6 +28,7 @@ interface EnqueueInput {
     payload: string;
 }
 export declare const createReportOutboxStore: (db: Database) => {
+    deletePendingForDispatch: (dispatchId: string) => void;
     enqueue: (input: EnqueueInput) => void;
     listPending: (workspaceId: string, targetAgentId: string) => ReportOutboxEntry[];
     markDelivered: (id: number) => void;

package/dist/src/server/report-outbox-store.js

@@ -25,9 +25,18 @@ export const createReportOutboxStore = (db) => {
     const markDelivered = (id) => {
         db.prepare(`UPDATE report_outbox SET delivered_at = ? WHERE id = ? AND delivered_at IS NULL`).run(Date.now(), id);
     };
+    const deletePendingForDispatch = (dispatchId) => {
+        db.prepare('DELETE FROM report_outbox WHERE dispatch_id = ? AND delivered_at IS NULL').run(dispatchId);
+    };
     const pendingCount = (workspaceId, targetAgentId) => db
         .prepare(`SELECT COUNT(*) AS n FROM report_outbox
            WHERE workspace_id = ? AND target_agent_id = ? AND delivered_at IS NULL`)
         .get(workspaceId, targetAgentId).n;
-    return { enqueue, listPending, markDelivered, pendingCount };
+    return {
+        deletePendingForDispatch,
+        enqueue,
+        listPending,
+        markDelivered,
+        pendingCount,
+    };
 };

package/dist/src/server/role-templates.js

@@ -1,9 +1,11 @@
 import { TASKS_RELATIVE_PATH } from './tasks-file.js';
 export const ORCHESTRATOR_ROLE_DESCRIPTION = [
-    'You are the Hive Orchestrator. You reply to the user directly and coordinate real workers shown on the right.',
+    'You are the Hive Orchestrator. You interface with the user and coordinate the other agent members in the current Hive workspace to get the work done.',
     'How to work:',
     '- Clarify the goal and split it into dispatchable tasks.',
-    '- Default to Hive dispatch: use `team send`, `team spawn`, or Hive `team workflow` for implementation, audit/review, test, validation, multi-file, or parallel work; do not use your CLI built-in subagents/workflows or keep a non-trivial branch for yourself.',
+    '- Default to Hive dispatch through the existing roster: use `team list`, then `team send` to suitable user-created/user-managed workers for implementation, audit/review, test, validation, multi-file, or parallel work.',
+    '- Do not create new members by default. Based on the task goal, if the current team lacks a suitable member, lacks enough parallel capacity, or adding a member would clearly improve speed and efficiency, explain the gap and recommend which agent member the user should add or start; use `team spawn` only when explicitly authorized by the user or the current workspace rules allow it.',
+    '- Do not use your CLI built-in subagents/workflows or keep a non-trivial branch for yourself.',
     `- Maintain ${TASKS_RELATIVE_PATH} so plan, progress, and blockers stay trackable.`,
     '- Drive the next step from worker reports; do not bounce choices back to the user unless a real decision is missing.',
 ].join('\n');
@@ -51,10 +53,12 @@ export const CUSTOM_ROLE_DESCRIPTION = [
     '- Done criteria: what results, risks, and blockers to report.',
 ].join('\n');
 export const ORCHESTRATOR_ROLE_DESCRIPTION_ZH = [
-    '你是 Hive Orchestrator。你直接回复用户，并协调右侧真实 worker。',
+    '你是 Hive Orchestrator，负责对接用户，并组织协调当前 Hive workspace 中的其他 agent 成员协作完成任务。',
     '工作方式：',
     '- 澄清目标，把需求拆成可派发的小任务。',
-    '- 默认走 Hive 派单：实现、审计/复核、测试、验证、多文件或并行任务用 `team send`、`team spawn` 或 Hive `team workflow`；不要用当前 CLI 内建子代理/工作流，也不要把非平凡分支留给自己。',
+    '- 默认通过当前团队中已有的 agent 成员走 Hive 派单：先用 `team list` 刷新成员列表，再把实现、审计/复核、测试、验证、多文件或并行任务用 `team send` 派给合适的用户创建/用户管理成员。',
+    '- 不要默认创建新成员。根据任务目标，若当前团队缺少合适成员、并行能力不足，或添加成员能明显提高效率和速度时，先说明缺口，并建议用户添加或启动对应的 agent 成员；只有用户明确授权或当前 workspace 规则允许时，才使用 `team spawn`。',
+    '- 不要用当前 CLI 内建子代理/工作流，也不要把非平凡分支留给自己。',
     `- 维护 ${TASKS_RELATIVE_PATH}，让当前计划、进度和阻塞可追踪。`,
     '- 根据成员汇报推进下一步，不把选择题无谓丢回给用户。',
 ].join('\n');

package/dist/src/server/routes-remote.js

@@ -1,5 +1,6 @@
 import { ForbiddenError } from './http-errors.js';
 import { REMOTE_DAEMON_TOKEN_KEY, REMOTE_ENABLED_KEY, REMOTE_GATEWAY_URL_KEY, } from './remote-config-keys.js';
+import { HIVE_REMOTE_DEVICE_HEADER } from './remote-loopback-auth.js';
 import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
 import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
 // Remote-access device-management + pairing routes (M4). Two gate classes:
@@ -23,8 +24,11 @@ const gateUi = ({ request, store }) => {
 // check, so even the short-circuit can't admit a tunnel request that slipped a cookie too.
 const gateLocalDesktopOnly = ({ request, store }) => {
     if (store.authorizeRemoteTunnelRequest(request)) {
+        const rawDeviceId = request.headers[HIVE_REMOTE_DEVICE_HEADER];
         store.getRemoteAuditStore().enqueue({
             action: 'reject',
+            deviceId: typeof rawDeviceId === 'string' ? rawDeviceId : null,
+            endpoint: request.url ?? null,
             result: 'rejected',
             rejectReason: 'pairing_confirm_forbidden',
         });
@@ -38,8 +42,8 @@ const remoteStatus = (store) => {
     const status = store.getRemoteTunnelStatus();
     return {
         enabled: store.settings.getAppState(REMOTE_ENABLED_KEY)?.value === 'true',
-        loggedIn: isLoggedIn(store),
-        gatewayUrl: store.settings.getAppState(REMOTE_GATEWAY_URL_KEY)?.value ?? null,
+        logged_in: isLoggedIn(store),
+        gateway_url: store.settings.getAppState(REMOTE_GATEWAY_URL_KEY)?.value ?? null,
         connected: status === 'online',
         // The FULL tunnel state, not just online/offline — the desktop dot was stuck looking "connected or
         // not" and couldn't show connecting / reconnecting / revoked / logged-out. (connecting+reconnecting
@@ -47,15 +51,41 @@ const remoteStatus = (store) => {
         connection: status,
     };
 };
-// RemoteDeviceRecord is already camelCase + metadata-only (no key material). Identity-mapped so the
-// response shape stays pinned to the store's invariant-7 projection.
+// HTTP responses stay snake_case even though the store uses camelCase records.
+const toPairingTicketView = (ticket) => ({
+    pairing_id: ticket.pairingId,
+    qr: ticket.qr,
+    code: ticket.code,
+    expires_at: ticket.expiresAt,
+});
+const toPendingPairingView = (pending) => ({
+    pairing_id: pending.pairingId,
+    device_name: pending.deviceName,
+    sas: pending.sas,
+    expires_at: pending.expiresAt,
+});
 const toDeviceView = (record) => ({
     id: record.id,
     name: record.name,
-    createdAt: record.createdAt,
-    lastActive: record.lastActive,
-    revokedAt: record.revokedAt,
+    created_at: record.createdAt,
+    last_active: record.lastActive,
+    revoked_at: record.revokedAt,
+});
+const toAuditView = (record) => ({
+    id: record.id,
+    device_id: record.deviceId,
+    ts: record.ts,
+    workspace_id: record.workspaceId,
+    action: record.action,
+    endpoint: record.endpoint,
+    result: record.result,
+    reject_reason: record.rejectReason,
+    byte_count: record.byteCount,
+    preview: record.preview,
 });
+const getSearchParams = (url) => new URL(url ?? '', 'http://x').searchParams;
+const hasCompatFlag = (params, snakeName, camelName) => params.has(snakeName) || params.has(camelName);
+const getCompatParam = (params, snakeName, camelName) => params.get(snakeName) ?? params.get(camelName);
 export const remoteRoutes = [
     route('GET', '/api/remote/status', (ctx) => {
         gateUi(ctx);
@@ -83,7 +113,7 @@ export const remoteRoutes = [
         }
         try {
             const ticket = ctx.store.getRemotePairing().beginPairing();
-            sendJson(ctx.response, 200, ticket);
+            sendJson(ctx.response, 200, toPairingTicketView(ticket));
         }
         catch {
             // beginPairing throws if gateway/daemon id vanished between the status read and here.
@@ -94,7 +124,7 @@ export const remoteRoutes = [
         // HARDEN minor: desktop-only. The confirm dialog backs this; a phone has no use for another
         // device's in-flight SAS, and exposing it would needlessly widen the secret surface (invariant 7).
         gateLocalDesktopOnly(ctx);
-        sendJson(ctx.response, 200, ctx.store.getRemotePairing().listPending());
+        sendJson(ctx.response, 200, ctx.store.getRemotePairing().listPending().map(toPendingPairingView));
     }),
     route('POST', '/api/remote/pairings/:pairingId/confirm', async (ctx) => {
         const { params, request, response, store } = ctx;
@@ -139,7 +169,8 @@ export const remoteRoutes = [
     // ── equal-authority device management ──────────────────────────────────────────────────────────
     route('GET', '/api/remote/devices', (ctx) => {
         gateUi(ctx);
-        const includeRevoked = new URL(ctx.request.url ?? '', 'http://x').searchParams.has('includeRevoked');
+        const params = getSearchParams(ctx.request.url);
+        const includeRevoked = hasCompatFlag(params, 'include_revoked', 'includeRevoked');
         sendJson(ctx.response, 200, ctx.store.getRemoteDeviceStore().list(includeRevoked).map(toDeviceView));
     }),
     route('POST', '/api/remote/devices/:deviceId/revoke', (ctx) => {
@@ -156,11 +187,12 @@ export const remoteRoutes = [
     }),
     route('GET', '/api/remote/audit', (ctx) => {
         gateUi(ctx);
-        const url = new URL(ctx.request.url ?? '', 'http://x');
-        const rawLimit = Number(url.searchParams.get('limit'));
+        const params = getSearchParams(ctx.request.url);
+        const rawLimit = Number(params.get('limit'));
         const limit = Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(rawLimit, 500) : 100;
-        const deviceId = url.searchParams.get('deviceId');
+        const deviceId = getCompatParam(params, 'device_id', 'deviceId');
         const audit = ctx.store.getRemoteAuditStore();
-        sendJson(ctx.response, 200, deviceId ? audit.listForDevice(deviceId, limit) : audit.list(limit));
+        const records = deviceId ? audit.listForDevice(deviceId, limit) : audit.list(limit);
+        sendJson(ctx.response, 200, records.map(toAuditView));
     }),
 ];

package/dist/src/server/routes-team.js

@@ -306,7 +306,7 @@ export const teamRoutes = [
             workspaceId: projectId,
         });
         requireCommandForRole(agent, 'cancel');
-        const result = store.cancelTask(projectId, dispatchId, { fromAgentId, reason });
+        const result = await store.cancelTask(projectId, dispatchId, { fromAgentId, reason });
         sendJson(response, 202, {
             dispatch_id: result.dispatch?.id ?? null,
             forward_error: result.forwardError,

package/dist/src/server/routes-workspaces.js

@@ -109,11 +109,9 @@ export const workspaceRoutes = [
             workspaceId,
         });
         requireCommandForRole(agent, 'list');
-        // The orchestrator polling `team list` is its natural post-restart wakeup:
-        // flush any reports a prior outage stranded back into its stdin now that
-        // it is reachable again. Cheap (indexed, usually empty) and a safe no-op
-        // for non-orchestrator callers.
-        store.drainReportOutbox(workspaceId);
+        // Polling `team list` is a natural post-restart wakeup: flush any durable
+        // notices stranded for the caller now that its PTY is reachable again.
+        store.drainReportOutbox(workspaceId, agent.id);
         sendJson(response, 200, serializeTeamListWithOpenDispatches(store, workspaceId));
     }),
     route('POST', '/api/workspaces/:workspaceId/workers', async ({ params, request, response, store }) => {
@@ -198,7 +196,6 @@ export const workspaceRoutes = [
         }
         const orchestratorId = getOrchestratorId(workspaceId);
         if (!store.getActiveRunByAgentId(workspaceId, orchestratorId)) {
-            store.recordUserInput(workspaceId, orchestratorId, body.text);
             throw new PtyInactiveError(`No active run for agent: ${orchestratorId}`);
         }
         await store.deliverUserInput(workspaceId, orchestratorId, body.text);

package/dist/src/server/runtime-store-contract.d.ts

@@ -44,9 +44,9 @@ export interface RuntimeStore {
     reportTask: (workspaceId: string, workerId: string, input?: ReportTaskInput) => ReportTaskResult;
     /** Flush any reports stranded by a prior orchestrator outage. Safe no-op
      *  when the orchestrator is down or the outbox is empty. */
-    drainReportOutbox: (workspaceId: string) => void;
+    drainReportOutbox: (workspaceId: string, targetAgentId?: string) => void;
     statusTask: (workspaceId: string, workerId: string, input?: StatusTaskInput) => ReportTaskResult;
-    cancelTask: (workspaceId: string, dispatchId: string, input: CancelTaskInput) => ReportTaskResult;
+    cancelTask: (workspaceId: string, dispatchId: string, input: CancelTaskInput) => Promise<ReportTaskResult>;
     listDispatches: (workspaceId: string, options?: ListDispatchesOptions) => DispatchRecord[];
     listOpenDispatches: (workspaceId: string) => DispatchRecord[];
     listRecentDispatches: (workspaceId: string, limit?: number) => DispatchRecord[];

package/dist/src/server/runtime-store-helpers.d.ts

@@ -10,6 +10,7 @@ import { type RemoteAuditStore } from './remote-audit-store.js';
 import type { DeviceSessionProvider } from './remote-device-session.js';
 import { type RemoteDeviceStore } from './remote-device-store.js';
 import { type RemotePairing } from './remote-pairing.js';
+import { createReportOutboxStore } from './report-outbox-store.js';
 import { openRuntimeDatabase } from './runtime-database.js';
 import { createSentinelHeartbeatService } from './sentinel-heartbeat.js';
 import { createSettingsStore } from './settings-store.js';
@@ -39,6 +40,8 @@ export interface RuntimeStoreServices {
     agentRuntime: ReturnType<typeof createAgentRuntime>;
     db: ReturnType<typeof openRuntimeDatabase>;
     dispatchLedgerStore: ReturnType<typeof createDispatchLedgerStore>;
+    isRuntimeClosing: () => boolean;
+    markRuntimeClosing: () => void;
     messageLogStore: ReturnType<typeof createMessageLogStore>;
     remoteAuditStore: RemoteAuditStore;
     remoteDeviceSessions: DeviceSessionProvider;
@@ -53,6 +56,7 @@ export interface RuntimeStoreServices {
     teamMemoryDreamScheduler: ReturnType<typeof createTeamMemoryDreamScheduler>;
     sentinelHeartbeat: ReturnType<typeof createSentinelHeartbeatService>;
     protocolEventStats: ReturnType<typeof createProtocolEventStats>;
+    reportOutbox: ReturnType<typeof createReportOutboxStore>;
     teamMemoryDreamStore: ReturnType<typeof createTeamMemoryDreamStore>;
     teamMemoryDiagnostics: ReturnType<typeof createTeamMemoryDiagnostics>;
     teamMemoryStore: ReturnType<typeof createTeamMemoryStore>;