@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/core/orchestrator-follow-up-runtime.js

@@ -0,0 +1,110 @@
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+import { buildConversationFollowUpPrompt, normalizeConversationFollowUpItems, } from '@pellux/goodvibes-sdk/platform/core/conversation-follow-ups';
+import { normalizeUsage } from './orchestrator-runtime.js';
+const FOLLOW_UP_DEDUP_TTL_MS = 60_000;
+const FOLLOW_UP_MAX_OUTPUT_TOKENS = 160;
+const FOLLOW_UP_RETRY_DELAY_MS = 250;
+export class OrchestratorFollowUpRuntime {
+    options;
+    queue = [];
+    flushScheduled = false;
+    isRunning = false;
+    recentKeys = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    enqueue(item) {
+        const summary = item.summary.trim();
+        if (summary.length === 0)
+            return;
+        const now = Date.now();
+        this.pruneRecent(now);
+        const lastSeenAt = this.recentKeys.get(item.key);
+        if (lastSeenAt !== undefined && now - lastSeenAt < FOLLOW_UP_DEDUP_TTL_MS)
+            return;
+        this.recentKeys.set(item.key, now);
+        this.queue.push({ key: item.key, summary });
+        this.scheduleFlush();
+    }
+    scheduleFlush() {
+        if (this.flushScheduled || this.queue.length === 0)
+            return;
+        this.flushScheduled = true;
+        queueMicrotask(() => {
+            this.flushScheduled = false;
+            void this.flush();
+        });
+    }
+    pruneRecent(now) {
+        for (const [key, seenAt] of this.recentKeys.entries()) {
+            if (now - seenAt >= FOLLOW_UP_DEDUP_TTL_MS) {
+                this.recentKeys.delete(key);
+            }
+        }
+    }
+    takeBatch() {
+        const batch = normalizeConversationFollowUpItems(this.queue);
+        if (batch.length === 0) {
+            this.queue = [];
+            return [];
+        }
+        const batchKeys = new Set(batch.map((item) => item.key));
+        this.queue = this.queue.filter((item) => !batchKeys.has(item.key));
+        return batch;
+    }
+    async flush() {
+        if (this.queue.length === 0)
+            return;
+        const state = this.options.getThinkingState();
+        if (state.isThinking || state.isCompacting || this.isRunning || this.options.getQueuedUserMessageCount() > 0) {
+            setTimeout(() => this.scheduleFlush(), FOLLOW_UP_RETRY_DELAY_MS);
+            return;
+        }
+        const providerRegistry = this.options.getProviderRegistry();
+        const model = this.options.getCurrentModel();
+        const provider = providerRegistry.get(model.provider);
+        const tokenLimit = Math.min(FOLLOW_UP_MAX_OUTPUT_TOKENS, providerRegistry.getTokenLimitsForModel(model).maxOutputTokens);
+        const batch = this.takeBatch();
+        if (batch.length === 0)
+            return;
+        this.isRunning = true;
+        try {
+            const response = await provider.chat({
+                model: model.id,
+                messages: [
+                    ...this.options.conversation.getMessagesForLLM(),
+                    { role: 'user', content: buildConversationFollowUpPrompt(batch) },
+                ],
+                systemPrompt: this.options.getSystemPrompt(),
+                maxTokens: tokenLimit,
+                reasoningEffort: model.capabilities.reasoning ? 'low' : undefined,
+            });
+            const content = response.content.trim();
+            if (content.length > 0) {
+                this.options.conversation.addAssistantMessage(content, {
+                    usage: response.usage,
+                    model: model.displayName,
+                    provider: model.provider,
+                });
+                const normalizedUsage = normalizeUsage(response.usage);
+                this.options.applyUsage(normalizedUsage);
+                this.options.scrollToEnd(this.options.getViewportHeight());
+                this.options.requestRender();
+            }
+        }
+        catch (error) {
+            logger.debug('Orchestrator follow-up acknowledgement failed', {
+                error: summarizeError(error),
+                updates: batch.map((item) => item.summary),
+            });
+            this.options.routeLowPriorityMessage(`[Follow-up] Acknowledgement update failed: ${summarizeError(error)}`);
+        }
+        finally {
+            this.isRunning = false;
+            if (this.queue.length > 0) {
+                this.scheduleFlush();
+            }
+        }
+    }
+}

package/dist/_internal/platform/core/orchestrator-runtime.d.ts

@@ -0,0 +1,30 @@
+import type { ConfigManager } from '../config/manager.js';
+import type { ProviderRegistry } from '../providers/registry.js';
+import type { ContentPart, LLMProvider } from '../providers/interface.js';
+import type { CacheHitTracker } from '@pellux/goodvibes-sdk/platform/providers/cache-strategy';
+import type { SessionLineageTracker } from '@pellux/goodvibes-sdk/platform/core/session-lineage';
+import type { IdempotencyStore } from '@pellux/goodvibes-sdk/platform/runtime/idempotency/index';
+import type { AdaptivePlanner } from '@pellux/goodvibes-sdk/platform/core/adaptive-planner';
+import type { ExecutionPlanManager } from '@pellux/goodvibes-sdk/platform/core/execution-plan';
+import type { SessionMemoryStore } from '@pellux/goodvibes-sdk/platform/core/session-memory';
+import type { FavoritesStore } from '@pellux/goodvibes-sdk/platform/providers/favorites';
+export type OrchestratorCoreServices = {
+    configManager?: Pick<ConfigManager, 'get' | 'getCategory' | 'getWorkingDirectory'>;
+    providerRegistry?: ProviderRegistry;
+    cacheHitTracker?: Pick<CacheHitTracker, 'getMetrics'>;
+    sessionLineageTracker?: SessionLineageTracker;
+    idempotencyStore?: IdempotencyStore;
+    planManager?: Pick<ExecutionPlanManager, 'getActive' | 'getSummary' | 'getNextItems' | 'toMarkdown' | 'create' | 'save' | 'parseFromMarkdown' | 'replaceItems' | 'load' | 'updateItem'>;
+    adaptivePlanner?: Pick<AdaptivePlanner, 'select' | 'getMode' | 'setMode' | 'explain' | 'override' | 'clearOverride' | 'getOverride' | 'getLatest'>;
+    sessionMemoryStore?: Pick<SessionMemoryStore, 'list'>;
+    favoritesStore?: Pick<FavoritesStore, 'recordUsage'>;
+};
+export declare function normalizeUsage(usage: Awaited<ReturnType<LLMProvider['chat']>>['usage']): Awaited<ReturnType<LLMProvider['chat']>>['usage'];
+export declare function estimateFreshTurnInputTokens(lastInputTokens: number, currentEstimatedTokens: number, text: string, content?: ContentPart[]): number;
+export declare function getSessionLineageTracker(services: OrchestratorCoreServices, ownedSessionLineageTracker: SessionLineageTracker): SessionLineageTracker;
+export declare function getIdempotencyStore(services: OrchestratorCoreServices, ownedIdempotencyStore: IdempotencyStore): IdempotencyStore;
+export declare function requireConfigManager(services: OrchestratorCoreServices): Pick<ConfigManager, 'get' | 'getCategory' | 'getWorkingDirectory'>;
+export declare function requireProviderRegistry(services: OrchestratorCoreServices): ProviderRegistry;
+export declare function getCacheHitTracker(services: OrchestratorCoreServices, ownedCacheHitTracker: Pick<CacheHitTracker, 'getMetrics'>): Pick<CacheHitTracker, 'getMetrics'>;
+export declare function createEmitterContext(sessionId: string, turnId: string): import('../runtime/emitters/index.js').EmitterContext;
+//# sourceMappingURL=orchestrator-runtime.d.ts.map

package/dist/_internal/platform/core/orchestrator-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-runtime.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/core/orchestrator-runtime.ts"],"names":[],"mappings":"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"}

package/dist/_internal/platform/core/orchestrator-runtime.js

@@ -0,0 +1,62 @@
+import { estimateTokens } from './context-compaction.js';
+export function normalizeUsage(usage) {
+    const cacheReadTokens = usage.cacheReadTokens ?? 0;
+    const hasExplicitCacheBreakout = Object.prototype.hasOwnProperty.call(usage, 'cacheWriteTokens');
+    const freshInputTokens = hasExplicitCacheBreakout
+        ? usage.inputTokens
+        : Math.max(0, usage.inputTokens - cacheReadTokens);
+    return {
+        ...usage,
+        inputTokens: freshInputTokens,
+    };
+}
+export function estimateFreshTurnInputTokens(lastInputTokens, currentEstimatedTokens, text, content) {
+    const explicitContentTokens = content?.reduce((sum, part) => {
+        if (part.type === 'text')
+            return sum + estimateTextTokens(part.text);
+        return sum;
+    }, 0) ?? 0;
+    const currentTurnPayloadTokens = Math.max(explicitContentTokens, estimateTextTokens(text));
+    if (lastInputTokens <= 0) {
+        return Math.max(currentEstimatedTokens, currentTurnPayloadTokens);
+    }
+    const deltaFromPreviousContext = currentEstimatedTokens - lastInputTokens;
+    if (deltaFromPreviousContext > 0) {
+        return Math.max(deltaFromPreviousContext, currentTurnPayloadTokens);
+    }
+    if (currentEstimatedTokens < Math.floor(lastInputTokens * 0.8)) {
+        return Math.max(currentEstimatedTokens, currentTurnPayloadTokens);
+    }
+    return currentTurnPayloadTokens;
+}
+export function getSessionLineageTracker(services, ownedSessionLineageTracker) {
+    return services.sessionLineageTracker ?? ownedSessionLineageTracker;
+}
+export function getIdempotencyStore(services, ownedIdempotencyStore) {
+    return services.idempotencyStore ?? ownedIdempotencyStore;
+}
+export function requireConfigManager(services) {
+    if (!services.configManager) {
+        throw new Error('Orchestrator requires configManager in core services');
+    }
+    return services.configManager;
+}
+export function requireProviderRegistry(services) {
+    if (!services.providerRegistry) {
+        throw new Error('Orchestrator requires providerRegistry in core services');
+    }
+    return services.providerRegistry;
+}
+export function getCacheHitTracker(services, ownedCacheHitTracker) {
+    return services.cacheHitTracker ?? ownedCacheHitTracker;
+}
+export function createEmitterContext(sessionId, turnId) {
+    return {
+        sessionId,
+        traceId: `${sessionId}:${turnId}`,
+        source: 'orchestrator',
+    };
+}
+function estimateTextTokens(text) {
+    return estimateTokens(text);
+}

package/dist/_internal/platform/core/orchestrator-tool-runtime.d.ts

@@ -0,0 +1,41 @@
+import type { HookEvent, HookResult } from '@pellux/goodvibes-sdk/platform/hooks/types';
+import type { ToolCall, ToolResult } from '@pellux/goodvibes-sdk/platform/types/tools';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools/registry';
+import type { PermissionManager } from '../permissions/manager.js';
+import type { RuntimeEventBus } from '../runtime/events/index.js';
+import { type ReconciliationReason } from '@pellux/goodvibes-sdk/platform/core/tool-reconciliation';
+import type { ConfigManager } from '../config/manager.js';
+import type { AgentManager } from '../tools/agent/index.js';
+import type { ExecutionPlan, ExecutionPlanManager, PlanItem } from '@pellux/goodvibes-sdk/platform/core/execution-plan';
+import type { ProviderRegistry } from '../providers/registry.js';
+type HookDispatcherLike = {
+    fire(event: HookEvent): Promise<HookResult>;
+};
+type EmitterContextFactory = (turnId: string) => import('../runtime/emitters/index.js').EmitterContext;
+export type ToolExecutionDeps = {
+    toolRegistry: ToolRegistry;
+    permissionManager: PermissionManager;
+    hookDispatcher: HookDispatcherLike | null;
+    runtimeBus: RuntimeEventBus | null;
+    sessionId: string;
+    emitterContext: EmitterContextFactory;
+};
+export declare function executeToolCalls(deps: ToolExecutionDeps, turnId: string, calls: ToolCall[]): Promise<ToolResult[]>;
+export type ReconciliationDeps = {
+    conversation: {
+        addToolResults: (results: ToolResult[]) => void;
+        addSystemMessage: (message: string) => void;
+    };
+    runtimeBus: RuntimeEventBus | null;
+    emitterContext: EmitterContextFactory;
+    isReconciliationEnabled: () => boolean;
+    currentSubmissionKey: string | null;
+    pendingToolCalls: ToolCall[];
+    setPendingToolCalls: (calls: ToolCall[]) => void;
+};
+export declare function reconcileUnresolvedToolCalls(deps: ReconciliationDeps, resolvedResults: ToolResult[], reason: ReconciliationReason): void;
+export declare function autoSpawnPendingItems(conversation: {
+    addSystemMessage: (message: string) => void;
+}, plan: ExecutionPlan, items: PlanItem[], agentManager: Pick<AgentManager, 'list' | 'spawn'>, configManager: Pick<ConfigManager, 'get'>, providerRegistry: Pick<ProviderRegistry, 'getCurrentModel'>, runtimeBus?: RuntimeEventBus | null, emitterContext?: import('../runtime/emitters/index.js').EmitterContext | null, planManager?: Pick<ExecutionPlanManager, 'updateItem'> | null): string[];
+export {};
+//# sourceMappingURL=orchestrator-tool-runtime.d.ts.map

package/dist/_internal/platform/core/orchestrator-tool-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-tool-runtime.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/core/orchestrator-tool-runtime.ts"],"names":[],"mappings":"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"}

package/dist/_internal/platform/core/orchestrator-tool-runtime.js

@@ -0,0 +1,373 @@
+import { ToolError, PermissionError } from '@pellux/goodvibes-sdk/platform/types/errors';
+import { emitOrchestrationGraphCreated, emitOrchestrationNodeAdded, emitOrchestrationNodeStarted, emitOrchestrationRecursionGuardTriggered, emitToolExecuting, emitToolFailed, emitToolPermissioned, emitToolReconciled, emitToolReceived, emitToolSucceeded, } from '../runtime/emitters/index.js';
+import { buildSyntheticResult, detectUnresolvedToolCalls } from '@pellux/goodvibes-sdk/platform/core/tool-reconciliation';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { evaluateOrchestrationSpawn } from '../runtime/orchestration/spawn-policy.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+export async function executeToolCalls(deps, turnId, calls) {
+    const results = [];
+    for (const call of calls) {
+        if (deps.runtimeBus) {
+            emitToolReceived(deps.runtimeBus, deps.emitterContext(turnId), {
+                callId: call.id,
+                turnId,
+                tool: call.name,
+                args: call.arguments,
+            });
+        }
+        const approved = await deps.permissionManager.check(call.name, call.arguments);
+        if (deps.runtimeBus) {
+            emitToolPermissioned(deps.runtimeBus, deps.emitterContext(turnId), {
+                callId: call.id,
+                turnId,
+                tool: call.name,
+                approved,
+            });
+        }
+        if (!approved) {
+            const err = new PermissionError(`Permission denied for tool '${call.name}'`);
+            const deniedResult = {
+                callId: call.id,
+                success: false,
+                error: err.message,
+            };
+            results.push(deniedResult);
+            if (deps.runtimeBus) {
+                emitToolFailed(deps.runtimeBus, deps.emitterContext(turnId), {
+                    callId: call.id,
+                    turnId,
+                    tool: call.name,
+                    error: err.message,
+                    durationMs: 0,
+                    result: deniedResult,
+                });
+            }
+            continue;
+        }
+        const startedAt = Date.now();
+        if (deps.runtimeBus) {
+            emitToolExecuting(deps.runtimeBus, deps.emitterContext(turnId), {
+                callId: call.id,
+                turnId,
+                tool: call.name,
+                startedAt,
+            });
+        }
+        if (deps.hookDispatcher) {
+            try {
+                const preEvent = {
+                    path: `Pre:tool:${call.name}`,
+                    phase: 'Pre',
+                    category: 'tool',
+                    specific: call.name,
+                    sessionId: deps.sessionId,
+                    timestamp: Date.now(),
+                    payload: { callId: call.id, tool: call.name, args: call.arguments },
+                };
+                const preResult = await deps.hookDispatcher.fire(preEvent);
+                if (preResult.decision === 'deny') {
+                    const deniedResult = {
+                        callId: call.id,
+                        success: false,
+                        error: preResult.reason ?? `Tool '${call.name}' denied by hook`,
+                    };
+                    if (deps.runtimeBus) {
+                        emitToolFailed(deps.runtimeBus, deps.emitterContext(turnId), {
+                            callId: call.id,
+                            turnId,
+                            tool: call.name,
+                            error: deniedResult.error ?? `Tool '${call.name}' denied by hook`,
+                            durationMs: Date.now() - startedAt,
+                            result: deniedResult,
+                        });
+                    }
+                    results.push(deniedResult);
+                    continue;
+                }
+            }
+            catch (hookErr) {
+                logger.error('Orchestrator: Pre hook error', {
+                    tool: call.name,
+                    error: hookErr instanceof Error ? hookErr.message : String(hookErr),
+                });
+            }
+        }
+        let result;
+        try {
+            result = await deps.toolRegistry.execute(call.id, call.name, call.arguments);
+        }
+        catch (err) {
+            const message = err instanceof ToolError
+                ? err.message
+                : err instanceof Error
+                    ? err.message
+                    : summarizeError(err);
+            result = {
+                callId: call.id,
+                success: false,
+                error: message,
+            };
+            if (deps.hookDispatcher) {
+                try {
+                    const failEvent = {
+                        path: `Fail:tool:${call.name}`,
+                        phase: 'Fail',
+                        category: 'tool',
+                        specific: call.name,
+                        sessionId: deps.sessionId,
+                        timestamp: Date.now(),
+                        payload: { callId: call.id, tool: call.name, error: message },
+                    };
+                    await deps.hookDispatcher.fire(failEvent);
+                }
+                catch (hookErr) {
+                    logger.error('Orchestrator: Fail hook error', {
+                        tool: call.name,
+                        error: hookErr instanceof Error ? hookErr.message : String(hookErr),
+                    });
+                }
+            }
+        }
+        if (deps.hookDispatcher && result.success === true) {
+            try {
+                const postEvent = {
+                    path: `Post:tool:${call.name}`,
+                    phase: 'Post',
+                    category: 'tool',
+                    specific: call.name,
+                    sessionId: deps.sessionId,
+                    timestamp: Date.now(),
+                    payload: { callId: call.id, tool: call.name, result },
+                };
+                await deps.hookDispatcher.fire(postEvent);
+            }
+            catch (hookErr) {
+                logger.error('Orchestrator: Post hook error', {
+                    tool: call.name,
+                    error: hookErr instanceof Error ? hookErr.message : String(hookErr),
+                });
+            }
+        }
+        if (deps.runtimeBus) {
+            if (result.success) {
+                emitToolSucceeded(deps.runtimeBus, deps.emitterContext(turnId), {
+                    callId: call.id,
+                    turnId,
+                    tool: call.name,
+                    durationMs: Date.now() - startedAt,
+                    result,
+                });
+            }
+            else {
+                emitToolFailed(deps.runtimeBus, deps.emitterContext(turnId), {
+                    callId: call.id,
+                    turnId,
+                    tool: call.name,
+                    error: result.error ?? 'unknown tool failure',
+                    durationMs: Date.now() - startedAt,
+                    result,
+                });
+            }
+        }
+        if (deps.hookDispatcher && (call.name === 'write' || call.name === 'edit')) {
+            const filePath = typeof call.arguments['path'] === 'string' ? call.arguments['path'] :
+                (Array.isArray(call.arguments['files']) ? JSON.stringify(call.arguments['files']) : '');
+            if (result.success) {
+                deps.hookDispatcher.fire({
+                    path: `Post:file:${call.name}`,
+                    phase: 'Post',
+                    category: 'file',
+                    specific: call.name,
+                    sessionId: deps.sessionId,
+                    timestamp: Date.now(),
+                    payload: { tool: call.name, path: filePath, callId: call.id },
+                }).catch((err) => { logger.debug(`Post:file:${call.name} hook error`, { error: summarizeError(err) }); });
+            }
+            else {
+                deps.hookDispatcher.fire({
+                    path: `Fail:file:${call.name}`,
+                    phase: 'Fail',
+                    category: 'file',
+                    specific: call.name,
+                    sessionId: deps.sessionId,
+                    timestamp: Date.now(),
+                    payload: { tool: call.name, path: filePath, callId: call.id, error: result.error },
+                }).catch((err) => { logger.debug(`Fail:file:${call.name} hook error`, { error: summarizeError(err) }); });
+            }
+        }
+        if (result.success && result.output && call.name === 'read') {
+            try {
+                const parsed = JSON.parse(result.output);
+                if (Array.isArray(parsed['images']) && parsed['images'].length > 0) {
+                    const images = parsed['images'];
+                    delete parsed['images'];
+                    if (parsed['files'] && typeof parsed['files'] === 'object') {
+                        for (const key of Object.keys(parsed['files'])) {
+                            const f = parsed['files'][key];
+                            if (f && typeof f === 'object') {
+                                delete f['imageData'];
+                            }
+                        }
+                    }
+                    result.output = JSON.stringify(parsed);
+                    result._images = images;
+                }
+            }
+            catch {
+                // leave result as-is
+            }
+        }
+        results.push(result);
+    }
+    return results;
+}
+export function reconcileUnresolvedToolCalls(deps, resolvedResults, reason) {
+    const pending = deps.pendingToolCalls;
+    if (pending.length === 0)
+        return;
+    const unresolved = detectUnresolvedToolCalls(pending, resolvedResults);
+    if (unresolved.length === 0) {
+        deps.setPendingToolCalls([]);
+        return;
+    }
+    if (!deps.isReconciliationEnabled()) {
+        logger.warn('Orchestrator: unresolved tool calls detected but reconciliation is disabled. ' +
+            'Enable the tool-result-reconciliation flag to suppress this.', { count: unresolved.length, callIds: unresolved.map((c) => c.id), reason });
+        deps.setPendingToolCalls([]);
+        return;
+    }
+    const syntheticResults = unresolved.map((call) => buildSyntheticResult(call, reason));
+    deps.conversation.addToolResults(syntheticResults);
+    const turnId = deps.currentSubmissionKey ?? `reconciled:${Date.now()}`;
+    for (const sr of syntheticResults) {
+        if (deps.runtimeBus) {
+            emitToolFailed(deps.runtimeBus, deps.emitterContext(turnId), {
+                callId: sr.callId,
+                turnId,
+                tool: unresolved.find((call) => call.id === sr.callId)?.name ?? 'unknown',
+                error: sr.error ?? 'synthetic tool reconciliation failure',
+                durationMs: 0,
+                result: sr,
+            });
+        }
+    }
+    deps.conversation.addSystemMessage(`[Tool Reconciliation] ${unresolved.length} tool call(s) (${unresolved.map((c) => `'${c.name}'`).join(', ')}) were not executed before ` +
+        `the turn ended. Synthetic error results have been injected. ` +
+        `Review the situation and avoid repeating the same tool calls if the root cause has not changed.`);
+    if (deps.runtimeBus) {
+        emitToolReconciled(deps.runtimeBus, deps.emitterContext(turnId), {
+            turnId,
+            count: unresolved.length,
+            callIds: unresolved.map((c) => c.id),
+            toolNames: unresolved.map((c) => c.name),
+            reason,
+            timestamp: Date.now(),
+        });
+    }
+    logger.warn('Orchestrator: reconciled unresolved tool calls', {
+        count: unresolved.length,
+        callIds: unresolved.map((c) => c.id),
+        reason,
+    });
+    deps.setPendingToolCalls([]);
+}
+export function autoSpawnPendingItems(conversation, plan, items, agentManager, configManager, providerRegistry, runtimeBus = null, emitterContext = null, planManager = null) {
+    const currentModel = providerRegistry.getCurrentModel();
+    const graphId = `plan:${plan.id}`;
+    const ctx = runtimeBus && emitterContext
+        ? {
+            ...emitterContext,
+            traceId: `${emitterContext.traceId}:${graphId}`,
+        }
+        : null;
+    if (runtimeBus && ctx) {
+        emitOrchestrationGraphCreated(runtimeBus, ctx, {
+            graphId,
+            title: plan.title,
+            mode: 'graph-execute',
+        });
+    }
+    let running = agentManager.list().filter(a => a.status === 'running' || a.status === 'pending').length;
+    const spawnDecision = evaluateOrchestrationSpawn({
+        configManager,
+        mode: 'plan-auto',
+        activeAgents: running,
+        requestedDepth: 1,
+    });
+    if (!spawnDecision.allowed) {
+        if (runtimeBus && ctx) {
+            emitOrchestrationRecursionGuardTriggered(runtimeBus, ctx, {
+                graphId,
+                depth: 1,
+                activeAgents: running,
+                reason: spawnDecision.reason ?? 'plan auto-spawn is currently blocked',
+            });
+        }
+        return [];
+    }
+    const spawned = [];
+    for (const item of items) {
+        if (runtimeBus && ctx) {
+            emitOrchestrationNodeAdded(runtimeBus, ctx, {
+                graphId,
+                nodeId: item.id,
+                title: item.description,
+                role: 'engineer',
+                dependsOn: item.dependencies ?? [],
+                taskId: item.id,
+            });
+        }
+        const decision = evaluateOrchestrationSpawn({
+            configManager,
+            mode: 'plan-auto',
+            activeAgents: running,
+            requestedDepth: 1,
+        });
+        if (!decision.allowed) {
+            if (runtimeBus && ctx) {
+                emitOrchestrationRecursionGuardTriggered(runtimeBus, ctx, {
+                    graphId,
+                    nodeId: item.id,
+                    depth: 1,
+                    activeAgents: running,
+                    reason: decision.reason ?? 'plan auto-spawn is currently blocked',
+                });
+            }
+            conversation.addSystemMessage(`[Plan] ${decision.reason ?? `Agent limit reached (${running}/${decision.maxAgents}). Remaining items will be spawned as agents complete.`}`);
+            break;
+        }
+        try {
+            const spawnInput = {
+                mode: 'spawn',
+                task: item.description,
+                template: 'engineer',
+                model: currentModel.id,
+                provider: currentModel.provider,
+            };
+            const agentRecord = agentManager.spawn(spawnInput);
+            if (runtimeBus && ctx) {
+                emitOrchestrationNodeStarted(runtimeBus, ctx, {
+                    graphId,
+                    nodeId: item.id,
+                    taskId: item.id,
+                    agentId: agentRecord.id,
+                });
+            }
+            planManager?.updateItem(plan.id, item.id, 'in_progress', agentRecord.id);
+            spawned.push(item.description);
+            running++;
+            logger.info('Orchestrator: Auto-spawned agent for plan item', {
+                agentId: agentRecord.id,
+                planItemId: item.id,
+                description: item.description,
+            });
+        }
+        catch (spawnErr) {
+            logger.error('Orchestrator: Failed to auto-spawn agent for plan item', {
+                planItemId: item.id,
+                error: spawnErr instanceof Error ? spawnErr.message : String(spawnErr),
+            });
+        }
+    }
+    return spawned;
+}