taskmeld 0.1.1

package/dist/src/pipeline/execution/route-item-manager.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRouteItemManager = void 0;
+const node_crypto_1 = require("node:crypto");
+const readiness_state_1 = require("./readiness-state");
+const state_machine_1 = require("../state-machine");
+const identity_1 = require("../identity");
+const routes_1 = require("../workflow/routes");
+const state_1 = require("../state");
+const ctx = (reason, extra) => ({ reason, ...extra });
+const normalizeAllowedRoute = (rawRoute, allowedRoutes) => {
+    if (typeof rawRoute !== "string")
+        return null;
+    const trimmed = rawRoute.trim();
+    if (!trimmed)
+        return null;
+    if (allowedRoutes.length === 0)
+        return trimmed;
+    const direct = allowedRoutes.find((route) => route === trimmed);
+    if (direct)
+        return direct;
+    const lower = trimmed.toLowerCase();
+    // 与结构化校验保持一致：大小写不一致时使用工作流声明值，避免命中丢失。
+    return allowedRoutes.find((route) => route.toLowerCase() === lower) ?? null;
+};
+const collectRouteBuckets = (content, allowedRoutes) => {
+    if (!Array.isArray(content))
+        return [];
+    const counts = new Map();
+    for (const entry of content) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            continue;
+        const route = normalizeAllowedRoute(entry.route, allowedRoutes);
+        if (!route)
+            continue;
+        entry.route = route;
+        counts.set(route, (counts.get(route) ?? 0) + 1);
+    }
+    return [...counts.entries()].map(([route, count]) => ({ route, count }));
+};
+const createRouteItemManager = (options) => {
+    const clearDerivedRouteItemRuns = (item) => {
+        const run = options.state.getRun();
+        const prefix = `${item.itemKey}::${item.nodeId}:`;
+        run.itemRuns = (run.itemRuns ?? []).filter((candidate) => !candidate.itemKey.startsWith(prefix));
+        run.groupItemRuns = (run.groupItemRuns ?? []).filter((candidate) => !candidate.itemKey.startsWith(prefix));
+    };
+    const resetNodeItemRun = (target, status) => {
+        (0, state_1.markItemReset)(target, status, ctx("route_reset", { command: "retry_reset" }));
+        target.route = null;
+        target.attempt = 0;
+        target.loopCount = 0;
+        target.artifacts = [];
+    };
+    const resetGroupItemRun = (target, status) => {
+        (0, state_1.markGroupItemReset)(target, status, ctx("route_reset", { command: "retry_reset" }));
+        target.attempt = 0;
+        target.artifacts = [];
+    };
+    const copyNodeItemRun = (target, source) => {
+        target.status = (0, state_machine_1.transitionStatus)(target.status, source.status, "route_backfill");
+        target.route = source.route;
+        target.attempt = source.attempt;
+        target.loopCount = source.loopCount;
+        target.wakeAt = source.wakeAt;
+        target.startedAt = source.startedAt;
+        target.finishedAt = source.finishedAt;
+        target.lastError = source.lastError;
+        target.artifacts = source.artifacts;
+    };
+    const copyGroupItemRun = (target, source) => {
+        target.status = (0, state_machine_1.transitionStatus)(target.status, source.status, "route_backfill");
+        target.attempt = source.attempt;
+        target.startedAt = source.startedAt;
+        target.finishedAt = source.finishedAt;
+        target.lastError = source.lastError;
+        target.artifacts = source.artifacts;
+    };
+    const initializeDerivedRouteItemKey = (sourceItem, derivedItemKey, route) => {
+        const run = options.state.getRun();
+        options.graph.syncRunGroupsFromWorkflow(run);
+        if (!run.itemRuns)
+            run.itemRuns = [];
+        if (!run.groupItemRuns)
+            run.groupItemRuns = [];
+        const outgoingEdges = options.graph.getOutgoingEdges(sourceItem.nodeId);
+        const isRouteNode = (options.graph.getWorkflowNodeById(sourceItem.nodeId)?.routePolicy?.allowed.length ?? 0) > 0;
+        const startTargets = outgoingEdges
+            // 分流节点中 yes 是主线语义：只沿普通依赖边初始化；no/自定义值只沿路由边初始化。
+            .filter((edge) => (isRouteNode ? (route === routes_1.MAINLINE_ROUTE_VALUE ? edge.when === null : edge.when === route) : !edge.when))
+            .map((edge) => edge.to);
+        const reachable = options.state.collectReachableEntities(startTargets);
+        const ancestors = options.state.collectAncestorEntities([sourceItem.nodeId, ...startTargets]);
+        for (const node of run.nodes) {
+            let target = options.state.getItemRun(node.id, derivedItemKey);
+            if (!target) {
+                target = {
+                    id: (0, node_crypto_1.randomUUID)(),
+                    nodeId: node.id,
+                    itemKey: derivedItemKey,
+                    status: "blocked",
+                    route: null,
+                    attempt: 0,
+                    loopCount: 0,
+                    wakeAt: null,
+                    startedAt: null,
+                    finishedAt: null,
+                    lastError: null,
+                    artifacts: [],
+                };
+                run.itemRuns.push(target);
+            }
+            const source = options.state.getItemRun(node.id, sourceItem.itemKey);
+            if (node.id === sourceItem.nodeId) {
+                copyNodeItemRun(target, source ?? sourceItem);
+                (0, state_1.markItemSuccess)(target, ctx("route_init_success", { command: "route_backfill" }));
+                target.route = route;
+                continue;
+            }
+            if (ancestors.nodeIds.has(node.id)) {
+                if (source) {
+                    copyNodeItemRun(target, source);
+                }
+                else {
+                    resetNodeItemRun(target, options.state.computeInitialItemStatus(node.id));
+                }
+                continue;
+            }
+            if (reachable.nodeIds.has(node.id)) {
+                resetNodeItemRun(target, options.state.computeInitialItemStatus(node.id));
+                continue;
+            }
+            resetNodeItemRun(target, "skipped");
+        }
+        for (const group of run.groups ?? []) {
+            let target = options.state.getGroupItemRun(group.id, derivedItemKey);
+            if (!target) {
+                target = {
+                    id: (0, node_crypto_1.randomUUID)(),
+                    groupId: group.id,
+                    itemKey: derivedItemKey,
+                    status: "blocked",
+                    attempt: 0,
+                    startedAt: null,
+                    finishedAt: null,
+                    lastError: null,
+                    artifacts: [],
+                };
+                run.groupItemRuns.push(target);
+            }
+            const source = options.state.getGroupItemRun(group.id, sourceItem.itemKey);
+            if (ancestors.groupIds.has(group.id)) {
+                if (source) {
+                    copyGroupItemRun(target, source);
+                }
+                else {
+                    resetGroupItemRun(target, options.state.computeInitialGroupItemStatus(group.id));
+                }
+                continue;
+            }
+            if (reachable.groupIds.has(group.id)) {
+                resetGroupItemRun(target, options.state.computeInitialGroupItemStatus(group.id));
+                continue;
+            }
+            resetGroupItemRun(target, "skipped");
+        }
+    };
+    const applyEnvelopeOutcomeToItem = async (item, envelope, opts) => {
+        if (!envelope)
+            return;
+        const workflowNode = options.graph.getWorkflowNodeById(item.nodeId);
+        const allowedRoutes = workflowNode?.routePolicy?.allowed ?? [];
+        const isRouteNode = allowedRoutes.length > 0;
+        item.route = null;
+        if (isRouteNode) {
+            clearDerivedRouteItemRuns(item);
+            const routeBuckets = collectRouteBuckets(envelope.artifacts[0]?.content, allowedRoutes);
+            for (const bucket of routeBuckets) {
+                const derivedItemKey = (0, identity_1.buildDerivedRouteItemKey)(item.itemKey, item.nodeId, bucket.route);
+                initializeDerivedRouteItemKey(item, derivedItemKey, bucket.route);
+                const nextItem = options.state.getItemRun(item.nodeId, derivedItemKey);
+                if (!nextItem)
+                    continue;
+                (0, state_1.markItemSuccess)(nextItem, ctx("route_hit", { command: "route_backfill" }));
+                nextItem.route = bucket.route;
+                nextItem.attempt = Math.max(nextItem.attempt, item.attempt);
+                nextItem.startedAt = item.startedAt;
+                nextItem.finishedAt = item.finishedAt ?? new Date().toISOString();
+                nextItem.wakeAt = null;
+                nextItem.artifacts = item.artifacts;
+                if (!opts?.suppressOutgoing) {
+                    for (const edge of options.graph.getOutgoingEdges(item.nodeId)) {
+                        if (bucket.route === routes_1.MAINLINE_ROUTE_VALUE)
+                            continue;
+                        // 路由节点只按命中的 route 边推进，普通边在此一律忽略，避免主线被隐式直通。
+                        if (edge.when !== bucket.route)
+                            continue;
+                        if (options.graph.isGroupId(edge.to)) {
+                            options.state.ensureGroupItemKeyInitialized(derivedItemKey);
+                            const downstreamGroup = options.state.getGroupItemRun(edge.to, derivedItemKey);
+                            if (downstreamGroup && (0, readiness_state_1.canPromoteToQueuedByDependency)(downstreamGroup)) {
+                                (0, state_1.markGroupItemQueued)(downstreamGroup, ctx("route_downstream"));
+                            }
+                            continue;
+                        }
+                        const downstream = options.state.getItemRun(edge.to, derivedItemKey);
+                        if (!downstream)
+                            continue;
+                        if ((0, readiness_state_1.canPromoteToQueuedByDependency)(downstream)) {
+                            (0, state_1.markItemQueued)(downstream, ctx("route_downstream"));
+                        }
+                    }
+                }
+                options.runtimeStore.pushTimeline(`分流命中: ${item.nodeId}#${item.itemKey} -> ${bucket.route} (${bucket.count} 条)`);
+            }
+        }
+        const sleepUntil = envelope.control?.sleepUntil;
+        if (typeof sleepUntil === "string" && sleepUntil.trim()) {
+            const parsed = Date.parse(sleepUntil);
+            if (Number.isFinite(parsed)) {
+                const wakeAt = new Date(parsed).toISOString();
+                (0, state_1.markItemWaiting)(item, { reason: "sleep_until", wakeAt });
+            }
+        }
+        if (!opts?.suppressOutgoing && !isRouteNode) {
+            for (const edge of options.graph.getOutgoingEdges(item.nodeId)) {
+                if (edge.when)
+                    continue;
+                if (options.graph.isCrossBranchEdge({ from: item.nodeId, to: edge.to, when: null })) {
+                    continue;
+                }
+                if (options.graph.isGroupId(edge.to)) {
+                    options.state.ensureGroupItemKeyInitialized(item.itemKey);
+                    const downstreamGroup = options.state.getGroupItemRun(edge.to, item.itemKey);
+                    if (downstreamGroup && (0, readiness_state_1.canPromoteToQueuedByDependency)(downstreamGroup)) {
+                        (0, state_1.markGroupItemQueued)(downstreamGroup, ctx("downstream_promote"));
+                    }
+                    continue;
+                }
+                const downstream = options.state.getItemRun(edge.to, item.itemKey);
+                if (!downstream)
+                    continue;
+                if ((0, readiness_state_1.canPromoteToQueuedByDependency)(downstream)) {
+                    (0, state_1.markItemQueued)(downstream, ctx("downstream_promote"));
+                }
+            }
+        }
+    };
+    return {
+        applyEnvelopeOutcomeToItem,
+    };
+};
+exports.createRouteItemManager = createRouteItemManager;

package/dist/src/pipeline/execution/run-abort-controller.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRunAbortController = void 0;
+const createRunAbortController = () => {
+    const nodeExecutionControllers = new Map();
+    const drainControllers = new Map();
+    const registerController = (runId, ac, sessionId) => {
+        let controllers = nodeExecutionControllers.get(runId);
+        if (!controllers) {
+            controllers = new Set();
+            nodeExecutionControllers.set(runId, controllers);
+        }
+        const entry = { ac, sessionId };
+        controllers.add(entry);
+        return entry;
+    };
+    const unregisterController = (runId, entry) => {
+        const controllers = nodeExecutionControllers.get(runId);
+        if (!controllers)
+            return;
+        controllers.delete(entry);
+        if (controllers.size === 0) {
+            nodeExecutionControllers.delete(runId);
+        }
+        entry.ac.abort();
+    };
+    /**
+     * 中止指定流水线运行的所有节点执行。
+     * 1. 向每个活跃节点的远端 agent 会话发送 "/stop" 命令（fire-and-forget）
+     * 2. 触发本地 AbortController 中断轮询/排水循环
+     */
+    const abortRunControllers = (runId, client) => {
+        const controllers = nodeExecutionControllers.get(runId);
+        if (controllers) {
+            const sessionIds = new Set();
+            for (const entry of controllers) {
+                entry.ac.abort();
+                sessionIds.add(entry.sessionId);
+            }
+            nodeExecutionControllers.delete(runId);
+            for (const sessionId of sessionIds) {
+                client.sendReq("chat.send", { sessionKey: sessionId, message: "/stop" }, { sideEffect: true })
+                    .catch(() => { });
+            }
+        }
+        const dc = drainControllers.get(runId);
+        if (dc) {
+            dc.abort();
+            drainControllers.delete(runId);
+        }
+    };
+    /**
+     * 获取或创建用于 drainPipeline 的中止信号。
+     * 每次新 run 会创建新的 AbortController，确保 stop/retry 只中断当前运行。
+     */
+    const getOrCreateDrainSignal = (runId) => {
+        let dc = drainControllers.get(runId);
+        if (!dc) {
+            dc = new AbortController();
+            drainControllers.set(runId, dc);
+        }
+        return dc.signal;
+    };
+    return { registerController, unregisterController, abortRunControllers, getOrCreateDrainSignal };
+};
+exports.createRunAbortController = createRunAbortController;

package/dist/src/pipeline/execution/run-state-helpers.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRunStateHelpers = void 0;
+const node_crypto_1 = require("node:crypto");
+const dependency_check_1 = require("./dependency-check");
+const state_machine_1 = require("../state-machine");
+const createRunStateHelpers = (options) => {
+    const getRun = () => options.runtimeStore.getRun();
+    const getNodeById = (nodeId) => getRun().nodes.find((node) => node.id === nodeId) ?? null;
+    const getGroupById = (groupId) => (getRun().groups ?? []).find((group) => group.id === groupId) ?? null;
+    const getItemRun = (nodeId, itemKey) => (getRun().itemRuns ?? []).find((item) => item.nodeId === nodeId && item.itemKey === itemKey) ?? null;
+    const getGroupItemRun = (groupId, itemKey) => (getRun().groupItemRuns ?? []).find((item) => item.groupId === groupId && item.itemKey === itemKey) ?? null;
+    const computeInitialItemStatus = (nodeId) => {
+        if (!options.graph.isWorkflowNodeEnabled(nodeId))
+            return "skipped";
+        if (options.graph.getParallelGroupByMemberNodeId(nodeId))
+            return "blocked";
+        const incoming = options.graph.getIncomingEdges(nodeId);
+        return incoming.length === 0 ? "queued" : "blocked";
+    };
+    const computeInitialGroupItemStatus = (groupId) => {
+        const incoming = options.graph.getIncomingEdges(groupId);
+        return incoming.length === 0 ? "queued" : "blocked";
+    };
+    const ensureGroupItemKeyInitialized = (itemKey) => {
+        const run = getRun();
+        options.graph.syncRunGroupsFromWorkflow(run);
+        if (!run.groupItemRuns)
+            run.groupItemRuns = [];
+        for (const group of run.groups ?? []) {
+            const existed = run.groupItemRuns.find((item) => item.groupId === group.id && item.itemKey === itemKey);
+            if (existed)
+                continue;
+            run.groupItemRuns.push({
+                id: (0, node_crypto_1.randomUUID)(),
+                groupId: group.id,
+                itemKey,
+                status: computeInitialGroupItemStatus(group.id),
+                attempt: 0,
+                startedAt: null,
+                finishedAt: null,
+                lastError: null,
+                artifacts: [],
+            });
+        }
+    };
+    const ensureItemRuns = () => {
+        const run = getRun();
+        if (!run.itemRuns)
+            run.itemRuns = [];
+        options.graph.syncRunGroupsFromWorkflow(run);
+        if (run.itemRuns.length === 0) {
+            run.itemRuns = options.graph.getTemplateNodes().flatMap((node) => {
+                const status = computeInitialItemStatus(node.id);
+                return options.defaultItemKeys.map((itemKey) => ({
+                    id: (0, node_crypto_1.randomUUID)(),
+                    nodeId: node.id,
+                    itemKey,
+                    status,
+                    route: null,
+                    attempt: 0,
+                    loopCount: 0,
+                    wakeAt: null,
+                    startedAt: null,
+                    finishedAt: null,
+                    lastError: null,
+                    artifacts: [],
+                }));
+            });
+            for (const itemKey of options.defaultItemKeys) {
+                ensureGroupItemKeyInitialized(itemKey);
+            }
+            return;
+        }
+        const knownNodeIds = new Set(run.nodes.map((node) => node.id));
+        run.itemRuns = run.itemRuns.filter((item) => knownNodeIds.has(item.nodeId));
+    };
+    const ensureItemKeyInitialized = (itemKey) => {
+        const run = getRun();
+        if (!run.itemRuns)
+            run.itemRuns = [];
+        for (const node of run.nodes) {
+            const existed = run.itemRuns.find((item) => item.nodeId === node.id && item.itemKey === itemKey);
+            if (existed)
+                continue;
+            run.itemRuns.push({
+                id: (0, node_crypto_1.randomUUID)(),
+                nodeId: node.id,
+                itemKey,
+                status: computeInitialItemStatus(node.id),
+                route: null,
+                attempt: 0,
+                loopCount: 0,
+                wakeAt: null,
+                startedAt: null,
+                finishedAt: null,
+                lastError: null,
+                artifacts: [],
+            });
+        }
+        ensureGroupItemKeyInitialized(itemKey);
+    };
+    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: (groupId, itemKey) => getGroupItemRun(groupId, itemKey),
+        getItemRun: (nodeId, itemKey) => getItemRun(nodeId, itemKey),
+    };
+    const isDependencySatisfied = (itemKey, edge) => (0, dependency_check_1.isDependencySatisfied)(itemKey, edge, depCheckContext);
+    const getEffectiveDependencyIdsForNodeItem = (nodeId, itemKey) => {
+        const directDependencyIds = options.graph.getIncomingEdges(nodeId)
+            .filter((edge) => isDependencySatisfied(itemKey, edge))
+            .map((edge) => edge.from);
+        const groupId = options.graph.getWorkflowNodeById(nodeId)?.parallelGroupId?.trim();
+        if (!groupId)
+            return [...new Set(directDependencyIds)];
+        const groupDependencyIds = options.graph.getIncomingEdges(groupId)
+            .filter((edge) => isDependencySatisfied(itemKey, edge))
+            .map((edge) => edge.from);
+        return [...new Set([...directDependencyIds, ...groupDependencyIds])];
+    };
+    const collectDownstreamSubgraph = (rootNodeId) => {
+        const nodeIds = new Set();
+        const groupIds = new Set();
+        const queue = [rootNodeId];
+        const seen = new Set();
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current || seen.has(current))
+                continue;
+            seen.add(current);
+            if (options.graph.isGroupId(current)) {
+                groupIds.add(current);
+                const group = options.graph.getWorkflowGroupById(current);
+                // 并行组本身不是执行节点，但它控制成员节点与后续 join 分支的状态。
+                // 回放/打回时必须穿透 group，把成员和 group 后面的节点一起纳入重置范围。
+                for (const memberId of group?.members ?? []) {
+                    queue.push(memberId);
+                }
+            }
+            else {
+                nodeIds.add(current);
+                const ownerGroup = options.graph.getParallelGroupByMemberNodeId(current);
+                if (ownerGroup) {
+                    queue.push(ownerGroup.id);
+                }
+            }
+            for (const edge of options.graph.getOutgoingEdges(current)) {
+                if (options.graph.isCrossBranchEdge(edge))
+                    continue;
+                queue.push(edge.to);
+            }
+        }
+        return { nodeIds, groupIds };
+    };
+    const collectReachableEntities = (startIds) => {
+        const nodeIds = new Set();
+        const groupIds = new Set();
+        const queue = [...startIds];
+        const seen = new Set();
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current || seen.has(current))
+                continue;
+            seen.add(current);
+            if (options.graph.isGroupId(current)) {
+                groupIds.add(current);
+            }
+            else {
+                nodeIds.add(current);
+            }
+            for (const edge of options.graph.getOutgoingEdges(current)) {
+                queue.push(edge.to);
+            }
+        }
+        return { nodeIds, groupIds };
+    };
+    const collectAncestorEntities = (startIds) => {
+        const nodeIds = new Set();
+        const groupIds = new Set();
+        const queue = [...startIds];
+        const seen = new Set();
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current || seen.has(current))
+                continue;
+            seen.add(current);
+            if (options.graph.isGroupId(current)) {
+                groupIds.add(current);
+            }
+            else {
+                nodeIds.add(current);
+            }
+            for (const edge of options.graph.getIncomingEdges(current)) {
+                queue.push(edge.from);
+            }
+        }
+        return { nodeIds, groupIds };
+    };
+    const resetNodeForReplay = (node, opts) => {
+        const run = getRun();
+        if (!options.graph.isWorkflowNodeEnabled(node.id)) {
+            node.status = (0, state_machine_1.transitionStatus)(node.status, "skipped");
+        }
+        else {
+            const effectiveDepIds = new Set(options.graph.getIncomingEdges(node.id)
+                .filter((edge) => !options.graph.isCrossBranchEdge(edge))
+                .map((edge) => edge.from));
+            const groupId = options.graph.getWorkflowNodeById(node.id)?.parallelGroupId?.trim();
+            if (groupId) {
+                for (const edge of options.graph.getIncomingEdges(groupId)) {
+                    if (!options.graph.isCrossBranchEdge(edge)) {
+                        effectiveDepIds.add(edge.from);
+                    }
+                }
+            }
+            node.status = (0, state_machine_1.transitionStatus)(node.status, [...effectiveDepIds].every((depId) => {
+                if (options.graph.isGroupId(depId)) {
+                    return (run.groups ?? []).find((group) => group.id === depId)?.status === "success";
+                }
+                if (!options.graph.isWorkflowNodeEnabled(depId))
+                    return true;
+                return run.nodes.find((current) => current.id === depId)?.status === "success";
+            })
+                ? "queued"
+                : "blocked");
+        }
+        node.artifacts = [];
+        node.startedAt = null;
+        node.finishedAt = null;
+        node.lastError = null;
+        if (opts?.clearRejectFeedbacks ?? true) {
+            node.rejectFeedbacks = [];
+        }
+    };
+    return {
+        getRun,
+        getNodeById,
+        getGroupById,
+        getItemRun,
+        getGroupItemRun,
+        computeInitialItemStatus,
+        computeInitialGroupItemStatus,
+        ensureGroupItemKeyInitialized,
+        ensureItemRuns,
+        ensureItemKeyInitialized,
+        isDependencySatisfied,
+        getEffectiveDependencyIdsForNodeItem,
+        collectDownstreamSubgraph,
+        collectReachableEntities,
+        collectAncestorEntities,
+        resetNodeForReplay,
+    };
+};
+exports.createRunStateHelpers = createRunStateHelpers;