taskmeld 0.1.1

package/dist/src/pipeline/runtime-model.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferSessionAgentIds = exports.parseAgentSessionMapFromEnv = exports.addTimeline = exports.seedRunWithItems = exports.seedRun = exports.touchRun = exports.computeRunStatus = exports.seedNodeItemRuns = exports.createGroupItemRun = exports.createNodeItemRun = exports.syncRunNodeStatusFromItemRuns = exports.aggregateNodeStatusFromItemRuns = exports.normalizeSession = exports.pickArray = void 0;
+const node_crypto_1 = require("node:crypto");
+const identity_1 = require("./identity");
+var array_1 = require("../utils/array");
+Object.defineProperty(exports, "pickArray", { enumerable: true, get: function () { return array_1.pickArray; } });
+var session_1 = require("../utils/session");
+Object.defineProperty(exports, "normalizeSession", { enumerable: true, get: function () { return session_1.normalizeSession; } });
+const NODE_STATUS_PRIORITY = {
+    failed: 100,
+    running: 90,
+    rejected: 80,
+    waiting: 70,
+    queued: 60,
+    blocked: 50,
+    success: 40,
+    skipped: 30,
+    stopped: 20,
+};
+const aggregateNodeStatusFromItemRuns = (itemRuns) => {
+    if (itemRuns.length === 0)
+        return "blocked";
+    let best = itemRuns[0].status;
+    for (const item of itemRuns) {
+        if (NODE_STATUS_PRIORITY[item.status] > NODE_STATUS_PRIORITY[best]) {
+            best = item.status;
+        }
+    }
+    return best;
+};
+exports.aggregateNodeStatusFromItemRuns = aggregateNodeStatusFromItemRuns;
+const syncRunNodeStatusFromItemRuns = (run) => {
+    const itemRuns = run.itemRuns ?? [];
+    if (itemRuns.length === 0)
+        return;
+    const itemsByNodeId = new Map();
+    for (const item of itemRuns) {
+        const current = itemsByNodeId.get(item.nodeId) ?? [];
+        current.push(item);
+        itemsByNodeId.set(item.nodeId, current);
+    }
+    for (const node of run.nodes) {
+        const related = itemsByNodeId.get(node.id);
+        if (!related || related.length === 0)
+            continue;
+        node.status = (0, exports.aggregateNodeStatusFromItemRuns)(related);
+    }
+};
+exports.syncRunNodeStatusFromItemRuns = syncRunNodeStatusFromItemRuns;
+const createNodeItemRun = (nodeId, itemKey, initialStatus) => ({
+    id: (0, node_crypto_1.randomUUID)(),
+    nodeId,
+    itemKey,
+    status: initialStatus,
+    route: null,
+    attempt: 0,
+    loopCount: 0,
+    wakeAt: null,
+    startedAt: null,
+    finishedAt: null,
+    lastError: null,
+    artifacts: [],
+});
+exports.createNodeItemRun = createNodeItemRun;
+const createGroupItemRun = (groupId, itemKey, initialStatus) => ({
+    id: (0, node_crypto_1.randomUUID)(),
+    groupId,
+    itemKey,
+    status: initialStatus,
+    attempt: 0,
+    startedAt: null,
+    finishedAt: null,
+    lastError: null,
+    artifacts: [],
+});
+exports.createGroupItemRun = createGroupItemRun;
+const seedNodeItemRuns = (templateNodes, itemKeys) => {
+    const uniqueItemKeys = [...new Set(itemKeys.map((item) => item.trim()).filter(Boolean))];
+    if (uniqueItemKeys.length === 0)
+        return [];
+    const itemRuns = [];
+    for (const node of templateNodes) {
+        const initialStatus = node.dependsOn.length > 0 ? "blocked" : "queued";
+        for (const itemKey of uniqueItemKeys) {
+            itemRuns.push((0, exports.createNodeItemRun)(node.id, itemKey, initialStatus));
+        }
+    }
+    return itemRuns;
+};
+exports.seedNodeItemRuns = seedNodeItemRuns;
+const computeRunStatus = (run) => {
+    if (run.nodes.some((node) => node.status === "failed"))
+        return "failed";
+    if ((run.groups ?? []).some((group) => group.status === "failed"))
+        return "failed";
+    if (run.nodes.some((node) => node.status === "stopped"))
+        return "stopped";
+    if ((run.groups ?? []).some((group) => group.status === "stopped"))
+        return "stopped";
+    if (run.nodes.every((node) => node.status === "success" || node.status === "skipped") &&
+        (run.groups ?? []).every((group) => group.status === "success" || group.status === "skipped")) {
+        return "success";
+    }
+    return "running";
+};
+exports.computeRunStatus = computeRunStatus;
+const touchRun = (run) => {
+    run.updatedAt = new Date().toISOString();
+    run.status = (0, exports.computeRunStatus)(run);
+};
+exports.touchRun = touchRun;
+const seedRun = (templateNodes) => {
+    const now = new Date().toISOString();
+    const run = {
+        id: (0, identity_1.buildRunId)(),
+        status: "running",
+        createdAt: now,
+        updatedAt: now,
+        input: { trigger: "manual" },
+        nodes: templateNodes.map((tpl) => ({
+            id: tpl.id,
+            title: tpl.title,
+            executor: tpl.executor,
+            instruction: tpl.instruction,
+            outputSpec: tpl.outputSpec,
+            allowReject: tpl.allowReject,
+            maxRejectCount: tpl.maxRejectCount,
+            status: tpl.dependsOn.length > 0 ? "blocked" : "queued",
+            dependsOn: tpl.dependsOn,
+            artifacts: [],
+            rejectFeedbacks: [],
+            attempt: 0,
+            rejectCount: 0,
+            startedAt: null,
+            finishedAt: null,
+            lastError: null,
+        })),
+        itemRuns: [],
+        groups: [],
+        groupItemRuns: [],
+        output: null,
+    };
+    (0, exports.touchRun)(run);
+    return run;
+};
+exports.seedRun = seedRun;
+const seedRunWithItems = (templateNodes, itemKeys) => {
+    const run = (0, exports.seedRun)(templateNodes);
+    run.itemRuns = (0, exports.seedNodeItemRuns)(templateNodes, itemKeys);
+    (0, exports.touchRun)(run);
+    return run;
+};
+exports.seedRunWithItems = seedRunWithItems;
+const addTimeline = (timeline, text, level = "info", detail, maxTimeline = 200) => {
+    const item = {
+        id: (0, node_crypto_1.randomUUID)(),
+        ts: new Date().toLocaleTimeString("zh-CN", { hour12: false }),
+        createdAt: new Date().toISOString(),
+        text,
+        level,
+        ...(detail === undefined ? {} : { detail }),
+    };
+    timeline.unshift(item);
+    if (timeline.length > maxTimeline) {
+        timeline.length = maxTimeline;
+    }
+    return item;
+};
+exports.addTimeline = addTimeline;
+var session_2 = require("../utils/session");
+Object.defineProperty(exports, "parseAgentSessionMapFromEnv", { enumerable: true, get: function () { return session_2.parseAgentSessionMapFromEnv; } });
+Object.defineProperty(exports, "inferSessionAgentIds", { enumerable: true, get: function () { return session_2.inferSessionAgentIds; } });

package/dist/src/pipeline/scheduler/dependency-state.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDependencyState = void 0;
+const runtime_model_1 = require("../runtime-model");
+const readiness_state_1 = require("../execution/readiness-state");
+const dependency_check_1 = require("../execution/dependency-check");
+const state_1 = require("../state");
+const createDependencyState = (options) => {
+    const getRun = () => options.runtimeStore.getRun();
+    const resolveDependencyPolicy = (nodeId) => {
+        const workflowNode = options.graph.getWorkflowNodeById(nodeId);
+        return workflowNode?.dependencyPolicy === "any" ? "any" : "all";
+    };
+    const resolveDependencyOutcome = (itemKey, incoming, policy) => {
+        let satisfiedCount = 0;
+        let impossibleCount = 0;
+        for (const edge of incoming) {
+            if ((0, dependency_check_1.isDependencySatisfied)(itemKey, edge, depCheckContext)) {
+                satisfiedCount += 1;
+                continue;
+            }
+            if ((0, dependency_check_1.canNeverSatisfy)(itemKey, edge, depCheckContext)) {
+                impossibleCount += 1;
+            }
+        }
+        // all/any 执行差异：
+        // - all: 只有全部依赖满足才入队；若剩余依赖都已不可能满足则跳过。
+        // - any: 任一依赖满足即可入队；仅当所有依赖都不可能满足时才跳过。
+        if (policy === "any") {
+            if (satisfiedCount > 0)
+                return "queued";
+            if (impossibleCount === incoming.length)
+                return "skipped";
+            return "waiting";
+        }
+        if (satisfiedCount === incoming.length)
+            return "queued";
+        if (satisfiedCount + impossibleCount === incoming.length && impossibleCount > 0)
+            return "skipped";
+        return "waiting";
+    };
+    const depCheckContext = {
+        isCrossBranchEdge: (edge) => options.graph.isCrossBranchEdge(edge),
+        isGroupId: (id) => options.graph.isGroupId(id),
+        isWorkflowNodeEnabled: (id) => options.graph.isWorkflowNodeEnabled(id),
+        isRoutePolicyNode: (id) => (options.graph.getWorkflowNodeById(id)?.routePolicy?.allowed.length ?? 0) > 0,
+        getGroupItemRun: options.getGroupItemRun,
+        getItemRun: options.getItemRun,
+    };
+    const wakeDueItems = () => {
+        const now = Date.now();
+        for (const item of getRun().itemRuns ?? []) {
+            if (item.status !== "waiting" || !item.wakeAt)
+                continue;
+            const wakeTs = Date.parse(item.wakeAt);
+            if (!Number.isFinite(wakeTs) || wakeTs > now)
+                continue;
+            (0, state_1.markItemWakeSuccess)(item, { reason: "sleep_expired" });
+            options.runtimeStore.pushTimeline(`等待节点已唤醒: ${item.nodeId}#${item.itemKey}`);
+        }
+    };
+    const markReadyItemsFromDependencies = () => {
+        options.ensureItemRuns();
+        options.graph.syncRunGroupsFromWorkflow(getRun());
+        wakeDueItems();
+        for (const item of getRun().itemRuns ?? []) {
+            if (!options.graph.isWorkflowNodeEnabled(item.nodeId)) {
+                (0, state_1.markItemSkipped)(item, { reason: "node_disabled" });
+                continue;
+            }
+            if (item.status === "running" || item.status === "success" || item.status === "failed" || item.status === "stopped" || (0, readiness_state_1.isSleepWaitingState)(item)) {
+                continue;
+            }
+            if (options.graph.getParallelGroupByMemberNodeId(item.nodeId)) {
+                (0, state_1.markItemBlocked)(item, { reason: "parallel_group_member", command: "dependency" });
+                continue;
+            }
+            const incoming = options.graph.getIncomingEdges(item.nodeId);
+            if (incoming.length === 0) {
+                if ((0, readiness_state_1.canPromoteToQueuedByDependency)(item))
+                    (0, state_1.markItemQueued)(item, { reason: "no_dependencies", command: "dependency" });
+                continue;
+            }
+            const outcome = resolveDependencyOutcome(item.itemKey, incoming, resolveDependencyPolicy(item.nodeId));
+            if (outcome === "queued")
+                (0, state_1.markItemQueued)(item, { reason: "dependency_satisfied", command: "dependency" });
+            else if (outcome === "waiting")
+                (0, state_1.markItemWaiting)(item, { reason: "dependency_pending", command: "dependency" });
+            else
+                (0, state_1.markItemSkipped)(item, { reason: "dependency_impossible", command: "dependency" });
+        }
+        (0, runtime_model_1.syncRunNodeStatusFromItemRuns)(getRun());
+    };
+    const markReadyGroupsFromDependencies = () => {
+        options.graph.syncRunGroupsFromWorkflow(getRun());
+        for (const item of getRun().groupItemRuns ?? []) {
+            if (item.status === "running" || item.status === "success" || item.status === "failed" || item.status === "stopped") {
+                continue;
+            }
+            const incoming = options.graph.getIncomingEdges(item.groupId);
+            if (incoming.length === 0) {
+                if ((0, readiness_state_1.canPromoteToQueuedByDependency)(item))
+                    (0, state_1.markGroupItemQueued)(item, { reason: "no_dependencies", command: "dependency" });
+                continue;
+            }
+            const outcome = resolveDependencyOutcome(item.itemKey, incoming, "all");
+            if (outcome === "queued")
+                (0, state_1.markGroupItemQueued)(item, { reason: "dependency_satisfied", command: "dependency" });
+            else if (outcome === "waiting")
+                (0, state_1.markGroupItemWaiting)(item, { reason: "dependency_pending", command: "dependency" });
+            else
+                (0, state_1.markGroupItemSkipped)(item, { reason: "dependency_impossible", command: "dependency" });
+        }
+        for (const group of getRun().groups ?? []) {
+            const related = (getRun().groupItemRuns ?? []).filter((item) => item.groupId === group.id);
+            if (related.length === 0)
+                continue;
+            // joinPolicy 仅支持 "all"：全部 group item 成功才标记 group 成功，任一失败即失败
+            if (related.some((item) => item.status === "failed")) {
+                (0, state_1.markGroupFailed)(group, { reason: "member_failed", command: "group_aggregate", error: related.find((item) => item.status === "failed")?.lastError });
+            }
+            else if (related.some((item) => item.status === "running")) {
+                (0, state_1.markGroupRunning)(group, { reason: "members_running", command: "group_aggregate" });
+            }
+            else if (related.some((item) => item.status === "waiting")) {
+                (0, state_1.markGroupWaiting)(group, { reason: "members_waiting", command: "group_aggregate" });
+            }
+            else if (related.some((item) => item.status === "queued")) {
+                (0, state_1.markGroupQueued)(group, { reason: "members_queued", command: "group_aggregate" });
+            }
+            else if (related.every((item) => item.status === "success" || item.status === "skipped")) {
+                (0, state_1.markGroupSuccess)(group, { reason: "all_members_done", command: "group_aggregate" });
+            }
+            else {
+                (0, state_1.markGroupBlocked)(group, { reason: "members_blocked", command: "group_aggregate" });
+            }
+        }
+    };
+    return {
+        markReadyItemsFromDependencies,
+        markReadyGroupsFromDependencies,
+    };
+};
+exports.createDependencyState = createDependencyState;

package/dist/src/pipeline/scheduler-service.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSchedulerService = void 0;
+const item_batch_controller_1 = require("./item-batch-controller");
+const runtime_model_1 = require("./runtime-model");
+const dependency_state_1 = require("./scheduler/dependency-state");
+const run_state_helpers_1 = require("./execution/run-state-helpers");
+const state_1 = require("./state");
+const identity_1 = require("./identity");
+/**
+ * 流水线调度器。
+ * 负责：决定何时执行节点、管理并发、控制调度模式。
+ * 不负责：节点的具体执行逻辑。
+ */
+const createSchedulerService = (deps) => {
+    const isSchedulerPluginEnabled = () => deps.graph.getWorkflow().plugins.scheduler.enabled;
+    const schedulerState = {
+        enabled: deps.graph.getWorkflow().scheduler.enabled,
+        mode: deps.graph.getWorkflow().scheduler.mode,
+    };
+    const getRun = () => deps.runtimeStore.getRun();
+    const state = (0, run_state_helpers_1.createRunStateHelpers)({
+        runtimeStore: deps.runtimeStore,
+        graph: deps.graph,
+        defaultItemKeys: deps.defaultItemKeys,
+    });
+    let drainInFlight = null;
+    let drainInFlightReason = null;
+    const dependencyState = (0, dependency_state_1.createDependencyState)({
+        runtimeStore: deps.runtimeStore,
+        graph: deps.graph,
+        ensureItemRuns: state.ensureItemRuns,
+        getItemRun: state.getItemRun,
+        getGroupItemRun: state.getGroupItemRun,
+    });
+    const { markReadyItemsFromDependencies, markReadyGroupsFromDependencies } = dependencyState;
+    const pickNextRunnableBatch = (maxBatchSize = Math.max(1, deps.graph.getWorkflow().scheduler.maxConcurrency || 1)) => {
+        const candidates = [];
+        for (const groupItem of getRun().groupItemRuns ?? []) {
+            if (groupItem.status !== "queued")
+                continue;
+            candidates.push(groupItem);
+            if (candidates.length >= maxBatchSize)
+                return candidates;
+        }
+        for (const item of getRun().itemRuns ?? []) {
+            if (item.status !== "queued")
+                continue;
+            const node = state.getNodeById(item.nodeId);
+            if (!node || !deps.graph.isWorkflowNodeEnabled(item.nodeId))
+                continue;
+            if (deps.graph.getParallelGroupByMemberNodeId(item.nodeId))
+                continue;
+            candidates.push(item);
+            if (candidates.length >= maxBatchSize)
+                return candidates;
+        }
+        return candidates;
+    };
+    const resetItemRunForRetry = (item) => {
+        (0, state_1.markItemReset)(item, state.computeInitialItemStatus(item.nodeId), { reason: "retry_reset" });
+        item.route = null;
+        item.artifacts = [];
+    };
+    const retryNodeExecution = async (nodeId, itemKey) => {
+        const node = state.getNodeById(nodeId);
+        if (!node) {
+            return { ok: false, error: "node_not_found" };
+        }
+        state.ensureItemRuns();
+        const affected = state.collectDownstreamSubgraph(nodeId);
+        const items = (getRun().itemRuns ?? []).filter((item) => affected.nodeIds.has(item.nodeId) && (!itemKey || item.itemKey === itemKey));
+        if (items.length === 0) {
+            return { ok: false, error: itemKey ? "node_item_not_found" : "node_item_runs_not_found" };
+        }
+        for (const current of items) {
+            resetItemRunForRetry(current);
+        }
+        for (const currentNode of getRun().nodes) {
+            if (!affected.nodeIds.has(currentNode.id))
+                continue;
+            state.resetNodeForReplay(currentNode, { clearRejectFeedbacks: currentNode.id !== nodeId });
+        }
+        for (const currentGroup of getRun().groups ?? []) {
+            if (!affected.groupIds.has(currentGroup.id))
+                continue;
+            (0, state_1.markGroupReset)(currentGroup, state.computeInitialGroupItemStatus(currentGroup.id), { reason: "retry_reset" });
+            currentGroup.artifacts = [];
+        }
+        for (const currentGroupItem of getRun().groupItemRuns ?? []) {
+            if (!affected.groupIds.has(currentGroupItem.groupId))
+                continue;
+            if (itemKey && currentGroupItem.itemKey !== itemKey)
+                continue;
+            (0, state_1.markGroupItemReset)(currentGroupItem, state.computeInitialGroupItemStatus(currentGroupItem.groupId), { reason: "retry_reset" });
+            currentGroupItem.attempt = 0;
+            currentGroupItem.artifacts = [];
+        }
+        // 手动重试模式下，目标节点可能已经满足依赖但被 reset 成 blocked。
+        // 这里先重新评估依赖，再决定是否立刻执行首个节点，避免稳定复现 node_retry_blocked。
+        markReadyItemsFromDependencies();
+        markReadyGroupsFromDependencies();
+        deps.runtimeStore.emitPipeline();
+        let drained = null;
+        if (schedulerState.mode === "manual") {
+            const first = items.find((candidate) => candidate.nodeId === nodeId && candidate.status === "queued") ?? null;
+            if (!first) {
+                (0, runtime_model_1.touchRun)(getRun());
+                deps.runtimeStore.emitPipeline();
+                return { ok: false, error: "node_retry_blocked", node, drained };
+            }
+            const exec = await deps.executionService.executeNodeItem(first);
+            (0, runtime_model_1.touchRun)(getRun());
+            deps.runtimeStore.emitPipeline();
+            return { ...exec, node, item: first, drained };
+        }
+        const drainSignal = deps.executionService.getOrCreateDrainSignal(getRun().id);
+        drained = await drainPipeline(`retry:${nodeId}${itemKey ? `#${itemKey}` : ""}`, drainSignal);
+        (0, runtime_model_1.touchRun)(getRun());
+        deps.runtimeStore.emitPipeline();
+        return { ok: true, node, drained };
+    };
+    /**
+     * 核心调度循环。遍历就绪节点并执行。这是调度器的核心职责。
+     *
+     * 传入的 AbortSignal 仅用于提前退出本地排水循环；
+     * 远端 agent 的停止由 executionService.abortRunControllers 通过 "/stop" 命令处理。
+     */
+    const drainPipeline = async (reason, signal) => {
+        const manualTick = reason.startsWith("manual_tick");
+        const forceBatchDrain = reason.startsWith("batch:");
+        const explicitRunStart = reason === "run" || reason.startsWith("run:");
+        const pipelineLinkDrain = reason.startsWith("pipeline_link:");
+        const retryDrain = reason.startsWith("retry:");
+        if (!manualTick && !forceBatchDrain && !explicitRunStart && !pipelineLinkDrain && !retryDrain) {
+            if (!isSchedulerPluginEnabled())
+                return { executed: 0, hardFailed: false };
+            if (!schedulerState.enabled)
+                return { executed: 0, hardFailed: false };
+            if (schedulerState.mode === "manual")
+                return { executed: 0, hardFailed: false };
+        }
+        if (drainInFlight) {
+            deps.runtimeStore.pushTimeline(`[调度排水锁] 调用方=${reason} 触发排水，但已有 ${drainInFlightReason} 排水正在执行，本次调用合并至现有排水`, "info");
+            return drainInFlight;
+        }
+        drainInFlight = (async () => {
+            drainInFlightReason = reason;
+            let executed = 0;
+            let hardFailed = false;
+            const maxIterations = deps.graph.getWorkflow().scheduler.loopGuard.maxGlobalIterations;
+            const maxConcurrency = Math.max(1, deps.graph.getWorkflow().scheduler.maxConcurrency || 1);
+            const active = new Set();
+            let stopScheduling = false;
+            const launchItem = (item) => {
+                const task = ("nodeId" in item ? deps.executionService.executeNodeItem(item) : deps.executionService.executeGroupItem(item))
+                    .then((result) => ({ item, result }))
+                    .finally(() => {
+                    active.delete(task);
+                });
+                active.add(task);
+            };
+            while (true) {
+                // 客户端侧中止：外部调用 abortRunControllers 后，signal 变为 aborted，
+                // 排水循环提前退出，不再等待活跃节点自然完成。
+                if (signal?.aborted) {
+                    stopScheduling = true;
+                }
+                if (executed >= maxIterations) {
+                    deps.runtimeStore.pushTimeline(`调度达到全局迭代上限: ${maxIterations}`, "warn");
+                    break;
+                }
+                while (!stopScheduling && !signal?.aborted && active.size < maxConcurrency && executed < maxIterations) {
+                    markReadyItemsFromDependencies();
+                    markReadyGroupsFromDependencies();
+                    const batch = pickNextRunnableBatch(maxConcurrency - active.size);
+                    if (batch.length === 0)
+                        break;
+                    const batchLabel = batch
+                        .map((item) => ("nodeId" in item ? `${item.nodeId}#${item.itemKey}` : `group:${item.groupId}#${item.itemKey}`))
+                        .join(", ");
+                    deps.runtimeStore.pushTimeline(`流水线自动调度: ${batchLabel} (${reason})`);
+                    for (const item of batch) {
+                        launchItem(item);
+                    }
+                    executed += batch.length;
+                    if (manualTick) {
+                        stopScheduling = true;
+                        break;
+                    }
+                }
+                if (active.size === 0)
+                    break;
+                const settled = await Promise.race(active);
+                if (signal?.aborted) {
+                    stopScheduling = true;
+                }
+                if (!settled.result.ok && settled.result.finalStatus !== "rejected") {
+                    const shouldHalt = settled.result.haltPipeline !== false;
+                    if (shouldHalt) {
+                        hardFailed = true;
+                        stopScheduling = true;
+                    }
+                }
+                if (manualTick && stopScheduling) {
+                    await Promise.all(active);
+                    break;
+                }
+            }
+            (0, runtime_model_1.syncRunNodeStatusFromItemRuns)(getRun());
+            (0, runtime_model_1.touchRun)(getRun());
+            deps.runtimeStore.emitPipeline();
+            deps.onRunCompleted?.(getRun());
+            return { executed, hardFailed };
+        })().finally(() => {
+            drainInFlight = null;
+            drainInFlightReason = null;
+        });
+        return drainInFlight;
+    };
+    /**
+     * 批量运行控制器。管理关键词池的分批执行生命周期（启动、停止、取消、状态查询）。
+     * 属于调度器职责——控制何时及如何分批执行。
+     */
+    const itemBatchController = (0, item_batch_controller_1.createItemBatchController)({
+        pipelineId: deps.pipelineId,
+        executeBatch: async ({ batchItems, batchIndex, totalBatches, totalItems }) => {
+            const batchItemKey = (0, identity_1.buildBatchItemKey)(batchIndex);
+            const nextRun = deps.runtimeStore.seedRun(deps.graph.getTemplateNodes(), [batchItemKey]);
+            deps.runtimeStore.setRun(nextRun);
+            deps.executionService.setActiveBatchKeywordItems([...batchItems]);
+            deps.graph.syncRunGroupsFromWorkflow(nextRun);
+            deps.runtimeStore.emitPipeline();
+            deps.runtimeStore.pushTimeline(`批量运行开始: 第 ${batchIndex}/${totalBatches} 批, 关键词 ${batchItems.length}/${totalItems}`);
+            let drained;
+            try {
+                const drainSignal = deps.executionService.getOrCreateDrainSignal(getRun().id);
+                drained = await drainPipeline(`batch:${batchIndex}/${totalBatches}`, drainSignal);
+                (0, runtime_model_1.touchRun)(getRun());
+                deps.runtimeStore.emitPipeline();
+            }
+            finally {
+                deps.executionService.setActiveBatchKeywordItems(null);
+            }
+            if (getRun().status === "running") {
+                deps.runtimeStore.pushTimeline(`批量运行结束: 第 ${batchIndex} 批无后续可执行节点，直接进入下一批`, "warn", {
+                    batchIndex,
+                    totalBatches,
+                    drained,
+                    runId: getRun().id,
+                });
+                return { ok: true };
+            }
+            // 仅在硬失败场景停止后续批次；业务型 failed(status=failed) 允许继续下一批。
+            if (drained.hardFailed) {
+                deps.runtimeStore.pushTimeline(`批量运行失败: 第 ${batchIndex} 批, 已停止后续批次`, "error", {
+                    batchIndex,
+                    totalBatches,
+                    drained,
+                    runId: getRun().id,
+                });
+                return { ok: false, error: `batch_${batchIndex}_failed`, hardStop: true };
+            }
+            deps.runtimeStore.pushTimeline(`批量运行完成: 第 ${batchIndex}/${totalBatches} 批, run=${getRun().id}`);
+            return { ok: true };
+        },
+    });
+    return {
+        getSchedulerState: () => ({
+            ...schedulerState,
+            // 调度器插件关闭时，对外统一表现为 disabled，避免界面和运行时状态不一致。
+            enabled: isSchedulerPluginEnabled() && schedulerState.enabled,
+        }),
+        setSchedulerEnabled: (enabled) => {
+            schedulerState.enabled = enabled;
+        },
+        setSchedulerMode: (mode) => {
+            schedulerState.mode = mode;
+        },
+        syncSchedulerStateFromWorkflow: () => {
+            schedulerState.enabled = deps.graph.getWorkflow().scheduler.enabled;
+            schedulerState.mode = deps.graph.getWorkflow().scheduler.mode;
+        },
+        getBatchRunState: () => itemBatchController.getSnapshot(),
+        startBatchRun: (items, batchSize, options) => {
+            const started = itemBatchController.start(items, batchSize, options);
+            if (started.ok) {
+                deps.runtimeStore.pushTimeline(`已启动关键词池批量运行: 共 ${started.snapshot.totalItems} 个, 每批 ${started.snapshot.batchSize} 个`);
+            }
+            return started;
+        },
+        stopBatchRun: () => {
+            const stopped = itemBatchController.stop();
+            if (stopped.ok) {
+                deps.runtimeStore.pushTimeline("已请求停止关键词池批量运行（当前批次结束后生效）", "warn");
+            }
+            return stopped;
+        },
+        cancelBatchRun: () => {
+            const canceled = itemBatchController.cancel();
+            if (canceled.ok) {
+                deps.runtimeStore.pushTimeline("已立即停止关键词池批量运行（插件已关闭）", "warn");
+            }
+            return canceled;
+        },
+        markReadyItemsFromDependencies,
+        markReadyGroupsFromDependencies,
+        retryNodeExecution,
+        drainPipeline,
+        abortRunControllers: deps.executionService.abortRunControllers,
+        getOrCreateDrainSignal: deps.executionService.getOrCreateDrainSignal,
+    };
+};
+exports.createSchedulerService = createSchedulerService;

package/dist/src/pipeline/state/group-item-state.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markGroupItemReset = exports.markGroupItemWaiting = exports.markGroupItemBlocked = exports.markGroupItemSkipped = exports.markGroupItemFailed = exports.markGroupItemSuccess = exports.markGroupItemRunning = exports.markGroupItemQueued = void 0;
+const state_machine_1 = require("../state-machine");
+const now = (ctx) => ctx.now ?? new Date().toISOString();
+const markGroupItemQueued = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "queued", ctx.command);
+};
+exports.markGroupItemQueued = markGroupItemQueued;
+const markGroupItemRunning = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "running", ctx.command);
+    item.attempt += 1;
+    item.startedAt = now(ctx);
+    item.finishedAt = null;
+    item.lastError = null;
+};
+exports.markGroupItemRunning = markGroupItemRunning;
+const markGroupItemSuccess = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "success", ctx.command);
+    item.finishedAt = now(ctx);
+    item.lastError = null;
+};
+exports.markGroupItemSuccess = markGroupItemSuccess;
+const markGroupItemFailed = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "failed", ctx.command);
+    item.finishedAt = now(ctx);
+    item.lastError = ctx.error ?? null;
+};
+exports.markGroupItemFailed = markGroupItemFailed;
+const markGroupItemSkipped = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "skipped", ctx.command);
+    item.finishedAt = now(ctx);
+    item.lastError = null;
+};
+exports.markGroupItemSkipped = markGroupItemSkipped;
+const markGroupItemBlocked = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "blocked", ctx.command);
+};
+exports.markGroupItemBlocked = markGroupItemBlocked;
+const markGroupItemWaiting = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "waiting", ctx.command);
+};
+exports.markGroupItemWaiting = markGroupItemWaiting;
+const markGroupItemReset = (item, targetStatus, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, targetStatus, ctx.command);
+    item.startedAt = null;
+    item.finishedAt = targetStatus === "skipped" ? now(ctx) : null;
+    item.lastError = null;
+};
+exports.markGroupItemReset = markGroupItemReset;