taskmeld 0.1.1

package/dist/src/pipeline/execution/group-item-executor.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGroupItemExecutor = void 0;
+const promises_1 = require("node:fs/promises");
+const artifact_storage_1 = require("../artifact-storage");
+const readiness_state_1 = require("./readiness-state");
+const state_1 = require("../state");
+const ctx = (reason, extra) => ({ reason, ...extra });
+const createGroupItemExecutor = (deps) => {
+    const executeGroupMembers = async (item, group) => {
+        const memberItems = group.members
+            .map((memberId) => {
+            deps.ensureItemKeyInitialized(item.itemKey);
+            return deps.getItemRun(memberId, item.itemKey);
+        })
+            .filter((candidate) => !!candidate);
+        for (const memberItem of memberItems) {
+            (0, state_1.markItemReset)(memberItem, "queued", ctx("group_member_start"));
+            memberItem.route = null;
+            memberItem.artifacts = [];
+        }
+        const groupDependencyIds = [
+            ...new Set(group.members.flatMap((memberId) => deps.getEffectiveDependencyIdsForNodeItem(memberId, item.itemKey))),
+        ];
+        const results = await Promise.all(memberItems.map((memberItem) => deps.executeNodeItem(memberItem, {
+            suppressOutgoing: true,
+            dependencyIds: groupDependencyIds,
+        })));
+        return { results, memberItems };
+    };
+    const collectGroupResult = async (item, group, runGroup, memberItems) => {
+        const run = deps.getRun();
+        const memberArtifacts = memberItems.flatMap((memberItem) => memberItem.artifacts.map((artifact) => ({
+            nodeId: memberItem.nodeId,
+            artifact,
+        })));
+        const memberArtifactContents = await Promise.all(memberArtifacts.map(async (entry) => {
+            let content = "[artifact_read_failed]";
+            let meta;
+            try {
+                const raw = await (0, promises_1.readFile)(entry.artifact.path, "utf8");
+                const parsed = JSON.parse(raw);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && "artifact" in parsed) {
+                    const artifactObj = parsed.artifact;
+                    content = artifactObj?.content ?? raw;
+                    if (artifactObj?.meta && typeof artifactObj.meta === "object" && !Array.isArray(artifactObj.meta)) {
+                        meta = artifactObj.meta;
+                    }
+                }
+                else {
+                    content = raw;
+                }
+            }
+            catch {
+                // keep fallback marker
+            }
+            const memberNode = deps.getNodeById(entry.nodeId);
+            return {
+                nodeId: entry.nodeId,
+                nodeTitle: memberNode?.title ?? entry.nodeId,
+                type: entry.artifact.type,
+                schemaVersion: entry.artifact.schemaVersion,
+                name: entry.artifact.name,
+                path: entry.artifact.path,
+                hash: entry.artifact.hash,
+                content,
+                meta,
+            };
+        }));
+        const groupContent = memberArtifactContents
+            .map((entry) => `${entry.nodeId}(${entry.nodeTitle})\n${typeof entry.content === "string" ? entry.content : JSON.stringify(entry.content, null, 2)}`)
+            .join("\n\n");
+        const groupArtifact = await (0, artifact_storage_1.persistArtifactFile)(deps.artifactDir, "success", {
+            runId: run.id,
+            pipelineId: deps.pipelineId,
+            batchRunId: deps.getBatchRunId?.(),
+            groupId: group.id,
+            itemKey: item.itemKey,
+            kind: "group",
+        }, {
+            type: "group.output.v1",
+            schemaVersion: 1,
+            name: `${group.id}-group-output`,
+            content: groupContent,
+            meta: { members: memberArtifactContents },
+        }, { fileNameSuffix: `${item.itemKey}-group-output` });
+        runGroup.artifacts = [groupArtifact];
+        item.artifacts = [groupArtifact];
+        (0, state_1.markGroupItemSuccess)(item, ctx("group_exec_done"));
+        (0, state_1.markGroupSuccess)(runGroup, ctx("group_exec_done"));
+        for (const edge of deps.graph.getOutgoingEdges(group.id)) {
+            if (edge.when)
+                continue;
+            const downstream = deps.getItemRun(edge.to, item.itemKey);
+            if (!downstream)
+                continue;
+            if ((0, readiness_state_1.canPromoteToQueuedByDependency)(downstream)) {
+                (0, state_1.markItemQueued)(downstream, ctx("group_downstream_promote"));
+            }
+        }
+        deps.runtimeStore.emitPipeline();
+    };
+    const executeGroupItem = async (item) => {
+        const run = deps.getRun();
+        const group = deps.graph.getWorkflowGroupById(item.groupId);
+        const runGroup = deps.getGroupById(item.groupId);
+        if (!group || !runGroup) {
+            (0, state_1.markGroupItemFailed)(item, ctx("group_not_found", { error: "group_not_found" }));
+            return { ok: false, error: "group_not_found", finalStatus: "failed" };
+        }
+        (0, state_1.markGroupItemRunning)(item, ctx("group_start"));
+        (0, state_1.markGroupRunning)(runGroup, ctx("group_start"));
+        deps.runtimeStore.pushTimeline(`并行组执行已触发: ${group.id}#${item.itemKey}`);
+        deps.runtimeStore.emitPipeline();
+        const { results, memberItems } = await executeGroupMembers(item, group);
+        if (results.some((result) => !result.ok)) {
+            const memberError = results.find((result) => !result.ok)?.error ?? "group_member_failed";
+            (0, state_1.markGroupItemFailed)(item, ctx("member_failed", { error: memberError }));
+            (0, state_1.markGroupFailed)(runGroup, ctx("member_failed", { error: memberError }));
+            deps.runtimeStore.emitPipeline();
+            return { ok: false, error: item.lastError ?? undefined, finalStatus: "failed" };
+        }
+        await collectGroupResult(item, group, runGroup, memberItems);
+        return { ok: true, finalStatus: "success" };
+    };
+    return { executeGroupMembers, collectGroupResult, executeGroupItem };
+};
+exports.createGroupItemExecutor = createGroupItemExecutor;

package/dist/src/pipeline/execution/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExecutionService = void 0;
+var service_1 = require("./service");
+Object.defineProperty(exports, "createExecutionService", { enumerable: true, get: function () { return service_1.createExecutionService; } });

package/dist/src/pipeline/execution/node-item-executor.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodeItemExecutor = void 0;
+const state_1 = require("../state");
+const ctx = (reason, extra) => ({ reason, ...extra });
+const createNodeItemExecutor = (deps) => {
+    const executeNodeItem = async (item, opts) => {
+        const run = deps.getRun();
+        const node = deps.getNodeById(item.nodeId);
+        if (!node) {
+            (0, state_1.markItemFailed)(item, ctx("node_not_found", { error: "node_not_found" }));
+            return { ok: false, error: "node_not_found", finalStatus: "failed" };
+        }
+        const workflowNode = deps.graph.getWorkflowNodeById(node.id);
+        if (workflowNode?.enabled === false) {
+            (0, state_1.markItemSkipped)(item, ctx("node_disabled"));
+            return { ok: true, envelope: null, finalStatus: "success" };
+        }
+        const maxAttempts = Math.max(1, workflowNode?.retryPolicy.maxAttempts ?? 1);
+        if (item.attempt >= maxAttempts) {
+            (0, state_1.markItemFailed)(item, ctx("max_attempts_exceeded", { error: `max_attempts_exceeded:${maxAttempts}` }));
+            deps.runtimeStore.pushTimeline(`节点项超过重试上限: ${item.nodeId}#${item.itemKey} (${maxAttempts})`, "error");
+            deps.runtimeStore.emitPipeline();
+            return { ok: false, error: item.lastError ?? undefined, finalStatus: "failed" };
+        }
+        const retryBackoffMs = workflowNode?.retryPolicy.backoffMs ?? 0;
+        if (item.attempt > 0 && retryBackoffMs > 0) {
+            await new Promise(resolve => setTimeout(resolve, retryBackoffMs));
+        }
+        (0, state_1.markItemRunning)(item, ctx("exec_start"));
+        deps.runtimeStore.pushTimeline(`节点项执行已触发: ${item.nodeId}#${item.itemKey}`);
+        deps.runtimeStore.emitPipeline();
+        const exec = await deps.nodeRunner.executeNode(node, {
+            itemKey: item.itemKey,
+            dependencyIds: opts?.dependencyIds ?? deps.getEffectiveDependencyIdsForNodeItem(item.nodeId, item.itemKey),
+        });
+        if (!exec.ok) {
+            if (exec.finalStatus === "stopped") {
+                // 用户中止时节点项已被标记为 stopped，不覆盖
+            }
+            else if (exec.finalStatus === "rejected") {
+                (0, state_1.markItemRejected)(item, ctx("node_rejected", { error: exec.error ?? null }));
+            }
+            else {
+                (0, state_1.markItemFailed)(item, ctx("node_item_failed", { error: exec.error ?? null }));
+            }
+            item.artifacts = node.artifacts;
+            await deps.routeItemManager.applyEnvelopeOutcomeToItem(item, exec.envelope ?? null, opts);
+            return exec;
+        }
+        (0, state_1.markItemSuccess)(item, ctx("exec_done"));
+        item.artifacts = node.artifacts;
+        await deps.routeItemManager.applyEnvelopeOutcomeToItem(item, exec.envelope ?? null, opts);
+        return exec;
+    };
+    return { executeNodeItem };
+};
+exports.createNodeItemExecutor = createNodeItemExecutor;

package/dist/src/pipeline/execution/node-runner.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodeRunner = void 0;
+const state_1 = require("../state");
+const reject_handler_1 = require("./reject-handler");
+const ctx = (reason, extra) => ({ reason, ...extra });
+const extractEnvelopeErrorCode = (error) => {
+    if (!error || typeof error !== "object")
+        return "";
+    const obj = error;
+    return typeof obj.code === "string" ? obj.code.trim() : "";
+};
+const normalizeEnvelopeErrorForDisplay = (error) => {
+    const code = extractEnvelopeErrorCode(error);
+    const message = (0, reject_handler_1.extractEnvelopeErrorMessage)(error);
+    const display = message || code || "node_failed";
+    return { code, message, display };
+};
+const classifyNodeFailure = (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    const lower = message.toLowerCase();
+    if (lower.includes("timeout") || lower.includes("etimedout") || lower.includes("timed out")) {
+        return { reason: "network_timeout", haltPipeline: true };
+    }
+    if (error instanceof TypeError || error instanceof ReferenceError || error instanceof SyntaxError) {
+        return { reason: "runtime_exception", haltPipeline: true };
+    }
+    return { reason: "unknown", haltPipeline: true };
+};
+const createNodeRunner = (deps) => {
+    const handleNodeEnvelopeResult = async (node, result, envelopeError, opts, effectiveDependencyIds, usedAgentId) => {
+        const envelopeErrorCode = envelopeError.code;
+        let succeeded = false;
+        let finalStatus = "failed";
+        let execError;
+        let haltPipeline = true;
+        if (result.envelope.status === "success") {
+            (0, state_1.markNodeSuccess)(node, ctx("exec_done", { artifacts: result.artifacts }));
+            finalStatus = "success";
+            haltPipeline = false;
+            node.rejectCount = 0;
+            node.rejectFeedbacks = [];
+            succeeded = true;
+            deps.runtimeStore.pushTimeline(`节点执行完成(结构化): ${node.id} <- ${usedAgentId}`);
+        }
+        else if (envelopeErrorCode === "upstream_reject" && node.allowReject) {
+            node.artifacts = [];
+            await deps.handleNodeReject({
+                node,
+                envelope: result.envelope,
+                itemKey: opts?.itemKey,
+                dependencyIds: effectiveDependencyIds,
+                nodes: deps.getRun().nodes,
+                runId: deps.getRun().id,
+                pushTimeline: deps.runtimeStore.pushTimeline,
+                artifactDir: deps.artifactDir,
+                pipelineId: deps.pipelineId,
+                getBatchRunId: deps.getBatchRunId,
+                resetAffectedDownstreamNodes: deps.resetAffectedDownstreamNodes,
+            });
+            finalStatus = "rejected";
+            haltPipeline = false;
+            execError = node.lastError ?? "upstream_reject";
+        }
+        else if (envelopeErrorCode === "upstream_reject" && !node.allowReject) {
+            const rejectNotAllowedError = JSON.stringify({
+                code: "upstream_reject_not_allowed",
+                message: "node_allowReject_false",
+                originalError: result.envelope.error ?? null,
+            });
+            (0, state_1.markNodeFailed)(node, ctx("upstream_reject_not_allowed", { error: rejectNotAllowedError }));
+            finalStatus = "failed";
+            node.artifacts = result.artifacts;
+            execError = "upstream_reject_not_allowed: node_allowReject_false";
+            deps.runtimeStore.pushTimeline(`节点执行失败(结构化): ${node.id} <- ${usedAgentId} upstream_reject_not_allowed: node_allowReject_false`, "error");
+        }
+        else {
+            const structuredFailError = JSON.stringify(result.envelope.error ?? "node_failed");
+            (0, state_1.markNodeFailed)(node, ctx("node_structured_failed", { error: structuredFailError }));
+            finalStatus = "failed";
+            haltPipeline = false;
+            node.artifacts = result.artifacts;
+            execError = envelopeError.display;
+            const detailText = envelopeError.message
+                ? `${envelopeError.code ? `${envelopeError.code}: ` : ""}${envelopeError.message}`
+                : envelopeError.code || "node_failed";
+            deps.runtimeStore.pushTimeline(`节点执行失败(结构化): ${node.id} <- ${usedAgentId} ${detailText}`, "error");
+        }
+        return { succeeded, finalStatus, execError, haltPipeline };
+    };
+    const executeNode = async (node, opts) => {
+        const resolved = await deps.sessionRegistry.resolveExecutorSession(node);
+        if (!resolved) {
+            deps.runtimeStore.pushTimeline(`节点 ${node.id} 执行失败: 找不到执行者会话(${node.executor.agentId})`, "error");
+            (0, state_1.markNodeFailed)(node, ctx("executor_session_not_found", { error: "executor_session_not_found" }));
+            deps.runtimeStore.emitPipeline();
+            return {
+                ok: false,
+                error: "executor_session_not_found",
+                executorAgentId: node.executor.agentId,
+                fallbackAgentId: node.executor.fallbackAgentId,
+                envelope: null,
+            };
+        }
+        const sessionId = resolved.sessionId;
+        const usedAgentId = resolved.agentId;
+        (0, state_1.markNodeRunning)(node, ctx("exec_start"));
+        deps.runtimeStore.pushTimeline(`节点执行已触发: ${node.id} -> ${usedAgentId}`);
+        deps.runtimeStore.emitPipeline();
+        const effectiveDependencyIds = opts?.dependencyIds?.length
+            ? Array.from(new Set(opts.dependencyIds.map((id) => id.trim()).filter(Boolean)))
+            : node.dependsOn;
+        const ac = new AbortController();
+        const runId = deps.getRun().id;
+        const entry = deps.runAbortController.registerController(runId, ac, sessionId);
+        try {
+            const result = await deps.structuredNodeRunner.runNodeViaStructuredOutput(node, sessionId, opts?.itemKey, effectiveDependencyIds, ac.signal);
+            const envelopeError = normalizeEnvelopeErrorForDisplay(result.envelope.error);
+            const outcome = await handleNodeEnvelopeResult(node, result, envelopeError, opts, effectiveDependencyIds, usedAgentId);
+            deps.runtimeStore.emitPipeline();
+            return {
+                ok: outcome.succeeded,
+                ...(outcome.succeeded ? {} : { error: outcome.execError ?? "node_not_success" }),
+                haltPipeline: outcome.haltPipeline,
+                usedAgentId,
+                usedSessionId: sessionId,
+                finalStatus: outcome.finalStatus,
+                envelope: result.envelope,
+            };
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            const isAborted = errMsg === "aborted";
+            const classification = isAborted
+                ? { reason: "pipeline_aborted", haltPipeline: true }
+                : classifyNodeFailure(error);
+            // 用户中止时节点已被标记为 stopped，不应再覆盖为 failed
+            if (!isAborted) {
+                (0, state_1.markNodeFailed)(node, ctx(classification.reason, { error: String(error) }));
+            }
+            deps.runtimeStore.pushTimeline(`节点执行中断(结构化): ${node.id} <- ${usedAgentId} ${String(error)}`, "warn");
+            deps.runtimeStore.emitPipeline();
+            return {
+                ok: false,
+                error: String(error),
+                haltPipeline: classification.haltPipeline,
+                usedAgentId,
+                usedSessionId: sessionId,
+                finalStatus: isAborted ? "stopped" : "failed",
+                envelope: null,
+            };
+        }
+        finally {
+            deps.runAbortController.unregisterController(runId, entry);
+        }
+    };
+    return { executeNode, handleNodeEnvelopeResult };
+};
+exports.createNodeRunner = createNodeRunner;

package/dist/src/pipeline/execution/readiness-state.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canPromoteToQueuedByDependency = exports.isSleepWaitingState = void 0;
+const isSleepWaitingState = (candidate) => candidate.status === "waiting" && typeof candidate.wakeAt === "string" && candidate.wakeAt.trim().length > 0;
+exports.isSleepWaitingState = isSleepWaitingState;
+const canPromoteToQueuedByDependency = (candidate) => candidate.status === "blocked" ||
+    candidate.status === "skipped" ||
+    // 仅允许“依赖未满足”造成的 waiting 被重新入队；sleep waiting 仍需等到 wakeAt 到期。
+    (candidate.status === "waiting" && !(0, exports.isSleepWaitingState)(candidate));
+exports.canPromoteToQueuedByDependency = canPromoteToQueuedByDependency;

package/dist/src/pipeline/execution/reject-handler.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleNodeReject = exports.pickDefaultRejectTarget = exports.extractEnvelopeRejectTargets = exports.extractEnvelopeErrorMessage = void 0;
+const state_1 = require("../state");
+const rejected_artifact_archiver_1 = require("./rejected-artifact-archiver");
+const ctx = (reason, extra) => ({ reason, ...extra });
+const extractEnvelopeErrorMessage = (error) => {
+    if (!error || typeof error !== "object")
+        return "";
+    const obj = error;
+    if (typeof obj.message === "string" && obj.message.trim())
+        return obj.message.trim();
+    if (typeof obj.reason === "string" && obj.reason.trim())
+        return obj.reason.trim();
+    return "";
+};
+exports.extractEnvelopeErrorMessage = extractEnvelopeErrorMessage;
+const extractEnvelopeRejectTargets = (error) => {
+    if (!error || typeof error !== "object")
+        return [];
+    const obj = error;
+    if (!Array.isArray(obj.targets))
+        return [];
+    return obj.targets
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter(Boolean);
+};
+exports.extractEnvelopeRejectTargets = extractEnvelopeRejectTargets;
+const pickDefaultRejectTarget = (node, nodes, dependencyIds) => {
+    const effectiveDependencyIds = dependencyIds?.length ? dependencyIds : node.dependsOn;
+    if (effectiveDependencyIds.length === 0)
+        return null;
+    const indexById = new Map(nodes.map((current, index) => [current.id, index]));
+    let best = null;
+    for (const depId of effectiveDependencyIds) {
+        const depIndex = indexById.get(depId);
+        if (typeof depIndex !== "number")
+            continue;
+        if (!best || depIndex > best.index) {
+            best = { id: depId, index: depIndex };
+        }
+    }
+    return best?.id ?? effectiveDependencyIds[effectiveDependencyIds.length - 1] ?? null;
+};
+exports.pickDefaultRejectTarget = pickDefaultRejectTarget;
+const handleNodeReject = async (params) => {
+    const { node, envelope, itemKey, dependencyIds, nodes, runId, pushTimeline, artifactDir, pipelineId, getBatchRunId, resetAffectedDownstreamNodes } = params;
+    const limit = Number.isFinite(node.maxRejectCount) ? Math.max(0, Math.trunc(node.maxRejectCount)) : 0;
+    node.rejectCount = (node.rejectCount ?? 0) + 1;
+    if (node.rejectCount > limit) {
+        (0, state_1.markNodeFailed)(node, ctx("reject_limit_exceeded", { error: JSON.stringify(envelope.error ?? "reject_limit_exceeded") }));
+        pushTimeline(`节点 ${node.id} 打回超过 ${limit} 次，标记失败`, "error");
+        return;
+    }
+    const effectiveDependencyIds = dependencyIds?.length ? dependencyIds : node.dependsOn;
+    const explicitTargets = (0, exports.extractEnvelopeRejectTargets)(envelope.error);
+    const defaultTarget = (0, exports.pickDefaultRejectTarget)(node, nodes, effectiveDependencyIds);
+    const rejectTargetIds = explicitTargets.length > 0
+        ? explicitTargets.filter((id) => effectiveDependencyIds.includes(id))
+        : defaultTarget
+            ? [defaultTarget]
+            : [];
+    const rejectMessage = (0, exports.extractEnvelopeErrorMessage)(envelope.error) || "下游校验不通过，请修正后重新提交。";
+    if (rejectTargetIds.length === 0) {
+        (0, state_1.markNodeFailed)(node, ctx("reject_target_missing", { error: JSON.stringify(envelope.error ?? "reject_target_missing") }));
+        pushTimeline(`节点 ${node.id} 请求打回但未找到可用上游节点，标记失败`, "error");
+        return;
+    }
+    (0, state_1.markNodeRejected)(node, ctx("upstream_reject", { error: JSON.stringify(envelope.error ?? "upstream_reject") }));
+    for (const targetId of rejectTargetIds) {
+        const targetNode = nodes.find((current) => current.id === targetId);
+        if (!targetNode)
+            continue;
+        const feedback = `${node.id}(${node.title})打回原因: ${rejectMessage}`;
+        targetNode.rejectFeedbacks = [...(targetNode.rejectFeedbacks ?? []), feedback].slice(-5);
+        const movedCount = await (0, rejected_artifact_archiver_1.archiveRejectedArtifacts)({
+            node: targetNode,
+            runId,
+            artifactDir,
+            pipelineId,
+            rejectedByNodeId: node.id,
+            getBatchRunId,
+            pushTimeline,
+        });
+        const { affectedNodeCount, affectedGroupCount } = resetAffectedDownstreamNodes({
+            targetNodeId: targetId,
+            itemKey,
+            skipNodeIds: [node.id],
+        });
+        pushTimeline(`节点 ${node.id} 打回 ${targetNode.id}，原因: ${rejectMessage}；重置 ${affectedNodeCount} 个节点/${affectedGroupCount} 个并行组，归档产物 ${movedCount} 条`, "warn");
+    }
+};
+exports.handleNodeReject = handleNodeReject;

package/dist/src/pipeline/execution/rejected-artifact-archiver.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.archiveRejectedArtifacts = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const artifact_storage_1 = require("../artifact-storage");
+const sanitizeArtifactFileSegment = (value) => {
+    const normalized = value
+        .trim()
+        .replace(/[<>:"/\\|?*\x00-\x1F]/g, "_")
+        .replace(/\s+/g, "_")
+        .replace(/\.+$/g, "_");
+    return normalized || "unnamed";
+};
+const buildArtifactFileName = (...parts) => parts.map(sanitizeArtifactFileSegment).join("-");
+const archiveRejectedArtifacts = async (params) => {
+    const { node, runId, artifactDir, pipelineId, rejectedByNodeId, getBatchRunId, pushTimeline } = params;
+    if (!node.artifacts.length)
+        return 0;
+    const persistDirs = (0, artifact_storage_1.buildArtifactStorageDirs)(artifactDir, runId, "rejected", new Date(), getBatchRunId?.());
+    await (0, promises_1.mkdir)(persistDirs.artifactsDir, { recursive: true });
+    let moved = 0;
+    for (const artifact of node.artifacts) {
+        const sourcePath = artifact.path;
+        const fileName = sourcePath.replace(/^.*[\\/]/, "");
+        const targetPath = (0, node_path_1.join)(persistDirs.artifactsDir, buildArtifactFileName(runId, node.id, "rejected-by", rejectedByNodeId, String(Date.now()), fileName));
+        try {
+            await (0, promises_1.rename)(sourcePath, targetPath);
+            await (0, artifact_storage_1.appendMovedArtifactIndexRecord)(artifactDir, {
+                manifest: artifact,
+                pipelineId,
+                status: "rejected",
+                relativePath: (0, node_path_1.relative)(artifactDir, targetPath).replaceAll("\\", "/"),
+                movedAt: new Date(),
+                rejectedByNodeId,
+            }).catch(() => { });
+            moved += 1;
+        }
+        catch (error) {
+            pushTimeline(`归档被驳回产物失败 (节点 ${node.id}): ${error instanceof Error ? error.message : String(error)}`, "warn");
+        }
+    }
+    return moved;
+};
+exports.archiveRejectedArtifacts = archiveRejectedArtifacts;