helixlife-expert-cli 0.1.0

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

@@ -0,0 +1,1248 @@
+import { dirname, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { ApiClient, createStderrProgress, helixlifeError, helixlifeErrorCode, printOutput, renderListAsMarkdown, } from "../../core/index.js";
+import { requestMeta } from "./api.js";
+import { META_API_PREFIX } from "./constants.js";
+import { getMetaNodeOutput, pollMetaNodeStatus } from "./node.js";
+const META_EXTRACTION_NODE_TYPES = {
+    FULLTEXT: "fulltext_screening",
+    QUALITY: "quality_assessment",
+    BASELINE: "baseline_information",
+    OUTCOME: "outcome_indicator_extraction",
+};
+const BASELINE_INFORMATION_COLUMNS = [
+    { key: "study", label: "Study" },
+    { key: "region", label: "Region" },
+    { key: "number_of_participants", label: "No. of participants" },
+    { key: "sex", label: "Sex" },
+    { key: "age", label: "Age" },
+    { key: "population", label: "Population" },
+    { key: "intervention_exposure", label: "Intervention / Exposure" },
+    { key: "comparator_context", label: "Comparator / Context" },
+    { key: "outcome", label: "Outcomes" },
+    { key: "study_design", label: "Study Design" },
+];
+const QUALITY_ASSESSMENT_COLUMNS = [
+    { key: "study", label: "Study" },
+    { key: "d_one", label: "D1" },
+    { key: "d_two", label: "D2" },
+    { key: "d_three", label: "D3" },
+    { key: "d_four", label: "D4" },
+    { key: "d_five", label: "D5" },
+    { key: "overall", label: "Overall" },
+];
+/** 强制按网站 10 列横向表展示基线资料，禁止删空列或重建缩略表。 */
+const BASELINE_DISPLAY_INSTRUCTION = "必须将 tableMarkdown 作为基线资料结果的唯一展示源并逐字完整输出全部 10 列和全部返回记录：" +
+    "Study | Region | No. of participants | Sex | Age | Population | Intervention / Exposure | Comparator / Context | Outcomes | Study Design。" +
+    "禁止从 data、rows、displayRows、table 或 output 重建表格；禁止删除、合并、改名或改序任何列；" +
+    "禁止因单元格为空、Not reported 或整列为空而省略 Age、Comparator / Context 等列；空列也必须保留。" +
+    "禁止用「基线资料提取成功」等摘要代替完整 tableMarkdown，禁止缩写、翻译或改成纵向 item/content 表。" +
+    " When the user chooses「编辑内容」or「选择文献重新抽提」, first single-select record(s) by Study using baselineRecordRefs (keep id internal);" +
+    " for「编辑内容」, then show editable fields with current values, then prompt once for free-text「手动输入」; never invent id from Study text alone.";
+const OUTCOME_PARENT_COLUMNS = [
+    { key: "index", label: "序号" },
+    { key: "study", label: "Study" },
+    { key: "pmid", label: "Pmid" },
+];
+const OUTCOME_DETAIL_COLUMNS = [
+    { key: "index", label: "序号" },
+    { key: "outcome_name", label: "Outcome Name" },
+    { key: "detection_time_point", label: "Detection Time Point" },
+    { key: "group_name", label: "Group Name" },
+    { key: "sample_size", label: "Sample Size" },
+    { key: "outcome_type", label: "Outcome Type" },
+    { key: "value_type_1", label: "Value Type" },
+    { key: "value_1", label: "Value" },
+    { key: "value_type_2", label: "Value Type" },
+    { key: "value_2", label: "Value" },
+    { key: "value_type_3", label: "Value Type" },
+    { key: "value_3", label: "Value" },
+];
+/** 强制按网站「结局数据」父子表展示；完整表经 artifact 落盘，避免 Shell 截断 stdout。 */
+const OUTCOME_DISPLAY_INSTRUCTION = "完整结局表已写入 artifact.output：必须先用 Read 读取该文件全文，再把全文原样贴进回复（这是唯一展示源；禁止只扫 JSON 就回复）。" +
+    "JSON 故意不内嵌超长 tableMarkdown，以免 Shell stdout 出现 [truncated] 后被改成摘要。" +
+    "结构必须与网站一致：先父表（序号 / Study / Pmid），再每个研究下各自的 Markdown 子表（首列序号 + 11 列：" +
+    "Outcome Name / Detection Time Point / Group Name / Sample Size / Outcome Type / Value Type / Value ×3）；" +
+    "g1/g2 在同一单元格内上下堆叠（
 换行实体须原样保留）。" +
+    "【交付失败·禁止只贴父表】若回复只有研究列表父表、没有各研究下含 Outcome Name 等列的子表，视为未展示结局数据，须立刻补贴 artifact 全文；" +
+    "禁止声称「完整结局数据表已展示」；禁止用 outcomeParentSelectionOptions 自行拼父表冒充完整表；" +
+    "禁止迷你表、文字汇总、单元格 ... 截断、以「太长」省略子表。" +
+    " When the user chooses「编辑内容」or「删除结局指标」: " +
+    "(1) first single-select parent Study+Pmid via outcomeParentSelectionOptions (label already includes 序号; keep ids internal); " +
+    "(2) then show ONLY that parent's detailTables sub-table (with 序号) and pop AskQuestion from outcomeChildSelectionOptions (≤10/page, add「查看下一页结局」when more; never ask for typed 序号); " +
+    "(3) for「编辑内容」, then show the full website edit form fields with current values once: " +
+    "outcome_name, detection_time_point, and for both g1 and g2 separately: group_name, sample_size, outcome_type (only g1 editable; g2 synced readonly), " +
+    "plus Value type/Value slots driven by Outcome Type — Binary→Events; Continuity→SD then Mean; Survival→HR then 95%Lower CI then 95%Upper CI; list every side's values (empty as (空)). " +
+    "Never flatten all Study—Outcome Name into one selector; never merge g1/g2 into a single summary cell; " +
+    "never always show 3 Value slots regardless of type; then prompt once for free-text「手动输入」.";
+/**
+ * 将结局 tableMarkdown 写入系统临时目录，返回 artifact 路径。
+ *
+ * @param tableMarkdown 完整结局 Markdown 表。
+ * @returns 落盘产物描述。
+ */
+async function writeOutcomeTableArtifact(tableMarkdown) {
+    const dir = join(tmpdir(), "helixlife-meta-outcome");
+    await mkdir(dir, { recursive: true });
+    const filename = "结局数据.md";
+    const outputPath = join(dir, filename);
+    const buffer = Buffer.from(tableMarkdown, "utf8");
+    await writeFile(outputPath, buffer);
+    return {
+        output: outputPath,
+        filename,
+        contentType: "text/markdown; charset=utf-8",
+        size: buffer.length,
+    };
+}
+function parseJsonObject(raw, optionName) {
+    const jsonText = raw?.replace(/^\uFEFF/, "").trim();
+    if (!jsonText) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(jsonText);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("not an object");
+        }
+        return parsed;
+    }
+    catch {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `${optionName} 须为合法 JSON 对象`);
+    }
+}
+function parseJsonStringArray(raw, optionName) {
+    const jsonText = raw?.replace(/^\uFEFF/, "").trim();
+    if (!jsonText) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(jsonText);
+        if (!Array.isArray(parsed) ||
+            parsed.some((item) => typeof item !== "string")) {
+            throw new Error("not a string array");
+        }
+        return parsed;
+    }
+    catch {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `${optionName} 须为合法 JSON 字符串数组`);
+    }
+}
+async function parseJsonObjectInput(raw, filePath, optionName, fileOptionName) {
+    if (filePath?.trim()) {
+        const content = await readFile(filePath.trim(), "utf8");
+        return parseJsonObject(content, fileOptionName);
+    }
+    if (!raw?.trim()) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `缺少 ${optionName} 或 ${fileOptionName}`);
+    }
+    return parseJsonObject(raw, optionName);
+}
+async function parseJsonStringArrayInput(raw, filePath, optionName, fileOptionName) {
+    if (filePath?.trim()) {
+        const content = await readFile(filePath.trim(), "utf8");
+        return parseJsonStringArray(content, fileOptionName);
+    }
+    if (!raw?.trim()) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `缺少 ${optionName} 或 ${fileOptionName}`);
+    }
+    return parseJsonStringArray(raw, optionName);
+}
+function extractNodeOutput(node) {
+    if (node.output &&
+        typeof node.output === "object" &&
+        "output" in node.output) {
+        return node.output.output;
+    }
+    return node.output ?? {};
+}
+/**
+ * Safely narrows an unknown API value into a record for list traversal.
+ *
+ * @param value The raw value returned by the API.
+ * @returns The value as a record, or an empty record when it is not object-like.
+ */
+function unwrapRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+/**
+ * Extracts rows from the common paginated response shapes used by Meta list APIs.
+ *
+ * @param data The raw list response.
+ * @returns The extracted list rows.
+ */
+function extractListItems(data) {
+    const root = unwrapRecord(data);
+    const nested = unwrapRecord(root.data);
+    const payload = Object.keys(nested).length > 0 ? nested : root;
+    return Array.isArray(payload.items)
+        ? payload.items
+        : Array.isArray(payload.list)
+            ? payload.list
+            : Array.isArray(payload.records)
+                ? payload.records
+                : Array.isArray(payload.results)
+                    ? payload.results
+                    : Array.isArray(payload.data)
+                        ? payload.data
+                        : Array.isArray(data)
+                            ? data
+                            : [];
+}
+/**
+ * Formats scalar and array fields for table display without dropping values.
+ *
+ * @param value The raw field value from a baseline record.
+ * @returns A readable string, joining arrays with commas.
+ */
+function formatListField(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => String(item ?? ""))
+            .filter(Boolean)
+            .join(", ");
+    }
+    return value === undefined || value === null ? "" : String(value);
+}
+/** 调用抽提结果 `/export` 接口下载产物并落盘。 */
+async function downloadExtractionExportArtifact(options) {
+    const client = new ApiClient();
+    const response = await client.requestBinary(`${META_API_PREFIX}/${options.endpoint}`, {
+        method: "GET",
+        params: {
+            run_id: options.workflowId,
+            node_id: options.nodeId,
+        },
+    });
+    if (response.buffer.length === 0) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, `${options.action}下载内容为空`);
+    }
+    const output = resolve(options.outputDirectory?.trim() || ".", options.filename);
+    await mkdir(dirname(output), { recursive: true });
+    await writeFile(output, response.buffer);
+    return {
+        output,
+        filename: options.filename,
+        contentType: response.contentType ?? "application/octet-stream",
+        size: response.buffer.length,
+    };
+}
+/**
+ * Builds the baseline information table using the same columns as the website.
+ *
+ * @param data The raw baseline information list response.
+ * @returns A table descriptor with website column labels and normalized rows.
+ */
+function buildBaselineInformationTable(data) {
+    const rows = extractListItems(data).map((item) => {
+        const record = unwrapRecord(item);
+        return {
+            study: formatListField(record.study),
+            region: formatListField(record.region),
+            number_of_participants: formatListField(record.number_of_participants),
+            sex: formatListField(record.sex),
+            age: formatListField(record.age),
+            population: formatListField(record.population),
+            intervention_exposure: formatListField(record.intervention_exposure),
+            comparator_context: formatListField(record.comparator_context),
+            outcome: formatListField(record.outcome),
+            study_design: formatListField(record.study_design),
+        };
+    });
+    return { columns: [...BASELINE_INFORMATION_COLUMNS], rows };
+}
+/**
+ * 为基线资料结果附加 tableMarkdown 等展示字段；Agent 须以 tableMarkdown 为唯一展示源。
+ *
+ * @param result 待附加表格的命令结果。
+ * @param table 规范化后的基线表（固定 10 列）。
+ * @param baselineRecordRefs 编辑/重抽用的内部定位（不对用户展示 id）。
+ * @returns 带 displayInstruction / tableMarkdown 的结果。
+ */
+function withBaselineTable(result, table, baselineRecordRefs = []) {
+    const tableMarkdown = renderListAsMarkdown(table.rows, table.columns);
+    return {
+        ...result,
+        displayInstruction: BASELINE_DISPLAY_INSTRUCTION,
+        columns: table.columns,
+        rows: table.rows,
+        displayColumns: table.columns.map((column) => column.label),
+        displayRows: table.rows,
+        tableMarkdown,
+        baselineRecordRefs,
+        table,
+    };
+}
+/**
+ * 输出基线资料结果；JSON 暴露 tableMarkdown + baselineRecordRefs（编辑定位），不暴露 rows。
+ *
+ * @param result create/list 返回的基线结果。
+ * @param format 输出格式。
+ */
+function printBaselineResult(result, format) {
+    if (format === "json") {
+        printOutput({
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            ...(result && "nodeType" in result
+                ? { nodeType: result.nodeType, status: result.status }
+                : {}),
+            displayInstruction: result.displayInstruction,
+            tableMarkdown: result.tableMarkdown,
+            baselineRecordRefs: result.baselineRecordRefs,
+        }, "json");
+        return;
+    }
+    console.log(result.tableMarkdown ?? "");
+}
+/** 基线资料编辑/重抽定位，与展示表分离。 */
+function buildBaselineRecordRefs(data) {
+    return extractListItems(data).map((item) => {
+        const record = unwrapRecord(item);
+        return {
+            id: formatListField(record.id),
+            study: formatListField(record.study),
+        };
+    });
+}
+/**
+ * 构建结局父表（序号 + Study / Pmid），序号与父级选择器对齐。
+ *
+ * @param data 结局列表原始响应。
+ * @returns 每行对应一篇研究的父表描述。
+ */
+function buildOutcomeParentTable(data) {
+    const rows = extractListItems(data).map((item, index) => {
+        const record = unwrapRecord(item);
+        return {
+            index: String(index + 1),
+            study: formatListField(record.study),
+            pmid: formatListField(record.pmid),
+        };
+    });
+    return { columns: [...OUTCOME_PARENT_COLUMNS], rows };
+}
+/**
+ * Extracts value rows from an outcome group payload without dropping any value slots.
+ *
+ * @param value The raw `g1_data` or `g2_data` value.
+ * @returns Normalized value rows.
+ */
+function extractOutcomeValueRows(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((item) => unwrapRecord(item));
+}
+/**
+ * 单元格内 g1/g2 换行：写入 HTML 数字实体 
（U+2028）。
+ * - 不能写裸 U+2028/\\n：会拆掉 Markdown 管道表
+ * - 不能写 <br> / HTML <table>：聊天端会剥掉标签（BinaryBinary 或整表空白）
+ * 实体留在 Markdown 源码中不拆表，渲染解码后浏览器在单元格内换行。
+ */
+const OUTCOME_CELL_LINE_BREAK = "&#8232;";
+/**
+ * 将 g1/g2 按网站子表样式上下堆叠到同一单元格；空侧保留 `/`。
+ * 两侧皆空时只输出单个 `/`。
+ *
+ * @param first g1 侧字段值。
+ * @param second g2 侧字段值。
+ * @returns 用换行实体连接的单元格文本（或单个 `/`）。
+ */
+function formatOutcomeGroupPair(first, second) {
+    const firstValue = formatListField(first);
+    const secondValue = formatListField(second);
+    if (!firstValue && !secondValue) {
+        return "/";
+    }
+    return `${firstValue || "/"}${OUTCOME_CELL_LINE_BREAK}${secondValue || "/"}`;
+}
+/**
+ * 按网站子表写入结局行：单元格内 g1/g2 上下堆叠；同一结局多 chunk 共用同一序号。
+ *
+ * @param rows 目标行数组。
+ * @param outcome 单条结局记录。
+ * @param childIndex 该父级下的子结局序号（1-based）。
+ */
+function pushOutcomeRows(rows, outcome, childIndex) {
+    const g1Data = extractOutcomeValueRows(outcome.g1_data);
+    const g2Data = extractOutcomeValueRows(outcome.g2_data);
+    const chunkCount = Math.max(1, Math.ceil(Math.max(g1Data.length, g2Data.length) / 3));
+    for (let chunkIndex = 0; chunkIndex < chunkCount; chunkIndex += 1) {
+        const valueCells = {};
+        for (let slot = 0; slot < 3; slot += 1) {
+            const dataIndex = chunkIndex * 3 + slot;
+            valueCells[`value_type_${slot + 1}`] = formatOutcomeGroupPair(g1Data[dataIndex]?.value_type, g2Data[dataIndex]?.value_type);
+            valueCells[`value_${slot + 1}`] = formatOutcomeGroupPair(g1Data[dataIndex]?.value, g2Data[dataIndex]?.value);
+        }
+        rows.push({
+            // 多 chunk 时仅首行展示序号，避免选择器与表行一一错位
+            index: chunkIndex === 0 ? String(childIndex) : "",
+            outcome_name: formatListField(outcome.outcome_name),
+            detection_time_point: formatListField(outcome.detection_time_point),
+            group_name: formatOutcomeGroupPair(outcome.g1_group_name, outcome.g2_group_name),
+            sample_size: formatOutcomeGroupPair(outcome.g1_sample_size, outcome.g2_sample_size),
+            outcome_type: formatOutcomeGroupPair(outcome.g1_outcome_type, outcome.g2_outcome_type),
+            ...valueCells,
+        });
+    }
+}
+/**
+ * 按父级研究拆分子表；首列序号与该父级下子选择器对齐。
+ *
+ * @param data 结局列表原始响应。
+ * @returns 按 Study/PMID 分组的子表。
+ */
+function buildOutcomeDetailTables(data) {
+    return extractListItems(data).map((item, index) => {
+        const record = unwrapRecord(item);
+        const outcomes = Array.isArray(record.outcomes) ? record.outcomes : [];
+        const rows = [];
+        outcomes.forEach((outcomeItem, outcomeIndex) => {
+            const outcome = unwrapRecord(outcomeItem);
+            pushOutcomeRows(rows, outcome, outcomeIndex + 1);
+        });
+        const study = formatListField(record.study) || `Study ${index + 1}`;
+        const pmid = formatListField(record.pmid);
+        return {
+            title: pmid ? `${study} (PMID ${pmid})` : study,
+            columns: [...OUTCOME_DETAIL_COLUMNS],
+            rows,
+            parentIndex: index + 1,
+        };
+    });
+}
+/**
+ * 构建父级 Study+Pmid 选择器选项（含序号）。
+ *
+ * @param data 结局列表原始响应。
+ * @returns AskQuestion 用父级选项。
+ */
+function buildOutcomeParentSelectionOptions(data) {
+    return extractListItems(data).map((item, index) => {
+        const record = unwrapRecord(item);
+        const study = formatListField(record.study) || "无 Study";
+        const pmid = formatListField(record.pmid);
+        const pmidText = pmid ? `PMID ${pmid}` : "无 PMID";
+        const parentIndex = index + 1;
+        return {
+            index: parentIndex,
+            // 半角括号/逗号：全角「，」在 AskQuestion 选择器中可能显示为乱码
+            label: `序号 ${parentIndex} (${study}, ${pmidText})`,
+            value: String(parentIndex),
+            study: formatListField(record.study),
+            pmid,
+        };
+    });
+}
+/**
+ * 构建子结局选择器选项；按父级序号分组，label 含子表序号。
+ *
+ * @param outcomeRecordRefs 已带 parentIndex/childIndex 的结局定位。
+ * @returns AskQuestion 用子结局选项。
+ */
+function buildOutcomeChildSelectionOptions(outcomeRecordRefs) {
+    return outcomeRecordRefs
+        .filter((ref) => ref.id.trim())
+        .map((ref) => {
+        const outcomeName = ref.outcomeName.trim() || "无 Outcome Name";
+        return {
+            index: ref.childIndex,
+            label: `序号 ${ref.childIndex} (${outcomeName})`,
+            value: ref.id,
+            parentIndex: ref.parentIndex,
+            study: ref.study,
+            pmid: ref.pmid,
+            outcomeName: ref.outcomeName,
+        };
+    });
+}
+/** 保留完整结局 id，并附带父/子序号供两级选择器定位。 */
+function buildOutcomeRecordRefs(data) {
+    return extractListItems(data).flatMap((item, parentOffset) => {
+        const parent = unwrapRecord(item);
+        const outcomes = Array.isArray(parent.outcomes) ? parent.outcomes : [];
+        const parentIndex = parentOffset + 1;
+        return outcomes.map((outcomeItem, outcomeOffset) => {
+            const outcome = unwrapRecord(outcomeItem);
+            return {
+                id: formatListField(outcome.id),
+                study: formatListField(parent.study),
+                pmid: formatListField(parent.pmid),
+                outcomeName: formatListField(outcome.outcome_name),
+                detectionTimePoint: formatListField(outcome.detection_time_point),
+                g1GroupName: formatListField(outcome.g1_group_name),
+                g2GroupName: formatListField(outcome.g2_group_name),
+                parentIndex,
+                childIndex: outcomeOffset + 1,
+            };
+        });
+    });
+}
+/**
+ * 为命令结果附加网站风格的结局父表与子表（供 WorkBuddy 原样展示）。
+ *
+ * @param result 待 enrichment 的命令结果。
+ * @param table 父表（序号 / Study / Pmid）。
+ * @param detailTables 各研究下带序号的子表。
+ * @param outcomeRecordRefs 编辑/删除用的内部定位（不对用户展示 id）。
+ * @param outcomeParentSelectionOptions 父级 Study+Pmid 选择器选项。
+ * @param outcomeChildSelectionOptions 子结局选择器选项（按 parentIndex 过滤）。
+ * @returns 带 tableMarkdown / displayInstruction 的结果。
+ */
+function withOutcomeTables(result, table, detailTables, outcomeRecordRefs = [], outcomeParentSelectionOptions = [], outcomeChildSelectionOptions = []) {
+    // 对齐网站「结局数据」：父表 + 子表均用 Markdown；单元格内换行靠 &#8232; 实体
+    const detailSections = detailTables.flatMap((detailTable, _index, all) => {
+        const section = [""];
+        if (all.length > 1) {
+            section.push(`#### ${detailTable.title}`, "");
+        }
+        section.push(renderListAsMarkdown(detailTable.rows, detailTable.columns));
+        return section;
+    });
+    const tableMarkdown = [
+        "结局数据",
+        "",
+        renderListAsMarkdown(table.rows, table.columns),
+        ...detailSections,
+    ].join("\n");
+    return {
+        ...result,
+        displayInstruction: OUTCOME_DISPLAY_INSTRUCTION,
+        columns: table.columns,
+        rows: table.rows,
+        displayColumns: table.columns.map((column) => column.label),
+        displayRows: table.rows,
+        tableMarkdown,
+        outcomeRecordRefs,
+        outcomeParentSelectionOptions,
+        outcomeChildSelectionOptions,
+        table,
+        detailTables,
+    };
+}
+function pickFields(input, allowedKeys) {
+    const picked = {};
+    for (const key of allowedKeys) {
+        if (key in input) {
+            picked[key] = input[key];
+        }
+    }
+    return picked;
+}
+function isEmptyObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.keys(value).length === 0);
+}
+function filterOutcomeDataRows(value) {
+    if (!Array.isArray(value)) {
+        return value;
+    }
+    return value.filter((item) => {
+        if (isEmptyObject(item)) {
+            return false;
+        }
+        if (!item || typeof item !== "object") {
+            return false;
+        }
+        const row = item;
+        return Boolean(row.value_type || row.value);
+    });
+}
+function buildQualityAssessmentTable(data) {
+    const rows = extractListItems(data).map((item) => {
+        const source = unwrapRecord(item);
+        return Object.fromEntries(QUALITY_ASSESSMENT_COLUMNS.map((column) => [
+            column.key,
+            formatListField(source[column.key]),
+        ]));
+    });
+    return { columns: [...QUALITY_ASSESSMENT_COLUMNS], rows };
+}
+/** 质量评估编辑用内部定位，与展示表分离。 */
+function buildQualityRecordRefs(data) {
+    return extractListItems(data).map((item) => {
+        const record = unwrapRecord(item);
+        return {
+            id: formatListField(record.id),
+            study: formatListField(record.study),
+        };
+    });
+}
+const OUTCOME_DATA_CONFIG = {
+    Binary: ["Events"],
+    Continuity: ["SD", "Mean"],
+    Survival: ["HR", "95%Lower CI", "95%Upper CI"],
+};
+/**
+ * Rebuilds outcome value slots exactly as the website edit form does.
+ *
+ * @param value Existing group values from the selected outcome record.
+ * @param outcomeType The first group's selected outcome type.
+ * @returns Fixed value slots for a known type, or filtered original rows otherwise.
+ */
+function normalizeOutcomeDataRows(value, outcomeType) {
+    const slots = OUTCOME_DATA_CONFIG[outcomeType];
+    if (!slots) {
+        return filterOutcomeDataRows(value);
+    }
+    const existing = Array.isArray(value)
+        ? value.map((item) => unwrapRecord(item))
+        : [];
+    return slots.map((valueType, index) => ({
+        value_type: valueType,
+        value: existing[index]?.value ?? "",
+    }));
+}
+function normalizeQualityInput(input) {
+    return pickFields(input, [
+        "id",
+        "study",
+        "d_one",
+        "d_two",
+        "d_three",
+        "d_four",
+        "d_five",
+        "overall",
+    ]);
+}
+function normalizeBaselineInput(input) {
+    return pickFields(input, [
+        "id",
+        "region",
+        "number_of_participants",
+        "sex",
+        "age",
+        "population",
+        "intervention_exposure",
+        "comparator_context",
+        "outcome",
+        "study",
+        "study_design",
+    ]);
+}
+function normalizeOutcomeInput(input) {
+    const normalized = pickFields(input, [
+        "id",
+        "outcome_name",
+        "detection_time_point",
+        "g1_group_name",
+        "g1_sample_size",
+        "g1_outcome_type",
+        "g1_data",
+        "g2_group_name",
+        "g2_sample_size",
+        "g2_outcome_type",
+        "g2_data",
+    ]);
+    const outcomeType = String(normalized.g1_outcome_type ?? "");
+    if (outcomeType) {
+        normalized.g2_outcome_type = outcomeType;
+    }
+    if ("g1_data" in normalized || outcomeType) {
+        normalized.g1_data = normalizeOutcomeDataRows(normalized.g1_data, outcomeType);
+    }
+    if ("g2_data" in normalized || outcomeType) {
+        normalized.g2_data = normalizeOutcomeDataRows(normalized.g2_data, outcomeType);
+    }
+    return normalized;
+}
+async function loadExtractionRecordForUpdate(options) {
+    const limit = 50;
+    for (let page = 1;; page += 1) {
+        const data = await requestMeta(`${META_API_PREFIX}/${options.endpoint}`, {
+            params: {
+                run_id: options.workflowId,
+                node_id: options.nodeId,
+                page,
+                limit,
+                scale_type: options.scaleType,
+            },
+            configPath: options.configPath,
+            action: "读取待编辑抽提记录完整数据",
+        });
+        const items = extractListItems(data);
+        for (const item of items) {
+            const record = unwrapRecord(item);
+            if (String(record.id ?? "") === options.recordId)
+                return record;
+            if (options.nestedOutcomes && Array.isArray(record.outcomes)) {
+                const outcome = record.outcomes
+                    .map((value) => unwrapRecord(value))
+                    .find((value) => String(value.id ?? "") === options.recordId);
+                if (outcome)
+                    return outcome;
+            }
+        }
+        if (items.length < limit)
+            break;
+    }
+    throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "未找到待编辑的抽提记录，已停止更新以避免覆盖丢失原字段");
+}
+async function getWorkflow(workflowId, configPath) {
+    return requestMeta(`${META_API_PREFIX}/workflow/runs/${encodeURIComponent(workflowId)}`, {
+        configPath,
+        action: "查询 Meta 工作流",
+    });
+}
+function findLatestNode(workflow, nodeType) {
+    return [...(workflow.nodes ?? [])]
+        .reverse()
+        .find((node) => node.node_type === nodeType);
+}
+async function resolveNodeId(options) {
+    if (options.nodeId?.trim()) {
+        return options.nodeId.trim();
+    }
+    const workflow = await getWorkflow(options.workflowId, options.configPath);
+    const node = findLatestNode(workflow, options.nodeType);
+    if (!node) {
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, `当前工作流中未找到 ${options.label} 节点`);
+    }
+    return node.id;
+}
+async function runExtractionExecute(options) {
+    const progress = createStderrProgress(options.format === "json");
+    progress.start(options.progressMessage);
+    try {
+        const created = await requestMeta(`${META_API_PREFIX}/${options.endpoint}`, {
+            method: "POST",
+            params: {
+                run_id: options.workflowId,
+                ...options.params,
+            },
+            configPath: options.configPath,
+            action: options.progressMessage,
+        });
+        if (!created.node_id) {
+            throw new helixlifeError(helixlifeErrorCode.INVALID_RESPONSE, `${options.progressMessage}响应缺少 node_id`);
+        }
+        await pollMetaNodeStatus({
+            workflowId: options.workflowId,
+            nodeId: created.node_id,
+            configPath: options.configPath,
+        });
+        const output = await getMetaNodeOutput({
+            workflowId: options.workflowId,
+            nodeId: created.node_id,
+            configPath: options.configPath,
+        });
+        progress.finish("Meta 节点执行完成，正在输出结果...");
+        return {
+            runnerId: options.workflowId,
+            nodeId: created.node_id,
+            nodeType: options.nodeType,
+            status: output.data.status,
+            input: options.input,
+            output: extractNodeOutput(output.data),
+            node: output.data,
+        };
+    }
+    catch (error) {
+        progress.dispose();
+        throw error;
+    }
+}
+function printStepResult(result, format) {
+    if (format === "json") {
+        printOutput(result, "json");
+        return;
+    }
+    if (result.table) {
+        console.log(renderListAsMarkdown(result.table.rows, result.table.columns));
+        for (const detailTable of result.detailTables ?? []) {
+            console.log(`\n${detailTable.title}`);
+            console.log(renderListAsMarkdown(detailTable.rows, detailTable.columns));
+        }
+        return;
+    }
+    console.log(renderListAsMarkdown([
+        {
+            runnerId: result.runnerId,
+            nodeType: result.nodeType,
+            status: result.status,
+        },
+    ], [
+        { key: "runnerId", label: "runnerId" },
+        { key: "nodeType", label: "节点类型" },
+        { key: "status", label: "状态" },
+    ]));
+    console.log("\n输出：");
+    console.log(JSON.stringify(result.output, null, 2));
+}
+/**
+ * 进入数据抽提前校验全文复筛（对齐网站复筛结果「下一步」的 check-before-next）。
+ * Include 不足等业务错误会直接抛出，阻止创建质量评估节点。
+ */
+async function verifyFulltextBeforeExtraction(options) {
+    const fulltextNodeId = options.fulltextNodeId?.trim() ??
+        (await resolveNodeId({
+            workflowId: options.workflowId,
+            nodeType: META_EXTRACTION_NODE_TYPES.FULLTEXT,
+            label: "全文复筛",
+            configPath: options.configPath,
+        }));
+    await requestMeta(`${META_API_PREFIX}/fulltext-screening/check-before-next`, {
+        params: {
+            run_id: options.workflowId,
+            node_id: fulltextNodeId,
+        },
+        configPath: options.configPath,
+        action: "校验全文复筛",
+    });
+    return fulltextNodeId;
+}
+export async function createQuality(options) {
+    const scaleType = options.scaleType ?? "rob2";
+    // 与网站 screening.tsx onNextStep(case 1) 一致：先 check，再进数据抽提。
+    const fulltextNodeId = await verifyFulltextBeforeExtraction(options);
+    return runExtractionExecute({
+        workflowId: options.workflowId,
+        nodeType: META_EXTRACTION_NODE_TYPES.QUALITY,
+        endpoint: "quality-assessment/execute",
+        params: { scale_type: scaleType, fulltext_node_id: fulltextNodeId },
+        input: { scale_type: scaleType, fulltext_node_id: fulltextNodeId },
+        progressMessage: "正在生成质量评估...",
+        format: options.format,
+        configPath: options.configPath,
+    });
+}
+export async function listQuality(options) {
+    const scaleType = options.scaleType ?? "rob2";
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_EXTRACTION_NODE_TYPES.QUALITY,
+        label: "质量评估",
+        configPath: options.configPath,
+    });
+    const data = await requestMeta(`${META_API_PREFIX}/quality-assessment`, {
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+            page: options.page ?? 1,
+            limit: options.limit ?? 10,
+            scale_type: scaleType,
+        },
+        configPath: options.configPath,
+        action: "查询质量评估结果",
+    });
+    const table = buildQualityAssessmentTable(data);
+    const tableMarkdown = renderListAsMarkdown(table.rows, table.columns);
+    return {
+        runnerId: options.workflowId,
+        nodeId,
+        data,
+        displayInstruction: "Render the quality assessment result using columns and rows/displayRows as a table. Render every returned row as an actual table row; when 10 rows are returned, all 10 must be visibly rendered. Never collapse or replace rows with '[and N more...]', ellipses, placeholders, summaries, or expandable content. Preserve the defined column order and every field value. " +
+            "When the user chooses「编辑内容」, first single-select a record by Study using qualityRecordRefs (keep id internal), then show editable fields with current values, then prompt once for free-text「手动输入」; never offer dimension pickers or suggested values like Low/Some concerns/High.",
+        columns: table.columns,
+        rows: table.rows,
+        displayColumns: table.columns.map((column) => column.label),
+        displayRows: table.rows,
+        tableMarkdown,
+        table,
+        qualityRecordRefs: buildQualityRecordRefs(data),
+    };
+}
+export async function updateQuality(options) {
+    const scaleType = options.scaleType ?? "rob2";
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_EXTRACTION_NODE_TYPES.QUALITY,
+        label: "质量评估",
+        configPath: options.configPath,
+    });
+    const patch = await parseJsonObjectInput(options.dataJson, options.dataFile, "--data-json", "--data-file");
+    const recordId = String(patch.id ?? "").trim();
+    if (!recordId)
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "编辑质量评估必须提供 id");
+    const original = await loadExtractionRecordForUpdate({
+        workflowId: options.workflowId,
+        nodeId,
+        endpoint: "quality-assessment",
+        recordId,
+        scaleType,
+        configPath: options.configPath,
+    });
+    const input = normalizeQualityInput({ ...original, ...patch });
+    const data = await requestMeta(`${META_API_PREFIX}/quality-assessment`, {
+        method: "PUT",
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+            scale_type: scaleType,
+        },
+        body: input,
+        configPath: options.configPath,
+        action: "更新质量评估",
+    });
+    return { runnerId: options.workflowId, nodeId, input, data };
+}
+export async function rerunQuality(options) {
+    const scaleType = options.scaleType ?? "rob2";
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_EXTRACTION_NODE_TYPES.QUALITY,
+        label: "质量评估",
+        configPath: options.configPath,
+    });
+    const ids = await parseJsonStringArrayInput(options.idsJson, options.idsFile, "--ids-json", "--ids-file");
+    const input = { output_ids: ids };
+    const data = await requestMeta(`${META_API_PREFIX}/quality-assessment/re-execute-on-selected`, {
+        method: "POST",
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+            scale_type: scaleType,
+        },
+        body: input,
+        configPath: options.configPath,
+        action: "重新质量评估",
+    });
+    await pollMetaNodeStatus({
+        workflowId: options.workflowId,
+        nodeId,
+        configPath: options.configPath,
+    });
+    return { runnerId: options.workflowId, nodeId, input, data };
+}
+export async function verifyQuality(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_EXTRACTION_NODE_TYPES.QUALITY,
+        label: "质量评估",
+        configPath: options.configPath,
+    });
+    const data = await requestMeta(`${META_API_PREFIX}/quality-assessment/verify-for-plot`, {
+        params: { run_id: options.workflowId, node_id: nodeId },
+        configPath: options.configPath,
+        action: "校验质量评估绘图数据",
+    });
+    return { runnerId: options.workflowId, nodeId, data };
+}
+export async function createBaseline(options) {
+    const fulltextNodeId = options.fulltextNodeId?.trim() ??
+        (await resolveNodeId({
+            workflowId: options.workflowId,
+            nodeType: META_EXTRACTION_NODE_TYPES.FULLTEXT,
+            label: "全文复筛",
+            configPath: options.configPath,
+        }));
+    const result = await runExtractionExecute({
+        workflowId: options.workflowId,
+        nodeType: META_EXTRACTION_NODE_TYPES.BASELINE,
+        endpoint: "baseline-information/execute",
+        params: { fulltext_node_id: fulltextNodeId },
+        input: { fulltext_node_id: fulltextNodeId },
+        progressMessage: "正在生成基线资料...",
+        format: options.format,
+        configPath: options.configPath,
+    });
+    const listResult = await listBaseline({
+        workflowId: options.workflowId,
+        nodeId: result.nodeId,
+        page: 1,
+        limit: 10,
+        configPath: options.configPath,
+    });
+    return withBaselineTable(result, listResult.table ?? {
+        columns: [...BASELINE_INFORMATION_COLUMNS],
+        rows: [],
+    }, listResult.baselineRecordRefs ?? []);
+}
+export async function listBaseline(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_EXTRACTION_NODE_TYPES.BASELINE,
+        label: "基线资料",
+        configPath: options.configPath,
+    });
+    const data = await requestMeta(`${META_API_PREFIX}/baseline-information`, {
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+            page: options.page,
+            limit: options.limit,
+        },
+        configPath: options.configPath,
+        action: "查询基线资料列表",
+    });
+    return withBaselineTable({ runnerId: options.workflowId, nodeId, data }, buildBaselineInformationTable(data), buildBaselineRecordRefs(data));
+}
+export async function updateBaseline(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_EXTRACTION_NODE_TYPES.BASELINE,
+        label: "基线资料",
+        configPath: options.configPath,
+    });
+    const patch = await parseJsonObjectInput(options.dataJson, options.dataFile, "--data-json", "--data-file");
+    const recordId = String(patch.id ?? "").trim();
+    if (!recordId)
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "编辑基线资料必须提供 id");
+    const original = await loadExtractionRecordForUpdate({
+        workflowId: options.workflowId,
+        nodeId,
+        endpoint: "baseline-information",
+        recordId,
+        configPath: options.configPath,
+    });
+    const input = normalizeBaselineInput({ ...original, ...patch });
+    const data = await requestMeta(`${META_API_PREFIX}/baseline-information`, {
+        method: "PUT",
+        params: { run_id: options.workflowId, node_id: nodeId },
+        body: input,
+        configPath: options.configPath,
+        action: "更新基线资料",
+    });
+    return { runnerId: options.workflowId, nodeId, input, data };
+}
+export async function rerunBaseline(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_EXTRACTION_NODE_TYPES.BASELINE,
+        label: "基线资料",
+        configPath: options.configPath,
+    });
+    const ids = await parseJsonStringArrayInput(options.idsJson, options.idsFile, "--ids-json", "--ids-file");
+    const input = { output_ids: ids };
+    const data = await requestMeta(`${META_API_PREFIX}/baseline-information/re-execute-on-selected`, {
+        method: "POST",
+        params: { run_id: options.workflowId, node_id: nodeId },
+        body: input,
+        configPath: options.configPath,
+        action: "重新抽提基线资料",
+    });
+    await pollMetaNodeStatus({
+        workflowId: options.workflowId,
+        nodeId,
+        configPath: options.configPath,
+    });
+    return { runnerId: options.workflowId, nodeId, input, data };
+}
+export async function createOutcome(options) {
+    const fulltextNodeId = options.fulltextNodeId?.trim() ??
+        (await resolveNodeId({
+            workflowId: options.workflowId,
+            nodeType: META_EXTRACTION_NODE_TYPES.FULLTEXT,
+            label: "全文复筛",
+            configPath: options.configPath,
+        }));
+    const result = await runExtractionExecute({
+        workflowId: options.workflowId,
+        nodeType: META_EXTRACTION_NODE_TYPES.OUTCOME,
+        endpoint: "outcome-indicator-extraction/execute",
+        params: { fulltext_node_id: fulltextNodeId },
+        input: { fulltext_node_id: fulltextNodeId },
+        progressMessage: "正在生成结局指标...",
+        format: options.format,
+        configPath: options.configPath,
+    });
+    const listResult = await listOutcome({
+        workflowId: options.workflowId,
+        nodeId: result.nodeId,
+        page: 1,
+        limit: 10,
+        configPath: options.configPath,
+    });
+    return withOutcomeTables(result, listResult.table ?? { columns: [...OUTCOME_PARENT_COLUMNS], rows: [] }, listResult.detailTables ?? [], listResult.outcomeRecordRefs, listResult.outcomeParentSelectionOptions, listResult.outcomeChildSelectionOptions);
+}
+export async function listOutcome(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_EXTRACTION_NODE_TYPES.OUTCOME,
+        label: "结局指标",
+        configPath: options.configPath,
+    });
+    const data = await requestMeta(`${META_API_PREFIX}/outcome-indicator-extraction`, {
+        params: {
+            run_id: options.workflowId,
+            node_id: nodeId,
+            page: options.page ?? 1,
+            limit: options.limit ?? 10,
+        },
+        configPath: options.configPath,
+        action: "查询结局指标",
+    });
+    const outcomeRecordRefs = buildOutcomeRecordRefs(data);
+    return withOutcomeTables({ runnerId: options.workflowId, nodeId, data }, buildOutcomeParentTable(data), buildOutcomeDetailTables(data), outcomeRecordRefs, buildOutcomeParentSelectionOptions(data), buildOutcomeChildSelectionOptions(outcomeRecordRefs));
+}
+/**
+ * 输出结局指标结果：JSON 只返回 artifact 路径（完整表落盘），避免 Shell 截断超长 stdout。
+ *
+ * @param result 结局 create/list 结果。
+ * @param format 输出格式。
+ */
+async function printOutcomeResult(result, format) {
+    const tableMarkdown = result.tableMarkdown ?? "";
+    if (format === "json") {
+        const artifact = await writeOutcomeTableArtifact(tableMarkdown);
+        // artifact 置前；故意不内嵌 tableMarkdown，防止宿主 Shell 截断后 Agent 改摘要
+        printOutput({
+            displayInstruction: result.displayInstruction ?? OUTCOME_DISPLAY_INSTRUCTION,
+            // 自检：回复必须同时含父表 + 全部研究子表；仅父表 = 交付失败
+            displayRequires: [
+                "Read artifact.output 全文",
+                "原样粘贴父表（序号/Study/Pmid）",
+                "原样粘贴每个研究下的子表（含 Outcome Name 等 11 列）",
+            ],
+            artifact,
+            outcomeRecordRefs: result.outcomeRecordRefs,
+            outcomeParentSelectionOptions: result.outcomeParentSelectionOptions,
+            outcomeChildSelectionOptions: result.outcomeChildSelectionOptions,
+            // 子表结构化数据：编辑时按 parentIndex 取单表展示（含序号）；列表展示仍以 artifact 为准
+            detailTables: result.detailTables,
+            runnerId: result.runnerId,
+            nodeId: result.nodeId,
+            ...(result && "nodeType" in result ? { nodeType: result.nodeType, status: result.status } : {}),
+        }, "json");
+        return;
+    }
+    console.log(tableMarkdown);
+}
+/** 下载质量评估/结局指标最终产物。 */
+export async function exportFinalExtractionMarkdownArtifacts(options) {
+    const qualityNodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeType: META_EXTRACTION_NODE_TYPES.QUALITY,
+        label: "质量评估",
+        configPath: options.configPath,
+    });
+    const outcomeNodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeType: META_EXTRACTION_NODE_TYPES.OUTCOME,
+        label: "结局指标",
+        configPath: options.configPath,
+    });
+    return Promise.all([
+        downloadExtractionExportArtifact({
+            workflowId: options.workflowId,
+            nodeId: qualityNodeId,
+            endpoint: "quality-assessment/plot-data/export",
+            filename: "质量评估.xlsx",
+            action: "下载质量评估结果",
+            outputDirectory: options.output,
+        }),
+        downloadExtractionExportArtifact({
+            workflowId: options.workflowId,
+            nodeId: outcomeNodeId,
+            endpoint: "outcome-indicator-extraction/plot-data/export",
+            filename: "结局指标.xlsx",
+            action: "下载结局指标结果",
+            outputDirectory: options.output,
+        }),
+    ]);
+}
+export async function updateOutcome(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_EXTRACTION_NODE_TYPES.OUTCOME,
+        label: "结局指标",
+        configPath: options.configPath,
+    });
+    const patch = await parseJsonObjectInput(options.dataJson, options.dataFile, "--data-json", "--data-file");
+    const recordId = String(patch.id ?? "").trim();
+    if (!recordId)
+        throw new helixlifeError(helixlifeErrorCode.INVALID_ARGUMENT, "编辑结局指标必须提供 id");
+    const original = await loadExtractionRecordForUpdate({
+        workflowId: options.workflowId,
+        nodeId,
+        endpoint: "outcome-indicator-extraction",
+        recordId,
+        nestedOutcomes: true,
+        configPath: options.configPath,
+    });
+    const input = normalizeOutcomeInput({ ...original, ...patch });
+    const data = await requestMeta(`${META_API_PREFIX}/outcome-indicator-extraction`, {
+        method: "PUT",
+        params: { run_id: options.workflowId, node_id: nodeId },
+        body: input,
+        configPath: options.configPath,
+        action: "更新结局指标",
+    });
+    return { runnerId: options.workflowId, nodeId, input, data };
+}
+export async function deleteOutcome(options) {
+    const data = await requestMeta(`${META_API_PREFIX}/outcome-indicator-extraction/${encodeURIComponent(options.outcomeId)}`, {
+        method: "DELETE",
+        configPath: options.configPath,
+        action: "删除结局指标",
+    });
+    return { runnerId: options.workflowId, data };
+}
+export async function verifyOutcome(options) {
+    const nodeId = await resolveNodeId({
+        workflowId: options.workflowId,
+        nodeId: options.nodeId,
+        nodeType: META_EXTRACTION_NODE_TYPES.OUTCOME,
+        label: "结局指标",
+        configPath: options.configPath,
+    });
+    const data = await requestMeta(`${META_API_PREFIX}/outcome-indicator-extraction/verify-for-plot`, {
+        params: { run_id: options.workflowId, node_id: nodeId },
+        configPath: options.configPath,
+        action: "校验结局指标绘图数据",
+    });
+    return { runnerId: options.workflowId, nodeId, data };
+}
+export async function runCreateQuality(options) {
+    printStepResult(await createQuality(options), options.format ?? "markdown");
+}
+export async function runListQuality(options) {
+    const result = await listQuality(options);
+    if ((options.format ?? "markdown") !== "json" && result.table) {
+        console.log(renderListAsMarkdown(result.table.rows, result.table.columns));
+        return;
+    }
+    printOutput(result, options.format ?? "markdown");
+}
+export async function runUpdateQuality(options) {
+    printOutput(await updateQuality(options), options.format ?? "markdown");
+}
+export async function runRerunQuality(options) {
+    printOutput(await rerunQuality(options), options.format ?? "markdown");
+}
+export async function runVerifyQuality(options) {
+    printOutput(await verifyQuality(options), options.format ?? "markdown");
+}
+export async function runCreateBaseline(options) {
+    printBaselineResult(await createBaseline(options), options.format ?? "markdown");
+}
+export async function runListBaseline(options) {
+    printBaselineResult(await listBaseline(options), options.format ?? "markdown");
+}
+export async function runUpdateBaseline(options) {
+    printOutput(await updateBaseline(options), options.format ?? "markdown");
+}
+export async function runRerunBaseline(options) {
+    printOutput(await rerunBaseline(options), options.format ?? "markdown");
+}
+export async function runCreateOutcome(options) {
+    await printOutcomeResult(await createOutcome(options), options.format ?? "markdown");
+}
+export async function runListOutcome(options) {
+    await printOutcomeResult(await listOutcome(options), options.format ?? "markdown");
+}
+export async function runUpdateOutcome(options) {
+    printOutput(await updateOutcome(options), options.format ?? "markdown");
+}
+export async function runDeleteOutcome(options) {
+    printOutput(await deleteOutcome(options), options.format ?? "markdown");
+}
+export async function runVerifyOutcome(options) {
+    printOutput(await verifyOutcome(options), options.format ?? "markdown");
+}
+//# sourceMappingURL=extraction.js.map