hivehq 2.0.0

package/dist/src/server/tasks-file-watcher.js

@@ -0,0 +1,200 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { basename, dirname, normalize } from 'node:path';
+import chokidar from 'chokidar';
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
+import { ensureProtocolFile, ensureTasksFile, getTasksFilePath, TASKS_FILE_NAME, } from './tasks-file.js';
+const DEBOUNCE_MS = 100;
+const WATCHER_RETRY_MS = 5000;
+const WATCHER_CLOSE_TIMEOUT_MS = 2000;
+const DEFAULT_WATCHER_READY_TIMEOUT_MS = 15000;
+const WINDOWS_WATCHER_READY_TIMEOUT_MS = 60000;
+/**
+ * Watcher configuration. The atomic-save option matters on Windows: VS
+ * Code, Cursor, Notepad++, and the editor inside Hive itself all save
+ * by writing a temp file and renaming it over the target. On
+ * ReadDirectoryChangesW (Windows' native fs-event backend) that rename
+ * invalidates the file-handle the chokidar watcher held for the
+ * single-file path, and subsequent edits would emit no events at all.
+ *
+ * `atomic: 100` tells chokidar to correlate an unlink+add pair within
+ * a 100ms window as a single `change` event — collapsing the rename
+ * into one logical "the file was modified" notification and rebinding
+ * the underlying watch handle. Without it the tasks panel goes deaf
+ * to changes the user makes outside the app after the first save.
+ *
+ * We intentionally do NOT set `awaitWriteFinish` here. It would help
+ * even more on Windows (waits for the file size to stabilise before
+ * emitting), but it also throttles every emission by `stabilityThreshold`
+ * — clashing with continuous-write workflows (a worker streaming
+ * updates into tasks.md every 100ms would never see an emit). The
+ * `atomic` option alone covers atomic-save; if a future workspace
+ * needs stronger settling behaviour we can promote it then.
+ *
+ * Exported so the configuration is testable in isolation.
+ */
+export const TASKS_WATCHER_OPTIONS = {
+    atomic: 100,
+    ignoreInitial: true,
+};
+const isWindowsUncPath = (path, platform = process.platform) => platform === 'win32' && /^[\\/]{2}[^\\/]+[\\/]+[^\\/]+/u.test(path);
+export const buildTasksWatcherOptions = (workspacePath, platform = process.platform) => ({
+    ...TASKS_WATCHER_OPTIONS,
+    ...(platform === 'win32' || isWindowsUncPath(workspacePath, platform)
+        ? { interval: 500, usePolling: true }
+        : {}),
+});
+export const getTasksWatcherReadyTimeoutMs = (workspacePath, platform = process.platform) => platform === 'win32' || isWindowsUncPath(workspacePath, platform)
+    ? WINDOWS_WATCHER_READY_TIMEOUT_MS
+    : DEFAULT_WATCHER_READY_TIMEOUT_MS;
+const closeWatcherWithTimeout = async (watcher) => {
+    if (!watcher)
+        return;
+    let timer;
+    try {
+        await Promise.race([
+            watcher.close(),
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, WATCHER_CLOSE_TIMEOUT_MS);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+};
+export const isTasksFileEvent = (tasksPath, changedPath, platform = process.platform) => {
+    if (!changedPath)
+        return true;
+    const text = Buffer.isBuffer(changedPath) ? changedPath.toString() : changedPath;
+    if (platform === 'win32') {
+        return (normalize(text).toLowerCase() === normalize(tasksPath).toLowerCase() ||
+            basename(text).toLowerCase() === TASKS_FILE_NAME);
+    }
+    return normalize(text) === normalize(tasksPath) || basename(text) === TASKS_FILE_NAME;
+};
+export const createTasksFileWatcher = ({ onTasksUpdated, getWorkflowCliPolicy, getFlags, }) => {
+    const watchers = new Map();
+    const timers = new Map();
+    const retryTimers = new Map();
+    let closed = false;
+    const logWatcherError = (workspaceId, error) => {
+        console.error(`[hive] tasks watcher error for workspace ${workspaceId}`, error);
+    };
+    const clearTimer = (workspaceId) => {
+        const timer = timers.get(workspaceId);
+        if (!timer)
+            return;
+        clearTimeout(timer);
+        timers.delete(workspaceId);
+    };
+    const clearRetryTimer = (workspaceId) => {
+        const timer = retryTimers.get(workspaceId);
+        if (!timer)
+            return;
+        clearTimeout(timer);
+        retryTimers.delete(workspaceId);
+    };
+    const emitCurrentContent = async (workspaceId, workspacePath) => {
+        const tasksPath = getTasksFilePath(workspacePath);
+        try {
+            const content = existsSync(tasksPath) ? await readFile(tasksPath, 'utf8') : '';
+            onTasksUpdated(workspaceId, content);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logWatcherError(workspaceId, error);
+                return;
+            }
+            onTasksUpdated(workspaceId, '');
+        }
+    };
+    const stop = async (workspaceId) => {
+        clearTimer(workspaceId);
+        clearRetryTimer(workspaceId);
+        const watcher = watchers.get(workspaceId);
+        watchers.delete(workspaceId);
+        await closeWatcherWithTimeout(watcher);
+    };
+    const scheduleRetry = (workspaceId, workspacePath) => {
+        if (closed || retryTimers.has(workspaceId))
+            return;
+        const timer = setTimeout(() => {
+            retryTimers.delete(workspaceId);
+            void start(workspaceId, workspacePath).catch((error) => logWatcherError(workspaceId, error));
+        }, WATCHER_RETRY_MS);
+        timer.unref?.();
+        retryTimers.set(workspaceId, timer);
+    };
+    const waitForReady = async (watcher, timeoutMs) => await new Promise((resolve, reject) => {
+        const cleanup = () => {
+            watcher.off('ready', handleReady);
+            watcher.off('error', handleError);
+            clearTimeout(timeout);
+        };
+        const handleReady = () => {
+            cleanup();
+            resolve();
+        };
+        const handleError = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const timeout = setTimeout(() => {
+            cleanup();
+            reject(new Error(`Timed out waiting for tasks watcher ready after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timeout.unref?.();
+        watcher.once('ready', handleReady);
+        watcher.once('error', handleError);
+    });
+    const start = async (workspaceId, workspacePath) => {
+        closed = false;
+        await stop(workspaceId);
+        ensureTasksFile(workspacePath);
+        ensureProtocolFile(workspacePath, getWorkflowCliPolicy?.(), getFlags?.() ?? FEATURE_FLAGS_ALL_OFF);
+        const tasksPath = getTasksFilePath(workspacePath);
+        const watcher = chokidar.watch(dirname(tasksPath), buildTasksWatcherOptions(workspacePath));
+        const readyTimeoutMs = getTasksWatcherReadyTimeoutMs(workspacePath);
+        const scheduleEmit = (changedPath) => {
+            if (!isTasksFileEvent(tasksPath, changedPath))
+                return;
+            clearTimer(workspaceId);
+            timers.set(workspaceId, setTimeout(() => {
+                timers.delete(workspaceId);
+                void emitCurrentContent(workspaceId, workspacePath);
+            }, DEBOUNCE_MS));
+        };
+        watcher.on('add', scheduleEmit);
+        watcher.on('change', scheduleEmit);
+        watcher.on('unlink', scheduleEmit);
+        watcher.on('error', (error) => {
+            logWatcherError(workspaceId, error);
+            void stop(workspaceId)
+                .catch((closeError) => logWatcherError(workspaceId, closeError))
+                .finally(() => scheduleRetry(workspaceId, workspacePath));
+        });
+        watchers.set(workspaceId, watcher);
+        try {
+            await waitForReady(watcher, readyTimeoutMs);
+        }
+        catch (error) {
+            watchers.delete(workspaceId);
+            await closeWatcherWithTimeout(watcher);
+            scheduleRetry(workspaceId, workspacePath);
+            throw error;
+        }
+    };
+    return {
+        close: async () => {
+            closed = true;
+            for (const workspaceId of retryTimers.keys())
+                clearRetryTimer(workspaceId);
+            await Promise.all(Array.from(watchers.keys(), (workspaceId) => stop(workspaceId)));
+        },
+        start,
+        stop,
+    };
+};

package/dist/src/server/tasks-file.d.ts

@@ -0,0 +1,23 @@
+import { type FeatureFlags } from './feature-flags.js';
+import type { WorkflowCliPolicy } from './workflow-cli-policy.js';
+interface TasksFileService {
+    readTasks: (workspacePath: string) => string;
+    writeTasks: (workspacePath: string, content: string) => void;
+}
+export declare const HIVE_DIR_NAME = ".hive";
+export declare const TASKS_FILE_NAME = "tasks.md";
+export declare const TASKS_RELATIVE_PATH = ".hive/tasks.md";
+export declare const PROTOCOL_FILE_NAME = "PROTOCOL.md";
+export declare const PROTOCOL_RELATIVE_PATH = ".hive/PROTOCOL.md";
+export declare const getTasksFilePath: (workspacePath: string) => string;
+export declare const getProtocolFilePath: (workspacePath: string) => string;
+export declare const ensureTasksFile: (workspacePath: string) => string;
+/**
+ * Always overwrites `.hive/PROTOCOL.md` with the freshly-built protocol doc.
+ * The doc is marked auto-generated so user edits are not expected; rewriting
+ * on every workspace open means a Hive version bump that changes the rules
+ * propagates without manual intervention.
+ */
+export declare const ensureProtocolFile: (workspacePath: string, cliPolicy?: WorkflowCliPolicy, flags?: FeatureFlags) => string;
+export declare const createTasksFileService: () => TasksFileService;
+export type { TasksFileService };

package/dist/src/server/tasks-file.js

@@ -0,0 +1,101 @@
+import { randomUUID } from 'node:crypto';
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
+import { buildProtocolDoc } from './hive-team-guidance.js';
+export const HIVE_DIR_NAME = '.hive';
+export const TASKS_FILE_NAME = 'tasks.md';
+export const TASKS_RELATIVE_PATH = `${HIVE_DIR_NAME}/${TASKS_FILE_NAME}`;
+export const PROTOCOL_FILE_NAME = 'PROTOCOL.md';
+export const PROTOCOL_RELATIVE_PATH = `${HIVE_DIR_NAME}/${PROTOCOL_FILE_NAME}`;
+export const getTasksFilePath = (workspacePath) => join(workspacePath, HIVE_DIR_NAME, TASKS_FILE_NAME);
+export const getProtocolFilePath = (workspacePath) => join(workspacePath, HIVE_DIR_NAME, PROTOCOL_FILE_NAME);
+const getLegacyTasksFilePath = (workspacePath) => join(workspacePath, TASKS_FILE_NAME);
+const RETRYABLE_TASKS_FS_ERROR_CODES = new Set(['EACCES', 'EBUSY', 'EPERM']);
+const TASKS_FS_RETRY_DELAYS_MS = [20, 50, 100];
+const sleepSync = (ms) => {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+const runRetryableTasksFileOperation = (operation) => {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return operation();
+        }
+        catch (error) {
+            const code = error?.code;
+            const delay = TASKS_FS_RETRY_DELAYS_MS[attempt];
+            if (!code || !RETRYABLE_TASKS_FS_ERROR_CODES.has(code) || delay === undefined)
+                throw error;
+            sleepSync(delay);
+        }
+    }
+};
+const ensureTasksDir = (workspacePath) => {
+    runRetryableTasksFileOperation(() => mkdirSync(dirname(getTasksFilePath(workspacePath)), { recursive: true }));
+};
+const writeUtf8FileAtomically = (targetPath, content) => {
+    const tempPath = join(dirname(targetPath), `.${basename(targetPath)}.${randomUUID()}.tmp`);
+    let committed = false;
+    let fd = null;
+    try {
+        try {
+            fd = openSync(tempPath, 'w');
+            writeFileSync(fd, content, 'utf8');
+            fsyncSync(fd);
+        }
+        finally {
+            if (fd !== null) {
+                closeSync(fd);
+                fd = null;
+            }
+        }
+        renameSync(tempPath, targetPath);
+        committed = true;
+    }
+    finally {
+        if (!committed && existsSync(tempPath))
+            rmSync(tempPath, { force: true });
+    }
+};
+export const ensureTasksFile = (workspacePath) => {
+    ensureTasksDir(workspacePath);
+    const tasksFilePath = getTasksFilePath(workspacePath);
+    if (existsSync(tasksFilePath)) {
+        return runRetryableTasksFileOperation(() => readFileSync(tasksFilePath, 'utf8'));
+    }
+    const legacyTasksFilePath = getLegacyTasksFilePath(workspacePath);
+    const content = existsSync(legacyTasksFilePath)
+        ? runRetryableTasksFileOperation(() => readFileSync(legacyTasksFilePath, 'utf8'))
+        : '';
+    runRetryableTasksFileOperation(() => writeUtf8FileAtomically(tasksFilePath, content));
+    return content;
+};
+/**
+ * Always overwrites `.hive/PROTOCOL.md` with the freshly-built protocol doc.
+ * The doc is marked auto-generated so user edits are not expected; rewriting
+ * on every workspace open means a Hive version bump that changes the rules
+ * propagates without manual intervention.
+ */
+export const ensureProtocolFile = (workspacePath, cliPolicy, flags = FEATURE_FLAGS_ALL_OFF) => {
+    ensureTasksDir(workspacePath);
+    const protocolFilePath = getProtocolFilePath(workspacePath);
+    const desired = buildProtocolDoc(cliPolicy, flags);
+    const current = existsSync(protocolFilePath)
+        ? runRetryableTasksFileOperation(() => readFileSync(protocolFilePath, 'utf8'))
+        : null;
+    if (current === desired)
+        return desired;
+    runRetryableTasksFileOperation(() => writeUtf8FileAtomically(protocolFilePath, desired));
+    return desired;
+};
+export const createTasksFileService = () => {
+    return {
+        readTasks(workspacePath) {
+            return ensureTasksFile(workspacePath);
+        },
+        writeTasks(workspacePath, content) {
+            ensureTasksDir(workspacePath);
+            runRetryableTasksFileOperation(() => writeUtf8FileAtomically(getTasksFilePath(workspacePath), content));
+        },
+    };
+};

package/dist/src/server/tasks-websocket-server.d.ts

@@ -0,0 +1,8 @@
+import type { Server } from 'node:http';
+import type { RuntimeStore } from './runtime-store.js';
+import type { TasksFileService } from './tasks-file.js';
+export interface TasksWebSocketServer {
+    close: () => void;
+    publish: (workspaceId: string, content: string) => void;
+}
+export declare const createTasksWebSocketServer: (server: Server, store: RuntimeStore, tasksFileService: Pick<TasksFileService, "readTasks">) => TasksWebSocketServer;

package/dist/src/server/tasks-websocket-server.js

@@ -0,0 +1,95 @@
+import { WebSocketServer } from 'ws';
+import { getLocalRequestRejection } from './local-request-guard.js';
+import { readCookie } from './ui-auth-helpers.js';
+import { attachRawSocketErrorHandler, attachWebSocketErrorHandler, attachWebSocketServerErrorHandler, rejectWebSocketUpgrade, sendWebSocketMessage, } from './websocket-upgrade-safety.js';
+const matchTasksPath = (pathname) => {
+    const match = /^\/ws\/tasks\/(?<workspaceId>[^/]+)$/.exec(pathname);
+    const workspaceId = match?.groups?.workspaceId;
+    return workspaceId ? decodeURIComponent(workspaceId) : null;
+};
+export const createTasksWebSocketServer = (server, store, tasksFileService) => {
+    const wss = new WebSocketServer({ noServer: true });
+    attachWebSocketServerErrorHandler(wss, 'tasks');
+    const socketsByWorkspaceId = new Map();
+    const validateUpgradeSession = (request) => {
+        // Tunnel-originated upgrades carry the per-boot secret (invariant 2); a
+        // request with no secret header falls through to the unchanged cookie path.
+        if (store.authorizeRemoteTunnelRequest(request))
+            return true;
+        const cookieHeader = Array.isArray(request.headers.cookie)
+            ? request.headers.cookie.join('; ')
+            : request.headers.cookie;
+        const token = readCookie(cookieHeader, 'hive_ui_token');
+        return store.validateUiToken(token);
+    };
+    server.on('upgrade', (request, socket, head) => {
+        const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+        const workspaceId = matchTasksPath(url.pathname);
+        if (!workspaceId)
+            return;
+        const detachRawSocketErrorHandler = attachRawSocketErrorHandler(socket, 'tasks upgrade');
+        if (getLocalRequestRejection(request)) {
+            rejectWebSocketUpgrade(socket, '403 Forbidden');
+            return;
+        }
+        if (!validateUpgradeSession(request)) {
+            rejectWebSocketUpgrade(socket, '401 Unauthorized');
+            return;
+        }
+        let workspacePath = '';
+        try {
+            workspacePath = store.getWorkspaceSnapshot(workspaceId).summary.path;
+        }
+        catch {
+            rejectWebSocketUpgrade(socket, '404 Not Found');
+            return;
+        }
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            detachRawSocketErrorHandler();
+            attachWebSocketErrorHandler(ws, `tasks ${workspaceId}`);
+            const sockets = socketsByWorkspaceId.get(workspaceId) ?? new Set();
+            sockets.add(ws);
+            socketsByWorkspaceId.set(workspaceId, sockets);
+            ws.on('close', () => {
+                sockets.delete(ws);
+                if (sockets.size === 0) {
+                    socketsByWorkspaceId.delete(workspaceId);
+                }
+            });
+            setImmediate(() => {
+                if (ws.readyState !== ws.OPEN)
+                    return;
+                try {
+                    sendWebSocketMessage(ws, JSON.stringify({
+                        type: 'tasks-snapshot',
+                        content: tasksFileService.readTasks(workspacePath),
+                    }), `tasks ${workspaceId} snapshot`);
+                }
+                catch {
+                    if (ws.readyState === ws.OPEN) {
+                        sendWebSocketMessage(ws, JSON.stringify({ type: 'tasks-error', error: 'Failed to read tasks file' }), `tasks ${workspaceId} snapshot error`);
+                    }
+                }
+            });
+        });
+    });
+    return {
+        close: () => {
+            for (const sockets of socketsByWorkspaceId.values()) {
+                for (const socket of sockets)
+                    socket.terminate();
+            }
+            socketsByWorkspaceId.clear();
+            wss.close();
+        },
+        publish: (workspaceId, content) => {
+            const sockets = socketsByWorkspaceId.get(workspaceId);
+            if (!sockets)
+                return;
+            const payload = JSON.stringify({ type: 'tasks-updated', content });
+            for (const socket of sockets) {
+                sendWebSocketMessage(socket, payload, `tasks ${workspaceId} publish`);
+            }
+        },
+    };
+};

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

@@ -0,0 +1,13 @@
+import type { AgentSummary } from '../shared/types.js';
+export type TeamCommand = 'send' | 'list' | 'next' | 'report' | 'recall' | 'memory_add' | 'memory_forget' | 'memory_search' | 'memory_show' | 'status' | 'cancel' | 'help' | 'spawn' | 'dismiss' | 'workflow';
+export declare const commandAllowedForRole: (role: AgentSummary["role"], command: TeamCommand) => boolean;
+interface AuthenticateInput {
+    fromAgentId: string | undefined;
+    getAgent: (workspaceId: string, agentId: string) => AgentSummary;
+    token: string | undefined;
+    validateToken: (agentId: string, token: string | undefined) => boolean;
+    workspaceId: string;
+}
+export declare const authenticateCliAgent: ({ fromAgentId, getAgent, token, validateToken, workspaceId, }: AuthenticateInput) => AgentSummary;
+export declare const requireCommandForRole: (agent: AgentSummary, command: TeamCommand) => void;
+export {};

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

@@ -0,0 +1,53 @@
+import { ForbiddenError, UnauthorizedError } from './http-errors.js';
+const ORCHESTRATOR_COMMANDS = new Set([
+    'send',
+    'list',
+    'next',
+    'cancel',
+    'help',
+    'recall',
+    'memory_add',
+    'memory_forget',
+    'memory_search',
+    'memory_show',
+    'spawn',
+    'dismiss',
+    'workflow',
+]);
+const WORKER_COMMANDS = new Set([
+    'report',
+    'status',
+    'help',
+    'recall',
+    'memory_search',
+    'memory_show',
+]);
+const WORKER_ROLES = new Set(['coder', 'reviewer', 'tester', 'custom']);
+export const commandAllowedForRole = (role, command) => {
+    if (role === 'orchestrator')
+        return ORCHESTRATOR_COMMANDS.has(command);
+    if (WORKER_ROLES.has(role))
+        return WORKER_COMMANDS.has(command);
+    return false;
+};
+export const authenticateCliAgent = ({ fromAgentId, getAgent, token, validateToken, workspaceId, }) => {
+    if (!fromAgentId) {
+        throw new UnauthorizedError('Missing agent identity');
+    }
+    if (!validateToken(fromAgentId, token)) {
+        throw new UnauthorizedError('Invalid or missing agent token');
+    }
+    let agent;
+    try {
+        agent = getAgent(workspaceId, fromAgentId);
+    }
+    catch {
+        throw new UnauthorizedError('Agent not found in workspace');
+    }
+    return agent;
+};
+export const requireCommandForRole = (agent, command) => {
+    if (!commandAllowedForRole(agent.role, command)) {
+        throw new ForbiddenError(`Role '${agent.role}' is not allowed to run team ${command}`);
+    }
+};

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

@@ -0,0 +1,16 @@
+/**
+ * Auto-staff experimental feature gate.
+ *
+ * The orchestrator can already create workers (`team spawn`); auto-staff is a
+ * guidance layer that grants + encourages it to size the team to the task up
+ * front (e.g. 2 coders + 1 reviewer + 1 tester in one go) rather than adding
+ * workers one at a time. It's purely additive orchestrator guidance — no new
+ * execution path — so unlike workflows it ships ON by default; a user opts
+ * OUT from Settings.
+ *
+ * Stored GLOBALLY in `app_state` under AUTOSTAFF_ENABLED_KEY. Only the exact
+ * string "false" disables it; absent / anything else reads back as enabled.
+ */
+export declare const AUTOSTAFF_ENABLED_KEY = "team.autostaff";
+export declare const readAutostaffEnabled: (raw: string | null | undefined) => boolean;
+export declare const serializeAutostaffEnabled: (enabled: boolean) => string;

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

@@ -0,0 +1,16 @@
+/**
+ * Auto-staff experimental feature gate.
+ *
+ * The orchestrator can already create workers (`team spawn`); auto-staff is a
+ * guidance layer that grants + encourages it to size the team to the task up
+ * front (e.g. 2 coders + 1 reviewer + 1 tester in one go) rather than adding
+ * workers one at a time. It's purely additive orchestrator guidance — no new
+ * execution path — so unlike workflows it ships ON by default; a user opts
+ * OUT from Settings.
+ *
+ * Stored GLOBALLY in `app_state` under AUTOSTAFF_ENABLED_KEY. Only the exact
+ * string "false" disables it; absent / anything else reads back as enabled.
+ */
+export const AUTOSTAFF_ENABLED_KEY = 'team.autostaff';
+export const readAutostaffEnabled = (raw) => raw !== 'false';
+export const serializeAutostaffEnabled = (enabled) => (enabled ? 'true' : 'false');

package/dist/src/server/team-list-enrichment.d.ts

@@ -0,0 +1,22 @@
+import type { TeamListItem } from '../shared/types.js';
+import type { RuntimeStore } from './runtime-store.js';
+export type TeamListEnrichmentStore = Pick<RuntimeStore, 'getLastPtyLineForAgent' | 'peekAgentLaunchConfig' | 'settings'>;
+/**
+ * Resolves the built-in command preset id for a worker. Mirrors the launch-time
+ * lookup in `agent-run-bootstrap.ts::resolveLaunchPreset`: explicit
+ * `commandPresetId` first, then implicit by matching `config.command` against a
+ * built-in preset record. Returns null when the worker was launched with a
+ * custom command, when augmentation has been disabled on the config (the
+ * launcher won't apply preset behavior, so claiming the brand logo would be a
+ * lie), or when there is no launch config row yet (worker created but never
+ * configured).
+ */
+export declare const resolveCommandPresetId: (store: Pick<RuntimeStore, "peekAgentLaunchConfig" | "settings">, workspaceId: string, workerId: string) => string | null;
+/**
+ * Folds the two transient signals exposed on team list payloads — last PTY
+ * line (read fresh per request) and resolved command preset id (read from the
+ * launch cache) — into the in-memory worker records. The records themselves
+ * stay narrow (`workspace-store.listWorkers`) because the workspace store does
+ * not own the launch cache; enrichment happens at the route boundary instead.
+ */
+export declare const enrichTeamList: (workspaceId: string, store: TeamListEnrichmentStore, workers: TeamListItem[]) => TeamListItem[];

package/dist/src/server/team-list-enrichment.js

@@ -0,0 +1,40 @@
+/**
+ * Resolves the built-in command preset id for a worker. Mirrors the launch-time
+ * lookup in `agent-run-bootstrap.ts::resolveLaunchPreset`: explicit
+ * `commandPresetId` first, then implicit by matching `config.command` against a
+ * built-in preset record. Returns null when the worker was launched with a
+ * custom command, when augmentation has been disabled on the config (the
+ * launcher won't apply preset behavior, so claiming the brand logo would be a
+ * lie), or when there is no launch config row yet (worker created but never
+ * configured).
+ */
+export const resolveCommandPresetId = (store, workspaceId, workerId) => {
+    const config = store.peekAgentLaunchConfig(workspaceId, workerId);
+    if (!config)
+        return null;
+    if (config.presetAugmentationDisabled)
+        return null;
+    if (config.commandPresetId)
+        return config.commandPresetId;
+    const implicit = store.settings.getCommandPreset(config.command);
+    if (!implicit || implicit.command !== config.command)
+        return null;
+    return implicit.id;
+};
+/**
+ * Folds the two transient signals exposed on team list payloads — last PTY
+ * line (read fresh per request) and resolved command preset id (read from the
+ * launch cache) — into the in-memory worker records. The records themselves
+ * stay narrow (`workspace-store.listWorkers`) because the workspace store does
+ * not own the launch cache; enrichment happens at the route boundary instead.
+ */
+export const enrichTeamList = (workspaceId, store, workers) => workers.map((worker) => {
+    const line = store.getLastPtyLineForAgent(workspaceId, worker.id);
+    const presetId = resolveCommandPresetId(store, workspaceId, worker.id);
+    const next = { ...worker };
+    if (line !== null)
+        next.lastPtyLine = line;
+    if (presetId !== null)
+        next.commandPresetId = presetId;
+    return next;
+});

package/dist/src/server/team-list-serializer.d.ts

@@ -0,0 +1,2 @@
+import type { TeamListItem, TeamListItemPayload } from '../shared/types.js';
+export declare const serializeTeamListItem: ({ commandPresetId, ephemeral, id, lastPtyLine, name, pendingTaskCount, role, spawnedBy, status, }: TeamListItem) => TeamListItemPayload;

package/dist/src/server/team-list-serializer.js

@@ -0,0 +1,11 @@
+export const serializeTeamListItem = ({ commandPresetId, ephemeral, id, lastPtyLine, name, pendingTaskCount, role, spawnedBy, status, }) => ({
+    id,
+    name,
+    role,
+    status,
+    pending_task_count: pendingTaskCount,
+    last_pty_line: lastPtyLine ?? null,
+    command_preset_id: commandPresetId ?? null,
+    ...(ephemeral === true ? { ephemeral: true } : {}),
+    ...(spawnedBy ? { spawned_by: spawnedBy } : {}),
+});

package/dist/src/server/team-memory-digest.d.ts

@@ -0,0 +1,52 @@
+import type { MemoryEntryWithSources, MemorySearchResult } from './team-memory-store.js';
+export declare const STARTUP_MEMORY_BUDGET_CHARS = 1200;
+export declare const RECOVERY_MEMORY_BUDGET_CHARS = 800;
+export declare const DISPATCH_MEMORY_BUDGET_CHARS = 1500;
+export declare const MEMORY_DIGEST_ENTRY_LIMIT = 20;
+export declare const DISPATCH_MEMORY_ENTRY_LIMIT = 5;
+export declare const DISPATCH_MEMORY_CANDIDATE_LIMIT = 20;
+export declare const DISPATCH_MEMORY_MIN_CONFIDENCE = 0.5;
+export declare const DISPATCH_MEMORY_RECENCY_DECAY_MS: number;
+export type MemoryDigestContext = 'recovery' | 'startup';
+export interface MemoryDigestPayload {
+    memoryIds: string[];
+    text: string;
+}
+export interface WorkspaceMemoryDigestProvider {
+    buildDigest: (input: {
+        contextType: MemoryDigestContext;
+        workspaceId: string;
+    }) => MemoryDigestPayload | null;
+    buildDispatchDigest: (input: {
+        taskText: string;
+        workerDescription: string;
+        workspaceId: string;
+    }) => MemoryDigestPayload | null;
+}
+interface AppStateReader {
+    getAppState: (key: string) => {
+        value: string | null;
+    } | undefined;
+}
+interface MemoryDigestStore {
+    listDigestEntries: (workspaceId: string, options?: {
+        limit?: number;
+    }) => MemoryEntryWithSources[];
+    searchEntries?: (workspaceId: string, query: string, options?: {
+        limit?: number;
+        statuses?: Array<'active' | 'archived' | 'candidate' | 'rejected'>;
+    }) => MemorySearchResult[];
+}
+export declare const formatMemoryDigestBlock: ({ budget, contextType, entries, }: {
+    budget: number;
+    contextType: MemoryDigestContext;
+    entries: MemoryEntryWithSources[];
+}) => MemoryDigestPayload | null;
+export declare const formatDispatchMemoryBlock: ({ entries, }: {
+    entries: MemorySearchResult[];
+}) => MemoryDigestPayload | null;
+export declare const createWorkspaceMemoryDigestProvider: ({ memoryStore, settings, }: {
+    memoryStore: MemoryDigestStore;
+    settings: AppStateReader;
+}) => WorkspaceMemoryDigestProvider;
+export {};