hivehq 2.0.0

package/dist/src/server/dispatch-ledger-store.js

@@ -0,0 +1,241 @@
+import { randomUUID } from 'node:crypto';
+const parseArtifacts = (value) => {
+    if (!value)
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed)
+            ? parsed.filter((artifact) => typeof artifact === 'string')
+            : [];
+    }
+    catch {
+        return [];
+    }
+};
+const toRecord = (row) => ({
+    artifacts: parseArtifacts(row.artifacts),
+    createdAt: row.created_at,
+    deliveredAt: row.delivered_at,
+    fromAgentId: row.from_agent_id,
+    id: row.id,
+    label: row.label ?? null,
+    phase: row.phase ?? null,
+    reportedAt: row.reported_at,
+    reportText: row.report_text,
+    sequence: row.sequence,
+    status: row.status,
+    stepIndex: row.step_index,
+    submittedAt: row.submitted_at,
+    text: row.text,
+    toAgentId: row.to_agent_id,
+    workflowRunId: row.workflow_run_id,
+    workspaceId: row.workspace_id,
+});
+export const createDispatchLedgerStore = (db) => {
+    const createDispatch = (input) => {
+        const record = {
+            artifacts: [],
+            createdAt: Date.now(),
+            deliveredAt: null,
+            fromAgentId: input.fromAgentId ?? null,
+            id: randomUUID(),
+            label: input.label ?? null,
+            phase: input.phase ?? null,
+            reportedAt: null,
+            reportText: null,
+            sequence: null,
+            status: 'queued',
+            stepIndex: input.stepIndex ?? null,
+            submittedAt: null,
+            text: input.text,
+            toAgentId: input.toAgentId,
+            workflowRunId: input.workflowRunId ?? null,
+            workspaceId: input.workspaceId,
+        };
+        db.prepare(`INSERT INTO dispatches (
+        id,
+        workspace_id,
+        from_agent_id,
+        to_agent_id,
+        text,
+        status,
+        created_at,
+        delivered_at,
+        submitted_at,
+        reported_at,
+        report_text,
+        artifacts,
+        workflow_run_id,
+        step_index,
+        phase,
+        label
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(record.id, record.workspaceId, record.fromAgentId, record.toAgentId, record.text, record.status, record.createdAt, record.deliveredAt, record.submittedAt, record.reportedAt, record.reportText, JSON.stringify(record.artifacts), record.workflowRunId, record.stepIndex, record.phase, record.label);
+        return record;
+    };
+    const deleteDispatch = (dispatchId) => {
+        db.prepare('DELETE FROM dispatches WHERE id = ?').run(dispatchId);
+    };
+    const markSubmitted = (dispatchId) => {
+        const submittedAt = Date.now();
+        db.prepare(`UPDATE dispatches
+       SET status = ?, submitted_at = ?
+       WHERE id = ?`).run('submitted', submittedAt, dispatchId);
+    };
+    const findOpenDispatch = (workspaceId, toAgentId, dispatchId) => {
+        if (dispatchId) {
+            const row = db
+                .prepare(`SELECT *
+           FROM dispatches
+           WHERE id = ?
+             AND workspace_id = ?
+             AND to_agent_id = ?
+             AND status IN ('queued', 'submitted')
+           LIMIT 1`)
+                .get(dispatchId, workspaceId, toAgentId);
+            return row ? toRecord(row) : undefined;
+        }
+        const row = db
+            .prepare(`SELECT *
+         FROM dispatches
+         WHERE workspace_id = ?
+           AND to_agent_id = ?
+           AND status IN ('queued', 'submitted')
+         ORDER BY sequence ASC
+         LIMIT 1`)
+            .get(workspaceId, toAgentId);
+        return row ? toRecord(row) : undefined;
+    };
+    const findOpenDispatchById = (workspaceId, dispatchId) => {
+        const row = db
+            .prepare(`SELECT *
+         FROM dispatches
+         WHERE id = ?
+           AND workspace_id = ?
+           AND status IN ('queued', 'submitted')
+         LIMIT 1`)
+            .get(dispatchId, workspaceId);
+        return row ? toRecord(row) : undefined;
+    };
+    const markReportedByWorker = (input) => {
+        const dispatch = findOpenDispatch(input.workspaceId, input.toAgentId, input.dispatchId);
+        if (!dispatch) {
+            return undefined;
+        }
+        const reportedAt = Date.now();
+        db.prepare(`UPDATE dispatches
+       SET status = ?,
+           reported_at = ?,
+           report_text = ?,
+           artifacts = ?
+       WHERE id = ?`).run('reported', reportedAt, input.reportText, JSON.stringify(input.artifacts), dispatch.id);
+        return {
+            ...dispatch,
+            artifacts: input.artifacts,
+            reportedAt,
+            reportText: input.reportText,
+            status: 'reported',
+        };
+    };
+    const markCancelled = (input) => {
+        const dispatch = findOpenDispatchById(input.workspaceId, input.dispatchId);
+        if (!dispatch) {
+            return undefined;
+        }
+        const cancelledAt = Date.now();
+        db.prepare(`UPDATE dispatches
+       SET status = ?,
+           reported_at = ?,
+           report_text = ?
+       WHERE id = ?`).run('cancelled', cancelledAt, input.reason, dispatch.id);
+        return {
+            ...dispatch,
+            reportedAt: cancelledAt,
+            reportText: input.reason,
+            status: 'cancelled',
+        };
+    };
+    const listWorkspaceDispatches = (workspaceId, options = {}) => {
+        const offset = options.offset ?? 0;
+        const limit = options.limit ?? 100;
+        if (options.status) {
+            return db
+                .prepare(`SELECT *
+             FROM dispatches
+             WHERE workspace_id = ?
+               AND status = ?
+             ORDER BY sequence ASC
+             LIMIT ? OFFSET ?`)
+                .all(workspaceId, options.status, limit, offset).map(toRecord);
+        }
+        return db
+            .prepare(`SELECT *
+           FROM dispatches
+           WHERE workspace_id = ?
+           ORDER BY sequence ASC
+           LIMIT ? OFFSET ?`)
+            .all(workspaceId, limit, offset).map(toRecord);
+    };
+    const listOpenDispatchKinds = () => {
+        return db
+            .prepare(`SELECT workspace_id, to_agent_id AS worker_id, 'send' AS type
+           FROM dispatches
+           WHERE status IN ('queued', 'submitted')
+           ORDER BY sequence ASC`)
+            .all();
+    };
+    const deleteWorkspaceDispatches = (workspaceId) => {
+        db.prepare('DELETE FROM dispatches WHERE workspace_id = ?').run(workspaceId);
+    };
+    const deleteWorkerDispatches = (workspaceId, workerId) => {
+        // Preserve workflow-run dispatch history (`workflow_run_id IS NOT NULL`)
+        // so the UI's run-detail timeline can still show what each ephemeral
+        // worker did after the worker itself is dismissed. Orchestrator-issued
+        // dispatches are tied to the worker identity and are dropped with it.
+        db.prepare(`DELETE FROM dispatches
+       WHERE workspace_id = ? AND to_agent_id = ? AND workflow_run_id IS NULL`).run(workspaceId, workerId);
+    };
+    // Every dispatch fired by a workflow run carries the run id (M1-B added the
+    // column; M2-C plumbs it through). This is the timeline query the UI uses to
+    // explode a run row into per-worker activity.
+    const listWorkflowRunDispatches = (runId) => {
+        const rows = db
+            .prepare('SELECT * FROM dispatches WHERE workflow_run_id = ? ORDER BY sequence, created_at')
+            .all(runId);
+        return rows.map(toRecord);
+    };
+    // Open dispatch ids tied to a workflow run — drives the runner's stop path
+    // (each id gets a notifyCancel so the runner's await rejects).
+    const listOpenDispatchIdsForRun = (runId) => db
+        .prepare(`SELECT id FROM dispatches
+           WHERE workflow_run_id = ? AND status IN ('queued', 'submitted')`)
+        .all(runId).map((row) => row.id);
+    // Open workflow-tagged dispatches addressed to a specific worker. Drives the
+    // PTY-exit cancel path (TIER 1 #1): when a workflow-spawned worker dies
+    // without calling `team report`, the runner's `awaitReport` would otherwise
+    // hang for DEFAULT_TIMEOUT_MS (10 min). The exit handler enumerates these
+    // and `notifyCancel`s each so the surrounding `agent()`/`parallel`/`pipeline`
+    // sees an immediate reject.
+    const listOpenWorkflowDispatchesForWorker = (workspaceId, workerId) => db
+        .prepare(`SELECT id, workflow_run_id FROM dispatches
+           WHERE workspace_id = ?
+             AND to_agent_id = ?
+             AND workflow_run_id IS NOT NULL
+             AND status IN ('queued', 'submitted')`)
+        .all(workspaceId, workerId).map((row) => ({ dispatchId: row.id, runId: row.workflow_run_id }));
+    return {
+        createDispatch,
+        deleteDispatch,
+        deleteWorkerDispatches,
+        deleteWorkspaceDispatches,
+        findOpenDispatch,
+        findOpenDispatchById,
+        listOpenDispatchKinds,
+        listOpenDispatchIdsForRun,
+        listOpenWorkflowDispatchesForWorker,
+        listWorkflowRunDispatches,
+        listWorkspaceDispatches,
+        markCancelled,
+        markReportedByWorker,
+        markSubmitted,
+    };
+};

package/dist/src/server/env-sync-message.d.ts

@@ -0,0 +1,9 @@
+import type { AgentSummary, WorkspaceSummary } from '../shared/types.js';
+import type { RecoveryMessage } from './message-log-store.js';
+export declare const buildEnvSyncMessage: ({ agent, tasksContent, workers, workspace, restartWindowMessages, }: {
+    agent: AgentSummary;
+    tasksContent: string;
+    workers: AgentSummary[];
+    workspace: WorkspaceSummary;
+    restartWindowMessages: RecoveryMessage[];
+}) => string;

package/dist/src/server/env-sync-message.js

@@ -0,0 +1,29 @@
+import { getHiveTeamRules } from './hive-team-guidance.js';
+import { wrapSystemMessage } from './system-message.js';
+import { TASKS_RELATIVE_PATH } from './tasks-file.js';
+const TASKS_HEAD_LIMIT = 1024;
+const formatWorkers = (workers) => {
+    if (workers.length === 0)
+        return ['- (no other workers)'];
+    return workers.map((worker) => `- ${worker.name} (${worker.role}, ${worker.status}, pending_task_count: ${worker.pendingTaskCount})`);
+};
+const formatRestartWindow = (messages) => {
+    const sends = messages.filter((message) => {
+        return message.type === 'send';
+    });
+    if (sends.length === 0)
+        return ['- no new dispatches during the restart'];
+    return sends.slice(-5).map((message) => `- send -> ${message.to}: ${message.text}`);
+};
+export const buildEnvSyncMessage = ({ agent, tasksContent, workers, workspace, restartWindowMessages, }) => wrapSystemMessage([
+    'Hive just restarted you. Environment changes during the restart:',
+    `- Current workspace: ${workspace.name}`,
+    '- Existing workers:',
+    ...formatWorkers(workers),
+    `- Current ${TASKS_RELATIVE_PATH} contents:`,
+    tasksContent.slice(0, TASKS_HEAD_LIMIT) || '(empty)',
+    ...formatRestartWindow(restartWindowMessages),
+    agent.role === 'orchestrator' ? '- Hive worker dispatch rules:' : '- Hive worker boundaries:',
+    ...getHiveTeamRules(agent).map((rule) => `  - ${rule}`),
+    `Continue. If unsure, run team list / Read ${TASKS_RELATIVE_PATH} to self-check, or ask the user.`,
+].join('\n'));

package/dist/src/server/feature-flags.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Every experimental feature flag resolved into one snapshot.
+ *
+ * Threading this bag through the prompt-build call graph — instead of one
+ * `getX` accessor per flag — is the whole point of this module: a new flag adds
+ * a field here and is read at the one site that needs it, without touching any
+ * of the carriers in between (agent-runtime → run-starter / restart-policy /
+ * tasks-watcher → the pure builders in hive-team-guidance).
+ *
+ * Each flag keeps its own storage semantics and doc in its own file
+ * ([[workflow-feature]], [[team-autostaff]]); this module only composes them.
+ */
+export interface FeatureFlags {
+    /** Workflow runtime — `team workflow`, the scheduler, the Drawer, and the
+     *  orchestrator guidance that teaches them. Default OFF. */
+    workflowsEnabled: boolean;
+    /** Auto-staff orchestrator guidance — size the team to the task up front
+     *  rather than one worker at a time. Default ON. */
+    autostaffEnabled: boolean;
+}
+/**
+ * Conservative all-off snapshot. Use as the parameter default wherever a
+ * builder is called without flags — it preserves the per-flag `= false`
+ * defaults the builders carried before this registry existed.
+ *
+ * This is NOT the storage default: an ABSENT `team.autostaff` key reads back
+ * ON via {@link readFeatureFlags}. Only an OMITTED argument falls back to off,
+ * which is the safe choice (never inject guidance for a flag nobody resolved).
+ */
+export declare const FEATURE_FLAGS_ALL_OFF: FeatureFlags;
+interface AppStateReader {
+    getAppState: (key: string) => {
+        value: string | null;
+    } | undefined;
+}
+/**
+ * Read every flag from app_state into one snapshot, each with its own storage
+ * default (workflows off-when-absent, auto-staff on-when-absent). Called fresh
+ * each time so a Settings toggle takes effect without restarting the runtime.
+ */
+export declare const readFeatureFlags: (settings: AppStateReader) => FeatureFlags;
+export {};

package/dist/src/server/feature-flags.js

@@ -0,0 +1,24 @@
+import { AUTOSTAFF_ENABLED_KEY, readAutostaffEnabled } from './team-autostaff.js';
+import { readWorkflowEnabled, WORKFLOW_ENABLED_KEY } from './workflow-feature.js';
+/**
+ * Conservative all-off snapshot. Use as the parameter default wherever a
+ * builder is called without flags — it preserves the per-flag `= false`
+ * defaults the builders carried before this registry existed.
+ *
+ * This is NOT the storage default: an ABSENT `team.autostaff` key reads back
+ * ON via {@link readFeatureFlags}. Only an OMITTED argument falls back to off,
+ * which is the safe choice (never inject guidance for a flag nobody resolved).
+ */
+export const FEATURE_FLAGS_ALL_OFF = {
+    workflowsEnabled: false,
+    autostaffEnabled: false,
+};
+/**
+ * Read every flag from app_state into one snapshot, each with its own storage
+ * default (workflows off-when-absent, auto-staff on-when-absent). Called fresh
+ * each time so a Settings toggle takes effect without restarting the runtime.
+ */
+export const readFeatureFlags = (settings) => ({
+    workflowsEnabled: readWorkflowEnabled(settings.getAppState(WORKFLOW_ENABLED_KEY)?.value ?? null),
+    autostaffEnabled: readAutostaffEnabled(settings.getAppState(AUTOSTAFF_ENABLED_KEY)?.value ?? null),
+});

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

@@ -0,0 +1,40 @@
+export interface FsBrowseEntry {
+    is_dir: true;
+    is_git_repository: boolean;
+    name: string;
+    path: string;
+}
+export interface FsBrowseResponse {
+    current_path: string;
+    entries: FsBrowseEntry[];
+    error: string | null;
+    ok: boolean;
+    parent_path: string | null;
+    root_path: string;
+}
+export interface FsProbeResponse {
+    current_branch: string | null;
+    exists: boolean;
+    is_dir: boolean;
+    is_git_repository: boolean;
+    ok: boolean;
+    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 {
+    /**
+     * When `true` (default), probe rejects paths outside `$HOME` so the
+     * in-browser FS tree can't be tricked into revealing arbitrary disk
+     * contents via a hand-crafted path string.
+     *
+     * When `false`, the sandbox check is skipped — callers who already
+     * have a user-authorized path (e.g. paths returned by the OS-native
+     * folder picker) must use this so a Windows user picking `D:\projects`
+     * isn't rejected just because their `$HOME` lives on `C:`.
+     */
+    enforceSandbox?: boolean;
+}
+export declare const probeDirectory: (requestedPath: string, options?: ProbeDirectoryOptions) => Promise<FsProbeResponse>;

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

@@ -0,0 +1,306 @@
+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
+ * failure paths — System Volume Information / $Recycle.Bin (EACCES),
+ * dangling junctions (EBUSY / EINVAL), paths past MAX_PATH on systems
+ * without long-path support (ENAMETOOLONG) — each get a recognizable
+ * prefix so the UI does not just show the raw errno.
+ */
+const formatFilesystemError = (error) => {
+    if (!(error instanceof Error))
+        return 'Failed to read directory';
+    const code = error.code;
+    if (code === 'EACCES' || code === 'EPERM') {
+        return `Permission denied: ${error.message}`;
+    }
+    if (code === 'ENAMETOOLONG') {
+        return `Path is too long for this filesystem: ${error.message}`;
+    }
+    if (code === 'EBUSY' || code === 'EINVAL') {
+        return `Path is busy or unavailable: ${error.message}`;
+    }
+    return error.message;
+};
+const resolveGitDirPath = async (repoPath) => {
+    const dotGitPath = resolve(repoPath, '.git');
+    try {
+        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 null;
+    }
+};
+const detectGitRepository = async (entryPath) => (await resolveGitDirPath(entryPath)) !== null;
+const readCurrentBranch = async (repoPath) => {
+    const gitDirPath = await resolveGitDirPath(repoPath);
+    if (!gitDirPath)
+        return null;
+    try {
+        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 = sanitizePastedPath(requestedPath);
+    const candidate = trimmed.length === 0 ? rootPath : resolve(rootPath, trimmed);
+    if (!isPathWithinRoot(rootPath, candidate)) {
+        return {
+            current_path: rootPath,
+            entries: [],
+            error: 'Access denied: path is outside the browse root.',
+            ok: false,
+            parent_path: null,
+            root_path: rootPath,
+        };
+    }
+    let dirStat;
+    try {
+        dirStat = await stat(candidate);
+    }
+    catch (error) {
+        return {
+            current_path: candidate,
+            entries: [],
+            error: formatFilesystemError(error),
+            ok: false,
+            parent_path: getSandboxParentPath(rootPath, candidate),
+            root_path: rootPath,
+        };
+    }
+    if (!dirStat.isDirectory()) {
+        return {
+            current_path: candidate,
+            entries: [],
+            error: 'The specified path is not a directory.',
+            ok: false,
+            parent_path: getSandboxParentPath(rootPath, candidate),
+            root_path: rootPath,
+        };
+    }
+    let rawEntries;
+    try {
+        rawEntries = await readdir(candidate, { withFileTypes: true });
+    }
+    catch (error) {
+        // Windows hits this for System Volume Information, $Recycle.Bin,
+        // broken junctions, and long paths on hosts without long-path
+        // support. Returning ok:false lets the picker surface a readable
+        // message instead of crashing the HTTP handler.
+        return {
+            current_path: candidate,
+            entries: [],
+            error: formatFilesystemError(error),
+            ok: false,
+            parent_path: getSandboxParentPath(rootPath, candidate),
+            root_path: rootPath,
+        };
+    }
+    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 = resolve(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: 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 && !fullWindowsBrowse ? resolve(rootPath, requested) : resolve(requested);
+    const base = {
+        current_branch: null,
+        exists: false,
+        is_dir: false,
+        is_git_repository: false,
+        ok: false,
+        path: candidate,
+        suggested_name: getSuggestedWorkspaceNameFromPath(candidate),
+    };
+    if (enforceSandbox && !fullWindowsBrowse && !isPathWithinRoot(rootPath, candidate)) {
+        return base;
+    }
+    try {
+        const info = await stat(candidate);
+        if (!info.isDirectory()) {
+            return { ...base, exists: true, is_dir: false, ok: true };
+        }
+        const is_git_repository = await detectGitRepository(candidate);
+        const current_branch = is_git_repository ? await readCurrentBranch(candidate) : null;
+        return {
+            current_branch,
+            exists: true,
+            is_dir: true,
+            is_git_repository,
+            ok: true,
+            path: candidate,
+            suggested_name: base.suggested_name,
+        };
+    }
+    catch {
+        return base;
+    }
+};