dsh-lark-agent 0.1.2 → 0.3.0

package/dist/bridge.js

@@ -1,4 +1,6 @@
-import { createHash } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
+import { realpath, stat } from 'node:fs/promises';
+import { basename, isAbsolute, relative, sep } from 'node:path';
 import { DshRuntimeError } from './dsh-runtime.js';
 import { authorize, chunksByBytes, ownerKey, parseMessage, sessionKey } from './message.js';
 import { MemoryStoreError } from './memory-store.js';
@@ -10,14 +12,72 @@ import { modelChoice, thinkingChoice, modelControlPanel, modelStateText, sameSel
 import { botMenuCommand, BOT_MENU_EVENT } from './bot-menu.js';
 import { CommandFeedback } from './command-feedback.js';
 import { PresentationError, presentationDraft, presentationCard, presentationText } from './presentation.js';
+import { LiveReply } from './live-reply.js';
+import { answeredText, approvalCard, questionAnswers, questionCard, simpleQuestion } from './interaction-cards.js';
+import { permissionPanel, permissionStateText } from './permission-controls.js';
 class ArtifactDeliveryError extends Error {
 }
+const APPROVAL_TIMEOUT_MS = 5 * 60_000;
+const QUESTION_TIMEOUT_MS = 10 * 60_000;
+// After a live card cannot be created (for example, before the CardKit scope is
+// granted), use ordinary replies for a while instead of failing every turn.
+const LIVE_RETRY_MS = 10 * 60_000;
+const MAX_FILE_BYTES = 30 * 1024 * 1024;
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+const TIMEOUT_TEXT = '本次处理超时，已请求取消。请缩小问题范围后重试。';
+const STOPPING_TEXT = '连接正在关闭，本次处理已停止。';
+// Clicks on these panels update the clicked card itself; anything else answers with a new message.
+const IN_PLACE = /^\/(?:(?:model|thinking)(?: (?:use [a-f0-9]{16}|page [0-9]{1,4}))?|permission(?: use [a-z][a-z0-9-]{0,39})?|sessions|new|resume [a-f0-9]{12})$/;
+// A switch that finishes sooner goes straight to its result, without a loading frame.
+const PANEL_PROGRESS_DELAY_MS = 150;
+const STALE_SETTINGS = '设置刚刚变化，已刷新为最新选项，请重新选择。';
+/** The card's model settings changed after it was drawn, so its choice is not applied. */
+class StaleCardError extends Error {
+    constructor() { super('模型设置已变化，请重新打开模型或思考深度菜单后操作。'); }
+}
+function commandError(error) {
+    return error instanceof DshRuntimeError || error instanceof MemoryStoreError || error instanceof SessionStoreError
+        || error instanceof ModelPreferencesError || error instanceof StaleCardError
+        ? error.message : '操作未完成，请稍后重试；尚未确认保存成功。';
+}
+/** Only a regular file inside the user's own workspace is uploaded; anything else is just named. */
+async function uploadable(workspace, path) {
+    let real;
+    try {
+        real = await realpath(path);
+    }
+    catch {
+        return { reason: '找不到这个文件' };
+    }
+    const inside = relative(workspace, real);
+    if (!inside || inside === '..' || inside.startsWith('..' + sep) || isAbsolute(inside))
+        return { reason: '不在这个私聊的工作区内，没有上传' };
+    let info;
+    try {
+        info = await stat(real);
+    }
+    catch {
+        return { reason: '无法读取' };
+    }
+    if (!info.isFile())
+        return { reason: '不是普通文件' };
+    if (info.size === 0)
+        return { reason: '是空文件' };
+    if (info.size > MAX_FILE_BYTES)
+        return { reason: '超过飞书 30 MB 的文件上限' };
+    if (/[\u0000-\u001f\u007f]/.test(basename(real)))
+        return { reason: '文件名含有无法发送的字符' };
+    return { path: real, image: /\.(?:png|jpe?g|gif|webp)$/i.test(real) && info.size <= MAX_IMAGE_BYTES };
+}
 const HELP = `直接把想做的事告诉我就好。
 
 比如：帮我理清一个问题、整理一段文字，或者接着刚才的话题继续。你也可以在私聊告诉我，以后希望我怎样配合你。
 
 私聊底部菜单可以新建话题、找历史对话，或调整模型和思考深度。
 也可以发 /new 换话题、/sessions 找对话、/model 看模型、/thinking 调深度、/stop 停下来。`;
+const HARNESS_HELP = `
+
+这里连着你电脑上的 Harness：可以让我查资料、读网页、处理工作区里的文件，回复会实时显示，思考过程折叠在卡片里；需要你确认的操作，我会先发卡片问你。发 /permission（或点底部菜单 设置 → 权限模式）可以切换权限，比如改成不再询问的「完全权限」。模型、思考深度和权限模式与电脑上的 Harness 同步。`;
 const ADVANCED_HELP = `高级命令（按需使用）：
 /new 或 /reset：归档当前会话，下一条消息开启新会话；长期记忆保留
 /sessions：选择以前的对话；/sessions detail 查看完整列表和 ID
@@ -27,6 +87,7 @@ const ADVANCED_HELP = `高级命令（按需使用）：
 /stop：停止当前处理并取消排队消息
 /results：查看当前话题的作品；/result <ID>：查看内容；/publish <ID>：在本人私聊生成飞书文档或画板
 /model：查看当前模型并选择；/thinking：选择当前模型支持的思考深度
+/permission：本人私聊切换 Harness 权限模式（如仅可查看、工作区内修改、完全权限）
 /remember <内容>：私聊保存私密个人记忆；群聊仅保存当前聊天记忆
 /remember --chat <内容>：只在当前聊天／话题保存记忆
 /memory：列出可用记忆（最多 20 条）
@@ -86,6 +147,8 @@ export class BotBridge {
     failedDisposals = new Set();
     cardActionsReady = false;
     progress;
+    interactions = new Map();
+    liveUnavailableUntil = 0;
     constructor(config, runtime, transport, ledger, state, audit = () => undefined, progressTransport, artifactPublisher) {
         this.config = config;
         this.runtime = runtime;
@@ -125,7 +188,7 @@ export class BotBridge {
             return;
         }
         let formValues;
-        if (binding.command.startsWith('/answer ')) {
+        if (binding.command.startsWith('/answer ') || binding.command.startsWith('/reply ')) {
             if (data.action_name !== 'dsh_submit' || typeof data.form_value !== 'string' || data.form_value.length > 8000)
                 return;
             try {
@@ -137,7 +200,7 @@ export class BotBridge {
             if (!formValues || typeof formValues !== 'object' || Array.isArray(formValues))
                 return;
         }
-        const mutation = /^\/(?:(?:new|resume|forget|answer)(?: |$)|(?:model|thinking) use )/.test(binding.command);
+        const mutation = /^\/(?:(?:new|resume|forget|answer)(?: |$)|(?:model|thinking|permission) use )/.test(binding.command);
         return { messageId: data.message_id, senderId: binding.ownerId, chatId: binding.chatId,
             chatType: binding.chatType, threadId: binding.threadId, text: binding.command,
             requestId: `card:${data.event_id}`, actionNonce: mutation ? binding.nonce : undefined,
@@ -201,6 +264,12 @@ export class BotBridge {
                 return;
             if (!message.menu && message.chatType === 'p2p')
                 await this.state.directChats?.record(message.senderId, message.chatId);
+            // A running turn holds its queue while it waits for its approval or
+            // question, so those answers must not queue behind it.
+            if (message.requestId?.startsWith('card:') && /^\/(?:approve|deny|choose|reply) /.test(message.text)) {
+                await this.answerInteraction(message);
+                return;
+            }
             const key = sessionKey(message, this.config);
             let lane = this.lanes.get(key);
             if (message.text === '/stop') {
@@ -228,7 +297,7 @@ export class BotBridge {
             const generation = lane.generation;
             current.pending++;
             this.pending++;
-            const finishProgress = message.menu ? () => undefined : this.progress.begin(message.messageId);
+            const finishProgress = message.menu || this.streams(message, user) ? () => undefined : this.progress.begin(message.messageId);
             const acceptedAt = Date.now();
             const job = current.tail.then(async () => {
                 if (this.stopped || generation !== current.generation)
@@ -276,16 +345,27 @@ export class BotBridge {
         if (this.state.modelPreferences && this.runtime.catalog && isModelQuestion(message.text))
             message.text = '/model current';
         let text = message.text;
+        const inPlace = this.inPlace(message);
+        // A stale card is redrawn with the current state instead of answered with another message.
         if (message.expectedSessionId !== undefined) {
             const current = await this.state.sessions.current(this.sessionContext(message));
             if ((current?.id ?? null) !== message.expectedSessionId) {
+                if (inPlace)
+                    return this.refreshPanel(message, lane, '话题刚刚变化，已刷新为最新状态，请重新选择。');
                 return this.reply(message, '这张卡片对应的会话状态已改变，请重新发送 /status 或 /sessions 后操作。');
             }
         }
         if (message.expectedModelRevision !== undefined) {
+            // A shared session may have been switched in the App after this card was drawn.
+            if (lane.session?.sharesModelSelection && !lane.unavailable) {
+                await this.mirrorModel(message, lane.session, await this.state.modelPreferences?.get(this.context(message)));
+            }
             const current = await this.state.modelPreferences?.get(this.context(message));
-            if ((current?.revision ?? null) !== message.expectedModelRevision)
-                return this.reply(message, '模型设置已变化，请重新打开模型或思考深度菜单后操作。');
+            if ((current?.revision ?? null) !== message.expectedModelRevision) {
+                if (inPlace)
+                    return this.refreshPanel(message, lane, STALE_SETTINGS);
+                return this.reply(message, new StaleCardError().message);
+            }
         }
         if (this.state.artifacts && (/^\/(?:result|publish|answer) [a-f0-9]{12}$/.test(text) || text === '/results')) {
             try {
@@ -326,6 +406,8 @@ export class BotBridge {
             }
         }
         if (text.startsWith('/')) {
+            if (inPlace)
+                return this.panelInPlace(message, lane);
             const feedback = this.commandFeedback(message);
             let response;
             let panel;
@@ -337,8 +419,7 @@ export class BotBridge {
             }
             catch (error) {
                 failed = true;
-                response = error instanceof DshRuntimeError || error instanceof MemoryStoreError || error instanceof SessionStoreError || error instanceof ModelPreferencesError
-                    ? error.message : '操作未完成，请稍后重试；尚未确认保存成功。';
+                response = commandError(error);
                 this.audit({ stage: 'command-failed', messageId: message.messageId });
             }
             const payload = panel ? renderPanel(panel) : renderPanel({ title: failed ? '暂时未完成' : '已处理',
@@ -354,48 +435,92 @@ export class BotBridge {
         lane.controller = controller;
         let timedOut = false;
         const timer = setTimeout(() => { timedOut = true; controller.abort(); }, this.config.turnTimeoutMs);
+        const harness = message.chatType === 'p2p' && lane.user.directMode === 'harness';
+        let live;
+        // Once a live card exists it carries this turn's whole outcome; nothing else is sent as text.
+        const conclude = async (final) => {
+            const card = live;
+            live = undefined;
+            if (!await card.finish(final))
+                this.audit({ stage: 'live-card-unconfirmed', messageId: message.messageId });
+        };
         try {
             await this.ensureSession(message, lane);
             if (controller.signal.aborted) {
                 if (timedOut)
-                    await this.reply(message, '本次处理超时，已请求取消。请缩小问题范围后重试。');
+                    await this.reply(message, TIMEOUT_TEXT);
                 return;
             }
             const context = this.context(message);
             const memoryText = promptMemories(await this.state.memories.list(context));
             const artifactsText = this.state.artifacts && lane.saved ? JSON.stringify((await this.state.artifacts.list(this.artifactContext(message, lane.saved.id)))
                 .map(row => ({ id: row.id, title: row.draft.title, kind: row.draft.kind }))) : undefined;
-            const result = await lane.session.run(text, controller.signal, { memoryText, ...(artifactsText ? { artifactsText } : {}) });
+            if (this.streams(message, lane.user)) {
+                const candidate = new LiveReply(this.liveTransport(), { messageId: message.messageId, inThread: Boolean(message.threadId),
+                    idempotencyKey: createHash('sha256').update(JSON.stringify([this.config.botOpenId, message.requestId ?? message.messageId, 'live'])).digest('hex').slice(0, 48) }, { audit: stage => this.audit({ stage, messageId: message.messageId }) });
+                if (await candidate.open()) {
+                    live = candidate;
+                    // Under the answer: what this reply runs with. Names may wait for the model catalog.
+                    void this.settingsLine(lane).then(line => { if (line)
+                        candidate.setFooter(line); }, () => undefined);
+                }
+                else
+                    this.liveUnavailableUntil = Date.now() + LIVE_RETRY_MS;
+            }
+            const turnContext = { memoryText, ...(artifactsText ? { artifactsText } : {}) };
+            // Only the owner's harness-mode chat can be asked anything; a restricted session gets no hooks at all.
+            const observer = live || harness ? {
+                ...(live ? { stream: (event) => live?.push(event) } : {}),
+                ...(harness ? { approve: (prompt, signal) => this.approve(message, prompt, signal),
+                    ask: (questions, signal) => this.ask(message, questions, signal) } : {}),
+            } : undefined;
+            const result = await (observer ? lane.session.run(text, controller.signal, turnContext, observer)
+                : lane.session.run(text, controller.signal, turnContext));
             // Native conversation data must be durable before acknowledging a turn.
             await lane.session.checkpoint();
             await this.state.sessions.touch(this.sessionContext(message), lane.saved.id);
             clearTimeout(timer);
             if (controller.signal.aborted || this.stopped) {
-                if (timedOut && !this.stopped)
-                    await this.reply(message, '本次处理超时，已请求取消。请缩小问题范围后重试。');
+                if (live)
+                    await conclude({ phase: 'stopped', note: timedOut ? TIMEOUT_TEXT : this.stopped ? STOPPING_TEXT : '已停止。' });
+                else if (timedOut && !this.stopped)
+                    await this.reply(message, TIMEOUT_TEXT);
                 return;
             }
             const answer = typeof result === 'string' ? result : result.text;
             const artifacts = typeof result === 'string' ? [] : result.artifacts;
+            const files = typeof result === 'string' ? [] : result.files ?? [];
             const bounded = Array.from(answer).slice(0, this.config.maxOutputChars).join('');
+            const truncated = bounded.length < answer.length;
             // The answer is already in native history. Send it before artifact work
             // that can fail, so a storage limit cannot swallow a complete reply.
-            if (bounded || !artifacts.length)
-                await this.reply(message, bounded ? bounded + (bounded.length < answer.length ? '\n\n（回复已截断）' : '') : 'dsh 本次没有返回文本。', controller.signal);
+            if (live)
+                await conclude({ phase: 'done', answer: bounded || (artifacts.length || files.length ? '已整理好，见下方。' : 'dsh 本次没有返回文本。'),
+                    ...(typeof result !== 'string' && result.reasoning ? { reasoning: result.reasoning } : {}), ...(truncated ? { note: '回复已截断。' } : {}) });
+            else if (bounded || !artifacts.length)
+                await this.reply(message, bounded ? bounded + (truncated ? '\n\n（回复已截断）' : '') : 'dsh 本次没有返回文本。', controller.signal);
             await this.presentArtifacts(message, lane, artifacts, controller.signal);
+            await this.deliverFiles(message, lane, files, controller.signal);
             this.audit({ stage: 'replied', messageId: message.messageId });
         }
         catch (error) {
             clearTimeout(timer);
             if (error instanceof ArtifactDeliveryError)
                 throw error;
+            const known = error instanceof DshRuntimeError || error instanceof MemoryStoreError || error instanceof SessionStoreError || error instanceof ModelPreferencesError || error instanceof PresentationError;
+            if (live) {
+                const stopped = timedOut || controller.signal.aborted || this.stopped;
+                await conclude({ phase: stopped ? 'stopped' : 'failed', note: timedOut ? TIMEOUT_TEXT : this.stopped ? STOPPING_TEXT
+                        : controller.signal.aborted ? '已停止。' : known ? error.message : '处理没有完成，请稍后重试。' }).catch(() => undefined);
+                return;
+            }
             if (this.stopped)
                 return;
             if (timedOut)
-                await this.reply(message, '本次处理超时，已请求取消。请缩小问题范围后重试。');
+                await this.reply(message, TIMEOUT_TEXT);
             else if (!controller.signal.aborted) {
                 // Transport failures may have delivered partial output. Do not send an extra ambiguous retry.
-                if (error instanceof DshRuntimeError || error instanceof MemoryStoreError || error instanceof SessionStoreError || error instanceof ModelPreferencesError || error instanceof PresentationError)
+                if (known)
                     await this.reply(message, error.message);
                 else
                     this.audit({ stage: 'delivery-or-runtime-failed', messageId: message.messageId });
@@ -406,6 +531,242 @@ export class BotBridge {
             lane.controller = undefined;
         }
     }
+    /** The model, thinking depth and permission mode a reply runs with, by name. */
+    async settingsLine(lane) {
+        const session = lane.session;
+        const selection = session?.modelSelection?.();
+        if (!session || !selection)
+            return;
+        const catalog = await this.runtime.catalog?.().catch(() => undefined);
+        const model = catalog?.models.find(item => item.provider === selection.provider && item.model === selection.model);
+        const efforts = model?.reasoning?.efforts ?? [];
+        const effort = selection.reasoningEffort ? efforts.find(item => item.id === selection.reasoningEffort)?.name ?? selection.reasoningEffort
+            : efforts.length ? '模型默认' : undefined;
+        const permission = session.permissionState?.();
+        const preset = permission && (permission.options.find(option => option.id === permission.current)?.name ?? (permission.current === 'custom' ? '自定义' : permission.current));
+        return [model?.name ?? selection.model, effort && `思考深度 ${effort}`, preset && `权限 ${preset}`].filter(Boolean).join(' · ');
+    }
+    /** Whether this message's reply streams into a live card, which makes the typing reaction redundant. */
+    streams(message, user) {
+        return message.chatType === 'p2p' && user.directMode === 'harness' && this.config.streamingCards && this.config.responseMode !== 'text'
+            && !message.text.startsWith('/') && Date.now() >= this.liveUnavailableUntil && this.liveTransport() !== undefined;
+    }
+    liveTransport() {
+        const transport = this.transport;
+        return transport.createCardEntity && transport.replyCardEntity && transport.streamCardText && transport.updateCardEntity
+            ? transport : undefined;
+    }
+    canInteract(message) {
+        return message.chatType === 'p2p' && !this.stopped && this.cardActionsReady && this.config.cardInteractions && this.config.responseMode !== 'text'
+            && Boolean(this.state.actions && this.transport.createFeedback && this.transport.updateFeedback);
+    }
+    issueAction(message, command) {
+        return this.state.actions.issue({ ownerId: message.senderId, chatId: message.chatId, chatType: message.chatType,
+            threadId: message.threadId, sourceMessageId: message.messageId, command });
+    }
+    /** Ask the owner about one Harness approval. Anything but an explicit allow denies the call. */
+    async approve(message, prompt, signal) {
+        if (!this.canInteract(message) || signal.aborted)
+            return false;
+        const id = randomBytes(6).toString('hex');
+        // Register before the card exists, so even an immediate click finds it.
+        const pending = this.waitForAnswer(id, message, answer => answer.verb === 'approve' ? true : answer.verb === 'deny' ? false : undefined, signal, APPROVAL_TIMEOUT_MS);
+        const card = await this.openInteraction(message, id, approvalCard(prompt, { allow: this.issueAction(message, `/approve ${id}`),
+            deny: this.issueAction(message, `/deny ${id}`) }));
+        if (!card) {
+            pending.cancel();
+            return false;
+        }
+        const outcome = await pending.result;
+        const allowed = outcome.kind === 'answer' && outcome.value;
+        await this.closeInteraction(card, approvalCard(prompt, undefined, outcome.kind === 'answer'
+            ? (allowed ? { text: '已允许这一次。', tone: 'success' } : { text: '已拒绝，这次不会执行。', tone: 'error' })
+            : { text: outcome.kind === 'timeout' ? '5 分钟内没有确认，已按拒绝处理。' : '本次处理已停止，没有执行。', tone: 'muted' }));
+        return allowed;
+    }
+    /** Ask the owner a Harness question. Without an answer the host gets an error and continues. */
+    async ask(message, questions, signal) {
+        const unavailable = '这里无法用卡片提问。请把问题写在回复里，由主人直接回答。';
+        if (!this.canInteract(message))
+            throw new Error(unavailable);
+        const id = randomBytes(6).toString('hex');
+        const first = questions[0];
+        const tokens = simpleQuestion(questions)
+            ? { choose: Array.from({ length: first.options.length + 1 }, (_unused, index) => this.issueAction(message, `/choose ${id} ${index}`)) }
+            : { reply: this.issueAction(message, `/reply ${id}`) };
+        const pending = this.waitForAnswer(id, message, answer => questionAnswers(questions, answer), signal, QUESTION_TIMEOUT_MS);
+        const card = await this.openInteraction(message, id, questionCard(questions, tokens));
+        if (!card) {
+            pending.cancel();
+            throw new Error(unavailable);
+        }
+        const outcome = await pending.result;
+        await this.closeInteraction(card, questionCard(questions, undefined, outcome.kind === 'answer' ? { text: answeredText(questions, outcome.value), tone: 'success' }
+            : { text: outcome.kind === 'timeout' ? '10 分钟内没有回答，已按未回答继续。' : '本次处理已停止，提问已关闭。', tone: 'muted' }));
+        if (outcome.kind !== 'answer')
+            throw new Error(outcome.kind === 'timeout' ? '主人没有在 10 分钟内回答。' : '提问已取消。');
+        return outcome.value;
+    }
+    waitForAnswer(id, message, parse, signal, timeoutMs) {
+        let finish;
+        const result = new Promise(resolve => {
+            let done = false;
+            const timer = setTimeout(() => finish({ kind: 'timeout' }), timeoutMs);
+            const onAbort = () => finish({ kind: 'cancelled' });
+            const entry = { ownerId: message.senderId, chatId: message.chatId, stop: onAbort,
+                settle: answer => {
+                    const value = parse(answer);
+                    if (value === undefined || done)
+                        return false;
+                    finish({ kind: 'answer', value });
+                    return true;
+                } };
+            finish = outcome => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                signal.removeEventListener('abort', onAbort);
+                if (this.interactions.get(id) === entry)
+                    this.interactions.delete(id);
+                resolve(outcome);
+            };
+            this.interactions.set(id, entry);
+            signal.addEventListener('abort', onAbort, { once: true });
+            if (signal.aborted)
+                onAbort();
+        });
+        return { result, cancel: () => finish({ kind: 'cancelled' }) };
+    }
+    async openInteraction(message, id, payload) {
+        if (payload.kind !== 'card' || this.stopped)
+            return;
+        const idempotencyKey = createHash('sha256').update(JSON.stringify([this.config.botOpenId, message.requestId ?? message.messageId, 'interaction', id]))
+            .digest('hex').slice(0, 48);
+        try {
+            return await this.transport.createFeedback({ messageId: message.messageId, inThread: Boolean(message.threadId) }, payload, { idempotencyKey });
+        }
+        catch {
+            this.audit({ stage: 'interaction-card-failed', messageId: message.messageId });
+            return;
+        }
+    }
+    async closeInteraction(messageId, payload) {
+        if (payload.kind !== 'card')
+            return;
+        try {
+            await this.transport.updateFeedback(messageId, payload);
+        }
+        catch {
+            this.audit({ stage: 'interaction-update-failed', messageId });
+        }
+    }
+    async answerInteraction(message) {
+        const match = /^\/(approve|deny|choose|reply) ([a-f0-9]{12})(?: ([0-9]{1,2}))?$/.exec(message.text);
+        const pending = match ? this.interactions.get(match[2]) : undefined;
+        if (!match || !pending || pending.ownerId !== message.senderId || pending.chatId !== message.chatId) {
+            await this.reply(message, '这张卡片已经失效。需要的话，直接在聊天里告诉我。');
+            return;
+        }
+        if (!pending.settle({ verb: match[1], ...(match[3] === undefined ? {} : { index: Number(match[3]) }),
+            ...(message.formValues === undefined ? {} : { formValues: message.formValues }) }))
+            await this.reply(message, '这次选择无效，请在卡片上重新选择后提交。');
+    }
+    /** Send files the host's delivery tool presented, from this user's workspace only. */
+    async deliverFiles(message, lane, files, signal) {
+        if (!files.length || signal.aborted || this.stopped)
+            return;
+        const workspace = await realpath(lane.user.cwd).catch(() => undefined);
+        const notes = [];
+        for (const [index, file] of files.entries()) {
+            if (signal.aborted || this.stopped)
+                return;
+            const name = basename(file.path);
+            const checked = workspace && this.transport.replyFile ? await uploadable(workspace, file.path) : { reason: '这个连接不能发送文件' };
+            if ('reason' in checked) {
+                notes.push(`${name}：${checked.reason}（电脑上的位置：${file.path}）`);
+                continue;
+            }
+            const idempotencyKey = createHash('sha256').update(JSON.stringify([this.config.botOpenId, message.requestId ?? message.messageId, 'file', index, checked.path]))
+                .digest('hex').slice(0, 48);
+            try {
+                await this.transport.replyFile(message.messageId, checked.path, { idempotencyKey, inThread: Boolean(message.threadId), image: checked.image });
+                this.audit({ stage: 'file-sent', messageId: message.messageId });
+            }
+            catch {
+                // The upload may still have arrived. Name it instead of sending again.
+                notes.push(`${name}：发送结果没有确认，请在电脑上查看 ${file.path}`);
+                this.audit({ stage: 'file-send-unknown', messageId: message.messageId });
+            }
+        }
+        if (notes.length)
+            await this.reply(message, `有 ${notes.length} 个文件没有发到这里：\n${notes.join('\n')}`, signal);
+    }
+    /** A private-chat click on a settings or topic panel, which can update the clicked card. */
+    inPlace(message) {
+        return message.chatType === 'p2p' && Boolean(message.requestId?.startsWith('card:')) && this.config.responseMode !== 'text'
+            && Boolean(this.transport.updateFeedback) && IN_PLACE.test(message.text);
+    }
+    /**
+     * Run a panel click and show its progress and result on the clicked card. That
+     * card exists, so a failed progress frame never holds back the result, and an
+     * unconfirmed update is never followed by another message.
+     */
+    async panelInPlace(message, lane) {
+        const target = message.messageId;
+        const mutation = /^\/(?:(?:model|thinking|permission) use |resume |new$)/.test(message.text);
+        const progress = mutation ? await this.commandPanel(message, lane, { pending: true }).catch(() => undefined) : undefined;
+        const feedback = new CommandFeedback(async () => {
+            if (progress && !this.stopped) {
+                try {
+                    await this.transport.updateFeedback(target, renderPanel(progress));
+                }
+                catch {
+                    this.audit({ stage: 'panel-progress-failed', messageId: target });
+                }
+            }
+            return target;
+        }, (_id, payload) => this.transport.updateFeedback(target, payload), PANEL_PROGRESS_DELAY_MS);
+        let panel, response, failed = false;
+        try {
+            response = await this.command(message, lane);
+            panel = await this.commandPanel(message, lane);
+        }
+        catch (error) {
+            // A card that went stale while it ran is refreshed, not reported as a failure.
+            const stale = error instanceof StaleCardError;
+            failed = !stale;
+            response = stale ? STALE_SETTINGS : commandError(error);
+            if (failed)
+                this.audit({ stage: 'command-failed', messageId: message.messageId });
+            panel = await this.commandPanel(message, lane, stale ? { notice: response } : { error: response }).catch(() => undefined);
+            if (stale && !panel)
+                panel = { title: '卡片已过期', tone: 'muted', status: { text: response, tone: 'muted' }, summary: response, sections: [] };
+        }
+        const payload = renderPanel(this.stopped ? { title: '连接正在关闭', tone: 'muted', summary: '连接恢复后可重新打开设置，已保存的选择保留',
+            sections: [{ text: '连接恢复后可重新打开菜单。已保存的选择会保留。' }] }
+            : panel ?? { title: failed ? '暂时未完成' : '已处理', tone: failed ? 'error' : 'success', status: { text: response, tone: failed ? 'error' : 'success' },
+                summary: response, sections: [] });
+        try {
+            await feedback.finish(payload, () => this.transport.updateFeedback(target, payload));
+            this.audit({ stage: 'panel-updated', messageId: target });
+        }
+        catch {
+            this.audit({ stage: 'panel-update-failed', messageId: target });
+        }
+    }
+    /** Redraw a stale card with the current state, without running its command. */
+    async refreshPanel(message, lane, notice) {
+        const panel = await this.commandPanel(message, lane, { notice }).catch(() => undefined);
+        const payload = renderPanel(panel ?? { title: '卡片已过期', tone: 'muted', status: { text: notice, tone: 'muted' }, summary: notice, sections: [] });
+        try {
+            await this.transport.updateFeedback(message.messageId, payload);
+            this.audit({ stage: 'panel-refreshed', messageId: message.messageId });
+        }
+        catch {
+            this.audit({ stage: 'panel-update-failed', messageId: message.messageId });
+        }
+    }
     commandFeedback(message) {
         // Private controls contain no model-generated output. Group replies retain
         // their existing authorization gate and native typing reaction.
@@ -456,6 +817,7 @@ export class BotBridge {
         const context = this.context(message);
         return {
             cwd: lane.user.cwd, allowedTools: lane.user.allowedTools,
+            mode: message.chatType === 'p2p' && lane.user.directMode === 'harness' ? 'harness' : 'restricted',
             provider: this.config.provider, model: this.config.model,
             presentation: Boolean(this.state.artifacts),
             ...selection,
@@ -482,25 +844,29 @@ export class BotBridge {
         if (lane.unavailable)
             await this.unload(lane);
         if (lane.session) {
-            if (modelPreference && lane.session.modelSelection && !sameSelection(lane.session.modelSelection(), modelPreference.selection)) {
+            // A session that shares its model with the App follows its own record instead of the chat's copy.
+            if (!lane.session.sharesModelSelection && modelPreference && lane.session.modelSelection && !sameSelection(lane.session.modelSelection(), modelPreference.selection)) {
                 if (lane.session.setModelSelection)
                     lane.session.setModelSelection(modelPreference.selection);
                 else
                     await this.unload(lane);
             }
-            if (lane.session)
+            if (lane.session) {
+                await this.adoptPermission(lane);
                 return;
+            }
         }
         const context = this.sessionContext(message);
         const saved = await this.state.sessions.current(context);
+        // Like the App: a shared session starts on the host default and resumes on its own record.
+        const selection = this.sharedModel(message, lane) ? undefined : modelPreference?.selection;
         const handle = saved
-            ? await this.runtime.resume(this.policy(message, lane, modelPreference?.selection), saved.nativeId)
-            : await this.runtime.create(this.policy(message, lane, modelPreference?.selection));
+            ? await this.runtime.resume(this.policy(message, lane, selection), saved.nativeId)
+            : await this.runtime.create(this.policy(message, lane, selection));
         try {
             await handle.checkpoint();
-            if (!modelPreference && handle.modelSelection && this.state.modelPreferences) {
-                await this.state.modelPreferences.set(this.context(message), handle.modelSelection(), { expectedRevision: null });
-            }
+            await this.applyPermission(message, lane, handle, !saved);
+            await this.mirrorModel(message, handle, modelPreference);
             // Publish a route only after even the empty native log is durable, and
             // before submitting the first prompt. An abandoned creation has no work.
             lane.saved = saved ? await this.bindRestoredSession(context, saved, handle)
@@ -529,6 +895,8 @@ export class BotBridge {
             lane.unavailable = false;
             return;
         }
+        // Keep a preset changed in the App before this session goes away (/new, /resume, idle sweep).
+        await this.adoptPermission(lane).catch(() => this.audit({ stage: 'permission-adopt-failed' }));
         lane.unavailable = true;
         try {
             await handle.dispose();
@@ -550,9 +918,12 @@ export class BotBridge {
         const context = this.context(message);
         const conversation = this.sessionContext(message);
         if (command === 'help')
-            return args === 'advanced' ? ADVANCED_HELP : HELP;
+            return args === 'advanced' ? ADVANCED_HELP
+                : HELP + (message.chatType === 'p2p' && lane.user.directMode === 'harness' ? HARNESS_HELP : '');
         if (command === 'model' || command === 'thinking')
             return this.modelCommand(message, lane, command, args);
+        if (command === 'permission')
+            return this.permissionCommand(message, lane, args);
         if (command === 'whoami')
             return `用户：${message.senderId}\n聊天：${message.chatId}\n范围：${message.chatType === 'p2p' ? '私聊' : '群聊'}${message.threadId ? '／独立话题' : ''}\n身份由飞书验证。个人记忆默认仅本人私聊可读，群聊仅可用本人明确授权的条目。`;
         if (command === 'status') {
@@ -600,11 +971,11 @@ export class BotBridge {
                 return `已经在会话「${target.title}」中。`;
             await this.unload(lane);
             const preference = await this.state.modelPreferences?.get(context);
-            const handle = await this.runtime.resume(this.policy(message, lane, preference?.selection), target.nativeId);
+            const handle = await this.runtime.resume(this.policy(message, lane, this.sharedModel(message, lane) ? undefined : preference?.selection), target.nativeId);
             try {
                 await handle.checkpoint();
-                if (!preference && handle.modelSelection && this.state.modelPreferences)
-                    await this.state.modelPreferences.set(context, handle.modelSelection(), { expectedRevision: null });
+                await this.applyPermission(message, lane, handle, false);
+                await this.mirrorModel(message, handle, preference);
                 await this.bindRestoredSession(conversation, target, handle);
                 lane.saved = await this.state.sessions.activate(conversation, target.id);
                 lane.session = handle;
@@ -672,6 +1043,91 @@ export class BotBridge {
         }
         return '未知命令。发送 /help 查看可用命令。';
     }
+    harness(message, lane) {
+        return message.chatType === 'p2p' && lane.user.directMode === 'harness';
+    }
+    /**
+     * The owner's harness chat on the App host shares model and thinking depth
+     * with the App, like any App session; an administrator's fixed route does not.
+     */
+    sharedModel(message, lane) {
+        return this.harness(message, lane) && Boolean(this.runtime.sharesModelSelection?.()) && !(this.config.provider && this.config.model);
+    }
+    /** Record what an opened session runs as the chat's copy: the first capture, or a shared session's own record. */
+    async mirrorModel(message, handle, preference) {
+        if (!handle.modelSelection || !this.state.modelPreferences || (preference && !handle.sharesModelSelection))
+            return;
+        const selection = handle.modelSelection();
+        if (preference && sameSelection(preference.selection, selection))
+            return;
+        await this.state.modelPreferences.set(this.context(message), selection, { expectedRevision: preference?.revision ?? null });
+    }
+    /** The host's presets, from the live session when there is one. Undefined when the host offers none. */
+    permissionView(lane) {
+        const live = lane.session?.permissionState?.();
+        if (live)
+            return live;
+        const options = this.runtime.permissionOptions?.() ?? [];
+        return options.length ? { options } : undefined;
+    }
+    /** What this chat runs: the live session's preset, else the chat's saved choice. */
+    async permissionChoice(message, lane) {
+        if (lane.unavailable)
+            await this.unload(lane);
+        await this.adoptPermission(lane);
+        const view = this.permissionView(lane);
+        if (!view)
+            return;
+        if (view.current)
+            return view;
+        const saved = await this.state.permissionPreferences?.get(this.context(message));
+        return saved && view.options.some(option => option.id === saved) ? { ...view, current: saved } : view;
+    }
+    /** Owner-only: switch this private chat's Harness permission preset, like the App's selector. */
+    async permissionCommand(message, lane, args) {
+        if (!this.harness(message, lane))
+            return message.chatType === 'p2p' ? '这个私聊使用管理员配置的助手，没有可切换的权限模式。' : '权限模式只能在你和我的私聊里切换。';
+        const view = await this.permissionChoice(message, lane);
+        if (!view)
+            throw new DshRuntimeError('PERMISSION_UNAVAILABLE');
+        if (!args)
+            return permissionStateText(view);
+        const choice = /^use ([a-z][a-z0-9-]{0,39})$/.exec(args)?.[1];
+        const option = view.options.find(item => item.id === choice);
+        if (!option)
+            return '请通过权限模式卡片选择，或发送 /permission 查看可用选项。';
+        // Save first: a later session in this chat starts in the chosen mode even if the live switch fails.
+        await this.state.permissionPreferences?.set(this.context(message), option.id);
+        if (lane.session?.setPermission) {
+            lane.session.setPermission(option.id);
+            lane.permissionSeen = option.id;
+        }
+        message.permissionChanged = true;
+        return `已切换为「${option.name}」。这个私聊里的对话都会使用它，电脑上打开这段对话也会看到同样的模式。`;
+    }
+    /** Bring a newly opened harness session to the chat's choice, or a new one without a choice to the App's default. */
+    async applyPermission(message, lane, handle, fresh) {
+        if (!this.harness(message, lane) || !handle.setPermission)
+            return;
+        const { ownerKey, conversationKey } = this.context(message);
+        lane.permissionContext = { ownerKey, conversationKey };
+        const saved = await this.state.permissionPreferences?.get(lane.permissionContext);
+        const state = handle.permissionState?.();
+        // The App's own new sessions start on its default preset; a resumed one keeps what it recorded.
+        const target = saved ?? (fresh ? state?.defaultPreset : undefined);
+        if (state && target && state.current !== target && state.options.some(option => option.id === target))
+            handle.setPermission(target);
+        lane.permissionSeen = handle.permissionState?.()?.current;
+    }
+    /** A preset changed in the App on this chat's live session becomes the chat's choice, so new sessions keep it. */
+    async adoptPermission(lane) {
+        const live = lane.permissionContext ? lane.session?.permissionState?.() : undefined;
+        if (!live || live.current === lane.permissionSeen)
+            return;
+        lane.permissionSeen = live.current;
+        if (live.options.some(option => option.id === live.current))
+            await this.state.permissionPreferences?.set(lane.permissionContext, live.current);
+    }
     async modelState(message, lane) {
         if (!this.runtime.catalog || !this.runtime.resolveModelSelection || !this.state.modelPreferences)
             throw new DshRuntimeError('MODEL_UNAVAILABLE');
@@ -682,6 +1138,17 @@ export class BotBridge {
         const catalog = await this.runtime.catalog();
         const context = this.context(message);
         let preference = await this.state.modelPreferences.get(context);
+        if (this.sharedModel(message, lane)) {
+            // As in the App: the live session's own record; without one, what this chat last ran,
+            // and for a chat that will start a new session, the host default.
+            const live = lane.session?.sharesModelSelection ? lane.session.modelSelection?.() : undefined;
+            const fresh = !live && !await this.state.sessions.current(this.sessionContext(message));
+            const selection = live ?? (fresh || !preference ? catalog.defaultSelection ?? await this.runtime.resolveModelSelection() : preference.selection);
+            if (!preference || !sameSelection(preference.selection, selection)) {
+                preference = await this.state.modelPreferences.set(context, selection, { expectedRevision: preference?.revision ?? null });
+            }
+            return message.modelView = { catalog, selection: preference.selection, preference };
+        }
         if (!preference) {
             let selection = lane.session?.modelSelection?.();
             if (!selection) {
@@ -706,12 +1173,21 @@ export class BotBridge {
         return message.modelView = { catalog, selection: preference.selection, preference };
     }
     async modelCommand(message, lane, kind, args) {
+        const shared = this.sharedModel(message, lane);
+        const match = /^use ([a-f0-9]{16})$/.exec(args);
+        // Like the App's selector, a pick goes into this chat's own session, so open it first.
+        if (match && shared && !lane.session && await this.state.sessions.current(this.sessionContext(message))) {
+            await this.ensureSession(message, lane);
+            message.modelView = undefined;
+        }
         const state = await this.modelState(message, lane);
         if (!args || args === 'current' || /^page [0-9]{1,4}$/.test(args))
             return modelStateText(state.selection, state.catalog);
-        const match = /^use ([a-f0-9]{16})$/.exec(args);
         if (!match)
             return `请通过菜单选择，或发送 /${kind} 查看当前可用选项。`;
+        // Reopening the session may have brought in a choice made in the App since the card was drawn.
+        if (message.expectedModelRevision !== undefined && state.preference.revision !== message.expectedModelRevision)
+            throw new StaleCardError();
         let candidate = kind === 'model' ? modelChoice(state.catalog, match[1]) : thinkingChoice(state.catalog, state.selection, match[1]);
         if (!candidate)
             throw new DshRuntimeError('INVALID_MODEL_SELECTION');
@@ -720,7 +1196,31 @@ export class BotBridge {
         const selection = await this.runtime.resolveModelSelection(candidate);
         if (!sameSelection(selection, state.selection)) {
             const saved = await this.state.modelPreferences.set(this.context(message), selection, { expectedRevision: state.preference.revision });
-            if (lane.session) {
+            if (shared) {
+                // Recorded in the session, then made the App's default for new sessions, as the App's selector does.
+                const recorded = Boolean(lane.session?.sharesModelSelection);
+                if (recorded) {
+                    lane.session.setModelSelection(saved.selection);
+                    // An unconfirmed pick must not drive another turn: the session is closed and reopened first.
+                    try {
+                        await lane.session.checkpoint();
+                    }
+                    catch (error) {
+                        lane.unavailable = true;
+                        throw error;
+                    }
+                }
+                try {
+                    await this.runtime.saveDefaultModel?.(saved.selection);
+                }
+                catch (error) {
+                    // Without a session holding the pick, the App default is the only place it lives.
+                    if (!recorded)
+                        throw error;
+                    this.audit({ stage: 'model-default-unsaved', messageId: message.messageId });
+                }
+            }
+            else if (lane.session) {
                 if (lane.session.setModelSelection) {
                     try {
                         lane.session.setModelSelection(saved.selection);
@@ -735,49 +1235,87 @@ export class BotBridge {
             message.modelView = { catalog: state.catalog, selection: saved.selection, preference: saved };
         }
         message.modelChanged = true;
-        return `设置已保存，下一条回复生效。\n${modelStateText(selection, state.catalog)}\n已有对话保留，只影响你在当前聊天中的选择。`;
+        return shared ? `设置已保存，下一条回复生效。\n${modelStateText(selection, state.catalog)}\n已有对话保留；电脑上的 Harness 也会用这个设置。`
+            : `设置已保存，下一条回复生效。\n${modelStateText(selection, state.catalog)}\n已有对话保留，只影响你在当前聊天中的选择。`;
     }
-    async commandPanel(message, lane) {
+    /**
+     * The management card for a command. `card` describes a click being shown on
+     * its own card: the switch in flight, its refusal, or a refresh of a stale card.
+     */
+    async commandPanel(message, lane, card) {
         const match = /^\/(\S+)(?:\s+([\s\S]*))?$/.exec(message.text);
         const command = match?.[1]?.toLowerCase(), args = (match?.[2] ?? '').trim();
-        if ((command === 'model' || command === 'thinking') && (!args || /^page [0-9]{1,4}$/.test(args) || message.modelChanged)) {
+        const choice = /^use (\S+)$/.exec(args)?.[1];
+        const pending = card?.pending ? choice : undefined;
+        const interactive = this.cardActionsReady && this.config.cardInteractions && Boolean(this.state.actions);
+        const issue = (target, extra = {}) => this.state.actions.issue({
+            ownerId: message.senderId, chatId: message.chatId, chatType: message.chatType, threadId: message.threadId,
+            sourceMessageId: message.messageId, command: target, ...extra
+        });
+        if ((command === 'model' || command === 'thinking') && (!args || /^page [0-9]{1,4}$/.test(args) || message.modelChanged || card)) {
+            if (card?.pending && !pending)
+                return;
             const state = await this.modelState(message, lane);
             const current = await this.state.sessions.current(this.sessionContext(message));
-            const interactive = this.cardActionsReady && this.config.cardInteractions && Boolean(this.state.actions);
-            return modelControlPanel(command, state.catalog, state.selection, (label, target, mutation, primary) => {
+            const panel = modelControlPanel(command, state.catalog, state.selection, (label, target, mutation, primary) => {
                 if (!interactive)
                     return;
-                const token = this.state.actions.issue({ ownerId: message.senderId, chatId: message.chatId, chatType: message.chatType,
-                    threadId: message.threadId, sourceMessageId: message.messageId, command: target, expectedSessionId: current?.id ?? null,
+                const token = issue(target, { expectedSessionId: current?.id ?? null,
                     ...(mutation ? { expectedModelRevision: state.preference?.revision ?? null } : {}) });
                 return { label, value: { token }, primary };
-            }, /^page /.test(args) ? Number(args.slice(5)) : 0, message.modelChanged);
+            }, { ...(/^page /.test(args) ? { page: Number(args.slice(5)) } : {}), changed: message.modelChanged, pending, error: card?.error, notice: card?.notice });
+            // The settings menu reaches the permission switch from here too.
+            if (interactive && this.harness(message, lane) && this.permissionView(lane))
+                panel.actions = [...panel.actions ?? [],
+                    pending ? { label: '权限模式', value: {}, disabled: true } : { label: '权限模式', value: { token: issue('/permission') } }];
+            return panel;
+        }
+        if (command === 'permission' && (!args || message.permissionChanged || card) && this.harness(message, lane)) {
+            if (card?.pending && !pending)
+                return;
+            const view = await this.permissionChoice(message, lane);
+            if (!view)
+                return;
+            return permissionPanel(view, (label, target, primary, confirm) => interactive
+                ? { label, value: { token: issue(target) }, primary, ...(confirm ? { confirm } : {}) } : undefined, { changed: message.permissionChanged, pending, error: card?.error, notice: card?.notice });
         }
         // Ordinary conversation and diagnostics stay out of management cards.
         // A card is useful here because the user explicitly wants to pick a topic.
-        if (command !== 'sessions' || args === 'detail')
+        const topic = card && (command === 'resume' || command === 'new');
+        if ((command !== 'sessions' || args === 'detail') && !topic)
             return;
         const conversation = this.sessionContext(message);
         const current = await this.state.sessions.current(conversation);
         const sessions = await this.state.sessions.list(conversation);
         if (!sessions.length)
             return;
-        const interactive = this.cardActionsReady && this.config.cardInteractions && Boolean(this.state.actions);
+        const busy = Boolean(card?.pending);
+        const target = command === 'resume' ? sessions.find(s => s.id === args) : undefined;
+        const status = card?.error ? { text: card.error, tone: 'error' }
+            : busy ? { text: target ? `正在切换到「${preview(target.title, 40)}」…` : '正在开始新话题…', tone: 'pending' }
+                : topic && command === 'resume' && target ? { text: `已切换到「${preview(target.title, 40)}」，可以接着聊了。`, tone: 'success' }
+                    : topic ? { text: '好，换个话题。直接发消息就会开始新的对话，之前的还在这里。', tone: 'success' }
+                        : card?.notice ? { text: card.notice } : undefined;
         const actions = [];
-        const add = (label, target, options = {}) => {
+        const add = (label, command, options = {}) => {
+            if (busy) {
+                actions.push({ label, value: {}, disabled: true });
+                return;
+            }
             if (!interactive)
                 return;
             const token = this.state.actions.issue({ ownerId: message.senderId, chatId: message.chatId,
                 chatType: message.chatType, threadId: message.threadId, sourceMessageId: message.messageId,
-                command: target, ...(options.expectedSessionId === undefined ? {} : { expectedSessionId: options.expectedSessionId }) });
-            actions.push({ label, value: { token }, primary: options.primary, confirm: options.confirm });
+                command, ...(options.expectedSessionId === undefined ? {} : { expectedSessionId: options.expectedSessionId }) });
+            actions.push({ label, value: { token }, confirm: options.confirm });
         };
         for (const session of sessions.filter(s => s.id !== current?.id).slice(0, 5))
             add(`继续 ${preview(session.title, 14)}`, `/resume ${session.id}`, { expectedSessionId: current?.id ?? null, confirm: { title: '接着这个话题聊？', text: `继续「${preview(session.title, 40)}」，现在的对话会保留。` } });
-        add('换个话题', '/new', { expectedSessionId: current?.id ?? null,
-            confirm: { title: '开始新话题？', text: '之前的对话会保留，需要时可以再找回来。' } });
-        return { title: '以前的对话', subtitle: '选一个话题，接着聊',
-            summary: '选择以前的话题继续，或开始一段新对话', actions,
+        if (current)
+            add('换个话题', '/new', { expectedSessionId: current.id,
+                confirm: { title: '开始新话题？', text: '之前的对话会保留，需要时可以再找回来。' } });
+        return { title: '以前的对话', subtitle: '选一个话题，接着聊', tone: status?.tone ?? 'normal', ...(status ? { status } : {}),
+            summary: status?.text ?? '选择以前的话题继续，或开始一段新对话', actions,
             sections: sessions.slice(0, 5).map(s => ({ title: preview(s.title, 40), text: s.id === current?.id ? '正在聊这个话题' : '可以接着聊' })),
             ...(!interactive || sessions.length > 5 ? { note: '完整列表和更多操作：/sessions detail' } : {}),
         };
@@ -961,10 +1499,14 @@ export class BotBridge {
             lane.controller?.abort();
             lane.session?.cancel();
         }
+        for (const interaction of [...this.interactions.values()])
+            interaction.stop();
         await Promise.allSettled([...this.admissions]);
         await Promise.all([...this.lanes.values()].map(lane => lane.tail));
         await this.sweepTail;
         await this.progress.drain();
+        // Shutdown disposes sessions directly; keep presets changed in the App first.
+        await Promise.allSettled([...this.lanes.values()].map(lane => this.adoptPermission(lane)));
         const sessions = new Set([...this.failedDisposals, ...[...this.lanes.values()].flatMap(lane => lane.session ? [lane.session] : [])]);
         const results = await Promise.allSettled([...sessions].map(session => session.dispose()));
         if (results.some(result => result.status === 'rejected'))