niceeval 0.13.1 → 0.13.2

package/dist/runner/feedback/human.cjs

@@ -47,8 +47,7 @@ function panelCapabilityForFeedback(io) {
 const HUMAN_FAILURE_CAP = 10;
 /** live 面板 FAILURES 分节滚动保留的条数(见 cli.md「运行中的 live 面板」)。 */
 const LIVE_FAILURES_VISIBLE = 5;
-/** 结束反馈 FAILURES 面板按失败形态聚合后,展开的组数上限;超出收进
- *  `+K more kinds — niceeval view` 尾行(见 cli.md「人看的结束反馈」)。 */
+/** 结束反馈中断言失败形态的展开上限；execution error 必须逐条保留自己的 message，不受此上限折叠。 */
 const FAILURE_GROUPS_CAP = 10;
 /** 非 TTY / `--json` 没有可依赖的终端宽度,失败单行投影用固定预算(见
  *  docs/feature/assertions/library/display.md「一条摘要怎样排版」)。 */
@@ -58,6 +57,144 @@ const NON_TTY_HEARTBEAT_IDLE_MS = 30000;
 /** dashboard 高度预留:避免最后一行触发终端自动滚动(与 live.ts 旧实现的 `rows - 2` 同一动机,
  *  这里只需要给「下一帧」留出一行余地,不需要额外的表头/尾行预留)。 */
 const DASHBOARD_ROW_RESERVE = 1;
+const HUMAN_RESULTS_EXPERIMENT_CAP = 5;
+const HUMAN_ERROR_TEXT_MAX_BYTES = 240;
+function freshHumanResult(result) {
+    const score = result.scoreResult;
+    const scoreState = score === undefined
+        ? undefined
+        : score.status === "scored"
+            ? "complete"
+            : score.earnedScore > 0
+                ? "partial"
+                : "unavailable";
+    return {
+        experimentId: result.experimentId ?? "default",
+        evalId: result.id,
+        evaluationKind: result.evaluationKind,
+        verdict: result.verdict,
+        ...(scoreState === undefined || score === undefined ? {} : { scoreState, earned: score.earnedScore }),
+    };
+}
+function reusedHumanResult(result) {
+    const attachment = result.score.state === "applicable" && result.score.attachment.state === "available"
+        ? result.score.attachment.value
+        : undefined;
+    return {
+        experimentId: result.target.experimentId,
+        evalId: result.target.evalId,
+        evaluationKind: result.source.evaluationKind,
+        verdict: result.verdict,
+        ...(attachment === undefined
+            ? {}
+            : {
+                scoreState: attachment.state,
+                ...(attachment.earned === undefined ? {} : { earned: attachment.earned }),
+            }),
+    };
+}
+function humanResultItems(summary) {
+    return [
+        ...summary.results.map(freshHumanResult),
+        ...summary.reusedAttempts.map(reusedHumanResult),
+    ];
+}
+function buildResultsPanelRows(items) {
+    const byExperiment = new Map();
+    for (const item of items) {
+        const group = byExperiment.get(item.experimentId);
+        if (group)
+            group.push(item);
+        else
+            byExperiment.set(item.experimentId, [item]);
+    }
+    const groups = [...byExperiment.entries()];
+    const rows = [];
+    for (const [experimentId, members] of groups.slice(0, HUMAN_RESULTS_EXPERIMENT_CAP)) {
+        rows.push({ kind: "line", text: experimentId });
+        const byEval = new Map();
+        for (const member of members) {
+            const evalGroup = byEval.get(member.evalId);
+            if (evalGroup)
+                evalGroup.push(member);
+            else
+                byEval.set(member.evalId, [member]);
+        }
+        for (const [evalId, attempts] of byEval) {
+            if (attempts.some((attempt) => attempt.evaluationKind === "score")) {
+                const complete = attempts.filter((attempt) => attempt.scoreState === "complete" && attempt.earned !== undefined);
+                const partial = attempts.filter((attempt) => attempt.scoreState === "partial" && attempt.earned !== undefined);
+                const reading = complete.length > 0
+                    ? `${complete.reduce((sum, attempt) => sum + attempt.earned, 0) / complete.length} score · ${complete.length}/${attempts.length} complete`
+                    : partial.length > 0
+                        ? `≥${partial.map((attempt) => attempt.earned).join(", ≥")} score · partial`
+                        : "score unavailable";
+                rows.push({ kind: "line", text: `  ${evalId}  ${reading}` });
+            }
+            else {
+                const passed = attempts.filter((attempt) => attempt.verdict === "passed").length;
+                rows.push({ kind: "line", text: `  ${evalId}  ${passed}/${attempts.length} passed` });
+            }
+        }
+    }
+    if (groups.length > HUMAN_RESULTS_EXPERIMENT_CAP) {
+        rows.push({
+            kind: "line",
+            text: (0, index_ts_1.t)("feedback.human.resultsMore", { count: groups.length - HUMAN_RESULTS_EXPERIMENT_CAP }),
+        });
+    }
+    return rows;
+}
+function buildPreAttemptErrorRows(results, runIdsByExperiment, panel) {
+    const errored = results.filter((result) => result.verdict === "errored" && result.locator === undefined && result.error !== undefined);
+    if (errored.length === 0)
+        return undefined;
+    const groups = new Map();
+    for (const result of errored) {
+        const error = result.error;
+        const runId = result.experimentId === undefined
+            ? undefined
+            : runIdsByExperiment.get(result.experimentId);
+        // Run timing node IDs are local identities. The same `n1` in another Run
+        // names a different physical failure and must not absorb its message.
+        const failureId = error.origin.scope === "run"
+            ? `${runId ?? result.experimentId ?? "default"}\u0000${error.origin.timingNodeId}`
+            : `${result.experimentId ?? "default"}\u0000${error.code}:${error.message}`;
+        const members = groups.get(failureId);
+        if (members)
+            members.push(result);
+        else
+            groups.set(failureId, [result]);
+    }
+    const rows = [];
+    const contentWidth = (0, panel_ts_1.panelContentWidth)(panel.width, panel.mode);
+    for (const members of groups.values()) {
+        const representative = members[0];
+        const error = representative.error;
+        rows.push({
+            kind: "line",
+            text: `${FAILURE_SYMBOL} ${representative.experimentId ?? "default"} · ${preAttemptErrorTitle(error.origin)}`,
+        });
+        rows.push({
+            kind: "line",
+            text: `  affected: ${members.map((member) => `${member.experimentId ?? "default"}/${member.id}`).join(", ")}`,
+        });
+        rows.push(...labelledWrappedRows("error", boundedHumanError(error.message), contentWidth));
+    }
+    return { rows, slots: errored.length };
+}
+function preAttemptErrorTitle(origin) {
+    if (origin.scope === "run")
+        return "Sandbox image build failed";
+    const phase = origin.phase;
+    switch (phase) {
+        case "judge.precheck": return "Judge precheck failed";
+        case "experiment.setup": return "Experiment setup failed";
+        case "sandbox.queue": return "Sandbox queue failed";
+        case "sandbox.create": return "Sandbox provisioning failed";
+        default: return `${phaseLabel(phase)} failed`;
+    }
+}
 /** 按 `io.stderr.isTTY` 派发:构造时选一次,运行期不再切换。 */
 function createHumanRenderer(options) {
     const { io, command } = options;
@@ -181,7 +318,7 @@ function renderDurableLines(event, state, panel) {
         case "summary":
             return buildSummaryLines(event, state, panel);
         case "receipt":
-            return buildReceiptLines(event, panel);
+            return buildReceiptLines(event, state, panel);
         default: {
             // 穷尽性检查:新增 DurableFeedbackEvent 变体时这里编译期报错提醒补上对应分支。
             const exhaustive = event;
@@ -257,20 +394,9 @@ function buildFailureFactLine(failure, maxWidth) {
     const budget = Math.max(0, maxWidth - (0, text_layout_ts_1.stringWidth)(prefix));
     const info = failure.fact
         ? (0, display_ts_1.fitCompactAssertionSummary)(failure.fact, budget)
-        : buildErroredInfo(failure.phase, failure.code, failure.reason);
+        : `error: ${boundedHumanError(failure.reason)}`;
     return prefix + clipDisplayWidth(info, budget);
 }
-/**
- * errored 且没有主 Fact 摘要（真正的结构化执行错误）时的信息段:
- * `errored · <phase> · <code>`,余量够再接 `: <message>`。`phase`/`code` 用未翻译的原始字面量
- * (`LifecyclePhase` 枚举值 / `AttemptError.code`),不走 `phaseLabel()` 的人读短语 —— 这一段
- * 是给读者对照 `--json` `error` 事件、`result.json` 与 `show` 里同一个字面量用的,不是散文。
- */
-function buildErroredInfo(phase, code, reason) {
-    const parts = ["errored", ...(phase ? [phase] : []), ...(code ? [code] : [])];
-    const base = parts.join(" · ");
-    return reason ? `${base}: ${reason}` : base;
-}
 /** 按显示列硬夹紧,超宽尾部截断补 `…`。`fitCompactAssertionSummary` 的截断口径是字符数,不是
  *  显示列(见该函数注释「显示宽度的精确裁剪仍归渲染面」);这里补上那道显示宽度的硬夹紧,
  *  堵住 CJK 内容"按字符数收口仍超显示列"的缝,保证渲染行恒不超过预算。 */
@@ -299,6 +425,11 @@ function buildDiagnosticLines(event, state) {
     // 跨用例撞上同一类状况时,读者需要的是「这类事发生了 N 次」,不是 N 段几乎相同的文字;
     // 逐 code 的次数与首条 message 由结束反馈的 WARNINGS / RECOVERY 面板汇总。
     const code = event.code ?? event.key;
+    // Judge precheck already has a live lifecycle row and a terminal pre-Attempt
+    // error block. Repeating its machine code in Human output adds no fact and
+    // exposes machine vocabulary in the default profile.
+    if (code === "judge-precheck-failed")
+        return [];
     const firstForCode = state.diagnostics.find((d) => (d.code ?? d.key) === code);
     const count = state.diagnostics.find((d) => d.key === event.key)?.count ?? 1;
     if (count > 1 || firstForCode?.key !== event.key)
@@ -327,36 +458,76 @@ function buildDiagnosticLines(event, state) {
 function buildSummaryLines(event, state, panel) {
     const { summary, completion } = event;
     const fullReuse = state.total > 0 && state.total === state.reused;
+    const resultItems = humanResultItems(summary);
+    const hasScore = resultItems.some((item) => item.evaluationKind === "score");
+    const hasPass = resultItems.some((item) => item.evaluationKind === "pass");
+    const scored = resultItems.filter((item) => item.evaluationKind === "score" && item.scoreState === "complete").length;
     // required reporter(显式 --junit)写失败必须让这行判红——它不是
     // CompletionStatus 的第四个值(那个枚举只有 complete/incomplete/interrupted 三态),但必须
     // 避免人看到一句会被误读成"全绿"的 PASSED、进程却以非零退出。
     const verdictWord = completion.status === "interrupted"
         ? (0, index_ts_1.t)("feedback.human.resultInterrupted")
-        : completion.status === "incomplete"
-            ? (0, index_ts_1.t)("feedback.human.resultIncomplete")
-            : summary.failed > 0 || summary.errored > 0 || completion.reporterErrors.some((e) => e.required)
-                ? (0, index_ts_1.t)("feedback.human.resultFailed")
-                : (0, index_ts_1.t)("feedback.human.resultPassed");
+        : summary.errored > 0
+            ? (0, index_ts_1.t)("feedback.human.resultErrored")
+            : completion.status === "incomplete"
+                ? (0, index_ts_1.t)("feedback.human.resultIncomplete")
+                : completion.reporterErrors.some((e) => e.required)
+                    ? (0, index_ts_1.t)("feedback.human.resultFailed")
+                    : hasScore && !hasPass
+                        ? (0, index_ts_1.t)("feedback.human.resultScored")
+                        : hasScore && hasPass
+                            ? summary.failed > 0
+                                ? (0, index_ts_1.t)("feedback.human.resultFailed")
+                                : (0, index_ts_1.t)("feedback.human.resultCompleted")
+                            : summary.failed > 0
+                                ? (0, index_ts_1.t)("feedback.human.resultFailed")
+                                : (0, index_ts_1.t)("feedback.human.resultPassed");
     const summaryRows = [
         {
             kind: "line",
-            text: (0, index_ts_1.t)(completion.unstarted > 0
-                ? "feedback.human.summaryIncompleteLine"
-                : fullReuse
-                    ? "feedback.human.summaryAllReusedLine"
-                    : "feedback.human.summaryLine", {
-                passed: summary.passed,
-                failed: summary.failed,
-                errored: summary.errored,
-                unstarted: completion.unstarted,
-                reused: state.reused,
-            }),
+            text: hasScore && !hasPass
+                ? (0, index_ts_1.t)("feedback.human.scoreSummaryLine", {
+                    scored,
+                    skipped: summary.skipped,
+                    errored: summary.errored,
+                    reused: state.reused,
+                })
+                : (0, index_ts_1.t)(completion.unstarted > 0
+                    ? "feedback.human.summaryIncompleteLine"
+                    : fullReuse
+                        ? "feedback.human.summaryAllReusedLine"
+                        : "feedback.human.summaryLine", {
+                    passed: summary.passed,
+                    failed: summary.failed,
+                    errored: summary.errored,
+                    unstarted: completion.unstarted,
+                    reused: state.reused,
+                }),
         },
         { kind: "line", text: formatSummaryCostLine(state) },
     ];
     const blocks = [
         (0, panel_ts_1.renderPanel)({ title: verdictWord, meta: formatElapsed(summary.durationMs), rows: summaryRows, width: panel.width, mode: panel.mode }),
     ];
+    if (resultItems.length > 0) {
+        blocks.push((0, panel_ts_1.renderPanel)({
+            title: (0, index_ts_1.t)("feedback.human.resultsHeader"),
+            meta: `${new Set(resultItems.map((item) => item.experimentId)).size} configs`,
+            rows: buildResultsPanelRows(resultItems),
+            width: panel.width,
+            mode: panel.mode,
+        }));
+    }
+    const preAttemptErrors = buildPreAttemptErrorRows(summary.results, state.runIdsByExperiment, panel);
+    if (preAttemptErrors !== undefined) {
+        blocks.push((0, panel_ts_1.renderPanel)({
+            title: (0, index_ts_1.t)("feedback.human.errorsHeader"),
+            meta: `${preAttemptErrors.slots} attempt${preAttemptErrors.slots === 1 ? "" : "s"} not started`,
+            rows: preAttemptErrors.rows,
+            width: panel.width,
+            mode: panel.mode,
+        }));
+    }
     // 全通过时(state.failures 为空)不留空 FAILURES 面板。fresh 失败来自 durable event，carry
     // 失败由 plan 静态注入；reducer 把两者按 locator 收进同一清单，这里不从 InvocationSummary 再造 ——
     // 整套结果集(含携入)都要出现在这里,不只是本次派发的那部分(见 cli.md「计数口径…」)。
@@ -390,7 +561,10 @@ function buildSummaryLines(event, state, panel) {
     // `WARNINGS`(有诊断才出现,位于 FAILURES 与 NEXT 之间,见 cli.md「人看的结束反馈」):
     // 按 code 汇总本次去重后的诊断,运行中同 code 只完整打印过第一条,这里是「这类事一共
     // 发生了几次」的权威答案。
-    const warningsRows = buildWarningsPanelRows(state.diagnostics);
+    const preAttemptCodes = new Set(summary.results.flatMap((result) => result.verdict === "errored" && result.locator === undefined && result.error !== undefined
+        ? [result.error.code]
+        : []));
+    const warningsRows = buildWarningsPanelRows(state.diagnostics.filter((diagnostic) => diagnostic.severity !== "error" || !preAttemptCodes.has(diagnostic.code ?? diagnostic.key)));
     if (warningsRows) {
         blocks.push((0, panel_ts_1.renderPanel)({ title: (0, index_ts_1.t)("feedback.human.warningsHeader"), rows: warningsRows, width: panel.width, mode: panel.mode }));
     }
@@ -410,7 +584,14 @@ function buildSummaryLines(event, state, panel) {
 function buildFailuresPanelRows(failures, panel) {
     const groups = groupFailuresByShape(failures);
     const contentWidth = (0, panel_ts_1.panelContentWidth)(panel.width, panel.mode);
-    const shown = groups.slice(0, FAILURE_GROUPS_CAP);
+    let shownAssertionKinds = 0;
+    const shown = groups.filter((group) => {
+        if (group.representative.fact === undefined)
+            return true;
+        shownAssertionKinds += 1;
+        return shownAssertionKinds <= FAILURE_GROUPS_CAP;
+    });
+    const omitted = groups.length - shown.length;
     const multi = shown.filter((g) => g.size > 1);
     const countWidth = Math.max(0, ...multi.map((g) => (0, text_layout_ts_1.stringWidth)(`${FAILURE_SYMBOL} ×${g.size}`)));
     const rows = [];
@@ -422,10 +603,10 @@ function buildFailuresPanelRows(failures, panel) {
             rows.push(buildMultiFailureGroupRow(group, countWidth));
         }
     }
-    if (groups.length > FAILURE_GROUPS_CAP) {
+    if (omitted > 0) {
         rows.push({
             kind: "line",
-            text: (0, index_ts_1.t)("feedback.human.moreFailureKinds", { count: groups.length - FAILURE_GROUPS_CAP }),
+            text: (0, index_ts_1.t)("feedback.human.moreFailureKinds", { count: omitted }),
         });
     }
     return { rows, meta: (0, index_ts_1.t)("feedback.human.failuresTotalKinds", { total: failures.length, kinds: groups.length }) };
@@ -446,18 +627,14 @@ function groupFailuresByShape(failures) {
         .map(([key, g]) => ({ key, ...g }))
         .sort((a, b) => b.size - a.size);
 }
-/** 组 key 与形态摘要文本共用同一个"剥掉 received 的断言摘要"投影(有主断言摘要时,`failed`
- *  与 Fact unavailable 造成的 `errored` 都走这条);没有主 Fact 摘要的 `errored`（真正的
- *  结构化执行错误)按 `phase · code` 分组,摘要文本复用 `buildErroredInfo`(不带 message)。 */
+/** 断言按稳定形态聚合；execution error 的 key 包含 locator，确保不同 Attempt 不会因共享
+ * phase/code 而吞掉各自的 Provider message。 */
 function failureShapeOf(failure) {
     if (failure.fact) {
         const shapeText = (0, display_ts_1.compactAssertionSummary)({ ...failure.fact, received: undefined, additionalFailures: 0 });
         return { key: `fact\u0000${failure.fact.title}\u0000${failure.fact.matcher ?? ""}`, shapeText };
     }
-    return {
-        key: `errored\u0000${failure.phase ?? "?"}\u0000${failure.code ?? "?"}`,
-        shapeText: buildErroredInfo(failure.phase, failure.code, ""),
-    };
+    return { key: `errored\u0000${failure.locator}`, shapeText: "error" };
 }
 function buildMultiFailureGroupRow(group, countWidth) {
     const countToken = (0, text_layout_ts_1.padStartDisplay)(`${FAILURE_SYMBOL} ×${group.size}`, countWidth);
@@ -472,13 +649,15 @@ function buildSingleFailureGroupRows(failure, contentWidth) {
     const identityLine = `${FAILURE_SYMBOL} ${failure.locator}  ${failure.identity.evalId}  [${failure.who}]`;
     const indent = (0, text_layout_ts_1.stringWidth)(`${FAILURE_SYMBOL} `);
     const budget = Math.max(0, contentWidth - indent);
-    const info = failure.fact
-        ? (0, display_ts_1.fitCompactAssertionSummary)(failure.fact, budget)
-        : buildErroredInfo(failure.phase, failure.code, failure.reason);
-    return [
-        { kind: "line", text: identityLine },
-        { kind: "line", text: `${" ".repeat(indent)}${clipDisplayWidth(info, budget)}` },
-    ];
+    const rows = [{ kind: "line", text: identityLine }];
+    if (failure.fact) {
+        rows.push({ kind: "line", text: `${" ".repeat(indent)}${clipDisplayWidth((0, display_ts_1.fitCompactAssertionSummary)(failure.fact, budget), budget)}` });
+    }
+    else {
+        rows.push(...labelledWrappedRows("error", boundedHumanError(failure.reason), contentWidth));
+    }
+    rows.push(...labelledWrappedRows("details", `niceeval show ${failure.locator}`, contentWidth));
+    return rows;
 }
 /** `WARNINGS` 面板:`state.diagnostics` 已经按去重 key 折叠,这里再按对外稳定词法 `code` 二次
  *  聚合。info 由自己的完成面板消费；没有 warning/error 时返回 undefined。 */
@@ -508,38 +687,98 @@ function buildWarningsPanelRows(diagnostics) {
     }));
 }
 function buildRecoveryPanelRows(diagnostics) {
-    let slots = 0;
     let locks = 0;
     for (const d of diagnostics) {
         if (d.severity !== "info" || d.code !== types_ts_1.COORDINATION_RECOVERED_CODE)
             continue;
-        if (d.data?.resource === "concurrency-slot")
-            slots += d.count;
         if (d.data?.resource === "case-lock")
             locks += d.count;
     }
-    if (slots === 0 && locks === 0)
+    if (locks === 0)
         return undefined;
-    const summary = (0, index_ts_1.t)("feedback.human.coordinationRecoveredSummary", {
-        slots: pluralUnit(slots, "feedback.human.unit.concurrencySlot", "feedback.human.unit.concurrencySlots"),
-        locks: pluralUnit(locks, "feedback.human.unit.caseLock", "feedback.human.unit.caseLocks"),
-    });
+    const summary = pluralUnit(locks, "feedback.human.unit.caseLock", "feedback.human.unit.caseLocks");
     return [{ kind: "line", text: `i ${types_ts_1.COORDINATION_RECOVERED_CODE}  ${summary}` }];
 }
 function warningCodeLabel(code, count) {
     return count > 1 ? `${code} ×${count}` : code;
 }
 /** `NEXT` 面板只由 receipt 的真实 Run ID 给出 Record 读取命令。 */
-function buildReceiptLines(event, panel) {
+function buildReceiptLines(event, state, panel) {
     const rows = [];
+    const published = new Set(event.receipt.runIds);
+    const emitted = new Set();
+    for (const [experimentId, runId] of state.runIdsByExperiment) {
+        if (!published.has(runId))
+            continue;
+        rows.push({ kind: "line", text: experimentId });
+        rows.push(...labelledWrappedRows("details", `niceeval show --run ${runId}`, (0, panel_ts_1.panelContentWidth)(panel.width, panel.mode)));
+        emitted.add(runId);
+    }
     for (const runId of event.receipt.runIds) {
-        rows.push({ kind: "line", text: `niceeval show --run ${runId}` });
+        if (!emitted.has(runId))
+            rows.push({ kind: "line", text: `details: niceeval show --run ${runId}` });
     }
     if (rows.length === 0) {
         rows.push({ kind: "line", text: "No published Record Runs are available for this invocation." });
     }
     return (0, panel_ts_1.renderPanel)({ title: (0, index_ts_1.t)("feedback.human.nextHeader"), rows, width: panel.width, mode: panel.mode });
 }
+function boundedHumanError(message) {
+    const safe = (0, display_ts_1.stripControl)(message).replace(/\s+/gu, " ").trim();
+    const signalIndexes = [
+        safe.search(/\b[1-5]\d{2}\s+[A-Z][A-Za-z -]{2,40}(?:\s+[—·:-]\s+[A-Z][A-Z0-9_-]+)?/u),
+        safe.search(/\b[A-Z][A-Z0-9]+(?:_[A-Z0-9]+){1,}\b/u),
+    ].filter((index) => index >= 0);
+    // Wrappers often prepend a long command or transport path before the
+    // Provider's safe status/code. Focus the Human budget at that first stable
+    // signal; the full structured error remains available through details.
+    const focused = signalIndexes.length === 0 ? safe : safe.slice(Math.min(...signalIndexes));
+    if (utf8Bytes(focused) <= HUMAN_ERROR_TEXT_MAX_BYTES)
+        return focused;
+    const separator = " … ";
+    const available = HUMAN_ERROR_TEXT_MAX_BYTES - utf8Bytes(separator);
+    const head = Math.ceil(available / 2);
+    const tail = available - head;
+    return `${utf8Prefix(focused, head)}${separator}${utf8Suffix(focused, tail)}`;
+}
+function utf8Bytes(value) {
+    return new TextEncoder().encode(value).byteLength;
+}
+function utf8Prefix(value, maximumBytes) {
+    let bytes = 0;
+    let result = "";
+    for (const character of value) {
+        const nextBytes = utf8Bytes(character);
+        if (bytes + nextBytes > maximumBytes)
+            break;
+        result += character;
+        bytes += nextBytes;
+    }
+    return result;
+}
+function utf8Suffix(value, maximumBytes) {
+    let bytes = 0;
+    const result = [];
+    const characters = Array.from(value);
+    for (let index = characters.length - 1; index >= 0; index -= 1) {
+        const character = characters[index];
+        const nextBytes = utf8Bytes(character);
+        if (bytes + nextBytes > maximumBytes)
+            break;
+        result.push(character);
+        bytes += nextBytes;
+    }
+    return result.reverse().join("");
+}
+function labelledWrappedRows(label, text, contentWidth) {
+    const prefix = `  ${label}: `;
+    const continuation = " ".repeat((0, text_layout_ts_1.stringWidth)(prefix));
+    const lines = (0, text_layout_ts_1.wrapDisplay)(text, Math.max(4, contentWidth - (0, text_layout_ts_1.stringWidth)(prefix)));
+    return lines.map((line, index) => ({
+        kind: "line",
+        text: `${index === 0 ? prefix : continuation}${line}`,
+    }));
+}
 /** estimated cost 展示:金额前加 `~`,明确是价目表估算(observed 只留在 result.usage.costUSD)。 */
 function formatEstimatedCost(value) {
     const cost = (0, format_ts_1.formatCost)(value);