@zhushanwen/pi-ask-user 5.0.0-dev.1 → 5.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-ask-user",
-  "version": "5.0.0-dev.1",
+  "version": "5.0.1",
   "description": "Inline adaptive ask_user tool for Pi — single/multi-question structured input with split-pane preview, inline editor and optional comments.",
   "type": "module",
   "main": "index.ts",
@@ -26,7 +26,7 @@
     "ARCHITECTURE.md"
   ],
   "dependencies": {
-    "@xyz-agent/extension-protocol": "^0.3.1-dev.0"
+    "@xyz-agent/extension-protocol": "^0.3.1"
   },
   "devDependencies": {
     "@earendil-works/pi-tui": "*",
@@ -38,7 +38,7 @@
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",
     "typebox": "*",
-    "@zhushanwen/pi-subagent-workflow": "5.0.0-dev.1"
+    "@zhushanwen/pi-subagent-workflow": "5.0.1"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-tui": {

package/src/__tests__/answer-format.test.ts

@@ -16,9 +16,10 @@ describe("formatAnswer", () => {
 		expect(formatAnswer([])).toBeNull();
 	});
 
-	it("returns null for empty parts even with comment", () => {
-		// parts 空 = 没有选中选项，即使有 comment 也不应产出有效答案行
-		expect(formatAnswer([], "some comment")).toBeNull();
+	it("comment-only: empty parts + comment → separator-prefixed comment (MF-1)", () => {
+		// parts 空但有 comment = allowComment 的「无选项适用但想说明原因」场景，
+		// 不能返回 null（会把评论一起丢弃）；以 ANSWER_COMMENT_SEPARATOR 开头保持往返可解析
+		expect(formatAnswer([], "some comment")).toBe(`${ANSWER_COMMENT_SEPARATOR}some comment`);
 	});
 
 	it("joins single part without separator", () => {
@@ -104,4 +105,171 @@ describe("parseAnswerParts", () => {
 		expect(result.selected).toEqual([]);
 		expect(result.comment).toBe("just a comment");
 	});
+
+	// MF-2 回归：label 自身含 ANSWER_COMMENT_SEPARATOR（LLM 生成 label 常见形态）时，
+	// 首个分隔符切分会把 label 拦腰截断 → token 无法精确匹配 → 选中值静默丢失
+	describe("MF-2: label contains ANSWER_COMMENT_SEPARATOR", () => {
+		const labels = ["Postgres — prod", "SQLite"];
+
+		it("whole answer exactly matches separator-containing label → selected, no comment", () => {
+			const result = parseAnswerParts("Postgres — prod", labels);
+			expect(result.selected).toEqual(["Postgres — prod"]);
+			expect(result.comment).toBeUndefined();
+		});
+
+		it("selection + comment → later separator becomes split point", () => {
+			const result = parseAnswerParts("Postgres — prod — fast", labels);
+			expect(result.selected).toEqual(["Postgres — prod"]);
+			expect(result.comment).toBe("fast");
+		});
+
+		it("two selections where first label contains separator", () => {
+			const result = parseAnswerParts("Postgres — prod, SQLite — my note", labels);
+			expect(result.selected).toEqual(["Postgres — prod", "SQLite"]);
+			expect(result.comment).toBe("my note");
+		});
+
+		it("comment containing separator keeps full remainder", () => {
+			const result = parseAnswerParts("Postgres — prod — fast — very fast", labels);
+			expect(result.selected).toEqual(["Postgres — prod"]);
+			expect(result.comment).toBe("fast — very fast");
+		});
+	});
+
+	it("returns non-matching body tokens as otherTokens (Other free text)", () => {
+		const result = parseAnswerParts("custom text", ["yes", "no"]);
+		expect(result.selected).toEqual([]);
+		expect(result.otherTokens).toEqual(["custom text"]);
+	});
+
+	it("otherTokens excludes matched labels and comment", () => {
+		const result = parseAnswerParts("A, custom text — note", ["A", "B"]);
+		expect(result.selected).toEqual(["A"]);
+		expect(result.otherTokens).toEqual(["custom text"]);
+		expect(result.comment).toBe("note");
+	});
+
+	// MF-6 回归：两个 label 都含分隔符时（"Postgres — prod, MySQL"），分隔符扫描会把
+	// 首个分隔符当切分点 → body "Postgres" 无匹配 → 剩余 "prod, MySQL" 被误判为 comment，
+	// 两个选中项全部静默丢失。纯多选分支（所有逗号 token 均为 label）在扫描前短路。
+	describe("MF-6: pure multi-select where every label contains separator", () => {
+		const labels = ["Postgres — prod", "MySQL"];
+
+		it("all comma tokens are labels → selected all, no comment", () => {
+			const result = parseAnswerParts("Postgres — prod, MySQL", labels);
+			expect(result.selected).toEqual(["Postgres — prod", "MySQL"]);
+			expect(result.comment).toBeUndefined();
+			expect(result.otherTokens).toEqual([]);
+		});
+
+		it("comment form not broken: non-label token 'MySQL — note' skips the branch", () => {
+			// "MySQL — note" 非 label → 不进纯多选分支；分隔符扫描取「body 整串可解析为
+			// 选中项」的最靠后切分（"Postgres — prod, MySQL" 两个 token 均 label）→
+			// 选中两项 + comment "note"（与 MF-2 多选 + comment 语义一致）
+			const result = parseAnswerParts("Postgres — prod, MySQL — note", labels);
+			expect(result.selected).toEqual(["Postgres — prod", "MySQL"]);
+			expect(result.comment).toBe("note");
+		});
+
+		it("three selections all containing separators", () => {
+			const labels3 = ["Postgres — prod", "MySQL — prod", "SQLite — prod"];
+			const result = parseAnswerParts("Postgres — prod, MySQL — prod, SQLite — prod", labels3);
+			expect(result.selected).toEqual(["Postgres — prod", "MySQL — prod", "SQLite — prod"]);
+			expect(result.comment).toBeUndefined();
+		});
+	});
+
+	// MF-7 回归：重叠前缀 label（短 label 是长 label 的前缀）时，分隔符扫描取「首个 body
+	// 含 label token」的切分会停在短 label 处，把长 label 的剩余部分误判为 comment。
+	// 修复：优先「body 整串精确命中 label」的切分点，多个命中取最靠后者（最长匹配）。
+	describe("MF-7: overlapping prefix labels prefer whole-body label split", () => {
+		const labels = ["Postgres", "Postgres — prod"];
+
+		it("longest whole-body label wins → 'Postgres — prod' + comment 'x'", () => {
+			const result = parseAnswerParts("Postgres — prod — x", labels);
+			expect(result.selected).toEqual(["Postgres — prod"]);
+			expect(result.comment).toBe("x");
+		});
+
+		it("short label + comment containing long-label prefix (inherent ambiguity, documented tradeoff)", () => {
+			// 长 label 不在候选时（labels 只有 "Postgres"），同一文本解析为
+			// 选短 label + comment "prod — x"——文本层面唯一可解析的归属
+			const result = parseAnswerParts("Postgres — prod — x", ["Postgres"]);
+			expect(result.selected).toEqual(["Postgres"]);
+			expect(result.comment).toBe("prod — x");
+		});
+
+		it("multi-select + comment with prefix labels → split after all labels", () => {
+			// "Postgres — prod, SQLite" 两个 token 均 label → 切分点取最后分隔符，
+			// body 完整保留两项选中，comment "note"（首个整串命中 "Postgres" 不截断）
+			const labels3 = ["Postgres", "Postgres — prod", "SQLite"];
+			const result = parseAnswerParts("Postgres — prod, SQLite — note", labels3);
+			expect(result.selected).toEqual(["Postgres — prod", "SQLite"]);
+			expect(result.comment).toBe("note");
+		});
+	});
+
+	// MF-2（R3 回归）：label 含分隔符 + Other 自由文本 + comment 的混合形态。
+	// R3 的 all-label 单谓词扫描落空 → 回退首分隔符 → 选中项静默丢失；第二级
+	// 「body 含 ≥1 label token」首个命中落在真正分隔选中/Other 与 comment 的分隔符上。
+	describe("MF-2: label with separator + Other free text + comment", () => {
+		const labels = ["Postgres — prod"];
+
+		it("mixed body (label + Other) + comment → label selected, Other kept, comment at later separator", () => {
+			const result = parseAnswerParts("Postgres — prod, custom text — note", labels);
+			expect(result.selected).toEqual(["Postgres — prod"]);
+			expect(result.otherTokens).toEqual(["custom text"]);
+			expect(result.comment).toBe("note");
+		});
+
+		it("comment containing separator keeps full remainder (no over-split at second separator)", () => {
+			// "A, B — note — x"：第一级 all-label body 在第一个分隔符命中，短路第二级
+			// ——若走「≥1 label token 取最后」会在第二个分隔符过切（comment 错位）
+			const result = parseAnswerParts("A, B — note — x", ["A", "B"]);
+			expect(result.selected).toEqual(["A", "B"]);
+			expect(result.comment).toBe("note — x");
+		});
+	});
+
+	// MF-3（pre-existing）：label 含分隔符 + Other 自由文本、无 comment 形态。
+	// 两级扫描均无命中（唯一候选 body "Postgres" 不含 label token）→ 整串含 label
+	// token 时不切分，整串作 body（选中 + Other）——首分隔符切分会把 label 拦腰截断
+	// 产生空选中。S-17 冻结边界：整串无任何 label token 时仍走首分隔符切分。
+	describe("MF-3: label with separator + Other free text, no comment", () => {
+		const labels = ["Postgres — prod"];
+
+		it("no comment variant → whole string as body, label selected + Other kept", () => {
+			const result = parseAnswerParts("Postgres — prod, custom text", labels);
+			expect(result.selected).toEqual(["Postgres — prod"]);
+			expect(result.otherTokens).toEqual(["custom text"]);
+			expect(result.comment).toBeUndefined();
+		});
+
+		it("S-17 freeze intact: whole string without any label token still first-separator split", () => {
+			// "custom — text" 整串无 label token → 不切分回退不触发，保持首分隔符切分
+			const result = parseAnswerParts("custom — text", labels);
+			expect(result.selected).toEqual([]);
+			expect(result.otherTokens).toEqual(["custom"]);
+			expect(result.comment).toBe("text");
+		});
+	});
+
+	// S-17 行为固化：Other 自由文本自身含 " — "（如 "custom — text"）与
+	// 「选中/Other + comment」形态在纯解析层面固有歧义，保持首个分隔符切分行为
+	// （body "custom" + comment "text"），不做解析层区分（见 answer-format.ts 注释）。
+	describe("S-17: Other free text containing separator (behavior freeze)", () => {
+		it("separator inside Other text → first-separator split, documented ambiguity", () => {
+			const result = parseAnswerParts("custom — text", ["yes", "no"]);
+			expect(result.selected).toEqual([]);
+			expect(result.otherTokens).toEqual(["custom"]);
+			expect(result.comment).toBe("text");
+		});
+
+		it("Other text with separator + matched label before it", () => {
+			const result = parseAnswerParts("yes, custom — text", ["yes", "no"]);
+			expect(result.selected).toEqual(["yes"]);
+			expect(result.otherTokens).toEqual(["custom"]);
+			expect(result.comment).toBe("text");
+		});
+	});
 });

package/src/__tests__/channel-handler.test.ts

@@ -232,6 +232,31 @@ describe("createAskUserChannelHandler", () => {
 		});
 	});
 
+	it("TUI: label containing ' — ' keeps full selection (MF-2)", async () => {
+		// label 含 ANSWER_COMMENT_SEPARATOR（"Postgres — prod"）时，首分隔符切分
+		// 会拦腰截断 label → 无法精确匹配 → 选中值静默丢失；修复后选中保留、comment 完整
+		const sepLabelProto: AskUserQuestion = {
+			question: "Which DB?",
+			allowComment: true,
+			options: [{ label: "Postgres — prod", value: "Postgres — prod" }, { label: "SQLite", value: "SQLite" }],
+		};
+		const internalResult: Result = {
+			questions: [],
+			answers: { "Which DB?": "Postgres — prod — constraint" },
+			cancelled: false,
+		};
+		const handler = createAskUserChannelHandler(
+			makeCtx({ mode: "tui", customResult: internalResult }) as never,
+		);
+		const resp = await handler({ channelPayload: { questions: [sepLabelProto] } });
+		expect(resp).toEqual({
+			value: JSON.stringify({
+				"Which DB?": "Postgres — prod",
+				"Which DB?__comment": "constraint",
+			}),
+		});
+	});
+
 	it("TUI: user cancel (custom returns null) → {cancelled: true}", async () => {
 		const handler = createAskUserChannelHandler(
 			makeCtx({ mode: "tui", customResult: null }) as never,

package/src/__tests__/index.test.ts

@@ -670,6 +670,32 @@ describe("execute — RPC mode (askUserInteract via select channel)", () => {
 		expect(result.details.answers["Which DB?"]).toBe("Postgres — prod constraint");
 	});
 
+	it("R-4b: comment-only answer → 保留（MF-1 回归：无选中 + comment 不静默丢失）", async () => {
+		const tool = getTool();
+		const withComment = {
+			questions: [
+				{
+					question: "Which DB?",
+					options: [{ label: "Postgres" }, { label: "SQLite" }],
+					allowComment: true,
+				},
+			],
+		};
+		// GUI 只填评论提交（无选中）：answers 只有 __comment key、无主 key
+		const protoAnswers = JSON.stringify({
+			"Which DB?__comment": "生产环境都不能用，需评估新方案",
+		});
+		const result = await tool.execute(
+			"id",
+			withComment,
+			undefined,
+			undefined,
+			makeCtx({ mode: "rpc", selectResult: protoAnswers }),
+		);
+		// formatAnswer 空 parts 不再返回 null——comment-only 以 " — comment" 形式保留
+		expect(result.details.answers["Which DB?"]).toBe(" — 生产环境都不能用，需评估新方案");
+	});
+
 	it("R-5: user cancel (select returns undefined) → cancelled details", async () => {
 		const tool = getTool();
 		const result = await tool.execute(

package/src/answer-format.ts

@@ -7,11 +7,13 @@ import { ANSWER_COMMENT_SEPARATOR } from "./types";
 
 /**
  * 把答案各部分拼装为最终文本格式："part1, part2 — comment"。
- * - parts 为空 → 返回 null（未答）
+ * - parts 为空 + comment 有值 → comment-only 答案（allowComment 的「无选项适用但想说明原因」
+ *   场景）：以 ANSWER_COMMENT_SEPARATOR 开头，保持 parseAnswerParts 往返可解析
+ * - parts 与 comment 都为空 → 返回 null（未答）
  * - comment 有值 → 追加 ANSWER_COMMENT_SEPARATOR + comment
  */
 export function formatAnswer(parts: string[], comment?: string | null): string | null {
-	if (parts.length === 0) return null;
+	if (parts.length === 0) return comment ? `${ANSWER_COMMENT_SEPARATOR}${comment}` : null;
 	const base = parts.join(", ");
 	return comment ? `${base}${ANSWER_COMMENT_SEPARATOR}${comment}` : base;
 }
@@ -27,25 +29,99 @@ export function formatAnswer(parts: string[], comment?: string | null): string |
 export function parseAnswerParts(
 	answer: string,
 	labels: string[],
-): { selected: string[]; comment?: string } {
-	// 先提取 comment（ANSWER_COMMENT_SEPARATOR 之后的部分）
-	let body = answer;
+): { selected: string[]; comment?: string; otherTokens: string[] } {
+	const labelSet = new Set(labels);
+	const trimmed = answer.trim();
+
+	// 整串精确命中单个 label → 单选该 label、无 comment。label 自身可能含
+	// ANSWER_COMMENT_SEPARATOR（如 "Postgres — prod"），首个分隔符切分会把它拦腰截断。
+	if (labelSet.has(trimmed)) return { selected: [trimmed], comment: undefined, otherTokens: [] };
+
+	// MF-6：整串逗号切分的每个 token 都是 label → 纯多选、无 comment。
+	// 必须置于分隔符扫描之前——"Postgres — prod, MySQL"（两个 label 都含分隔符形态）
+	// 若进扫描，首个分隔符切在 "Postgres — prod" 中间，剩余 "prod, MySQL" 被误判为
+	// comment，两个选中项全部静默丢失。仅当全部 token 均为 label 时触发：
+	// "Postgres — prod, MySQL — note" 中 "MySQL — note" 非 label → 不进此分支，
+	// 由分隔符扫描解析为选中 "Postgres — prod" + "MySQL" + comment "note"
+	// （含 comment 的多选形态不破坏）。
+	const allTokens = trimmed.split(/[,，]/).map((t) => t.trim()).filter(Boolean);
+	if (allTokens.length > 0 && allTokens.every((t) => labelSet.has(t))) {
+		return { selected: allTokens, comment: undefined, otherTokens: [] };
+	}
+
+	// body/comment 切分点：两级扫描 + 不切分回退，语义见各段注释。
+	// 第一级（MF-7 语义）：取「body 整串可解析为选中项」的最靠后分隔符 = 最长选中 body，
+	// 其后的全部剩余文本为 comment。"可解析为选中项" = 整串精确命中单个 label（含逗号
+	// label 如 "A, B"），或全部逗号 token 均为 label（多选 body，如 "Postgres — prod, MySQL"）。
+	// 第二级（MF-2 回归修复）：第一级无命中时回退「body 含 ≥1 个 label token」的首个分隔符——
+	// "Postgres — prod, custom text — note"（label 含分隔符 + Other 自由文本 + comment）
+	// 无任何 all-label body，单谓词扫描落空 → 回退首分隔符把 label 拦腰截断，选中项静默丢失；
+	// ≥1 谓词在真正分隔选中/Other 与 comment 的第二个分隔符命中。
+	// 不切分回退（MF-3）：两级都无命中但整串含 label token（"Postgres — prod, custom text"
+	// 无 comment 形态）→ 整串作 body（选中 + Other），不切分——首分隔符切分把 label 拦腰
+	// 截断产生空选中。整串无任何 label token（S-17："custom — text" Other 自由文本自身含
+	// 分隔符）→ 保持首个分隔符切分（body "custom" + comment "text"），不做解析层区分，
+	// 由调用方（TUI encode）按 label 命中情况归属。
+	// MF-7 固有歧义取舍（第一级）：重叠前缀 label 如 ["Postgres", "Postgres — prod"] 时，
+	// "Postgres — prod — x" 取最靠后的整串命中即最长匹配（选中长 label + comment "x"）；
+	// 若用户意图确实是「选短 label + comment 含长 label 前缀」会被误判——文本本身无法区分，
+	// 精确 label body 优先是更优启发而非完备解；长 label 不在候选时（"Postgres — prod" 非
+	// label）该意图解析正确。
+	// 注意：分隔符扫描用原始 answer（不 trim）——comment-only 答案以 " — comment" 开头，
+	// trim 会吃掉前导空格导致 indexOf 失配。
+	let body = trimmed;
 	let comment: string | undefined;
-	const sepIdx = answer.indexOf(ANSWER_COMMENT_SEPARATOR);
-	if (sepIdx >= 0) {
-		body = answer.slice(0, sepIdx);
-		comment = answer.slice(sepIdx + ANSWER_COMMENT_SEPARATOR.length).trim();
+	let splitIdx = answer.indexOf(ANSWER_COMMENT_SEPARATOR);
+	// 第一级：取「body 整串可解析为选中项」的最靠后分隔符
+	let bestSplit = -1;
+	let scan = splitIdx;
+	while (scan >= 0) {
+		const candidateBody = answer.slice(0, scan).trim();
+		if (labelSet.has(candidateBody)) {
+			bestSplit = scan;
+		} else {
+			const candidateTokens = candidateBody.split(/[,，]/).map((t) => t.trim()).filter(Boolean);
+			if (candidateTokens.length > 0 && candidateTokens.every((t) => labelSet.has(t))) {
+				bestSplit = scan;
+			}
+		}
+		scan = answer.indexOf(ANSWER_COMMENT_SEPARATOR, scan + ANSWER_COMMENT_SEPARATOR.length);
+	}
+	if (bestSplit < 0) {
+		// 第二级：取「body 含 ≥1 个 label token」的首个分隔符（R2 的 some() 谓词回归，
+		// 仅在第一级无命中时运行——"A, B — note — x" 形态第一级已命中，不会过切）
+		scan = splitIdx;
+		while (scan >= 0) {
+			const candidateTokens = answer.slice(0, scan).trim().split(/[,，]/).map((t) => t.trim()).filter(Boolean);
+			if (candidateTokens.some((t) => labelSet.has(t))) {
+				bestSplit = scan;
+				break;
+			}
+			scan = answer.indexOf(ANSWER_COMMENT_SEPARATOR, scan + ANSWER_COMMENT_SEPARATOR.length);
+		}
+	}
+	// MF-3 不切分回退：整串含 label token 时以整串为 body（选中 + Other），不切分。
+	// splitIdx >= 0 前置（无分隔符时本就整串为 body，无需走此分支）。
+	const noSplit = bestSplit < 0 && splitIdx >= 0 && allTokens.some((t) => labelSet.has(t));
+	if (!noSplit && splitIdx >= 0) {
+		if (bestSplit >= 0) {
+			splitIdx = bestSplit;
+		}
+		body = answer.slice(0, splitIdx).trim();
+		comment = answer.slice(splitIdx + ANSWER_COMMENT_SEPARATOR.length).trim() || undefined;
 	}
 
-	// body 形如 "label1, label2" → 精确匹配候选 label
-	const labelSet = new Set(labels);
+	// body 形如 "label1, label2" → 精确匹配候选 label；剩余 tokens 不匹配任何 label
+	// → Other 自由文本（otherTokens 返回给调用方，如 channel-handler 提取 __other）
 	const tokens = body.split(/[,，]/).map((t) => t.trim()).filter(Boolean);
 	const selected: string[] = [];
-	// 剩余 tokens 不匹配任何 label → 是 Other 自由文本（不返回，调用方自行处理）
+	const otherTokens: string[] = [];
 	for (const token of tokens) {
 		if (labelSet.has(token)) {
 			selected.push(token);
+		} else {
+			otherTokens.push(token);
 		}
 	}
-	return { selected, comment };
+	return { selected, comment, otherTokens };
 }

package/src/channel-handler.ts

@@ -23,7 +23,8 @@ import {
 } from "@xyz-agent/extension-protocol";
 
 import { AskUserComponent } from "./component";
-import { ANSWER_COMMENT_SEPARATOR, type Option, type Question, type Result, type ThemeLike } from "./types";
+import { parseAnswerParts } from "./answer-format";
+import { type Option, type Question, type Result, type ThemeLike } from "./types";
 
 /**
  * channel handler 签名——与 subagent-workflow 的 UiChannelRegistry.ChannelHandler 一致
@@ -97,29 +98,21 @@ function encodeTuiResultToProto(
 			if (o.value !== undefined) knownLabels.add(o.value);
 		}
 
-		// 切 body / comment（comment 在 ANSWER_COMMENT_SEPARATOR 之后）
-		const sepIdx = internalText.indexOf(ANSWER_COMMENT_SEPARATOR);
-		const body = sepIdx >= 0 ? internalText.slice(0, sepIdx) : internalText;
-		const comment = sepIdx >= 0
-			? internalText.slice(sepIdx + ANSWER_COMMENT_SEPARATOR.length).trim() || undefined
-			: undefined;
-
-		// body tokens：匹配 knownLabels 的为 selected，其余为 Other 自由文本
-		const tokens = body.split(/[,，]/).map((t: string) => t.trim()).filter((t: string) => t !== "");
-		const selected: string[] = [];
-		const otherTokens: string[] = [];
-		for (const t of tokens) {
-			if (knownLabels.has(t)) {
-				// 回查 proto option 的 value（PR #85 #8）：TUI 渲染用 label，但 RPC 路径
-				// （askUserInteract）回传的是 option.value。value≠label 时若直接 push label，
-				// TUI/RPC 两条路径产出分裂。value 缺失时 fallback label（保持 ask-user 自身
-				// toProtoQuestions 的 value=label 语义，以及历史行为）。
-				const opt = pq.options?.find(o => o.label === t || o.value === t);
-				selected.push(opt?.value ?? t);
-			} else {
-				otherTokens.push(t);
-			}
-		}
+		// body/comment 切分 + 选中/Other 识别：复用 parseAnswerParts（answer-format.ts 是
+		// 唯一权威切分实现——label 含 ANSWER_COMMENT_SEPARATOR 时首分隔符切分会把 label
+		// 拦腰截断导致选中丢失，两处各自实现必然漂移；复用保证 TUI/RPC 解码行为一致，
+		// comment 自身含分隔符也正确往返）。knownLabels 传 label+value 并集（value 缺失时
+		// 用 label）。
+		const { selected: matchedLabels, comment, otherTokens } = parseAnswerParts(internalText, [...knownLabels]);
+
+		// matched label 回查 proto option 的 value（PR #85 #8）：TUI 渲染用 label，但 RPC 路径
+		// （askUserInteract）回传的是 option.value。value≠label 时若直接 push label，
+		// TUI/RPC 两条路径产出分裂。value 缺失时 fallback label（保持 ask-user 自身
+		// toProtoQuestions 的 value=label 语义，以及历史行为）。
+		const selected = matchedLabels.map((t: string) => {
+			const opt = pq.options?.find(o => o.label === t || o.value === t);
+			return opt?.value ?? t;
+		});
 		const otherText = otherTokens.join(", ") || undefined;
 
 		// 主 key：单选 = 首个选中 value；多选 = JSON 数组（即便为空也写入，与 RPC 契约一致）

package/src/index.ts

@@ -135,7 +135,7 @@ function toProtoQuestions(questions: Question[]): AskUserQuestion[] {
 /**
  * 把协议包 AskUserAnswers 转换为 ask-user 内部 Result.answers。
  *
- * 协议格式：key=header/question, 单选=string, 多选=JSON数组, Other=__other, comment=__comment（4.0.1 restore）
+ * 协议格式：key=header/question, 单选=string, 多选=JSON数组, Other=__other, comment=__comment（5.0.0-dev.1 restore）
  * ask-user 格式：key=question 全文, value=逗号分隔 label + Other, comment 内联（` — `）
  *
  * 拼装逻辑复用 formatAnswer（与 TUI 版 getAnswerText 共享同一格式函数），