@tt-a1i/hive 1.7.0 → 2.0.1

package/dist/src/server/agent-stdin-dispatcher.js

@@ -2,6 +2,7 @@ import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
 import { buildOrchestratorReminderTail, buildWorkerReminderTail } from './hive-team-guidance.js';
 import { PtyInactiveError } from './http-errors.js';
 import { createPostStartInputWriter } from './post-start-input-writer.js';
+import { buildDispatchMemoryDigestSafely, logMemoryDigestInjection, rollbackMemoryDigestInjection, } from './team-memory-injection.js';
 export const buildOrchestratorReportPayload = (workerName, text, artifacts, flags = FEATURE_FLAGS_ALL_OFF) => {
     const lines = [`<hive-message kind="report" from="@${workerName}">`, text];
     for (const artifact of artifacts)
@@ -17,7 +18,7 @@ export const buildOrchestratorStatusPayload = (workerName, text, artifacts, flag
     return lines.join('\n');
 };
 export const buildOrchestratorUserInputPayload = (text, flags = FEATURE_FLAGS_ALL_OFF) => [text, '', buildOrchestratorReminderTail(flags), ''].join('\n');
-export const buildWorkerDispatchPayload = (fromAgentName, workerDescription, dispatchId, text) => [
+export const buildWorkerDispatchPayload = (fromAgentName, workerDescription, dispatchId, text, memoryDigest) => [
     `<hive-message kind="dispatch" from="@${fromAgentName}">`,
     '',
     `Your role: ${workerDescription}`,
@@ -28,6 +29,7 @@ export const buildWorkerDispatchPayload = (fromAgentName, workerDescription, dis
     '',
     `dispatch_id: ${dispatchId}`,
     '',
+    ...(memoryDigest ? [memoryDigest, ''] : []),
     'Task:',
     text,
     '</hive-message>',
@@ -45,7 +47,7 @@ export const buildWorkerCancelPayload = (dispatchId, reason) => [
     '</hive-message>',
     '',
 ].join('\n');
-export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, getFlags, }) => {
+export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, memoryInjection, getFlags, }) => {
     const flags = () => getFlags?.() ?? FEATURE_FLAGS_ALL_OFF;
     const chains = new Map();
     const getChain = (agentId) => {
@@ -163,7 +165,37 @@ export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getW
             swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorStatusPayload(workerName, text, artifacts, flags()), input));
         },
         writeSendPrompt(workspaceId, workerId, dispatchId, fromAgentName, workerDescription, text) {
-            return writeToActiveAgentRun(workspaceId, workerId, buildWorkerDispatchPayload(fromAgentName, workerDescription, dispatchId, text), { requireActiveRun: true });
+            if (!resolveActiveRun(workspaceId, workerId)) {
+                throw new PtyInactiveError(`No active run for agent: ${workerId}`);
+            }
+            const memoryDigest = buildDispatchMemoryDigestSafely({
+                memoryInjection,
+                taskText: text,
+                workerDescription,
+                workspaceId,
+            });
+            const injectionIds = logMemoryDigestInjection({
+                agentId: workerId,
+                contextType: 'dispatch',
+                dispatchId,
+                memoryDigest,
+                memoryInjection,
+                workspaceId,
+            });
+            const rollback = () => rollbackMemoryDigestInjection({
+                injectionIds,
+                memoryInjection,
+            });
+            try {
+                return writeToActiveAgentRun(workspaceId, workerId, buildWorkerDispatchPayload(fromAgentName, workerDescription, dispatchId, text, injectionIds ? memoryDigest?.text : null), { requireActiveRun: true }).catch((error) => {
+                    rollback();
+                    throw error;
+                });
+            }
+            catch (error) {
+                rollback();
+                throw error;
+            }
         },
         writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input = {}) {
             swallowQueuedFailure(writeToActiveAgentRun(workspaceId, workerId, buildWorkerCancelPayload(dispatchId, reason), input));

package/dist/src/server/command-preset-defaults.d.ts

@@ -1,6 +1,8 @@
 import type { SessionIdCaptureConfig } from './session-capture.js';
+export declare const BUILTIN_COMMAND_PRESET_IDS: readonly ["claude", "codex", "opencode", "gemini", "hermes", "qwen", "agy", "cursor", "grok"];
+export type BuiltinCommandPresetId = (typeof BUILTIN_COMMAND_PRESET_IDS)[number];
 export interface BuiltinCommandPresetDefaults {
-    id: string;
+    id: BuiltinCommandPresetId;
     displayName: string;
     command: string;
     resumeArgsTemplate: string | null;
@@ -9,3 +11,6 @@ export interface BuiltinCommandPresetDefaults {
 }
 export declare const BUILTIN_COMMAND_PRESETS: BuiltinCommandPresetDefaults[];
 export declare const getBuiltinCommandPreset: (id: string) => BuiltinCommandPresetDefaults | undefined;
+export declare const getBuiltinCommandPresetByCommand: (command: string) => BuiltinCommandPresetDefaults | undefined;
+export declare const BUILTIN_COMMAND_PRESET_CLI_LIST: string;
+export declare const BUILTIN_INTERACTIVE_COMMANDS: Set<string>;

package/dist/src/server/command-preset-defaults.js

@@ -1,8 +1,23 @@
 import { CLAUDE_DEFAULT_YOLO_ARGS } from './claude-command-defaults.js';
+export const BUILTIN_COMMAND_PRESET_IDS = [
+    'claude',
+    'codex',
+    'opencode',
+    'gemini',
+    'hermes',
+    'qwen',
+    'agy',
+    'cursor',
+    'grok',
+];
 const CODEX_DEFAULT_YOLO_ARGS = ['--dangerously-bypass-approvals-and-sandbox'];
 const OPENCODE_DEFAULT_YOLO_ARGS = [];
 const GEMINI_DEFAULT_YOLO_ARGS = ['--yolo'];
 const HERMES_DEFAULT_YOLO_ARGS = ['--yolo'];
+const QWEN_DEFAULT_YOLO_ARGS = ['--approval-mode', 'yolo'];
+const AGY_DEFAULT_YOLO_ARGS = ['--dangerously-skip-permissions'];
+const CURSOR_DEFAULT_YOLO_ARGS = ['--force'];
+const GROK_DEFAULT_YOLO_ARGS = ['--always-approve'];
 export const BUILTIN_COMMAND_PRESETS = [
     {
         command: 'claude',
@@ -59,5 +74,46 @@ export const BUILTIN_COMMAND_PRESETS = [
         },
         yoloArgsTemplate: HERMES_DEFAULT_YOLO_ARGS,
     },
+    {
+        command: 'qwen',
+        displayName: 'Qwen Code',
+        id: 'qwen',
+        resumeArgsTemplate: '--resume {session_id}',
+        sessionIdCapture: {
+            pattern: '~/.qwen/sessions/**/*.json',
+            source: 'qwen_session_json_dir',
+        },
+        yoloArgsTemplate: QWEN_DEFAULT_YOLO_ARGS,
+    },
+    {
+        command: 'agy',
+        displayName: 'Antigravity CLI',
+        id: 'agy',
+        resumeArgsTemplate: '--conversation {session_id}',
+        sessionIdCapture: {
+            pattern: String.raw `(?:^|\s)(?:\S*[\\/])?agy(?:\.(?:cmd|exe))?\s+--conversation\s+([0-9a-fA-F-]{36})\b`,
+            source: 'stdout_regex',
+        },
+        yoloArgsTemplate: AGY_DEFAULT_YOLO_ARGS,
+    },
+    {
+        command: 'cursor-agent',
+        displayName: 'Cursor CLI',
+        id: 'cursor',
+        resumeArgsTemplate: null,
+        sessionIdCapture: null,
+        yoloArgsTemplate: CURSOR_DEFAULT_YOLO_ARGS,
+    },
+    {
+        command: 'grok',
+        displayName: 'Grok Build',
+        id: 'grok',
+        resumeArgsTemplate: null,
+        sessionIdCapture: null,
+        yoloArgsTemplate: GROK_DEFAULT_YOLO_ARGS,
+    },
 ];
 export const getBuiltinCommandPreset = (id) => BUILTIN_COMMAND_PRESETS.find((preset) => preset.id === id);
+export const getBuiltinCommandPresetByCommand = (command) => BUILTIN_COMMAND_PRESETS.find((preset) => preset.command === command);
+export const BUILTIN_COMMAND_PRESET_CLI_LIST = BUILTIN_COMMAND_PRESET_IDS.join('|');
+export const BUILTIN_INTERACTIVE_COMMANDS = new Set(BUILTIN_COMMAND_PRESETS.flatMap((preset) => [preset.id, preset.command]));

package/dist/src/server/fs-browse.d.ts

@@ -21,6 +21,8 @@ export interface FsProbeResponse {
     path: string;
     suggested_name: string;
 }
+export declare const getWindowsBrowseParentPath: (candidate: string) => string;
+export declare const getSuggestedWorkspaceNameFromPath: (path: string) => string;
 export declare const browseDirectory: (requestedPath: string) => Promise<FsBrowseResponse>;
 export interface ProbeDirectoryOptions {
     /**

package/dist/src/server/fs-browse.js

@@ -1,10 +1,9 @@
-import { execFile } from 'node:child_process';
-import { readdir, stat } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-import { promisify } from 'node:util';
-import { getFsBrowseRoot, isPathWithinRoot } from './fs-sandbox.js';
-const execFileP = promisify(execFile);
-const GIT_BRANCH_TIMEOUT_MS = 800;
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import { dirname as dirnameWin32Path, parse as parseWin32Path, resolve as resolveWin32Path, } from 'node:path/win32';
+import { WINDOWS_DRIVES_ROOT } from '../shared/fs-browse.js';
+import { sanitizePastedPath } from '../shared/path-input.js';
+import { getFsBrowseRoot, hasFsBrowseRootOverride, isPathWithinRoot } from './fs-sandbox.js';
 /**
  * Map a filesystem rejection (from `readdir`, `stat`, etc.) to a string
  * suitable for surfacing in the browse response. The common Windows
@@ -28,31 +27,94 @@ const formatFilesystemError = (error) => {
     }
     return error.message;
 };
-const detectGitRepository = async (entryPath) => {
+const resolveGitDirPath = async (repoPath) => {
+    const dotGitPath = resolve(repoPath, '.git');
     try {
-        const info = await stat(resolve(entryPath, '.git'));
-        return info.isDirectory() || info.isFile();
+        const info = await stat(dotGitPath);
+        if (info.isDirectory())
+            return dotGitPath;
+        if (!info.isFile())
+            return null;
+        const text = await readFile(dotGitPath, 'utf8');
+        const firstLine = text.split(/\r?\n/u)[0]?.trim() ?? '';
+        const match = /^gitdir:\s*(?<path>.+)$/iu.exec(firstLine);
+        const gitDirPath = match?.groups?.path?.trim();
+        if (!gitDirPath)
+            return null;
+        return isAbsolute(gitDirPath) ? gitDirPath : resolve(repoPath, gitDirPath);
     }
     catch {
-        return false;
+        return null;
     }
 };
+const detectGitRepository = async (entryPath) => (await resolveGitDirPath(entryPath)) !== null;
 const readCurrentBranch = async (repoPath) => {
+    const gitDirPath = await resolveGitDirPath(repoPath);
+    if (!gitDirPath)
+        return null;
     try {
-        const { stdout } = await execFileP('git', ['-C', repoPath, 'rev-parse', '--abbrev-ref', 'HEAD'], {
-            timeout: GIT_BRANCH_TIMEOUT_MS,
-            windowsHide: true,
-        });
-        const branch = stdout.trim();
-        return branch.length > 0 ? branch : null;
+        const head = (await readFile(resolve(gitDirPath, 'HEAD'), 'utf8')).split(/\r?\n/u)[0]?.trim();
+        const branchRef = head?.startsWith('ref: refs/heads/')
+            ? head.slice('ref: refs/heads/'.length)
+            : '';
+        return branchRef.length > 0 ? branchRef : null;
     }
     catch {
         return null;
     }
 };
+const isFullWindowsBrowseEnabled = () => process.platform === 'win32' && !hasFsBrowseRootOverride();
+const trimTrailingWindowsSeparators = (path) => path.replace(/[\\/]+$/u, '');
+const isWindowsRootPath = (path) => {
+    const resolved = resolveWin32Path(path);
+    const parsed = parseWin32Path(resolved);
+    return (parsed.root.length > 0 &&
+        trimTrailingWindowsSeparators(resolved).toLowerCase() ===
+            trimTrailingWindowsSeparators(parsed.root).toLowerCase());
+};
+const listWindowsDriveRoots = async () => {
+    const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
+    const roots = await Promise.all(letters.map(async (letter) => {
+        const root = `${letter}:\\`;
+        try {
+            const info = await stat(root);
+            if (!info.isDirectory())
+                return null;
+            return {
+                is_dir: true,
+                is_git_repository: false,
+                name: `${letter}:`,
+                path: root,
+            };
+        }
+        catch {
+            return null;
+        }
+    }));
+    return roots.filter((root) => root !== null);
+};
+const browseWindowsDrivesRoot = async () => ({
+    current_path: WINDOWS_DRIVES_ROOT,
+    entries: await listWindowsDriveRoots(),
+    error: null,
+    ok: true,
+    parent_path: null,
+    root_path: WINDOWS_DRIVES_ROOT,
+});
+const getSandboxParentPath = (rootPath, candidate) => {
+    if (candidate === rootPath)
+        return null;
+    const rawParent = dirname(candidate);
+    return isPathWithinRoot(rootPath, rawParent) ? rawParent : null;
+};
+export const getWindowsBrowseParentPath = (candidate) => isWindowsRootPath(candidate) ? WINDOWS_DRIVES_ROOT : dirnameWin32Path(candidate);
+export const getSuggestedWorkspaceNameFromPath = (path) => (path.split(/[\\/]/).filter(Boolean).pop() ?? '').replace(/:$/u, '');
 export const browseDirectory = async (requestedPath) => {
+    if (isFullWindowsBrowseEnabled()) {
+        return browseWindowsDirectory(requestedPath);
+    }
     const rootPath = getFsBrowseRoot();
-    const trimmed = requestedPath.trim();
+    const trimmed = sanitizePastedPath(requestedPath);
     const candidate = trimmed.length === 0 ? rootPath : resolve(rootPath, trimmed);
     if (!isPathWithinRoot(rootPath, candidate)) {
         return {
@@ -74,7 +136,7 @@ export const browseDirectory = async (requestedPath) => {
             entries: [],
             error: formatFilesystemError(error),
             ok: false,
-            parent_path: null,
+            parent_path: getSandboxParentPath(rootPath, candidate),
             root_path: rootPath,
         };
     }
@@ -84,7 +146,7 @@ export const browseDirectory = async (requestedPath) => {
             entries: [],
             error: 'The specified path is not a directory.',
             ok: false,
-            parent_path: null,
+            parent_path: getSandboxParentPath(rootPath, candidate),
             root_path: rootPath,
         };
     }
@@ -102,7 +164,7 @@ export const browseDirectory = async (requestedPath) => {
             entries: [],
             error: formatFilesystemError(error),
             ok: false,
-            parent_path: null,
+            parent_path: getSandboxParentPath(rootPath, candidate),
             root_path: rootPath,
         };
     }
@@ -118,25 +180,97 @@ export const browseDirectory = async (requestedPath) => {
             path: entryPath,
         };
     }));
-    const isAtRoot = candidate === rootPath;
-    const rawParent = dirname(candidate);
-    const parentIsWithinRoot = isPathWithinRoot(rootPath, rawParent);
-    const parent_path = isAtRoot ? null : parentIsWithinRoot ? rawParent : null;
     return {
         current_path: candidate,
         entries,
         error: null,
         ok: true,
-        parent_path,
+        parent_path: getSandboxParentPath(rootPath, candidate),
         root_path: rootPath,
     };
 };
+const browseWindowsDirectory = async (requestedPath) => {
+    const trimmed = sanitizePastedPath(requestedPath);
+    if (trimmed.length === 0 || trimmed === WINDOWS_DRIVES_ROOT) {
+        return browseWindowsDrivesRoot();
+    }
+    const candidate = resolveWin32Path(trimmed);
+    let dirStat;
+    try {
+        dirStat = await stat(candidate);
+    }
+    catch (error) {
+        return {
+            current_path: candidate,
+            entries: [],
+            error: formatFilesystemError(error),
+            ok: false,
+            parent_path: getWindowsBrowseParentPath(candidate),
+            root_path: WINDOWS_DRIVES_ROOT,
+        };
+    }
+    if (!dirStat.isDirectory()) {
+        return {
+            current_path: candidate,
+            entries: [],
+            error: 'The specified path is not a directory.',
+            ok: false,
+            parent_path: getWindowsBrowseParentPath(candidate),
+            root_path: WINDOWS_DRIVES_ROOT,
+        };
+    }
+    let rawEntries;
+    try {
+        rawEntries = await readdir(candidate, { withFileTypes: true });
+    }
+    catch (error) {
+        return {
+            current_path: candidate,
+            entries: [],
+            error: formatFilesystemError(error),
+            ok: false,
+            parent_path: getWindowsBrowseParentPath(candidate),
+            root_path: WINDOWS_DRIVES_ROOT,
+        };
+    }
+    const directoryEntries = rawEntries
+        .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const entries = await Promise.all(directoryEntries.map(async (entry) => {
+        const entryPath = resolveWin32Path(candidate, entry.name);
+        return {
+            is_dir: true,
+            is_git_repository: await detectGitRepository(entryPath),
+            name: entry.name,
+            path: entryPath,
+        };
+    }));
+    return {
+        current_path: candidate,
+        entries,
+        error: null,
+        ok: true,
+        parent_path: getWindowsBrowseParentPath(candidate),
+        root_path: WINDOWS_DRIVES_ROOT,
+    };
+};
 export const probeDirectory = async (requestedPath, options = {}) => {
     const enforceSandbox = options.enforceSandbox ?? true;
+    const fullWindowsBrowse = isFullWindowsBrowseEnabled();
+    const requested = sanitizePastedPath(requestedPath);
+    if (requested === WINDOWS_DRIVES_ROOT) {
+        return {
+            current_branch: null,
+            exists: false,
+            is_dir: false,
+            is_git_repository: false,
+            ok: false,
+            path: '',
+            suggested_name: '',
+        };
+    }
     const rootPath = getFsBrowseRoot();
-    const candidate = enforceSandbox
-        ? resolve(rootPath, requestedPath.trim())
-        : resolve(requestedPath.trim());
+    const candidate = enforceSandbox && !fullWindowsBrowse ? resolve(rootPath, requested) : resolve(requested);
     const base = {
         current_branch: null,
         exists: false,
@@ -144,9 +278,9 @@ export const probeDirectory = async (requestedPath, options = {}) => {
         is_git_repository: false,
         ok: false,
         path: candidate,
-        suggested_name: candidate.split(/[\\/]/).filter(Boolean).pop() ?? '',
+        suggested_name: getSuggestedWorkspaceNameFromPath(candidate),
     };
-    if (enforceSandbox && !isPathWithinRoot(rootPath, candidate)) {
+    if (enforceSandbox && !fullWindowsBrowse && !isPathWithinRoot(rootPath, candidate)) {
         return base;
     }
     try {

package/dist/src/server/fs-pick-folder.js

@@ -95,73 +95,6 @@ const linuxPick = async (run) => {
         return emptyResponse({ canceled: true });
     return finalizeWithProbe(picked);
 };
-const windowsPick = async (run) => {
-    /* Hive's PowerShell child has no visible main window, so a bare
-       `$dialog.ShowDialog()` inherits the desktop as IWin32Window parent —
-       and ends up below the foreground browser in z-order. To the user
-       that looks like a hang ("Add Workspace pops up then nothing"); the
-       picker is open, just occluded.
-  
-       Fix: build a TopMost invisible owner Form, `Show()` it so it has a
-       real HWND (an unshown Form has none, and ShowDialog silently falls
-       back to desktop-parent), then pass the owner to `ShowDialog($owner)`.
-       The owner inherits TopMost z-order onto the dialog. The owner itself
-       stays invisible — Opacity 0, parked at (-32000, -32000), 1x1 size,
-       no taskbar entry — so the user only sees the picker. Dispose in
-       `finally` to release the HWND each invocation.
-  
-       `Add-Type -AssemblyName System.Drawing` is required because Point /
-       Size live in System.Drawing.dll, not System.Windows.Forms.dll. */
-    // PS 5.1 on zh-CN Windows defaults [Console]::OutputEncoding to cp936/GBK;
-    // Node decodes stdout as UTF-8 and CJK paths arrive mojibake'd. Force UTF-8
-    // before any output. No-op on PS 7+ which already defaults to UTF-8.
-    const script = [
-        '[Console]::OutputEncoding = [System.Text.Encoding]::UTF8',
-        'Add-Type -AssemblyName System.Windows.Forms',
-        'Add-Type -AssemblyName System.Drawing',
-        '$owner = New-Object System.Windows.Forms.Form',
-        "$owner.FormBorderStyle = 'None'",
-        '$owner.Opacity = 0',
-        '$owner.ShowInTaskbar = $false',
-        "$owner.StartPosition = 'Manual'",
-        '$owner.Location = New-Object System.Drawing.Point(-32000, -32000)',
-        '$owner.Size = New-Object System.Drawing.Size(1, 1)',
-        '$owner.TopMost = $true',
-        '$owner.Show()',
-        'try {',
-        '  $dialog = New-Object System.Windows.Forms.FolderBrowserDialog',
-        '  $dialog.Description = "Select Hive workspace"',
-        '  $dialog.ShowNewFolderButton = $false',
-        '  $result = $dialog.ShowDialog($owner)',
-        '  if ($result -eq [System.Windows.Forms.DialogResult]::OK) { [Console]::Out.WriteLine($dialog.SelectedPath); exit 0 }',
-        '  exit 1',
-        '} finally {',
-        '  $owner.Close()',
-        '  $owner.Dispose()',
-        '}',
-    ].join('; ');
-    const result = await run('powershell.exe', ['-NoProfile', '-STA', '-ExecutionPolicy', 'Bypass', '-Command', script], { timeout: PICKER_TIMEOUT_MS });
-    if (result.spawnError?.code === 'ENOENT') {
-        return emptyResponse({
-            error: 'PowerShell is unavailable on this host. Use Advanced: paste path.',
-            supported: false,
-        });
-    }
-    if (result.timedOut) {
-        return emptyResponse({ error: 'Folder picker timed out before a folder was selected.' });
-    }
-    if (result.status !== 0) {
-        const stderr = result.stderr.trim();
-        if (stderr.length > 0) {
-            return emptyResponse({ error: `Folder picker failed: ${stderr}` });
-        }
-        return emptyResponse({ canceled: true });
-    }
-    const picked = result.stdout.trim();
-    if (picked.length === 0)
-        return emptyResponse({ canceled: true });
-    return finalizeWithProbe(picked);
-};
 export const pickFolder = async (options = {}) => {
     const platform = options.platform ?? process.platform;
     const run = options.runCommand ?? defaultRunCommand;
@@ -169,8 +102,12 @@ export const pickFolder = async (options = {}) => {
         return macOsPick(run);
     if (platform === 'linux')
         return linuxPick(run);
-    if (platform === 'win32')
-        return windowsPick(run);
+    if (platform === 'win32') {
+        return emptyResponse({
+            error: 'Native folder picker is disabled on Windows. Use Browse server filesystem or paste path.',
+            supported: false,
+        });
+    }
     return emptyResponse({
         error: 'Native folder picker not supported on this platform. Use Advanced: paste path.',
         supported: false,

package/dist/src/server/fs-sandbox.d.ts

@@ -1,9 +1,11 @@
 /**
- * Root directory the FS-browse API is allowed to reveal. We sandbox to
- * `$HOME` (override via `HIVE_FS_BROWSE_ROOT` for tests). Anything outside
- * this prefix is rejected before readdir/stat even runs.
+ * Root directory the FS-browse API is allowed to reveal when sandboxing is
+ * enabled. Tests and remote/headless setups can set `HIVE_FS_BROWSE_ROOT`.
+ * Normal Windows runs skip this sandbox root and browse from the virtual
+ * "This PC" drive list; POSIX sandboxed browsing defaults to `$HOME`.
  */
 export declare const getFsBrowseRoot: () => string;
+export declare const hasFsBrowseRootOverride: () => boolean;
 /**
  * True when `candidatePath` is `rootPath` itself or a descendant of it.
  * Uses `path.relative` + separator check so Windows back-slashes and drive

package/dist/src/server/fs-sandbox.js

@@ -2,9 +2,10 @@ import { homedir } from 'node:os';
 import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { realpathNative } from './path-canonicalization.js';
 /**
- * Root directory the FS-browse API is allowed to reveal. We sandbox to
- * `$HOME` (override via `HIVE_FS_BROWSE_ROOT` for tests). Anything outside
- * this prefix is rejected before readdir/stat even runs.
+ * Root directory the FS-browse API is allowed to reveal when sandboxing is
+ * enabled. Tests and remote/headless setups can set `HIVE_FS_BROWSE_ROOT`.
+ * Normal Windows runs skip this sandbox root and browse from the virtual
+ * "This PC" drive list; POSIX sandboxed browsing defaults to `$HOME`.
  */
 export const getFsBrowseRoot = () => {
     const override = process.env.HIVE_FS_BROWSE_ROOT;
@@ -16,6 +17,7 @@ export const getFsBrowseRoot = () => {
         return root;
     }
 };
+export const hasFsBrowseRootOverride = () => (process.env.HIVE_FS_BROWSE_ROOT ?? '').length > 0;
 const isResolvedPathWithinRoot = (rootPath, candidatePath) => {
     if (candidatePath === rootPath)
         return true;

package/dist/src/server/hive-team-guidance.js

@@ -1,3 +1,4 @@
+import { BUILTIN_COMMAND_PRESET_CLI_LIST } from './command-preset-defaults.js';
 import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
 import { DEFAULT_WORKFLOW_CLI_POLICY } from './workflow-cli-policy.js';
 /**
@@ -20,7 +21,7 @@ import { DEFAULT_WORKFLOW_CLI_POLICY } from './workflow-cli-policy.js';
 export const buildOrchestratorReminderTail = ({ workflowsEnabled }) => {
     const body = 'You are the Hive Orchestrator. Reply with one of: ' +
         '(a) `team send "<worker-name>" "<task>"` to dispatch — run `team list` first if the roster may have changed since your last view (Hive does not push membership changes; stale names fail). ' +
-        'If no worker fits or the roster is empty, `team spawn <role> [--cli claude|codex|opencode|gemini|hermes]` to create one (add `--ephemeral` for a one-shot), then dispatch; do not ask the user to add workers. ' +
+        `If no worker fits or the roster is empty, \`team spawn <role> [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>]\` to create one (add \`--ephemeral\` for a one-shot), then dispatch; do not ask the user to add workers. ` +
         '(b) `team cancel --dispatch <id> "<reason>"` to close an obsolete dispatch. ' +
         (workflowsEnabled
             ? '(c) `team workflow run --stdin` to fan out across 3+ workers or run a staged review→fix — never a loop of `team send` (no barrier, no UI group, no stop button). (d) plain text to the user. '
@@ -53,10 +54,11 @@ const CORE_ORCHESTRATOR_RULES = [
     'Small, low-risk tasks you can finish in a couple of minutes: do them yourself; do not dispatch for the sake of form. Reach for `team send` when the work needs parallelism, long execution, independent review/test, a dedicated role, or the user explicitly asked for a worker.',
     'If exactly one worker is available, dispatch to it directly with `team send <worker-name> "<task>"` — do not bounce the choice back to the user.',
     'When the user says "have a worker do X", dispatch it with `team send <worker-name> "<task>"`.',
-    'If the roster is empty or lacks the role the task needs, build the team yourself: `team spawn <role> [--name <n>] [--cli claude|codex|opencode|gemini|hermes]`, then immediately dispatch. Do not stop to ask the user to add members — that call is yours.',
+    `If the roster is empty or lacks the role the task needs, build the team yourself: \`team spawn <role> [--name <n>] [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>]\`, then immediately dispatch. Do not stop to ask the user to add members — that call is yours.`,
     '`team spawn` is PERSISTENT by default (a normal member that stays in the workspace); add `--ephemeral` for a one-shot worker that auto-dismisses after its first `team report`. Rule of thumb: will you reuse this role in the next 10 minutes? Yes → persistent; no → `--ephemeral`.',
     'When the user cancels or changes direction on an open dispatch, close it explicitly with `team cancel --dispatch <id> "<reason>"` — do not just say "cancel" in prose.',
     'Each `team send` opens a SEPARATE dispatch with its own pending count and its own required report — it is not a way to tack context onto a dispatch already in flight. Send the same worker twice and it owes you TWO reports; one report closes only one dispatch (the one its `--dispatch <id>` names, or the oldest open one if the flag is omitted), so the other stays open and the worker is pinned on `working`. To change or extend an in-flight task, `team cancel --dispatch <id> "<reason>"` the stale dispatch and re-send the whole task, or wait for the worker to report and dispatch the follow-up after.',
+    'Only orchestrators can add memory directly; workers should report durable findings for the orchestrator or Dream to capture. Search memory before adding: use `team memory search "<query>"` to avoid duplicates. Use `team memory add "<body>"` only for rare, evidence-backed workspace facts, decisions, and pitfalls that should help future Hive agents across sessions. Nothing worth saving is a normal outcome; do not add memory just to prove you used it. Use `team memory forget <memory-id>` only to archive obsolete memory.',
     "Never substitute your CLI's own subagent / workflow tools (e.g. Task / Explore / Workflow / Agent) for Hive workers or Hive workflows — they run inside your CLI process, bypass Hive's PTY fleet, never appear in the UI or `team list`, and the stop button cannot reach them.",
     'In `team list`, `last_pty_line` is raw terminal output (stdout / help / control-sequence noise), NOT a worker\'s report. A real report arrives only as an injected "report from @<name>" / "status from @<name>" system message — treat only those as replies.',
 ];
@@ -96,6 +98,8 @@ const WORKER_RULES = [
     "Do not call `team send`, and do not launch your own CLI's subagent tools to do the work for you — finish it yourself.",
     'When an assigned task is done, blocked, or has failed, you MUST report to the Orchestrator with `team report`.',
     'When you have no active dispatch and only want to report readiness, environment, or status, use `team status "<state>"`.',
+    'Use `team recall "<query>"` when prior team messages or reports may contain useful evidence.',
+    'Use `team memory search "<query>"` to inspect active workspace memory. Include durable findings in `team report`; workers cannot add or forget memory.',
     '`team --help` only prints command syntax — it is NOT a way to report; its output never reaches the Orchestrator. You still owe a real `team report` / `team status` afterward.',
     'If `team report` / `team status` errors, it also prints USAGE — fix the arguments per USAGE and retry; do not use `team --help` as a stand-in for reporting.',
 ];
@@ -121,7 +125,7 @@ Host functions injected into the script: \`agent(prompt, opts)\`,
 \`parallel(thunks)\`, \`pipeline(items, ...stages)\`, \`phase(title)\`,
 \`log(msg)\`, plus the \`args\` global.
 
-\`agent(prompt, opts)\` opts: \`{ agentType?: "coder"|"reviewer"|"tester"|"custom"|<custom-role-name>, cli?: "claude"|"codex"|"opencode"|"gemini"|"hermes", model?: string, outputSchema?: object, label?: string, timeoutMs?: number }\` — other fields are silently ignored. \`agentType\` also accepts the name of a workspace custom role template (case-insensitive); a typo throws rather than silently falling back to coder. \`model\` is passed through to the worker launch config (\`--model <id>\`), so a 100-way fan-out can use a cheap model and the synthesizer a strong one. \`outputSchema\` makes \`agent()\` resolve to a parsed object instead of a string: the worker is told to end its report with a fenced \`\`\`json block whose keys match the schema. On a parse miss it falls back to \`{ text: "<raw report>" }\`, so ALWAYS treat a missing field as the SAFE default (never assume success). The worker auto-dismisses when its \`agent()\` call resolves — you never dismiss it.
+\`agent(prompt, opts)\` opts: \`{ agentType?: "coder"|"reviewer"|"tester"|"custom"|<custom-role-name>, cli?: "${BUILTIN_COMMAND_PRESET_CLI_LIST.replace(/\|/gu, '"|"')}", model?: string, outputSchema?: object, label?: string, timeoutMs?: number }\` — other fields are silently ignored. \`agentType\` also accepts the name of a workspace custom role template (case-insensitive); a typo throws rather than silently falling back to coder. \`model\` is passed through to the worker launch config (\`--model <id>\`), so a 100-way fan-out can use a cheap model and the synthesizer a strong one. \`outputSchema\` makes \`agent()\` resolve to a parsed object instead of a string: the worker is told to end its report with a fenced \`\`\`json block whose keys match the schema. On a parse miss it falls back to \`{ text: "<raw report>" }\`, so ALWAYS treat a missing field as the SAFE default (never assume success). The worker auto-dismisses when its \`agent()\` call resolves — you never dismiss it.
 
 \`parallel()\` takes an array of THUNKS (\`() => agent(...)\`), NOT already-started promises: \`parallel([agent(...), agent(...)])\` degrades to unordered concurrency counted as a single step (a no-op grouping), because the promises already started at construction time. \`pipeline(items, ...stages)\` stages are also functions, shape \`(prev, item, i) => agent(...)\`.
 
@@ -240,7 +244,7 @@ export const buildProtocolDoc = (cliPolicy = DEFAULT_WORKFLOW_CLI_POLICY, flags
         '## You are running inside Hive',
         '',
         'Hive is a multi-CLI-agent workbench. Each agent in this workspace is a',
-        'real CLI process (Claude Code / Codex / OpenCode / Gemini). All',
+        'real CLI process (Antigravity CLI / Claude Code / Codex / OpenCode / Gemini / Hermes / Qwen Code / Cursor CLI / Grok Build). All',
         'inter-agent communication goes through the `team` CLI binary on your',
         'PATH.',
         '',
@@ -252,8 +256,13 @@ export const buildProtocolDoc = (cliPolicy = DEFAULT_WORKFLOW_CLI_POLICY, flags
         '## `team` CLI — orchestrator',
         '',
         '- `team list` — show workspace members and their status',
+        '- `team recall "<query>" [--limit <n>] [--window <n>]` — search prior team messages/reports in this workspace',
+        '- `team memory add "<body>" [--kind fact|preference|decision|pitfall|procedure_ref] [--tag <tag>]` — save durable workspace memory (orchestrator entries become active)',
+        '- `team memory show <memory-id>` — inspect a memory entry and evidence snapshots',
+        '- `team memory search "<query>" [--limit <n>]` — search active workspace memory',
+        '- `team memory forget <memory-id>` — archive obsolete memory (orchestrator only; does not physically delete evidence)',
         '- `team send "<worker-name>" "<task>"` — dispatch to a worker by name (never id)',
-        '- `team spawn <role> [--name <name>] [--cli claude|codex|opencode|gemini|hermes]` — create a PERSISTENT member when none fits (or when the roster is empty)',
+        `- \`team spawn <role> [--name <name>] [--cli <${BUILTIN_COMMAND_PRESET_CLI_LIST}>]\` — create a PERSISTENT member when none fits (or when the roster is empty)`,
         '- `team spawn <role> --ephemeral [other-flags]` — create a one-shot worker that auto-dismisses after its first `team report`',
         '- `team dismiss <worker-name>` — remove an ephemeral worker you spawned',
         '- `team cancel --dispatch <id> "<reason>"` — cancel an obsolete open dispatch',
@@ -261,8 +270,11 @@ export const buildProtocolDoc = (cliPolicy = DEFAULT_WORKFLOW_CLI_POLICY, flags
         '',
         '## `team` CLI — worker',
         '',
+        '- `team recall "<query>" [--limit <n>] [--window <n>]` — search prior team messages/reports in this workspace',
+        '- `team memory show <memory-id>` — inspect a memory entry and evidence snapshots',
+        '- `team memory search "<query>" [--limit <n>]` — search active workspace memory',
         '- `team report "<result>" --dispatch <id>` — report task outcome',
-        '- `team report --stdin --dispatch <id>` — same, body from stdin (pipe content in via your shell — POSIX heredoc, `type file |`, or whatever your environment supports)',
+        '- `team report --stdin --dispatch <id>` — same, body from stdin (pipe content in via your shell — POSIX heredoc, Windows cmd `type file |`, PowerShell `Get-Content -Raw -Encoding utf8 file |`, or portable stdin redirection `< file`)',
         '- `team status "<state>"` — update orchestrator when no dispatch is active',
         '',
         '## Orchestrator rules',