@rynx-ai/plugin-channel-lark 0.1.10 → 0.1.11-beta.10

package/dist/lark-config-store.js

@@ -0,0 +1,135 @@
+import { randomUUID } from "node:crypto";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+const INSTANCE_ID_PATTERN = /^[a-z][a-z0-9-]{0,62}$/;
+export class LarkConfigStore {
+    file;
+    constructor(dataDir) {
+        mkdirSync(dataDir, { recursive: true, mode: 0o700 });
+        this.file = path.join(dataDir, "lark-config.json");
+    }
+    list() {
+        return structuredClone(this.read().instances);
+    }
+    get(id) {
+        return this.list().find((instance) => instance.id === id);
+    }
+    upsert(input) {
+        const state = this.read();
+        const id = input.id ?? `instance-${randomUUID().slice(0, 8)}`;
+        if (!INSTANCE_ID_PATTERN.test(id))
+            throw new Error("Lark instance id is invalid");
+        const existing = state.instances.find((instance) => instance.id === id);
+        const secret = input.appSecret?.trim() || existing?.appSecret;
+        if (!secret)
+            throw new Error("App Secret is required");
+        const appId = input.appId.trim();
+        const name = input.name.trim();
+        if (!appId)
+            throw new Error("App ID is required");
+        if (!name)
+            throw new Error("instance name is required");
+        const defaultAgent = input.defaultAgent === undefined
+            ? existing?.defaultAgent
+            : input.defaultAgent?.trim() || undefined;
+        const roots = input.allowedRoots ?? existing?.executionDefaults.allowedRoots ?? [];
+        if (!Array.isArray(roots) || roots.some((root) => typeof root !== "string" || !path.isAbsolute(root))) {
+            throw new Error("allowed roots must be absolute paths");
+        }
+        const instance = {
+            id,
+            name,
+            enabled: input.enabled,
+            appId,
+            appSecret: secret,
+            ...(defaultAgent ? { defaultAgent } : {}),
+            executionDefaults: {
+                runtime: input.runtime ?? existing?.executionDefaults.runtime ?? "codex",
+                allowedRoots: [...new Set(roots.map((root) => path.resolve(root)))],
+                ...(defaultAgent ? { defaultAgent } : {}),
+            },
+        };
+        const index = state.instances.findIndex((item) => item.id === id);
+        if (index >= 0)
+            state.instances[index] = instance;
+        else
+            state.instances.push(instance);
+        this.write(state);
+        return structuredClone(instance);
+    }
+    remove(id) {
+        const state = this.read();
+        const filtered = state.instances.filter((instance) => instance.id !== id);
+        if (filtered.length === state.instances.length)
+            return false;
+        this.write({ ...state, instances: filtered });
+        return true;
+    }
+    setEnabled(id, enabled) {
+        const state = this.read();
+        const instance = state.instances.find((item) => item.id === id);
+        if (!instance)
+            throw new Error(`Lark instance "${id}" not found`);
+        instance.enabled = enabled;
+        this.write(state);
+        return structuredClone(instance);
+    }
+    read() {
+        if (!existsSync(this.file))
+            return { schemaVersion: 1, instances: [] };
+        const info = lstatSync(this.file);
+        if (!info.isFile() || info.isSymbolicLink() || info.size > 1024 * 1024) {
+            throw new Error("Lark plugin configuration is invalid");
+        }
+        return parseState(JSON.parse(readFileSync(this.file, "utf8")));
+    }
+    write(state) {
+        const temporary = `${this.file}.tmp-${randomUUID()}`;
+        try {
+            writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`, {
+                encoding: "utf8",
+                mode: 0o600,
+                flag: "wx",
+            });
+            chmodSync(temporary, 0o600);
+            renameSync(temporary, this.file);
+        }
+        finally {
+            rmSync(temporary, { force: true });
+        }
+    }
+}
+function parseState(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("Lark plugin configuration must be an object");
+    }
+    const record = value;
+    if (record.schemaVersion !== 1 || !Array.isArray(record.instances)) {
+        throw new Error("Lark plugin configuration schema is invalid");
+    }
+    const ids = new Set();
+    const instances = record.instances.map((value) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            throw new Error("Lark instance configuration is invalid");
+        }
+        const instance = value;
+        if (!INSTANCE_ID_PATTERN.test(instance.id) ||
+            typeof instance.name !== "string" || !instance.name ||
+            typeof instance.enabled !== "boolean" ||
+            typeof instance.appId !== "string" || !instance.appId ||
+            typeof instance.appSecret !== "string" || !instance.appSecret ||
+            (instance.defaultAgent !== undefined &&
+                (typeof instance.defaultAgent !== "string" || !instance.defaultAgent.trim())) ||
+            !instance.executionDefaults ||
+            !["codex", "traex", "claude"].includes(instance.executionDefaults.runtime) ||
+            !Array.isArray(instance.executionDefaults.allowedRoots) ||
+            !instance.executionDefaults.allowedRoots.every((root) => typeof root === "string" && path.isAbsolute(root))) {
+            throw new Error("Lark instance configuration is invalid");
+        }
+        if (ids.has(instance.id))
+            throw new Error(`duplicate Lark instance id "${instance.id}"`);
+        ids.add(instance.id);
+        return structuredClone(instance);
+    });
+    return { schemaVersion: 1, instances };
+}

package/dist/lark-runtime-state-store.d.ts

@@ -0,0 +1,18 @@
+import type { PluginHealth } from "@rynx-ai/plugin-sdk";
+export interface LarkRuntimeInstanceState {
+    state: "starting" | "running" | "failed" | "stopping" | "stopped";
+    connected: boolean;
+    lastError: string | null;
+    lastEventAt: string | null;
+}
+export interface LarkRuntimeState {
+    active: boolean;
+    health: PluginHealth;
+    instances: Record<string, LarkRuntimeInstanceState>;
+}
+export declare class LarkRuntimeStateStore {
+    private readonly file;
+    constructor(dataDir: string);
+    read(): LarkRuntimeState;
+    write(state: LarkRuntimeState): void;
+}

package/dist/lark-runtime-state-store.js

@@ -0,0 +1,95 @@
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+export class LarkRuntimeStateStore {
+    file;
+    constructor(dataDir) {
+        mkdirSync(dataDir, { recursive: true, mode: 0o700 });
+        this.file = path.join(dataDir, "lark-runtime-state.json");
+    }
+    read() {
+        if (!existsSync(this.file)) {
+            return { active: false, health: { state: "running" }, instances: {} };
+        }
+        const info = lstatSync(this.file);
+        if (!info.isFile() || info.isSymbolicLink() || info.size > 1024 * 1024) {
+            return {
+                active: false,
+                health: { state: "degraded", message: "Runtime state is unavailable" },
+                instances: {},
+            };
+        }
+        try {
+            return parseState(JSON.parse(readFileSync(this.file, "utf8")));
+        }
+        catch {
+            return {
+                active: false,
+                health: { state: "degraded", message: "Runtime state is unavailable" },
+                instances: {},
+            };
+        }
+    }
+    write(state) {
+        const temporary = `${this.file}.tmp-${randomUUID()}`;
+        try {
+            writeFileSync(temporary, `${JSON.stringify(state)}\n`, {
+                encoding: "utf8",
+                mode: 0o600,
+                flag: "wx",
+            });
+            chmodSync(temporary, 0o600);
+            renameSync(temporary, this.file);
+        }
+        finally {
+            rmSync(temporary, { force: true });
+        }
+    }
+}
+function parseState(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("invalid runtime state");
+    }
+    const record = value;
+    if (typeof record.active !== "boolean")
+        throw new Error("invalid runtime activity");
+    const health = parseHealth(record.health);
+    if (typeof record.instances !== "object" || record.instances === null ||
+        Array.isArray(record.instances)) {
+        throw new Error("invalid runtime instances");
+    }
+    const instances = {};
+    for (const [id, raw] of Object.entries(record.instances)) {
+        if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+            throw new Error("invalid runtime instance");
+        }
+        const item = raw;
+        if (!["starting", "running", "failed", "stopping", "stopped"].includes(String(item.state)) ||
+            typeof item.connected !== "boolean" ||
+            (item.lastError !== null && typeof item.lastError !== "string") ||
+            (item.lastEventAt !== null && typeof item.lastEventAt !== "string")) {
+            throw new Error("invalid runtime instance");
+        }
+        instances[id] = {
+            state: item.state,
+            connected: item.connected,
+            lastError: item.lastError,
+            lastEventAt: item.lastEventAt,
+        };
+    }
+    return { active: record.active, health, instances };
+}
+function parseHealth(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("invalid runtime health");
+    }
+    const record = value;
+    if ((record.state !== "running" && record.state !== "degraded") ||
+        (record.message !== undefined && typeof record.message !== "string")) {
+        throw new Error("invalid runtime health");
+    }
+    return {
+        state: record.state,
+        ...(typeof record.message === "string" ? { message: record.message } : {}),
+    };
+}

package/dist/lark-setup.d.ts

@@ -1,4 +1,27 @@
-import type { AuthMaterial, ConfigField } from "@rynx-ai/core";
+export interface LarkSetupField {
+    key: "LARK_APP_ID" | "LARK_APP_SECRET";
+    label: string;
+    type: "string" | "secret";
+    required: boolean;
+    help?: string;
+}
+export type LarkAuthorizationMaterial = {
+    kind: "qr";
+    url: string;
+    expireIn?: number;
+} | {
+    kind: "link";
+    url: string;
+    label?: string;
+} | {
+    kind: "status";
+    text: string;
+};
+export interface LarkAuthorizationCredentials {
+    LARK_APP_ID: string;
+    LARK_APP_SECRET: string;
+    botName?: string;
+}
 /**
  * Minimal tenant (app-identity) scopes the Lark channel needs: receive/send
  * messages, add reactions, read chat + members, upload/download resources, and
@@ -8,10 +31,9 @@ export declare const LARK_BOT_SCOPES: string[];
 /** The bot only needs to be told when a message arrives. */
 export declare const LARK_BOT_EVENTS: string[];
 /** Config mode 1: paste an existing app's credentials. */
-export declare const larkConfigSchema: ConfigField[];
+export declare const larkConfigSchema: LarkSetupField[];
 /**
- * Config mode 2: scan-to-create/authorize. Emits a `qr` material (the URL the
- * host renders as a QR and/or a clickable link) and `status` updates, then
+ * Scan-to-create/authorize. Emits a `qr` material and `status` updates, then
  * resolves with the App ID / App Secret to persist. Aborts via `signal`.
  */
-export declare function authorizeLark(emit: (material: AuthMaterial) => void, signal: AbortSignal): Promise<Record<string, unknown>>;
+export declare function authorizeLark(emit: (material: LarkAuthorizationMaterial) => void, signal: AbortSignal): Promise<LarkAuthorizationCredentials>;

package/dist/lark-setup.js

@@ -1,9 +1,9 @@
 /**
  * Lark (Feishu) authorization flow + its credential form schema.
  *
- * Two config modes the host can offer for this channel type:
+ * Two setup modes the Lark plugin can offer from its own UI or command:
  *   1. **Form** ({@link larkConfigSchema}) — paste an existing app's App ID /
- *      App Secret. The host renders these fields generically.
+ *      App Secret.
  *   2. **Authorize** ({@link authorizeLark}) — the SDK's `registerApp` device
  *      flow (RFC 8628-shaped, Feishu-proprietary provisioning): the user scans a
  *      QR (or opens the link) in Feishu, an app is created/authorized with the
@@ -11,10 +11,11 @@
  *      App ID / App Secret.
  *
  * `authorizeLark` is transport-neutral: it translates the SDK's callbacks into
- * the host's {@link AuthMaterial} stream (`qr` / `status`) and resolves with the
- * options to persist. The terminal vs web rendering is the host's concern.
+ * the plugin's own {@link LarkAuthorizationMaterial} stream and resolves with
+ * the values to persist.
  */
 import { registerApp } from "@larksuiteoapi/node-sdk";
+import { createLarkSdkClient } from "./lark-sdk/client.js";
 /**
  * Minimal tenant (app-identity) scopes the Lark channel needs: receive/send
  * messages, add reactions, read chat + members, upload/download resources, and
@@ -50,8 +51,7 @@ const STATUS_TEXT = {
     domain_switched: "识别到国际版租户,已切换到 larksuite.com 继续。",
 };
 /**
- * Config mode 2: scan-to-create/authorize. Emits a `qr` material (the URL the
- * host renders as a QR and/or a clickable link) and `status` updates, then
+ * Scan-to-create/authorize. Emits a `qr` material and `status` updates, then
  * resolves with the App ID / App Secret to persist. Aborts via `signal`.
  */
 export async function authorizeLark(emit, signal) {
@@ -75,7 +75,24 @@ export async function authorizeLark(emit, signal) {
     if (!result.client_id || !result.client_secret) {
         throw new Error("扫码返回的凭据为空,请改用手动填写 App ID / App Secret。");
     }
-    return { LARK_APP_ID: result.client_id, LARK_APP_SECRET: result.client_secret };
+    const botName = await resolveBotName(result.client_id, result.client_secret);
+    return {
+        LARK_APP_ID: result.client_id,
+        LARK_APP_SECRET: result.client_secret,
+        ...(botName ? { botName } : {}),
+    };
+}
+async function resolveBotName(appId, appSecret) {
+    try {
+        const response = await createLarkSdkClient({ appId, appSecret }).request({
+            method: "GET",
+            url: "/open-apis/bot/v3/info",
+        });
+        return response?.bot?.app_name?.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
 }
 function messageOf(err) {
     return err instanceof Error ? err.message : String(err);

package/dist/lark.d.ts

@@ -4,7 +4,7 @@ import { chunkLarkReplyText, extractLarkTextPrompt, isLarkNewSessionCommand, isL
 import { type LarkConversationDirectory } from "./lark-conversation-directory.js";
 import { LarkClientProvider, LarkSdkMessageSender } from "./lark-sender.js";
 import { type LarkActiveSessionStore } from "./lark-session-store.js";
-import type { ConversationProvider, ConversationRuntime } from "@rynx-ai/core";
+import type { ConversationProvider, ConversationStreamRequest, StartedLiveExecution } from "@rynx-ai/core";
 export { chunkLarkReplyText, extractLarkTextPrompt, isLarkNewSessionCommand, isLarkStopCommand, };
 export { LarkClientProvider, LarkSdkMessageSender };
 export interface LarkUserIdentifier {
@@ -234,7 +234,12 @@ export interface LarkWsClientProvider {
     start(options: LarkWsClientStartOptions): Promise<void>;
     stop(): Promise<void>;
 }
-type LarkConversationRuntime = Pick<ConversationRuntime, "runLive">;
+/** Plugin-facing run contract. The daemon-backed adapter sends only the
+ * provisioned Session id and message over Host RPC; the daemon loads that
+ * Session's immutable workspace/execution snapshots. */
+export interface LarkConversationRuntime {
+    runLive(input: ConversationStreamRequest): Promise<StartedLiveExecution>;
+}
 interface LarkMessageIngestorOptions {
     conversationRuntime: LarkConversationRuntime;
     messageSender: LarkMessageSender;
@@ -278,6 +283,7 @@ interface LarkMessageIngestorOptions {
     sessionProvisioner?: (input: {
         sessionKey: string;
         fromSessionId: string;
+        title?: string;
     }) => Promise<string>;
 }
 export interface LarkAgentCatalog {
@@ -484,6 +490,7 @@ interface LocalLarkBotRuntimeOptions {
     sessionProvisioner?: (input: {
         sessionKey: string;
         fromSessionId: string;
+        title?: string;
     }) => Promise<string>;
 }
 export declare class LocalLarkBotRuntime implements LarkBotRuntime {

package/dist/lark.js

@@ -1,6 +1,5 @@
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { mkdir } from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { CodexRuntimeError, collectLiveRun, } from "@rynx-ai/core";
@@ -16,7 +15,6 @@ import { buildSettingsCard, buildSettingsCardJson, buildSettingsResultCard, SETT
 import { getRuntimeProfile, isAgentRuntimeId, RUNTIME_PROFILES, } from "@rynx-ai/core";
 import { SteerController } from "@rynx-ai/core";
 import { toErrorMessage } from "@rynx-ai/core";
-import { findInnermostAllowedRoot } from "@rynx-ai/core";
 export { chunkLarkReplyText, extractLarkTextPrompt, isLarkNewSessionCommand, isLarkStopCommand, };
 export { LarkClientProvider, LarkSdkMessageSender };
 const DEFAULT_UNSUPPORTED_MESSAGE = "暂时只支持文本消息，请发送文本内容。";
@@ -38,7 +36,7 @@ const LARK_COMMANDS = [
     { name: "models", help: "/models — 列出当前运行时可用模型", category: "info" },
     { name: "resume", help: "/resume [短id] — 列出最近会话/跳转或转发到指定会话", category: "takeover" },
     { name: "fork", help: "/fork — 把当前会话 fork 到新群/新话题（带上下文+历史记录）", category: "takeover" },
-    { name: "cwd", help: "/cwd [目录] — 查看/绑定当前会话的工作目录（不存在则新建）", category: "takeover" },
+    { name: "cwd", help: "/cwd — 工作目录已改由 Rynx Project 管理", category: "other" },
     { name: "goal", help: "/goal [目标|clear] — 查看/设置/清除当前会话目标", category: "action" },
     { name: "diff", help: "/diff — 显示当前工作区 git 改动（含未跟踪文件）", category: "action" },
     { name: "help", help: "/help — 显示本帮助", category: "info" },
@@ -64,8 +62,7 @@ const defaultLogger = {
         }));
     },
 };
-/** Route SDK diagnostics through the runner logger instead of stdout, which is
- * reserved for the NDJSON RPC transport in an out-of-process plugin. */
+/** Route SDK diagnostics through the host logger; the process transport owns stdout. */
 function larkSdkLogger(logger) {
     const write = (level, messages) => {
         const text = messages
@@ -502,6 +499,14 @@ export class LarkMessageIngestor {
                 // → fall through to the queue so the message runs as the next turn.
             }
         }
+        // /new must execute immediately after interrupting the active turn. If it
+        // joins the per-session queue, it waits behind the very turn it just
+        // aborted; a backend that is slow to close its stream can otherwise leave
+        // the command with no acknowledgement and no rotated session.
+        if (isLarkNewSessionCommand(prompt)) {
+            await this.handleNewSessionCommand(event, sessionKey);
+            return;
+        }
         // Informational commands (/help, /models, /search) answer instantly and
         // also bypass the queue so they respond even while a turn is running.
         if (command && LARK_INFO_COMMANDS.has(command.name)) {
@@ -524,9 +529,9 @@ export class LarkMessageIngestor {
             await this.handleForkCommand(event, sessionKey);
             return;
         }
-        // /cwd binds the conversation's working directory; bypasses queue.
+        // /cwd is retained only as a migration notice; Project owns workspace selection.
         if (command && command.name === "cwd") {
-            await this.handleCwdCommand(event, sessionKey, command);
+            await this.handleCwdCommand(event);
             return;
         }
         // /runtime and /model open the interactive settings card; bypass queue.
@@ -540,10 +545,6 @@ export class LarkMessageIngestor {
             return;
         }
         await this.queue.enqueue(sessionKey, async () => {
-            if (isLarkNewSessionCommand(prompt)) {
-                await this.handleNewSessionCommand(event, sessionKey);
-                return;
-            }
             // Best-effort, off the turn's critical path: the directory only feeds
             // /resume, so a lagging or failed write must never delay the reply.
             void this.recordConversation(event, sessionKey, prompt);
@@ -559,11 +560,10 @@ export class LarkMessageIngestor {
                     session_id: session.sessionId,
                     provider: this.provider,
                 });
+                // A session title is initialized from its first ordinary message and
+                // remains stable for the rest of that session.
+                this.registerSession(session.sessionId, prompt);
             }
-            // Register the session's identity row (idempotent): the first turn fixes
-            // its source + title; rotated (`/new`) and forked sessions land here on
-            // their first turn too, so the control plane lists every Lark session.
-            this.registerSession(session.sessionId, prompt);
             this.logMessageReceived(event, sessionKey, session.sessionId);
             const startedReactionId = await this.tryCreateReaction(event, sessionKey, LARK_WORK_STARTED_REACTION, session.sessionId);
             const reply = await this.buildReply(event, sessionKey, session.sessionId, prompt, session.cwd ?? this.cwd, await this.resolveTurnExecution(sessionKey, session));
@@ -810,39 +810,8 @@ export class LarkMessageIngestor {
             });
         }
     }
-    async handleCwdCommand(event, sessionKey, command) {
-        const session = await this.activeSessionStore.get(sessionKey);
-        const currentCwd = session?.cwd ?? this.cwd;
-        const arg = command.args.trim();
-        if (!arg) {
-            await this.sendReplyText(event, currentCwd ? `当前工作目录：${currentCwd}` : "当前使用默认工作目录。");
-            return;
-        }
-        const base = currentCwd ?? this.allowedRoots[0] ?? process.cwd();
-        const resolved = path.isAbsolute(arg) ? path.resolve(arg) : path.resolve(base, arg);
-        if (!findInnermostAllowedRoot(resolved, this.allowedRoots)) {
-            await this.sendReplyText(event, `目录不在允许范围内（需位于 AGENT_ALLOWED_DIRS 内）：${resolved}`);
-            return;
-        }
-        try {
-            await mkdir(resolved, { recursive: true });
-        }
-        catch (error) {
-            await this.sendReplyText(event, `创建目录失败：${toErrorMessage(error)}`);
-            return;
-        }
-        await this.activeSessionStore.bindCwd(sessionKey, resolved);
-        await this.sendReplyText(event, `已绑定工作目录：${resolved}，并开启新会话。`);
-        this.logger.log({
-            event: "command.handled",
-            tenant_key: event.tenant_key ?? event.sender.tenant_key,
-            chat_id: event.message.chat_id,
-            thread_id: event.message.thread_id,
-            message_id: event.message.message_id,
-            session_key: sessionKey,
-            command: "cwd",
-            provider: this.provider,
-        });
+    async handleCwdCommand(event) {
+        await this.sendReplyText(event, "工作目录已改由 Rynx Project 管理；请在 Rynx 中创建或选择 Project。未选择时会使用该 Session 的独立临时目录。");
     }
     async handleResumeCommand(event, sessionKey, command) {
         const arg = command.args.trim();
@@ -955,8 +924,7 @@ export class LarkMessageIngestor {
     }
     async handleForkCommand(event, sessionKey) {
         const sender = this.messageSender;
-        if (!this.capabilities?.forkSession ||
-            !sender.sendText ||
+        if (!sender.sendText ||
             !sender.listMessages ||
             !sender.listChatMembers) {
             await this.sendReplyText(event, "当前不支持 /fork（仅 app_server 后端 + 飞书机器人能力）。");
@@ -1006,6 +974,22 @@ export class LarkMessageIngestor {
         }
         const header = `📋 原会话「${baseName}」记录（fork）：`;
         const body = transcript ? `${header}\n${transcript}` : header;
+        if (!this.sessionProvisioner) {
+            await this.sendReplyText(event, LARK_BACKEND_UNSUPPORTED);
+            return;
+        }
+        let newLocalThreadId;
+        try {
+            newLocalThreadId = await this.sessionProvisioner({
+                sessionKey: `fork:${tenantKey}:${event.message.message_id}`,
+                fromSessionId: session.sessionId,
+                title: `${baseName} - fork`,
+            });
+        }
+        catch (error) {
+            await this.sendReplyText(event, `fork 会话创建失败：${toErrorMessage(error)}`);
+            return;
+        }
         let newSessionKey;
         let newChatId = null;
         try {
@@ -1041,31 +1025,16 @@ export class LarkMessageIngestor {
             await this.sendReplyText(event, `fork 失败：${toErrorMessage(error)}`);
             return;
         }
-        // Bind the new conversation to a forked Codex thread carrying context.
-        // Carry the source cwd so the forked thread's working dir stays consistent.
-        // The session id is opaque (no routing baked in); newSessionKey is the
-        // routing key the store maps to it.
-        if (!this.sessionProvisioner) {
-            await this.sendReplyText(event, LARK_BACKEND_UNSUPPORTED);
-            return;
-        }
-        let newLocalThreadId;
-        let forkResult;
+        // Bind the new external conversation to the already-committed Machine
+        // Session fork. Feishu group/topic creation remains channel-owned.
         try {
-            newLocalThreadId = await this.sessionProvisioner({
-                sessionKey: newSessionKey,
-                fromSessionId: session.sessionId,
-            });
             await this.activeSessionStore.set(newSessionKey, newLocalThreadId, session.cwd);
-            forkResult = await this.capabilities.forkSession(session.sessionId, newLocalThreadId);
         }
         catch (error) {
-            await this.sendReplyText(event, `fork 会话创建失败：${toErrorMessage(error)}`);
+            await this.sendReplyText(event, `fork 已创建，但飞书会话绑定失败：${toErrorMessage(error)}`);
             return;
         }
-        const contextNote = forkResult.ok
-            ? "已带上当前会话上下文。"
-            : `但未能带上上下文：${this.capabilityErrorText(forkResult)}`;
+        const contextNote = "已带上当前会话上下文。";
         // Surface a one-tap entry into the new conversation in the current chat.
         if (newChatId) {
             const entryCardJson = buildOpenChatCardJson(newChatId, `${baseName} - fork`);
@@ -1082,9 +1051,6 @@ export class LarkMessageIngestor {
             if (!sentCard) {
                 await this.sendReplyText(event, `已 fork 到新群「${baseName} - fork」，点此进入：${buildChatApplink(newChatId)}（${contextNote}）`);
             }
-            else if (!forkResult.ok) {
-                await this.sendReplyText(event, `提示：${contextNote}`);
-            }
         }
         else {
             // Topic thread: the root message is already visible in this group.
@@ -1119,6 +1085,7 @@ export class LarkMessageIngestor {
             includeRuntime,
             currentRuntime,
             currentModel,
+            currentEffort,
             runtime: currentRuntime,
             model: currentModel ?? SETTINGS_DEFAULT_VALUE,
             effort: currentEffort ?? SETTINGS_DEFAULT_VALUE,
@@ -1333,7 +1300,6 @@ export class LarkMessageIngestor {
         const runtime = pending.includeRuntime && isAgentRuntimeId(pending.runtime)
             ? pending.runtime
             : pending.currentRuntime;
-        const runtimeChanged = runtime !== pending.currentRuntime;
         const model = pending.model === SETTINGS_DEFAULT_VALUE ? undefined : pending.model;
         const selectedModel = pending.models.find((candidate) => candidate.value === pending.model);
         const allowedEfforts = selectedModel?.supportedEfforts?.length
@@ -1342,10 +1308,9 @@ export class LarkMessageIngestor {
         const effort = pending.effort !== SETTINGS_DEFAULT_VALUE && allowedEfforts.includes(pending.effort)
             ? pending.effort
             : undefined;
-        // Only a runtime change rotates to a fresh session (its rollout/transcript
-        // store is runtime-specific). model / effort switch on the SAME thread —
-        // both lineages take them per-turn — so the conversation keeps its context.
-        const rotate = runtimeChanged;
+        // Provider selects the immutable runtime implementation. Model and
+        // reasoning effort are Turn settings and update the same idle Session.
+        const rotate = runtime !== pending.currentRuntime;
         await this.activeSessionStore.applySettings(sessionKey, {
             runtime,
             model,
@@ -1748,7 +1713,7 @@ export class LarkMessageIngestor {
                 // A user-triggered cancel needs no redundant chat reply (the card carries it).
                 text: cancelled ? "" : `处理失败：${errorMessage}`,
                 provider: started.provider,
-                model: started.model,
+                ...(started.model ? { model: started.model } : {}),
             };
         }
         // The card carries the answer; only emit a plain-text reply when no card
@@ -1756,7 +1721,7 @@ export class LarkMessageIngestor {
         return {
             text: orchestrator.cardStarted ? "" : orchestrator.fallbackText.trim() || DEFAULT_EMPTY_RESPONSE,
             provider: started.provider,
-            model: started.model,
+            ...(started.model ? { model: started.model } : {}),
         };
     }
     /**
@@ -1798,7 +1763,7 @@ export class LarkMessageIngestor {
             return {
                 text: answer.trim() || DEFAULT_EMPTY_RESPONSE,
                 provider: started.provider,
-                model: started.model,
+                ...(started.model ? { model: started.model } : {}),
             };
         }
         catch (error) {