@tt-a1i/hive 2.1.0 → 2.1.3

package/dist/src/server/workflow-agent-call-executor.js

@@ -0,0 +1,259 @@
+import { randomUUID } from 'node:crypto';
+import { cpus } from 'node:os';
+import { resolveWorkflowCli } from './workflow-cli-policy.js';
+import { buildSchemaInstruction, extractJsonBlock } from './workflow-output-schema.js';
+const DEFAULT_MAX_AGENTS_PER_RUN = 1000;
+const DEFAULT_MAX_CONCURRENT_AGENTS = Math.min(16, Math.max(2, cpus().length - 2));
+const BUILT_IN_WORKER_ROLES = new Set(['coder', 'reviewer', 'tester', 'custom']);
+const isBuiltInWorkerRole = (value) => BUILT_IN_WORKER_ROLES.has(value);
+const buildModelArgs = (_cli, model) => {
+    if (!model?.trim())
+        return [];
+    /* All supported CLIs accept `--model <id>` as a positional flag. Keeping
+       the mapping centralised here so future CLI quirks can be patched without
+       touching workflow run lifecycle code. */
+    return ['--model', model];
+};
+export const createWorkflowAgentCallExecutor = ({ assertRunActive, awaiter, cancelOpenDispatch, cliPolicy, getCurrentPhaseTitle, hivePort, isRunStopped, maxAgentCalls, maxConcurrentAgents: configuredMaxConcurrentAgents, registerDagDispatch, resolveCliLaunchConfig, roleTemplateResolver, runId, store, workflowAgentId, workflowName, workspaceId, }) => {
+    let stepCounter = 0;
+    const spawnedWorkers = [];
+    const activeAgentCalls = new Set();
+    const activeDispatchIds = new Set();
+    const maxAgents = typeof maxAgentCalls === 'number' && maxAgentCalls > 0
+        ? maxAgentCalls
+        : DEFAULT_MAX_AGENTS_PER_RUN;
+    const maxConcurrentAgents = typeof configuredMaxConcurrentAgents === 'number' && configuredMaxConcurrentAgents > 0
+        ? configuredMaxConcurrentAgents
+        : DEFAULT_MAX_CONCURRENT_AGENTS;
+    let inFlight = 0;
+    const waitQueue = [];
+    const releaseSlot = () => {
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            inFlight--;
+            drainSlotQueue();
+        };
+    };
+    const takeSlot = () => {
+        inFlight++;
+        return releaseSlot();
+    };
+    function drainSlotQueue() {
+        while (inFlight < maxConcurrentAgents) {
+            const next = waitQueue.shift();
+            if (!next)
+                return;
+            next.resolve(takeSlot());
+        }
+    }
+    const acquireSlot = async (dagLayerId) => {
+        if (inFlight < maxConcurrentAgents) {
+            return takeSlot();
+        }
+        return new Promise((resolve, reject) => {
+            waitQueue.push({ dagLayerId, reject, resolve });
+        });
+    };
+    const cancelQueuedSlotWaiters = (reason, predicate) => {
+        const error = new Error(reason);
+        const remaining = [];
+        for (const waiter of waitQueue) {
+            if (predicate(waiter))
+                waiter.reject(error);
+            else
+                remaining.push(waiter);
+        }
+        waitQueue.length = 0;
+        waitQueue.push(...remaining);
+    };
+    const resolveWorkerLaunch = (opts) => {
+        const requestedType = opts.agentType ?? 'coder';
+        let role;
+        let command;
+        let templateArgs = [];
+        if (typeof requestedType === 'string' && !isBuiltInWorkerRole(requestedType)) {
+            const template = roleTemplateResolver.findByName(requestedType);
+            if (!template) {
+                throw new Error(`Workflow agentType '${requestedType}' is not a built-in role (coder/reviewer/tester/custom) and no matching role template exists in this workspace. ` +
+                    `Use a built-in role or an existing dispatchable role template.`);
+            }
+            if (template.roleType === 'sentinel') {
+                throw new Error(`Workflow agentType '${requestedType}' resolves to a sentinel role, but sentinels are read-only observers and cannot receive workflow dispatches. Use coder, reviewer, tester, custom, or a dispatchable role template.`);
+            }
+            role = template.roleType === 'orchestrator' ? 'custom' : template.roleType;
+            command = resolveWorkflowCli({
+                ...(opts.cli !== undefined ? { requestedCli: opts.cli } : {}),
+                isCustomTemplate: true,
+                templateDefaultCommand: template.defaultCommand,
+                policy: cliPolicy,
+            });
+            templateArgs = template.defaultArgs;
+        }
+        else {
+            role = requestedType;
+            command = resolveWorkflowCli({
+                ...(opts.cli !== undefined ? { requestedCli: opts.cli } : {}),
+                isCustomTemplate: false,
+                policy: cliPolicy,
+            });
+        }
+        const baseLaunchConfig = resolveCliLaunchConfig(command) ?? { command, args: [] };
+        const launchArgs = [
+            ...(baseLaunchConfig.args ?? []),
+            ...templateArgs,
+            ...buildModelArgs(baseLaunchConfig.command, opts.model),
+        ];
+        return {
+            requestedType,
+            role,
+            launchConfig: { ...baseLaunchConfig, args: launchArgs },
+        };
+    };
+    const agent = async (prompt, opts = {}) => {
+        let markAgentCallDone;
+        const agentCallDone = new Promise((resolve) => {
+            markAgentCallDone = resolve;
+        });
+        activeAgentCalls.add(agentCallDone);
+        try {
+            assertRunActive();
+            if (stepCounter >= maxAgents) {
+                throw new Error(`Workflow agent cap exceeded: ${maxAgents} calls (set meta.maxAgentCalls to raise)`);
+            }
+            const myStep = ++stepCounter;
+            const dagLayerId = typeof opts.__hiveDagLayerId === 'string' && opts.__hiveDagLayerId.trim()
+                ? opts.__hiveDagLayerId.trim()
+                : null;
+            const { launchConfig, requestedType, role } = resolveWorkerLaunch(opts);
+            const name = opts.label ?? `${requestedType}-${myStep}-${randomUUID()}`;
+            const releaseSlot = await acquireSlot(dagLayerId);
+            let worker;
+            let dispatchId;
+            try {
+                assertRunActive();
+                worker = store.addWorkerWithLaunch(workspaceId, { name, role, ephemeral: true, spawnedBy: 'workflow' }, launchConfig);
+                spawnedWorkers.push(worker.id);
+                assertRunActive();
+                const liveRun = await store.startAgent(workspaceId, worker.id, { hivePort });
+                await liveRun.postStartInputReady;
+                assertRunActive();
+                const dispatchPrompt = opts.outputSchema
+                    ? prompt + buildSchemaInstruction(opts.outputSchema)
+                    : prompt;
+                const currentPhaseTitle = getCurrentPhaseTitle();
+                const dispatch = await store.dispatchTaskByWorkerName(workspaceId, name, dispatchPrompt, {
+                    fromAgentId: workflowAgentId,
+                    hivePort,
+                    workflowRunId: runId,
+                    stepIndex: myStep,
+                    ...(currentPhaseTitle ? { phase: currentPhaseTitle } : {}),
+                    label: opts.label ?? name,
+                });
+                dispatchId = dispatch.id;
+                activeDispatchIds.add(dispatch.id);
+                registerDagDispatch(dagLayerId, dispatch.id);
+                assertRunActive();
+                const report = await awaiter.awaitReport(dispatch.id, opts.timeoutMs);
+                assertRunActive();
+                if (opts.outputSchema) {
+                    return extractJsonBlock(report.text) ?? { text: report.text };
+                }
+                return report.text;
+            }
+            catch (error) {
+                if (dispatchId) {
+                    try {
+                        cancelOpenDispatch(dispatchId, error instanceof Error ? error.message : String(error));
+                    }
+                    catch (cancelError) {
+                        console.error('[hive] swallowed:workflow.agent.cancelDispatch', cancelError);
+                    }
+                }
+                throw error;
+            }
+            finally {
+                if (dispatchId)
+                    activeDispatchIds.delete(dispatchId);
+                if (worker) {
+                    try {
+                        store.deleteWorker(workspaceId, worker.id);
+                    }
+                    catch {
+                        /* idempotent — worker may already be gone via cascade or boot cleanup */
+                    }
+                    const idx = spawnedWorkers.indexOf(worker.id);
+                    if (idx !== -1)
+                        spawnedWorkers.splice(idx, 1);
+                }
+                releaseSlot();
+            }
+        }
+        finally {
+            markAgentCallDone();
+            activeAgentCalls.delete(agentCallDone);
+        }
+    };
+    const catchPerItem = (value) => {
+        if (isRunStopped())
+            throw value;
+        console.warn(`[workflow ${workflowName}] item failed:`, value);
+        return null;
+    };
+    const waitForActiveCalls = async (timeoutMs) => {
+        const calls = [...activeAgentCalls];
+        if (calls.length === 0) {
+            return { settled: true, activeCount: 0 };
+        }
+        if (timeoutMs === undefined) {
+            await Promise.allSettled(calls);
+            return { settled: true, activeCount: 0 };
+        }
+        let timeoutHandle;
+        const timeout = new Promise((resolve) => {
+            timeoutHandle = setTimeout(() => resolve('timeout'), timeoutMs);
+        });
+        const result = await Promise.race([
+            Promise.allSettled(calls).then(() => 'settled'),
+            timeout,
+        ]);
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+        return {
+            settled: result === 'settled',
+            activeCount: activeAgentCalls.size,
+        };
+    };
+    const forceCancelActiveDispatchWaiters = (reason) => {
+        for (const dispatchId of activeDispatchIds) {
+            awaiter.forceCancel(dispatchId, reason);
+        }
+        cancelQueuedSlotWaiters(reason, () => true);
+    };
+    const cancelQueuedAgentCallsForDagLayer = (layerId, reason) => {
+        const normalized = layerId.trim();
+        if (!normalized)
+            return;
+        cancelQueuedSlotWaiters(reason, (waiter) => waiter.dagLayerId === normalized);
+    };
+    const deleteSpawnedWorkers = () => {
+        for (const workerId of spawnedWorkers.splice(0)) {
+            try {
+                store.deleteWorker(workspaceId, workerId);
+            }
+            catch {
+                /* swallow */
+            }
+        }
+    };
+    return {
+        agent,
+        cancelQueuedAgentCallsForDagLayer,
+        catchPerItem,
+        deleteSpawnedWorkers,
+        forceCancelActiveDispatchWaiters,
+        waitForActiveCalls,
+    };
+};

package/dist/src/server/workflow-dag-layer-tracker.d.ts

@@ -0,0 +1,14 @@
+import type { WorkflowDispatchAwaiter } from './workflow-dispatch-awaiter.js';
+interface WorkflowDagDispatchCancelPort {
+    cancelOpenDispatchForRun: (workspaceId: string, dispatchId: string, reason: string) => boolean;
+}
+export declare const createWorkflowDagLayerTracker: (input: {
+    awaiter: Pick<WorkflowDispatchAwaiter, "notifyCancel">;
+    cancelQueuedAgentCallsForDagLayer: (layerId: string, reason: string) => void;
+    dispatchPort: WorkflowDagDispatchCancelPort;
+    workspaceId: string;
+}) => {
+    cancelLayerAgents: (layerId: unknown, reason: unknown) => void;
+    registerDispatch: (layerId: string | null, dispatchId: string) => void;
+};
+export {};

package/dist/src/server/workflow-dag-layer-tracker.js

@@ -0,0 +1,37 @@
+const errorToMessage = (error) => error instanceof Error ? error.message : String(error);
+export const createWorkflowDagLayerTracker = (input) => {
+    const dagLayerDispatches = new Map();
+    const registerDispatch = (layerId, dispatchId) => {
+        if (!layerId)
+            return;
+        let dispatches = dagLayerDispatches.get(layerId);
+        if (!dispatches) {
+            dispatches = new Set();
+            dagLayerDispatches.set(layerId, dispatches);
+        }
+        dispatches.add(dispatchId);
+    };
+    const cancelLayerAgents = (layerId, reason) => {
+        const message = typeof reason === 'string' && reason.trim() ? reason : 'Workflow DAG node failed';
+        const normalizedLayerId = typeof layerId === 'string' ? layerId.trim() : '';
+        if (!normalizedLayerId)
+            throw new Error('Missing DAG layer id');
+        input.cancelQueuedAgentCallsForDagLayer(normalizedLayerId, message);
+        const dispatchIds = dagLayerDispatches.get(normalizedLayerId) ?? new Set();
+        const errors = [];
+        for (const dispatchId of dispatchIds) {
+            try {
+                const cancelled = input.dispatchPort.cancelOpenDispatchForRun(input.workspaceId, dispatchId, message);
+                if (cancelled)
+                    input.awaiter.notifyCancel(dispatchId, message);
+            }
+            catch (error) {
+                errors.push(errorToMessage(error));
+            }
+        }
+        if (errors.length > 0) {
+            throw new Error(errors.join('; '));
+        }
+    };
+    return { cancelLayerAgents, registerDispatch };
+};

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

@@ -0,0 +1,8 @@
+export interface WorkflowDagNodeInput {
+    deps: string[];
+    id: string;
+}
+export interface WorkflowDagPlan {
+    layers: string[][];
+}
+export declare const planWorkflowDag: (input: unknown) => WorkflowDagPlan;

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

@@ -0,0 +1,65 @@
+const assertDagNodeInput = (node, index) => {
+    if (!node || typeof node !== 'object') {
+        throw new Error(`dag(): node #${index + 1} must be an object`);
+    }
+    const record = node;
+    const id = typeof record.id === 'string' ? record.id.trim() : '';
+    if (!id)
+        throw new Error(`dag(): node #${index + 1} requires a non-empty string id`);
+    if (!Array.isArray(record.deps)) {
+        throw new Error(`dag(${id}): deps must be an array`);
+    }
+    const deps = record.deps.map((dep) => String(dep).trim());
+    for (const dep of deps) {
+        if (!dep)
+            throw new Error(`dag(${id}): dependency ids must be non-empty strings`);
+    }
+    return { deps, id };
+};
+export const planWorkflowDag = (input) => {
+    if (!Array.isArray(input)) {
+        throw new Error('dag(): expected planner input to be an array of nodes');
+    }
+    const nodes = input.map(assertDagNodeInput);
+    const remainingDeps = new Map();
+    const dependents = new Map();
+    for (const node of nodes) {
+        if (remainingDeps.has(node.id))
+            throw new Error(`dag(): duplicate node id "${node.id}"`);
+        remainingDeps.set(node.id, node.deps.length);
+        dependents.set(node.id, []);
+    }
+    for (const node of nodes) {
+        for (const dep of node.deps) {
+            const children = dependents.get(dep);
+            if (!children)
+                throw new Error(`dag(${node.id}): unknown dependency "${dep}"`);
+            children.push(node.id);
+        }
+    }
+    const queue = nodes.filter((node) => node.deps.length === 0).map((node) => node.id);
+    const layers = [];
+    let cursor = 0;
+    let visited = 0;
+    while (cursor < queue.length) {
+        const layer = queue.slice(cursor);
+        cursor = queue.length;
+        layers.push(layer);
+        for (const id of layer) {
+            visited += 1;
+            for (const childId of dependents.get(id) ?? []) {
+                const next = (remainingDeps.get(childId) ?? 0) - 1;
+                remainingDeps.set(childId, next);
+                if (next === 0)
+                    queue.push(childId);
+            }
+        }
+    }
+    if (visited !== nodes.length) {
+        const cyclic = nodes
+            .filter((node) => (remainingDeps.get(node.id) ?? 0) > 0)
+            .map((node) => node.id);
+        throw new Error(`dag(): cycle or unsatisfied dependencies among: ${cyclic.join(', ')}`);
+    }
+    return { layers };
+};

package/dist/src/server/workflow-dispatch-awaiter.d.ts

@@ -7,6 +7,12 @@ export interface WorkflowDispatchAwaiter {
     awaitReport(dispatchId: string, timeoutMs?: number): Promise<ReportPayload>;
     notifyReport(dispatchId: string, payload: ReportPayload): void;
     notifyCancel(dispatchId: string, reason: string): void;
+    forceCancel(dispatchId: string, reason: string): void;
     cancelAll(reason: string): void;
 }
-export declare const createWorkflowDispatchAwaiter: () => WorkflowDispatchAwaiter;
+export interface WorkflowDispatchAwaiterOptions {
+    deferredEventTtlMs?: number;
+    maxDeferredEvents?: number;
+    now?: () => number;
+}
+export declare const createWorkflowDispatchAwaiter: (options?: WorkflowDispatchAwaiterOptions) => WorkflowDispatchAwaiter;

package/dist/src/server/workflow-dispatch-awaiter.js

@@ -1,6 +1,8 @@
 // Default 10 minutes — workflows often run long. Callers may shorten via opts.
 const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
-export const createWorkflowDispatchAwaiter = () => {
+const DEFAULT_DEFERRED_EVENT_TTL_MS = DEFAULT_TIMEOUT_MS;
+const DEFAULT_MAX_DEFERRED_EVENTS = 4096;
+export const createWorkflowDispatchAwaiter = (options = {}) => {
     const pending = new Map();
     // TIER 2 #10 — deferred-cancel state. The runner creates a dispatch
     // and THEN calls awaitReport, with at least one microtask gap between
@@ -13,6 +15,13 @@ export const createWorkflowDispatchAwaiter = () => {
     // reason — defensive against a future ordering change.
     const cancelledIds = new Map();
     const reportedIds = new Map();
+    const now = options.now ?? (() => Date.now());
+    const deferredEventTtlMs = typeof options.deferredEventTtlMs === 'number' && options.deferredEventTtlMs > 0
+        ? options.deferredEventTtlMs
+        : DEFAULT_DEFERRED_EVENT_TTL_MS;
+    const maxDeferredEvents = typeof options.maxDeferredEvents === 'number' && options.maxDeferredEvents > 0
+        ? options.maxDeferredEvents
+        : DEFAULT_MAX_DEFERRED_EVENTS;
     const take = (dispatchId) => {
         const entry = pending.get(dispatchId);
         if (entry) {
@@ -21,19 +30,53 @@ export const createWorkflowDispatchAwaiter = () => {
         }
         return entry;
     };
+    const pruneDeferredEvents = () => {
+        const time = now();
+        for (const [id, entry] of cancelledIds) {
+            if (entry.expiresAt <= time)
+                cancelledIds.delete(id);
+        }
+        for (const [id, entry] of reportedIds) {
+            if (entry.expiresAt <= time)
+                reportedIds.delete(id);
+        }
+        while (cancelledIds.size + reportedIds.size > maxDeferredEvents) {
+            const reportedKey = reportedIds.keys().next().value;
+            if (typeof reportedKey === 'string') {
+                reportedIds.delete(reportedKey);
+                continue;
+            }
+            const cancelledKey = cancelledIds.keys().next().value;
+            if (typeof cancelledKey === 'string') {
+                cancelledIds.delete(cancelledKey);
+                continue;
+            }
+            break;
+        }
+    };
+    const putDeferred = (map, dispatchId, value) => {
+        map.set(dispatchId, { value, expiresAt: now() + deferredEventTtlMs });
+        pruneDeferredEvents();
+    };
+    const takeDeferred = (map, dispatchId) => {
+        pruneDeferredEvents();
+        const entry = map.get(dispatchId);
+        if (!entry)
+            return undefined;
+        map.delete(dispatchId);
+        return entry.value;
+    };
     return {
         awaitReport(dispatchId, timeoutMs = DEFAULT_TIMEOUT_MS) {
             return new Promise((resolve, reject) => {
                 // Pre-arrived events: drain immediately, no timer / no entry.
-                const earlyReport = reportedIds.get(dispatchId);
+                const earlyReport = takeDeferred(reportedIds, dispatchId);
                 if (earlyReport) {
-                    reportedIds.delete(dispatchId);
                     resolve(earlyReport);
                     return;
                 }
-                const earlyCancel = cancelledIds.get(dispatchId);
-                if (earlyCancel) {
-                    cancelledIds.delete(dispatchId);
+                const earlyCancel = takeDeferred(cancelledIds, dispatchId);
+                if (earlyCancel !== undefined) {
                     reject(new Error(`workflow dispatch ${dispatchId} cancelled: ${earlyCancel}`));
                     return;
                 }
@@ -51,8 +94,8 @@ export const createWorkflowDispatchAwaiter = () => {
             }
             else {
                 // Pre-arrival: stash for the eventual awaitReport call. Cap
-                // stash size implicitly by overwriting on duplicate id.
-                reportedIds.set(dispatchId, payload);
+                // stash size and TTL so unknown ids cannot grow forever.
+                putDeferred(reportedIds, dispatchId, payload);
             }
         },
         notifyCancel(dispatchId, reason) {
@@ -61,7 +104,15 @@ export const createWorkflowDispatchAwaiter = () => {
                 entry.reject(new Error(`workflow dispatch ${dispatchId} cancelled: ${reason}`));
             }
             else {
-                cancelledIds.set(dispatchId, reason);
+                putDeferred(cancelledIds, dispatchId, reason);
+            }
+        },
+        forceCancel(dispatchId, reason) {
+            cancelledIds.delete(dispatchId);
+            reportedIds.delete(dispatchId);
+            const entry = take(dispatchId);
+            if (entry) {
+                entry.reject(new Error(`workflow dispatch ${dispatchId} cancelled: ${reason}`));
             }
         },
         cancelAll(reason) {

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

@@ -1,6 +1,6 @@
-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 WorkflowAgentExecutorStorePort, type WorkflowRoleTemplateResolver } from './workflow-agent-call-executor.js';
+import type { WorkflowCliPolicy } from './workflow-cli-policy.js';
 import type { WorkflowDispatchAwaiter } from './workflow-dispatch-awaiter.js';
 import type { WorkflowRunRecord, WorkflowRunStatus } from './workflow-run-store.js';
 export interface RunWorkflowInput {
@@ -31,41 +31,7 @@ export interface RunInlineWorkflowInput {
  *  into an ephemeral worker. Returns `undefined` if the name doesn't
  *  match any template (built-in or custom); the runner falls back to
  *  built-in-role semantics in that case. */
-export interface RoleTemplateResolver {
-    findByName(name: string): {
-        name: string;
-        roleType: WorkerRole | 'orchestrator';
-        defaultCommand: string;
-        defaultArgs: string[];
-    } | undefined;
-}
-interface RunnerStorePort {
-    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;
-}
+export type RoleTemplateResolver = WorkflowRoleTemplateResolver;
 /** TIER 2 #3 — narrator lane sink. The runner calls append(runId, message)
  *  every time the script invokes log(). Implementation lives in
  *  workflow-run-log-store; the port keeps the runner free of DB types. */
@@ -111,9 +77,10 @@ export interface WorkflowRunner {
 }
 interface ListDispatchesForStopPort {
     listOpenDispatchIdsForRun: (runId: string) => string[];
+    cancelOpenDispatchForRun: (workspaceId: string, dispatchId: string, reason: string) => boolean;
 }
 export declare const createWorkflowRunner: (deps: {
-    store: RunnerStorePort;
+    store: WorkflowAgentExecutorStorePort;
     workflowRunStore: WorkflowRunStorePort;
     awaiter: WorkflowDispatchAwaiter;
     dispatchPort: ListDispatchesForStopPort;