@tt-a1i/hive 1.7.0 → 2.0.2

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

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

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

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

package/dist/src/server/terminal-input-profile.d.ts

@@ -1,5 +1,5 @@
 import type { AgentLaunchConfigInput } from './agent-run-store.js';
-export type TerminalInputProfile = 'default' | 'opencode';
+export type TerminalInputProfile = 'codex' | 'default' | 'grok' | 'opencode';
 export interface TerminalRunSummary {
     agent_id: string;
     agent_name: string;

package/dist/src/server/terminal-input-profile.js

@@ -1,9 +1,27 @@
 import { normalizeExecutableToken } from './startup-command-parser.js';
+const isCodexNpmEntrypoint = (arg) => {
+    if (!arg)
+        return false;
+    const normalized = arg.replace(/\\/gu, '/');
+    return /(?:^|\/)@openai\/codex\/bin\/codex\.js$/iu.test(normalized);
+};
 export const resolveTerminalInputProfile = (config) => {
     if (!config)
         return 'default';
+    if (config.commandPresetId === 'codex')
+        return 'codex';
+    if (config.commandPresetId === 'grok')
+        return 'grok';
     if (config.commandPresetId === 'opencode')
         return 'opencode';
+    if (config.sessionIdCapture?.source === 'codex_session_jsonl_dir')
+        return 'codex';
     const executable = normalizeExecutableToken(config.interactiveCommand) ?? normalizeExecutableToken(config.command);
+    if (executable === 'codex')
+        return 'codex';
+    if (executable === 'grok')
+        return 'grok';
+    if (isCodexNpmEntrypoint(config.args?.[0]))
+        return 'codex';
     return executable === 'opencode' ? 'opencode' : 'default';
 };

package/dist/src/server/terminal-ws-server.js

@@ -36,6 +36,12 @@ export const createTerminalWebSocketServer = (server, store, tasksFileService) =
         tasksWss.publish(workspaceId, content);
     });
     const validateUpgradeSession = (request) => {
+        // Tunnel-originated upgrades carry the per-boot secret (invariant 2). A
+        // request with no secret header falls straight to the cookie path, so
+        // browser behavior is unchanged. getLocalRequestRejection still runs in
+        // front (loopback Host), so this is reachable only from 127.0.0.1.
+        if (store.authorizeRemoteTunnelRequest(request))
+            return true;
         const cookieHeader = Array.isArray(request.headers.cookie)
             ? request.headers.cookie.join('; ')
             : request.headers.cookie;

package/dist/src/server/ui-auth-helpers.d.ts

@@ -1,4 +1,4 @@
 import type { IncomingMessage } from 'node:http';
 import type { RuntimeStore } from './runtime-store.js';
 export declare const readCookie: (cookieHeader: string | undefined, name: string) => string | undefined;
-export declare const requireUiTokenFromRequest: (request: IncomingMessage, validateUiToken: RuntimeStore["validateUiToken"]) => void;
+export declare const requireUiTokenFromRequest: (request: IncomingMessage, validateUiToken: RuntimeStore["validateUiToken"], authorizeTunnel?: RuntimeStore["authorizeRemoteTunnelRequest"]) => void;

package/dist/src/server/ui-auth-helpers.js

@@ -11,7 +11,13 @@ export const readCookie = (cookieHeader, name) => {
     }
     return undefined;
 };
-export const requireUiTokenFromRequest = (request, validateUiToken) => {
+export const requireUiTokenFromRequest = (request, validateUiToken, authorizeTunnel) => {
+    // Tunnel-originated requests carry the per-boot secret and short-circuit here
+    // (invariant 2). A request with no secret header — every browser, every
+    // existing test — gets authorizeTunnel === false and falls straight to the
+    // cookie path, so cookie behavior is byte-identical (invariant 4).
+    if (authorizeTunnel?.(request))
+        return;
     const cookieHeader = Array.isArray(request.headers.cookie)
         ? request.headers.cookie.join('; ')
         : request.headers.cookie;

package/dist/src/server/ui-auth.d.ts

@@ -1,5 +1,8 @@
+import type { IncomingMessage } from 'node:http';
 export interface UiAuth {
     getToken: () => string;
     validate: (token: string | undefined) => boolean;
+    isTunnelRequest: (request: IncomingMessage) => boolean;
+    getTunnelSecret: () => string;
 }
 export declare const createUiAuth: () => UiAuth;

package/dist/src/server/ui-auth.js

@@ -1,6 +1,11 @@
-import { randomUUID } from 'node:crypto';
+import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
+import { HIVE_REMOTE_SECRET_HEADER } from './remote-loopback-auth.js';
 export const createUiAuth = () => {
     const token = randomUUID();
+    // 32 bytes of CSPRNG entropy, fresh every boot. base64url so it travels as a
+    // clean header value. Held only in this closure.
+    const tunnelSecret = randomBytes(32).toString('base64url');
+    const expected = Buffer.from(tunnelSecret);
     return {
         getToken() {
             return token;
@@ -8,5 +13,20 @@ export const createUiAuth = () => {
         validate(input) {
             return input === token;
         },
+        isTunnelRequest(request) {
+            const raw = request.headers[HIVE_REMOTE_SECRET_HEADER];
+            const got = Array.isArray(raw) ? raw[0] : raw;
+            if (typeof got !== 'string' || got.length === 0)
+                return false;
+            const candidate = Buffer.from(got);
+            // length check first: timingSafeEqual throws on mismatched lengths, and a
+            // length difference is not secret anyway.
+            if (candidate.length !== expected.length)
+                return false;
+            return timingSafeEqual(candidate, expected);
+        },
+        getTunnelSecret() {
+            return tunnelSecret;
+        },
     };
 };

package/dist/src/server/workflow-cli-policy.d.ts

@@ -12,9 +12,8 @@
  * unrestricted and defaults to `claude` — i.e. exactly the old behavior, so
  * upgrading without configuring anything changes nothing.
  */
-/** Canonical CLI set — mirrors the built-in command preset ids
- *  (see command-preset-defaults.ts). The allowlist is a subset of these. */
-export declare const CANONICAL_WORKFLOW_CLIS: readonly ["claude", "codex", "opencode", "gemini", "hermes"];
+/** Canonical CLI set — mirrors the built-in command preset ids. The allowlist is a subset of these. */
+export declare const CANONICAL_WORKFLOW_CLIS: readonly ["claude", "codex", "opencode", "gemini", "hermes", "qwen", "agy", "cursor", "grok"];
 export type WorkflowCli = (typeof CANONICAL_WORKFLOW_CLIS)[number];
 export declare const WORKFLOW_CLI_POLICY_KEY = "workflow.cli-policy";
 export interface WorkflowCliPolicy {

package/dist/src/server/workflow-cli-policy.js

@@ -12,9 +12,9 @@
  * unrestricted and defaults to `claude` — i.e. exactly the old behavior, so
  * upgrading without configuring anything changes nothing.
  */
-/** Canonical CLI set — mirrors the built-in command preset ids
- *  (see command-preset-defaults.ts). The allowlist is a subset of these. */
-export const CANONICAL_WORKFLOW_CLIS = ['claude', 'codex', 'opencode', 'gemini', 'hermes'];
+import { BUILTIN_COMMAND_PRESET_IDS } from './command-preset-defaults.js';
+/** Canonical CLI set — mirrors the built-in command preset ids. The allowlist is a subset of these. */
+export const CANONICAL_WORKFLOW_CLIS = BUILTIN_COMMAND_PRESET_IDS;
 export const WORKFLOW_CLI_POLICY_KEY = 'workflow.cli-policy';
 export const DEFAULT_WORKFLOW_CLI_POLICY = {
     default: 'claude',

package/dist/src/server/workflow-runner.d.ts

@@ -134,6 +134,7 @@ export declare const createWorkflowRunner: (deps: {
      *  the user's configured default, and an explicit `cli` outside the
      *  allowlist fails the call with a clear, fixable error. */
     getWorkflowCliPolicy: () => WorkflowCliPolicy;
+    resolveCliLaunchConfig: (cli: string) => AgentLaunchConfigInput | undefined;
     /** Called when a run reaches a terminal state (completed/failed/stopped).
      *  The runtime uses this to inject a `<hive-system-reminder>` into the
      *  triggering agent's PTY so the orchestrator picks the result back up,

package/dist/src/server/workflow-runner.js

@@ -19,7 +19,7 @@ const isBuiltInWorkerRole = (value) => BUILT_IN_WORKER_ROLES.has(value);
 const buildModelArgs = (_cli, model) => {
     if (!model?.trim())
         return [];
-    /* All supported CLIs (claude / codex / opencode / gemini / hermes) accept
+    /* All supported CLIs accept
        `--model <id>` as a positional flag. Keeping the mapping centralised
        here so future CLI quirks (e.g. opencode wanting `-m` instead) can
        be patched without touching the runner body. */
@@ -34,7 +34,7 @@ const toNestedWorkflowFilename = (scriptName) => {
     return filename;
 };
 export const createWorkflowRunner = (deps) => {
-    const { store, workflowRunStore, awaiter, dispatchPort, resolveWorkspacePath, roleTemplateResolver, logStore, getWorkflowCliPolicy, } = deps;
+    const { store, workflowRunStore, awaiter, dispatchPort, resolveWorkspacePath, roleTemplateResolver, logStore, resolveCliLaunchConfig, getWorkflowCliPolicy, } = deps;
     const stoppedRuns = new Set();
     // In-memory map: runId → triggering agent. Lost on restart; the spec already
     // doesn't auto-resume interrupted runs, so this is consistent.
@@ -139,15 +139,20 @@ export const createWorkflowRunner = (deps) => {
                 });
             }
             const name = opts.label ?? `${requestedType}-${myStep}-${randomUUID()}`;
+            const baseLaunchConfig = resolveCliLaunchConfig(command) ?? { command, args: [] };
             /* Model flag goes AFTER the template's own args so an explicit
                opts.model overrides any --model the template baked in. */
-            const launchArgs = [...templateArgs, ...buildModelArgs(command, opts.model)];
+            const launchArgs = [
+                ...(baseLaunchConfig.args ?? []),
+                ...templateArgs,
+                ...buildModelArgs(baseLaunchConfig.command, opts.model),
+            ];
             // TIER 2 #2 — semaphore. Holding the slot across the full
             // dispatch+await means a parallel(100) fan-out gets paced at
             // min(16, cores-2) concurrent PTYs instead of 100 simultaneous
             // process spawns.
             const releaseSlot = await acquireSlot();
-            const worker = store.addWorkerWithLaunch(workspaceId, { name, role, ephemeral: true, spawnedBy: 'workflow' }, { command, args: launchArgs });
+            const worker = store.addWorkerWithLaunch(workspaceId, { name, role, ephemeral: true, spawnedBy: 'workflow' }, { ...baseLaunchConfig, args: launchArgs });
             spawnedWorkers.push(worker.id);
             try {
                 await store.startAgent(workspaceId, worker.id, { hivePort });

package/dist/src/server/workspace-path-validation.js

@@ -1,11 +1,15 @@
 import { statSync } from 'node:fs';
+import { sanitizePastedPath } from '../shared/path-input.js';
 import { BadRequestError } from './http-errors.js';
 import { realpathNative } from './path-canonicalization.js';
 export const validateWorkspacePath = (path) => {
-    if (typeof path !== 'string' || path.trim().length === 0) {
+    if (typeof path !== 'string') {
+        throw new BadRequestError('Workspace path is required');
+    }
+    const candidate = sanitizePastedPath(path);
+    if (candidate.length === 0) {
         throw new BadRequestError('Workspace path is required');
     }
-    const candidate = path.trim();
     let resolved;
     try {
         resolved = realpathNative(candidate);

package/dist/src/server/workspace-store.d.ts

@@ -2,4 +2,4 @@ import type { Database } from 'better-sqlite3';
 import type { WorkerInput, WorkspaceRecord, WorkspaceStore } from './workspace-store-contract.js';
 import { type MessageKindRecord } from './workspace-store-support.js';
 export type { WorkerInput, WorkspaceRecord, WorkspaceStore };
-export declare const createWorkspaceStore: (db: Database, messageKinds: MessageKindRecord[]) => WorkspaceStore;
+export declare const createWorkspaceStore: (db: Database, listOpenDispatchKinds: () => MessageKindRecord[]) => WorkspaceStore;

package/dist/src/server/workspace-store.js

@@ -4,7 +4,7 @@ import { sameFilesystemPath } from './path-canonicalization.js';
 import { getDefaultRoleDescription } from './role-templates.js';
 import { hydrateWorkspaceFromDb, seedWorkspacesFromDb } from './workspace-store-hydration.js';
 import { getAgentRecord, getWorkerByNameRecord, getWorkerRecord, markAgentStarted, markAgentStopped, markTaskCancelled, markTaskDispatched, markTaskReported, } from './workspace-store-mutations.js';
-import { createOrchestrator, createWorkflowAgent, isWorkerAgent, } from './workspace-store-support.js';
+import { createOrchestrator, createWorkflowAgent, getStatusFromPendingCount, isWorkerAgent, } from './workspace-store-support.js';
 const normalizeWorkerName = (name) => {
     const trimmed = name.trim();
     if (!trimmed)
@@ -13,14 +13,31 @@ const normalizeWorkerName = (name) => {
         throw new Error('Worker name must be 64 characters or fewer');
     return trimmed;
 };
-export const createWorkspaceStore = (db, messageKinds) => {
+export const createWorkspaceStore = (db, listOpenDispatchKinds) => {
     const workspaces = new Map();
-    seedWorkspacesFromDb(db, workspaces, messageKinds);
+    seedWorkspacesFromDb(db, workspaces, listOpenDispatchKinds());
+    const syncPendingFromDispatchLedger = (workspace) => {
+        const counts = new Map();
+        for (const item of listOpenDispatchKinds()) {
+            if (item.workspace_id !== workspace.summary.id)
+                continue;
+            counts.set(item.worker_id, (counts.get(item.worker_id) ?? 0) + 1);
+        }
+        for (const agent of workspace.agents) {
+            if (!isWorkerAgent(agent))
+                continue;
+            const pendingTaskCount = counts.get(agent.id) ?? 0;
+            agent.pendingTaskCount = pendingTaskCount;
+            if (agent.status !== 'stopped')
+                agent.status = getStatusFromPendingCount(pendingTaskCount);
+        }
+    };
     const getWorkspace = (workspaceId) => {
-        hydrateWorkspaceFromDb(db, workspaces, messageKinds, workspaceId);
+        hydrateWorkspaceFromDb(db, workspaces, listOpenDispatchKinds(), workspaceId);
         const workspace = workspaces.get(workspaceId);
         if (!workspace)
             throw new Error(`Workspace not found: ${workspaceId}`);
+        syncPendingFromDispatchLedger(workspace);
         return workspace;
     };
     return {
@@ -90,11 +107,11 @@ export const createWorkspaceStore = (db, messageKinds) => {
             workspaces.delete(workspaceId);
         },
         renameWorker(workspaceId, workerId, name) {
+            const workspace = getWorkspace(workspaceId);
             const worker = getWorkerRecord(workspaces, workspaceId, workerId);
             const trimmed = normalizeWorkerName(name);
             if (trimmed === worker.name)
                 return worker;
-            const workspace = getWorkspace(workspaceId);
             if (workspace.agents.some((agent) => agent.id !== workerId && agent.name === trimmed && isWorkerAgent(agent))) {
                 throw new ConflictError(`Worker name already exists: ${trimmed}`);
             }
@@ -114,12 +131,21 @@ export const createWorkspaceStore = (db, messageKinds) => {
             })();
             workspace.agents = workspace.agents.filter((agent) => agent.id !== workerId);
         },
-        getAgent: (workspaceId, agentId) => getAgentRecord(workspaces, workspaceId, agentId),
-        getWorker: (workspaceId, workerId) => getWorkerRecord(workspaces, workspaceId, workerId),
-        getWorkerByName: (workspaceId, workerName) => getWorkerByNameRecord(workspaces, workspaceId, workerName),
+        getAgent(workspaceId, agentId) {
+            getWorkspace(workspaceId);
+            return getAgentRecord(workspaces, workspaceId, agentId);
+        },
+        getWorker(workspaceId, workerId) {
+            getWorkspace(workspaceId);
+            return getWorkerRecord(workspaces, workspaceId, workerId);
+        },
+        getWorkerByName(workspaceId, workerName) {
+            getWorkspace(workspaceId);
+            return getWorkerByNameRecord(workspaces, workspaceId, workerName);
+        },
         getWorkspaceSnapshot: getWorkspace,
         hasAgent(workspaceId, agentId) {
-            hydrateWorkspaceFromDb(db, workspaces, messageKinds, workspaceId);
+            hydrateWorkspaceFromDb(db, workspaces, listOpenDispatchKinds(), workspaceId);
             return workspaces.get(workspaceId)?.agents.some((agent) => agent.id === agentId) ?? false;
         },
         listWorkers(workspaceId) {

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

@@ -0,0 +1 @@
+export declare const WINDOWS_DRIVES_ROOT = "hive://windows-drives";

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

@@ -0,0 +1 @@
+export const WINDOWS_DRIVES_ROOT = 'hive://windows-drives';

package/dist/src/shared/path-input.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Normalize a path pasted into a workspace input. Windows Explorer's
+ * "Copy as path" wraps the value in double quotes (e.g. `"C:\\Users\\me"`);
+ * shell-style paste from a terminal sometimes uses single quotes. Resolving
+ * the quoted form with `realpathSync` fails even though the unquoted path is
+ * valid.
+ *
+ * The heuristic is intentionally conservative: only a symmetric outer pair
+ * of identical quote characters is removed. Asymmetric or interior quotes
+ * survive so legitimately quote-containing paths still reach the server.
+ */
+export declare const sanitizePastedPath: (raw: string) => string;

package/dist/src/shared/path-input.js

@@ -0,0 +1,22 @@
+/**
+ * Normalize a path pasted into a workspace input. Windows Explorer's
+ * "Copy as path" wraps the value in double quotes (e.g. `"C:\\Users\\me"`);
+ * shell-style paste from a terminal sometimes uses single quotes. Resolving
+ * the quoted form with `realpathSync` fails even though the unquoted path is
+ * valid.
+ *
+ * The heuristic is intentionally conservative: only a symmetric outer pair
+ * of identical quote characters is removed. Asymmetric or interior quotes
+ * survive so legitimately quote-containing paths still reach the server.
+ */
+export const sanitizePastedPath = (raw) => {
+    const trimmed = raw.trim();
+    if (trimmed.length < 2)
+        return trimmed;
+    const first = trimmed[0];
+    const last = trimmed[trimmed.length - 1];
+    if ((first === '"' || first === "'") && first === last) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+};

package/dist/src/shared/remote-bridge-routing.d.ts

@@ -0,0 +1,19 @@
+import { type StreamMeta } from './remote-protocol.js';
+export declare const ALLOWED_HTTP_PREFIX: "/api/";
+export type BridgeRejectReason = 'path_not_whitelisted' | 'path_not_canonical' | 'path_denied' | 'bad_method' | 'malformed_meta';
+export type RouteDecision = {
+    ok: true;
+    transport: 'http';
+    method: string;
+    path: string;
+} | {
+    ok: true;
+    transport: 'ws';
+    path: string;
+    query?: [string, string][];
+} | {
+    ok: false;
+    reason: BridgeRejectReason;
+};
+export declare function isCanonicalPath(path: string): boolean;
+export declare function classifyOpen(meta: StreamMeta): RouteDecision;