@tt-a1i/hive 2.1.0 → 2.1.3

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

@@ -33,6 +33,9 @@ export declare const createAgentStdinDispatcher: ({ agentManager, getLaunchConfi
         requireActiveRun?: boolean;
     }): void;
     writeUserInputPrompt(workspaceId: string, text: string): void;
+    deliverUserInputToOrchestrator(workspaceId: string, text: string, input?: {
+        requireActiveRun?: boolean;
+    }): Promise<void>;
     /** Generic: deliver an opaque text block to a specific agent's PTY.
      *  Used by the workflow runner to notify the triggering orchestrator
      *  when a run finishes (mirrors Claude Code's <task-notification>). */

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

@@ -211,6 +211,9 @@ export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getW
         writeUserInputPrompt(workspaceId, text) {
             swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorUserInputPayload(text, flags())));
         },
+        deliverUserInputToOrchestrator(workspaceId, text, input = {}) {
+            return writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorUserInputPayload(text, flags()), input);
+        },
         /** Generic: deliver an opaque text block to a specific agent's PTY.
          *  Used by the workflow runner to notify the triggering orchestrator
          *  when a run finishes (mirrors Claude Code's <task-notification>). */

package/dist/src/server/diagnostics-support-bundle.d.ts

@@ -6,10 +6,13 @@ export declare const buildDiagnosticsSupportBundle: (input: {
     version: VersionInfoPayload;
 }) => {
     app: {
+        can_run_hive_update: boolean;
         current_version: string;
         install_hint: string;
+        install_source: import("./update-install-plan.js").UpdateInstallSource;
         latest_version: string;
         package_name: string;
+        update_note: string;
         update_available: boolean;
     };
     generated_at: number;

package/dist/src/server/diagnostics-support-bundle.js

@@ -127,10 +127,13 @@ export const buildDiagnosticsSupportBundle = (input) => {
     const includedWorkspaces = workspaces.slice(0, MAX_INCLUDED_WORKSPACES);
     return {
         app: {
+            can_run_hive_update: input.version.can_run_hive_update,
             current_version: input.version.current_version,
             install_hint: input.version.install_hint,
+            install_source: input.version.install_source,
             latest_version: input.version.latest_version,
             package_name: input.version.package_name,
+            update_note: input.version.update_note,
             update_available: input.version.update_available,
         },
         generated_at: now,

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

@@ -61,7 +61,7 @@ const CORE_ORCHESTRATOR_RULES = [
     '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 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 STOPPED worker parks the dispatch (the response carries `queued: true`): it is delivered automatically when the user starts that worker. If the task 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. 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.',
     '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.",
@@ -74,7 +74,7 @@ const CORE_ORCHESTRATOR_RULES = [
  * avoids it firing a command the runtime will reject.
  */
 const WORKFLOW_ORCHESTRATOR_RULES = [
-    'Choosing to use a workflow is YOUR call, judged from the task\'s shape — the user describes what they want in plain language and will not (and need not) ask for a "workflow" by name. When a task fans out across 3+ workers, needs a staged review→fix, or loops until results converge, author an orchestration-only workflow script and fire it with ONE `team workflow run --stdin`: the script may decide phases and call `agent()`, but it must not read/write files, shell out, fetch the network, or perform the task itself in JavaScript. Decide this on your own, do not wait to be told, and do not approximate it with a loop of `team send` (no barrier, no UI grouping, no stop button). The DSL and ready-made patterns are in `.hive/PROTOCOL.md`.',
+    'Choosing to use a workflow is YOUR call, judged from the task\'s shape — the user describes what they want in plain language and will not (and need not) ask for a "workflow" by name. When a task fans out across 3+ workers, needs a staged review→fix, has an explicit dependency graph, or loops until results converge, author an orchestration-only workflow script and fire it with ONE `team workflow run --stdin`: the script may decide phases and call `agent()` / `dag()`, but it must not read/write files, shell out, fetch the network, or perform the task itself in JavaScript. Decide this on your own, do not wait to be told, and do not approximate it with a loop of `team send` (no barrier, no UI grouping, no stop button). The DSL and ready-made patterns are in `.hive/PROTOCOL.md`.',
 ];
 /**
  * Auto-staff rule — only injected when the experimental auto-staff feature is
@@ -154,15 +154,26 @@ runtime; never use your CLI's own built-in workflow or subagent runner.
 
 Host functions injected into the script: \`agent(prompt, opts)\`,
 \`parallel(thunks)\`, \`pipeline(items, ...stages)\`, \`phase(title)\`,
-\`log(msg)\`, plus the \`args\` global.
+\`log(msg)\`, \`workflow(scriptName, childArgs?)\`, \`dag(spec)\`, plus the
+\`args\` global.
 
 \`agent(prompt, opts)\` opts: \`{ agentType?: "coder"|"reviewer"|"tester"|"custom"|<custom-role-name>, cli?: "${BUILTIN_COMMAND_PRESET_CLI_LIST.replace(/\|/gu, '"|"')}", model?: string, outputSchema?: object, label?: string, timeoutMs?: number }\` — other fields are silently ignored. \`agentType\` also accepts the name of a workspace custom role template (case-insensitive); a typo throws rather than silently falling back to coder. \`model\` is passed through to the worker launch config (\`--model <id>\`), so a 100-way fan-out can use a cheap model and the synthesizer a strong one. \`outputSchema\` makes \`agent()\` resolve to a parsed object instead of a string: the worker is told to end its report with a fenced \`\`\`json block whose keys match the schema. On a parse miss it falls back to \`{ text: "<raw report>" }\`, so ALWAYS treat a missing field as the SAFE default (never assume success). The worker auto-dismisses when its \`agent()\` call resolves — you never dismiss it.
 
 \`parallel()\` takes an array of THUNKS (\`() => agent(...)\`), NOT already-started promises: \`parallel([agent(...), agent(...)])\` degrades to unordered concurrency counted as a single step (a no-op grouping), because the promises already started at construction time. \`pipeline(items, ...stages)\` stages are also functions, shape \`(prev, item, i) => agent(...)\`.
 
+\`dag(spec)\` is for explicit dependency graphs. Pass either an array of nodes
+or \`{ nodes }\`. Each node is \`{ id, needs?: string[], run }\` (aliases:
+\`dependsOn\` / \`after\`). Nodes whose dependencies are complete run in
+parallel; dependent nodes wait for all upstream results. Missing dependencies,
+duplicate ids, and cycles fail the run before unsafe downstream dispatches.
+\`run(deps, results)\` receives an object containing only that node's direct
+dependencies plus the full result map. The return value is
+\`{ order: string[], results: Record<string, unknown> }\`, where \`undefined\`
+node results are stored as \`null\`.
+
 \`log("...")\` writes one narrator line — stored in the DB, shown when the run row is expanded in the Drawer, and its last 8 lines are spliced into the completion reminder sent back to you. Use it for a readable progress summary, e.g. \`log('Discovered 47 endpoints')\`.
 
-Runtime limits: each run defaults to at most 1000 \`agent()\` calls and 60 minutes wall-clock; the concurrency cap is \`min(16, cores-2)\` and parallel/pipeline queue against it automatically. Override in \`meta\`, e.g. \`meta = { name, description, maxAgentCalls: 50, maxDurationMs }\`.
+Runtime limits: each run defaults to at most 1000 \`agent()\` calls and 60 minutes wall-clock; the concurrency cap is \`min(16, cores-2)\` and parallel/pipeline/dag queue against it automatically. Override in \`meta\`, e.g. \`meta = { name, description, maxAgentCalls: 50, maxDurationMs }\`.
 
 \`meta\` must be a pure literal (no variables). Scripts are JS, not TS (type annotations error). The body may use top-level \`await\` and a trailing \`return\`.
 
@@ -186,6 +197,25 @@ phase('Synthesize')
 return await agent(\`Synthesize: \${reports.filter(Boolean).join('\\n---\\n')}\`, { agentType: 'reviewer', cli: 'claude', label: 'synth' })
 \`\`\`
 
+Explicit DAG (use when later steps need named upstream results):
+\`\`\`
+export const meta = { name: 'dag-review-fix', description: 'review, fix, verify as a graph' }
+phase('Graph')
+const graph = await dag({
+  nodes: [
+    { id: 'review', run: () => agent('Find correctness bugs.', { agentType: 'reviewer', label: 'review' }) },
+    { id: 'tests', run: () => agent('Find missing regression tests.', { agentType: 'tester', label: 'tests' }) },
+    {
+      id: 'fix',
+      needs: ['review', 'tests'],
+      run: (deps) => agent('Implement the fix using this evidence:\\n' + deps.review + '\\n---\\n' + deps.tests, { agentType: 'coder', label: 'fix' }),
+    },
+    { id: 'verify', needs: ['fix'], run: (deps) => agent('Verify the fix:\\n' + deps.fix, { agentType: 'tester', label: 'verify' }) },
+  ],
+})
+return graph
+\`\`\`
+
 Passing args (so a saved script is reusable instead of hard-coding values):
 \`\`\`
 team workflow run --stdin --args '["src/a.ts","src/b.ts"]' <<'EOF'

package/dist/src/server/message-log-store.d.ts

@@ -44,6 +44,7 @@ interface MessageKindRow {
 }
 export declare const createMessageLogStore: (db: Database) => {
     deleteMessage: (handle: MessageLogHandle) => void;
+    hasUserInputSince: (workspaceId: string, agentId: string, sinceMs: number) => boolean;
     insertMessage: (input: MessageLogRecord) => MessageLogHandle;
     listMessageKinds: () => MessageKindRow[];
     listMessagesForRecovery: (workspaceId: string, sinceMs: number) => RecoveryMessage[];

package/dist/src/server/message-log-store.js

@@ -26,6 +26,18 @@ export const createMessageLogStore = (db) => {
     const deleteMessage = (handle) => {
         db.prepare('DELETE FROM messages WHERE sequence = ?').run(handle.sequence);
     };
+    const hasUserInputSince = (workspaceId, agentId, sinceMs) => {
+        const row = db
+            .prepare(`SELECT 1
+         FROM messages
+         WHERE workspace_id = ?
+           AND type = 'user_input'
+           AND worker_id = ?
+           AND created_at >= ?
+         LIMIT 1`)
+            .get(workspaceId, agentId, sinceMs);
+        return row !== undefined;
+    };
     const parseArtifacts = (value) => {
         if (!value) {
             return [];
@@ -83,6 +95,7 @@ export const createMessageLogStore = (db) => {
     };
     return {
         deleteMessage,
+        hasUserInputSince,
         insertMessage,
         listMessageKinds,
         listMessagesForRecovery,

package/dist/src/server/orchestrator-autostart.d.ts

@@ -10,7 +10,9 @@ interface AutostartPort {
     getLiveRun: (runId: string) => {
         status: string;
         exitCode: number | null;
+        output?: string;
     };
+    waitForRunExit?: (runId: string, timeoutMs: number) => Promise<boolean>;
     peekAgentLaunchConfig: (workspaceId: string, agentId: string) => AgentLaunchConfigInput | undefined;
 }
 export interface OrchestratorStartResult {

package/dist/src/server/orchestrator-autostart.js

@@ -2,9 +2,15 @@ import { getStartupCommandExecutable } from './startup-command-parser.js';
 // SETTLE_WAIT_MS: how long we wait before declaring autostart "ok". Must be
 // long enough to observe an early exit when the child shell prints
 // "command not found" then dies with exit 127 (POSIX) or 9009 (Windows)
-// — typically <100ms in practice. 800ms balances reliability vs the perceived
-// workspace-create latency cost.
+// - typically <100ms in practice. 800ms balances reliability vs the perceived
+// workspace-create latency cost. Production runtime exposes an exit promise so
+// we don't miss the event between polling ticks; stubs fall back to polling.
 const SETTLE_WAIT_MS = process.platform === 'win32' ? 2000 : 800;
+// node-pty's spawn helper can take several seconds to finish executing a
+// shebang script that exits immediately. Only use this longer window while the
+// PTY is still completely silent and "starting"; real CLIs that print output
+// keep the normal fast path above.
+const SILENT_STARTING_SETTLE_WAIT_MS = process.platform === 'win32' ? 5000 : 4000;
 const POLL_INTERVAL_MS = 25;
 // Shells emit a "command not found" exit code when the requested binary is
 // missing on PATH. node-pty does NOT raise a synchronous spawn error for that
@@ -74,26 +80,39 @@ export const autostartAgent = async (port, workspaceId, agentId, hivePort, optio
     try {
         const run = await port.startAgent(workspaceId, agentId, { hivePort });
         // node-pty often doesn't throw on missing binaries — it spawns then exits
-        // fast via onExit with a non-zero code. Poll briefly so we surface the
-        // failure synchronously in the response instead of returning a fake "ok".
-        //
-        // Loop condition is "until we hit a terminal state OR deadline". Earlier
-        // versions exited as soon as `status === 'running'`, which missed the case
-        // where bash prints `command not found` (status flips to running) and then
-        // exits 127 a few ms later. The tighter loop catches that path.
+        // fast via onExit with a non-zero code. Wait briefly for that real exit
+        // event so we surface the failure synchronously instead of returning a fake
+        // "ok". Older test ports without waitForRunExit use the polling fallback.
         let exitCode = run.exitCode;
         let status = run.status;
-        const deadline = Date.now() + SETTLE_WAIT_MS;
+        let output = '';
+        const startedAt = Date.now();
+        let deadline = startedAt + SETTLE_WAIT_MS;
+        const silentStartingDeadline = startedAt + SILENT_STARTING_SETTLE_WAIT_MS;
         while (status !== 'exited' && status !== 'error' && Date.now() < deadline) {
-            await sleep(POLL_INTERVAL_MS);
+            const remainingMs = Math.max(0, deadline - Date.now());
+            const waitMs = Math.min(POLL_INTERVAL_MS, remainingMs);
+            if (port.waitForRunExit) {
+                await port.waitForRunExit(run.runId, waitMs);
+            }
+            else {
+                await sleep(waitMs);
+            }
             try {
                 const live = port.getLiveRun(run.runId);
                 status = live.status;
                 exitCode = live.exitCode;
+                output = live.output ?? output;
             }
             catch {
                 break;
             }
+            if (status === 'starting' &&
+                output.length === 0 &&
+                deadline < silentStartingDeadline &&
+                Date.now() >= deadline) {
+                deadline = silentStartingDeadline;
+            }
         }
         if (status === 'error' || (status === 'exited' && (exitCode ?? 0) !== 0)) {
             return {

package/dist/src/server/post-start-input-writer.d.ts

@@ -1,6 +1,7 @@
 import type { AgentManager } from './agent-manager.js';
 export declare const toBracketedPasteSubmission: (text: string) => string;
 export declare const isInteractiveAgentCommand: (command: string) => boolean;
+export declare const hasFirstRunSetupPrompt: (output: string) => boolean;
 export declare const hasInteractivePromptReady: (output: string, command?: string) => boolean;
 export declare const hasBracketedPasteAcknowledgement: (output: string, baselineLength: number) => boolean;
 export declare const createPostStartInputWriter: (agentManager: AgentManager, command: string) => ((runId: string, text: string) => Promise<void>);

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

@@ -2,6 +2,8 @@ import { BUILTIN_INTERACTIVE_COMMANDS } from './command-preset-defaults.js';
 import { normalizeExecutableToken } from './startup-command-parser.js';
 const READY_CHECK_INTERVAL_MS = 50;
 const READY_TIMEOUT_MS = 3000;
+const PROMPT_READY_HARD_TIMEOUT_MS = 30000;
+const PROMPT_READY_TAIL_CHARS = 8000;
 const MIN_SUBMIT_AFTER_PASTE_DELAY_MS = 600;
 const MAX_SUBMIT_AFTER_PASTE_DELAY_MS = 1500;
 const PASTE_CHARS_PER_DELAY_MS = 4;
@@ -9,9 +11,13 @@ const PASTE_ACK_CHECK_INTERVAL_MS = 50;
 const PASTE_ACK_SETTLE_DELAY_MS = 100;
 const CODEX_PASTE_ACK_SETTLE_DELAY_MS = 250;
 const PASTE_ACK_TIMEOUT_MS = 3000;
+const CLAUDE_HIVE_PASTE_ACK_TIMEOUT_MS = 10000;
+const CLAUDE_HIVE_PASTE_ACK_MIN_CHARS = 2000;
 // Codex can take several seconds to render "[Pasted Content ...]" on Windows
-// conpty for large bracketed-paste payloads. Keep Claude's shorter fallback,
-// but give Codex enough time to use the ack-gated path in normal operation.
+// conpty for large bracketed-paste payloads. Claude gets the longer window only
+// on Windows and only for large Hive envelopes; small prompts need the shorter
+// fallback so a CLI that does not render paste acknowledgements still receives
+// Enter promptly.
 const CODEX_PASTE_ACK_TIMEOUT_MS = 10000;
 // Codex only emits "[Pasted Content ...]" for sufficiently large pastes. Short
 // Hive report/status/user-input payloads are usually rendered literally in the
@@ -20,6 +26,9 @@ const CODEX_PASTE_ACK_TIMEOUT_MS = 10000;
 const CODEX_PASTE_ACK_MIN_CHARS = 2000;
 const CODEX_SUBMIT_RETRY_DELAY_MS = 500;
 const GROK_SUBMIT_AFTER_PASTE_DELAY_MS = 100;
+const OPENCODE_MIN_SUBMIT_AFTER_PASTE_DELAY_MS = 2500;
+const OPENCODE_MAX_SUBMIT_AFTER_PASTE_DELAY_MS = 5000;
+const OPENCODE_PASTE_CHARS_PER_DELAY_MS = 2;
 const GEMINI_STYLE_MAX_SUBMIT_AFTER_PASTE_DELAY_MS = 4000;
 const GEMINI_STYLE_PASTE_CHARS_PER_DELAY_MS = 2;
 const COMMANDS_WITH_BRACKETED_PASTE = new Set([
@@ -37,13 +46,18 @@ const PASTE_ACK_ONLY_DELTA_PATTERN = /^[\s\r\n]*(?:[❯›]\s*)?\[(?:Pasted text
 const ESCAPE = String.fromCharCode(27);
 const BELL = String.fromCharCode(7);
 const TERMINAL_CONTROL_PATTERN = new RegExp(`${ESCAPE}\\[[0-?]*[ -/]*[@-~]|${ESCAPE}\\][^${BELL}${ESCAPE}]*(?:${BELL}|${ESCAPE}\\\\)`, 'gu');
+const HIVE_ACK_GATED_MESSAGE_PATTERN = /<(?:hive-system-message\b|hive-message\s+kind="(?:cancel|dispatch|heartbeat|startup)"(?:\s|>))/u;
 export const toBracketedPasteSubmission = (text) => `\u001b[200~${text}\u001b[201~`;
 const toError = (error) => (error instanceof Error ? error : new Error(String(error)));
 const createRunInactiveError = (runId) => new Error(`Run became inactive before input was submitted: ${runId}`);
+const createPromptReadyTimeoutError = (runId, command) => new Error(`Timed out waiting for ${getCommandName(command) || command} prompt readiness: ${runId}`);
 const getSubmitAfterPasteDelayMs = (command, text) => {
     const commandName = getCommandName(command);
     if (commandName === 'grok')
         return GROK_SUBMIT_AFTER_PASTE_DELAY_MS;
+    if (commandName === 'opencode') {
+        return Math.min(OPENCODE_MAX_SUBMIT_AFTER_PASTE_DELAY_MS, Math.max(OPENCODE_MIN_SUBMIT_AFTER_PASTE_DELAY_MS, Math.ceil(text.length / OPENCODE_PASTE_CHARS_PER_DELAY_MS)));
+    }
     if (commandName === 'gemini' || commandName === 'qwen') {
         return Math.min(GEMINI_STYLE_MAX_SUBMIT_AFTER_PASTE_DELAY_MS, Math.max(MIN_SUBMIT_AFTER_PASTE_DELAY_MS, Math.ceil(text.length / GEMINI_STYLE_PASTE_CHARS_PER_DELAY_MS)));
     }
@@ -54,10 +68,15 @@ export const isInteractiveAgentCommand = (command) => {
     const brand = normalizeExecutableToken(command);
     return brand !== null && BUILTIN_INTERACTIVE_COMMANDS.has(brand);
 };
+const getPlainTerminalOutput = (output) => output.replace(/\r/g, '\n').replace(TERMINAL_CONTROL_PATTERN, '');
+const getPlainTerminalTail = (output) => getPlainTerminalOutput(output).slice(-PROMPT_READY_TAIL_CHARS);
 const hasGeminiPromptReady = (output) => /\bType your message\b/u.test(output);
-const hasOpencodePromptReady = (output) => /\bAsk anything\.\.\./u.test(output);
+const hasHermesPromptReady = (output) => {
+    const plain = getPlainTerminalTail(output);
+    return /\bWelcome to Hermes Agent![\s\S]*❯/u.test(plain);
+};
+const hasOpencodePromptReady = (output) => /\bAsk anything\.\.\./u.test(getPlainTerminalTail(output));
 const hasGrokPromptReady = (output) => /\b(?:Enter:send|Composer\s+\S+)/u.test(output);
-const getPlainTerminalOutput = (output) => output.replace(/\r/g, '\n').replace(TERMINAL_CONTROL_PATTERN, '');
 const hasAgyPromptReady = (output) => /(?:^|\n)\s*>\s*\n\s*(?:[─-]{8,}|\?\s*for shortcuts)/u.test(getPlainTerminalOutput(output));
 const getLastNonEmptyTerminalLine = (output) => {
     const normalized = getPlainTerminalOutput(output);
@@ -68,12 +87,35 @@ const getLastNonEmptyTerminalLine = (output) => {
     return '';
 };
 const hasBarePromptLine = (output) => /^[❯›]$/u.test(getLastNonEmptyTerminalLine(output));
-const hasCodexChoicePrompt = (output, command) => getCommandName(command) === 'codex' && /^[❯›]\s+\S/u.test(getLastNonEmptyTerminalLine(output));
+const SETUP_PROMPT_PATTERNS = [
+    /\bDo you trust\b/iu,
+    /\btrust this (?:directory|folder|workspace|project)\b/iu,
+    /\b(?:Log in|Login required|Sign in)\b/iu,
+    /\b(?:Enter|Return)\s+to\s+confirm\b/iu,
+    /\bEsc\s+to\s+(?:cancel|exit)\b/iu,
+    /\b(?:Choose|Pick|Select)\s+(?:a\s+)?(?:theme|option|provider)\b/iu,
+];
+export const hasFirstRunSetupPrompt = (output) => {
+    const plainTail = getPlainTerminalTail(output);
+    if (hasBarePromptLine(plainTail))
+        return false;
+    const recentLines = plainTail
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .slice(-8);
+    const lastLine = recentLines.at(-1) ?? '';
+    if (/^[❯›]\s+(?:\d+\.?\s*)?\S/u.test(lastLine))
+        return true;
+    const recent = recentLines.join('\n');
+    return SETUP_PROMPT_PATTERNS.some((pattern) => pattern.test(recent));
+};
 export const hasInteractivePromptReady = (output, command = '') => {
     const commandName = getCommandName(command);
     return (hasBarePromptLine(output) ||
         (commandName === 'agy' && hasAgyPromptReady(output)) ||
         (commandName === 'grok' && hasGrokPromptReady(output)) ||
+        (commandName === 'hermes' && hasHermesPromptReady(output)) ||
         ((commandName === 'gemini' || commandName === 'qwen') && hasGeminiPromptReady(output)) ||
         (commandName === 'opencode' && hasOpencodePromptReady(output)));
 };
@@ -88,17 +130,37 @@ export const hasBracketedPasteAcknowledgement = (output, baselineLength) => {
 const onlyPasteAcknowledgementWasAppended = (before, after) => after.startsWith(before) && PASTE_ACK_ONLY_DELTA_PATTERN.test(after.slice(before.length));
 const shouldWaitForPasteAck = (command, text) => {
     const commandName = getCommandName(command);
-    if (commandName === 'codex')
-        return text.length >= CODEX_PASTE_ACK_MIN_CHARS;
+    if (commandName === 'codex') {
+        return text.length >= CODEX_PASTE_ACK_MIN_CHARS || HIVE_ACK_GATED_MESSAGE_PATTERN.test(text);
+    }
     return COMMANDS_WAITING_FOR_PASTE_ACK.has(commandName);
 };
 const retriesSubmit = (command) => getCommandName(command) === 'codex';
 const getPasteAckSettleDelayMs = (command) => getCommandName(command) === 'codex' ? CODEX_PASTE_ACK_SETTLE_DELAY_MS : PASTE_ACK_SETTLE_DELAY_MS;
-const getPasteAckTimeoutMs = (command) => getCommandName(command) === 'codex' ? CODEX_PASTE_ACK_TIMEOUT_MS : PASTE_ACK_TIMEOUT_MS;
+const getPasteAckTimeoutMs = (command, text) => {
+    const commandName = getCommandName(command);
+    if (commandName === 'codex')
+        return CODEX_PASTE_ACK_TIMEOUT_MS;
+    if (commandName === 'claude' &&
+        process.platform === 'win32' &&
+        text.length >= CLAUDE_HIVE_PASTE_ACK_MIN_CHARS &&
+        HIVE_ACK_GATED_MESSAGE_PATTERN.test(text)) {
+        return CLAUDE_HIVE_PASTE_ACK_TIMEOUT_MS;
+    }
+    return PASTE_ACK_TIMEOUT_MS;
+};
 const usesBracketedPaste = (command) => COMMANDS_WITH_BRACKETED_PASTE.has(getCommandName(command));
 const canTimeoutBeforePromptReady = (command) => {
     const commandName = getCommandName(command);
-    return commandName !== 'agy' && commandName !== 'gemini' && commandName !== 'qwen';
+    return (commandName !== 'agy' &&
+        commandName !== 'gemini' &&
+        commandName !== 'hermes' &&
+        commandName !== 'opencode' &&
+        commandName !== 'qwen');
+};
+const hasPromptReadyHardTimeout = (command) => {
+    const commandName = getCommandName(command);
+    return commandName === 'hermes' || commandName === 'opencode';
 };
 const isWritableRunStatus = (status) => status === undefined || status === 'starting' || status === 'running';
 const writeIfRunWritable = (agentManager, runId, text) => {
@@ -234,8 +296,9 @@ export const createPostStartInputWriter = (agentManager, command) => {
                 rejectDone(createRunInactiveError(runId));
                 return;
             }
-            if (hasInteractivePromptReady(output, command) ||
-                (!hasCodexChoicePrompt(output, command) &&
+            const firstRunSetupPromptVisible = hasFirstRunSetupPrompt(output);
+            if ((!firstRunSetupPromptVisible && hasInteractivePromptReady(output, command)) ||
+                (!firstRunSetupPromptVisible &&
                     canTimeoutBeforePromptReady(command) &&
                     Date.now() - startedAt >= READY_TIMEOUT_MS)) {
                 const baselineLength = output.length;
@@ -252,7 +315,12 @@ export const createPostStartInputWriter = (agentManager, command) => {
                     rejectDone(toError(error));
                     return;
                 }
-                submitPastedInteractiveInput(agentManager, runId, command, text, baselineLength, shouldWaitForPasteAck(command, text), getPasteAckSettleDelayMs(command), getPasteAckTimeoutMs(command), retriesSubmit(command), resolveDone, rejectDone);
+                submitPastedInteractiveInput(agentManager, runId, command, text, baselineLength, shouldWaitForPasteAck(command, text), getPasteAckSettleDelayMs(command), getPasteAckTimeoutMs(command, text), retriesSubmit(command), resolveDone, rejectDone);
+                return;
+            }
+            if (hasPromptReadyHardTimeout(command) &&
+                Date.now() - startedAt >= PROMPT_READY_HARD_TIMEOUT_MS) {
+                rejectDone(createPromptReadyTimeoutError(runId, command));
                 return;
             }
             setTimeout(tryWrite, READY_CHECK_INTERVAL_MS);

package/dist/src/server/role-templates.d.ts

@@ -1,8 +1,15 @@
 import type { WorkerRole } from '../shared/types.js';
+import type { UiLanguage } from '../shared/ui-language.js';
 export declare const ORCHESTRATOR_ROLE_DESCRIPTION: string;
 export declare const CODER_ROLE_DESCRIPTION: string;
 export declare const REVIEWER_ROLE_DESCRIPTION: string;
 export declare const TESTER_ROLE_DESCRIPTION: string;
 export declare const SENTINEL_ROLE_DESCRIPTION: string;
 export declare const CUSTOM_ROLE_DESCRIPTION: string;
-export declare const getDefaultRoleDescription: (role: WorkerRole | "orchestrator") => string;
+export declare const ORCHESTRATOR_ROLE_DESCRIPTION_ZH: string;
+export declare const CODER_ROLE_DESCRIPTION_ZH: string;
+export declare const REVIEWER_ROLE_DESCRIPTION_ZH: string;
+export declare const TESTER_ROLE_DESCRIPTION_ZH: string;
+export declare const SENTINEL_ROLE_DESCRIPTION_ZH: string;
+export declare const CUSTOM_ROLE_DESCRIPTION_ZH: string;
+export declare const getDefaultRoleDescription: (role: WorkerRole | "orchestrator", language?: UiLanguage) => string;

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

@@ -1,68 +1,122 @@
 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.',
-    '工作方式 / 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. / 默认走 Hive 派单：实现、审计/复核、测试、验证、多文件或并行任务用 `team send`、`team spawn` 或 Hive `team workflow`；不要用当前 CLI 内建子代理/工作流，也不要把非平凡分支留给自己。',
-    `- Maintain ${TASKS_RELATIVE_PATH} so plan, progress, and blockers stay trackable. / 维护 ${TASKS_RELATIVE_PATH}，让当前计划、进度和阻塞可追踪。`,
-    '- Drive the next step from worker reports; do not bounce choices back to the user unless a real decision is missing. / 根据成员汇报推进下一步，不把选择题无谓丢回给用户。',
+    '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.',
+    `- 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');
 export const CODER_ROLE_DESCRIPTION = [
     'You are an implementation Coder. Turn clear tasks into minimal, correct code changes.',
-    '工作方式 / How to work:',
-    '- Read relevant files and existing patterns before editing. / 先阅读相关文件和现有模式，再动手。',
-    '- Prefer small scoped changes; avoid unrelated refactors and scope creep. / 优先小步修改，避免无关重构和范围扩张。',
-    '- After editing, run validation commands that cover the risk; if you cannot validate, say why. / 改动后运行能覆盖风险的验证命令；不能验证时说明原因。',
-    'Delivery / 交付说明: include changed files, validation results, and remaining risks or blockers.',
+    'How to work:',
+    '- Read relevant files and existing patterns before editing.',
+    '- Prefer small scoped changes; avoid unrelated refactors and scope creep.',
+    '- After editing, run validation commands that cover the risk; if you cannot validate, say why.',
+    'Delivery: include changed files, validation results, and remaining risks or blockers.',
 ].join('\n');
 export const REVIEWER_ROLE_DESCRIPTION = [
     'You are a Reviewer. Audit quality; do not replace the Orchestrator and do not edit code by default.',
-    '工作方式 / How to work:',
-    '- Prioritize real bugs, regression risks, edge cases, and test gaps. / 优先找真实 bug、回归风险、边界条件和测试缺口。',
-    '- For each issue, give severity, file/line, trigger condition, and the smallest credible fix. / 发现问题时给出严重度、文件/行号、触发条件和最小修复建议。',
-    '- If there is no high-risk issue, state residual risk and what was not verified. / 没有高风险问题时明确说清剩余风险和未验证范围。',
-    'Delivery / 交付说明: sort by severity and list blocking issues first.',
+    'How to work:',
+    '- Prioritize real bugs, regression risks, edge cases, and test gaps.',
+    '- For each issue, give severity, file/line, trigger condition, and the smallest credible fix.',
+    '- If there is no high-risk issue, state residual risk and what was not verified.',
+    'Delivery: sort by severity and list blocking issues first.',
 ].join('\n');
 export const TESTER_ROLE_DESCRIPTION = [
     'You are a Tester. Reproduce, test, and produce evidence-backed validation.',
-    '工作方式 / How to work:',
-    '- First identify the behavior, entry point, and failure condition to validate. / 先明确要验证的行为、入口和失败条件。',
-    '- Prefer real commands or real end-to-end paths; add minimal tests only when needed. / 优先跑真实命令或真实链路；必要时补充最小测试。',
-    '- Record commands, results, key output, and scenarios you could not cover. / 记录命令、结果、关键输出和不能覆盖的场景。',
-    'Delivery / 交付说明: separate passed, failed, unverified, and recommended next steps.',
+    'How to work:',
+    '- First identify the behavior, entry point, and failure condition to validate.',
+    '- Prefer real commands or real end-to-end paths; add minimal tests only when needed.',
+    '- Record commands, results, key output, and scenarios you could not cover.',
+    'Delivery: separate passed, failed, unverified, and recommended next steps.',
 ].join('\n');
 export const SENTINEL_ROLE_DESCRIPTION = [
     'You are a read-only Sentinel. Observe team health; do not execute tasks or modify anything.',
-    '工作方式 / How to work:',
-    '- Hive periodically injects workspace snapshots: member states, open dispatches, and possible orphaned work. / 系统会定期向你注入工作区快照。',
-    '- Compare snapshots with your own observations and escalate only anomalies worth Orchestrator attention. / 把快照与你自己的观察对照，只上报值得 Orchestrator 注意的异常。',
-    '- Long silence is not automatically stuck; large tasks can be slow. / 长时间无汇报不等于卡死。',
-    'Hard boundaries / 硬性边界:',
-    '- Observe only: do not edit files, run side-effecting commands, or dispatch work. / 只观察：不改文件、不跑有副作用的命令、不派活。',
-    '- You take no dispatches and do not have `team report`; use `team status "<finding>"` for findings. / 你不接派单，也没有 `team report`；发现统一用 `team status "<巡检发现>"` 汇报。',
-    '- Stay quiet when nothing is abnormal. / 没有异常时保持安静。',
+    'How to work:',
+    '- Hive periodically injects workspace snapshots: member states, open dispatches, and possible orphaned work.',
+    '- Compare snapshots with your own observations and escalate only anomalies worth Orchestrator attention.',
+    '- Long silence is not automatically stuck; large tasks can be slow.',
+    'Hard boundaries:',
+    '- Observe only: do not edit files, run side-effecting commands, or dispatch work.',
+    '- You take no dispatches and do not have `team report`; use `team status "<finding>"` for findings.',
+    '- Stay quiet when nothing is abnormal.',
 ].join('\n');
 export const CUSTOM_ROLE_DESCRIPTION = [
     'You are a custom Hive member. Replace this with the member-specific behavior contract.',
-    '建议包含 / Include:',
-    '- Goal: what this member is responsible for. / 目标：这个成员主要负责什么。',
-    '- Boundaries: what it may and may not do. / 边界：哪些事可以做，哪些事不要做。',
-    '- Working style: how it investigates, edits, validates, or reviews. / 工作方式：如何调查、修改、验证或审查。',
-    '- Done criteria: what results, risks, and blockers to report. / 完成标准：交付时需要说明哪些结果、风险和阻塞。',
+    'Recommended shape:',
+    '- Goal: what this member is responsible for.',
+    '- Boundaries: what it may and may not do.',
+    '- Working style: how it investigates, edits, validates, or reviews.',
+    '- Done criteria: what results, risks, and blockers to report.',
 ].join('\n');
-export const getDefaultRoleDescription = (role) => {
-    switch (role) {
-        case 'orchestrator':
-            return ORCHESTRATOR_ROLE_DESCRIPTION;
-        case 'coder':
-            return CODER_ROLE_DESCRIPTION;
-        case 'reviewer':
-            return REVIEWER_ROLE_DESCRIPTION;
-        case 'tester':
-            return TESTER_ROLE_DESCRIPTION;
-        case 'sentinel':
-            return SENTINEL_ROLE_DESCRIPTION;
-        case 'custom':
-            return CUSTOM_ROLE_DESCRIPTION;
-    }
+export const ORCHESTRATOR_ROLE_DESCRIPTION_ZH = [
+    '你是 Hive Orchestrator。你直接回复用户，并协调右侧真实 worker。',
+    '工作方式：',
+    '- 澄清目标，把需求拆成可派发的小任务。',
+    '- 默认走 Hive 派单：实现、审计/复核、测试、验证、多文件或并行任务用 `team send`、`team spawn` 或 Hive `team workflow`；不要用当前 CLI 内建子代理/工作流，也不要把非平凡分支留给自己。',
+    `- 维护 ${TASKS_RELATIVE_PATH}，让当前计划、进度和阻塞可追踪。`,
+    '- 根据成员汇报推进下一步，不把选择题无谓丢回给用户。',
+].join('\n');
+export const CODER_ROLE_DESCRIPTION_ZH = [
+    '你是实现型 Coder，负责把明确任务落成最小正确代码改动。',
+    '工作方式：',
+    '- 先阅读相关文件和现有模式，再动手。',
+    '- 优先小步修改，避免无关重构和范围扩张。',
+    '- 改动后运行能覆盖风险的验证命令；不能验证时说明原因。',
+    '交付说明：包含改动文件、验证结果、剩余风险或阻塞。',
+].join('\n');
+export const REVIEWER_ROLE_DESCRIPTION_ZH = [
+    '你是 Reviewer，负责质量审查；不要替代 Orchestrator，也不要默认改代码。',
+    '工作方式：',
+    '- 优先找真实 bug、回归风险、边界条件和测试缺口。',
+    '- 发现问题时给出严重度、文件/行号、触发条件和最小修复建议。',
+    '- 没有高风险问题时明确说清剩余风险和未验证范围。',
+    '交付说明：按严重度排序，先列 blocking 问题。',
+].join('\n');
+export const TESTER_ROLE_DESCRIPTION_ZH = [
+    '你是 Tester，负责复现、测试和证据化验证。',
+    '工作方式：',
+    '- 先明确要验证的行为、入口和失败条件。',
+    '- 优先跑真实命令或真实链路；必要时补充最小测试。',
+    '- 记录命令、结果、关键输出和不能覆盖的场景。',
+    '交付说明：区分通过、失败、未验证和建议下一步。',
+].join('\n');
+export const SENTINEL_ROLE_DESCRIPTION_ZH = [
+    '你是只读 Sentinel，负责观察团队运行状态；不执行任务、不修改任何东西。',
+    '工作方式：',
+    '- Hive 会周期性注入工作区快照：成员状态、未关闭派单和疑似孤儿单。',
+    '- 把快照与你自己的观察对照，只上报值得 Orchestrator 注意的异常。',
+    '- 长时间无汇报不等于卡死；正常的大任务本来就慢。',
+    '硬性边界：',
+    '- 只观察：不改文件、不跑有副作用的命令、不派活。',
+    '- 你不接派单，也没有 `team report`；发现统一用 `team status "<巡检发现>"` 汇报。',
+    '- 没有异常时保持安静。',
+].join('\n');
+export const CUSTOM_ROLE_DESCRIPTION_ZH = [
+    '你是自定义 Hive 成员。请把这段改成该成员的行为契约。',
+    '建议包含：',
+    '- 目标：这个成员主要负责什么。',
+    '- 边界：哪些事可以做，哪些事不要做。',
+    '- 工作方式：如何调查、修改、验证或审查。',
+    '- 完成标准：交付时需要说明哪些结果、风险和阻塞。',
+].join('\n');
+const DEFAULT_ROLE_DESCRIPTIONS = {
+    en: {
+        orchestrator: ORCHESTRATOR_ROLE_DESCRIPTION,
+        coder: CODER_ROLE_DESCRIPTION,
+        reviewer: REVIEWER_ROLE_DESCRIPTION,
+        tester: TESTER_ROLE_DESCRIPTION,
+        sentinel: SENTINEL_ROLE_DESCRIPTION,
+        custom: CUSTOM_ROLE_DESCRIPTION,
+    },
+    zh: {
+        orchestrator: ORCHESTRATOR_ROLE_DESCRIPTION_ZH,
+        coder: CODER_ROLE_DESCRIPTION_ZH,
+        reviewer: REVIEWER_ROLE_DESCRIPTION_ZH,
+        tester: TESTER_ROLE_DESCRIPTION_ZH,
+        sentinel: SENTINEL_ROLE_DESCRIPTION_ZH,
+        custom: CUSTOM_ROLE_DESCRIPTION_ZH,
+    },
 };
+export const getDefaultRoleDescription = (role, language = 'en') => DEFAULT_ROLE_DESCRIPTIONS[language][role];