@tt-a1i/hive 1.4.4 → 1.6.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,14 @@
 import type { AgentSummary, WorkspaceSummary } from '../shared/types.js';
+import { type FeatureFlags } from './feature-flags.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, flags, }: {
     agent: AgentSummary;
     allTaskMessages?: RecoveryMessage[];
     messages: RecoveryMessage[];
     tasksContent: string;
     workers: AgentSummary[];
     workspace: WorkspaceSummary;
+    /** Live experimental flags — keep the recovered handover prompt consistent
+     *  with what a fresh startup would inject (workflow + team-sizing rules). */
+    flags?: FeatureFlags;
 }) => string;

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

@@ -1,3 +1,4 @@
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
 import { getHiveTeamRules } from './hive-team-guidance.js';
 import { wrapSystemMessage } from './system-message.js';
 import { TASKS_RELATIVE_PATH } from './tasks-file.js';
@@ -6,7 +7,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 +29,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 +54,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, flags = FEATURE_FLAGS_ALL_OFF, }) => 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, flags),
     '',
-    '请基于此继续。如果不确定，问 user。',
+    'Continue from here. If unsure, ask the user.',
 ].join('\n'));

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

@@ -0,0 +1,36 @@
+import type { Database } from 'better-sqlite3';
+/**
+ * Durable redelivery queue for worker reports the orchestrator could not
+ * receive. `team report` persists the dispatch as reported and forwards the
+ * report into the orchestrator's stdin best-effort; if that write fails (the
+ * PTY exited / is mid-restart, or the orchestrator was down at report time)
+ * the report would otherwise be lost — the ledger says "reported" yet the
+ * orchestrator waits forever, indistinguishable from a hang.
+ *
+ * Entries are keyed by dispatch id (UNIQUE) so a report enqueues at most once,
+ * and drain marks them delivered only after the orchestrator PTY write
+ * actually resolves, so a failed redelivery stays pending for the next drain.
+ */
+export interface ReportOutboxEntry {
+    id: number;
+    workspaceId: string;
+    targetAgentId: string;
+    dispatchId: string;
+    payload: string;
+    createdAt: number;
+    deliveredAt: number | null;
+}
+interface EnqueueInput {
+    workspaceId: string;
+    targetAgentId: string;
+    dispatchId: string;
+    payload: string;
+}
+export declare const createReportOutboxStore: (db: Database) => {
+    enqueue: (input: EnqueueInput) => void;
+    listPending: (workspaceId: string, targetAgentId: string) => ReportOutboxEntry[];
+    markDelivered: (id: number) => void;
+    pendingCount: (workspaceId: string, targetAgentId: string) => number;
+};
+export type ReportOutboxStore = ReturnType<typeof createReportOutboxStore>;
+export {};

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

@@ -0,0 +1,33 @@
+const rowToEntry = (row) => ({
+    id: row.id,
+    workspaceId: row.workspace_id,
+    targetAgentId: row.target_agent_id,
+    dispatchId: row.dispatch_id,
+    payload: row.payload,
+    createdAt: row.created_at,
+    deliveredAt: row.delivered_at,
+});
+export const createReportOutboxStore = (db) => {
+    // INSERT OR IGNORE on the UNIQUE dispatch_id: a dispatch reports once, so a
+    // second enqueue for the same dispatch (e.g. a retry path) is a no-op rather
+    // than a duplicate the orchestrator would see twice.
+    const enqueue = (input) => {
+        db.prepare(`INSERT OR IGNORE INTO report_outbox
+        (workspace_id, target_agent_id, dispatch_id, payload, created_at)
+       VALUES (?, ?, ?, ?, ?)`).run(input.workspaceId, input.targetAgentId, input.dispatchId, input.payload, Date.now());
+    };
+    const listPending = (workspaceId, targetAgentId) => db
+        .prepare(`SELECT id, workspace_id, target_agent_id, dispatch_id, payload, created_at, delivered_at
+           FROM report_outbox
+           WHERE workspace_id = ? AND target_agent_id = ? AND delivered_at IS NULL
+           ORDER BY created_at ASC, id ASC`)
+        .all(workspaceId, targetAgentId).map(rowToEntry);
+    const markDelivered = (id) => {
+        db.prepare(`UPDATE report_outbox SET delivered_at = ? WHERE id = ? AND delivered_at IS NULL`).run(Date.now(), id);
+    };
+    const pendingCount = (workspaceId, targetAgentId) => db
+        .prepare(`SELECT COUNT(*) AS n FROM report_outbox
+           WHERE workspace_id = ? AND target_agent_id = ? AND delivered_at IS NULL`)
+        .get(workspaceId, targetAgentId).n;
+    return { enqueue, listPending, markDelivered, pendingCount };
+};

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

@@ -1,5 +1,6 @@
 import type { AgentSummary, WorkspaceSummary } from '../shared/types.js';
 import type { PersistedAgentRun } from './agent-run-store.js';
+import type { FeatureFlags } from './feature-flags.js';
 import type { MessageLogHandle, MessageLogRecord, RecoveryMessage } from './message-log-store.js';
 export interface RestartPolicyInput {
     deleteMessage: (handle: MessageLogHandle) => void;
@@ -11,6 +12,9 @@ export interface RestartPolicyInput {
     listAgentRuns: (agentId: string) => PersistedAgentRun[];
     listMessagesForRecovery: (workspaceId: string, sinceMs: number) => RecoveryMessage[];
     readTasks: (workspacePath: string) => string;
+    /** Resolves the live experimental flags, threaded into the recovery handover
+     *  prompt so it matches a fresh startup. Optional; omitted → all off. */
+    getFlags?: () => FeatureFlags;
 }
 export declare const findPreviousRun: (runs: PersistedAgentRun[], currentRunId: string) => PersistedAgentRun | undefined;
 export declare const writeSystemMessage: ({ deleteMessage, insertMessage, record, runId, text, writeToRun, }: {
@@ -19,5 +23,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,12 @@ export interface RestartPolicy {
         runId: string;
         startConfig: AgentLaunchConfigInput;
         workspace: WorkspaceSummary;
-        writeToRun: (runId: string, text: string) => void;
+        writeToRun: (runId: string, text: string) => Promise<void>;
     }) => boolean;
+    /** Record that `runId` was killed at the user's request (Stop button), so a
+     *  subsequent restart does not inject the crash-recovery handover for a run
+     *  the user deliberately ended. */
+    markUserStopped: (runId: string) => void;
 }
 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, getFlags, }: RestartPolicyInput) => RestartPolicy;

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

@@ -1,3 +1,4 @@
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
 import { buildRecoverySummary } from './recovery-summary.js';
 import { findPreviousRun, writeSystemMessage, } from './restart-policy-support.js';
 import { createSystemRecoverySummaryMessage } from './runtime-message-builders.js';
@@ -6,36 +7,55 @@ export const createNoopRestartPolicy = () => ({
     injectPostStartMessage() {
         return false;
     },
+    markUserStopped() { },
 });
-export const createRestartPolicy = ({ deleteMessage, getWorkspaceSnapshot, insertMessage, listAgentRuns, listMessagesForRecovery, readTasks, }) => ({
-    injectPostStartMessage({ agentId, runId, startConfig, workspace, writeToRun }) {
-        const previousRun = findPreviousRun(listAgentRuns(agentId), runId);
-        if (!previousRun)
-            return false;
-        const snapshot = getWorkspaceSnapshot(workspace.id);
-        const agent = snapshot.agents.find((item) => item.id === agentId);
-        if (!agent)
-            return false;
-        const workers = snapshot.agents.filter((item) => item.role !== 'orchestrator' && item.id !== agentId);
-        const tasksContent = readTasks(snapshot.summary.path);
-        if (startConfig.resumedSessionId)
+export const createRestartPolicy = ({ deleteMessage, getWorkspaceSnapshot, insertMessage, listAgentRuns, listMessagesForRecovery, readTasks, getFlags, }) => {
+    // Runs the user killed via the Stop button. A deliberate stop is otherwise
+    // byte-identical to a crash (both end status 'error'), so without this a
+    // stop+Restart would inject the "could not recover" handover with stale open
+    // tasks the user may have meant to abandon. In-process only: after a runtime
+    // restart this is empty, which is correct — that case IS a recovery.
+    const userStoppedRuns = new Set();
+    return {
+        markUserStopped(runId) {
+            userStoppedRuns.add(runId);
+        },
+        injectPostStartMessage({ agentId, runId, startConfig, workspace, writeToRun }) {
+            const previousRun = findPreviousRun(listAgentRuns(agentId), runId);
+            if (!previousRun)
+                return false;
+            // Consume the marker whether or not we end up skipping, so it never
+            // lingers to suppress a later genuine crash on the same run id.
+            const wasUserStopped = userStoppedRuns.delete(previousRun.runId);
+            const snapshot = getWorkspaceSnapshot(workspace.id);
+            const agent = snapshot.agents.find((item) => item.id === agentId);
+            if (!agent)
+                return false;
+            const workers = snapshot.agents.filter((item) => item.role !== 'orchestrator' && item.id !== agentId);
+            const tasksContent = readTasks(snapshot.summary.path);
+            if (startConfig.resumedSessionId)
+                return true;
+            // Deliberate stop + restart: start fresh, no crash handover.
+            if (wasUserStopped)
+                return false;
+            const text = buildRecoverySummary({
+                agent,
+                allTaskMessages: listMessagesForRecovery(workspace.id, 0),
+                messages: listMessagesForRecovery(workspace.id, Date.now() - RECOVERY_WINDOW_MS),
+                tasksContent,
+                workers,
+                workspace,
+                flags: getFlags?.() ?? FEATURE_FLAGS_ALL_OFF,
+            });
+            writeSystemMessage({
+                deleteMessage,
+                insertMessage,
+                record: createSystemRecoverySummaryMessage(workspace.id, agentId, text),
+                runId,
+                text,
+                writeToRun,
+            });
             return true;
-        const text = buildRecoverySummary({
-            agent,
-            allTaskMessages: listMessagesForRecovery(workspace.id, 0),
-            messages: listMessagesForRecovery(workspace.id, Date.now() - RECOVERY_WINDOW_MS),
-            tasksContent,
-            workers,
-            workspace,
-        });
-        writeSystemMessage({
-            deleteMessage,
-            insertMessage,
-            record: createSystemRecoverySummaryMessage(workspace.id, agentId, text),
-            runId,
-            text,
-            writeToRun,
-        });
-        return true;
-    },
-});
+        },
+    };
+};

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 };
 };