@sjhmars/happy-bridge 0.3.7 → 0.3.9

package/README.md

@@ -12,16 +12,16 @@
 
 - 未配对：二维码 + 可复制的手机/网页链接。请在 **Happy App 里扫**，不要用系统相机。
 - 已配对：显示已连接，可断开或点 **重新配对** 再出一张新二维码。断开只关掉 Happy 映射，网页 UI 还在。
-- **手机能管多深**：只看 / 能聊 / 能批 / 完整。默认「能批」。改到 `danger-full-access`、以及让手机换模型和思考强度同步到电脑输入框，都需要「完整」。电脑上换模型和思考强度不需要这个档。两边都能切，会互相跟着变。网页加了新模型后，已经同步到手机的旧对话名单也会更新。改档位立刻生效，不必重新配对。
+- **手机能管多深**：只看 / 能聊 / 能批 / 完整。默认「能批」。改到 `danger-full-access`、以及让手机换模型和思考强度同步到电脑输入框，都需要「完整」。电脑上换模型和思考强度不需要这个档。**真正发给模型的，永远是网页那一栏**；手机切档会先改这一栏，再发消息。两边都能切，会互相跟着变。网页自己发布到手机的回声（同一模型、同一档）不会反过来改网页。网页加了新模型后，已经同步到手机的旧对话名单也会更新。改档位立刻生效，不必重新配对。
 
 手机 Happy App：
 
 - 列表里看到本机普通会话（子 agent 不镜像）。侧栏里没点开的对话同样保持在线心跳。网页上的空白「新会话」占位（没发过第一条消息、网页未选中时会藏起来）不会出现在手机上；发出第一条之后才会镜像。在手机里给这样的对话发消息，会把它在电脑上唤醒（网页不必跟着切过去），并用这场对话上次用过的模型生成回复；没有记录就用网页默认模型。连着电脑时是在线；心跳断了会显示未在线。网页侧栏还在的对话会自动把心跳续上；手机点开这条未在线对话也会重新接通，不必先去网页点开。标题优先用网页会话名，没有就用第一条用户消息；空对话和网页一样叫「新会话」。列表按网页工作区分组，不会把 Windows 盘符路径堆成一坨。网页归档的对话会停心跳、进手机归档列表；从归档里打开或再发一条，网页侧栏会把这场对话显示回来。
-- 打开空的 Happy 会话时，会把网页里已有的用户/助手/工具记录补进去。之后网页新消息也会推到手机。从手机新建或唤醒一场对话时，首轮请求会补上明确的思考强度（网页正在用的档，否则模型默认档），并同时认消息里的 `effort` / `effortLevel`，避免第一段思考被写成正文。
+- 打开空的 Happy 会话时，会把网页里已有的用户/助手/工具记录补进去。之后网页新消息也会推到手机。网页第一条、以及从手机新建或唤醒一场对话时，会把思考强度写进网页模型栏（网页正在用的档，否则模型默认档），请求只读这一栏，避免第一段思考被写成正文。手机消息里的 `effort` / `effortLevel` 若真是换档（不是网页刚发布的回声），会先落到网页栏再发出。
 - 新建：只能选已经在网页登记过的工作区。不会在磁盘上 mkdir。App 里「new worktree」会失败（故意不暴露 bash）。
 - 发文字：已注册 `/命令` 走命令通道；否则当聊天。`/skill名` 仍当普通消息，由 harness 注入。
 - 发图片：相册/拍照/粘贴后，会随下一条文字（也可以只发图）进同一场电脑对话，模型能看见图。`.java` / `.txt` 等普通文件会先下载到工作区 `happy-inbox/`，再走电脑原来的 `read` 工具读内容（和你在仓库里打开一个文件一样）。PDF、Word 这类不是纯文本的文件，电脑的 `read` 会拒绝，插件也不会自己拆文档。远程档至少「能聊」。输入框左边应有图片按钮；发出后电脑网页会出现图片，手机会转圈等回复。电脑网页贴的图也会按同一套加密上传推到手机。
-- 工具批准、计划审阅、选择题：和网页黄框/提问框赛跑，谁先点谁算。手机点「始终允许」只在这次网页进程里记住。选择题走 Happy 表单通道，首题末尾带一行提示「自定义回答：直接在下方聊天输入框输入并发送」——想选就点选项提交，想自由回答就直接打字发送，那条文本会作为答案并回显到卡片。旧版 App 没有这条通道，见 `questionChannel`。提问还在等的时候，直接用输入框打字也等于自己填；审阅计划时打字会关掉审阅，这句话当普通聊天发出去。批完/拒完的卡片会停在「已批准/已拒绝」状态，按钮失效。远程档至少「能批」才能从手机点。
+- 工具批准、计划审阅、选择题：和网页黄框/提问框赛跑，谁先点谁算。手机点「始终允许」只在这次网页进程里记住。选择题走 Happy 表单通道，首题末尾带一行提示「自定义回答：直接在下方聊天输入框输入并发送」——想选就点选项提交，想自由回答就直接打字发送，那条文本会作为答案并回显到卡片。**网页上填自定义答案或点选项，也会把同一份答案写回手机卡片**，不会再把手机表单标成「取消」（取消会让 App 走进输入框自定义流程，把网页模型栏锁回目录第一项 DeepSeek V4）。旧版 App 没有这条通道，见 `questionChannel`。提问还在等的时候，直接用输入框打字也等于自己填；审阅计划时打字会关掉审阅，这句话当普通聊天发出去。批完/拒完的卡片会停在「已批准/已拒绝」状态，按钮失效。远程档至少「能批」才能从手机点。
 - 电脑正在生成时，手机可以点停止（Happy App 的 Stop）。远程档至少「能聊」。只看档点了不会停。
 - 助手回复按整段推到手机（生成中会转圈）。思考收成一行 **Think · 摘要** 的 Note 卡片，点进去看全文。工具用 Happy 认识的名字（Grep / Read / Bash），描述跟网页那一行摘要一样。Happy 没有网页同款图标。
 
@@ -72,7 +72,7 @@ pnpm dsh web --port 3080
         questionChannel: communications
 ```
 
-`remoteGrant`：`watch` | `chat` | `approve` | `full`。设置页下拉框会写入这份配置。会话里也可以 `/remote approve`（只改当前进程，不写设置）。档位「完整」时，手机换模型和思考强度走电脑同一条 `session.selectModel`，网页模型栏和推理等级会跟着变。电脑自己换模型和思考强度同样会写回手机。网页加了新模型后，已镜像的手机会话会重新收到完整名单。
+`remoteGrant`：`watch` | `chat` | `approve` | `full`。设置页下拉框会写入这份配置。会话里也可以 `/remote approve`（只改当前进程，不写设置）。档位「完整」时，手机换模型和思考强度会先 `await` 电脑同一条 `session.selectModel`（网页模型栏和推理等级跟着变），再发下一条。电脑自己换模型和思考强度同样会写回手机。发给模型的请求只读网页栏，不会另走一套手机记忆。网页加了新模型后，已镜像的手机会话会重新收到完整名单。
 
 `questionChannel`：`communications`（默认）| `permission`。选择题走的 Happy 通道。`communications` 是 App 的表单通道：答完卡片常驻显示你选的答案，会话列表也会显示「等回答」；需要较新版 Happy App。`permission` 是旧通道：题目选项仍可见可答，答完卡片不回显。两条通道都没有内联输入框——自由回答都是直接在聊天输入框打字发送（表单首题末尾有提示行；`communications` 下零选项的题目会弹 App 全屏表单，那里有真正的输入框）。
 

package/lib/client.js

@@ -17,21 +17,21 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var HappyBridgeCard_module_css_default = {
-			"headText": "l9rBEq_headText",
-			"name": "l9rBEq_name",
 			"card": "l9rBEq_card",
-			"status": "l9rBEq_status",
 			"description": "l9rBEq_description",
-			"header": "l9rBEq_header",
-			"error": "l9rBEq_error",
-			"select": "l9rBEq_select",
-			"button": "l9rBEq_button",
-			"qr": "l9rBEq_qr",
+			"status": "l9rBEq_status",
+			"headText": "l9rBEq_headText",
+			"name": "l9rBEq_name",
 			"body": "l9rBEq_body",
 			"checkbox": "l9rBEq_checkbox",
-			"label": "l9rBEq_label",
+			"error": "l9rBEq_error",
 			"row": "l9rBEq_row",
-			"chevron": "l9rBEq_chevron"
+			"label": "l9rBEq_label",
+			"chevron": "l9rBEq_chevron",
+			"select": "l9rBEq_select",
+			"qr": "l9rBEq_qr",
+			"header": "l9rBEq_header",
+			"button": "l9rBEq_button"
 		};
 		//#endregion
 		//#region src/client/HappyBridgeCard.tsx

package/lib/index.js

@@ -247,7 +247,8 @@ async function buildSessionMetadata(ctx, source, machineId, title, selection, _g
 		value: name,
 		description: name === "danger-full-access" ? "不限制文件，且不再询问批准" : "只能改当前工作区，危险工具要批准"
 	}));
-	const selected = resolveSelection(models, selection);
+	const selected = resolvePublishedSelection(models, selection);
+	const publishedModels = selected === void 0 || models.some((model) => model.providerId === selected.row.providerId && model.id === selected.row.id) ? models : [selected.row, ...models];
 	const thoughtLevels = selected?.row.effortOptions;
 	const thought = selected === void 0 ? void 0 : selected.effort ?? selected.row.defaultThinkingLevel;
 	return {
@@ -271,7 +272,7 @@ async function buildSessionMetadata(ctx, source, machineId, title, selection, _g
 		happyToolsDir: VIRTUAL_HOME,
 		slashCommands,
 		skills,
-		models,
+		models: publishedModels,
 		operatingModes,
 		client: {
 			id: "rig",
@@ -329,17 +330,47 @@ async function buildSessionMetadata(ctx, source, machineId, title, selection, _g
 		}
 	};
 }
-function resolveSelection(models, selection) {
+/**
+* Pick the Happy catalog row that matches Host selection.
+* A known Host pick that is missing from the listed rows stays that pick
+* (synthetic row) instead of falling back to `models[0]` (usually DeepSeek V4).
+* @param models - rows advertised to the App.
+* @param selection - current Host provider/model/effort, when known.
+* @returns the row to publish, plus effort when the Host named one.
+*/
+function resolvePublishedSelection(models, selection) {
 	if (selection !== void 0) {
 		const row = models.find((model) => model.providerId === selection.provider && model.id === selection.model) ?? models.find((model) => model.code === `${selection.provider}/${selection.model}`);
 		if (row !== void 0) return {
 			row,
 			...selection.reasoningEffort === void 0 ? {} : { effort: selection.reasoningEffort }
 		};
+		return {
+			row: syntheticHappyRow(selection),
+			...selection.reasoningEffort === void 0 ? {} : { effort: selection.reasoningEffort }
+		};
 	}
 	const first = models[0];
 	return first === void 0 ? void 0 : { row: first };
 }
+function syntheticHappyRow(selection) {
+	const effort = selection.reasoningEffort;
+	return {
+		code: `${selection.provider}/${selection.model}`,
+		value: selection.model,
+		id: selection.model,
+		name: selection.model,
+		providerId: selection.provider,
+		providerKind: "custom",
+		providerName: selection.provider,
+		thinkingLevels: effort === void 0 ? [] : [effort],
+		effortOptions: effort === void 0 ? [] : [{
+			code: effort,
+			value: effort
+		}],
+		...effort === void 0 ? {} : { defaultThinkingLevel: effort }
+	};
+}
 function listCommands(ctx, agent) {
 	const commands = ctx.get("commands");
 	if (commands === void 0) return [];
@@ -1105,6 +1136,22 @@ function sameCatalogPick(previous, next) {
 	if (previous === void 0) return false;
 	return catalogPickKey(previous) === catalogPickKey(next);
 }
+/**
+* Whether inbound `meta.model` is the pick we last published.
+* The App often echoes only `currentModelCode` (bare id) on a chat line,
+* while we publish `provider:id`; treating that as a user switch would
+* lock the web composer onto the catalog default (DeepSeek V4).
+* @param published - last pick we wrote, if any.
+* @param inbound - model code from the inbound message.
+* @returns true when the inbound model is our own echo.
+*/
+function isPublishedModelEcho(published, inbound) {
+	if (published?.model === void 0) return false;
+	if (sameCatalogPick({ model: published.model }, { model: inbound })) return true;
+	const publishedSplit = splitModelCode(published.model);
+	const inboundSplit = splitModelCode(inbound);
+	return inboundSplit.provider === "" && inboundSplit.model === publishedSplit.model;
+}
 function catalogPickKey(pick) {
 	const split = pick.model === void 0 ? void 0 : splitModelCode(pick.model);
 	return `${split === void 0 ? "" : split.provider === "" ? split.model : `${split.provider}/${split.model}`}\0${pick.effort === void 0 ? "" : pick.effort === null ? "null" : pick.effort}`;
@@ -1566,9 +1613,10 @@ function wakeModelSelection(primary, ...fallbacks) {
 	};
 }
 /**
-* Effort the first phone-spawn / phone-wake request should send.
+* Effort the first web / phone-spawn / phone-wake request should send.
 * Current pick wins; otherwise a preferred (web) value or the model's
 * advertised default, but only when the model lists that id.
+* Written onto the Host picker via `selectModel`; requests then read that bar.
 * @param currentEffort - already chosen effort, if any.
 * @param preferred - web picker effort to reuse when the model accepts it.
 * @param modelDefault - `resolveModelInfo().reasoning.defaultEffort`.
@@ -1767,6 +1815,18 @@ function mergeCustomAnswers(questions, text, deferred) {
 	});
 }
 /**
+* Translate a web-side harness answer batch into Happy communications answers
+* so the phone card shows the same choice instead of a cancelled form.
+* @param answers - harness answer rows from the web composer.
+* @returns answers keyed by question id.
+*/
+function communicationAnswersFromWeb(answers) {
+	return Object.fromEntries(answers.map((row) => [row.id, {
+		options: row.selected,
+		...row.custom === void 0 || row.custom === "" ? {} : { custom: row.custom }
+	}]));
+}
+/**
 * Translate Happy communications answers (`{ [question id]: { options, custom } }`)
 * into harness answer rows. Options become `selected`; free text becomes `custom`.
 * @param answers - communication RPC answers keyed by question id.
@@ -2761,8 +2821,6 @@ var HappyBridge = class {
 	lastPublished = /* @__PURE__ */ new Map();
 	/** Count of in-flight phone-originated Host `selectModel` calls. */
 	hostSelectFromPhone = 0;
-	/** Per-agent selection installed on phone wake / spawn, matching Host `selectionFor`. */
-	selections = /* @__PURE__ */ new WeakMap();
 	/** In-flight phone wakes, so two inbound texts do not double-resume. */
 	waking = /* @__PURE__ */ new Map();
 	/** Phone stop-session / archive: do not recreate these Happy rows. */
@@ -2773,6 +2831,10 @@ var HappyBridge = class {
 	lastArchivedIds = /* @__PURE__ */ new Set();
 	/** Serialize phone text so two messages cannot split one attachment batch. */
 	inboundTail = /* @__PURE__ */ new Map();
+	/** One Host-picker pin per live Agent, awaited before the first prompt assembly. */
+	hostPin = /* @__PURE__ */ new WeakMap();
+	/** Agents that already prepend the pin onto `system-prompt/assemble`. */
+	assemblePinBound = /* @__PURE__ */ new WeakSet();
 	error;
 	running = false;
 	scanTimer;
@@ -2957,6 +3019,7 @@ var HappyBridge = class {
 				this.wakePhone(existing, true);
 				return;
 			}
+			this.watchFirstAssemble(agent);
 			if (isBlankSession(agent.session.events) && !this.phoneSpawned.has(agent.id)) return;
 			this.mirrorAgent(agent).then(() => {
 				if (this.isHarnessArchived(agent.id)) this.parkPhoneSession(agent.id);
@@ -3034,7 +3097,7 @@ var HappyBridge = class {
 						text: "当前没有已选模型"
 					};
 					if (id === "") {
-						this.rememberModel(invocation.agent, {
+						await this.rememberModel(invocation.agent, {
 							provider: current.provider,
 							model: current.model
 						});
@@ -3043,7 +3106,7 @@ var HappyBridge = class {
 							text: "推理档已恢复为模型默认"
 						};
 					}
-					this.rememberModel(invocation.agent, {
+					await this.rememberModel(invocation.agent, {
 						provider: current.provider,
 						model: current.model,
 						reasoningEffort: ReasoningEffortId(id)
@@ -3198,6 +3261,7 @@ var HappyBridge = class {
 			if (session.header.id !== link.dshId) return;
 			this.onSessionEvent(link, event);
 		}, { global: true });
+		this.watchFirstAssemble(agent);
 	}
 	/** Copy log events newer than {@link Link.lastForwardedSeq} onto Happy. */
 	drainNewEvents(link, agent) {
@@ -3253,14 +3317,15 @@ var HappyBridge = class {
 			resumeSessionId: SessionId(link.dshId),
 			setup
 		});
-		await this.ensurePinnedEffort(handle.agent);
+		await this.watchFirstAssemble(handle.agent);
 		const current = this.links.get(link.dshId);
 		if (current !== void 0) this.attachAgent(current, handle.agent);
 		return handle.agent;
 	}
 	/**
-	* Resume/create composition matching Host `composeAgent`: install model
-	* selection, then mount the preset when a roster exists.
+	* Resume/create composition matching Host `composeAgent`: mount the preset
+	* when a roster exists. Model selection is the Host picker, landed by
+	* `selectModel` in {@link watchFirstAssemble} / {@link rememberModel}.
 	* @param presetHint - logged or requested preset id; omitted uses the roster default.
 	*/
 	async composeAgentSetup(presetHint) {
@@ -3268,71 +3333,9 @@ var HappyBridge = class {
 		let resolvedId;
 		if (presets !== void 0) resolvedId = (await presets.resolve(presetHint)).id;
 		return async (agentCtx) => {
-			this.installWakeSelection(agentCtx);
 			if (presets !== void 0 && resolvedId !== void 0) await presets.mount(agentCtx, resolvedId);
 		};
 	}
-	/**
-	* Same lazy selection Host `selectionFor` installs: remembered pick, else
-	* the session's last `request/header`, else `agentDefaultModel`. A missing
-	* thinking level keeps the web picker's effort when it is the same model.
-	* Unlike Host `installModelSelection`, an absent effort does not clear
-	* inherited thinking.
-	*/
-	installWakeSelection(agentCtx) {
-		const agent = agentCtx.agent;
-		if (agent === void 0) throw new Error("happy-bridge: agent setup has no scoped agent");
-		if (this.selections.has(agent)) return;
-		let picked;
-		const bridge = this;
-		const selection = {
-			get current() {
-				if (picked !== void 0) return picked;
-				return bridge.currentModel(agent);
-			},
-			set current(next) {
-				picked = next;
-			},
-			assembled: void 0
-		};
-		this.bindWakeSelection(agentCtx, selection);
-		this.selections.set(agent, selection);
-		const current = selection.current;
-		if (current === void 0) return;
-		const existing = this.models.get(agent.id);
-		if (existing === void 0 || existing.reasoningEffort === void 0 && current.reasoningEffort !== void 0) this.models.set(agent.id, current);
-	}
-	/**
-	* Pin provider/model for a phone-woken agent without wiping thinking when
-	* the selection names no effort.
-	*/
-	bindWakeSelection(agentCtx, selection) {
-		agentCtx.on("system-prompt/assemble", async (_assembly, _context, next) => {
-			const selected = selection.current;
-			const assembled = await next();
-			selection.assembled = selected;
-			if (selected === void 0) return assembled;
-			return {
-				...assembled,
-				variables: {
-					...assembled.variables,
-					provider: selected.provider,
-					model: selected.model
-				}
-			};
-		});
-		agentCtx.on("agent/request", async (_payload, next) => {
-			const resolved = await next();
-			const selected = selection.assembled;
-			if (selected === void 0) return resolved;
-			return {
-				...resolved,
-				provider: selected.provider,
-				model: selected.model,
-				...selected.reasoningEffort === void 0 ? {} : { reasoningEffort: selected.reasoningEffort }
-			};
-		});
-	}
 	/** Host default model, when the web profile mounted `agentDefaultModel`. */
 	defaultModelSelection() {
 		return this.ctx.get("agentDefaultModel")?.currentSelection();
@@ -3421,7 +3424,7 @@ var HappyBridge = class {
 			onAbort: () => this.onPhoneAbort(agent.id),
 			onArchived: () => this.onPhoneArchive(sessionId, agent.id),
 			onResumed: () => this.onPhoneRestore(agent.id),
-			onCatalog: (meta) => this.applyPhoneCatalog(agent.id, meta),
+			onCatalog: (meta) => this.queuePhoneCatalog(agent.id, meta),
 			log: this.log
 		});
 		try {
@@ -3455,6 +3458,7 @@ var HappyBridge = class {
 		};
 		this.links.set(agent.id, link);
 		this.happyToDsh.set(sessionId, agent.id);
+		await this.watchFirstAssemble(agent);
 		await this.pushMetadata(link);
 		if (seq === 0) await this.replayHistory(link);
 		this.log(`已镜像会话 ${agent.id} → Happy ${sessionId}（seq=${seq}）`);
@@ -3490,7 +3494,7 @@ var HappyBridge = class {
 			onAbort: () => this.onPhoneAbort(dshId),
 			onArchived: () => this.onPhoneArchive(created.id, dshId),
 			onResumed: () => this.onPhoneRestore(dshId),
-			onCatalog: (meta) => this.applyPhoneCatalog(dshId, meta),
+			onCatalog: (meta) => this.queuePhoneCatalog(dshId, meta),
 			log: this.log
 		});
 		try {
@@ -3695,8 +3699,8 @@ var HappyBridge = class {
 			});
 			await (this.ctx.get("workspaceRegistry")?.list().find((item) => item.path === real))?.attachSession(sessionId);
 			this.phoneSpawned.add(handle.agent.id);
-			this.applySpawnMeta(handle.agent, options);
-			await this.ensurePinnedEffort(handle.agent);
+			await this.applySpawnMeta(handle.agent, options);
+			await this.watchFirstAssemble(handle.agent);
 			await this.mirrorAgent(handle.agent, options.sessionId);
 			return {
 				type: "success",
@@ -3709,15 +3713,20 @@ var HappyBridge = class {
 			};
 		}
 	}
-	applySpawnMeta(agent, options) {
-		if (options.modelMode !== void 0) this.applyModel(agent, options.modelMode, options.effortLevel);
-		else if (options.effortLevel !== void 0) this.applyEffort(agent, options.effortLevel);
+	async applySpawnMeta(agent, options) {
+		if (options.modelMode !== void 0) await this.applyModel(agent, options.modelMode, options.effortLevel);
+		else if (options.effortLevel !== void 0) await this.applyEffort(agent, options.effortLevel);
 		if (options.permissionMode !== void 0) this.applyPermission(agent, options.permissionMode, true);
 	}
 	queueInbound(dshId, message) {
 		const next = (this.inboundTail.get(dshId) ?? Promise.resolve()).then(() => this.onInbound(dshId, message), () => this.onInbound(dshId, message));
 		this.inboundTail.set(dshId, next);
 	}
+	/** Same queue as inbound text, so a catalog switch lands on the bar before the next send. */
+	queuePhoneCatalog(dshId, meta) {
+		const next = (this.inboundTail.get(dshId) ?? Promise.resolve()).then(() => this.applyPhoneCatalog(dshId, meta), () => this.applyPhoneCatalog(dshId, meta));
+		this.inboundTail.set(dshId, next);
+	}
 	async onInbound(dshId, message) {
 		const link = this.links.get(dshId);
 		if (link === void 0 || link.replaying) return;
@@ -3767,7 +3776,6 @@ var HappyBridge = class {
 			return;
 		}
 		const { agent } = ensured;
-		await this.ensurePinnedEffort(agent);
 		const names = new Set((this.ctx.get("commands")?.list(agent) ?? []).map((command) => command.name));
 		const kind = classifyInboundText(message.text, names);
 		await this.applyMessageMeta(current, agent, message.meta, kind === "command");
@@ -3789,24 +3797,24 @@ var HappyBridge = class {
 		const effort = messageEffort(meta);
 		const permissionMode = meta.permissionMode;
 		const published = this.lastPublished.get(agent.id);
-		const modelIsEcho = model !== void 0 && published?.model !== void 0 && sameCatalogPick({ model: published.model }, { model });
+		const modelIsEcho = model !== void 0 && isPublishedModelEcho(published, model);
 		const effortIsEcho = effort !== void 0 && published?.effort != null && effort === published.effort;
 		if (model !== void 0 && !modelIsEcho) {
 			if (!grantAtLeast(this.config.remoteGrant, "full")) link.socket.sendText("service", "改模型需要远程档「完整」，这条消息仍会发出。");
-			else this.applyModel(agent, model, typeof effort === "string" ? effort : effort === null ? null : void 0);
+			else await this.applyModel(agent, model, typeof effort === "string" ? effort : effort === null ? null : void 0);
 		} else if ((effort === null || typeof effort === "string") && !effortIsEcho) {
 			if (!grantAtLeast(this.config.remoteGrant, "full")) link.socket.sendText("service", "改思考强度需要远程档「完整」，这条消息仍会发出。");
 			else if (effort === null) {
 				const current = this.currentModel(agent);
-				if (current !== void 0) this.rememberModel(agent, {
+				if (current !== void 0) await this.rememberModel(agent, {
 					provider: current.provider,
 					model: current.model
 				});
-			} else this.applyEffort(agent, effort);
+			} else await this.applyEffort(agent, effort);
 		}
 		if (typeof permissionMode === "string" && permissionMode !== "") this.applyPermission(agent, permissionMode, isCommand);
 	}
-	applyPhoneCatalog(dshId, meta) {
+	async applyPhoneCatalog(dshId, meta) {
 		if (!grantAtLeast(this.config.remoteGrant, "full")) return;
 		const pick = catalogModelPick(meta);
 		if (pick === void 0) return;
@@ -3817,20 +3825,20 @@ var HappyBridge = class {
 		const agent = link === void 0 ? void 0 : this.requireAgent(link);
 		if (agent === void 0) return;
 		if (pick.model !== void 0) {
-			this.applyModel(agent, pick.model, pick.effort);
+			await this.applyModel(agent, pick.model, pick.effort);
 			return;
 		}
 		if (pick.effort === null) {
 			const current = this.currentModel(agent);
-			if (current !== void 0) this.rememberModel(agent, {
+			if (current !== void 0) await this.rememberModel(agent, {
 				provider: current.provider,
 				model: current.model
 			});
 			return;
 		}
-		if (typeof pick.effort === "string") this.applyEffort(agent, pick.effort);
+		if (typeof pick.effort === "string") await this.applyEffort(agent, pick.effort);
 	}
-	applyModel(agent, code, effort) {
+	async applyModel(agent, code, effort) {
 		const split = splitModelCode(code);
 		const current = this.currentModel(agent);
 		const provider = split.provider === "" ? current?.provider ?? "" : split.provider;
@@ -3842,24 +3850,25 @@ var HappyBridge = class {
 			model: split.model,
 			...reasoningEffort === void 0 ? {} : { reasoningEffort }
 		};
-		this.rememberModel(agent, next);
+		await this.rememberModel(agent, next);
 	}
-	applyEffort(agent, effort) {
+	async applyEffort(agent, effort) {
 		const current = this.currentModel(agent);
 		if (current === void 0) return;
-		this.rememberModel(agent, {
+		await this.rememberModel(agent, {
 			...current,
 			reasoningEffort: ReasoningEffortId(effort)
 		});
 	}
-	/** Keep the last Host pick so Happy metadata can echo the web composer. */
-	rememberModel(agent, next) {
-		const previous = this.models.get(agent.id);
+	/**
+	* Remember a phone-originated pick and land it on the Host picker before
+	* the next request. `onHostModelSelected` is skipped while this runs, so
+	* {@link models} is written here.
+	*/
+	async rememberModel(agent, next) {
+		if (sameModelOverride(this.models.get(agent.id), next)) return;
 		this.models.set(agent.id, next);
-		const selection = this.selections.get(agent);
-		if (selection !== void 0) selection.current = next;
-		if (sameModelOverride(previous, next)) return;
-		this.syncHostSelection(agent, next);
+		await this.syncHostSelection(agent, next);
 	}
 	/**
 	* Write the web picker's Host selection (`sessionController.selectModel`) so
@@ -3898,16 +3907,36 @@ var HappyBridge = class {
 		};
 		this.models.set(sessionId, next);
 		const link = this.links.get(sessionId);
-		const agent = link?.agent;
-		if (agent !== void 0) {
-			const current = this.selections.get(agent);
-			if (current !== void 0) current.current = next;
-		}
 		if (link !== void 0 && !link.parked) this.pushMetadata(link);
 	}
 	/**
-	* Put a concrete reasoningEffort on a phone-spawned / phone-woken agent
-	* before the first LLM request, matching the effort Happy metadata advertises.
+	* Land explicit effort on the Host picker and wait for that pin before this
+	* Agent's first prompt assembly, so the request reads the web bar.
+	* @param agent - live agent whose picker should carry explicit effort.
+	*/
+	watchFirstAssemble(agent) {
+		const pending = this.pinHostPicker(agent);
+		if (this.assemblePinBound.has(agent)) return pending;
+		this.assemblePinBound.add(agent);
+		agent.ctx.on("system-prompt/assemble", async (_assembly, _context, next) => {
+			await this.pinHostPicker(agent);
+			return next();
+		}, { prepend: true });
+		return pending;
+	}
+	pinHostPicker(agent) {
+		const existing = this.hostPin.get(agent);
+		if (existing !== void 0) return existing;
+		const pending = this.ensurePinnedEffort(agent);
+		this.hostPin.set(agent, pending);
+		return pending;
+	}
+	/**
+	* Write a concrete reasoningEffort onto the Host picker so the next request
+	* reads the web bar. Always lands via `selectModel`: phone resume/spawn have
+	* no Host interceptor until then, and a live web agent with no conversation
+	* effort would otherwise send the first call without thinking.
+	* @param agent - live agent whose picker should carry explicit effort.
 	*/
 	async ensurePinnedEffort(agent) {
 		const current = this.currentModel(agent);
@@ -3921,14 +3950,13 @@ var HappyBridge = class {
 			if (reasoning?.efforts !== void 0 && reasoning.efforts.length > 0) supported = reasoning.efforts.map((effort) => effort.id);
 		} catch {}
 		const effort = pinWakeEffort(current.reasoningEffort, preferred, modelDefault, supported);
-		if (effort === void 0 || effort === current.reasoningEffort) return;
 		const next = {
-			...current,
-			reasoningEffort: ReasoningEffortId(effort)
+			provider: current.provider,
+			model: current.model,
+			...effort === void 0 ? {} : { reasoningEffort: ReasoningEffortId(effort) }
 		};
 		this.models.set(agent.id, next);
-		const selection = this.selections.get(agent);
-		if (selection !== void 0) selection.current = next;
+		await this.syncHostSelection(agent, next);
 	}
 	applyPermission(agent, mode, fromCommand) {
 		const presets = this.ctx.get("permissionPresets");
@@ -4253,8 +4281,8 @@ var HappyBridge = class {
 			const pending = link.pendingHuman;
 			if (pending !== void 0) {
 				delete link.pendingHuman;
-				if (pending.kind === "ask" && pending.communication !== void 0) this.completeCommunication(link, pending.id, pending.communication, "cancelled");
-				else this.clearRequest(link, pending.id, "canceled", pending.request);
+				if (pending.kind === "ask" && pending.communication !== void 0) this.completeCommunication(link, pending.id, pending.communication, "answered", communicationAnswersFromWeb(answer.answers));
+				else this.clearRequest(link, pending.id, "approved", pending.request);
 				link.socket.sendToolEnd(pending.id);
 			}
 			return answer;

package/lib/types/bridge.d.ts

@@ -18,8 +18,6 @@ export declare class HappyBridge {
     private readonly lastPublished;
     /** Count of in-flight phone-originated Host `selectModel` calls. */
     private hostSelectFromPhone;
-    /** Per-agent selection installed on phone wake / spawn, matching Host `selectionFor`. */
-    private readonly selections;
     /** In-flight phone wakes, so two inbound texts do not double-resume. */
     private readonly waking;
     /** Phone stop-session / archive: do not recreate these Happy rows. */
@@ -30,6 +28,10 @@ export declare class HappyBridge {
     private lastArchivedIds;
     /** Serialize phone text so two messages cannot split one attachment batch. */
     private readonly inboundTail;
+    /** One Host-picker pin per live Agent, awaited before the first prompt assembly. */
+    private readonly hostPin;
+    /** Agents that already prepend the pin onto `system-prompt/assemble`. */
+    private readonly assemblePinBound;
     private error;
     private running;
     private scanTimer;
@@ -98,24 +100,12 @@ export declare class HappyBridge {
     private wakeAgent;
     private resumeSession;
     /**
-     * Resume/create composition matching Host `composeAgent`: install model
-     * selection, then mount the preset when a roster exists.
+     * Resume/create composition matching Host `composeAgent`: mount the preset
+     * when a roster exists. Model selection is the Host picker, landed by
+     * `selectModel` in {@link watchFirstAssemble} / {@link rememberModel}.
      * @param presetHint - logged or requested preset id; omitted uses the roster default.
      */
     private composeAgentSetup;
-    /**
-     * Same lazy selection Host `selectionFor` installs: remembered pick, else
-     * the session's last `request/header`, else `agentDefaultModel`. A missing
-     * thinking level keeps the web picker's effort when it is the same model.
-     * Unlike Host `installModelSelection`, an absent effort does not clear
-     * inherited thinking.
-     */
-    private installWakeSelection;
-    /**
-     * Pin provider/model for a phone-woken agent without wiping thinking when
-     * the selection names no effort.
-     */
-    private bindWakeSelection;
     /** Host default model, when the web profile mounted `agentDefaultModel`. */
     private defaultModelSelection;
     /** Registered workspace for this session, or `undefined` when it is not in the sidebar. */
@@ -161,12 +151,18 @@ export declare class HappyBridge {
     private spawn;
     private applySpawnMeta;
     private queueInbound;
+    /** Same queue as inbound text, so a catalog switch lands on the bar before the next send. */
+    private queuePhoneCatalog;
     private onInbound;
     private applyMessageMeta;
     private applyPhoneCatalog;
     private applyModel;
     private applyEffort;
-    /** Keep the last Host pick so Happy metadata can echo the web composer. */
+    /**
+     * Remember a phone-originated pick and land it on the Host picker before
+     * the next request. `onHostModelSelected` is skipped while this runs, so
+     * {@link models} is written here.
+     */
     private rememberModel;
     /**
      * Write the web picker's Host selection (`sessionController.selectModel`) so
@@ -179,8 +175,18 @@ export declare class HappyBridge {
      */
     private onHostModelSelected;
     /**
-     * Put a concrete reasoningEffort on a phone-spawned / phone-woken agent
-     * before the first LLM request, matching the effort Happy metadata advertises.
+     * Land explicit effort on the Host picker and wait for that pin before this
+     * Agent's first prompt assembly, so the request reads the web bar.
+     * @param agent - live agent whose picker should carry explicit effort.
+     */
+    private watchFirstAssemble;
+    private pinHostPicker;
+    /**
+     * Write a concrete reasoningEffort onto the Host picker so the next request
+     * reads the web bar. Always lands via `selectModel`: phone resume/spawn have
+     * no Host interceptor until then, and a live web agent with no conversation
+     * effort would otherwise send the first call without thinking.
+     * @param agent - live agent whose picker should carry explicit effort.
      */
     private ensurePinnedEffort;
     private applyPermission;

package/lib/types/catalogs.d.ts

@@ -117,4 +117,16 @@ export declare function buildSessionMetadata(ctx: Context, source: {
     }[];
     agent?: Agent;
 }, machineId: string, title: string, selection: HappySelection | undefined, _grant: RemoteGrant): Promise<SessionMetadata>;
+/**
+ * Pick the Happy catalog row that matches Host selection.
+ * A known Host pick that is missing from the listed rows stays that pick
+ * (synthetic row) instead of falling back to `models[0]` (usually DeepSeek V4).
+ * @param models - rows advertised to the App.
+ * @param selection - current Host provider/model/effort, when known.
+ * @returns the row to publish, plus effort when the Host named one.
+ */
+export declare function resolvePublishedSelection(models: HappyModelRow[], selection: HappySelection | undefined): {
+    row: HappyModelRow;
+    effort?: string;
+} | undefined;
 //# sourceMappingURL=catalogs.d.ts.map

package/lib/types/grant.d.ts

@@ -84,4 +84,14 @@ export interface CatalogModelPick {
  * @returns true when the inbound pick is our own echo.
  */
 export declare function sameCatalogPick(previous: CatalogModelPick | undefined, next: CatalogModelPick): boolean;
+/**
+ * Whether inbound `meta.model` is the pick we last published.
+ * The App often echoes only `currentModelCode` (bare id) on a chat line,
+ * while we publish `provider:id`; treating that as a user switch would
+ * lock the web composer onto the catalog default (DeepSeek V4).
+ * @param published - last pick we wrote, if any.
+ * @param inbound - model code from the inbound message.
+ * @returns true when the inbound model is our own echo.
+ */
+export declare function isPublishedModelEcho(published: CatalogModelPick | undefined, inbound: string): boolean;
 //# sourceMappingURL=grant.d.ts.map

package/lib/types/history.d.ts

@@ -155,9 +155,10 @@ export interface WakeModelSelection {
  */
 export declare function wakeModelSelection(primary: WakeModelSelection | undefined, ...fallbacks: Array<WakeModelSelection | undefined>): WakeModelSelection | undefined;
 /**
- * Effort the first phone-spawn / phone-wake request should send.
+ * Effort the first web / phone-spawn / phone-wake request should send.
  * Current pick wins; otherwise a preferred (web) value or the model's
  * advertised default, but only when the model lists that id.
+ * Written onto the Host picker via `selectModel`; requests then read that bar.
  * @param currentEffort - already chosen effort, if any.
  * @param preferred - web picker effort to reuse when the model accepts it.
  * @param modelDefault - `resolveModelInfo().reasoning.defaultEffort`.

package/lib/types/inbound.d.ts

@@ -110,6 +110,20 @@ export declare function mergeCustomAnswers(questions: readonly {
     selected: string[];
     custom?: string;
 }[];
+/**
+ * Translate a web-side harness answer batch into Happy communications answers
+ * so the phone card shows the same choice instead of a cancelled form.
+ * @param answers - harness answer rows from the web composer.
+ * @returns answers keyed by question id.
+ */
+export declare function communicationAnswersFromWeb(answers: readonly {
+    id: string;
+    selected: string[];
+    custom?: string;
+}[]): Record<string, {
+    options: string[];
+    custom?: string;
+}>;
 /**
  * Translate Happy communications answers (`{ [question id]: { options, custom } }`)
  * into harness answer rows. Options become `selected`; free text becomes `custom`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjhmars/happy-bridge",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "Remote-control bridge: pair a running dsh web/desktop client with the Happy mobile app by QR code, then remote-control the same harness sessions from the phone (send messages, read replies, approve tool calls, switch models)",
   "keywords": [
     "deepseek-harness",