helixlife-expert-cli 0.1.0

package/cli/dist/modules/meta/workflow.js

@@ -0,0 +1,956 @@
+import { helixlifeError, helixlifeErrorCode, printOutput, renderListAsMarkdown, } from "../../core/index.js";
+import { META_API_PREFIX } from "./constants.js";
+import { requestMeta } from "./api.js";
+const WORKFLOW_COOLDOWN_MESSAGE = "请联系解螺旋客服";
+const META_WORKFLOW_STEP_DEFINITIONS = [
+    {
+        index: "1.1",
+        label: "拟定主题",
+        nodeType: "title",
+        aliases: ["generate_topic", "verify_topic"],
+    },
+    { index: "1.2", label: "生成 PI(E)COS", nodeType: "generate_picos" },
+    { index: "1.3", label: "建立纳排", nodeType: "generate_sorting_criteria" },
+    {
+        index: "2.1",
+        label: "撰写检索式",
+        nodeType: "generate_retrieve_expression",
+    },
+    { index: "2.2", label: "执行检索", nodeType: "literature_retrieve" },
+    { index: "3.1", label: "摘要初筛", nodeType: "abstract_screening" },
+    { index: "3.2", label: "全文复筛", nodeType: "fulltext_screening" },
+    { index: "4.1", label: "质量评估", nodeType: "quality_assessment" },
+    { index: "4.2", label: "基线资料", nodeType: "baseline_information" },
+    { index: "4.3", label: "结局指标", nodeType: "outcome_indicator_extraction" },
+    { index: "5.1", label: "效应量合并", nodeType: "effect_quantity" },
+    { index: "5.2", label: "发表偏倚", nodeType: "publication_bias" },
+    { index: "5.3", label: "质量评估图", nodeType: "quality_assessment_plot" },
+    {
+        index: "5.4",
+        label: "PRISMA 流程图",
+        nodeType: "prisma",
+    },
+    { index: "6.1", label: "生成方法", nodeType: "generate_method" },
+    { index: "6.2", label: "生成结果", nodeType: "generate_outcome" },
+    { index: "6.3", label: "生成初稿", nodeType: "generate_fulltext" },
+];
+/** 历史列表展示列：不含 workflowId 等内部字段（仍保留在 row / switchTargets 供串联） */
+const HISTORY_COLUMNS = [
+    { key: "index", label: "序号" },
+    { key: "name", label: "名称" },
+    { key: "status", label: "状态" },
+    { key: "currentStep", label: "当前步骤" },
+    { key: "createdAt", label: "创建时间" },
+];
+/**
+ * 历史记录状态中文（对齐网站 HistoryModal：success/archived 为完成态，其余为进行态）。
+ * archived 文案与网站一致为「已归档」；pending 类参考 NODE_PENDING_STATUS 中文标签。
+ */
+const HISTORY_STATUS_LABEL = {
+    success: "成功",
+    archived: "已归档",
+    queued: "排队中",
+    pending: "等待中",
+    running: "执行中",
+    more_coming: "执行中",
+    fail: "失败",
+    failed: "失败",
+    error: "失败",
+    failure: "失败",
+};
+/** 历史列表操作选项文案（固定，禁止改写） */
+const HISTORY_OP_PREV_PAGE = "查看上一页";
+const HISTORY_OP_NEXT_PAGE = "查看下一页";
+const HISTORY_OP_SWITCH = "切换指定历史记录";
+/** 历史列表操作选择器 value（固定，供 Agent 分支） */
+const HISTORY_OP_VALUE_PREV = "prev_page";
+const HISTORY_OP_VALUE_NEXT = "next_page";
+const HISTORY_OP_VALUE_SWITCH = "switch_record";
+/** 历史列表操作选择器标题（固定，禁止改写） */
+const HISTORY_LIST_SELECTOR_TITLE = "请选择历史记录操作";
+/** 切换记录选择器标题（固定，禁止改写） */
+const HISTORY_SWITCH_SELECTOR_TITLE = "请选择要切换的历史记录";
+/** 聊天压缩表名称最大长度（避免大表同轮挤掉 AskQuestion） */
+const HISTORY_CHAT_NAME_MAX_LEN = 48;
+/**
+ * 历史列表交付硬指令。
+ * 表格在聊天展示；AskQuestion 的 prompt 不含表；本轮恰好弹 1 次选择器。
+ */
+const HISTORY_LIST_DISPLAY_INSTRUCTION = "同轮两步后停轮：①在聊天原样输出 tableMarkdown（历史记录表）；" +
+    "②按 askQuestion 原样调用恰好 1 次 AskQuestion（prompt 不含表格），然后停轮。" +
+    "AskQuestion 调用次数必须为 1：禁止 0 次、禁止连弹 2 次；回到第 1 页也不得补弹。" +
+    "禁止把表格塞进 askQuestion.prompt。prev_page/next_page 后规则相同。";
+/** 切换记录选项交付硬指令：本页全部序号一次展平，禁止拆成 1/2 段 */
+const HISTORY_SWITCH_OPTIONS_DISPLAY_INSTRUCTION = "本轮 AskQuestion 恰好 1 次：按 askQuestion 原样调用（prompt 不含表）；" +
+    "禁止连弹两次；禁止拆成 1/2 分页；禁止「其他补充」；" +
+    "选中后用选项 id 立刻 workflow switch。";
+/** 步骤列表展示列：不含 nodeId / nodeType 等内部字段（仍保留在 steps 数据供 switch） */
+const STEP_COLUMNS = [
+    { key: "index", label: "Step" },
+    { key: "label", label: "Name" },
+];
+/**
+ * Detects workflow-creation cooldown or rate-limit failures returned by the API.
+ *
+ * @param error The error thrown while creating a Meta workflow.
+ * @returns True when the failure means a new workflow cannot currently be created.
+ */
+function isWorkflowCreateCooldownError(error) {
+    const message = error instanceof Error ? error.message : String(error ?? "");
+    return /冷却|冷卻|cooldown|频繁|頻繁|too many|rate limit|rate-limit|429|无法创建新的工作流|不能创建新的工作流|创建新的工作流/i.test(message);
+}
+/**
+ * 将历史记录时间戳格式化为本地可读时间。
+ *
+ * @param value 接口返回的原始时间戳。
+ * @returns `YYYY-MM-DD HH:mm` 字符串。
+ */
+function formatTimestamp(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        const timestamp = value > 10_000_000_000 ? value : value * 1000;
+        const date = new Date(timestamp);
+        const pad = (n) => String(n).padStart(2, "0");
+        return (`${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ` +
+            `${pad(date.getHours())}:${pad(date.getMinutes())}`);
+    }
+    return value === undefined || value === null ? "" : String(value);
+}
+/**
+ * 将历史记录状态转为中文展示。
+ *
+ * @param status 接口返回的英文状态值。
+ * @returns 中文状态；未知值原样回退。
+ */
+function formatHistoryStatus(status) {
+    const key = typeof status === "string" ? status.trim() : "";
+    if (!key)
+        return "";
+    return HISTORY_STATUS_LABEL[key] ?? key;
+}
+/**
+ * Gets the user-facing step label for a workflow node type.
+ *
+ * @param nodeType The backend node type.
+ * @returns A step label aligned with the website process list.
+ */
+function getStepText(nodeType) {
+    const type = typeof nodeType === "string" ? nodeType : "";
+    const match = META_WORKFLOW_STEP_DEFINITIONS.find((step) => {
+        const aliases = "aliases" in step ? [...step.aliases] : [];
+        return step.nodeType === type || aliases.includes(type);
+    });
+    return match ? `${match.index} ${match.label}` : type;
+}
+/**
+ * Extracts a workflow id from a history item.
+ *
+ * @param item The raw history item.
+ * @returns The workflow id if present.
+ */
+function getHistoryWorkflowId(item) {
+    return String(item.id ?? item.runner_id ?? "");
+}
+/**
+ * 构建历史列表本轮 AskQuestion 选项（翻页 / 切换；写入 selectionOptions）。
+ *
+ * @param hasPrevPage 是否有上一页。
+ * @param hasNextPage 是否有下一页。
+ * @returns selectionOptions 与同序 operationOptions。
+ */
+function buildHistoryOperationSelection(hasPrevPage, hasNextPage) {
+    const selectionOptions = [];
+    if (hasPrevPage) {
+        selectionOptions.push({
+            index: selectionOptions.length + 1,
+            label: HISTORY_OP_PREV_PAGE,
+            value: HISTORY_OP_VALUE_PREV,
+        });
+    }
+    if (hasNextPage) {
+        selectionOptions.push({
+            index: selectionOptions.length + 1,
+            label: HISTORY_OP_NEXT_PAGE,
+            value: HISTORY_OP_VALUE_NEXT,
+        });
+    }
+    selectionOptions.push({
+        index: selectionOptions.length + 1,
+        label: HISTORY_OP_SWITCH,
+        value: HISTORY_OP_VALUE_SWITCH,
+    });
+    return {
+        selectionOptions,
+        operationOptions: selectionOptions.map((item) => item.label),
+    };
+}
+/**
+ * 截断历史列表名称，供聊天压缩表使用。
+ *
+ * @param name 原始名称。
+ * @returns 截断后的名称。
+ */
+function truncateHistoryChatName(name) {
+    const text = name.trim();
+    if (text.length <= HISTORY_CHAT_NAME_MAX_LEN)
+        return text;
+    return `${text.slice(0, HISTORY_CHAT_NAME_MAX_LEN - 1)}...`;
+}
+/**
+ * 构建历史列表表格、分页序号与操作选择器。
+ *
+ * @param data 接口返回的历史列表数据。
+ * @param options 当前请求的分页参数（用于序号与上下页判断）。
+ * @returns 表格、tableMarkdown、chatTableMarkdown、selectionOptions 等。
+ */
+function buildHistoryListView(data, options = {}) {
+    const items = Array.isArray(data.items) ? data.items : [];
+    const page = Math.max(1, Number(options.page ?? data.page ?? 1) || 1);
+    const limit = Math.max(1, Number(options.limit ?? data.limit ?? 10) || 10);
+    const total = Math.max(0, Number(data.total ?? 0) || 0);
+    const hasPrevPage = page > 1;
+    const hasNextPage = page * limit < total;
+    const rows = items.map((item, index) => {
+        const workflowId = getHistoryWorkflowId(item);
+        return {
+            // 序号按分页连续编号：(page - 1) * limit + 行号
+            index: (page - 1) * limit + index + 1,
+            name: String(item.name ?? ""),
+            status: formatHistoryStatus(item.status),
+            currentStep: getStepText(item.head_node_type),
+            createdAt: formatTimestamp(item.created_timestamp),
+            workflowId,
+        };
+    });
+    const columns = [...HISTORY_COLUMNS];
+    const { selectionOptions, operationOptions } = buildHistoryOperationSelection(hasPrevPage, hasNextPage);
+    // 非 SelectionOptions 形，降低 Agent 同轮误弹第二选择器的概率
+    const switchTargets = rows
+        .filter((row) => row.workflowId)
+        .map((row) => ({
+        index: Number(row.index),
+        workflowId: String(row.workflowId),
+    }));
+    const indexStart = rows.length > 0 ? Number(rows[0].index) : (page - 1) * limit + 1;
+    const indexEnd = rows.length > 0 ? Number(rows[rows.length - 1].index) : indexStart - 1;
+    const pageSummary = rows.length > 0
+        ? // 用 ASCII 连字符，避免 AskQuestion prompt 中 en-dash（U+2013）显示为 �
+            `第 ${page} 页（序号 ${indexStart}-${indexEnd}），共 ${total} 条。`
+        : `第 ${page} 页，共 ${total} 条（本页无记录）。`;
+    // 聊天压缩表：缩短名称，去掉创建时间，降低同轮消息体积
+    const chatRows = rows.map((row) => ({
+        index: row.index,
+        name: truncateHistoryChatName(String(row.name)),
+        status: row.status,
+        currentStep: row.currentStep,
+    }));
+    const chatColumns = [
+        { key: "index", label: "序号" },
+        { key: "name", label: "名称" },
+        { key: "status", label: "状态" },
+        { key: "currentStep", label: "当前步骤" },
+    ];
+    return {
+        table: { columns, rows },
+        tableMarkdown: renderListAsMarkdown(rows, columns),
+        chatTableMarkdown: renderListAsMarkdown(chatRows, [...chatColumns]),
+        pageSummary,
+        selectorPhase: "list-operation",
+        selectionOptions,
+        switchTargets,
+        operationOptions,
+        page,
+        limit,
+        total,
+        hasPrevPage,
+        hasNextPage,
+        requireSelector: true,
+        selectorTitle: HISTORY_LIST_SELECTOR_TITLE,
+        displayInstruction: HISTORY_LIST_DISPLAY_INSTRUCTION,
+    };
+}
+/**
+ * 历史列表 JSON：聊天用 tableMarkdown；askQuestion.prompt 仅短文案不含表。
+ *
+ * @param result listMetaWorkflows 完整结果。
+ * @returns Agent 应消费的精简 JSON。
+ */
+function toHistoryListJsonPayload(result) {
+    // 每次 list 使用唯一 question id，避免回到第 1 页时与历史 AskQuestion 冲突连弹
+    const questionId = `meta_history_list_p${result.page}_${Date.now()}`;
+    return {
+        displayInstruction: result.displayInstruction,
+        askQuestionCallCountMustBe: 1,
+        // 历史记录表：必须贴进聊天，不要放进 askQuestion.prompt
+        tableMarkdown: result.tableMarkdown,
+        pageSummary: result.pageSummary,
+        askQuestion: {
+            title: result.selectorTitle,
+            questions: [
+                {
+                    id: questionId,
+                    // prompt 仅短说明，不含压缩表/完整表
+                    prompt: result.pageSummary,
+                    options: result.selectionOptions.map((item) => ({
+                        id: item.value,
+                        label: item.label,
+                    })),
+                },
+            ],
+        },
+        page: result.page,
+        limit: result.limit,
+        total: result.total,
+        hasPrevPage: result.hasPrevPage,
+        hasNextPage: result.hasNextPage,
+        onSelect: {
+            prev_page: "list --page <page-1> → 聊天输出 tableMarkdown → 对 askQuestion 只调用 1 次 AskQuestion",
+            next_page: "list --page <page+1> → 聊天输出 tableMarkdown → 对 askQuestion 只调用 1 次 AskQuestion",
+            switch_record: "下一轮 list --page <当前页> --switch-options → 对其 askQuestion 只调用 1 次 → switch",
+        },
+    };
+}
+/**
+ * 切换记录选项 JSON：只下发 askQuestion（含本页全部序号）。
+ *
+ * @param result listMetaWorkflows 完整结果。
+ * @returns Agent 应消费的切换选项 JSON。
+ */
+function toHistorySwitchOptionsJsonPayload(result) {
+    const selectionOptions = result.switchTargets.map((target) => ({
+        index: target.index,
+        label: `序号 ${target.index}`,
+        value: target.workflowId,
+    }));
+    const questionId = `meta_history_switch_p${result.page}_${Date.now()}`;
+    return {
+        displayInstruction: HISTORY_SWITCH_OPTIONS_DISPLAY_INSTRUCTION,
+        askQuestionCallCountMustBe: 1,
+        passAllOptionsInOneAsk: true,
+        selectionOptionsCount: selectionOptions.length,
+        askQuestion: {
+            title: HISTORY_SWITCH_SELECTOR_TITLE,
+            questions: [
+                {
+                    id: questionId,
+                    prompt: `请选择要切换的历史记录（本页共 ${selectionOptions.length} 条，须一次全部展示）：`,
+                    options: selectionOptions.map((item) => ({
+                        id: item.value,
+                        label: item.label,
+                    })),
+                },
+            ],
+        },
+        page: result.page,
+        limit: result.limit,
+        total: result.total,
+    };
+}
+const SWITCH_ARTIFACT_DISPLAY_RULE = "必须与正常流程一致：先执行 refetchCommand 生成/落盘当前节点产物，再实际展示产物本身；" +
+    "禁止只输出切换成功、步骤摘要、参数列表、语言/元数据，或口头声称「已展示 / 正文已完整展示」。";
+/** 各节点切换后的重取命令、选择器与操作选项。 */
+const SWITCH_NODE_GUIDANCE = {
+    generate_topic: {
+        requireSelector: true,
+        operationOptions: ["选题序号（selectionOptions）", "重新生成选题"],
+        displayInstruction: "切换后须按选题节点规则完整展示候选题（candidateListMarkdown / selectionOptions），再弹选择器。" +
+            "若已选定（返回 selectorTitle）：AskQuestion 标题必须原样为 selectorTitle（已选择选题 N），" +
+            "选项为编辑当前选题 / 确认无误，下一步（生成 PICOS）；" +
+            "禁止「请选择下一步操作」等泛化标题；禁止未标明已选项就弹编辑/确认操作。",
+    },
+    verify_topic: {
+        requireSelector: true,
+        operationOptions: [
+            "编辑当前选题",
+            "确认无误，下一步（生成 PICOS）",
+        ],
+        displayInstruction: "切换后若已选定：聊天写明「已选择选题 N：题目」；" +
+            "AskQuestion 标题必须原样用返回的 selectorTitle（已选择选题 N），" +
+            "禁止「请选择下一步操作」「请选择操作」；" +
+            "选项：编辑当前选题 / 确认无误，下一步（生成 PICOS）。" +
+            "若尚未选定，则按候选题规则弹 selectionOptions。",
+    },
+    generate_picos: {
+        requireSelector: true,
+        operationOptions: [
+            "编辑内容",
+            "重新生成 PICOS",
+            "确认无误，下一步（生成纳排标准）",
+        ],
+        displayInstruction: "切换后须完整展示 PICOS 各字段原文，再弹选择器。",
+    },
+    generate_sorting_criteria: {
+        requireSelector: true,
+        operationOptions: [
+            "编辑内容",
+            "重新生成纳排标准",
+            "确认无误，下一步（生成检索式）",
+        ],
+        displayInstruction: "切换后须原样展示纳排标准 displayData，再弹选择器。",
+    },
+    generate_retrieve_expression: {
+        refetchCommand: "retrieve expression get",
+        requireSelector: true,
+        operationOptions: [
+            "编辑当前检索式",
+            "重新生成检索式",
+            "确认无误，下一步（检索文献）",
+        ],
+        displayInstruction: "切换后必须执行 retrieve expression get，原样完整输出 expressionMarkdown，再弹选择器（编辑细则见 meta.md「检索式 / 编辑检索式」）。",
+    },
+    literature_retrieve: {
+        refetchCommand: "retrieve literature list",
+        requireSelector: true,
+        operationOptions: [
+            "补充文献",
+            "编辑检索式并重新检索",
+            "查看下一页结果",
+            "确认无误，下一步（摘要初筛）",
+        ],
+        displayInstruction: "切换后必须执行 retrieve literature list，原样完整输出 tableMarkdown，再弹选择器。",
+    },
+    abstract_screening: {
+        refetchCommand: "screening abstract list",
+        requireSelector: true,
+        operationOptions: [
+            "编辑文献信息",
+            "上传PDF文件",
+            "已选文献重新筛选",
+            "确认无误，下一步（全文复筛）",
+        ],
+        displayInstruction: "切换后先 screening abstract count-pdf，再 abstract list；原样完整输出 tableMarkdown 后弹选择器（pdf-count < 3 时去掉「下一步」）。" +
+            "选记录用 list 的 selectionOptions；上传 PDF 三拍停轮见 meta.md「初筛选文献」。",
+    },
+    fulltext_screening: {
+        refetchCommand: "screening fulltext list",
+        requireSelector: true,
+        operationOptions: [
+            "编辑文献信息",
+            "已选文献重新筛选",
+            "确认无误，下一步（数据抽提）",
+        ],
+        displayInstruction: "切换后必须执行 screening fulltext list 与 fulltext check；原样完整输出 tableMarkdown 后立刻弹选择器。",
+    },
+    quality_assessment: {
+        refetchCommand: "extraction quality list",
+        requireSelector: true,
+        operationOptions: [
+            "编辑内容",
+            "选择文献重新评估",
+            "确认无误，下一步（提取基线资料）",
+        ],
+        displayInstruction: "切换后必须执行 extraction quality list，原样完整输出表格后弹选择器。",
+    },
+    baseline_information: {
+        refetchCommand: "extraction baseline list",
+        requireSelector: true,
+        operationOptions: [
+            "编辑内容",
+            "选择文献重新抽提",
+            "确认无误，下一步（提取结局指标）",
+        ],
+        displayInstruction: "切换后必须执行 extraction baseline list，原样完整输出 tableMarkdown（10 列）后弹选择器。" +
+            "点选「编辑内容」或「选择文献重新抽提」时：用 baselineRecordRefs 按 Study 选记录（id 仅内部使用）；编辑时再展示可编辑字段并弹「手动输入」。",
+    },
+    outcome_indicator_extraction: {
+        refetchCommand: "extraction outcome list",
+        requireSelector: true,
+        operationOptions: [
+            "编辑内容",
+            "删除结局指标",
+            "确认无误，下一步（统计分析）",
+        ],
+        displayInstruction: "切换后必须执行 extraction outcome list；先 Read 返回的 artifact.output 全文，再原样贴进回复（须同时含父表+各研究子表），再弹选择器。" +
+            "禁止只贴序号/Study/Pmid 父表或用 outcomeParentSelectionOptions 拼父表冒充完整结局数据；无 Outcome Name 子表视为交付失败。" +
+            "点选「编辑内容」/「删除结局指标」：先弹父级 Study+Pmid 选择器 → 再只贴该父级子表并弹子结局选择器（每页最多 10 条，超出分页）；" +
+            "编辑时再按网站表单一次列全字段（g1/g2 分列；Value 槽随 Binary→Events / Continuity→SD+Mean / Survival→HR+95%CI 切换），再弹「手动输入」。",
+    },
+    effect_quantity: {
+        refetchCommand: "analysis forest get",
+        requireSelector: false,
+        operationOptions: [
+            "编辑参数并重新生成",
+            "确认无误，下一步（发表偏倚）",
+        ],
+        displayInstruction: `${SWITCH_ARTIFACT_DISPLAY_RULE}` +
+            "执行 analysis forest get，从 artifact 打开/预览森林图 PDF；可附带当前参数说明。" +
+            "禁止弹选择器；按 operationOptions 以 Markdown 无序列表列出后停顿，禁止用 / 同行拼接。",
+    },
+    publication_bias: {
+        refetchCommand: "analysis funnel get",
+        requireSelector: false,
+        operationOptions: [
+            "编辑参数并重新生成",
+            "确认无误，下一步（质量评估图）",
+        ],
+        displayInstruction: `${SWITCH_ARTIFACT_DISPLAY_RULE}` +
+            "执行 analysis funnel get，从 artifact 打开/预览漏斗图 PDF；可附带当前参数说明。" +
+            "禁止弹选择器；按 operationOptions 以 Markdown 无序列表列出后停顿，禁止用 / 同行拼接。",
+    },
+    quality_assessment_plot: {
+        refetchCommand: "analysis quality-plot get",
+        requireSelector: false,
+        operationOptions: [
+            "编辑参数并重新生成",
+            "确认无误，下一步（PRISMA 流程图）",
+        ],
+        displayInstruction: `${SWITCH_ARTIFACT_DISPLAY_RULE}` +
+            "执行 analysis quality-plot get，必须展示红绿灯图与总结图两份 PDF 产物。" +
+            "禁止弹选择器；按 operationOptions 以 Markdown 无序列表列出后停顿，禁止用 / 同行拼接。",
+    },
+    prisma: {
+        refetchCommand: "analysis prisma get-image",
+        requireSelector: false,
+        operationOptions: [
+            "导出其他格式",
+            "确认无误，下一步（辅助写作）",
+        ],
+        displayInstruction: `${SWITCH_ARTIFACT_DISPLAY_RULE}` +
+            "执行 analysis prisma get-image，从 artifact 打开/预览 PRISMA PNG。" +
+            "禁止弹选择器；按 operationOptions 以 Markdown 无序列表列出后停顿，禁止用 / 同行拼接。" +
+            "禁止此时弹全文语言选择器；仅用户点选「确认无误，下一步（辅助写作）」后，才必须弹出可点击交互选择器选择 English / 中文（禁止聊天列表代替），选定后再进入写作。",
+    },
+    generate_method: {
+        refetchCommand: "writing method get",
+        requireSelector: false,
+        operationOptions: [
+            "编辑内容",
+            "重新生成方法",
+            "确认无误，下一步（生成结果）",
+        ],
+        displayInstruction: `${SWITCH_ARTIFACT_DISPLAY_RULE}` +
+            "执行 writing method get，必须将响应 text 原文逐字完整贴进对话，并交付 artifact（方法.md）。" +
+            "禁止用「方法正文已完整展示」「含 N 个章节」或章节名清单代替原文；未贴出正文即交付失败。" +
+            "禁止弹选择器；按 operationOptions 以 Markdown 无序列表列出后停顿，禁止用 / 同行拼接。",
+    },
+    generate_outcome: {
+        refetchCommand: "writing result get",
+        requireSelector: false,
+        operationOptions: [
+            "编辑内容",
+            "重新生成结果",
+            "确认无误，下一步（生成全文）",
+        ],
+        displayInstruction: `${SWITCH_ARTIFACT_DISPLAY_RULE}` +
+            "执行 writing result get，交付并展示 artifact（结果.md）；获取结果后回复文本中也要展示开头若干段原文，随后输出 ...，并提示「详细内容可查看文档产物」。" +
+            "禁止只用「结果已生成」而无预览；禁止只列操作选项却不展示产物；禁止弹选择器；按 operationOptions 以 Markdown 无序列表列出后停顿，禁止用 / 同行拼接。",
+    },
+    generate_fulltext: {
+        refetchCommand: "writing fulltext get",
+        requireSelector: false,
+        operationOptions: [],
+        displayInstruction: `${SWITCH_ARTIFACT_DISPLAY_RULE}` +
+            "执行 writing fulltext get，交付并展示全部 artifact：" +
+            "初筛结果.xlsx、复筛结果.xlsx、质量评估.xlsx、结局指标.xlsx、PRISMA流程图.docx、PRISMA流程图.pdf、生成初稿.docx；" +
+            "若响应含 text，回复文本中也要展示开头若干段原文后接 ...，并提示「详细内容可查看文档产物」；" +
+            "禁止只交付生成初稿.docx；结束后不弹选择器。",
+    },
+};
+/**
+ * 解析节点类型对应的切换指引。
+ *
+ * @param nodeType 后端 node_type。
+ * @returns 重取命令与交互指引；未知类型时返回通用指令。
+ */
+function resolveSwitchGuidance(nodeType) {
+    const known = SWITCH_NODE_GUIDANCE[nodeType];
+    if (known) {
+        return known;
+    }
+    return {
+        requireSelector: true,
+        operationOptions: [],
+        displayInstruction: "切换后须按该节点原有展示规则完整交付当前结果，再按逐节点操作选项继续；禁止只输出切换成功摘要。",
+    };
+}
+const TOPIC_NODE_TYPES = new Set([
+    "generate_topic",
+    "generate_topic_guard",
+    "verify_topic",
+    "verify_topic_guard",
+]);
+const CONFIRMED_TOPIC_OPERATION_OPTIONS = [
+    "编辑当前选题",
+    "确认无误，下一步（生成 PICOS）",
+];
+/**
+ * 从选题节点 payload 取出原始对象（兼容 output.output 嵌套）。
+ */
+function extractTopicPayload(node) {
+    const raw = node.output;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return undefined;
+    }
+    const record = raw;
+    if (record.output &&
+        typeof record.output === "object" &&
+        !Array.isArray(record.output)) {
+        return record.output;
+    }
+    return record;
+}
+/**
+ * 从选题节点提取候选题目列表。
+ */
+function extractTopicTitlesFromNode(node) {
+    const raw = node.output;
+    const payload = raw &&
+        typeof raw === "object" &&
+        !Array.isArray(raw) &&
+        "output" in raw &&
+        Array.isArray(raw.output)
+        ? raw.output
+        : extractTopicPayload(node);
+    if (Array.isArray(payload)) {
+        return payload
+            .map((item) => {
+            if (typeof item === "string") {
+                return item.trim();
+            }
+            if (item && typeof item === "object") {
+                const row = item;
+                const english = row.English ?? row.english ?? row.title;
+                return typeof english === "string" ? english.trim() : "";
+            }
+            return "";
+        })
+            .filter(Boolean);
+    }
+    if (!payload || typeof payload !== "object") {
+        return [];
+    }
+    return Object.entries(payload)
+        .filter(([key]) => /^Title\d+$/i.test(key))
+        .sort(([a], [b]) => a.localeCompare(b, undefined, { numeric: true }))
+        .map(([, value]) => {
+        if (typeof value === "string") {
+            return value.trim();
+        }
+        if (value && typeof value === "object") {
+            const row = value;
+            const english = row.English ?? row.english ?? row.title;
+            return typeof english === "string" ? english.trim() : "";
+        }
+        return "";
+    })
+        .filter(Boolean);
+}
+/**
+ * 读取节点已选选题；无 selected 时可用工作流名称在候选中匹配。
+ */
+function extractSelectedTopicTitle(node, workflowName) {
+    const payload = extractTopicPayload(node);
+    const selected = payload?.selected;
+    if (selected && typeof selected === "object" && !Array.isArray(selected)) {
+        const row = selected;
+        for (const key of ["English", "english", "Chinese", "chinese", "title"]) {
+            const value = row[key];
+            if (typeof value === "string" && value.trim()) {
+                return value.trim();
+            }
+        }
+    }
+    if (typeof selected === "string" && selected.trim()) {
+        return selected.trim();
+    }
+    const name = workflowName?.trim();
+    if (!name) {
+        return undefined;
+    }
+    const titles = extractTopicTitlesFromNode(node);
+    return titles.find((title) => title === name);
+}
+/**
+ * 选题节点切换后：若已选定则覆盖为「已确认选题」指引（含 selectorTitle）。
+ *
+ * @param node 目标选题节点。
+ * @param workflowName 工作流名称（可作已选匹配回退）。
+ * @param base 静态节点指引。
+ * @returns 可能叠加 selectorTitle / selected* 的指引字段。
+ */
+function resolveTopicSwitchFields(node, workflowName, base) {
+    if (!node || !TOPIC_NODE_TYPES.has(node.node_type)) {
+        return {
+            operationOptions: base.operationOptions,
+            displayInstruction: base.displayInstruction,
+        };
+    }
+    const selectedTitle = extractSelectedTopicTitle(node, workflowName);
+    if (!selectedTitle) {
+        return {
+            operationOptions: ["选题序号（selectionOptions）", "重新生成选题"],
+            displayInstruction: "切换后须完整展示候选题（candidateListMarkdown / selectionOptions），再弹候选题选择器；" +
+                "禁止未选定就弹「编辑当前选题 / 确认无误…」。",
+        };
+    }
+    const titles = extractTopicTitlesFromNode(node);
+    const matched = titles.findIndex((title) => title === selectedTitle);
+    const selectedIndex = matched >= 0 ? matched + 1 : undefined;
+    const selectorTitle = selectedIndex !== undefined
+        ? `已选择选题 ${selectedIndex}`
+        : "已选择选题";
+    return {
+        selectedTitle,
+        ...(selectedIndex !== undefined ? { selectedIndex } : {}),
+        selectorTitle,
+        operationOptions: [...CONFIRMED_TOPIC_OPERATION_OPTIONS],
+        displayInstruction: `已确认选题：聊天须写明「${selectorTitle}：${selectedTitle}」；` +
+            `AskQuestion / 选择器的标题（title）必须原样为「${selectorTitle}」；` +
+            "选项：编辑当前选题 / 确认无误，下一步（生成 PICOS）。" +
+            "禁止使用「请选择下一步操作」「请选择操作」「请选择」等泛化标题。",
+    };
+}
+/**
+ * Finds a successful node that can be used as a branch starting point.
+ *
+ * @param workflow The source workflow.
+ * @param nodeType The requested node type or website pseudo node type.
+ * @param options.includeHead 为 true 时允许匹配 head（switch 定位含当前步骤）。
+ * @returns The matching workflow node when available.
+ */
+function findSwitchableNode(workflow, nodeType, options) {
+    const definition = META_WORKFLOW_STEP_DEFINITIONS.find((step) => step.nodeType === nodeType ||
+        ("aliases" in step &&
+            [...step.aliases].includes(nodeType)));
+    const aliases = definition && "aliases" in definition ? [...definition.aliases] : [];
+    const candidates = new Set([
+        nodeType,
+        ...(definition ? [definition.nodeType] : []),
+        ...aliases,
+    ]);
+    const includeHead = options?.includeHead === true;
+    // 优先精确匹配指定类型；includeHead 时允许定位到当前 head
+    return (workflow.nodes ?? []).find((node) => (includeHead || node.id !== workflow.head) &&
+        node.status === "success" &&
+        candidates.has(node.node_type));
+}
+/**
+ * Builds switchable step options from successful workflow nodes.
+ *
+ * @param workflow The workflow detail response.
+ * @returns Step options that can be used to locate a historical workflow step.
+ */
+function buildSwitchableSteps(workflow) {
+    const nodeMap = new Map();
+    for (const node of workflow.nodes ?? []) {
+        if (node.id !== workflow.head && node.status === "success") {
+            nodeMap.set(node.node_type, node);
+        }
+    }
+    const steps = [];
+    for (const step of META_WORKFLOW_STEP_DEFINITIONS) {
+        const node = findSwitchableNode(workflow, step.nodeType);
+        if (node) {
+            steps.push({
+                index: step.index,
+                label: step.label,
+                nodeType: step.nodeType,
+                nodeId: node.id,
+            });
+        }
+        else if (step.nodeType === "title") {
+            const topicNode = nodeMap.get("generate_topic") ?? nodeMap.get("verify_topic");
+            if (topicNode) {
+                steps.push({
+                    index: step.index,
+                    label: step.label,
+                    nodeType: topicNode.node_type,
+                    nodeId: topicNode.id,
+                });
+            }
+        }
+    }
+    return steps;
+}
+function summarizeWorkflow(workflow) {
+    if (!workflow.runner_id) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, "Meta 工作流响应缺少 runner_id");
+    }
+    const nodes = Array.isArray(workflow.nodes) ? workflow.nodes : [];
+    const headNode = nodes.find((node) => node.id === workflow.head);
+    return {
+        runnerId: workflow.runner_id,
+        head: workflow.head,
+        nodeCount: nodes.length,
+        headNodeType: headNode?.node_type,
+        headStatus: headNode?.status,
+    };
+}
+function printWorkflowResult(result, format) {
+    if (format === "json") {
+        printOutput(result, "json");
+        return;
+    }
+    // 用户侧不展示 runnerId / head 等内部 ID，仅输出可读摘要
+    console.log(renderListAsMarkdown([
+        {
+            nodeCount: result.summary.nodeCount,
+            headNodeType: getStepText(result.summary.headNodeType),
+            headStatus: result.summary.headStatus ?? "",
+        },
+    ], [
+        { key: "nodeCount", label: "节点数" },
+        { key: "headNodeType", label: "当前步骤" },
+        { key: "headStatus", label: "状态" },
+    ]));
+}
+export async function createMetaWorkflow(options = {}) {
+    let workflow;
+    try {
+        workflow = await requestMeta(`${META_API_PREFIX}/workflow/runs`, {
+            method: "POST",
+            body: { base: null },
+            configPath: options.configPath,
+            action: "创建 Meta 工作流",
+        });
+    }
+    catch (error) {
+        if (isWorkflowCreateCooldownError(error)) {
+            throw new helixlifeError(helixlifeErrorCode.REQUEST_FAILED, WORKFLOW_COOLDOWN_MESSAGE, {
+                cause: error,
+            });
+        }
+        throw error;
+    }
+    const summary = summarizeWorkflow(workflow);
+    return {
+        runnerId: summary.runnerId,
+        summary,
+        workflow,
+    };
+}
+export async function getMetaWorkflow(options) {
+    const workflow = await requestMeta(`${META_API_PREFIX}/workflow/runs/${encodeURIComponent(options.workflowId)}`, {
+        configPath: options.configPath,
+        action: "查询 Meta 工作流",
+    });
+    const summary = summarizeWorkflow(workflow);
+    return {
+        runnerId: summary.runnerId,
+        summary,
+        workflow,
+    };
+}
+export async function listMetaWorkflows(options = {}) {
+    const page = options.page ?? 1;
+    const limit = options.limit ?? 10;
+    const data = await requestMeta(`${META_API_PREFIX}/workflow/runs`, {
+        params: {
+            page,
+            limit,
+            name: options.name ?? "",
+        },
+        configPath: options.configPath,
+        action: "查询 Meta 历史记录",
+    });
+    const view = buildHistoryListView(data, { page, limit });
+    return { data, ...view };
+}
+export async function listMetaWorkflowSteps(options) {
+    const workflow = await requestMeta(`${META_API_PREFIX}/workflow/runs/${encodeURIComponent(options.workflowId)}`, {
+        configPath: options.configPath,
+        action: "查询 Meta 历史记录步骤",
+    });
+    const headNode = (workflow.nodes ?? []).find((node) => node.id === workflow.head);
+    return {
+        runnerId: workflow.runner_id,
+        head: workflow.head,
+        headNodeType: headNode?.node_type,
+        steps: buildSwitchableSteps(workflow),
+        workflow,
+    };
+}
+export async function switchMetaWorkflow(options) {
+    const current = await getMetaWorkflow(options);
+    const workflow = current.workflow;
+    const availableSteps = buildSwitchableSteps(workflow);
+    const requestedType = options.nodeType?.trim();
+    const workflowName = typeof workflow.name === "string" ? workflow.name : undefined;
+    // 未指定 node-type：定位到历史当前节点（head），与网站历史卡片一致
+    if (!requestedType) {
+        const headNodeType = current.summary.headNodeType;
+        const guidance = headNodeType
+            ? resolveSwitchGuidance(headNodeType)
+            : resolveSwitchGuidance("");
+        const headNode = (workflow.nodes ?? []).find((node) => node.id === workflow.head);
+        const topicFields = resolveTopicSwitchFields(headNode, workflowName, guidance);
+        return {
+            ...current,
+            targetNodeType: headNodeType,
+            targetNodeId: current.summary.head,
+            availableSteps,
+            refetchCommand: guidance.refetchCommand,
+            requireSelector: guidance.requireSelector,
+            ...topicFields,
+        };
+    }
+    // 指定 node-type：可切到该步骤（含 head）
+    const node = findSwitchableNode(workflow, requestedType, {
+        includeHead: true,
+    });
+    if (!node) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `当前历史记录中没有可切换的成功步骤：${requestedType}`);
+    }
+    const guidance = resolveSwitchGuidance(node.node_type);
+    const topicFields = resolveTopicSwitchFields(node, workflowName, guidance);
+    return {
+        ...current,
+        targetNodeType: node.node_type,
+        targetNodeId: node.id,
+        availableSteps,
+        refetchCommand: guidance.refetchCommand,
+        requireSelector: guidance.requireSelector,
+        ...topicFields,
+    };
+}
+export async function runCreateMetaWorkflow(options = {}) {
+    const result = await createMetaWorkflow(options);
+    printWorkflowResult(result, options.format ?? "markdown");
+}
+export async function runGetMetaWorkflow(options) {
+    const result = await getMetaWorkflow(options);
+    printWorkflowResult(result, options.format ?? "markdown");
+}
+export async function runListMetaWorkflows(options = {}) {
+    const result = await listMetaWorkflows(options);
+    if ((options.format ?? "markdown") === "json") {
+        // 切换选项模式：只出序号选择器字段，避免与列表操作选择器同包双弹
+        if (options.switchOptions) {
+            printOutput(toHistorySwitchOptionsJsonPayload(result), "json");
+            return;
+        }
+        printOutput(toHistoryListJsonPayload(result), "json");
+        return;
+    }
+    if (options.switchOptions) {
+        // markdown 下仍给出可点选序号列表（极少使用）
+        const rows = result.switchTargets.map((target) => ({
+            index: target.index,
+            label: `序号 ${target.index}`,
+        }));
+        console.log(renderListAsMarkdown(rows, [
+            { key: "index", label: "序号" },
+            { key: "label", label: "选项" },
+        ]));
+        return;
+    }
+    console.log(result.tableMarkdown);
+}
+export async function runListMetaWorkflowSteps(options) {
+    const result = await listMetaWorkflowSteps(options);
+    if ((options.format ?? "markdown") === "json") {
+        printOutput(result, "json");
+        return;
+    }
+    console.log(renderListAsMarkdown(result.steps, [
+        ...STEP_COLUMNS,
+    ]));
+}
+export async function runSwitchMetaWorkflow(options) {
+    const result = await switchMetaWorkflow(options);
+    if ((options.format ?? "markdown") === "json") {
+        printOutput(result, "json");
+        return;
+    }
+    printWorkflowResult(result, options.format ?? "markdown");
+}
+//# sourceMappingURL=workflow.js.map