@tt-a1i/hive 2.1.1 → 2.1.4

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

@@ -45,6 +45,7 @@ export const formatNoOpenDispatchError = (workerName, requestedDispatchId, openD
         'if you have progress or standby info to share, use `team status "<state>"` instead.');
 };
 const reportForwardErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+const isPromptReadinessTimeoutError = (error) => error instanceof Error && /^Timed out waiting for .+ prompt readiness:/u.test(error.message);
 const buildPendingWarning = (workerName, pendingTaskCount, action) => pendingTaskCount > 0
     ? `Hive recorded the ${action}, but ${workerName} still has ${pendingTaskCount} open dispatch${pendingTaskCount === 1 ? '' : 'es'}. ` +
         'A worker stays working until every dispatch is closed with `team report --dispatch <id>` or `team cancel --dispatch <id>`.'
@@ -72,8 +73,9 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
         }
     };
     const ensureWorkerRun = async (workspaceId, workerId, hivePort) => {
-        if (agentRuntime.getActiveRunByAgentId(workspaceId, workerId)) {
-            return;
+        const activeRun = agentRuntime.getActiveRunByAgentId(workspaceId, workerId);
+        if (activeRun) {
+            return activeRun;
         }
         const config = agentRuntime.peekAgentLaunchConfig(workspaceId, workerId);
         if (!config) {
@@ -86,6 +88,7 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                 workspaceStore.markAgentStopped(workspaceId, workerId);
                 throw new ConflictError(`${config.command} failed to start`);
             }
+            return run;
         }
         catch (error) {
             workspaceStore.markAgentStopped(workspaceId, workerId);
@@ -191,6 +194,9 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             item.status === 'queued' &&
             item.workflowRunId === null &&
             item.fromAgentId !== getWorkflowAgentId(workspaceId) &&
+            (options.createdBeforeMs === undefined || item.createdAt < options.createdBeforeMs) &&
+            (options.beforeSequence === undefined ||
+                (item.sequence !== null && item.sequence < options.beforeSequence)) &&
             item.id !== options.excludeDispatchId);
         if (queued.length === 0)
             return;
@@ -206,10 +212,20 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
            to parked for the next start instead of being cancelled: one bad start
            must not destroy parked work. If the row is no longer 'submitted'
            (reported/cancelled meanwhile), the repark loses and we leave it be. */
-        const failDispatch = (dispatchId, error) => {
+        const failDispatch = (item, error) => {
+            if (isPromptReadinessTimeoutError(error)) {
+                try {
+                    cancelUndeliveredDispatch(workspaceId, workerId, item.id, reportForwardErrorMessage(error), item.workflowRunId ?? undefined, item.fromAgentId ?? undefined);
+                }
+                catch (cancelError) {
+                    console.error('[hive] swallowed:teamReplay.cancelUndelivered', cancelError);
+                }
+                console.error('[hive] swallowed:teamReplay.writePrompt', error);
+                return;
+            }
             try {
-                if (!reparkClaimedDispatch(dispatchId)) {
-                    console.error('[hive] swallowed:teamReplay.reparkLost', dispatchId);
+                if (!reparkClaimedDispatch(item.id)) {
+                    console.error('[hive] swallowed:teamReplay.reparkLost', item.id);
                 }
             }
             catch (reparkError) {
@@ -231,10 +247,10 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             }
             try {
                 const writePrompt = agentRuntime.writeSendPrompt(workspaceId, workerId, item.id, senderName, worker.description, item.text);
-                void writePrompt.catch((error) => failDispatch(item.id, error));
+                void writePrompt.catch((error) => failDispatch(item, error));
             }
             catch (error) {
-                failDispatch(item.id, error);
+                failDispatch(item, error);
             }
         }
     };
@@ -268,13 +284,12 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             const dispatchId = dispatch.id;
             if (fromAgentId && sender) {
                 const shouldAutoStartWorker = input.autoStartWorker !== false;
-                const hadActiveRun = Boolean(agentRuntime.getActiveRunByAgentId(workspaceId, workerId));
-                if (!hadActiveRun && shouldAutoStartWorker) {
-                    await ensureWorkerRun(workspaceId, workerId, input.hivePort ?? '');
-                    // The fresh run may also have OLDER parked dispatches waiting —
-                    // deliver them ahead of this one. Claims keep delivery single-shot;
-                    // the current dispatch is claimed by this same path just below.
-                    replayQueuedDispatches(workspaceId, workerId, { excludeDispatchId: dispatchId });
+                let activeRun = agentRuntime.getActiveRunByAgentId(workspaceId, workerId);
+                if (!activeRun && shouldAutoStartWorker) {
+                    activeRun = await ensureWorkerRun(workspaceId, workerId, input.hivePort ?? '');
+                    // Revalidate before accepting the task: a worker deleted while the
+                    // PTY was starting must not leave an accepted-but-undeliverable row.
+                    workspaceStore.getWorker(workspaceId, workerId);
                 }
                 if (!shouldAutoStartWorker && !agentRuntime.getActiveRunByAgentId(workspaceId, workerId)) {
                     workspaceStore.markTaskDispatched(workspaceId, workerId);
@@ -284,19 +299,9 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                     return Object.assign(dispatch, { queuedForStoppedWorker: true });
                 }
                 const isWorkflowDispatch = input.workflowRunId !== undefined || input.fromAgentId === getWorkflowAgentId(workspaceId);
-                // Revalidate the worker before claiming: it may have been deleted
-                // while ensureWorkerRun was awaited (R2 hardening) — a vanished worker
-                // must not leave a claimed-but-undeliverable dispatch behind.
-                workspaceStore.getWorker(workspaceId, workerId);
-                // Claim (queued → submitted) instead of a blind mark: a UI-initiated
-                // start can replay-deliver this dispatch while ensureWorkerRun above
-                // was awaited — losing the claim means delivery is already owned.
-                const claimed = claimQueuedDispatch(dispatchId);
-                workspaceStore.markTaskDispatched(workspaceId, workerId);
-                pendingMarked = true;
-                if (claimed)
+                const writeClaimedDispatch = (currentWorker) => {
                     try {
-                        const writePrompt = agentRuntime.writeSendPrompt(workspaceId, workerId, dispatchId, sender.name, worker.description, text);
+                        const writePrompt = agentRuntime.writeSendPrompt(workspaceId, workerId, dispatchId, sender.name, currentWorker.description, text);
                         void writePrompt.catch((error) => {
                             // `team send` is intentionally asynchronous (§3.3). A worker that
                             // exits during paste-submit did not receive actionable work, so
@@ -323,6 +328,62 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                         if (!isWorkflowDispatch)
                             console.error('[hive] swallowed:teamDispatch.writePrompt', error);
                     }
+                };
+                const claimAndWriteDispatch = () => {
+                    const currentWorker = workspaceStore.getWorker(workspaceId, workerId);
+                    const claimed = claimQueuedDispatch(dispatchId);
+                    if (claimed)
+                        writeClaimedDispatch(currentWorker);
+                };
+                // A PTY can flip from starting -> running on the first stdout chunk
+                // before Hermes/OpenCode is actually ready for our startup injection.
+                // The post-start barrier, not the coarse run status, is the source of
+                // truth for when the first task may be pasted.
+                const deferUntilPostStartReady = activeRun?.postStartInputReady;
+                if (deferUntilPostStartReady) {
+                    workspaceStore.markTaskDispatched(workspaceId, workerId);
+                    pendingMarked = true;
+                    const cancelDeferredDispatch = (error) => {
+                        try {
+                            cancelUndeliveredDispatch(workspaceId, workerId, dispatchId, reportForwardErrorMessage(error), input.workflowRunId, isWorkflowDispatch ? undefined : fromAgentId);
+                        }
+                        catch (cancelError) {
+                            if (!isWorkflowDispatch)
+                                console.error('[hive] swallowed:teamDispatch.cancelUndelivered', cancelError);
+                        }
+                        if (!isWorkflowDispatch)
+                            console.error('[hive] swallowed:teamDispatch.deferredWrite', error);
+                    };
+                    void deferUntilPostStartReady
+                        .then(() => {
+                        const current = listOpenWorkspaceDispatches(workspaceId).find((item) => item.id === dispatchId);
+                        if (!current || current.status !== 'queued')
+                            return;
+                        // Deliver older parked work first, but do not let later sends
+                        // jump ahead of this dispatch while a starting PTY settles.
+                        const replayOptions = {
+                            excludeDispatchId: dispatchId,
+                        };
+                        if (current.sequence !== null)
+                            replayOptions.beforeSequence = current.sequence;
+                        replayQueuedDispatches(workspaceId, workerId, replayOptions);
+                        claimAndWriteDispatch();
+                    })
+                        .catch(cancelDeferredDispatch);
+                    return dispatch;
+                }
+                // Revalidate the worker before claiming: it may have been deleted
+                // while ensureWorkerRun was awaited (R2 hardening) — a vanished worker
+                // must not leave a claimed-but-undeliverable dispatch behind.
+                workspaceStore.getWorker(workspaceId, workerId);
+                // Claim (queued → submitted) instead of a blind mark: a UI-initiated
+                // start can replay-deliver this dispatch while ensureWorkerRun above
+                // was awaited — losing the claim means delivery is already owned.
+                const claimed = claimQueuedDispatch(dispatchId);
+                workspaceStore.markTaskDispatched(workspaceId, workerId);
+                pendingMarked = true;
+                if (claimed)
+                    writeClaimedDispatch(worker);
             }
             else {
                 workspaceStore.markTaskDispatched(workspaceId, workerId);
@@ -397,9 +458,9 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                 throw new ConflictError(formatUnknownWorkerError(workerName, roster));
             }
             /* Capture the active-run state *before* dispatchTask runs. Internal
-               workflow calls may auto-start a stopped worker; explicit CLI
-               `team send` passes autoStartWorker:false so the worker remains
-               stopped with a queued dispatch until the user restarts it. */
+               workflow calls and orchestrator-owned `team spawn` follow-up sends may
+               auto-start a stopped worker; user-managed stopped workers remain
+               stopped with a queued dispatch until the user restarts them. */
             const restartedWorker = input.fromAgentId !== undefined &&
                 input.autoStartWorker !== false &&
                 !agentRuntime.getActiveRunByAgentId(workspaceId, worker.id);
@@ -411,6 +472,13 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             agentRuntime.writeUserInputPrompt(workspaceId, text);
             insertMessage(createUserInputMessage(workspaceId, orchestratorId, text));
         },
+        async deliverUserInput(workspaceId, orchestratorId, text) {
+            workspaceStore.getAgent(workspaceId, orchestratorId);
+            await agentRuntime.deliverUserInputToOrchestrator(workspaceId, text, {
+                requireActiveRun: true,
+            });
+            insertMessage(createUserInputMessage(workspaceId, orchestratorId, text));
+        },
         statusTask(workspaceId, workerId, input = {}) {
             const text = input.text ?? '';
             const artifacts = input.artifacts ?? [];

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

@@ -3,7 +3,9 @@ export type TerminalInputProfile = 'codex' | 'default' | 'grok' | 'opencode';
 export interface TerminalRunSummary {
     agent_id: string;
     agent_name: string;
+    has_user_input_since_start?: boolean | null;
     run_id: string;
+    startup_blocked_reason?: 'first_run_setup' | null;
     status: string;
     terminal_input_profile: TerminalInputProfile;
 }

package/dist/src/server/update-install-plan.d.ts

@@ -0,0 +1,20 @@
+export type UpdateInstallSource = 'bun-global' | 'bunx' | 'npm-global' | 'npm-prefix' | 'npx' | 'pnpm-dlx' | 'pnpm-global' | 'source-checkout' | 'unknown' | 'yarn-dlx' | 'yarn-global';
+export interface UpdateInstallPlan {
+    canRunHiveUpdate: boolean;
+    installArgs: string[];
+    installCommand: string;
+    installSource: UpdateInstallSource;
+    manualCommand: string;
+    note: string;
+}
+interface UpdateInstallPlanOptions {
+    env?: NodeJS.ProcessEnv | undefined;
+    moduleUrl?: string | undefined;
+    platform?: NodeJS.Platform | undefined;
+}
+export declare const formatUpdateCommand: (command: string, args: readonly string[], platform?: NodeJS.Platform) => string;
+export declare const findPackageRoot: (moduleUrl: string) => string | undefined;
+export declare const findPrefixFromPackageRoot: (packageRoot: string) => string | undefined;
+export declare const resolveHiveUpdateInstallArgs: (moduleUrl?: string) => string[];
+export declare const createUpdateInstallPlan: (options?: UpdateInstallPlanOptions) => UpdateInstallPlan;
+export {};

package/dist/src/server/update-install-plan.js

@@ -0,0 +1,151 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { INSTALL_COMMAND_ARGS, PACKAGE_NAME } from './package-version.js';
+const shellQuote = (value) => {
+    if (/^[A-Za-z0-9_/:=.,@+-]+$/.test(value))
+        return value;
+    return `'${value.replaceAll("'", "'\\''")}'`;
+};
+const windowsQuote = (value) => {
+    if (/^[-A-Za-z0-9_/:=.,@+\\]+$/.test(value))
+        return value;
+    return `"${value.replace(/"/g, '""')}"`;
+};
+export const formatUpdateCommand = (command, args, platform = process.platform) => `${command} ${args.map(platform === 'win32' ? windowsQuote : shellQuote).join(' ')}`;
+const normalizePath = (value) => value.replaceAll('\\', '/');
+const includesPathSegment = (path, segment) => normalizePath(path).split('/').includes(segment);
+export const findPackageRoot = (moduleUrl) => {
+    let dir = dirname(fileURLToPath(moduleUrl));
+    for (let depth = 0; depth < 12; depth += 1) {
+        const candidate = join(dir, 'package.json');
+        if (existsSync(candidate)) {
+            try {
+                const parsed = JSON.parse(readFileSync(candidate, 'utf8'));
+                if (parsed.name === PACKAGE_NAME)
+                    return dir;
+            }
+            catch {
+                // Keep walking. A malformed unrelated package.json should not break update planning.
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+    return undefined;
+};
+export const findPrefixFromPackageRoot = (packageRoot) => {
+    let dir = packageRoot;
+    for (let depth = 0; depth < 8; depth += 1) {
+        if (basename(dir) === 'node_modules') {
+            const parent = dirname(dir);
+            return basename(parent) === 'lib' ? dirname(parent) : parent;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+    return undefined;
+};
+export const resolveHiveUpdateInstallArgs = (moduleUrl = import.meta.url) => {
+    const packageRoot = findPackageRoot(moduleUrl);
+    const prefix = packageRoot ? findPrefixFromPackageRoot(packageRoot) : undefined;
+    if (!prefix)
+        return [...INSTALL_COMMAND_ARGS];
+    return [...INSTALL_COMMAND_ARGS, '--prefix', prefix];
+};
+const hasHint = (packageRoot, env, matcher) => {
+    const hints = [
+        packageRoot,
+        env._,
+        env.npm_command,
+        env.npm_config_user_agent,
+        env.npm_execpath,
+        env.npm_lifecycle_event,
+    ];
+    return hints.some((value) => typeof value === 'string' && matcher(normalizePath(value)));
+};
+const hasEnvHint = (env, matcher) => {
+    const hints = [
+        env._,
+        env.npm_command,
+        env.npm_config_user_agent,
+        env.npm_execpath,
+        env.npm_lifecycle_event,
+    ];
+    return hints.some((value) => typeof value === 'string' && matcher(normalizePath(value)));
+};
+const isBunGlobalHint = (value) => value.includes('/.bun/install/global/') ||
+    value.startsWith('bun/') ||
+    value.endsWith('/bun') ||
+    value.endsWith('/bun.exe');
+const commandPlan = (source, command, args, note, platform) => ({
+    canRunHiveUpdate: false,
+    installArgs: [],
+    installCommand: formatUpdateCommand(command, args, platform),
+    installSource: source,
+    manualCommand: formatUpdateCommand(command, args, platform),
+    note,
+});
+export const createUpdateInstallPlan = (options = {}) => {
+    const env = options.env ?? process.env;
+    const moduleUrl = options.moduleUrl ?? import.meta.url;
+    const platform = options.platform ?? process.platform;
+    const packageRoot = findPackageRoot(moduleUrl);
+    const packageRootPath = packageRoot ? normalizePath(packageRoot) : '';
+    if (packageRootPath.includes('/_npx/')) {
+        return commandPlan('npx', 'npx', [`${PACKAGE_NAME}@latest`], 'This Hive process is running from an npx cache; re-run npx with @latest instead of installing a global copy.', platform);
+    }
+    if (hasHint(packageRoot, env, (value) => value.includes('bunx'))) {
+        return commandPlan('bunx', 'bunx', [`${PACKAGE_NAME}@latest`], 'This Hive process is running from bunx; re-run bunx with @latest instead of installing a global copy.', platform);
+    }
+    if (hasHint(packageRoot, env, (value) => (value.includes('pnpm') && value.includes('dlx')) || value.includes('/dlx-'))) {
+        return commandPlan('pnpm-dlx', 'pnpm', ['dlx', `${PACKAGE_NAME}@latest`], 'This Hive process is running from pnpm dlx; re-run pnpm dlx with @latest instead of installing a global copy.', platform);
+    }
+    if (hasHint(packageRoot, env, (value) => value.includes('yarn') && value.includes('dlx'))) {
+        return commandPlan('yarn-dlx', 'yarn', ['dlx', `${PACKAGE_NAME}@latest`], 'This Hive process is running from yarn dlx; re-run yarn dlx with @latest instead of installing a global copy.', platform);
+    }
+    const prefix = packageRoot ? findPrefixFromPackageRoot(packageRoot) : undefined;
+    if (!prefix && packageRoot && !includesPathSegment(packageRoot, 'node_modules')) {
+        return commandPlan('source-checkout', 'sh', ['-lc', 'git pull && pnpm install && pnpm build'], 'This Hive process is running from a source checkout; update the checkout and rebuild instead of installing a global copy.', platform);
+    }
+    if (packageRootPath.includes('/.bun/install/global/') ||
+        (!prefix && hasEnvHint(env, isBunGlobalHint))) {
+        return commandPlan('bun-global', 'bun', ['add', '-g', `${PACKAGE_NAME}@latest`], 'Hive appears to be installed through bun; update it with bun so the active binary changes.', platform);
+    }
+    if (packageRootPath.includes('/.pnpm/') ||
+        (!prefix && hasEnvHint(env, (value) => value.includes('pnpm')))) {
+        return commandPlan('pnpm-global', 'pnpm', ['add', '-g', `${PACKAGE_NAME}@latest`], 'Hive appears to be installed through pnpm; update it with pnpm so npm does not create a shadow global install.', platform);
+    }
+    if (packageRootPath.includes('/yarn/global/') ||
+        packageRootPath.includes('/.config/yarn/global/') ||
+        (!prefix &&
+            hasEnvHint(env, (value) => value.includes('/yarn/global/') || value.includes('/.config/yarn/global/')))) {
+        return commandPlan('yarn-global', 'yarn', ['global', 'add', `${PACKAGE_NAME}@latest`], 'Hive appears to be installed through yarn; update it with yarn so npm does not create a shadow global install.', platform);
+    }
+    const installArgs = resolveHiveUpdateInstallArgs(moduleUrl);
+    const manualCommand = formatUpdateCommand('npm', installArgs, platform);
+    if (!packageRoot) {
+        return {
+            canRunHiveUpdate: false,
+            installArgs: [],
+            installCommand: '',
+            installSource: 'unknown',
+            manualCommand: '',
+            note: 'Hive could not determine how this process was installed; update it with the same package manager and install target you originally used.',
+        };
+    }
+    return {
+        canRunHiveUpdate: true,
+        installArgs,
+        installCommand: 'hive update',
+        installSource: prefix ? 'npm-prefix' : 'npm-global',
+        manualCommand,
+        note: prefix
+            ? 'Hive appears to be installed through npm with a custom prefix; hive update will update that same prefix.'
+            : 'Hive appears to be installed through npm; hive update will run the matching npm upgrade.',
+    };
+};

package/dist/src/server/version-service.d.ts

@@ -1,9 +1,13 @@
+import { type UpdateInstallPlan, type UpdateInstallSource } from './update-install-plan.js';
 export interface VersionInfoPayload {
+    can_run_hive_update: boolean;
     current_version: string;
     install_hint: string;
+    install_source: UpdateInstallSource;
     latest_version: string;
     package_name: string;
     release_url: string;
+    update_note: string;
     update_available: boolean;
 }
 export interface VersionService {
@@ -11,6 +15,7 @@ export interface VersionService {
 }
 export declare const compareVersions: (left: string, right: string) => number;
 export declare const createVersionService: (options?: {
+    createUpdateInstallPlan?: () => UpdateInstallPlan;
     fetchLatestVersion?: () => Promise<string>;
     now?: () => number;
 }) => VersionService;

package/dist/src/server/version-service.js

@@ -1,4 +1,5 @@
 import { PACKAGE_NAME, readPackageVersion } from './package-version.js';
+import { createUpdateInstallPlan, } from './update-install-plan.js';
 const VERSION_CACHE_MS = 6 * 60 * 60 * 1000;
 const REGISTRY_URL = 'https://registry.npmjs.org/@tt-a1i%2Fhive/latest';
 const parseVersion = (version) => {
@@ -25,20 +26,23 @@ export const compareVersions = (left, right) => {
         return -1;
     return a.prerelease.localeCompare(b.prerelease, undefined, { numeric: true });
 };
-const buildVersionInfo = (currentVersion, latestVersion) => ({
-    current_version: currentVersion,
-    // Show `hive update` as the primary upgrade path now that the subcommand
-    // exists; it prints the npm fallback if its own spawn fails, so users
-    // running on Windows / Linux without a working npm in PATH still recover.
-    install_hint: 'hive update',
-    latest_version: latestVersion,
-    package_name: PACKAGE_NAME,
-    release_url: `https://www.npmjs.com/package/${PACKAGE_NAME}/v/${latestVersion}`,
-    update_available: compareVersions(latestVersion, currentVersion) > 0,
-});
+const buildVersionInfo = (currentVersion, latestVersion, updatePlan) => {
+    return {
+        can_run_hive_update: updatePlan.canRunHiveUpdate,
+        current_version: currentVersion,
+        install_hint: updatePlan.installCommand,
+        install_source: updatePlan.installSource,
+        latest_version: latestVersion,
+        package_name: PACKAGE_NAME,
+        release_url: `https://www.npmjs.com/package/${PACKAGE_NAME}/v/${latestVersion}`,
+        update_available: compareVersions(latestVersion, currentVersion) > 0,
+        update_note: updatePlan.note,
+    };
+};
 export const createVersionService = (options = {}) => {
     const currentVersion = readPackageVersion();
     const now = options.now ?? Date.now;
+    const planUpdateInstall = options.createUpdateInstallPlan ?? createUpdateInstallPlan;
     const fetchLatestVersion = options.fetchLatestVersion ??
         (async () => {
             const response = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(1500) });
@@ -58,12 +62,12 @@ export const createVersionService = (options = {}) => {
                 return cached.info;
             try {
                 const latestVersion = await fetchLatestVersion();
-                const info = buildVersionInfo(currentVersion, latestVersion);
+                const info = buildVersionInfo(currentVersion, latestVersion, planUpdateInstall());
                 cached = { expiresAt: currentTime + VERSION_CACHE_MS, info };
                 return info;
             }
             catch {
-                const info = buildVersionInfo(currentVersion, currentVersion);
+                const info = buildVersionInfo(currentVersion, currentVersion, planUpdateInstall());
                 cached = { expiresAt: currentTime + VERSION_CACHE_MS, info };
                 return info;
             }

package/dist/src/server/workflow-agent-call-executor.d.ts

@@ -0,0 +1,81 @@
+import type { WorkerRole } from '../shared/types.js';
+import type { AgentLaunchConfigInput } from './agent-run-store.js';
+import { type WorkflowCliPolicy } from './workflow-cli-policy.js';
+import type { WorkflowDispatchAwaiter } from './workflow-dispatch-awaiter.js';
+export interface WorkflowAgentOptions {
+    label?: string;
+    /** Built-in role name OR the name of a workspace-defined custom role template. */
+    agentType?: WorkerRole | string;
+    cli?: string;
+    timeoutMs?: number;
+    /** Per-call model override, appended as `--model <id>` after template args. */
+    model?: string;
+    outputSchema?: Record<string, unknown>;
+    __hiveDagLayerId?: string;
+}
+export interface WorkflowRoleTemplateResolver {
+    findByName(name: string): {
+        name: string;
+        roleType: WorkerRole | 'orchestrator';
+        defaultCommand: string;
+        defaultArgs: string[];
+    } | undefined;
+}
+export interface WorkflowAgentExecutorStorePort {
+    addWorkerWithLaunch: (workspaceId: string, input: {
+        name: string;
+        role: WorkerRole;
+        ephemeral: true;
+        spawnedBy: 'workflow';
+    }, launchConfig: AgentLaunchConfigInput) => {
+        id: string;
+        name: string;
+    };
+    startAgent: (workspaceId: string, agentId: string, input: {
+        hivePort: string;
+    }) => Promise<{
+        postStartInputReady?: Promise<void>;
+    }>;
+    dispatchTaskByWorkerName: (workspaceId: string, workerName: string, text: string, input: {
+        fromAgentId: string;
+        hivePort: string;
+        workflowRunId: string;
+        stepIndex: number;
+        phase?: string;
+        label?: string;
+    }) => Promise<{
+        id: string;
+    }>;
+    deleteWorker: (workspaceId: string, workerId: string) => void;
+}
+interface CreateWorkflowAgentCallExecutorInput {
+    assertRunActive: () => void;
+    awaiter: WorkflowDispatchAwaiter;
+    cancelOpenDispatch: (dispatchId: string, reason: string) => void;
+    cliPolicy: WorkflowCliPolicy;
+    getCurrentPhaseTitle: () => string | null;
+    hivePort: string;
+    isRunStopped: () => boolean;
+    maxAgentCalls?: number;
+    maxConcurrentAgents?: number;
+    registerDagDispatch: (layerId: string | null, dispatchId: string) => void;
+    resolveCliLaunchConfig: (cli: string) => AgentLaunchConfigInput | undefined;
+    roleTemplateResolver: WorkflowRoleTemplateResolver;
+    runId: string;
+    store: WorkflowAgentExecutorStorePort;
+    workflowAgentId: string;
+    workflowName: string;
+    workspaceId: string;
+}
+export declare const createWorkflowAgentCallExecutor: ({ assertRunActive, awaiter, cancelOpenDispatch, cliPolicy, getCurrentPhaseTitle, hivePort, isRunStopped, maxAgentCalls, maxConcurrentAgents: configuredMaxConcurrentAgents, registerDagDispatch, resolveCliLaunchConfig, roleTemplateResolver, runId, store, workflowAgentId, workflowName, workspaceId, }: CreateWorkflowAgentCallExecutorInput) => {
+    agent: (prompt: string, opts?: WorkflowAgentOptions) => Promise<string | Record<string, unknown>>;
+    cancelQueuedAgentCallsForDagLayer: (layerId: string, reason: string) => void;
+    catchPerItem: <U>(value: unknown) => U | null;
+    deleteSpawnedWorkers: () => void;
+    forceCancelActiveDispatchWaiters: (reason: string) => void;
+    waitForActiveCalls: (timeoutMs?: number) => Promise<{
+        settled: boolean;
+        activeCount: number;
+    }>;
+};
+export {};