@pixelbyte-software/pixcode 1.54.10 → 1.55.0

package/dist-server/server/modules/orchestration/workflows/workflow-runner.js

@@ -1,1718 +0,0 @@
-import crypto from 'node:crypto';
-import { PIXCODE_HANDOFF_PROTOCOL, formatHandoffArtifactForContext, handoffArtifactToWorkflowArtifact, parseHandoffArtifact, } from '../../../modules/orchestration/workflows/handoff-artifact.js';
-import { buildWorkflowContextPacket, formatContextPacketForPrompt, } from '../../../modules/orchestration/workflows/context-packet.js';
-import { classifyWorkflowFailure, resolveWorkflowFallbackDecision, } from '../../../modules/orchestration/workflows/workflow-fallback-policy.js';
-import { evaluatePermissionRequest, resolvePermissionPolicyFromMetadata, } from '../../../modules/orchestration/security/permission-policy.js';
-import { resolveWorkflowWorkspace, workspaceContextPrompt, workspaceTargetMetadata, } from '../../../modules/orchestration/workflows/workspace-target.js';
-import { workflowStore } from '../../../modules/orchestration/workflows/workflow-store.js';
-import { orchestrationTaskService } from '../../../modules/orchestration/tasks/orchestration-task.service.js';
-import { cancelA2ATask, getA2ATask, submitA2ATask, } from '../../../modules/orchestration/a2a/task-dispatcher.js';
-// @ts-ignore — plain-JS service
-import { getDefaultProviderModel, getProviderModelRegistryEntry, getStaticProviderModels, } from '../../../services/model-registry.js';
-// @ts-ignore — plain-JS service
-import { createNotificationEvent, notifyRunFailed, notifyRunStopped, notifyUserIfEnabled, } from '../../../services/notification-orchestrator.js';
-// @ts-ignore — plain-JS service
-import { dispatchWebhookEvent } from '../../../services/webhooks.js';
-const TERMINAL = new Set(['completed', 'failed', 'canceled']);
-const SKIPPED = 'skipped';
-const BACKEND_HANDOFF_TIMEOUT_MS = 120_000;
-const MAX_OUTPUT_CONTEXT_CHARS = 12_000;
-const DEFAULT_MAX_REPAIR_CYCLES = 1;
-const MAX_REPAIR_CYCLES = 5;
-const HANDOFF_ARTIFACT_EXAMPLE = [
-    '{',
-    '  "protocol": "pixcode.handoff.v1",',
-    '  "taskStatus": "ready | completed | blocked | failed | needs-review",',
-    '  "contextSummary": "Compacted context the next agent needs.",',
-    '  "taskResult": "What was decided or completed in this step.",',
-    '  "changedFiles": [],',
-    '  "blockers": [],',
-    '  "risks": [],',
-    '  "nextAction": "The requested next action.",',
-    '  "nextInstructions": "Specific instructions for the next agent."',
-    '}',
-].join('\n');
-const KNOWN_AGENT_ROLES = [
-    'backend',
-    'frontend',
-    'review',
-    'implementation',
-    'proposal',
-    'critique',
-    'response',
-    'decision',
-    'report',
-];
-class WorkflowCanceledError extends Error {
-    constructor() {
-        super('Workflow canceled.');
-        this.name = 'WorkflowCanceledError';
-    }
-}
-class WorkflowNodeTimeoutError extends Error {
-    timeoutMs;
-    constructor(timeoutMs) {
-        super(`Workflow node timed out after ${Math.round(timeoutMs / 1000)}s.`);
-        this.timeoutMs = timeoutMs;
-        this.name = 'WorkflowNodeTimeoutError';
-    }
-}
-function newId(prefix) {
-    return `${prefix}_${crypto.randomBytes(8).toString('hex')}`;
-}
-function validateWorkflow(workflow) {
-    if (workflow.nodes.length > 64) {
-        throw new Error('Workflow node limit exceeded.');
-    }
-    const ids = new Set(workflow.nodes.map((node) => node.id));
-    for (const node of workflow.nodes) {
-        for (const input of node.inputs) {
-            if (!ids.has(input)) {
-                throw new Error(`Workflow node ${node.id} references missing input ${input}.`);
-            }
-        }
-    }
-}
-const sendRunStoppedNotification = notifyRunStopped;
-const sendRunFailedNotification = notifyRunFailed;
-const adapterProviderMap = {
-    'claude-code': 'claude',
-    cursor: 'cursor',
-    codex: 'codex',
-    gemini: 'gemini',
-    qwen: 'qwen',
-    opencode: 'opencode',
-};
-function readAgentRole(value) {
-    return typeof value === 'string' && value.trim() && value.trim() !== 'auto'
-        ? value.trim()
-        : undefined;
-}
-function isKnownAgentRole(value) {
-    return Boolean(value && KNOWN_AGENT_ROLES.includes(value));
-}
-function getMetadataRecord(metadata, key) {
-    return readRecord(metadata?.[key]) ?? {};
-}
-function readRecord(value) {
-    return value && typeof value === 'object' ? value : undefined;
-}
-function readString(value) {
-    return typeof value === 'string' && value.trim() ? value : undefined;
-}
-function readNotificationUserId(metadata) {
-    const value = metadata?.userId;
-    return typeof value === 'string' || typeof value === 'number' ? value : null;
-}
-function workflowNotificationTitle(run) {
-    return readString(run.metadata?.workflowName) ?? run.workflowId;
-}
-function notifyWorkflowRunFinished(run) {
-    const userId = readNotificationUserId(run.metadata);
-    if (!userId)
-        return;
-    if (run.status === 'completed') {
-        sendRunStoppedNotification({
-            userId,
-            provider: 'system',
-            sessionId: run.id,
-            sessionName: workflowNotificationTitle(run),
-            stopReason: 'Orchestration completed',
-        });
-        return;
-    }
-    if (run.status === 'canceled') {
-        sendRunStoppedNotification({
-            userId,
-            provider: 'system',
-            sessionId: run.id,
-            sessionName: workflowNotificationTitle(run),
-            stopReason: 'Orchestration canceled',
-        });
-        return;
-    }
-    if (run.status === 'failed') {
-        sendRunFailedNotification({
-            userId,
-            provider: 'system',
-            sessionId: run.id,
-            sessionName: workflowNotificationTitle(run),
-            error: readString(run.metadata?.error) ?? 'Orchestration failed',
-        });
-    }
-}
-function permissionPolicyFromRun(run) {
-    return resolvePermissionPolicyFromMetadata(run.metadata);
-}
-function permissionPolicyEvents(run) {
-    return Array.isArray(run.metadata?.permissionPolicyEvents)
-        ? run.metadata.permissionPolicyEvents.filter((event) => Boolean(event && typeof event === 'object'))
-        : [];
-}
-function permissionApprovalRequests(run) {
-    return Array.isArray(run.metadata?.pendingPermissionApprovals)
-        ? run.metadata.pendingPermissionApprovals.filter((event) => Boolean(event && typeof event === 'object'))
-        : [];
-}
-function notifyPermissionApprovalRequested(run, decision) {
-    const userId = readNotificationUserId(run.metadata);
-    if (!userId || !decision.approvalRequest)
-        return;
-    const event = createNotificationEvent({
-        provider: 'system',
-        sessionId: run.id,
-        kind: 'action_required',
-        code: 'permission.required',
-        meta: {
-            toolName: decision.capabilities.join(', '),
-            sessionName: workflowNotificationTitle(run),
-        },
-        severity: 'warning',
-        requiresUserAction: true,
-        dedupeKey: `workflow:permission:${run.id}:${decision.requestId}`,
-    });
-    notifyUserIfEnabled({
-        userId,
-        event,
-    });
-}
-function readBoolean(value) {
-    return typeof value === 'boolean' ? value : undefined;
-}
-function modelValueSet(models) {
-    return new Set(models.map((model) => model.value).filter(Boolean));
-}
-function preferredFallbackModel(models, defaultModel) {
-    const values = modelValueSet(models);
-    if (defaultModel && values.has(defaultModel))
-        return defaultModel;
-    return models.find((model) => model.source === 'api' && model.free)?.value
-        ?? models.find((model) => model.source === 'api')?.value
-        ?? models.find((model) => model.free)?.value
-        ?? models[0]?.value
-        ?? defaultModel;
-}
-async function resolveWorkflowModel(adapterId, requestedModel) {
-    const provider = adapterProviderMap[adapterId];
-    if (!provider)
-        return requestedModel;
-    const defaultModel = getDefaultProviderModel(provider);
-    if (!requestedModel)
-        return defaultModel;
-    try {
-        const result = await getProviderModelRegistryEntry(provider);
-        const models = Array.isArray(result?.models) ? result.models : [];
-        if (modelValueSet(models).has(requestedModel)) {
-            return requestedModel;
-        }
-        return preferredFallbackModel(models, defaultModel) ?? requestedModel;
-    }
-    catch {
-        const staticModels = getStaticProviderModels(provider);
-        const staticValues = modelValueSet(staticModels);
-        return staticValues.has(requestedModel)
-            ? requestedModel
-            : preferredFallbackModel(staticModels, defaultModel) ?? requestedModel;
-    }
-}
-function readIsolation(value) {
-    return value === 'host' || value === 'worktree' || value === 'docker' ? value : undefined;
-}
-function readLegacyEnabledAdapters(metadata) {
-    return Array.isArray(metadata?.enabledAdapters)
-        ? metadata.enabledAdapters.filter((value) => typeof value === 'string' && value.trim().length > 0)
-        : [];
-}
-function readMetadataAgents(metadata) {
-    if (!Array.isArray(metadata?.agents))
-        return [];
-    return metadata.agents
-        .map((value, index) => {
-        if (!value || typeof value !== 'object')
-            return null;
-        const record = value;
-        const adapterId = readString(record.adapterId);
-        if (!adapterId)
-            return null;
-        if (readBoolean(record.enabled) === false)
-            return null;
-        return {
-            instanceId: readString(record.instanceId) ?? `${adapterId}-${index + 1}`,
-            adapterId,
-            label: readString(record.label) ?? `${adapterId} #${index + 1}`,
-            role: readAgentRole(record.role),
-            instruction: readString(record.instruction),
-            model: readString(record.model),
-            permissionMode: readString(record.permissionMode),
-            toolsSettings: readRecord(record.toolsSettings),
-            order: index,
-        };
-    })
-        .filter((value) => Boolean(value))
-        .slice(0, 16);
-}
-function readAgentAssignments(metadata) {
-    const agents = readMetadataAgents(metadata);
-    if (agents.length > 0)
-        return agents;
-    return readLegacyEnabledAdapters(metadata).map((adapterId, index) => ({
-        instanceId: `${adapterId}-${index + 1}`,
-        adapterId,
-        label: `${adapterId} #${index + 1}`,
-        order: index,
-    }));
-}
-function readEnabledAdapters(metadata) {
-    return [...new Set(readAgentAssignments(metadata).map((agent) => agent.adapterId))];
-}
-function readMaxParallelAgents(metadata) {
-    const settings = getMetadataRecord(metadata, 'settings');
-    const value = settings.maxParallelAgents;
-    return typeof value === 'number' && Number.isFinite(value)
-        ? Math.max(1, Math.min(12, Math.round(value)))
-        : 3;
-}
-function readMaxRepairCycles(metadata) {
-    const settings = getMetadataRecord(metadata, 'settings');
-    const value = settings.maxRepairCycles;
-    return typeof value === 'number' && Number.isFinite(value)
-        ? Math.max(0, Math.min(MAX_REPAIR_CYCLES, Math.round(value)))
-        : DEFAULT_MAX_REPAIR_CYCLES;
-}
-function safeNodeId(adapterId, suffix) {
-    return `${adapterId.replace(/[^a-zA-Z0-9_]+/g, '_')}_${suffix}`;
-}
-function safeAgentNodeId(agent, index, suffix) {
-    return `agent_${index + 1}_${safeNodeId(agent.adapterId, suffix)}`;
-}
-function agentRoster(agents) {
-    return agents
-        .map((agent, index) => {
-        const instruction = agent.instruction
-            ? `\n   User assignment: ${agent.instruction}`
-            : '';
-        const role = agent.role ? `\n   API role: ${agent.role}` : '';
-        return `${index + 1}. ${agent.label} (${agent.adapterId})${role}${instruction}`;
-    })
-        .join('\n');
-}
-function inferAgentRole(agent) {
-    if (isKnownAgentRole(agent.role))
-        return agent.role;
-    const text = `${agent.label} ${agent.adapterId} ${agent.role ?? ''} ${agent.instruction ?? ''}`.toLocaleLowerCase('tr');
-    if (/(test|tester|qa|review|code review|hata|kontrol|onay|incele|doğrula|dogrula)/u.test(text)) {
-        return 'review';
-    }
-    if (/(backend|back-end|api|server|veri|database|db|fapi|endpoint|websocket|ws)/u.test(text)) {
-        return 'backend';
-    }
-    if (/(frontend|front-end|ui|ux|tailwind|tasarım|tasarim|design|chart|tradingview|arayüz|arayuz)/u.test(text)) {
-        return 'frontend';
-    }
-    return 'implementation';
-}
-function inferImplementationRole(agent) {
-    const role = inferAgentRole(agent);
-    return role === 'backend' || role === 'frontend' || role === 'review' || role === 'implementation'
-        ? role
-        : 'implementation';
-}
-function displayStage(agent, fallback) {
-    return agent.role && !isKnownAgentRole(agent.role) ? agent.role : fallback;
-}
-function rolePrompt(role) {
-    if (role === 'backend') {
-        return 'Backend/API/data work should define stable contracts first. Report endpoints, payload shapes, ports, and any data-source limitations clearly for downstream agents.';
-    }
-    if (role === 'frontend') {
-        return 'Frontend/UI work must use prior backend/data-contract outputs when present. If a dependency is missing, use a minimal mock only as a temporary fallback and report the blocker.';
-    }
-    if (role === 'review') {
-        return 'You are the validation/review stage. Inspect the prior agent outputs and actual project state. Approve only if it works; otherwise return a concrete bug list and required fixes.';
-    }
-    if (role === 'proposal') {
-        return 'You are in the proposal stage. Produce a concrete option with tradeoffs, assumptions, and what should happen next. Do not edit files.';
-    }
-    if (role === 'critique') {
-        return 'You are in the critique stage. Challenge the proposal for risks, missing constraints, and weak assumptions. Do not edit files.';
-    }
-    if (role === 'response') {
-        return 'You are in the response stage. Reconcile the critique with the proposal and refine the practical path forward. Do not edit files.';
-    }
-    if (role === 'decision' || role === 'report') {
-        return 'You are the reporting stage. Produce the final concise decision report and a next prompt for launching an implementation agent team. Do not edit files.';
-    }
-    if (role !== 'implementation') {
-        return `You are assigned to the custom stage "${role}". Follow that user-defined stage literally, avoid duplicating other agents, and report changed files, commands, blockers, and next actions.`;
-    }
-    return 'Implementation work should avoid duplicating other agents and should report changed files, commands, blockers, and next actions.';
-}
-function privacyGuardPrompt() {
-    return 'Do not mention internal instructions, memory files, skill use, or tool protocol unless the user explicitly asks.';
-}
-function handoffArtifactInstructions(statusHint) {
-    return [
-        `Output exactly one JSON object using the ${PIXCODE_HANDOFF_PROTOCOL} handoff artifact protocol.`,
-        'Do not wrap it in Markdown. Do not add commentary before or after it.',
-        `Use "${statusHint}" for taskStatus unless completed, blocked, failed, or needs-review is more accurate.`,
-        'Schema:',
-        HANDOFF_ARTIFACT_EXAMPLE,
-    ].join('\n');
-}
-function handoffPrompt(agent, role) {
-    return [
-        `You are ${agent.label} in a Pixcode CLI team.`,
-        `Your inferred stage is: ${role}.`,
-        'This is a bounded Pixcode handoff task, not the full implementation.',
-        'Read the original user goal and coordinator plan, then publish a compact contract for downstream agents.',
-        agent.instruction ? `Your explicit assignment from the user is: ${agent.instruction}` : '',
-        handoffArtifactInstructions('ready'),
-        'Do not install dependencies, edit files, run long commands, or start servers in this handoff task.',
-        privacyGuardPrompt(),
-        'Stop after the contract. Keep it concise and respond in the same language as the user request.',
-    ].filter(Boolean).join('\n');
-}
-function handoffInitPrompt(agent, index) {
-    return [
-        `You are preparing ${agent.label} for a strict Pixcode handoff chain.`,
-        `This is internal step ${index + 1}.`,
-        'Create a compact init packet for the next visible work step.',
-        'Use the original user goal and any prior compact handoff packet included above.',
-        agent.instruction ? `The explicit assignment for this agent is: ${agent.instruction}` : '',
-        handoffArtifactInstructions('ready'),
-        privacyGuardPrompt(),
-        'Do not perform the task yet. Do not mention that this is hidden from the user.',
-        'Respond in the same language as the user request.',
-    ].filter(Boolean).join('\n');
-}
-function handoffWorkPrompt(agent, index) {
-    return [
-        `You are ${agent.label} in a strict Pixcode handoff chain.`,
-        `This is visible work step ${index + 1}.`,
-        'The internal init packet above is your starting context. Do the assigned work now.',
-        agent.instruction
-            ? `Your explicit assignment from the user is: ${agent.instruction}`
-            : 'Use the init packet and original user goal to choose the next useful work for this step.',
-        rolePrompt(agent.role ?? 'implementation'),
-        privacyGuardPrompt(),
-        'Report only user-facing progress, changed files, commands, verification, blockers, and next actions.',
-        'Respond in the same language as the user request.',
-    ].filter(Boolean).join('\n');
-}
-function handoffCompactPrompt(agent, index) {
-    return [
-        `You are compacting ${agent.label}'s strict handoff output for the next Pixcode agent.`,
-        `This is internal compact step ${index + 1}.`,
-        'Read the prior visible work output included above and create a compact handoff packet.',
-        handoffArtifactInstructions('completed'),
-        privacyGuardPrompt(),
-        'Do not include raw logs unless they are essential. Keep it concise and actionable.',
-        'Respond in the same language as the user request.',
-    ].join('\n');
-}
-function compactOutputForContext(text) {
-    if (text.length <= MAX_OUTPUT_CONTEXT_CHARS) {
-        return text;
-    }
-    const edge = Math.floor(MAX_OUTPUT_CONTEXT_CHARS / 2);
-    return [
-        text.slice(0, edge),
-        `\n\n[...${text.length - MAX_OUTPUT_CONTEXT_CHARS} characters omitted from prior agent output...]\n\n`,
-        text.slice(-edge),
-    ].join('');
-}
-function requiresHandoffArtifact(node) {
-    return node.stage === 'handoff' || node.stage === 'handoff_init' || node.stage === 'handoff_compact';
-}
-function handoffArtifactSource(result) {
-    const structured = result.artifacts.find((artifact) => artifact.type === 'handoff-artifact' && artifact.data);
-    if (structured?.data) {
-        return JSON.stringify(structured.data);
-    }
-    return result.text;
-}
-function isExternalDirectoryPermissionError(value) {
-    const text = String(value ?? '').toLocaleLowerCase('en');
-    return (text.includes('external_directory') ||
-        /permission requested:.*auto-rejecting/u.test(text) ||
-        /auto-rejecting.*permission/u.test(text) ||
-        /outside (the )?(workspace|working directory)/u.test(text) ||
-        /permission.*external/u.test(text));
-}
-function isFinalReportNode(node) {
-    return node.id === 'final_report' || node.stage === 'final_report' || node.stage === 'report';
-}
-function workspaceNeedsHostPermissionBypass(target) {
-    return (target.kind === 'selected_project' || target.kind === 'custom') && target.projectPath !== target.appRoot;
-}
-function resolveNodePermissionMode(node, target) {
-    if (node.permissionMode && node.permissionMode !== 'default') {
-        return node.permissionMode;
-    }
-    if (workspaceNeedsHostPermissionBypass(target)) {
-        return 'bypassPermissions';
-    }
-    return node.permissionMode;
-}
-function buildPermissionFallbackOutput(node, reason, target) {
-    return [
-        'Bu adım çalışma alanı izin sınırına takıldı.',
-        '',
-        `Ajan: ${node.agentLabel || node.id}`,
-        `Hedef çalışma alanı: ${target.projectPath}`,
-        `Hata: ${reason}`,
-        '',
-        'Pixcode bu adımı workflow dışına taşırmadan devam ettirdi. Ajan aynı dış dizin yoluna tekrar tekrar erişmek yerine mevcut bağlamla ilerlemeli.',
-    ].join('\n');
-}
-function buildFallbackFinalReport(outputs, reason, target) {
-    const completedOutputs = [...outputs.entries()]
-        .map(([nodeId, output]) => [`## ${nodeId}`, output || '(çıktı yok)'].join('\n'))
-        .join('\n\n');
-    return [
-        'Final rapor aracı çalışma alanı izin sınırına takıldı, bu yüzden Pixcode tamamlanan ajan çıktılarından güvenli bir özet üretti.',
-        '',
-        `Hedef çalışma alanı: ${target.projectPath}`,
-        `İzin hatası: ${reason}`,
-        '',
-        completedOutputs || 'Bu turda final rapora aktarılabilecek tamamlanmış ajan çıktısı yok.',
-    ].join('\n');
-}
-function completeNodeWithPermissionFallback(nodeRun, node, outputs, completed, reason, target) {
-    const outputText = isFinalReportNode(node)
-        ? buildFallbackFinalReport(outputs, reason, target)
-        : buildPermissionFallbackOutput(node, reason, target);
-    nodeRun.status = 'completed';
-    nodeRun.error = reason;
-    nodeRun.outputText = outputText;
-    nodeRun.finishedAt = nodeRun.finishedAt ?? Date.now();
-    outputs.set(node.id, compactOutputForContext(outputText));
-    completed.add(node.id);
-}
-function expandAgentTeamWorkflow(workflow, metadata) {
-    const agents = readAgentAssignments(metadata);
-    if (agents.length === 0) {
-        throw new Error('Select at least one CLI agent.');
-    }
-    const coordinator = agents.find((agent) => agent.adapterId === 'claude-code') ?? agents[0];
-    const roster = agentRoster(agents);
-    const workerSpecs = agents.map((agent, index) => ({
-        agent,
-        role: inferImplementationRole(agent),
-        stage: displayStage(agent, inferImplementationRole(agent)),
-        nodeId: safeAgentNodeId(agent, index, 'work'),
-        handoffNodeId: safeAgentNodeId(agent, index, 'handoff'),
-    }));
-    const backendHandoffNodeIds = workerSpecs
-        .filter((spec) => spec.role === 'backend')
-        .map((spec) => spec.handoffNodeId);
-    const implementationNodeIds = workerSpecs
-        .filter((spec) => spec.role !== 'review')
-        .map((spec) => spec.nodeId);
-    const handoffNodes = workerSpecs
-        .filter((spec) => spec.role === 'backend')
-        .map(({ agent, role, handoffNodeId }) => ({
-        id: handoffNodeId,
-        adapterId: agent.adapterId,
-        agentInstanceId: agent.instanceId,
-        agentLabel: `${agent.label} Handoff`,
-        assignment: agent.instruction,
-        stage: 'handoff',
-        model: agent.model,
-        permissionMode: agent.permissionMode,
-        toolsSettings: agent.toolsSettings,
-        prompt: handoffPrompt(agent, role),
-        inputs: ['coordinator'],
-        output: 'message',
-        onFail: 'continue',
-        timeoutMs: BACKEND_HANDOFF_TIMEOUT_MS,
-    }));
-    const workerNodes = workerSpecs.map(({ agent, role, stage, nodeId, handoffNodeId }) => {
-        const inputs = role === 'review'
-            ? (implementationNodeIds.length > 0 ? implementationNodeIds : ['coordinator'])
-            : role === 'frontend' && backendHandoffNodeIds.length > 0
-                ? ['coordinator', ...backendHandoffNodeIds]
-                : role === 'backend'
-                    ? ['coordinator', handoffNodeId]
-                    : ['coordinator'];
-        return {
-            id: nodeId,
-            adapterId: agent.adapterId,
-            agentInstanceId: agent.instanceId,
-            agentLabel: agent.label,
-            assignment: agent.instruction,
-            stage,
-            model: agent.model,
-            permissionMode: agent.permissionMode,
-            toolsSettings: agent.toolsSettings,
-            prompt: [
-                `You are ${agent.label} in a Pixcode CLI team.`,
-                `Your stage is: ${stage}.`,
-                stage !== role ? `Runtime routing category: ${role}.` : '',
-                'The coordinator plan and any dependency outputs are included above. Use them together with the original user goal.',
-                agent.instruction
-                    ? `Your explicit assignment from the user is: ${agent.instruction}`
-                    : 'No fixed per-agent assignment was set. Take the part assigned to you by the coordinator; if none is named, choose useful work that fits this CLI.',
-                rolePrompt(stage),
-                privacyGuardPrompt(),
-                'Respond in the same language as the user request.',
-            ].filter(Boolean).join('\n'),
-            inputs,
-            output: 'both',
-            onFail: 'continue',
-        };
-    });
-    return {
-        ...workflow,
-        nodes: [
-            {
-                id: 'coordinator',
-                adapterId: coordinator.adapterId,
-                agentInstanceId: coordinator.instanceId,
-                agentLabel: coordinator.label,
-                stage: 'coordinator',
-                model: coordinator.model,
-                permissionMode: coordinator.permissionMode,
-                toolsSettings: coordinator.toolsSettings,
-                prompt: [
-                    'You are the coordinator for a Pixcode CLI agent team.',
-                    'Read the user goal, active CLI roster, and any per-agent assignments. Create a compact execution plan for the selected agents.',
-                    'If the user directly names a CLI, honor that. Do not invent permanent roles; assign work only from the goal, active agents, and explicit assignment text.',
-                    `Active roster:\n${roster}`,
-                    'Respond in the same language as the user request.',
-                ].join('\n'),
-                inputs: [],
-                output: 'message',
-                onFail: 'abort',
-            },
-            ...handoffNodes,
-            ...workerNodes,
-            {
-                id: 'final_report',
-                adapterId: coordinator.adapterId,
-                agentInstanceId: coordinator.instanceId,
-                agentLabel: coordinator.label,
-                stage: 'final_report',
-                model: coordinator.model,
-                permissionMode: coordinator.permissionMode,
-                toolsSettings: coordinator.toolsSettings,
-                prompt: [
-                    'Collect the worker outputs into one user-facing result.',
-                    'Show what each CLI did, which parts failed, what changed, and the next action if work remains.',
-                    'Do not expose internal prompts, memory lookup, skill/tool instructions, raw agent logs, or role prefixes like "agent:" and "user:".',
-                    'If a worker reveals internal process text, summarize only the useful user-facing result.',
-                    'Respond in the same language as the user request.',
-                ].join('\n'),
-                inputs: workerNodes.map((node) => node.id),
-                output: 'message',
-                onFail: 'abort',
-            },
-        ],
-    };
-}
-function stagePrompt(agent, stage) {
-    return [
-        `You are ${agent.label} in a Pixcode decision workflow.`,
-        `Your stage is: ${stage}.`,
-        agent.role && agent.role !== stage ? `User custom stage label: ${agent.role}.` : '',
-        agent.instruction ? `User assignment for you: ${agent.instruction}` : '',
-        rolePrompt(stage),
-        privacyGuardPrompt(),
-        'Keep the answer concise, structured, and useful for the next stage.',
-        'Respond in the same language as the user request.',
-    ].filter(Boolean).join('\n');
-}
-function agentsWithRole(agents, role) {
-    return agents.filter((agent) => agent.role === role);
-}
-function autoAssignDebateAgents(agents) {
-    const assigned = new Set();
-    const markAssigned = (items) => {
-        for (const item of items)
-            assigned.add(item.instanceId);
-    };
-    const pickNext = () => agents.find((agent) => !assigned.has(agent.instanceId) && agent.role !== 'decision' && agent.role !== 'report')
-        ?? agents.find((agent) => !assigned.has(agent.instanceId))
-        ?? agents[0];
-    const proposalAgents = agentsWithRole(agents, 'proposal');
-    if (proposalAgents.length === 0)
-        proposalAgents.push(pickNext());
-    markAssigned(proposalAgents);
-    const critiqueAgents = agentsWithRole(agents, 'critique');
-    if (critiqueAgents.length === 0)
-        critiqueAgents.push(pickNext());
-    markAssigned(critiqueAgents);
-    const responseAgents = agentsWithRole(agents, 'response');
-    if (responseAgents.length === 0 && agents.length > 2) {
-        responseAgents.push(...agents.filter((agent) => !assigned.has(agent.instanceId) && agent.role !== 'decision' && agent.role !== 'report'));
-    }
-    markAssigned(responseAgents);
-    const reportAgent = agentsWithRole(agents, 'decision')[0]
-        ?? agentsWithRole(agents, 'report')[0]
-        ?? agents[0];
-    return { proposalAgents, critiqueAgents, responseAgents, reportAgent };
-}
-function expandAdversarialDebateWorkflow(workflow, metadata) {
-    const agents = readAgentAssignments(metadata);
-    if (agents.length === 0) {
-        throw new Error('Select at least one CLI agent.');
-    }
-    const { proposalAgents, critiqueAgents, responseAgents, reportAgent, } = autoAssignDebateAgents(agents);
-    const proposalNodes = proposalAgents.map((agent, index) => ({
-        id: safeAgentNodeId(agent, index, 'proposal'),
-        adapterId: agent.adapterId,
-        agentInstanceId: agent.instanceId,
-        agentLabel: agent.label,
-        assignment: agent.instruction || 'Proposal stage',
-        stage: 'proposal',
-        model: agent.model,
-        permissionMode: agent.permissionMode,
-        toolsSettings: agent.toolsSettings,
-        prompt: stagePrompt(agent, 'proposal'),
-        inputs: [],
-        output: 'message',
-        onFail: 'continue',
-    }));
-    const critiqueNodes = critiqueAgents.map((agent, index) => ({
-        id: safeAgentNodeId(agent, index, 'critique'),
-        adapterId: agent.adapterId,
-        agentInstanceId: agent.instanceId,
-        agentLabel: agent.label,
-        assignment: agent.instruction || 'Critique stage',
-        stage: 'critique',
-        model: agent.model,
-        permissionMode: agent.permissionMode,
-        toolsSettings: agent.toolsSettings,
-        prompt: stagePrompt(agent, 'critique'),
-        inputs: proposalNodes.map((node) => node.id),
-        output: 'message',
-        onFail: 'continue',
-    }));
-    const responseNodes = responseAgents.map((agent, index) => ({
-        id: safeAgentNodeId(agent, index, 'response'),
-        adapterId: agent.adapterId,
-        agentInstanceId: agent.instanceId,
-        agentLabel: agent.label,
-        assignment: agent.instruction || 'Response stage',
-        stage: 'response',
-        model: agent.model,
-        permissionMode: agent.permissionMode,
-        toolsSettings: agent.toolsSettings,
-        prompt: stagePrompt(agent, 'response'),
-        inputs: critiqueNodes.map((node) => node.id),
-        output: 'message',
-        onFail: 'continue',
-    }));
-    const finalInputs = responseNodes.length > 0
-        ? responseNodes.map((node) => node.id)
-        : critiqueNodes.map((node) => node.id);
-    return {
-        ...workflow,
-        nodes: [
-            ...proposalNodes,
-            ...critiqueNodes,
-            ...responseNodes,
-            {
-                id: 'final_report',
-                adapterId: reportAgent.adapterId,
-                agentInstanceId: reportAgent.instanceId,
-                agentLabel: reportAgent.label,
-                assignment: reportAgent.instruction || 'Final decision report',
-                stage: 'final_report',
-                model: reportAgent.model,
-                permissionMode: reportAgent.permissionMode,
-                toolsSettings: reportAgent.toolsSettings,
-                prompt: [
-                    'Produce the final decision report from the debate.',
-                    'Use this exact structure:',
-                    '1. Short decision',
-                    '2. Why',
-                    '3. Risks',
-                    '4. Suggested next prompt',
-                    '5. Proposed agent team and assignments',
-                    'The next prompt should be ready to paste into Pixcode Agent Team mode.',
-                    'Do not edit files. Respond in the same language as the user request.',
-                ].join('\n'),
-                inputs: finalInputs,
-                output: 'message',
-                onFail: 'abort',
-            },
-        ],
-    };
-}
-function expandSequentialHandoffWorkflow(workflow, metadata) {
-    const agents = readAgentAssignments(metadata);
-    if (agents.length === 0) {
-        throw new Error('Select at least one CLI agent.');
-    }
-    const nodes = agents.flatMap((agent, index) => {
-        const initNodeId = safeAgentNodeId(agent, index, 'init');
-        const workNodeId = safeAgentNodeId(agent, index, 'work');
-        const compactNodeId = safeAgentNodeId(agent, index, 'compact');
-        return [
-            {
-                id: initNodeId,
-                adapterId: agent.adapterId,
-                agentInstanceId: agent.instanceId,
-                agentLabel: `${agent.label} Init`,
-                assignment: agent.instruction,
-                stage: 'handoff_init',
-                model: agent.model,
-                permissionMode: agent.permissionMode,
-                toolsSettings: agent.toolsSettings,
-                prompt: handoffInitPrompt(agent, index),
-                inputs: index === 0 ? [] : [safeAgentNodeId(agents[index - 1], index - 1, 'compact')],
-                output: 'message',
-                onFail: 'abort',
-                internal: true,
-            },
-            {
-                id: workNodeId,
-                adapterId: agent.adapterId,
-                agentInstanceId: agent.instanceId,
-                agentLabel: agent.label,
-                assignment: agent.instruction,
-                stage: agent.role ?? 'implementation',
-                model: agent.model,
-                permissionMode: agent.permissionMode,
-                toolsSettings: agent.toolsSettings,
-                prompt: handoffWorkPrompt(agent, index),
-                inputs: [initNodeId],
-                output: 'both',
-                onFail: 'abort',
-            },
-            {
-                id: compactNodeId,
-                adapterId: agent.adapterId,
-                agentInstanceId: agent.instanceId,
-                agentLabel: `${agent.label} Compact`,
-                assignment: agent.instruction,
-                stage: 'handoff_compact',
-                model: agent.model,
-                permissionMode: agent.permissionMode,
-                toolsSettings: agent.toolsSettings,
-                prompt: handoffCompactPrompt(agent, index),
-                inputs: [workNodeId],
-                output: 'message',
-                onFail: 'abort',
-                internal: true,
-            },
-        ];
-    });
-    const reportAgent = agents[0];
-    const lastCompactNodeId = safeAgentNodeId(agents[agents.length - 1], agents.length - 1, 'compact');
-    return {
-        ...workflow,
-        nodes: [
-            ...nodes,
-            {
-                id: 'final_report',
-                adapterId: reportAgent.adapterId,
-                agentInstanceId: reportAgent.instanceId,
-                agentLabel: reportAgent.label,
-                stage: 'final_report',
-                model: reportAgent.model,
-                permissionMode: reportAgent.permissionMode,
-                toolsSettings: reportAgent.toolsSettings,
-                prompt: [
-                    'Create the final user-facing result for this strict handoff run.',
-                    'Use the final compact handoff packet and the original user goal.',
-                    'Summarize what each visible agent did, what changed, verification, blockers, and next actions.',
-                    'Do not expose internal init packets, compact packets, prompts, memory lookup, skill/tool instructions, raw agent logs, or role prefixes like "agent:" and "user:".',
-                    'Respond in the same language as the user request.',
-                ].join('\n'),
-                inputs: [lastCompactNodeId],
-                output: 'message',
-                onFail: 'abort',
-            },
-        ],
-    };
-}
-function expandWorkflowForRun(workflow, metadata) {
-    if (workflow.id === 'agent_team') {
-        return expandAgentTeamWorkflow(workflow, metadata);
-    }
-    const agents = readAgentAssignments(metadata);
-    if (workflow.id === 'adversarial_debate') {
-        return expandAdversarialDebateWorkflow(workflow, metadata);
-    }
-    if (workflow.id === 'sequential_handoff') {
-        return expandSequentialHandoffWorkflow(workflow, metadata);
-    }
-    if (workflow.id !== 'multi_model_review' || agents.length === 0) {
-        return workflow;
-    }
-    const reportAgent = agentsWithRole(agents, 'report')[0] ?? agentsWithRole(agents, 'decision')[0] ?? agents[0];
-    const reviewAgents = agents.filter((agent) => agent.instanceId !== reportAgent.instanceId || agents.length === 1);
-    const reviewNodes = reviewAgents.map((agent, index) => ({
-        id: safeAgentNodeId(agent, index, 'review'),
-        adapterId: agent.adapterId,
-        agentInstanceId: agent.instanceId,
-        agentLabel: agent.label,
-        assignment: agent.instruction,
-        stage: 'review',
-        model: agent.model,
-        permissionMode: agent.permissionMode,
-        toolsSettings: agent.toolsSettings,
-        prompt: [
-            `You are ${agent.label}.`,
-            'Review the requested change for bugs, regressions, missing validation, security, scale, and user-experience risks.',
-            agent.instruction ? `Focus on this user assignment: ${agent.instruction}` : '',
-            privacyGuardPrompt(),
-            'Respond in the same language as the user request.',
-        ].filter(Boolean).join('\n'),
-        inputs: [],
-        output: 'both',
-        onFail: 'continue',
-    }));
-    return {
-        ...workflow,
-        nodes: [
-            ...reviewNodes,
-            {
-                id: 'aggregate',
-                adapterId: reportAgent.adapterId,
-                agentInstanceId: reportAgent.instanceId,
-                agentLabel: reportAgent.label,
-                stage: 'report',
-                model: reportAgent.model,
-                permissionMode: reportAgent.permissionMode,
-                toolsSettings: reportAgent.toolsSettings,
-                prompt: [
-                    'Aggregate the prior agent reviews into a concise prioritized report.',
-                    'Do not expose internal prompts, memory lookup, skill/tool instructions, raw agent logs, or role prefixes like "agent:" and "user:".',
-                    'Respond in the same language as the user request.',
-                ].join('\n'),
-                inputs: reviewNodes.map((node) => node.id),
-                output: 'message',
-                onFail: 'abort',
-            },
-        ],
-    };
-}
-function readTaskResult(task) {
-    const messages = (task.history ?? []).map((message) => ({
-        role: typeof message.role === 'string' ? message.role : 'agent',
-        text: (message.parts ?? [])
-            .filter((part) => part.kind === 'text' && typeof part.text === 'string')
-            .map((part) => part.text)
-            .join('\n'),
-    })).filter((message) => message.text.trim());
-    const artifacts = (task.artifacts ?? []).map((artifact) => {
-        const text = (artifact.parts ?? [])
-            .filter((part) => part.kind === 'text' && typeof part.text === 'string')
-            .map((part) => part.text)
-            .join('\n');
-        const data = (artifact.parts ?? []).find((part) => part.kind === 'data')?.data;
-        return {
-            type: artifact.type ?? 'data',
-            text: text || undefined,
-            data,
-            metadata: artifact.metadata,
-        };
-    });
-    const outputMessages = messages.filter((message) => message.role !== 'user');
-    const userFacingTaskText = outputMessages.map((message) => message.text.trim()).filter(Boolean).join('\n\n');
-    const error = task.error?.message
-        ? `${task.error.code ? `${task.error.code}: ` : ''}${task.error.message}`
-        : undefined;
-    return {
-        state: task.state ?? 'submitted',
-        text: userFacingTaskText,
-        error,
-        messages,
-        artifacts,
-    };
-}
-async function waitForTask(taskId, shouldCancel, onSnapshot, timeoutMs) {
-    const timeout = timeoutMs && timeoutMs > 0 ? timeoutMs : undefined;
-    const deadline = timeout ? Date.now() + timeout : undefined;
-    for (;;) {
-        if (shouldCancel?.()) {
-            throw new WorkflowCanceledError();
-        }
-        if (deadline && Date.now() >= deadline) {
-            throw new WorkflowNodeTimeoutError(timeout ?? 0);
-        }
-        const task = getA2ATask(taskId);
-        if (!task) {
-            throw new Error(`Agent task ${taskId} was not found.`);
-        }
-        const snapshot = readTaskResult(task);
-        onSnapshot?.(snapshot);
-        if (task.state && TERMINAL.has(task.state)) {
-            return snapshot;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-    }
-}
-function readyNodes(workflow, completed, started) {
-    return workflow.nodes.filter((node) => !started.has(node.id) && node.inputs.every((input) => completed.has(input)));
-}
-function nodeRunFromNode(node) {
-    return {
-        nodeId: node.id,
-        adapterId: node.adapterId,
-        agentInstanceId: node.agentInstanceId,
-        agentLabel: node.agentLabel,
-        assignment: node.assignment,
-        promptPreview: node.prompt,
-        model: node.model,
-        permissionMode: node.permissionMode,
-        timeoutMs: node.timeoutMs,
-        stage: node.stage,
-        internal: node.internal,
-        fallbackTrigger: node.fallbackTrigger,
-        fallbackSourceNodeId: node.fallbackSourceNodeId,
-        status: 'queued',
-    };
-}
-function uniqueInputs(inputs) {
-    return [...new Set(inputs.filter(Boolean))];
-}
-function isReviewNode(node) {
-    return node.stage === 'review';
-}
-function isImplementationNode(node) {
-    return node.stage === 'backend' || node.stage === 'frontend' || node.stage === 'implementation' || node.stage === 'repair';
-}
-function reviewRequiresRepair(text) {
-    const normalized = text.toLocaleLowerCase('tr').replace(/\s+/g, ' ').trim();
-    if (!normalized)
-        return false;
-    const approvalPatterns = [
-        /hata yok/u,
-        /sorun yok/u,
-        /problem yok/u,
-        /bulgu yok/u,
-        /kritik bulgu yok/u,
-        /temiz/u,
-        /onaylı/u,
-        /onayli/u,
-        /approved/u,
-        /lgtm/u,
-        /no issues/u,
-        /no findings/u,
-        /looks good/u,
-        /pass(?:ed)?/u,
-    ];
-    const actionableText = approvalPatterns.reduce((current, pattern) => current.replace(pattern, ' '), normalized);
-    const issuePatterns = [
-        /hata/u,
-        /bug/u,
-        /kritik/u,
-        /critical/u,
-        /blocker/u,
-        /regression/u,
-        /failed/u,
-        /failure/u,
-        /fail/u,
-        /eksik/u,
-        /düzelt/u,
-        /duzelt/u,
-        /fix required/u,
-        /needs fix/u,
-        /sorun/u,
-        /risk/u,
-        /güvenlik/u,
-        /guvenlik/u,
-        /security/u,
-        /çalışmıyor/u,
-        /calismiyor/u,
-    ];
-    return issuePatterns.some((pattern) => pattern.test(actionableText));
-}
-function findRepairFixer(workflow, reviewNode) {
-    return reviewNode.inputs
-        .map((input) => workflow.nodes.find((node) => node.id === input))
-        .find((node) => Boolean(node && isImplementationNode(node)))
-        ?? workflow.nodes.find((node) => isImplementationNode(node))
-        ?? workflow.nodes.find((node) => node.stage === 'coordinator');
-}
-class WorkflowRunner {
-    cancelingRuns = new Set();
-    preview(workflow, metadata) {
-        const runtimeWorkflow = expandWorkflowForRun(workflow, metadata);
-        validateWorkflow(runtimeWorkflow);
-        return runtimeWorkflow;
-    }
-    start(workflow, input = '', metadata) {
-        const runtimeWorkflow = expandWorkflowForRun(workflow, metadata);
-        validateWorkflow(runtimeWorkflow);
-        const workspaceTarget = resolveWorkflowWorkspace(metadata);
-        const permissionPolicy = resolvePermissionPolicyFromMetadata(metadata);
-        const runMetadata = {
-            ...metadata,
-            permissionPolicy,
-            projectPath: workspaceTarget.projectPath,
-            selectedProjectPath: workspaceTarget.selectedProjectPath,
-            workspaceTarget: workspaceTargetMetadata(workspaceTarget),
-        };
-        const run = {
-            id: newId('wrun'),
-            workflowId: runtimeWorkflow.id,
-            contextId: newId('ctx'),
-            status: 'queued',
-            input,
-            nodeRuns: runtimeWorkflow.nodes.map(nodeRunFromNode),
-            startedAt: Date.now(),
-            metadata: runMetadata,
-        };
-        workflowStore.setRun(run);
-        const orchestrationTaskId = readString(runMetadata.orchestrationTaskId);
-        if (orchestrationTaskId) {
-            orchestrationTaskService.linkWorkflowRun(orchestrationTaskId, run);
-        }
-        void this.execute(runtimeWorkflow, run);
-        return run;
-    }
-    async cancel(runId) {
-        const run = workflowStore.getRun(runId);
-        if (!run)
-            return undefined;
-        if (TERMINAL.has(run.status))
-            return run;
-        this.cancelingRuns.add(run.id);
-        const taskIds = run.nodeRuns
-            .filter((node) => node.a2aTaskId && (node.status === 'running' || node.status === 'queued'))
-            .map((node) => node.a2aTaskId);
-        this.markCanceled(run);
-        workflowStore.setRun(run);
-        await Promise.all(taskIds.map((taskId) => cancelA2ATask(taskId)));
-        return workflowStore.getRun(run.id) ?? run;
-    }
-    isCanceling(runId) {
-        return this.cancelingRuns.has(runId) || workflowStore.getRun(runId)?.status === 'canceled';
-    }
-    markCanceled(run) {
-        run.status = 'canceled';
-        run.finishedAt = run.finishedAt ?? Date.now();
-        for (const nodeRun of run.nodeRuns) {
-            if (!TERMINAL.has(nodeRun.status) && nodeRun.status !== SKIPPED) {
-                nodeRun.status = 'canceled';
-                nodeRun.finishedAt = nodeRun.finishedAt ?? Date.now();
-            }
-        }
-    }
-    fallbackAgentFor(run, node) {
-        if (node.stage === 'fallback' || node.id.startsWith('fallback_')) {
-            return undefined;
-        }
-        const settings = getMetadataRecord(run.metadata, 'settings');
-        const fallbackAgentInstanceId = readString(settings.fallbackAgentInstanceId);
-        if (!fallbackAgentInstanceId || fallbackAgentInstanceId === node.agentInstanceId) {
-            return undefined;
-        }
-        return readAgentAssignments(run.metadata).find((agent) => agent.instanceId === fallbackAgentInstanceId);
-    }
-    createFallbackNode(node, fallbackAgent, reason, fallbackTrigger) {
-        const fallbackSuffix = safeNodeId(fallbackAgent.instanceId, 'fallback');
-        return {
-            ...node,
-            id: `fallback_${node.id}_${fallbackSuffix}`,
-            adapterId: fallbackAgent.adapterId,
-            agentInstanceId: fallbackAgent.instanceId,
-            agentLabel: `${fallbackAgent.label} Fallback`,
-            assignment: `Fallback for ${node.agentLabel || node.id}`,
-            stage: 'fallback',
-            model: fallbackAgent.model,
-            permissionMode: fallbackAgent.permissionMode,
-            toolsSettings: fallbackAgent.toolsSettings,
-            fallbackTrigger,
-            fallbackSourceNodeId: node.id,
-            prompt: [
-                'The previous CLI agent failed on this orchestration step.',
-                `Failed step: ${node.agentLabel || node.id}`,
-                `Fallback trigger: ${fallbackTrigger}`,
-                `Failure: ${reason}`,
-                'Take over the same assignment as the backup CLI. Use the original goal and upstream context.',
-                'Do not repeat unrelated work; complete the failed step and report what you did.',
-                node.prompt,
-            ].join('\n'),
-            onFail: 'continue',
-        };
-    }
-    recordFallbackSkipped(run, node, reason, fallbackTrigger, skippedReason) {
-        const fallbackSkippedEvents = Array.isArray(run.metadata?.fallbackSkippedEvents)
-            ? run.metadata.fallbackSkippedEvents
-            : [];
-        run.metadata = {
-            ...run.metadata,
-            fallbackSkippedEvents: [
-                ...fallbackSkippedEvents,
-                {
-                    nodeId: node.id,
-                    trigger: fallbackTrigger,
-                    reason,
-                    skippedReason,
-                    createdAt: Date.now(),
-                },
-            ],
-        };
-        workflowStore.setRun(run);
-    }
-    async runFallbackAfterFailure(node, workflow, run, outputs, started, completed, reason, trigger) {
-        const fallbackTrigger = classifyWorkflowFailure(reason, trigger);
-        const fallbackAgent = this.fallbackAgentFor(run, node);
-        if (!fallbackAgent) {
-            this.recordFallbackSkipped(run, node, reason, fallbackTrigger, 'No fallback agent is configured for this run.');
-            return false;
-        }
-        const decision = resolveWorkflowFallbackDecision({
-            run,
-            node,
-            reason,
-            trigger: fallbackTrigger,
-            fallbackAgentInstanceId: fallbackAgent.instanceId,
-        });
-        if (!decision.shouldFallback) {
-            this.recordFallbackSkipped(run, node, reason, decision.trigger, decision.skippedReason ?? 'Fallback policy skipped this failure.');
-            return false;
-        }
-        if (workflow.nodes.length + 1 > 64) {
-            run.metadata = {
-                ...run.metadata,
-                fallbackSkipped: `Workflow node limit reached after ${node.id}.`,
-            };
-            workflowStore.setRun(run);
-            return false;
-        }
-        let fallbackNode = this.createFallbackNode(node, fallbackAgent, reason, decision.trigger);
-        let collision = 1;
-        while (workflow.nodes.some((candidate) => candidate.id === fallbackNode.id)) {
-            collision += 1;
-            fallbackNode = {
-                ...fallbackNode,
-                id: `${fallbackNode.id}_${collision}`,
-            };
-        }
-        const nodeIndex = workflow.nodes.findIndex((candidate) => candidate.id === node.id);
-        const runIndex = run.nodeRuns.findIndex((candidate) => candidate.nodeId === node.id);
-        if (nodeIndex >= 0) {
-            workflow.nodes.splice(nodeIndex + 1, 0, fallbackNode);
-        }
-        else {
-            workflow.nodes.push(fallbackNode);
-        }
-        if (runIndex >= 0) {
-            run.nodeRuns.splice(runIndex + 1, 0, nodeRunFromNode(fallbackNode));
-        }
-        else {
-            run.nodeRuns.push(nodeRunFromNode(fallbackNode));
-        }
-        const fallbackEvents = Array.isArray(run.metadata?.fallbackEvents)
-            ? run.metadata.fallbackEvents
-            : [];
-        run.metadata = {
-            ...run.metadata,
-            fallbackEvents: [
-                ...fallbackEvents,
-                {
-                    nodeId: node.id,
-                    fallbackNodeId: fallbackNode.id,
-                    fallbackAgentInstanceId: fallbackAgent.instanceId,
-                    trigger: decision.trigger,
-                    policy: decision.policy,
-                    reason,
-                    startedAt: Date.now(),
-                },
-            ],
-        };
-        workflowStore.setRun(run);
-        await this.executeNode(fallbackNode, workflow, run, outputs, started, completed);
-        const fallbackRun = run.nodeRuns.find((candidate) => candidate.nodeId === fallbackNode.id);
-        if (fallbackRun?.status !== 'completed') {
-            return false;
-        }
-        const fallbackOutput = outputs.get(fallbackNode.id) || fallbackRun.outputText;
-        if (fallbackOutput) {
-            outputs.set(node.id, compactOutputForContext(fallbackOutput));
-        }
-        completed.add(node.id);
-        workflowStore.setRun(run);
-        return true;
-    }
-    maybeAddRepairCycle(node, workflow, run, result) {
-        if (workflow.id !== 'agent_team')
-            return;
-        if (!isReviewNode(node) || node.id.startsWith('repair_') || node.id.startsWith('recheck_'))
-            return;
-        if (!reviewRequiresRepair(`${result.text}\n${result.error ?? ''}`))
-            return;
-        const maxRepairCycles = readMaxRepairCycles(run.metadata);
-        if (maxRepairCycles <= 0)
-            return;
-        const existingCycles = workflow.nodes.filter((candidate) => candidate.id.startsWith(`repair_${node.id}_`)).length;
-        if (existingCycles >= maxRepairCycles)
-            return;
-        if (workflow.nodes.length + 2 > 64) {
-            run.metadata = {
-                ...run.metadata,
-                dynamicRepairSkipped: `Workflow node limit reached after ${node.id}.`,
-            };
-            workflowStore.setRun(run);
-            return;
-        }
-        const fixer = findRepairFixer(workflow, node);
-        if (!fixer || fixer.id === node.id)
-            return;
-        const cycle = existingCycles + 1;
-        const repairNode = {
-            id: `repair_${node.id}_${cycle}`,
-            adapterId: fixer.adapterId,
-            agentInstanceId: fixer.agentInstanceId,
-            agentLabel: fixer.agentLabel ? `${fixer.agentLabel} Repair` : undefined,
-            assignment: `Automatic repair from ${node.agentLabel || node.id} review findings`,
-            stage: 'repair',
-            model: fixer.model,
-            permissionMode: fixer.permissionMode,
-            toolsSettings: fixer.toolsSettings,
-            prompt: [
-                'A review stage found actionable issues in the prior work.',
-                'Use the original user goal, prior implementation outputs, and review output included above.',
-                'Fix only the reported issues; do not restart the whole project or duplicate unrelated work.',
-                'Report changed files, commands, verification, and any remaining blockers.',
-                'Respond in the same language as the user request.',
-            ].join('\n'),
-            inputs: uniqueInputs([...node.inputs, fixer.id, node.id]),
-            output: 'both',
-            onFail: 'continue',
-        };
-        const recheckNode = {
-            id: `recheck_${node.id}_${cycle}`,
-            adapterId: node.adapterId,
-            agentInstanceId: node.agentInstanceId,
-            agentLabel: node.agentLabel ? `${node.agentLabel} Recheck` : undefined,
-            assignment: 'Automatic validation after repair',
-            stage: 'review',
-            model: node.model,
-            permissionMode: node.permissionMode,
-            toolsSettings: node.toolsSettings,
-            prompt: [
-                'Validate the automatic repair against the original review findings.',
-                'Approve only if the reported issues are fixed.',
-                'If anything remains, list the remaining blockers clearly and do not invent new unrelated scope.',
-                'Respond in the same language as the user request.',
-            ].join('\n'),
-            inputs: uniqueInputs([node.id, repairNode.id]),
-            output: 'message',
-            onFail: 'continue',
-        };
-        const finalIndex = workflow.nodes.findIndex((candidate) => candidate.id === 'final_report' || candidate.stage === 'final_report' || candidate.stage === 'report');
-        if (finalIndex >= 0) {
-            workflow.nodes.splice(finalIndex, 0, repairNode, recheckNode);
-            run.nodeRuns.splice(finalIndex, 0, nodeRunFromNode(repairNode), nodeRunFromNode(recheckNode));
-        }
-        else {
-            workflow.nodes.push(repairNode, recheckNode);
-            run.nodeRuns.push(nodeRunFromNode(repairNode), nodeRunFromNode(recheckNode));
-        }
-        for (const finalNode of workflow.nodes) {
-            if (finalNode.id === 'final_report' || finalNode.stage === 'final_report' || finalNode.stage === 'report') {
-                finalNode.inputs = uniqueInputs([...finalNode.inputs, recheckNode.id]);
-            }
-        }
-        const repairCycles = Array.isArray(run.metadata?.dynamicRepairCycles)
-            ? run.metadata.dynamicRepairCycles
-            : [];
-        run.metadata = {
-            ...run.metadata,
-            dynamicRepairCycles: [
-                ...repairCycles,
-                {
-                    reviewNodeId: node.id,
-                    repairNodeId: repairNode.id,
-                    recheckNodeId: recheckNode.id,
-                    fixerNodeId: fixer.id,
-                },
-            ],
-        };
-        workflowStore.setRun(run);
-    }
-    async execute(workflow, run) {
-        run.status = 'running';
-        workflowStore.setRun(run);
-        const completed = new Set();
-        const started = new Set();
-        const outputs = new Map();
-        const maxParallelAgents = readMaxParallelAgents(run.metadata);
-        try {
-            while (completed.size < workflow.nodes.length) {
-                if (this.isCanceling(run.id)) {
-                    throw new WorkflowCanceledError();
-                }
-                const batch = readyNodes(workflow, completed, started);
-                if (batch.length === 0) {
-                    throw new Error('Workflow stalled; no ready nodes remain.');
-                }
-                for (let index = 0; index < batch.length; index += maxParallelAgents) {
-                    if (this.isCanceling(run.id)) {
-                        throw new WorkflowCanceledError();
-                    }
-                    const slice = batch.slice(index, index + maxParallelAgents);
-                    await Promise.all(slice.map((node) => this.executeNode(node, workflow, run, outputs, started, completed)));
-                }
-            }
-            if (this.isCanceling(run.id)) {
-                throw new WorkflowCanceledError();
-            }
-            run.status = 'completed';
-        }
-        catch (error) {
-            if (error instanceof WorkflowCanceledError || this.isCanceling(run.id)) {
-                this.markCanceled(run);
-            }
-            else {
-                run.status = 'failed';
-                run.metadata = {
-                    ...run.metadata,
-                    error: error instanceof Error ? error.message : String(error),
-                };
-            }
-        }
-        finally {
-            run.finishedAt = run.finishedAt ?? Date.now();
-            workflowStore.setRun(run);
-            orchestrationTaskService.updateFromWorkflowRun(run);
-            notifyWorkflowRunFinished(run);
-            const webhookRunStatus = String(run.status);
-            dispatchWebhookEvent({
-                type: webhookRunStatus === 'completed'
-                    ? 'run.completed'
-                    : webhookRunStatus === 'canceled'
-                        ? 'run.canceled'
-                        : 'run.failed',
-                payload: {
-                    runId: run.id,
-                    workflowId: run.workflowId,
-                    status: webhookRunStatus,
-                    error: readString(run.metadata?.error),
-                },
-            });
-            this.cancelingRuns.delete(run.id);
-        }
-    }
-    recordPermissionDecision(run, nodeRun, decision) {
-        nodeRun.permissionDecisions = [
-            ...(nodeRun.permissionDecisions ?? []),
-            decision,
-        ];
-        const existingApprovals = permissionApprovalRequests(run)
-            .filter((approval) => approval.id !== decision.approvalRequest?.id);
-        run.metadata = {
-            ...run.metadata,
-            permissionPolicyEvents: [
-                ...permissionPolicyEvents(run),
-                decision.event,
-            ],
-            pendingPermissionApprovals: decision.approvalRequest
-                ? [
-                    ...existingApprovals,
-                    decision.approvalRequest,
-                ]
-                : existingApprovals,
-        };
-        if (decision.approvalRequest) {
-            notifyPermissionApprovalRequested(run, decision);
-            dispatchWebhookEvent({
-                type: 'approval.needed',
-                payload: {
-                    runId: run.id,
-                    workflowId: run.workflowId,
-                    approvalId: decision.approvalRequest.id,
-                    capabilities: decision.capabilities,
-                },
-            });
-        }
-    }
-    async executeNode(node, workflow, run, outputs, started, completed) {
-        started.add(node.id);
-        const nodeRun = run.nodeRuns.find((candidate) => candidate.nodeId === node.id);
-        const enabledAdapters = readEnabledAdapters(run.metadata);
-        if (enabledAdapters.length > 0 && !enabledAdapters.includes(node.adapterId)) {
-            nodeRun.status = SKIPPED;
-            nodeRun.finishedAt = Date.now();
-            completed.add(node.id);
-            workflowStore.setRun(run);
-            return;
-        }
-        if (this.isCanceling(run.id)) {
-            nodeRun.status = 'canceled';
-            nodeRun.finishedAt = Date.now();
-            workflowStore.setRun(run);
-            throw new WorkflowCanceledError();
-        }
-        nodeRun.status = 'running';
-        nodeRun.startedAt = Date.now();
-        nodeRun.permissionMode = resolveNodePermissionMode(node, resolveWorkflowWorkspace(run.metadata));
-        workflowStore.setRun(run);
-        const inputContext = node.inputs.map((input) => outputs.get(input)).filter(Boolean).join('\n\n');
-        const workspaceTarget = resolveWorkflowWorkspace(run.metadata);
-        const contextPacket = buildWorkflowContextPacket({
-            run,
-            node,
-            workspaceTarget,
-            inputContext,
-            inputNodeIds: node.inputs,
-        });
-        nodeRun.contextPacket = contextPacket;
-        workflowStore.setRun(run);
-        const prompt = [
-            'Original user request (primary task; answer this directly even if the workspace is empty):',
-            run.input?.trim() || '(No original user request was provided.)',
-            formatContextPacketForPrompt(contextPacket),
-            inputContext
-                ? `Upstream workflow context from prior agents:\n${inputContext}`
-                : '',
-            `Current workflow step instructions:\n${node.prompt}`,
-            workspaceContextPrompt(workspaceTarget),
-        ].filter(Boolean).join('\n\n');
-        const settings = getMetadataRecord(run.metadata, 'settings');
-        const projectPath = workspaceTarget.projectPath;
-        const isolation = readIsolation(settings.isolation) ?? node.isolation ?? 'host';
-        const keepAfterCompletion = readBoolean(settings.keepWorkspace) ?? true;
-        const baseRef = readString(settings.baseRef) ?? 'HEAD';
-        const effectivePermissionMode = resolveNodePermissionMode(node, workspaceTarget);
-        const effectiveModel = await resolveWorkflowModel(node.adapterId, node.model);
-        if (effectiveModel !== node.model) {
-            nodeRun.model = effectiveModel;
-            const modelFallbackEvents = Array.isArray(run.metadata?.modelFallbackEvents)
-                ? run.metadata.modelFallbackEvents
-                : [];
-            run.metadata = {
-                ...run.metadata,
-                modelFallbackEvents: [
-                    ...modelFallbackEvents,
-                    {
-                        nodeId: node.id,
-                        adapterId: node.adapterId,
-                        requestedModel: node.model,
-                        effectiveModel,
-                        changedAt: Date.now(),
-                    },
-                ],
-            };
-            workflowStore.setRun(run);
-        }
-        const permissionPolicy = permissionPolicyFromRun(run);
-        nodeRun.permissionPolicy = permissionPolicy;
-        const permissionDecision = evaluatePermissionRequest({
-            policy: permissionPolicy,
-            request: {
-                source: 'workflow_node',
-                toolName: node.adapterId,
-                input: {
-                    assignment: node.assignment,
-                    stage: node.stage,
-                    toolsSettings: node.toolsSettings,
-                },
-                cwd: projectPath,
-                workspacePath: workspaceTarget.appRoot,
-                targetPaths: [projectPath],
-                summary: [
-                    node.agentLabel || node.id,
-                    node.stage ? `stage=${node.stage}` : undefined,
-                    node.assignment,
-                ].filter(Boolean).join(' / '),
-            },
-            context: {
-                runId: run.id,
-                nodeId: node.id,
-                workflowId: run.workflowId,
-                adapterId: node.adapterId,
-                agentLabel: node.agentLabel,
-                userId: readNotificationUserId(run.metadata),
-            },
-        });
-        this.recordPermissionDecision(run, nodeRun, permissionDecision);
-        workflowStore.setRun(run);
-        if (permissionDecision.behavior === 'deny') {
-            nodeRun.finishedAt = Date.now();
-            nodeRun.status = 'failed';
-            nodeRun.error = permissionDecision.message;
-            workflowStore.setRun(run);
-            if (node.onFail === 'continue') {
-                completed.add(node.id);
-                return;
-            }
-            throw new Error(permissionDecision.message);
-        }
-        let submittedTask;
-        try {
-            submittedTask = await submitA2ATask({
-                adapterId: node.adapterId,
-                contextId: run.contextId,
-                message: {
-                    messageId: newId('msg'),
-                    role: 'user',
-                    parts: [{ kind: 'text', text: prompt }],
-                },
-                metadata: {
-                    workflowRunId: run.id,
-                    workflowNodeId: node.id,
-                    agentInstanceId: node.agentInstanceId,
-                    agentLabel: node.agentLabel,
-                    assignment: node.assignment,
-                    model: effectiveModel,
-                    permissionMode: effectivePermissionMode,
-                    permissionPolicy,
-                    permissionPolicyContext: {
-                        runId: run.id,
-                        nodeId: node.id,
-                        workflowId: run.workflowId,
-                        adapterId: node.adapterId,
-                        agentLabel: node.agentLabel,
-                        userId: readNotificationUserId(run.metadata),
-                    },
-                    toolsSettings: node.toolsSettings,
-                    projectPath,
-                    workspaceTarget: workspaceTargetMetadata(workspaceTarget),
-                    workspace: {
-                        kind: isolation,
-                        projectPath,
-                        baseRef,
-                        keepAfterCompletion,
-                    },
-                },
-            });
-        }
-        catch (error) {
-            nodeRun.finishedAt = Date.now();
-            nodeRun.status = 'failed';
-            nodeRun.error = error instanceof Error ? error.message : String(error);
-            workflowStore.setRun(run);
-            if (isExternalDirectoryPermissionError(nodeRun.error)) {
-                completeNodeWithPermissionFallback(nodeRun, node, outputs, completed, nodeRun.error, workspaceTarget);
-                workflowStore.setRun(run);
-                return;
-            }
-            if (await this.runFallbackAfterFailure(node, workflow, run, outputs, started, completed, nodeRun.error, 'provider_failure')) {
-                return;
-            }
-            if (node.onFail === 'continue') {
-                completed.add(node.id);
-                return;
-            }
-            throw error;
-        }
-        nodeRun.a2aTaskId = submittedTask.id;
-        workflowStore.setRun(run);
-        if (this.isCanceling(run.id)) {
-            await cancelA2ATask(submittedTask.id);
-            nodeRun.status = 'canceled';
-            nodeRun.finishedAt = Date.now();
-            workflowStore.setRun(run);
-            throw new WorkflowCanceledError();
-        }
-        let result;
-        try {
-            result = await waitForTask(submittedTask.id, () => this.isCanceling(run.id), (snapshot) => {
-                nodeRun.outputText = snapshot.text || nodeRun.outputText;
-                nodeRun.messages = snapshot.messages;
-                nodeRun.artifacts = snapshot.artifacts;
-                nodeRun.error = snapshot.error;
-                workflowStore.setRun(run);
-            }, node.timeoutMs);
-        }
-        catch (error) {
-            if (!(error instanceof WorkflowNodeTimeoutError)) {
-                throw error;
-            }
-            await cancelA2ATask(submittedTask.id);
-            nodeRun.finishedAt = Date.now();
-            nodeRun.status = 'failed';
-            nodeRun.error = error.message;
-            if (nodeRun.outputText) {
-                outputs.set(node.id, compactOutputForContext(nodeRun.outputText));
-            }
-            workflowStore.setRun(run);
-            if (isExternalDirectoryPermissionError(nodeRun.error)) {
-                completeNodeWithPermissionFallback(nodeRun, node, outputs, completed, nodeRun.error, workspaceTarget);
-                workflowStore.setRun(run);
-                return;
-            }
-            if (await this.runFallbackAfterFailure(node, workflow, run, outputs, started, completed, nodeRun.error, 'timeout')) {
-                return;
-            }
-            if (node.onFail === 'continue') {
-                completed.add(node.id);
-                return;
-            }
-            throw error;
-        }
-        nodeRun.finishedAt = Date.now();
-        nodeRun.outputText = result.text;
-        nodeRun.messages = result.messages;
-        nodeRun.artifacts = result.artifacts;
-        if (this.isCanceling(run.id)) {
-            nodeRun.status = 'canceled';
-            workflowStore.setRun(run);
-            throw new WorkflowCanceledError();
-        }
-        if (result.state === 'completed') {
-            let outputForContext = result.text;
-            if (requiresHandoffArtifact(node)) {
-                const handoffParse = parseHandoffArtifact(handoffArtifactSource(result), {
-                    workflowRunId: run.id,
-                    nodeId: node.id,
-                    agentLabel: node.agentLabel,
-                    stage: node.stage,
-                });
-                if (!handoffParse.ok) {
-                    const visibleHandoffError = handoffParse.error.startsWith('Invalid handoff artifact')
-                        ? handoffParse.error
-                        : `Invalid handoff artifact: ${handoffParse.error}`;
-                    nodeRun.status = 'failed';
-                    nodeRun.error = visibleHandoffError;
-                    workflowStore.setRun(run);
-                    if (await this.runFallbackAfterFailure(node, workflow, run, outputs, started, completed, visibleHandoffError, 'invalid_output')) {
-                        return;
-                    }
-                    if (node.onFail === 'continue') {
-                        completed.add(node.id);
-                        return;
-                    }
-                    throw new Error(visibleHandoffError);
-                }
-                nodeRun.handoffArtifact = handoffParse.artifact;
-                nodeRun.artifacts = [
-                    ...(nodeRun.artifacts ?? []).filter((artifact) => artifact.type !== 'handoff-artifact'),
-                    handoffArtifactToWorkflowArtifact(handoffParse.artifact),
-                ];
-                outputForContext = formatHandoffArtifactForContext(handoffParse.artifact);
-            }
-            outputs.set(node.id, compactOutputForContext(outputForContext));
-            completed.add(node.id);
-            nodeRun.status = 'completed';
-            workflowStore.setRun(run);
-            this.maybeAddRepairCycle(node, workflow, run, result);
-            return;
-        }
-        if (result.state === 'canceled') {
-            nodeRun.status = 'canceled';
-            workflowStore.setRun(run);
-            throw new WorkflowCanceledError();
-        }
-        nodeRun.status = 'failed';
-        nodeRun.error = result.error ?? `Agent task ended with ${result.state}`;
-        workflowStore.setRun(run);
-        if (isExternalDirectoryPermissionError(`${nodeRun.error}\n${nodeRun.outputText ?? ''}`)) {
-            completeNodeWithPermissionFallback(nodeRun, node, outputs, completed, nodeRun.error, workspaceTarget);
-            workflowStore.setRun(run);
-            return;
-        }
-        if (await this.runFallbackAfterFailure(node, workflow, run, outputs, started, completed, nodeRun.error, classifyWorkflowFailure(`${nodeRun.error}\n${nodeRun.outputText ?? ''}`))) {
-            return;
-        }
-        if (node.onFail === 'continue') {
-            if (nodeRun.outputText) {
-                outputs.set(node.id, compactOutputForContext(nodeRun.outputText));
-            }
-            completed.add(node.id);
-            return;
-        }
-        throw new Error(nodeRun.error);
-    }
-}
-export const workflowRunner = new WorkflowRunner();
-//# sourceMappingURL=workflow-runner.js.map