@tt-a1i/hive 1.4.4 → 1.5.0

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

@@ -7,9 +7,26 @@ 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 CODEX_PASTE_ACK_SETTLE_DELAY_MS = 250;
 const PASTE_ACK_TIMEOUT_MS = 3000;
+// 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.
+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
+// input box, so waiting for an acknowledgement there degrades into the 10s
+// timeout before Enter is sent.
+const CODEX_PASTE_ACK_MIN_CHARS = 2000;
+const CODEX_SUBMIT_RETRY_DELAY_MS = 500;
 const COMMANDS_WITH_BRACKETED_PASTE = new Set(['claude', 'codex', 'opencode']);
+const COMMANDS_WAITING_FOR_PASTE_ACK = new Set(['claude', 'codex']);
+const BRACKETED_PASTE_END = '\u001b[201~';
+const PASTE_ACK_PATTERN = /(?:^|[\r\n])\s*(?:[❯›]\s*)?\[(?:Pasted text #\d+[^\]]*|Pasted Content [\d,]+ chars)\]/u;
+const PASTE_ACK_ONLY_DELTA_PATTERN = /^[\s\r\n]*(?:[❯›]\s*)?\[(?:Pasted text #\d+[^\]]*|Pasted Content [\d,]+ chars)\]\s*(?:[❯›]\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 getSubmitAfterPasteDelayMs = (text) => Math.min(MAX_SUBMIT_AFTER_PASTE_DELAY_MS, Math.max(MIN_SUBMIT_AFTER_PASTE_DELAY_MS, Math.ceil(text.length / PASTE_CHARS_PER_DELAY_MS)));
 export const isInteractiveAgentCommand = (command) => {
     const brand = normalizeExecutableToken(command);
@@ -22,8 +39,24 @@ export const hasInteractivePromptReady = (output, command = '') => {
     return (/(?:^|[\r\n])\s*[❯›]\s*/u.test(output) ||
         (commandName === 'gemini' && hasGeminiPromptReady(output)));
 };
-export const hasBracketedPasteAcknowledgement = (output, baselineLength) => /\[Pasted text #\d+/u.test(output.slice(baselineLength));
-const isClaudeCommand = (command) => getCommandName(command) === 'claude';
+export const hasBracketedPasteAcknowledgement = (output, baselineLength) => {
+    const outputAfterPaste = output.slice(baselineLength);
+    const pasteEndIndex = outputAfterPaste.lastIndexOf(BRACKETED_PASTE_END);
+    const acknowledgementOutput = pasteEndIndex === -1
+        ? outputAfterPaste
+        : outputAfterPaste.slice(pasteEndIndex + BRACKETED_PASTE_END.length);
+    return PASTE_ACK_PATTERN.test(acknowledgementOutput);
+};
+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;
+    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 usesBracketedPaste = (command) => COMMANDS_WITH_BRACKETED_PASTE.has(getCommandName(command));
 const canTimeoutBeforePromptReady = (command) => getCommandName(command) !== 'gemini';
 const isWritableRunStatus = (status) => status === undefined || status === 'starting' || status === 'running';
@@ -40,7 +73,7 @@ const writeIfRunWritable = (agentManager, runId, text) => {
     agentManager.writeInput(runId, text);
     return true;
 };
-const submitPastedInteractiveInput = (agentManager, runId, text, baselineLength, waitForPasteAck) => {
+const submitPastedInteractiveInput = (agentManager, runId, text, baselineLength, waitForPasteAck, pasteAckSettleDelayMs, pasteAckTimeoutMs, retrySubmit, onDone, onError) => {
     const pastedAt = Date.now();
     const minDelay = getSubmitAfterPasteDelayMs(text);
     let acknowledgedAt = null;
@@ -53,30 +86,73 @@ const submitPastedInteractiveInput = (agentManager, runId, text, baselineLength,
             return null;
         }
     };
-    const submit = () => {
+    const getRunOutputState = () => {
         try {
-            writeIfRunWritable(agentManager, runId, '\r');
+            const run = agentManager.getRun(runId);
+            return { output: run.output, writable: isWritableRunStatus(run.status) };
         }
         catch {
+            return null;
+        }
+    };
+    const submit = (retryAfterSubmit) => {
+        try {
+            const outputBeforeSubmit = retryAfterSubmit ? getWritableOutput() : null;
+            if (!writeIfRunWritable(agentManager, runId, '\r')) {
+                onError(createRunInactiveError(runId));
+                return;
+            }
+            if (!retryAfterSubmit) {
+                onDone();
+                return;
+            }
+            setTimeout(() => {
+                try {
+                    const runAfterSubmit = getRunOutputState();
+                    if (runAfterSubmit === null) {
+                        onDone();
+                        return;
+                    }
+                    if (outputBeforeSubmit !== null &&
+                        hasBracketedPasteAcknowledgement(runAfterSubmit.output, baselineLength) &&
+                        onlyPasteAcknowledgementWasAppended(outputBeforeSubmit, runAfterSubmit.output)) {
+                        if (!runAfterSubmit.writable || !writeIfRunWritable(agentManager, runId, '\r')) {
+                            onError(createRunInactiveError(runId));
+                            return;
+                        }
+                    }
+                }
+                catch (error) {
+                    onError(toError(error));
+                    return;
+                }
+                onDone();
+            }, CODEX_SUBMIT_RETRY_DELAY_MS);
+        }
+        catch (error) {
             // The PTY may have exited between paste and submit.
+            onError(toError(error));
         }
     };
     const trySubmit = () => {
         if (!waitForPasteAck) {
-            submit();
+            submit(false);
             return;
         }
         const output = getWritableOutput();
         if (output === null) {
+            onError(createRunInactiveError(runId));
             return;
         }
         if (acknowledgedAt === null && hasBracketedPasteAcknowledgement(output, baselineLength)) {
             acknowledgedAt = Date.now();
         }
         const elapsed = Date.now() - pastedAt;
-        const ackSettled = acknowledgedAt !== null && Date.now() - acknowledgedAt >= PASTE_ACK_SETTLE_DELAY_MS;
-        if ((ackSettled && elapsed >= minDelay) || elapsed >= PASTE_ACK_TIMEOUT_MS) {
-            submit();
+        const ackSettled = acknowledgedAt !== null && Date.now() - acknowledgedAt >= pasteAckSettleDelayMs;
+        const submitAfterAck = ackSettled && elapsed >= minDelay;
+        const submitAfterTimeout = elapsed >= pasteAckTimeoutMs;
+        if (submitAfterAck || submitAfterTimeout) {
+            submit(retrySubmit && submitAfterTimeout);
             return;
         }
         setTimeout(trySubmit, PASTE_ACK_CHECK_INTERVAL_MS);
@@ -86,10 +162,21 @@ const submitPastedInteractiveInput = (agentManager, runId, text, baselineLength,
 export const createPostStartInputWriter = (agentManager, command) => {
     if (!isInteractiveAgentCommand(command)) {
         return (runId, text) => {
-            writeIfRunWritable(agentManager, runId, `${text}\n`);
+            // Synchronous write; an EPIPE/inactive failure still throws synchronously
+            // (before the promise is returned), preserving the dispatcher's contract.
+            if (!writeIfRunWritable(agentManager, runId, `${text}\n`)) {
+                throw createRunInactiveError(runId);
+            }
+            return Promise.resolve();
         };
     }
     return (runId, text) => {
+        let resolveDone;
+        let rejectDone;
+        const rejectableDone = new Promise((resolve, reject) => {
+            resolveDone = resolve;
+            rejectDone = reject;
+        });
         const startedAt = Date.now();
         let isInitialAttempt = true;
         const tryWrite = () => {
@@ -99,33 +186,43 @@ export const createPostStartInputWriter = (agentManager, command) => {
                 output = isWritableRunStatus(run.status) ? run.output : null;
             }
             catch {
+                rejectDone(createRunInactiveError(runId));
                 return;
             }
-            if (output === null)
+            if (output === null) {
+                rejectDone(createRunInactiveError(runId));
                 return;
+            }
             if (hasInteractivePromptReady(output, command) ||
                 (canTimeoutBeforePromptReady(command) && Date.now() - startedAt >= READY_TIMEOUT_MS)) {
                 const baselineLength = output.length;
                 const input = usesBracketedPaste(command) ? toBracketedPasteSubmission(text) : text;
                 try {
-                    if (!writeIfRunWritable(agentManager, runId, input))
+                    if (!writeIfRunWritable(agentManager, runId, input)) {
+                        rejectDone(createRunInactiveError(runId));
                         return;
+                    }
                 }
                 catch (error) {
                     if (isInitialAttempt)
                         throw error;
+                    rejectDone(toError(error));
                     return;
                 }
-                submitPastedInteractiveInput(agentManager, runId, text, baselineLength, isClaudeCommand(command));
+                submitPastedInteractiveInput(agentManager, runId, text, baselineLength, shouldWaitForPasteAck(command, text), getPasteAckSettleDelayMs(command), getPasteAckTimeoutMs(command), retriesSubmit(command), resolveDone, rejectDone);
                 return;
             }
             setTimeout(tryWrite, READY_CHECK_INTERVAL_MS);
         };
         try {
+            // Called outside the Promise executor so an initial-attempt throw
+            // propagates synchronously to the caller (preserving the dispatcher's
+            // synchronous-throw contract) instead of becoming a rejection.
             tryWrite();
         }
         finally {
             isInitialAttempt = false;
         }
+        return rejectableDone;
     };
 };

package/dist/src/server/preset-launch-support.d.ts

@@ -1,6 +1,6 @@
 import type { AgentLaunchConfigInput } from './agent-run-store.js';
 import type { CommandPresetRecord } from './command-preset-store.js';
 import type { SessionCaptureSnapshot } from './session-capture.js';
-type BoundPreset = Pick<CommandPresetRecord, 'resumeArgsTemplate' | 'sessionIdCapture' | 'yoloArgsTemplate'>;
+type BoundPreset = Pick<CommandPresetRecord, 'resumeArgsTemplate' | 'sessionIdCapture' | 'yoloArgsTemplate'> & Partial<Pick<CommandPresetRecord, 'command' | 'id'>>;
 export declare const withPresetResumeArgs: (config: AgentLaunchConfigInput, preset: BoundPreset | null | undefined, lastSessionId: string | undefined, cwd?: string, discriminator?: SessionCaptureSnapshot["discriminator"], onInvalidSessionId?: (sessionId: string) => void) => AgentLaunchConfigInput;
 export {};

package/dist/src/server/preset-launch-support.js

@@ -3,6 +3,36 @@ const appendUniqueArgs = (prefix, args) => {
     const seen = new Set(prefix);
     return prefix.concat(args.filter((arg) => !seen.has(arg)));
 };
+const unquoteExecutable = (command) => command.trim().replace(/^"(.+)"$/, '$1');
+const isNodeExecutable = (command) => {
+    if (!command)
+        return false;
+    return /(?:^|[\\/])node(?:\.exe)?$/iu.test(unquoteExecutable(command));
+};
+const isCodexNpmEntrypoint = (arg) => {
+    if (!arg)
+        return false;
+    const normalized = arg.replace(/\\/gu, '/');
+    return /(?:^|\/)@openai\/codex\/bin\/codex\.js$/iu.test(normalized);
+};
+const isCodexPreset = (preset) => preset?.id === 'codex' ||
+    preset?.command === 'codex' ||
+    preset?.sessionIdCapture?.source === 'codex_session_jsonl_dir';
+const normalizeCodexNodeEntrypoint = (config, preset) => {
+    if (!isCodexPreset(preset) || !isNodeExecutable(config.command))
+        return config;
+    const args = config.args ?? [];
+    if (!isCodexNpmEntrypoint(args[0]))
+        return config;
+    return {
+        ...config,
+        args: args.slice(1),
+        command: preset?.command ?? 'codex',
+        interactiveCommand: isNodeExecutable(config.interactiveCommand)
+            ? 'codex'
+            : (config.interactiveCommand ?? 'codex'),
+    };
+};
 const getEffectiveCapture = (config, preset) => config.sessionIdCapture ?? preset?.sessionIdCapture ?? null;
 const getEffectiveResumeTemplate = (config, preset) => config.resumeArgsTemplate ?? preset?.resumeArgsTemplate ?? null;
 const withPresetYoloArgs = (config, preset) => {
@@ -35,7 +65,8 @@ const supportsPresetResume = (capture) => capture?.source === 'claude_project_js
     capture?.source === 'gemini_session_json_dir' ||
     capture?.source === 'opencode_session_db';
 export const withPresetResumeArgs = (config, preset, lastSessionId, cwd, discriminator, onInvalidSessionId) => {
-    let nextConfig = withPresetYoloArgs(config, preset);
+    const launchConfig = normalizeCodexNodeEntrypoint(config, preset);
+    let nextConfig = withPresetYoloArgs(launchConfig, preset);
     const sessionIdCapture = getEffectiveCapture(nextConfig, preset);
     if (sessionIdCapture && sessionIdCapture !== nextConfig.sessionIdCapture) {
         nextConfig = { ...nextConfig, sessionIdCapture };
@@ -52,7 +83,7 @@ export const withPresetResumeArgs = (config, preset, lastSessionId, cwd, discrim
         onInvalidSessionId?.(lastSessionId);
         return nextConfig;
     }
-    const args = config.args ?? [];
+    const args = launchConfig.args ?? [];
     if (hasResumeArgs(args))
         return nextConfig;
     const yoloArgs = getPresetYoloArgs(preset);

package/dist/src/server/recovery-summary.d.ts

@@ -1,10 +1,15 @@
 import type { AgentSummary, WorkspaceSummary } from '../shared/types.js';
 import type { RecoveryMessage } from './message-log-store.js';
-export declare const buildRecoverySummary: ({ agent, allTaskMessages, messages, tasksContent, workers, workspace, }: {
+export declare const buildRecoverySummary: ({ agent, allTaskMessages, messages, tasksContent, workers, workspace, workflowsEnabled, autostaffEnabled, }: {
     agent: AgentSummary;
     allTaskMessages?: RecoveryMessage[];
     messages: RecoveryMessage[];
     tasksContent: string;
     workers: AgentSummary[];
     workspace: WorkspaceSummary;
+    /** Experimental workflow gate — keeps the recovered handover prompt
+     *  consistent with the live flag (omits the workflow rule when off). */
+    workflowsEnabled?: boolean;
+    /** Experimental auto-staff gate (default on) — same, for the team-sizing rule. */
+    autostaffEnabled?: boolean;
 }) => string;

package/dist/src/server/recovery-summary.js

@@ -6,7 +6,7 @@ const formatUserInputs = (messages) => {
     const userInputs = messages.filter((message) => message.type === 'user_input');
     return userInputs.length > 0
         ? userInputs.slice(-5).map((message) => `- user: ${message.text}`)
-        : ['- （最近 1 小时没有新的 user_input）'];
+        : ['- (no new user_input in the last hour)'];
 };
 const formatTaskEvents = (messages, agent) => {
     const taskEvents = messages.filter((message) => {
@@ -28,7 +28,7 @@ const formatTaskEvents = (messages, agent) => {
             const status = message.status ? ` [${message.status}]` : '';
             return `- report <- ${message.from}${status}: ${message.text}`;
         })
-        : ['- （最近没有任务事件）'];
+        : ['- (no recent task events)'];
 };
 const getOpenTaskTargets = (agent, workers) => agent.role === 'orchestrator' ? workers : [agent];
 const formatOpenTasks = (messages, agent, workers) => {
@@ -53,38 +53,38 @@ const formatOpenTasks = (messages, agent, workers) => {
             lines.push(`- ${target.name}: ${task.text}`);
         }
         if (target.pendingTaskCount > queue.length) {
-            lines.push(`- ${target.name}: ${target.pendingTaskCount - queue.length} 个 pending 无可恢复详情`);
+            lines.push(`- ${target.name}: ${target.pendingTaskCount - queue.length} pending with no recoverable detail`);
         }
     }
-    return lines.length > 0 ? lines : ['- （当前没有未完成任务）'];
+    return lines.length > 0 ? lines : ['- (no open tasks right now)'];
 };
 const formatWorkers = (workers) => {
     if (workers.length === 0)
-        return ['- 当前没有其他 worker'];
+        return ['- (no other workers)'];
     return workers.map((worker) => `- ${worker.name} (${worker.role}, ${worker.status}, pending_task_count: ${worker.pendingTaskCount})`);
 };
-const getTaskSectionTitle = (agent) => agent.role === 'orchestrator' ? '## 你已派出的任务' : '## 最近派给你的任务';
-export const buildRecoverySummary = ({ agent, allTaskMessages, messages, tasksContent, workers, workspace, }) => wrapSystemMessage([
-    `你是 ${workspace.name} 的 ${agent.name}（${agent.role}）。`,
-    '你刚被 Hive 重启了，且无法通过原生 session resume 恢复。下面是接力上下文。',
+const getTaskSectionTitle = (agent) => agent.role === 'orchestrator' ? '## Tasks you dispatched' : '## Tasks recently sent to you';
+export const buildRecoverySummary = ({ agent, allTaskMessages, messages, tasksContent, workers, workspace, workflowsEnabled = false, autostaffEnabled = false, }) => wrapSystemMessage([
+    `You are ${agent.name} (${agent.role}) in workspace ${workspace.name}.`,
+    'Hive just restarted you and could not recover via native session resume. Here is the handover context.',
     '',
-    '## 最近 1 小时与 user 的对话',
+    '## Conversation with the user in the last hour',
     ...formatUserInputs(messages),
     '',
     getTaskSectionTitle(agent),
     ...formatTaskEvents(messages, agent),
     '',
-    '## 当前未完成任务',
+    '## Open tasks',
     ...formatOpenTasks(allTaskMessages ?? messages, agent, workers),
     '',
-    `## 当前 ${TASKS_RELATIVE_PATH} 状态`,
-    tasksContent.slice(0, TASKS_HEAD_LIMIT) || '(空)',
+    `## Current ${TASKS_RELATIVE_PATH}`,
+    tasksContent.slice(0, TASKS_HEAD_LIMIT) || '(empty)',
     '',
-    '## 当前活跃 worker',
+    '## Active workers',
     ...formatWorkers(workers),
     '',
-    agent.role === 'orchestrator' ? '## Hive worker 派单规则' : '## Hive worker 边界',
-    ...getHiveTeamRules(agent),
+    agent.role === 'orchestrator' ? '## Hive worker dispatch rules' : '## Hive worker boundaries',
+    ...getHiveTeamRules(agent, workflowsEnabled, autostaffEnabled),
     '',
-    '请基于此继续。如果不确定，问 user。',
+    'Continue from here. If unsure, ask the user.',
 ].join('\n'));

package/dist/src/server/restart-policy-support.d.ts

@@ -11,6 +11,11 @@ export interface RestartPolicyInput {
     listAgentRuns: (agentId: string) => PersistedAgentRun[];
     listMessagesForRecovery: (workspaceId: string, sinceMs: number) => RecoveryMessage[];
     readTasks: (workspacePath: string) => string;
+    /** Experimental workflow gate — threaded into the recovery handover prompt
+     *  so it matches the live flag. Optional; omitted → off. */
+    getWorkflowsEnabled?: () => boolean;
+    /** Experimental auto-staff gate (default on) — same. */
+    getAutostaffEnabled?: () => boolean;
 }
 export declare const findPreviousRun: (runs: PersistedAgentRun[], currentRunId: string) => PersistedAgentRun | undefined;
 export declare const writeSystemMessage: ({ deleteMessage, insertMessage, record, runId, text, writeToRun, }: {
@@ -19,5 +24,5 @@ export declare const writeSystemMessage: ({ deleteMessage, insertMessage, record
     record: MessageLogRecord;
     runId: string;
     text: string;
-    writeToRun: (runId: string, text: string) => void;
+    writeToRun: (runId: string, text: string) => Promise<void>;
 }) => void;

package/dist/src/server/restart-policy-support.js

@@ -2,7 +2,15 @@ export const findPreviousRun = (runs, currentRunId) => runs.find((run) => run.ru
 export const writeSystemMessage = ({ deleteMessage, insertMessage, record, runId, text, writeToRun, }) => {
     const handle = insertMessage(record);
     try {
-        writeToRun(runId, text);
+        void writeToRun(runId, text).catch(() => {
+            try {
+                deleteMessage(handle);
+            }
+            catch {
+                // The runtime may already be closing; the failed post-start write is
+                // non-critical once the run is gone.
+            }
+        });
     }
     catch (error) {
         deleteMessage(handle);

package/dist/src/server/restart-policy.d.ts

@@ -7,8 +7,8 @@ export interface RestartPolicy {
         runId: string;
         startConfig: AgentLaunchConfigInput;
         workspace: WorkspaceSummary;
-        writeToRun: (runId: string, text: string) => void;
+        writeToRun: (runId: string, text: string) => Promise<void>;
     }) => boolean;
 }
 export declare const createNoopRestartPolicy: () => RestartPolicy;
-export declare const createRestartPolicy: ({ deleteMessage, getWorkspaceSnapshot, insertMessage, listAgentRuns, listMessagesForRecovery, readTasks, }: RestartPolicyInput) => RestartPolicy;
+export declare const createRestartPolicy: ({ deleteMessage, getWorkspaceSnapshot, insertMessage, listAgentRuns, listMessagesForRecovery, readTasks, getWorkflowsEnabled, getAutostaffEnabled, }: RestartPolicyInput) => RestartPolicy;

package/dist/src/server/restart-policy.js

@@ -7,7 +7,7 @@ export const createNoopRestartPolicy = () => ({
         return false;
     },
 });
-export const createRestartPolicy = ({ deleteMessage, getWorkspaceSnapshot, insertMessage, listAgentRuns, listMessagesForRecovery, readTasks, }) => ({
+export const createRestartPolicy = ({ deleteMessage, getWorkspaceSnapshot, insertMessage, listAgentRuns, listMessagesForRecovery, readTasks, getWorkflowsEnabled, getAutostaffEnabled, }) => ({
     injectPostStartMessage({ agentId, runId, startConfig, workspace, writeToRun }) {
         const previousRun = findPreviousRun(listAgentRuns(agentId), runId);
         if (!previousRun)
@@ -27,6 +27,8 @@ export const createRestartPolicy = ({ deleteMessage, getWorkspaceSnapshot, inser
             tasksContent,
             workers,
             workspace,
+            workflowsEnabled: getWorkflowsEnabled?.() ?? false,
+            autostaffEnabled: getAutostaffEnabled?.() ?? false,
         });
         writeSystemMessage({
             deleteMessage,

package/dist/src/server/role-template-store.d.ts

@@ -41,4 +41,5 @@ export declare const createRoleTemplateStore: (db: Database) => {
         id: string;
         isBuiltin: boolean;
     };
+    findByName: (name: string) => RoleTemplateRecord | undefined;
 };

package/dist/src/server/role-template-store.js

@@ -34,6 +34,16 @@ export const createRoleTemplateStore = (db) => {
             .all()
             .map((row) => toRecord(row));
     };
+    /* TIER 2 #4 — case-insensitive lookup by template name. The workflow
+       runner uses this to resolve `agent('...', { agentType: 'security-reviewer' })`
+       against the workspace's custom role library so workflows can target
+       curated roles instead of always re-rolling fresh claude defaults. */
+    const findByName = (name) => {
+        const needle = name.trim().toLowerCase();
+        if (!needle)
+            return undefined;
+        return list().find((template) => template.name.trim().toLowerCase() === needle);
+    };
     const create = (input) => {
         const record = { id: randomUUID(), ...input, isBuiltin: false };
         const now = Date.now();
@@ -62,5 +72,5 @@ export const createRoleTemplateStore = (db) => {
             throw new ConflictError(`Builtin role template is read-only: ${id}`);
         db.prepare('DELETE FROM role_templates WHERE id = ?').run(id);
     };
-    return { create, list, remove, update };
+    return { create, list, remove, update, findByName };
 };

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

@@ -13,6 +13,49 @@ export interface SendTaskBody {
     to: string;
     text: string;
 }
+export interface SpawnAgentBody {
+    hive_port?: string;
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    role?: string;
+    name?: string;
+    cli?: string;
+    /** Opt-in: auto-dismiss the worker after its next dispatch report. Default
+     *  false → persistent member (lives until explicit `team dismiss`). */
+    ephemeral?: boolean;
+}
+export interface DismissAgentBody {
+    hive_port?: string;
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    name: string;
+}
+export interface WorkflowRunBody {
+    hive_port?: string;
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    source: string;
+    name?: string;
+    args?: unknown;
+}
+export interface WorkflowControlBody {
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    run_id: string;
+}
+export interface WorkflowScheduleBody {
+    project_id: string;
+    from_agent_id: string;
+    token?: string;
+    source: string;
+    name: string;
+    cron: string;
+    args?: unknown;
+}
 export interface ReportTaskBody {
     dispatch_id?: string;
     project_id: string;

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

@@ -1,5 +1,6 @@
 import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
 import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+import { serializeLiveAgentRun } from './workflow-http-serializers.js';
 import { getWorkspaceShellAgentId } from './workspace-shell-runtime.js';
 export const runtimeRoutes = [
     route('GET', '/api/ui/workspaces/:workspaceId/runs', ({ params, request, response, store }) => {
@@ -73,6 +74,6 @@ export const runtimeRoutes = [
             return;
         }
         requireUiTokenFromRequest(request, store.validateUiToken);
-        sendJson(response, 200, store.getLiveRun(runId));
+        sendJson(response, 200, serializeLiveAgentRun(store.getLiveRun(runId)));
     }),
 ];

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

@@ -1,6 +1,11 @@
 import { resolveCommandPath } from './agent-command-resolver.js';
+import { BadRequestError } from './http-errors.js';
 import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
+import { ensureProtocolFile } from './tasks-file.js';
+import { AUTOSTAFF_ENABLED_KEY, readAutostaffEnabled, serializeAutostaffEnabled, } from './team-autostaff.js';
 import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
+import { assertValidWorkflowCliPolicy, CANONICAL_WORKFLOW_CLIS, readWorkflowCliPolicy, WORKFLOW_CLI_POLICY_KEY, } from './workflow-cli-policy.js';
+import { readWorkflowEnabled, serializeWorkflowEnabled, WORKFLOW_ENABLED_KEY, } from './workflow-feature.js';
 const serializeCommandPreset = (preset) => {
     let available = false;
     try {
@@ -35,6 +40,26 @@ const serializeRoleTemplate = (template) => ({
     default_env: template.defaultEnv,
     is_builtin: template.isBuiltin,
 });
+/**
+ * Rewrite every open workspace's `.hive/PROTOCOL.md` to match the just-saved
+ * workflow feature flag + CLI policy. Without this the doc only refreshes on
+ * the next workspace open / watcher start, so toggling the feature would leave
+ * stale guidance (workflow DSL still present after disabling, or absent right
+ * after enabling). Idempotent: ensureProtocolFile only rewrites on change.
+ */
+const refreshWorkflowProtocolDocs = (store) => {
+    const policy = readWorkflowCliPolicy(store.settings.getAppState(WORKFLOW_CLI_POLICY_KEY)?.value ?? null);
+    const enabled = readWorkflowEnabled(store.settings.getAppState(WORKFLOW_ENABLED_KEY)?.value ?? null);
+    const autostaff = readAutostaffEnabled(store.settings.getAppState(AUTOSTAFF_ENABLED_KEY)?.value ?? null);
+    for (const workspace of store.listWorkspaces()) {
+        try {
+            ensureProtocolFile(workspace.path, policy, enabled, autostaff);
+        }
+        catch (error) {
+            console.error('[hive] swallowed:settings.refreshProtocol', error);
+        }
+    }
+};
 const readCommandPresetBody = async (request) => {
     const body = await readJsonBody(request);
     return {
@@ -134,4 +159,55 @@ export const settingsRoutes = [
         response.statusCode = 204;
         response.end();
     }),
+    route('GET', '/api/settings/workflow-cli-policy', ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const policy = readWorkflowCliPolicy(store.settings.getAppState(WORKFLOW_CLI_POLICY_KEY)?.value ?? null);
+        sendJson(response, 200, { ...policy, supported: [...CANONICAL_WORKFLOW_CLIS] });
+    }),
+    route('PUT', '/api/settings/workflow-cli-policy', async ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const body = await readJsonBody(request);
+        // Strict validation: a bad payload is rejected (400) rather than persisted.
+        const clean = (() => {
+            try {
+                return assertValidWorkflowCliPolicy(body);
+            }
+            catch (error) {
+                throw new BadRequestError(error instanceof Error ? error.message : String(error));
+            }
+        })();
+        store.settings.setAppState(WORKFLOW_CLI_POLICY_KEY, JSON.stringify(clean));
+        refreshWorkflowProtocolDocs(store);
+        sendJson(response, 200, { ...clean, supported: [...CANONICAL_WORKFLOW_CLIS] });
+    }),
+    route('GET', '/api/settings/workflow-feature', ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const enabled = readWorkflowEnabled(store.settings.getAppState(WORKFLOW_ENABLED_KEY)?.value ?? null);
+        sendJson(response, 200, { enabled });
+    }),
+    route('PUT', '/api/settings/workflow-feature', async ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const body = await readJsonBody(request);
+        if (typeof body.enabled !== 'boolean') {
+            throw new BadRequestError('workflow-feature requires { enabled: boolean }');
+        }
+        store.settings.setAppState(WORKFLOW_ENABLED_KEY, serializeWorkflowEnabled(body.enabled));
+        refreshWorkflowProtocolDocs(store);
+        sendJson(response, 200, { enabled: body.enabled });
+    }),
+    route('GET', '/api/settings/team-autostaff', ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const enabled = readAutostaffEnabled(store.settings.getAppState(AUTOSTAFF_ENABLED_KEY)?.value ?? null);
+        sendJson(response, 200, { enabled });
+    }),
+    route('PUT', '/api/settings/team-autostaff', async ({ request, response, store }) => {
+        requireUiTokenFromRequest(request, store.validateUiToken);
+        const body = await readJsonBody(request);
+        if (typeof body.enabled !== 'boolean') {
+            throw new BadRequestError('team-autostaff requires { enabled: boolean }');
+        }
+        store.settings.setAppState(AUTOSTAFF_ENABLED_KEY, serializeAutostaffEnabled(body.enabled));
+        refreshWorkflowProtocolDocs(store);
+        sendJson(response, 200, { enabled: body.enabled });
+    }),
 ];