@tt-a1i/hive 1.4.4 → 1.5.0

package/dist/src/server/sqlite-schema-v21.js

@@ -0,0 +1,20 @@
+export const applySchemaVersion21 = (db) => {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS workflow_schedules (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      script_path TEXT NOT NULL,
+      cron TEXT NOT NULL,
+      args TEXT,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      last_run_at INTEGER,
+      next_run_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_workflow_schedules_due
+      ON workflow_schedules (enabled, next_run_at);
+    CREATE INDEX IF NOT EXISTS idx_workflow_schedules_workspace
+      ON workflow_schedules (workspace_id, created_at);
+  `);
+};

package/dist/src/server/sqlite-schema.d.ts

@@ -1,3 +1,3 @@
 import type { Database } from 'better-sqlite3';
-export declare const CURRENT_SCHEMA_VERSION = 18;
+export declare const CURRENT_SCHEMA_VERSION = 21;
 export declare const initializeRuntimeDatabase: (db: Database) => void;

package/dist/src/server/sqlite-schema.js

@@ -11,7 +11,19 @@ import { applySchemaVersion15 } from './sqlite-schema-v15.js';
 import { applySchemaVersion16 } from './sqlite-schema-v16.js';
 import { applySchemaVersion17 } from './sqlite-schema-v17.js';
 import { applySchemaVersion18 } from './sqlite-schema-v18.js';
-export const CURRENT_SCHEMA_VERSION = 18;
+import { applySchemaVersion19 } from './sqlite-schema-v19.js';
+import { applySchemaVersion20 } from './sqlite-schema-v20.js';
+import { applySchemaVersion21 } from './sqlite-schema-v21.js';
+export const CURRENT_SCHEMA_VERSION = 21;
+// Idempotent column-add helper. SQLite doesn't have `ALTER TABLE … ADD COLUMN
+// IF NOT EXISTS`, so PRAGMA-check first. Safe to call on every init; required
+// for foreign-built DBs where the version-gated migration is skipped.
+const ensureColumn = (db, table, column, definition) => {
+    const present = new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((r) => r.name));
+    if (!present.has(column)) {
+        db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+    }
+};
 export const initializeRuntimeDatabase = (db) => {
     db.exec(`
     CREATE TABLE IF NOT EXISTS schema_version (
@@ -105,7 +117,79 @@ export const initializeRuntimeDatabase = (db) => {
 
     CREATE INDEX IF NOT EXISTS idx_dispatches_open_by_worker
       ON dispatches (workspace_id, to_agent_id, status, sequence);
+
+    CREATE TABLE IF NOT EXISTS workflow_runs (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      script_path TEXT NOT NULL,
+      script_hash TEXT,
+      name TEXT NOT NULL,
+      status TEXT NOT NULL,
+      phase TEXT,
+      args TEXT,
+      started_at INTEGER NOT NULL,
+      finished_at INTEGER,
+      error TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_workspace
+      ON workflow_runs (workspace_id, created_at);
+
+    CREATE TABLE IF NOT EXISTS workflow_schedules (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      script_path TEXT NOT NULL,
+      cron TEXT NOT NULL,
+      args TEXT,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      last_run_at INTEGER,
+      next_run_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workflow_schedules_due
+      ON workflow_schedules (enabled, next_run_at);
+    CREATE INDEX IF NOT EXISTS idx_workflow_schedules_workspace
+      ON workflow_schedules (workspace_id, created_at);
   `);
+    // Idempotent column additions — run on every init regardless of
+    // schema_version. The v19 migration adds these columns but is gated on
+    // !appliedVersions.has(19); a foreign-built DB whose v19 was a DIFFERENT
+    // migration leaves these absent. PRAGMA + ALTER here makes the writes safe.
+    ensureColumn(db, 'workers', 'ephemeral', 'INTEGER NOT NULL DEFAULT 0');
+    ensureColumn(db, 'workers', 'spawned_by', 'TEXT');
+    ensureColumn(db, 'dispatches', 'workflow_run_id', 'TEXT');
+    ensureColumn(db, 'dispatches', 'step_index', 'INTEGER');
+    // M9 — phase + label on dispatches so the workflow UI can render the
+    // phase tree + agent fleet view (mirrors Claude Code's /workflows view).
+    ensureColumn(db, 'dispatches', 'phase', 'TEXT');
+    ensureColumn(db, 'dispatches', 'label', 'TEXT');
+    // M10: capture the workflow script's `return` value so the UI can render
+    // a single canonical "Result" panel and the orchestrator notification can
+    // include it.
+    ensureColumn(db, 'workflow_runs', 'result', 'TEXT');
+    // TIER 2 #5: parent_run_id lets the Drawer render nested workflow() calls
+    // as a tree (child runs indented under their parent). Without it,
+    // nested runs were flat and the user couldn't tell which child
+    // belonged to which parent. Null on top-level runs.
+    ensureColumn(db, 'workflow_runs', 'parent_run_id', 'TEXT');
+    // TIER 2 #3: log() narrator pipeline. Authors call `log('Discovered 47
+    // endpoints')` from a workflow script; rows live here and stream to
+    // the Drawer's narrator lane + the last few lines are appended to
+    // the orchestrator's completion notification.
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS workflow_run_logs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id TEXT NOT NULL,
+      ts INTEGER NOT NULL,
+      message TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_workflow_run_logs_run
+      ON workflow_run_logs (run_id, id);
+  `);
+    db.exec('CREATE INDEX IF NOT EXISTS idx_dispatches_workflow ON dispatches (workflow_run_id, step_index)');
     const versions = db
         .prepare('SELECT version FROM schema_version ORDER BY version ASC')
         .all();
@@ -203,4 +287,16 @@ export const initializeRuntimeDatabase = (db) => {
         applySchemaVersion18(db);
         db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(18, Date.now());
     }
+    if (!appliedVersions.has(19)) {
+        applySchemaVersion19(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(19, Date.now());
+    }
+    if (!appliedVersions.has(20)) {
+        applySchemaVersion20(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(20, Date.now());
+    }
+    if (!appliedVersions.has(21)) {
+        applySchemaVersion21(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(21, Date.now());
+    }
 };

package/dist/src/server/system-message.d.ts

@@ -1 +1,8 @@
+/**
+ * Wraps a system-injected message body in an out-of-band XML envelope so the
+ * agent attends to it as system content rather than mistaking it for user
+ * input or its own output. `<hive-system-reminder>` is reserved for the short
+ * re-anchoring action menu appended at a message tail; this `<hive-system-message>`
+ * tag carries larger injected bodies (crash-recovery / restart env-sync).
+ */
 export declare const wrapSystemMessage: (content: string) => string;

package/dist/src/server/system-message.js

@@ -1 +1,8 @@
-export const wrapSystemMessage = (content) => `[Hive 系统消息：${content}]`;
+/**
+ * Wraps a system-injected message body in an out-of-band XML envelope so the
+ * agent attends to it as system content rather than mistaking it for user
+ * input or its own output. `<hive-system-reminder>` is reserved for the short
+ * re-anchoring action menu appended at a message tail; this `<hive-system-message>`
+ * tag carries larger injected bodies (crash-recovery / restart env-sync).
+ */
+export const wrapSystemMessage = (content) => `<hive-system-message>\n${content}\n</hive-system-message>`;

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

@@ -1,4 +1,5 @@
 import { type ChokidarOptions } from 'chokidar';
+import type { WorkflowCliPolicy } from './workflow-cli-policy.js';
 /**
  * Watcher configuration. The atomic-save option matters on Windows: VS
  * Code, Cursor, Notepad++, and the editor inside Hive itself all save
@@ -24,11 +25,22 @@ import { type ChokidarOptions } from 'chokidar';
  * Exported so the configuration is testable in isolation.
  */
 export declare const TASKS_WATCHER_OPTIONS: ChokidarOptions;
+export declare const buildTasksWatcherOptions: (workspacePath: string, platform?: NodeJS.Platform) => ChokidarOptions;
 export interface TasksFileWatcher {
     close: () => Promise<void>;
     start: (workspaceId: string, workspacePath: string) => Promise<void>;
     stop: (workspaceId: string) => Promise<void>;
 }
-export declare const createTasksFileWatcher: ({ onTasksUpdated, }: {
+export declare const createTasksFileWatcher: ({ onTasksUpdated, getWorkflowCliPolicy, getWorkflowsEnabled, getAutostaffEnabled, }: {
     onTasksUpdated: (workspaceId: string, content: string) => void;
+    /** Lets the freshly-written `.hive/PROTOCOL.md` state the workspace's
+     *  workflow CLI default + allowlist. Optional: omitted → the doc renders
+     *  the unrestricted default. */
+    getWorkflowCliPolicy?: () => WorkflowCliPolicy;
+    /** Whether the experimental workflow feature is on. Off → PROTOCOL.md omits
+     *  the workflow DSL + `team workflow` commands entirely. Defaults to off. */
+    getWorkflowsEnabled?: () => boolean;
+    /** Whether the experimental auto-staff feature is on (default on). Off →
+     *  PROTOCOL.md omits the team-sizing rule. */
+    getAutostaffEnabled?: () => boolean;
 }) => TasksFileWatcher;

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

@@ -1,8 +1,12 @@
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
+import { basename, dirname, normalize } from 'node:path';
 import chokidar from 'chokidar';
-import { ensureProtocolFile, ensureTasksFile, getTasksFilePath } from './tasks-file.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 WATCHER_READY_TIMEOUT_MS = 15000;
 /**
  * Watcher configuration. The atomic-save option matters on Windows: VS
  * Code, Cursor, Notepad++, and the editor inside Hive itself all save
@@ -31,9 +35,45 @@ export const TASKS_WATCHER_OPTIONS = {
     atomic: 100,
     ignoreInitial: true,
 };
-export const createTasksFileWatcher = ({ onTasksUpdated, }) => {
+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 }
+        : {}),
+});
+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);
+    }
+};
+const isTasksFileEvent = (tasksPath, changedPath) => {
+    if (!changedPath)
+        return true;
+    const text = Buffer.isBuffer(changedPath) ? changedPath.toString() : changedPath;
+    return normalize(text) === normalize(tasksPath) || basename(text) === TASKS_FILE_NAME;
+};
+export const createTasksFileWatcher = ({ onTasksUpdated, getWorkflowCliPolicy, getWorkflowsEnabled, getAutostaffEnabled, }) => {
     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)
@@ -41,6 +81,13 @@ export const createTasksFileWatcher = ({ onTasksUpdated, }) => {
         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 {
@@ -48,39 +95,96 @@ export const createTasksFileWatcher = ({ onTasksUpdated, }) => {
             onTasksUpdated(workspaceId, content);
         }
         catch (error) {
-            if (error.code !== 'ENOENT')
-                throw 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 watcher?.close();
+        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) => 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 ${WATCHER_READY_TIMEOUT_MS}ms`));
+        }, WATCHER_READY_TIMEOUT_MS);
+        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?.(), getWorkflowsEnabled?.() ?? false, getAutostaffEnabled?.() ?? false);
+        const tasksPath = getTasksFilePath(workspacePath);
+        const watcher = chokidar.watch(dirname(tasksPath), buildTasksWatcherOptions(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);
+        }
+        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: async (workspaceId, workspacePath) => {
-            await stop(workspaceId);
-            ensureTasksFile(workspacePath);
-            ensureProtocolFile(workspacePath);
-            const watcher = chokidar.watch(getTasksFilePath(workspacePath), TASKS_WATCHER_OPTIONS);
-            const scheduleEmit = () => {
-                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);
-            watchers.set(workspaceId, watcher);
-            await new Promise((resolve) => watcher.once('ready', () => resolve()));
-        },
+        start,
         stop,
     };
 };

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

@@ -1,3 +1,4 @@
+import type { WorkflowCliPolicy } from './workflow-cli-policy.js';
 interface TasksFileService {
     readTasks: (workspacePath: string) => string;
     writeTasks: (workspacePath: string, content: string) => void;
@@ -16,6 +17,6 @@ export declare const ensureTasksFile: (workspacePath: string) => string;
  * on every workspace open means a Hive version bump that changes the rules
  * propagates without manual intervention.
  */
-export declare const ensureProtocolFile: (workspacePath: string) => string;
+export declare const ensureProtocolFile: (workspacePath: string, cliPolicy?: WorkflowCliPolicy, workflowsEnabled?: boolean, autostaffEnabled?: boolean) => string;
 export declare const createTasksFileService: () => TasksFileService;
 export type { TasksFileService };

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

@@ -9,18 +9,39 @@ 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) => {
-    mkdirSync(dirname(getTasksFilePath(workspacePath)), { recursive: true });
+    runRetryableTasksFileOperation(() => mkdirSync(dirname(getTasksFilePath(workspacePath)), { recursive: true }));
 };
 export const ensureTasksFile = (workspacePath) => {
     ensureTasksDir(workspacePath);
     const tasksFilePath = getTasksFilePath(workspacePath);
     if (existsSync(tasksFilePath)) {
-        return readFileSync(tasksFilePath, 'utf8');
+        return runRetryableTasksFileOperation(() => readFileSync(tasksFilePath, 'utf8'));
     }
     const legacyTasksFilePath = getLegacyTasksFilePath(workspacePath);
-    const content = existsSync(legacyTasksFilePath) ? readFileSync(legacyTasksFilePath, 'utf8') : '';
-    writeFileSync(tasksFilePath, content, 'utf8');
+    const content = existsSync(legacyTasksFilePath)
+        ? runRetryableTasksFileOperation(() => readFileSync(legacyTasksFilePath, 'utf8'))
+        : '';
+    runRetryableTasksFileOperation(() => writeFileSync(tasksFilePath, content, 'utf8'));
     return content;
 };
 /**
@@ -29,14 +50,16 @@ export const ensureTasksFile = (workspacePath) => {
  * on every workspace open means a Hive version bump that changes the rules
  * propagates without manual intervention.
  */
-export const ensureProtocolFile = (workspacePath) => {
+export const ensureProtocolFile = (workspacePath, cliPolicy, workflowsEnabled = false, autostaffEnabled = false) => {
     ensureTasksDir(workspacePath);
     const protocolFilePath = getProtocolFilePath(workspacePath);
-    const desired = buildProtocolDoc();
-    const current = existsSync(protocolFilePath) ? readFileSync(protocolFilePath, 'utf8') : null;
+    const desired = buildProtocolDoc(cliPolicy, workflowsEnabled, autostaffEnabled);
+    const current = existsSync(protocolFilePath)
+        ? runRetryableTasksFileOperation(() => readFileSync(protocolFilePath, 'utf8'))
+        : null;
     if (current === desired)
         return desired;
-    writeFileSync(protocolFilePath, desired, 'utf8');
+    runRetryableTasksFileOperation(() => writeFileSync(protocolFilePath, desired, 'utf8'));
     return desired;
 };
 export const createTasksFileService = () => {
@@ -46,7 +69,7 @@ export const createTasksFileService = () => {
         },
         writeTasks(workspacePath, content) {
             ensureTasksDir(workspacePath);
-            writeFileSync(getTasksFilePath(workspacePath), content, 'utf8');
+            runRetryableTasksFileOperation(() => writeFileSync(getTasksFilePath(workspacePath), content, 'utf8'));
         },
     };
 };

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

@@ -1,17 +1,15 @@
 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;
 };
-const rejectUpgrade = (socket, status) => {
-    socket.write(`HTTP/1.1 ${status}\r\n\r\n`);
-    socket.destroy();
-};
 export const createTasksWebSocketServer = (server, store, tasksFileService) => {
     const wss = new WebSocketServer({ noServer: true });
+    attachWebSocketServerErrorHandler(wss, 'tasks');
     const socketsByWorkspaceId = new Map();
     const validateUpgradeSession = (request) => {
         const cookieHeader = Array.isArray(request.headers.cookie)
@@ -25,12 +23,13 @@ export const createTasksWebSocketServer = (server, store, tasksFileService) => {
         const workspaceId = matchTasksPath(url.pathname);
         if (!workspaceId)
             return;
+        const detachRawSocketErrorHandler = attachRawSocketErrorHandler(socket, 'tasks upgrade');
         if (getLocalRequestRejection(request)) {
-            rejectUpgrade(socket, '403 Forbidden');
+            rejectWebSocketUpgrade(socket, '403 Forbidden');
             return;
         }
         if (!validateUpgradeSession(request)) {
-            rejectUpgrade(socket, '401 Unauthorized');
+            rejectWebSocketUpgrade(socket, '401 Unauthorized');
             return;
         }
         let workspacePath = '';
@@ -38,10 +37,12 @@ export const createTasksWebSocketServer = (server, store, tasksFileService) => {
             workspacePath = store.getWorkspaceSnapshot(workspaceId).summary.path;
         }
         catch {
-            rejectUpgrade(socket, '404 Not Found');
+            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);
@@ -55,14 +56,14 @@ export const createTasksWebSocketServer = (server, store, tasksFileService) => {
                 if (ws.readyState !== ws.OPEN)
                     return;
                 try {
-                    ws.send(JSON.stringify({
+                    sendWebSocketMessage(ws, JSON.stringify({
                         type: 'tasks-snapshot',
                         content: tasksFileService.readTasks(workspacePath),
-                    }));
+                    }), `tasks ${workspaceId} snapshot`);
                 }
                 catch {
                     if (ws.readyState === ws.OPEN) {
-                        ws.send(JSON.stringify({ type: 'tasks-snapshot', content: '' }));
+                        sendWebSocketMessage(ws, JSON.stringify({ type: 'tasks-error', error: 'Failed to read tasks file' }), `tasks ${workspaceId} snapshot error`);
                     }
                 }
             });
@@ -72,7 +73,7 @@ export const createTasksWebSocketServer = (server, store, tasksFileService) => {
         close: () => {
             for (const sockets of socketsByWorkspaceId.values()) {
                 for (const socket of sockets)
-                    socket.close();
+                    socket.terminate();
             }
             socketsByWorkspaceId.clear();
             wss.close();
@@ -83,9 +84,7 @@ export const createTasksWebSocketServer = (server, store, tasksFileService) => {
                 return;
             const payload = JSON.stringify({ type: 'tasks-updated', content });
             for (const socket of sockets) {
-                if (socket.readyState === socket.OPEN) {
-                    socket.send(payload);
-                }
+                sendWebSocketMessage(socket, payload, `tasks ${workspaceId} publish`);
             }
         },
     };

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

@@ -1,5 +1,5 @@
 import type { AgentSummary } from '../shared/types.js';
-export type TeamCommand = 'send' | 'list' | 'report' | 'status' | 'cancel' | 'help';
+export type TeamCommand = 'send' | 'list' | 'report' | 'status' | 'cancel' | 'help' | 'spawn' | 'dismiss' | 'workflow';
 export declare const commandAllowedForRole: (role: AgentSummary["role"], command: TeamCommand) => boolean;
 interface AuthenticateInput {
     fromAgentId: string | undefined;

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

@@ -1,5 +1,13 @@
 import { ForbiddenError, UnauthorizedError } from './http-errors.js';
-const ORCHESTRATOR_COMMANDS = new Set(['send', 'list', 'cancel', 'help']);
+const ORCHESTRATOR_COMMANDS = new Set([
+    'send',
+    'list',
+    'cancel',
+    'help',
+    'spawn',
+    'dismiss',
+    'workflow',
+]);
 const WORKER_COMMANDS = new Set(['report', 'status', 'help']);
 const WORKER_ROLES = new Set(['coder', 'reviewer', 'tester', 'custom']);
 export const commandAllowedForRole = (role, 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-serializer.d.ts

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

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

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