taskmeld 0.1.1

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markGroupReset = exports.markGroupWaiting = exports.markGroupBlocked = exports.markGroupFailed = exports.markGroupSuccess = exports.markGroupRunning = exports.markGroupQueued = void 0;
+const state_machine_1 = require("../state-machine");
+const now = (ctx) => ctx.now ?? new Date().toISOString();
+const markGroupQueued = (group, ctx) => {
+    group.status = (0, state_machine_1.transitionStatus)(group.status, "queued", ctx.command);
+};
+exports.markGroupQueued = markGroupQueued;
+const markGroupRunning = (group, ctx) => {
+    group.status = (0, state_machine_1.transitionStatus)(group.status, "running", ctx.command);
+    group.startedAt = now(ctx);
+};
+exports.markGroupRunning = markGroupRunning;
+const markGroupSuccess = (group, ctx) => {
+    group.status = (0, state_machine_1.transitionStatus)(group.status, "success", ctx.command);
+    group.finishedAt = now(ctx);
+    group.lastError = null;
+};
+exports.markGroupSuccess = markGroupSuccess;
+const markGroupFailed = (group, ctx) => {
+    group.status = (0, state_machine_1.transitionStatus)(group.status, "failed", ctx.command);
+    group.finishedAt = now(ctx);
+    group.lastError = ctx.error ?? null;
+};
+exports.markGroupFailed = markGroupFailed;
+const markGroupBlocked = (group, ctx) => {
+    group.status = (0, state_machine_1.transitionStatus)(group.status, "blocked", ctx.command);
+};
+exports.markGroupBlocked = markGroupBlocked;
+const markGroupWaiting = (group, ctx) => {
+    group.status = (0, state_machine_1.transitionStatus)(group.status, "waiting", ctx.command);
+};
+exports.markGroupWaiting = markGroupWaiting;
+const markGroupReset = (group, targetStatus, ctx) => {
+    group.status = (0, state_machine_1.transitionStatus)(group.status, targetStatus, ctx.command);
+    group.startedAt = null;
+    group.finishedAt = null;
+    group.lastError = null;
+};
+exports.markGroupReset = markGroupReset;

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

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./node-item-state"), exports);
+__exportStar(require("./node-run-state"), exports);
+__exportStar(require("./group-item-state"), exports);
+__exportStar(require("./group-run-state"), exports);

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markItemReset = exports.markItemWakeSuccess = exports.markItemBlocked = exports.markItemWaiting = exports.markItemSkipped = exports.markItemRejected = exports.markItemFailed = exports.markItemSuccess = exports.markItemRunning = exports.markItemQueued = void 0;
+const state_machine_1 = require("../state-machine");
+const now = (ctx) => ctx.now ?? new Date().toISOString();
+const markItemQueued = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "queued", ctx.command);
+};
+exports.markItemQueued = markItemQueued;
+const markItemRunning = (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;
+    item.wakeAt = null;
+};
+exports.markItemRunning = markItemRunning;
+const markItemSuccess = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "success", ctx.command);
+    item.finishedAt = now(ctx);
+    item.lastError = null;
+};
+exports.markItemSuccess = markItemSuccess;
+const markItemFailed = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "failed", ctx.command);
+    item.finishedAt = now(ctx);
+    item.lastError = ctx.error ?? null;
+};
+exports.markItemFailed = markItemFailed;
+const markItemRejected = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "rejected", ctx.command);
+    item.finishedAt = now(ctx);
+    item.lastError = ctx.error ?? null;
+};
+exports.markItemRejected = markItemRejected;
+const markItemSkipped = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "skipped", ctx.command);
+    item.wakeAt = null;
+    item.finishedAt = now(ctx);
+    item.lastError = null;
+};
+exports.markItemSkipped = markItemSkipped;
+const markItemWaiting = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "waiting", ctx.command);
+    if (ctx.wakeAt)
+        item.wakeAt = ctx.wakeAt;
+};
+exports.markItemWaiting = markItemWaiting;
+const markItemBlocked = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "blocked", ctx.command);
+};
+exports.markItemBlocked = markItemBlocked;
+const markItemWakeSuccess = (item, ctx) => {
+    item.status = (0, state_machine_1.transitionStatus)(item.status, "success", ctx.command);
+    item.wakeAt = null;
+    item.finishedAt = now(ctx);
+};
+exports.markItemWakeSuccess = markItemWakeSuccess;
+const markItemReset = (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;
+    item.wakeAt = null;
+};
+exports.markItemReset = markItemReset;

package/dist/src/pipeline/state/node-run-state.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markNodeWaiting = exports.markNodeBlocked = exports.markNodeSkipped = exports.markNodeRejected = exports.markNodeFailed = exports.markNodeSuccess = exports.markNodeRunning = exports.markNodeQueued = void 0;
+const state_machine_1 = require("../state-machine");
+const now = (ctx) => ctx.now ?? new Date().toISOString();
+const markNodeQueued = (node, ctx) => {
+    node.status = (0, state_machine_1.transitionStatus)(node.status, "queued", ctx.command);
+};
+exports.markNodeQueued = markNodeQueued;
+const markNodeRunning = (node, ctx) => {
+    node.status = (0, state_machine_1.transitionStatus)(node.status, "running", ctx.command);
+    node.attempt += 1;
+    node.startedAt = now(ctx);
+    node.finishedAt = null;
+    node.lastError = null;
+};
+exports.markNodeRunning = markNodeRunning;
+const markNodeSuccess = (node, ctx) => {
+    node.status = (0, state_machine_1.transitionStatus)(node.status, "success", ctx.command);
+    node.finishedAt = now(ctx);
+    node.lastError = null;
+    if (ctx.artifacts)
+        node.artifacts = ctx.artifacts;
+};
+exports.markNodeSuccess = markNodeSuccess;
+const markNodeFailed = (node, ctx) => {
+    node.status = (0, state_machine_1.transitionStatus)(node.status, "failed", ctx.command);
+    node.finishedAt = now(ctx);
+    node.lastError = ctx.error ?? null;
+};
+exports.markNodeFailed = markNodeFailed;
+const markNodeRejected = (node, ctx) => {
+    node.status = (0, state_machine_1.transitionStatus)(node.status, "rejected", ctx.command);
+    node.finishedAt = now(ctx);
+    node.lastError = ctx.error ?? null;
+};
+exports.markNodeRejected = markNodeRejected;
+const markNodeSkipped = (node, ctx) => {
+    node.status = (0, state_machine_1.transitionStatus)(node.status, "skipped", ctx.command);
+    node.finishedAt = now(ctx);
+    node.lastError = null;
+};
+exports.markNodeSkipped = markNodeSkipped;
+const markNodeBlocked = (node, ctx) => {
+    node.status = (0, state_machine_1.transitionStatus)(node.status, "blocked", ctx.command);
+};
+exports.markNodeBlocked = markNodeBlocked;
+const markNodeWaiting = (node, ctx) => {
+    node.status = (0, state_machine_1.transitionStatus)(node.status, "waiting", ctx.command);
+};
+exports.markNodeWaiting = markNodeWaiting;

package/dist/src/pipeline/state/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/pipeline/state-machine.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transitionStatus = exports.IllegalStateTransitionError = exports.VALID_TRANSITIONS = void 0;
+exports.VALID_TRANSITIONS = {
+    queued: {
+        execute: ["running", "failed"],
+        dependency: ["waiting", "blocked", "skipped"],
+        group_aggregate: ["running", "failed", "waiting", "blocked", "skipped"],
+        retry_reset: ["queued"],
+        reject_reset: ["queued"],
+        route_backfill: ["running", "success", "failed", "rejected", "waiting", "skipped", "blocked"],
+    },
+    running: {
+        execute: ["success", "failed", "rejected", "waiting"],
+        group_aggregate: ["success", "failed", "rejected", "waiting", "queued", "blocked", "skipped"],
+        retry_reset: ["queued", "blocked", "skipped"],
+        reject_reset: ["queued", "blocked", "skipped"],
+    },
+    waiting: {
+        sleep: ["success"],
+        dependency: ["queued", "skipped", "blocked"],
+        group_aggregate: ["success", "queued", "skipped", "blocked"],
+        retry_reset: ["queued"],
+        reject_reset: ["queued"],
+    },
+    blocked: {
+        dependency: ["queued", "waiting", "skipped"],
+        group_aggregate: ["running", "success", "failed", "rejected", "queued", "waiting", "blocked"],
+        route_backfill: ["running", "success", "failed", "rejected", "skipped", "queued", "waiting", "blocked"],
+        retry_reset: ["queued", "skipped"],
+        reject_reset: ["queued", "skipped"],
+    },
+    success: {
+        sleep: ["waiting"],
+        dependency: ["queued", "blocked", "skipped"],
+        group_aggregate: ["queued", "blocked", "skipped", "waiting"],
+        retry_reset: ["queued", "blocked", "skipped"],
+        reject_reset: ["queued", "blocked", "skipped"],
+        route_backfill: ["success", "running", "failed", "rejected", "queued", "blocked", "skipped", "waiting"],
+    },
+    failed: {
+        dependency: ["queued", "blocked", "skipped"],
+        group_aggregate: ["queued", "blocked", "skipped"],
+        retry_reset: ["queued", "blocked", "running"],
+        reject_reset: ["queued", "blocked"],
+        sleep: ["waiting"],
+        route_backfill: ["success"],
+    },
+    rejected: {
+        dependency: ["queued", "blocked", "skipped"],
+        group_aggregate: ["queued", "blocked", "skipped"],
+        retry_reset: ["queued", "blocked"],
+        reject_reset: ["queued", "blocked"],
+        sleep: ["waiting"],
+        route_backfill: ["success"],
+    },
+    skipped: {
+        dependency: ["queued", "blocked"],
+        group_aggregate: ["queued", "blocked"],
+        retry_reset: ["queued", "blocked"],
+        route_backfill: ["running", "success", "failed", "rejected", "queued", "blocked", "skipped", "waiting"],
+    },
+    stopped: {
+        retry_reset: ["queued", "blocked", "skipped"],
+        reject_reset: ["queued", "blocked", "skipped"],
+    },
+};
+class IllegalStateTransitionError extends Error {
+    current;
+    next;
+    command;
+    constructor(current, next, command) {
+        const cmdInfo = command ? ` (command: ${command})` : "";
+        super(`Illegal state transition: "${current}" -> "${next}"${cmdInfo}`);
+        this.name = "IllegalStateTransitionError";
+        this.current = current;
+        this.next = next;
+        this.command = command;
+    }
+}
+exports.IllegalStateTransitionError = IllegalStateTransitionError;
+const transitionStatus = (current, next, command) => {
+    if (current === next)
+        return current;
+    const allowedByCommand = exports.VALID_TRANSITIONS[current];
+    // 未指定 command 时仅允许 execute + dependency 权限（安全默认值），
+    // 特殊权限（route_backfill/retry_reset/reject_reset/sleep/group_aggregate）必须显式传 command。
+    const allowed = command
+        ? (allowedByCommand[command] ?? [])
+        : [
+            ...new Set([
+                ...(allowedByCommand["execute"] ?? []),
+                ...(allowedByCommand["dependency"] ?? []),
+            ]),
+        ];
+    if (!allowed.includes(next)) {
+        throw new IllegalStateTransitionError(current, next, command);
+    }
+    return next;
+};
+exports.transitionStatus = transitionStatus;

package/dist/src/pipeline/structured-output/contract.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEnvelope = exports.normalizeAllowedRoute = exports.normalizeSchemaVersion = exports.isRecord = void 0;
+const guards_1 = require("../../utils/guards");
+Object.defineProperty(exports, "isRecord", { enumerable: true, get: function () { return guards_1.isRecord; } });
+const normalizeSchemaVersion = (value) => {
+    if (typeof value === "number") {
+        if (Number.isFinite(value) && Number.isSafeInteger(value))
+            return value;
+        return null;
+    }
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    // 兼容模型把 schemaVersion 输出成字符串数字（例如 "1"）的场景。
+    if (!/^\d+$/.test(trimmed))
+        return null;
+    const parsed = Number(trimmed);
+    if (!Number.isFinite(parsed) || !Number.isSafeInteger(parsed))
+        return null;
+    return parsed;
+};
+exports.normalizeSchemaVersion = normalizeSchemaVersion;
+const normalizeAllowedRoute = (rawRoute, allowedRoutes) => {
+    if (typeof rawRoute !== "string")
+        return null;
+    const trimmed = rawRoute.trim();
+    if (!trimmed)
+        return null;
+    if (!allowedRoutes || allowedRoutes.length === 0)
+        return trimmed;
+    const direct = allowedRoutes.find((route) => route === trimmed);
+    if (direct)
+        return direct;
+    const lower = trimmed.toLowerCase();
+    // 允许大小写不一致，统一纠正为工作流里声明的 route，避免无意义失败。
+    const insensitive = allowedRoutes.find((route) => route.toLowerCase() === lower);
+    return insensitive ?? null;
+};
+exports.normalizeAllowedRoute = normalizeAllowedRoute;
+const isJsonValue = (value, depth = 0) => {
+    if (depth > 20)
+        return false;
+    if (value === null)
+        return true;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        return true;
+    if (Array.isArray(value)) {
+        return value.every((item) => isJsonValue(item, depth + 1));
+    }
+    if (!(0, guards_1.isRecord)(value))
+        return false;
+    return Object.values(value).every((item) => isJsonValue(item, depth + 1));
+};
+const isEmptyArtifactContent = (value) => {
+    if (value === null)
+        return true;
+    if (typeof value === "string")
+        return value.trim().length === 0;
+    if (typeof value === "number" || typeof value === "boolean")
+        return false;
+    if (Array.isArray(value))
+        return value.length === 0 || value.every((item) => isEmptyArtifactContent(item));
+    const entries = Object.values(value);
+    return entries.length === 0 || entries.every((item) => isEmptyArtifactContent(item));
+};
+const validateEnvelope = (envelope, ctx) => {
+    if (envelope.runId !== ctx.runId)
+        return { ok: false, code: "run_id_mismatch" };
+    if (envelope.nodeId !== ctx.nodeId)
+        return { ok: false, code: "node_id_mismatch" };
+    if (envelope.requestId !== ctx.requestId)
+        return { ok: false, code: "request_id_mismatch" };
+    if (envelope.sessionId !== ctx.sessionId)
+        return { ok: false, code: "session_id_mismatch" };
+    if (!Array.isArray(envelope.artifacts))
+        return { ok: false, code: "artifacts_invalid" };
+    if (envelope.status === "success" && envelope.artifacts.length === 0) {
+        return { ok: false, code: "artifacts_required" };
+    }
+    const spec = ctx.outputSpec;
+    for (const artifact of envelope.artifacts) {
+        if (!(0, guards_1.isRecord)(artifact))
+            return { ok: false, code: "artifact_invalid" };
+        if (typeof artifact.type !== "string" || !artifact.type)
+            return { ok: false, code: "artifact_type_invalid" };
+        const normalizedSchemaVersion = (0, exports.normalizeSchemaVersion)(artifact.schemaVersion);
+        if (normalizedSchemaVersion === null)
+            return { ok: false, code: "artifact_schema_invalid" };
+        artifact.schemaVersion = normalizedSchemaVersion;
+        if (!isJsonValue(artifact.content))
+            return { ok: false, code: "artifact_content_invalid" };
+        if (envelope.status === "success" && isEmptyArtifactContent(artifact.content))
+            return { ok: false, code: "artifact_content_invalid" };
+        if (artifact.type !== spec.type || artifact.schemaVersion !== spec.schemaVersion) {
+            return { ok: false, code: "artifact_spec_mismatch" };
+        }
+    }
+    // 兼容历史/冗余字段：顶层 route、decisions 不再作为硬失败条件，忽略即可。
+    if (envelope.control !== undefined) {
+        if (!(0, guards_1.isRecord)(envelope.control))
+            return { ok: false, code: "hold_control_invalid" };
+        const sleepUntil = envelope.control.sleepUntil;
+        if (sleepUntil !== undefined && sleepUntil !== null) {
+            if (typeof sleepUntil !== "string" || !sleepUntil.trim() || !Number.isFinite(Date.parse(sleepUntil))) {
+                return { ok: false, code: "hold_control_invalid" };
+            }
+        }
+    }
+    if (ctx.requireRouteContent && envelope.status === "success") {
+        const primaryArtifact = envelope.artifacts[0];
+        if (!primaryArtifact) {
+            return { ok: false, code: "route_content_invalid" };
+        }
+        if (!Array.isArray(primaryArtifact.content) && (0, guards_1.isRecord)(primaryArtifact.content)) {
+            // 兼容单对象输出，统一纠正为数组，后续分流逻辑保持一致。
+            primaryArtifact.content = [primaryArtifact.content];
+        }
+        if (!Array.isArray(primaryArtifact.content) || primaryArtifact.content.length === 0) {
+            return { ok: false, code: "route_content_invalid" };
+        }
+        for (const entry of primaryArtifact.content) {
+            if (!(0, guards_1.isRecord)(entry))
+                return { ok: false, code: "route_content_invalid" };
+            const route = (0, exports.normalizeAllowedRoute)(entry.route, ctx.allowedRoutes);
+            if (!route)
+                return { ok: false, code: "route_content_invalid" };
+            entry.route = route;
+        }
+    }
+    return { ok: true };
+};
+exports.validateEnvelope = validateEnvelope;

package/dist/src/pipeline/structured-output/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// 目录出口：调用方继续从 structured-output 子模块导入，内部文件按职责拆分。
+// 统一从这里 re-export，避免后续再次拆分时把外部 import 路径扩散到实现细节。
+__exportStar(require("./contract"), exports);
+__exportStar(require("./parser"), exports);
+__exportStar(require("./prompt"), exports);
+__exportStar(require("./waiter"), exports);

package/dist/src/pipeline/structured-output/parser.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectEnvelopeCandidates = exports.detectFenceLanguage = exports.toPromptContentText = void 0;
+const guards_1 = require("../../utils/guards");
+const contract_1 = require("./contract");
+const truncateText = (text, maxChars) => text.length > maxChars ? `${text.slice(0, maxChars)}\n...[truncated]` : text;
+const toPromptContentText = (content) => {
+    if (typeof content === "string")
+        return truncateText(content, 8_000);
+    try {
+        return truncateText(JSON.stringify(content, null, 2), 8_000);
+    }
+    catch {
+        return truncateText(String(content), 8_000);
+    }
+};
+exports.toPromptContentText = toPromptContentText;
+const detectFenceLanguage = (content) => {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return "text";
+    try {
+        JSON.parse(trimmed);
+        return "json";
+    }
+    catch {
+        return "text";
+    }
+};
+exports.detectFenceLanguage = detectFenceLanguage;
+const extractBalancedJsonObjectCandidates = (text) => {
+    const candidates = [];
+    const seen = new Set();
+    // 流式输出常出现“说明文字 + JSON”拼接在同一段文本中的情况。
+    // 这里通过括号平衡扫描抽取内嵌 JSON 对象，避免整段 JSON.parse 直接失败。
+    for (let start = text.indexOf("{"); start >= 0; start = text.indexOf("{", start + 1)) {
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        for (let i = start; i < text.length; i += 1) {
+            const char = text[i];
+            if (inString) {
+                if (escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if (char === "\\") {
+                    escaped = true;
+                    continue;
+                }
+                if (char === "\"") {
+                    inString = false;
+                }
+                continue;
+            }
+            if (char === "\"") {
+                inString = true;
+                continue;
+            }
+            if (char === "{") {
+                depth += 1;
+                continue;
+            }
+            if (char !== "}")
+                continue;
+            depth -= 1;
+            if (depth !== 0)
+                continue;
+            const candidate = text.slice(start, i + 1).trim();
+            if (!candidate || seen.has(candidate))
+                break;
+            seen.add(candidate);
+            candidates.push(candidate);
+            break;
+        }
+    }
+    return candidates;
+};
+const extractTextCandidates = (payload) => {
+    const texts = [];
+    const seen = new Set();
+    let nodesVisited = 0;
+    const walk = (value, depth) => {
+        if (depth > 6)
+            return;
+        nodesVisited += 1;
+        if (nodesVisited > 2_000)
+            return;
+        if (typeof value === "string") {
+            const trimmed = value.trim();
+            if (trimmed && trimmed.length <= 60_000 && !seen.has(trimmed)) {
+                seen.add(trimmed);
+                texts.push(trimmed);
+            }
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value)
+                walk(item, depth + 1);
+            return;
+        }
+        if (!(0, guards_1.isRecord)(value))
+            return;
+        for (const item of Object.values(value)) {
+            walk(item, depth + 1);
+        }
+    };
+    walk(payload, 0);
+    return texts;
+};
+const tryParseEnvelopeObject = (value) => {
+    if (!(0, guards_1.isRecord)(value))
+        return null;
+    if (value.version !== "2.0")
+        return null;
+    if (value.status !== "success" && value.status !== "failed")
+        return null;
+    if (!Array.isArray(value.artifacts))
+        return null;
+    if (typeof value.runId !== "string" || !value.runId)
+        return null;
+    if (typeof value.nodeId !== "string" || !value.nodeId)
+        return null;
+    if (typeof value.requestId !== "string" || !value.requestId)
+        return null;
+    if (typeof value.sessionId !== "string" || !value.sessionId)
+        return null;
+    for (const rawArtifact of value.artifacts) {
+        if (!(0, guards_1.isRecord)(rawArtifact))
+            continue;
+        const normalized = (0, contract_1.normalizeSchemaVersion)(rawArtifact.schemaVersion);
+        if (normalized !== null) {
+            // 解析阶段先做宽松纠正，后续统一走 number 语义校验与持久化。
+            rawArtifact.schemaVersion = normalized;
+        }
+    }
+    return value;
+};
+const mayContainResultEnvelopeText = (text) => text.includes('"version"') &&
+    text.includes('"requestId"') &&
+    text.includes('"artifacts"');
+const tryParseEnvelopeText = (text) => {
+    if (!mayContainResultEnvelopeText(text))
+        return null;
+    const ENVELOPE_TEXT_SCAN_TAIL_CHARS = 64_000;
+    let scanText = text;
+    if (text.length > ENVELOPE_TEXT_SCAN_TAIL_CHARS) {
+        const headLen = text.length - ENVELOPE_TEXT_SCAN_TAIL_CHARS;
+        const headPart = text.slice(0, headLen);
+        // 向前回溯到最近的 {，防止 JSON 起始被窗口切断
+        const lastBrace = headPart.lastIndexOf("{");
+        scanText = lastBrace >= 0 ? text.slice(lastBrace) : text.slice(-ENVELOPE_TEXT_SCAN_TAIL_CHARS);
+    }
+    const fenced = scanText.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const candidate = fenced?.[1]?.trim() || scanText.trim();
+    try {
+        const parsed = JSON.parse(candidate);
+        return tryParseEnvelopeObject(parsed);
+    }
+    catch {
+        const embeddedCandidates = extractBalancedJsonObjectCandidates(candidate);
+        for (const embedded of embeddedCandidates) {
+            try {
+                const parsed = JSON.parse(embedded);
+                const envelope = tryParseEnvelopeObject(parsed);
+                if (envelope)
+                    return envelope;
+            }
+            catch {
+                // 继续尝试后续候选
+            }
+        }
+        return null;
+    }
+};
+const collectEnvelopeCandidates = (payload) => {
+    const envelopes = [];
+    const seenKeys = new Set();
+    const pushEnvelope = (envelope) => {
+        const key = `${envelope.runId}|${envelope.nodeId}|${envelope.requestId}|${envelope.sessionId}|${envelope.status}|${envelope.artifacts.length}`;
+        if (seenKeys.has(key))
+            return;
+        seenKeys.add(key);
+        envelopes.push(envelope);
+    };
+    const textCandidates = extractTextCandidates(payload);
+    for (const text of textCandidates) {
+        const parsed = tryParseEnvelopeText(text);
+        if (parsed)
+            pushEnvelope(parsed);
+    }
+    const walk = (value, depth) => {
+        if (depth > 6)
+            return;
+        const parsed = tryParseEnvelopeObject(value);
+        if (parsed) {
+            pushEnvelope(parsed);
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value)
+                walk(item, depth + 1);
+            return;
+        }
+        if (!(0, guards_1.isRecord)(value))
+            return;
+        for (const item of Object.values(value)) {
+            walk(item, depth + 1);
+        }
+    };
+    walk(payload, 0);
+    return envelopes;
+};
+exports.collectEnvelopeCandidates = collectEnvelopeCandidates;