hivehq 2.0.0

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

@@ -0,0 +1,387 @@
+import { buildOrchestratorReportPayload } from './agent-stdin-dispatcher.js';
+import { ConflictError } from './http-errors.js';
+import { createReportMessage, createSendMessage, createStatusMessage, createUserInputMessage, } from './runtime-message-builders.js';
+import { getWorkflowAgentId } from './workspace-store-support.js';
+/* Roster snapshot embedded in the 409 the orchestrator sees when it
+   dispatches to a missing name. Format prioritizes the orchestrator's
+   parsing path: bullet-per-member with role + live status + pending
+   count, plus an explicit retry hint that names both fix-up paths
+   (direct send to a listed name, or re-`team list` if it doubts the
+   snapshot). Keeping role/status/pending inline saves a follow-up
+   `team list` round-trip — the orchestrator can re-pick in the same
+   turn. */
+export const formatUnknownWorkerError = (workerName, roster) => {
+    if (roster.length === 0) {
+        return [
+            `Unknown worker "${workerName}": this workspace currently has no workers.`,
+            'Ask the user to add a worker in the Hive UI (Add Worker), then run `team list` and retry.',
+        ].join('\n');
+    }
+    const lines = roster.map((entry) => `  - ${entry.name} (${entry.role}, ${entry.status}, ${entry.pendingTaskCount} pending)`);
+    return [
+        `Unknown worker "${workerName}" in this workspace. Current members:`,
+        ...lines,
+        'Retry with `team send "<one of the names above>" "<task>"`, or run `team list` to refresh the roster.',
+    ].join('\n');
+};
+const reportForwardErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, findOpenDispatchById, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, markDispatchSubmitted, reportOutbox, notifyWebhook, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, }) => {
+    // Best-effort redelivery of reports a prior orchestrator outage stranded.
+    // Called when a fresh report confirms the orchestrator is reachable and
+    // when the orchestrator polls `team list` (its natural post-restart wakeup).
+    // An entry is marked delivered only after its PTY write actually resolves,
+    // so a still-down orchestrator just leaves the backlog pending.
+    const drainReportOutbox = (workspaceId) => {
+        const orchestratorId = `${workspaceId}:orchestrator`;
+        if (!agentRuntime.getActiveRunByAgentId(workspaceId, orchestratorId))
+            return;
+        for (const entry of reportOutbox.listPending(workspaceId, orchestratorId)) {
+            void agentRuntime
+                .deliverSystemMessageToAgent(workspaceId, orchestratorId, entry.payload, {
+                requireActiveRun: true,
+            })
+                .then(() => reportOutbox.markDelivered(entry.id))
+                .catch((error) => {
+                console.error('[hive] swallowed:teamReport.outboxDrain', error);
+            });
+        }
+    };
+    const ensureWorkerRun = async (workspaceId, workerId, hivePort) => {
+        if (agentRuntime.getActiveRunByAgentId(workspaceId, workerId)) {
+            return;
+        }
+        const config = agentRuntime.peekAgentLaunchConfig(workspaceId, workerId);
+        if (!config) {
+            throw new ConflictError('No worker launch config available');
+        }
+        workspaceStore.markAgentStarted(workspaceId, workerId);
+        try {
+            const run = await agentRuntime.startAgent(workspaceStore.getWorkspaceSnapshot(workspaceId).summary, workerId, { hivePort });
+            if (run.status === 'error') {
+                workspaceStore.markAgentStopped(workspaceId, workerId);
+                throw new ConflictError(`${config.command} failed to start`);
+            }
+        }
+        catch (error) {
+            workspaceStore.markAgentStopped(workspaceId, workerId);
+            throw error;
+        }
+    };
+    const cancelUndeliveredDispatch = (workspaceId, workerId, dispatchId, reason, workflowRunId) => {
+        const cancelled = markDispatchCancelled({ dispatchId, reason, workspaceId });
+        if (!cancelled)
+            return;
+        try {
+            workspaceStore.markTaskCancelled(workspaceId, workerId);
+        }
+        catch (error) {
+            console.error('[hive] swallowed:teamDispatch.markTaskCancelled', error);
+        }
+        if (workflowRunId !== undefined) {
+            workflowDispatchAwaiter.notifyCancel(dispatchId, reason);
+        }
+    };
+    const dispatchTask = async (workspaceId, workerId, text, input = {}) => {
+        const message = createSendMessage(workspaceId, workerId, text, input.fromAgentId);
+        const messageHandle = insertMessage(message);
+        let dispatch;
+        let pendingMarked = false;
+        try {
+            const dispatchInput = {
+                text,
+                toAgentId: workerId,
+                workspaceId,
+            };
+            if (input.fromAgentId)
+                dispatchInput.fromAgentId = input.fromAgentId;
+            if (input.workflowRunId !== undefined)
+                dispatchInput.workflowRunId = input.workflowRunId;
+            if (input.stepIndex !== undefined)
+                dispatchInput.stepIndex = input.stepIndex;
+            if (input.phase !== undefined)
+                dispatchInput.phase = input.phase;
+            if (input.label !== undefined)
+                dispatchInput.label = input.label;
+            dispatch = createDispatch(dispatchInput);
+            const dispatchId = dispatch.id;
+            if (input.fromAgentId) {
+                const sender = workspaceStore.getAgent(workspaceId, input.fromAgentId);
+                const shouldAutoStartWorker = input.autoStartWorker !== false;
+                const hadActiveRun = Boolean(agentRuntime.getActiveRunByAgentId(workspaceId, workerId));
+                if (!hadActiveRun && shouldAutoStartWorker) {
+                    await ensureWorkerRun(workspaceId, workerId, input.hivePort ?? '');
+                }
+                const worker = workspaceStore.getWorker(workspaceId, workerId);
+                if (!shouldAutoStartWorker && !agentRuntime.getActiveRunByAgentId(workspaceId, workerId)) {
+                    workspaceStore.markTaskDispatched(workspaceId, workerId);
+                    pendingMarked = true;
+                    return dispatch;
+                }
+                const isWorkflowDispatch = input.workflowRunId !== undefined || input.fromAgentId === getWorkflowAgentId(workspaceId);
+                markDispatchSubmitted(dispatchId);
+                workspaceStore.markTaskDispatched(workspaceId, workerId);
+                pendingMarked = true;
+                try {
+                    const writePrompt = agentRuntime.writeSendPrompt(workspaceId, workerId, dispatchId, sender.name, worker.description, text);
+                    void writePrompt.catch((error) => {
+                        // `team send` is intentionally asynchronous (§3.3). A worker that
+                        // exits during paste-submit did not receive actionable work, so
+                        // close the open dispatch instead of leaving a fake pending task.
+                        try {
+                            cancelUndeliveredDispatch(workspaceId, workerId, dispatchId, reportForwardErrorMessage(error), input.workflowRunId);
+                        }
+                        catch (cancelError) {
+                            if (!isWorkflowDispatch)
+                                console.error('[hive] swallowed:teamDispatch.cancelUndelivered', cancelError);
+                        }
+                        if (!isWorkflowDispatch)
+                            console.error('[hive] swallowed:teamDispatch.writePrompt', error);
+                    });
+                }
+                catch (error) {
+                    try {
+                        cancelUndeliveredDispatch(workspaceId, workerId, dispatchId, reportForwardErrorMessage(error), input.workflowRunId);
+                    }
+                    catch (cancelError) {
+                        if (!isWorkflowDispatch)
+                            console.error('[hive] swallowed:teamDispatch.cancelUndelivered', cancelError);
+                    }
+                    if (!isWorkflowDispatch)
+                        console.error('[hive] swallowed:teamDispatch.writePrompt', error);
+                }
+            }
+            else {
+                workspaceStore.markTaskDispatched(workspaceId, workerId);
+                pendingMarked = true;
+            }
+            return dispatch;
+        }
+        catch (error) {
+            if (pendingMarked) {
+                try {
+                    workspaceStore.markTaskCancelled(workspaceId, workerId);
+                }
+                catch {
+                    // Best-effort compensation for the in-memory pending count; the
+                    // durable send message is deleted below.
+                }
+            }
+            if (dispatch)
+                deleteDispatch(dispatch.id);
+            deleteMessage(messageHandle);
+            throw error;
+        }
+    };
+    return {
+        cancelTask(workspaceId, dispatchId, input) {
+            workspaceStore.getAgent(workspaceId, input.fromAgentId);
+            const openDispatch = findOpenDispatchById(workspaceId, dispatchId);
+            if (!openDispatch) {
+                throw new ConflictError(`No open dispatch: ${dispatchId}`);
+            }
+            const dispatch = markDispatchCancelled({
+                dispatchId,
+                reason: input.reason,
+                workspaceId,
+            });
+            if (!dispatch) {
+                throw new ConflictError(`No open dispatch: ${dispatchId}`);
+            }
+            workspaceStore.markTaskCancelled(workspaceId, dispatch.toAgentId);
+            let forwardError = null;
+            let forwarded = false;
+            try {
+                agentRuntime.writeCancelPrompt(workspaceId, dispatch.toAgentId, dispatch.id, input.reason);
+                forwarded = true;
+            }
+            catch (error) {
+                forwardError = reportForwardErrorMessage(error);
+                console.error('[hive] swallowed:teamCancel.forward', error);
+            }
+            return { dispatch, forwardError, forwarded };
+        },
+        dispatchTask,
+        drainReportOutbox,
+        async dispatchTaskByWorkerName(workspaceId, workerName, text, input = {}) {
+            /* Build the roster once so a missing-name path can surface it without
+               a second store call. We deliberately don't go through
+               `getWorkerByName` because its underlying record helper throws a
+               bare Error — that bubbles as HTTP 500 and looks like a server bug
+               to the orchestrator, instead of the self-healing 409 we want. */
+            const roster = workspaceStore.listWorkers(workspaceId);
+            const worker = roster.find((entry) => entry.name === workerName);
+            if (!worker) {
+                throw new ConflictError(formatUnknownWorkerError(workerName, roster));
+            }
+            /* Capture the active-run state *before* dispatchTask runs. Internal
+               workflow calls may auto-start a stopped worker; explicit CLI
+               `team send` passes autoStartWorker:false so the worker remains
+               stopped with a queued dispatch until the user restarts it. */
+            const restartedWorker = input.fromAgentId !== undefined &&
+                input.autoStartWorker !== false &&
+                !agentRuntime.getActiveRunByAgentId(workspaceId, worker.id);
+            const dispatch = await dispatchTask(workspaceId, worker.id, text, input);
+            return Object.assign(dispatch, { restartedWorker });
+        },
+        recordUserInput(workspaceId, orchestratorId, text) {
+            workspaceStore.getAgent(workspaceId, orchestratorId);
+            agentRuntime.writeUserInputPrompt(workspaceId, text);
+            insertMessage(createUserInputMessage(workspaceId, orchestratorId, text));
+        },
+        statusTask(workspaceId, workerId, input = {}) {
+            const text = input.text ?? '';
+            const artifacts = input.artifacts ?? [];
+            const worker = workspaceStore.getWorker(workspaceId, workerId);
+            const messageHandle = insertMessage(createStatusMessage(workspaceId, workerId, text, artifacts));
+            try {
+                let forwardError = null;
+                let forwarded = false;
+                if (input.requireActiveRun === true) {
+                    try {
+                        agentRuntime.writeStatusPrompt(workspaceId, worker.name, workerId, text, artifacts, {
+                            requireActiveRun: input.requireActiveRun,
+                        });
+                        forwarded = true;
+                    }
+                    catch (error) {
+                        forwardError = reportForwardErrorMessage(error);
+                        console.error('[hive] swallowed:teamStatus.forward', error);
+                    }
+                }
+                return { dispatch: null, forwardError, forwarded };
+            }
+            catch (error) {
+                deleteMessage(messageHandle);
+                throw error;
+            }
+        },
+        reportTask(workspaceId, workerId, input = {}) {
+            const text = input.text ?? '';
+            const status = input.status;
+            const artifacts = input.artifacts ?? [];
+            const worker = workspaceStore.getWorker(workspaceId, workerId);
+            const openDispatch = findOpenDispatch(workspaceId, workerId, input.dispatchId);
+            if (!openDispatch) {
+                throw new ConflictError(`No open dispatch for worker: ${worker.name}`);
+            }
+            const messageHandle = insertMessage(createReportMessage(workspaceId, workerId, text, status, artifacts));
+            try {
+                const dispatch = markDispatchReportedByWorker({
+                    artifacts,
+                    ...(input.dispatchId ? { dispatchId: input.dispatchId } : {}),
+                    reportText: text,
+                    toAgentId: workerId,
+                    workspaceId,
+                });
+                if (!dispatch) {
+                    throw new ConflictError(`No open dispatch for worker: ${worker.name}`);
+                }
+                workspaceStore.markTaskReported(workspaceId, workerId);
+                let forwardError = null;
+                let forwarded = false;
+                // Workflow-sourced dispatches: the source is the in-process runner, not a
+                // PTY. Resolve its awaiting Promise instead of injecting into orchestrator
+                // stdin (which would do nothing — `__workflow__` has no PTY).
+                if (dispatch.fromAgentId === getWorkflowAgentId(workspaceId)) {
+                    try {
+                        workflowDispatchAwaiter.notifyReport(dispatch.id, {
+                            artifacts,
+                            text,
+                            ...(status ? { status } : {}),
+                        });
+                        forwarded = true;
+                    }
+                    catch (error) {
+                        forwardError = reportForwardErrorMessage(error);
+                        console.error('[hive] swallowed:teamReport.workflowForward', error);
+                    }
+                    return { dispatch, forwardError, forwarded };
+                }
+                // Real worker reported (not a workflow-internal step) — fire the
+                // outbound completion webhook. Best-effort; never blocks the report.
+                notifyWebhook?.({
+                    type: 'report_received',
+                    workspaceId,
+                    agentId: workerId,
+                    agentName: worker.name,
+                    summary: text.slice(0, 280),
+                    at: Date.now(),
+                });
+                if (input.requireActiveRun === true) {
+                    const orchestratorId = `${workspaceId}:orchestrator`;
+                    // A fresh report proves the orchestrator is reachable — flush any
+                    // backlog a prior outage stranded first, in arrival order, before
+                    // this one (both ride the dispatcher's per-agent serial queue).
+                    drainReportOutbox(workspaceId);
+                    const payload = buildOrchestratorReportPayload(worker.name, text, artifacts);
+                    if (agentRuntime.getActiveRunByAgentId(workspaceId, orchestratorId)) {
+                        try {
+                            const delivery = agentRuntime.deliverReportToOrchestrator(workspaceId, worker.name, text, artifacts, { requireActiveRun: true });
+                            forwarded = true;
+                            // The dispatch is already marked reported. If the PTY dies
+                            // mid-write the ledger would say "reported" while the
+                            // orchestrator never received it — persist for redelivery so it
+                            // isn't silently lost.
+                            void delivery.catch((error) => {
+                                console.error('[hive] swallowed:teamReport.forward', error);
+                                reportOutbox.enqueue({
+                                    workspaceId,
+                                    targetAgentId: orchestratorId,
+                                    dispatchId: dispatch.id,
+                                    payload,
+                                });
+                            });
+                        }
+                        catch (error) {
+                            // TOCTOU: orchestrator vanished between the active-run check and
+                            // the write. Same fix — queue it.
+                            console.error('[hive] swallowed:teamReport.forward', error);
+                            forwardError = reportForwardErrorMessage(error);
+                            reportOutbox.enqueue({
+                                workspaceId,
+                                targetAgentId: orchestratorId,
+                                dispatchId: dispatch.id,
+                                payload,
+                            });
+                        }
+                    }
+                    else {
+                        // Orchestrator is down. Queue the report instead of dropping it;
+                        // the CLI surfaces forwarded:false and the backlog drains on the
+                        // orchestrator's next `team list` after it restarts.
+                        forwardError = 'Orchestrator is not running; report queued for delivery.';
+                        reportOutbox.enqueue({
+                            workspaceId,
+                            targetAgentId: orchestratorId,
+                            dispatchId: dispatch.id,
+                            payload,
+                        });
+                    }
+                }
+                // M11: if this worker was spawned with `team spawn --ephemeral`, this
+                // first successful report is its trigger to auto-dismiss. Deferred via
+                // queueMicrotask so the orchestrator's forward write lands BEFORE the
+                // worker's PTY is torn down (otherwise the inject + dismiss race).
+                // Skipped for workflow dispatches — workflow workers are managed by
+                // the runner's own finally block.
+                if (worker.ephemeral === true &&
+                    worker.spawnedBy === 'orchestrator' &&
+                    dismissEphemeralWorker) {
+                    queueMicrotask(() => {
+                        try {
+                            dismissEphemeralWorker(workspaceId, workerId);
+                        }
+                        catch (error) {
+                            console.error('[hive] swallowed:teamReport.ephemeralDismiss', error);
+                        }
+                    });
+                }
+                return { dispatch, forwardError, forwarded };
+            }
+            catch (error) {
+                deleteMessage(messageHandle);
+                throw error;
+            }
+        },
+    };
+};

package/dist/src/server/team-recall-store.d.ts

@@ -0,0 +1,38 @@
+import type { Database } from 'better-sqlite3';
+export interface RecallContextMessage {
+    createdAt: number;
+    fromAgentId: string | null;
+    sourceSequence: number;
+    text: string;
+    toAgentId: string | null;
+    type: string;
+    workerId: string;
+}
+export interface RecallResult {
+    context: RecallContextMessage[];
+    createdAt: number;
+    dispatchId: string | null;
+    dispatchStatus: string | null;
+    fromAgentId: string | null;
+    indexName: 'like' | 'trigram' | 'unicode';
+    memoryConfidence?: number | null;
+    memoryId?: string | null;
+    memoryKind?: string | null;
+    memoryStatus?: string | null;
+    memoryTags?: string[];
+    messageType: string | null;
+    reportText: string | null;
+    score: number;
+    sourceSequence: number;
+    sourceType: 'dispatch' | 'memory' | 'message';
+    text: string;
+    toAgentId: string | null;
+    workerId: string | null;
+}
+export interface RecallOptions {
+    limit?: number;
+    window?: number;
+}
+export declare const createTeamRecallStore: (db: Database) => {
+    recallMessages: (workspaceId: string, query: string, options?: RecallOptions) => RecallResult[];
+};

package/dist/src/server/team-recall-store.js

@@ -0,0 +1,205 @@
+import { RECALL_QUERY_MAX_CHARS } from '../shared/team-recall.js';
+const DEFAULT_LIMIT = 10;
+const DEFAULT_WINDOW = 2;
+const MAX_LIMIT = 50;
+const MAX_WINDOW = 10;
+const clampInt = (value, fallback, max) => {
+    if (value === undefined || !Number.isInteger(value) || value < 0)
+        return fallback;
+    return Math.min(value, max);
+};
+const quoteFtsToken = (value) => `"${value.replaceAll('"', '""')}"`;
+const toSearchTerms = (query) => query.trim().split(/\s+/).filter(Boolean);
+const toFtsQuery = (query) => toSearchTerms(query).map(quoteFtsToken).join(' AND ');
+const hasShortTerm = (terms) => terms.some((term) => [...term].length < 3);
+const escapeLike = (value) => `%${value.replaceAll('\\', '\\\\').replaceAll('%', '\\%').replaceAll('_', '\\_')}%`;
+const mapContext = (row) => ({
+    createdAt: row.created_at,
+    fromAgentId: row.from_agent_id,
+    sourceSequence: row.sequence,
+    text: row.text ?? '',
+    toAgentId: row.to_agent_id,
+    type: row.type,
+    workerId: row.worker_id,
+});
+const mapRow = (row) => ({
+    context: [],
+    createdAt: row.created_at,
+    dispatchId: row.dispatch_id,
+    dispatchStatus: row.dispatch_status,
+    fromAgentId: row.from_agent_id,
+    indexName: row.index_name,
+    messageType: row.message_type,
+    reportText: row.report_text,
+    score: row.score,
+    sourceSequence: row.source_sequence,
+    sourceType: row.source_type,
+    text: row.text ?? '',
+    toAgentId: row.to_agent_id,
+    workerId: row.worker_id,
+});
+export const createTeamRecallStore = (db) => {
+    const searchMessages = (table, workspaceId, ftsQuery) => {
+        const indexName = table === 'messages_fts' ? 'unicode' : 'trigram';
+        return db
+            .prepare(`SELECT
+           'message' AS source_type,
+           ? AS index_name,
+           m.sequence AS source_sequence,
+           NULL AS dispatch_id,
+           NULL AS dispatch_status,
+           m.type AS message_type,
+           m.worker_id,
+           m.from_agent_id,
+           m.to_agent_id,
+           m.text,
+           NULL AS report_text,
+           m.created_at,
+           bm25(${table}) AS score
+         FROM ${table}
+         JOIN messages m ON m.sequence = ${table}.rowid
+         WHERE ${table} MATCH ?
+           AND m.workspace_id = ?`)
+            .all(indexName, ftsQuery, workspaceId);
+    };
+    const searchDispatches = (table, workspaceId, ftsQuery) => {
+        const indexName = table === 'dispatches_fts' ? 'unicode' : 'trigram';
+        return db
+            .prepare(`SELECT
+           'dispatch' AS source_type,
+           ? AS index_name,
+           d.sequence AS source_sequence,
+           d.id AS dispatch_id,
+           d.status AS dispatch_status,
+           NULL AS message_type,
+           NULL AS worker_id,
+           d.from_agent_id,
+           d.to_agent_id,
+           d.text,
+           d.report_text,
+           COALESCE(d.reported_at, d.submitted_at, d.created_at) AS created_at,
+           bm25(${table}) AS score
+         FROM ${table}
+         JOIN dispatches d ON d.sequence = ${table}.rowid
+         WHERE ${table} MATCH ?
+           AND d.workspace_id = ?`)
+            .all(indexName, ftsQuery, workspaceId);
+    };
+    const searchMessagesLike = (workspaceId, terms) => {
+        if (terms.length === 0)
+            return [];
+        const predicates = terms.map(() => "m.text LIKE ? ESCAPE '\\'").join(' AND ');
+        return db
+            .prepare(`SELECT
+           'message' AS source_type,
+           'like' AS index_name,
+           m.sequence AS source_sequence,
+           NULL AS dispatch_id,
+           NULL AS dispatch_status,
+           m.type AS message_type,
+           m.worker_id,
+           m.from_agent_id,
+           m.to_agent_id,
+           m.text,
+           NULL AS report_text,
+           m.created_at,
+           0 AS score
+         FROM messages m
+         WHERE m.workspace_id = ?
+           AND ${predicates}`)
+            .all(workspaceId, ...terms.map(escapeLike));
+    };
+    const searchDispatchesLike = (workspaceId, terms) => {
+        if (terms.length === 0)
+            return [];
+        const predicates = terms
+            .map(() => "(d.text LIKE ? ESCAPE '\\' OR d.report_text LIKE ? ESCAPE '\\')")
+            .join(' AND ');
+        return db
+            .prepare(`SELECT
+           'dispatch' AS source_type,
+           'like' AS index_name,
+           d.sequence AS source_sequence,
+           d.id AS dispatch_id,
+           d.status AS dispatch_status,
+           NULL AS message_type,
+           NULL AS worker_id,
+           d.from_agent_id,
+           d.to_agent_id,
+           d.text,
+           d.report_text,
+           COALESCE(d.reported_at, d.submitted_at, d.created_at) AS created_at,
+           0 AS score
+         FROM dispatches d
+         WHERE d.workspace_id = ?
+           AND ${predicates}`)
+            .all(workspaceId, ...terms.flatMap((term) => [escapeLike(term), escapeLike(term)]));
+    };
+    const listContext = (workspaceId, sequence, window) => {
+        if (window <= 0)
+            return [];
+        const previousRows = db
+            .prepare(`SELECT sequence, worker_id, type, from_agent_id, to_agent_id, text, created_at
+         FROM messages
+         WHERE workspace_id = ?
+           AND sequence < ?
+         ORDER BY sequence DESC
+         LIMIT ?`)
+            .all(workspaceId, sequence, window);
+        const anchorRow = db
+            .prepare(`SELECT sequence, worker_id, type, from_agent_id, to_agent_id, text, created_at
+         FROM messages
+         WHERE workspace_id = ?
+           AND sequence = ?
+         LIMIT 1`)
+            .get(workspaceId, sequence);
+        const nextRows = db
+            .prepare(`SELECT sequence, worker_id, type, from_agent_id, to_agent_id, text, created_at
+         FROM messages
+         WHERE workspace_id = ?
+           AND sequence > ?
+         ORDER BY sequence ASC
+         LIMIT ?`)
+            .all(workspaceId, sequence, window);
+        const rows = [...previousRows.slice().reverse(), ...(anchorRow ? [anchorRow] : []), ...nextRows];
+        return rows.map(mapContext);
+    };
+    const recallMessages = (workspaceId, query, options = {}) => {
+        if ([...query].length > RECALL_QUERY_MAX_CHARS)
+            return [];
+        const ftsQuery = toFtsQuery(query);
+        if (!ftsQuery)
+            return [];
+        const terms = toSearchTerms(query);
+        const likeRows = hasShortTerm(terms)
+            ? [...searchMessagesLike(workspaceId, terms), ...searchDispatchesLike(workspaceId, terms)]
+            : [];
+        const limit = clampInt(options.limit, DEFAULT_LIMIT, MAX_LIMIT);
+        const window = clampInt(options.window, DEFAULT_WINDOW, MAX_WINDOW);
+        const byKey = new Map();
+        const rows = [
+            ...searchMessages('messages_fts', workspaceId, ftsQuery),
+            ...searchMessages('messages_fts_trigram', workspaceId, ftsQuery),
+            ...searchDispatches('dispatches_fts', workspaceId, ftsQuery),
+            ...searchDispatches('dispatches_fts_trigram', workspaceId, ftsQuery),
+            ...likeRows,
+        ];
+        for (const row of rows) {
+            const result = mapRow(row);
+            const key = `${result.sourceType}:${result.sourceSequence}`;
+            const previous = byKey.get(key);
+            if (!previous || result.score < previous.score) {
+                byKey.set(key, result);
+            }
+        }
+        return [...byKey.values()]
+            .sort((a, b) => a.score - b.score || b.createdAt - a.createdAt)
+            .slice(0, limit)
+            .map((result) => result.sourceType === 'message'
+            ? { ...result, context: listContext(workspaceId, result.sourceSequence, window) }
+            : result);
+    };
+    return {
+        recallMessages,
+    };
+};

package/dist/src/server/terminal-flow-control.d.ts

@@ -0,0 +1,19 @@
+import type WebSocket from 'ws';
+export declare const FLOW_CONTROL: {
+    readonly BATCH_INTERVAL_MS: 4;
+    readonly LOW_LATENCY_THRESHOLD_BYTES: 256;
+    readonly WS_BUFFERED_HIGH_WATER: number;
+    readonly WS_BUFFERED_LOW_WATER: number;
+    readonly UNACKED_HIGH_WATER: number;
+    readonly UNACKED_LOW_WATER: number;
+};
+interface TerminalOutputFlowOptions {
+    onBackpressureChange: (backpressured: boolean) => void;
+}
+export interface TerminalOutputFlow {
+    ack: (bytes: number) => void;
+    close: () => void;
+    enqueue: (chunk: string) => void;
+}
+export declare const createTerminalOutputFlow: (ws: WebSocket, { onBackpressureChange }: TerminalOutputFlowOptions) => TerminalOutputFlow;
+export {};