@tt-a1i/hive 2.1.1 → 2.1.4

package/dist/src/server/route-types.d.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { WorkerRole } from '../shared/types.js';
+import type { UiLanguage } from '../shared/ui-language.js';
 import type { PickFolderResponse } from './fs-pick-folder.js';
 import type { OpenCommandResult, OpenWorkspaceInput as OpenWorkspaceServiceInput } from './open-target-commands.js';
 import type { RuntimeStore } from './runtime-store.js';
@@ -24,6 +25,7 @@ export interface SpawnAgentBody {
     /** Opt-in: auto-dismiss the worker after its next dispatch report. Default
      *  false → persistent member (lives until explicit `team dismiss`). */
     ephemeral?: boolean;
+    locale?: UiLanguage;
 }
 export interface DismissAgentBody {
     hive_port?: string;
@@ -81,6 +83,8 @@ export interface CreateWorkspaceBody {
     command_preset_id?: string | null;
     /** Optional full startup command. When set, it overrides the executable only. */
     startup_command?: string | null;
+    /** Browser UI language at creation time; stored per workspace for server-generated prompts. */
+    ui_language?: UiLanguage;
 }
 export interface CreateWorkerBody {
     autostart?: boolean;
@@ -90,6 +94,8 @@ export interface CreateWorkerBody {
     role: WorkerRole;
     /** Optional full startup command. When set, it overrides the executable only. */
     startup_command?: string | null;
+    /** Browser UI language for server-generated fallback descriptions. */
+    ui_language?: UiLanguage;
 }
 export interface UserInputBody {
     text: string;

package/dist/src/server/routes-scenarios.d.ts

@@ -3,6 +3,7 @@ import type { RouteDefinition } from './route-types.js';
 import type { RuntimeStore } from './runtime-store-contract.js';
 import { type ScenarioPreset } from './scenario-presets.js';
 import { type CliAvailabilityProbe } from './spawn-cli-resolver.js';
+import { type UiLanguage } from './workspace-ui-language.js';
 export declare const scenarioRoutes: RouteDefinition[];
 /**
  * Materialize the scenario team and hand the goal to the orchestrator.
@@ -18,7 +19,7 @@ export declare const scenarioRoutes: RouteDefinition[];
  * addWorkerWithLaunch is atomic, but a mid-loop failure (e.g. a name race)
  * leaves earlier workers in place and surfaces the error to the caller.
  */
-export declare const applyScenario: (store: RuntimeStore, workspaceId: string, scenario: ScenarioPreset, goal: string, isCommandAvailable?: CliAvailabilityProbe) => Array<{
+export declare const applyScenario: (store: RuntimeStore, workspaceId: string, scenario: ScenarioPreset, goal: string, isCommandAvailable?: CliAvailabilityProbe, language?: UiLanguage) => Array<{
     id: string;
     name: string;
     role: WorkerRole;

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

@@ -1,9 +1,10 @@
 import { BadRequestError, ConflictError } from './http-errors.js';
 import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
-import { buildScenarioKickoffMessage, buildScenarioWorkerName, getScenarioPreset, } from './scenario-presets.js';
+import { buildScenarioKickoffMessage, buildScenarioWorkerName, getScenarioPreset, getScenarioWorkerDescription, } from './scenario-presets.js';
 import { resolveDefaultSpawnCliLaunchConfig, } from './spawn-cli-resolver.js';
 import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
 import { getOrchestratorId } from './workspace-store-support.js';
+import { resolveWorkspaceUiLanguage, writeWorkspaceUiLanguage, } from './workspace-ui-language.js';
 export const scenarioRoutes = [
     /**
      * One-click team assembly: materialize a scenario preset's workers (each
@@ -32,13 +33,15 @@ export const scenarioRoutes = [
         if (!goal) {
             throw new BadRequestError('Missing goal');
         }
+        const language = resolveWorkspaceUiLanguage(store.settings, workspaceId, body.locale);
+        writeWorkspaceUiLanguage(store.settings, workspaceId, language);
         // The kickoff is delivered to the orchestrator's live terminal and is NOT
         // persisted for replay, so an offline orchestrator would silently lose the
         // goal. Gate up front: no live run, no team assembly.
         if (!store.getActiveRunByAgentId(workspaceId, getOrchestratorId(workspaceId))) {
             throw new ConflictError('Start the Orchestrator first — the scenario goal is handed to its terminal');
         }
-        const created = applyScenario(store, workspaceId, scenario, goal);
+        const created = applyScenario(store, workspaceId, scenario, goal, undefined, language);
         sendJson(response, 201, {
             created_workers: created,
             injected: true,
@@ -59,7 +62,7 @@ export const scenarioRoutes = [
  * addWorkerWithLaunch is atomic, but a mid-loop failure (e.g. a name race)
  * leaves earlier workers in place and surfaces the error to the caller.
  */
-export const applyScenario = (store, workspaceId, scenario, goal, isCommandAvailable) => {
+export const applyScenario = (store, workspaceId, scenario, goal, isCommandAvailable, language = 'en') => {
     const ports = {
         getCommandPreset: (id) => store.settings.getCommandPreset(id),
         getOrchestratorLaunchConfig: () => store.peekAgentLaunchConfig(workspaceId, getOrchestratorId(workspaceId)),
@@ -71,18 +74,20 @@ export const applyScenario = (store, workspaceId, scenario, goal, isCommandAvail
     for (const spec of scenario.workers) {
         const name = buildScenarioWorkerName(spec, (candidate) => takenNames.has(candidate));
         takenNames.add(name);
+        const description = spec.descriptionOverride !== undefined
+            ? getScenarioWorkerDescription(spec, language)
+            : undefined;
         const worker = store.addWorkerWithLaunch(workspaceId, {
             name,
             role: spec.role,
-            ...(spec.descriptionOverride !== undefined
-                ? { description: spec.descriptionOverride }
-                : {}),
+            ...(description !== undefined ? { description } : {}),
         }, launchConfig);
         created.push({ id: worker.id, name: worker.name, role: spec.role });
     }
     store.recordUserInput(workspaceId, getOrchestratorId(workspaceId), buildScenarioKickoffMessage({
         scenarioId: scenario.id,
         goal,
+        language,
         workers: created.map((worker) => ({ name: worker.name, role: worker.role })),
     }));
     return created;

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

@@ -6,6 +6,8 @@ import { resolveSpawnWorkerDefaults } from './spawn-worker-defaults.js';
 import { authenticateCliAgent, requireCommandForRole } from './team-authz.js';
 import { readWorkflowEnabled, WORKFLOW_ENABLED_KEY } from './workflow-feature.js';
 import { getOrchestratorId } from './workspace-store-support.js';
+import { resolveWorkspaceUiLanguage } from './workspace-ui-language.js';
+const shouldAutoStartTeamSendTarget = (store, targetWorker) => targetWorker?.spawnedBy === 'orchestrator' && store.listAgentRuns(targetWorker.id).length === 0;
 // Experimental gate: `team workflow run` / `team workflow schedule` only work
 // when the user has enabled workflows in Settings. Off by default. The PTY
 // runner itself isn't gated (internal API + the scheduler gate handle that) —
@@ -64,16 +66,20 @@ export const teamRoutes = [
             workspaceId: projectId,
         });
         requireCommandForRole(agent, 'send');
+        const targetWorker = store.listWorkers(projectId).find((worker) => worker.name === to);
+        const shouldAutoStartWorker = shouldAutoStartTeamSendTarget(store, targetWorker);
         const dispatch = await store.dispatchTaskByWorkerName(projectId, to, text, {
-            autoStartWorker: false,
+            autoStartWorker: shouldAutoStartWorker,
             fromAgentId,
             hivePort: String(request.socket.localPort ?? ''),
         });
-        /* The user-facing team send route queues work for stopped workers without
-           auto-starting them; internal workflow dispatches may still surface
-           restarted_worker when they intentionally wake a worker. A parked
-           dispatch is flagged so the orchestrator can tell the user the worker
-           needs a start (replay delivers it automatically on that start). */
+        /* The user-facing team send route queues work for user-managed stopped
+           workers without auto-starting them. An orchestrator-spawned worker is
+           different only for its first dispatch: `team spawn` is immediately
+           followed by `team send`, so the send path wakes a never-started spawned
+           worker to keep that natural flow from parking forever. A parked dispatch
+           is flagged so the orchestrator can tell the user the worker needs a
+           start (replay delivers it automatically on that start). */
         sendJson(response, 202, {
             dispatch_id: dispatch.id,
             ok: true,
@@ -95,7 +101,9 @@ export const teamRoutes = [
             workspaceId: projectId,
         });
         requireCommandForRole(agent, 'spawn');
+        const language = resolveWorkspaceUiLanguage(store.settings, projectId, body.locale);
         const { role, name, description } = resolveSpawnWorkerDefaults({
+            language,
             requestedRole: typeof body.role === 'string' ? body.role : undefined,
             requestedName: typeof body.name === 'string' ? body.name : undefined,
             takenNames: new Set(store.listWorkers(projectId).map((worker) => worker.name)),
@@ -106,15 +114,13 @@ export const teamRoutes = [
         // but orchestrator-spawned). Existing M1-D cascade-on-orchestrator-exit
         // still applies to whatever ephemeral workers remain.
         const ephemeral = body.ephemeral === true;
-        const workerInput = ephemeral
-            ? {
-                name,
-                role,
-                ...(description !== undefined ? { description } : {}),
-                ephemeral: true,
-                spawnedBy: 'orchestrator',
-            }
-            : { name, role, ...(description !== undefined ? { description } : {}) };
+        const workerInput = {
+            name,
+            role,
+            ...(description !== undefined ? { description } : {}),
+            ...(ephemeral ? { ephemeral: true } : {}),
+            spawnedBy: 'orchestrator',
+        };
         const worker = store.addWorkerWithLaunch(projectId, workerInput, launchConfig);
         sendJson(response, 201, {
             name: worker.name,

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

@@ -1,6 +1,8 @@
 import { resolveCommandPresetLaunchConfig, resolveStartupCommandLaunchConfig, } from './agent-launch-resolver.js';
+import { PtyInactiveError } from './http-errors.js';
 import { autostartAgent, autostartOrchestrator } from './orchestrator-autostart.js';
 import { seedOrchestratorLaunchConfig } from './orchestrator-launch.js';
+import { getDefaultRoleDescription } from './role-templates.js';
 import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
 import { authenticateCliAgent, requireCommandForRole } from './team-authz.js';
 import { enrichTeamList } from './team-list-enrichment.js';
@@ -8,6 +10,7 @@ import { serializeTeamListItem } from './team-list-serializer.js';
 import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
 import { validateWorkspacePath } from './workspace-path-validation.js';
 import { getOrchestratorId, getWorkflowAgentId } from './workspace-store-support.js';
+import { resolveWorkspaceUiLanguage, writeWorkspaceUiLanguage } from './workspace-ui-language.js';
 /* #35: fold each worker's open dispatches (id, age, status, task preview)
    into the team list payload. Display-only ages — no timeout or heartbeat is
    derived from them; `queued` rows age from createdAt (submittedAt is null
@@ -56,6 +59,8 @@ export const workspaceRoutes = [
         const startupCommand = typeof body.startup_command === 'string' ? body.startup_command : null;
         const workspacePath = validateWorkspacePath(body.path);
         const workspace = store.createWorkspace(workspacePath, body.name);
+        const language = resolveWorkspaceUiLanguage(store.settings, workspace.id, body.ui_language);
+        writeWorkspaceUiLanguage(store.settings, workspace.id, language);
         seedOrchestratorLaunchConfig(store, store.settings, workspace.id, body.command_preset_id ?? null, startupCommand);
         const autostart = body.autostart_orchestrator !== false;
         if (!autostart) {
@@ -120,6 +125,7 @@ export const workspaceRoutes = [
         const body = await readJsonBody(request);
         const presetId = body.command_preset_id ?? null;
         const startupCommand = typeof body.startup_command === 'string' ? body.startup_command : null;
+        const language = resolveWorkspaceUiLanguage(store.settings, workspaceId, body.ui_language);
         const launchConfig = startupCommand?.trim()
             ? resolveStartupCommandLaunchConfig(store.settings, startupCommand, presetId)
             : presetId
@@ -128,7 +134,12 @@ export const workspaceRoutes = [
         if (presetId && !startupCommand?.trim() && !launchConfig) {
             throw new Error(`Command preset not found: ${presetId}`);
         }
-        const worker = store.addWorker(workspaceId, body);
+        const worker = store.addWorker(workspaceId, {
+            ...body,
+            description: typeof body.description === 'string'
+                ? body.description
+                : getDefaultRoleDescription(body.role, language),
+        });
         if (launchConfig) {
             try {
                 store.configureAgentLaunch(workspaceId, worker.id, launchConfig);
@@ -181,7 +192,16 @@ export const workspaceRoutes = [
         }
         requireUiTokenFromRequest(request, store.validateUiToken, store.authorizeRemoteTunnelRequest);
         const body = await readJsonBody(request);
-        store.recordUserInput(workspaceId, `${workspaceId}:orchestrator`, body.text);
+        if (typeof body.text !== 'string' || body.text.trim().length === 0) {
+            sendJson(response, 400, { error: 'text is required' });
+            return;
+        }
+        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);
         sendJson(response, 202, { ok: true });
     }),
     route('POST', '/api/workspaces/:workspaceId/agents/:agentId/start', async ({ params, request, response, store }) => {

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

@@ -34,6 +34,7 @@ export interface RuntimeStore {
     deleteWorker: (workspaceId: string, workerId: string) => void;
     renameWorker: (workspaceId: string, workerId: string, name: string) => AgentSummary;
     recordUserInput: (workspaceId: string, orchestratorId: string, text: string) => void;
+    deliverUserInput: (workspaceId: string, orchestratorId: string, text: string) => Promise<void>;
     dispatchTask: (workspaceId: string, workerId: string, text: string, input?: DispatchTaskInput) => Promise<DispatchRecord>;
     dispatchTaskByWorkerName: (workspaceId: string, workerName: string, text: string, input?: DispatchTaskInput) => Promise<DispatchRecord & {
         restartedWorker: boolean;
@@ -69,6 +70,7 @@ export interface RuntimeStore {
     }>>;
     startWorkspaceWatch: (workspaceId: string) => Promise<void>;
     getLiveRun: (runId: string) => LiveAgentRun;
+    waitForRunExit: (runId: string, timeoutMs: number) => Promise<boolean>;
     getActiveRunByAgentId: (workspaceId: string, agentId: string) => LiveAgentRun | undefined;
     registerTasksListener: (listener: (workspaceId: string, content: string) => void) => () => void;
     listAgentRuns: (agentId: string) => PersistedAgentRun[];

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

@@ -84,14 +84,23 @@ export declare const createRuntimeStoreLifecycle: ({ agentManager, services, }:
     deleteWorkspaceShell: (workspaceId: string) => void;
     closeWorkspaceShell: (workspaceId: string, runId: string) => boolean;
     getLiveRun: (runId: string) => LiveAgentRun;
+    waitForRunExit: (runId: string, timeoutMs: number) => Promise<boolean>;
     getPtyOutputBus: () => PtyOutputBus;
-    listTerminalRuns: (workspaceId: string) => {
+    listTerminalRuns: (workspaceId: string) => ({
         agent_id: string;
         agent_name: string;
         run_id: string;
         status: import("./agent-manager.js").RunStatus;
+        terminal_input_profile: "default";
+    } | {
+        agent_id: string;
+        agent_name: string;
+        has_user_input_since_start: boolean | null;
+        run_id: string;
+        startup_blocked_reason: "first_run_setup" | null;
+        status: import("./agent-manager.js").RunStatus;
         terminal_input_profile: import("./terminal-input-profile.js").TerminalInputProfile;
-    }[];
+    })[];
     startAgent: (workspaceId: string, agentId: string, input: {
         hivePort: string;
     }) => Promise<LiveAgentRun>;

package/dist/src/server/runtime-store-helpers.js

@@ -8,6 +8,7 @@ import { createDispatchLedgerStore } from './dispatch-ledger-store.js';
 import { readFeatureFlags } from './feature-flags.js';
 import { createMessageLogStore } from './message-log-store.js';
 import { seedOrchestratorLaunchConfig } from './orchestrator-launch.js';
+import { hasFirstRunSetupPrompt, isInteractiveAgentCommand } from './post-start-input-writer.js';
 import { createProtocolEventStats } from './protocol-event-stats.js';
 import { createRemoteAuditStore } from './remote-audit-store.js';
 import { REMOTE_DAEMON_ID_KEY, REMOTE_GATEWAY_URL_KEY } from './remote-config-keys.js';
@@ -323,12 +324,25 @@ export const createRuntimeStoreLifecycle = ({ agentManager, services, }) => {
                 // #33: a freshly started worker may have dispatches parked from when
                 // it was stopped — deliver them now (single-shot via claims; no-op
                 // for orchestrator/workflow pseudo-agents, which never hold queued
-                // worker dispatches addressed to themselves).
-                try {
-                    services.teamOps.replayQueuedDispatches(workspaceId, agentId);
+                // worker dispatches addressed to themselves). Wait for post-start
+                // guidance first so startup instructions never race the first task.
+                const replayQueuedDispatches = () => {
+                    try {
+                        services.teamOps.replayQueuedDispatches(workspaceId, agentId, {
+                            createdBeforeMs: run.startedAt,
+                        });
+                    }
+                    catch (error) {
+                        console.error('[hive] swallowed:startAgent.replayQueued', error);
+                    }
+                };
+                if (run.postStartInputReady) {
+                    void run.postStartInputReady.then(replayQueuedDispatches).catch((error) => {
+                        console.error('[hive] swallowed:startAgent.replayAfterPostStart', error);
+                    });
                 }
-                catch (error) {
-                    console.error('[hive] swallowed:startAgent.replayQueued', error);
+                else {
+                    replayQueuedDispatches();
                 }
             }
             return run;
@@ -401,6 +415,7 @@ export const createRuntimeStoreLifecycle = ({ agentManager, services, }) => {
         },
         closeWorkspaceShell: (workspaceId, runId) => services.shellRuntime.closeRun(workspaceId, runId),
         getLiveRun: (runId) => services.shellRuntime.getLiveRun(runId) ?? services.agentRuntime.getLiveRun(runId),
+        waitForRunExit: (runId, timeoutMs) => services.agentRuntime.waitForRunExit(runId, timeoutMs),
         getPtyOutputBus: () => {
             if (!agentManager)
                 throw new Error('Agent manager is required for PTY output subscriptions');
@@ -412,11 +427,20 @@ export const createRuntimeStoreLifecycle = ({ agentManager, services, }) => {
                 if (!run)
                     return [];
                 const launchConfig = services.agentRuntime.peekAgentLaunchConfig(workspaceId, agent.id);
+                const interactiveCommand = launchConfig?.interactiveCommand ?? launchConfig?.command;
                 return [
                     {
                         agent_id: agent.id,
                         agent_name: agent.name,
+                        has_user_input_since_start: agent.role === 'orchestrator'
+                            ? services.messageLogStore.hasUserInputSince(workspaceId, agent.id, run.startedAt)
+                            : null,
                         run_id: run.runId,
+                        startup_blocked_reason: interactiveCommand &&
+                            isInteractiveAgentCommand(interactiveCommand) &&
+                            hasFirstRunSetupPrompt(run.output)
+                            ? 'first_run_setup'
+                            : null,
                         status: run.status,
                         terminal_input_profile: resolveTerminalInputProfile(launchConfig),
                     },

package/dist/src/server/runtime-store-workflows.js

@@ -10,6 +10,26 @@ export const createRuntimeStoreWorkflowRuntime = (services, store) => {
         workflowRunStore: services.workflowRunStore,
         dispatchPort: {
             listOpenDispatchIdsForRun: (runId) => services.dispatchLedgerStore.listOpenDispatchIdsForRun(runId),
+            cancelOpenDispatchForRun: (workspaceId, dispatchId, reason) => {
+                const openDispatch = services.dispatchLedgerStore.findOpenDispatchById(workspaceId, dispatchId);
+                if (!openDispatch)
+                    return false;
+                const cancelled = services.dispatchLedgerStore.markCancelled({
+                    dispatchId,
+                    reason,
+                    workspaceId,
+                });
+                if (!cancelled)
+                    return false;
+                services.workspaceStore.markTaskCancelled(workspaceId, openDispatch.toAgentId);
+                try {
+                    services.agentRuntime.writeCancelPrompt(workspaceId, cancelled.toAgentId, cancelled.id, reason);
+                }
+                catch (error) {
+                    console.error('[hive] swallowed:workflow.cancelDispatch.forward', error);
+                }
+                return true;
+            },
         },
         resolveWorkspacePath: (workspaceId) => services.workspaceStore.getWorkspaceSnapshot(workspaceId).summary.path,
         logStore: {

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

@@ -82,6 +82,7 @@ export const createRuntimeStore = (options = {}) => {
         renameWorker: (workspaceId, workerId, name) => services.workspaceStore.renameWorker(workspaceId, workerId, name),
         deleteWorker: workerMutations.deleteWorker,
         recordUserInput: services.teamOps.recordUserInput,
+        deliverUserInput: services.teamOps.deliverUserInput,
         cancelTask: services.teamOps.cancelTask,
         dispatchTask: services.teamOps.dispatchTask,
         dispatchTaskByWorkerName: services.teamOps.dispatchTaskByWorkerName,
@@ -106,6 +107,7 @@ export const createRuntimeStore = (options = {}) => {
         startWorkspaceWatch: lifecycle.startWorkspaceWatch,
         startWorkspaceShell: lifecycle.startWorkspaceShell,
         getLiveRun: lifecycle.getLiveRun,
+        waitForRunExit: lifecycle.waitForRunExit,
         getActiveRunByAgentId: (workspaceId, agentId) => services.agentRuntime.getActiveRunByAgentId(workspaceId, agentId),
         registerTasksListener: lifecycle.registerTasksListener,
         listAgentRuns: (agentId) => services.agentRuntime.listAgentRuns(agentId),

package/dist/src/server/scenario-presets.d.ts

@@ -1,6 +1,7 @@
 import type { ScenarioWorkerSpec } from '../shared/scenario-presets.js';
 import type { WorkerRole } from '../shared/types.js';
-export { getScenarioPreset, SCENARIO_PRESETS, type ScenarioId, type ScenarioPreset, type ScenarioWorkerSpec, } from '../shared/scenario-presets.js';
+import type { UiLanguage } from '../shared/ui-language.js';
+export { getScenarioPreset, getScenarioWorkerDescription, SCENARIO_PRESETS, type ScenarioId, type ScenarioPreset, type ScenarioWorkerSpec, } from '../shared/scenario-presets.js';
 /**
  * `<stem>-<4 base36 chars>` — short, `team send`-safe (no spaces, lowercase),
  * and unlikely to collide. The caller passes an `isTaken` probe against the
@@ -10,6 +11,7 @@ export declare const buildScenarioWorkerName: (spec: Pick<ScenarioWorkerSpec, "n
 export interface ScenarioKickoffInput {
     scenarioId: string;
     goal: string;
+    language?: UiLanguage;
     workers: Array<{
         name: string;
         role: WorkerRole;

package/dist/src/server/scenario-presets.js

@@ -1,5 +1,5 @@
 import { randomBytes } from 'node:crypto';
-export { getScenarioPreset, SCENARIO_PRESETS, } from '../shared/scenario-presets.js';
+export { getScenarioPreset, getScenarioWorkerDescription, SCENARIO_PRESETS, } from '../shared/scenario-presets.js';
 /**
  * `<stem>-<4 base36 chars>` — short, `team send`-safe (no spaces, lowercase),
  * and unlikely to collide. The caller passes an `isTaken` probe against the
@@ -23,6 +23,17 @@ export const buildScenarioWorkerName = (spec, isTaken, maxAttempts = 16) => {
  */
 export const buildScenarioKickoffMessage = (input) => {
     const roster = input.workers.map((worker) => `- ${worker.name} (${worker.role})`).join('\n');
+    if (input.language === 'zh') {
+        return [
+            `用户选择了 "${input.scenarioId}" 场景，Hive 已经为你创建这些团队成员：`,
+            roster,
+            '',
+            '用户目标：',
+            input.goal,
+            '',
+            '请先运行 `team list` 确认团队成员，然后把目标拆成任务，并用 `team send "<worker-name>" "<task>"` 派发。任务拆分由你决定；只有缺少真实决策时才回问用户。',
+        ].join('\n');
+    }
     return [
         `The user picked the "${input.scenarioId}" scenario and Hive has already created these team members for you:`,
         roster,

package/dist/src/server/spawn-worker-defaults.d.ts

@@ -1,4 +1,5 @@
 import type { WorkerRole } from '../shared/types.js';
+import type { UiLanguage } from '../shared/ui-language.js';
 export interface SpawnWorkerDefaults {
     role: WorkerRole;
     name: string;
@@ -7,6 +8,7 @@ export interface SpawnWorkerDefaults {
     description?: string;
 }
 export declare const resolveSpawnWorkerDefaults: (input: {
+    language?: UiLanguage;
     requestedRole: string | undefined;
     requestedName: string | undefined;
     takenNames: ReadonlySet<string>;

package/dist/src/server/spawn-worker-defaults.js

@@ -28,12 +28,17 @@ const MAX_LABEL_IN_FALLBACK = MAX_NAME_LENGTH - 37;
 export const resolveSpawnWorkerDefaults = (input) => {
     const label = input.requestedRole?.trim() || 'coder';
     const role = WORKER_ROLES.has(label) ? label : 'custom';
+    const language = input.language ?? 'en';
     const description = role === 'custom' && label !== 'custom'
-        ? [
-            `You are ${label}. Work from the task instructions dispatched by the Orchestrator.`,
-            `你是 ${label}，按 Orchestrator 派发的任务说明工作。`,
-            'When done, use `team report` to report results, risks, and blockers. / 完成后用 `team report` 汇报结果、风险和阻塞。',
-        ].join('\n')
+        ? language === 'zh'
+            ? [
+                `你是 ${label}，按 Orchestrator 派发的任务说明工作。`,
+                '完成后用 `team report` 汇报结果、风险和阻塞。',
+            ].join('\n')
+            : [
+                `You are ${label}. Work from the task instructions dispatched by the Orchestrator.`,
+                'When done, use `team report` to report results, risks, and blockers.',
+            ].join('\n')
         : undefined;
     const requestedName = input.requestedName?.trim();
     const bareLabelAvailable = label.length <= MAX_NAME_LENGTH &&

package/dist/src/server/team-operations.d.ts

@@ -99,6 +99,8 @@ export declare const createTeamOperations: ({ agentRuntime, createDispatch, dele
     dispatchTask: (workspaceId: string, workerId: string, text: string, input?: DispatchTaskInput) => Promise<DispatchRecord>;
     drainReportOutbox: (workspaceId: string) => void;
     replayQueuedDispatches: (workspaceId: string, workerId: string, options?: {
+        beforeSequence?: number;
+        createdBeforeMs?: number;
         excludeDispatchId?: string;
     }) => void;
     notifyIssuersOfDroppedDispatches: (workspaceId: string, workerId: string, reason: string) => void;
@@ -106,6 +108,7 @@ export declare const createTeamOperations: ({ agentRuntime, createDispatch, dele
         restartedWorker: boolean;
     }>;
     recordUserInput(workspaceId: string, orchestratorId: string, text: string): void;
+    deliverUserInput(workspaceId: string, orchestratorId: string, text: string): Promise<void>;
     statusTask(workspaceId: string, workerId: string, input?: StatusTaskInput): {
         pendingWarning?: string;
         dispatch: null;