@openclaw/feishu 2026.5.24-beta.2 → 2026.5.26-beta.1

package/dist/{channel-Br99IozO.js → channel-DavfT_AA.js}

@@ -1,17 +1,19 @@
 import { a as parseFeishuTargetId, i as parseFeishuDirectConversationId, n as buildFeishuModelOverrideParentCandidates, r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-DuL575sn.js";
 import { n as looksLikeFeishuId, r as normalizeFeishuTarget, t as detectIdType } from "./targets-BUjQ1TcA.js";
-import { a as resolveDefaultFeishuAccountId, f as isRecord$1, i as listFeishuAccountIds, n as inspectFeishuCredentials, o as resolveFeishuAccount, r as listEnabledFeishuAccounts, s as resolveFeishuRuntimeAccount } from "./accounts-CRcvqpsl.js";
+import { a as resolveDefaultFeishuAccountId, f as isRecord$2, i as listFeishuAccountIds, n as inspectFeishuCredentials, o as resolveFeishuAccount, r as listEnabledFeishuAccounts, s as resolveFeishuRuntimeAccount } from "./accounts-CXnY5H8g.js";
+import { n as createFeishuSendReceipt, s as createFeishuCardInteractionEnvelope } from "./send-result-CHvu8Rr7.js";
 import { t as messageActionTargetAliases } from "./security-audit-BIeA3W3Q.js";
 import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-ChjJKAJ9.js";
 import { t as collectFeishuSecurityAuditFindings } from "./security-audit-shared-BIHeF-S_.js";
 import { t as resolveFeishuSessionConversation } from "./session-conversation-CZSMgac-.js";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getSessionBindingService } from "openclaw/plugin-sdk/conversation-runtime";
+import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
 import { adaptScopedAccountAccessor, createHybridChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
 import { buildChannelOutboundSessionRoute, createChatChannelPlugin, stripChannelTargetPrefix } from "openclaw/plugin-sdk/channel-core";
-import { createMessageReceiptFromOutboundResults, defineChannelMessageAdapter } from "openclaw/plugin-sdk/channel-message";
+import { defineChannelMessageAdapter } from "openclaw/plugin-sdk/channel-message";
 import { createPairingPrefixStripper } from "openclaw/plugin-sdk/channel-pairing";
 import { createAllowlistProviderGroupPolicyWarningCollector, projectConfigAccountIdWarningCollector } from "openclaw/plugin-sdk/channel-policy";
 import { createChannelDirectoryAdapter, createRuntimeDirectoryLiveAdapter, listDirectoryGroupEntriesFromMapKeysAndAllowFrom, listDirectoryUserEntriesFromAllowFromAndMapKeys } from "openclaw/plugin-sdk/directory-runtime";
@@ -19,15 +21,20 @@ import { normalizeMessagePresentation, renderMessagePresentationFallbackText } f
 import { createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
 import { createRuntimeOutboundDelegates } from "openclaw/plugin-sdk/outbound-runtime";
 import { buildProbeChannelStatusSummary, createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
-import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$2, normalizeAccountId, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-resolution";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$2, normalizeAccountId as normalizeAccountId$1, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-resolution";
 import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
 import { createActionGate } from "openclaw/plugin-sdk/channel-actions";
 import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-primitives";
 import { PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk/channel-status";
 import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
-import { normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/account-id";
+import { normalizeAccountId as normalizeAccountId$2 } from "openclaw/plugin-sdk/account-id";
 import { z } from "zod";
 import { buildSecretInputSchema, hasConfiguredSecretInput as hasConfiguredSecretInput$2 } from "openclaw/plugin-sdk/secret-input";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { loadSessionStore, resolveSessionFilePath, resolveStorePath, updateSessionStore } from "openclaw/plugin-sdk/session-store-runtime";
+import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
 import { createChannelIngressResolver, defineStableChannelIngressIdentity } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, createSetupTranslator, formatDocsLink, hasConfiguredSecretInput as hasConfiguredSecretInput$1, mergeAllowFromEntries, patchTopLevelChannelConfigSection, promptSingleChannelSecretInput, splitSetupEntries } from "openclaw/plugin-sdk/setup";
 //#region extensions/feishu/src/approval-auth.ts
@@ -50,100 +57,6 @@ const feishuApprovalAuth = createResolvedApproverActionAuthAdapter({
 	normalizeSenderId: (value) => normalizeFeishuApproverId(value)
 });
 //#endregion
-//#region extensions/feishu/src/card-interaction.ts
-const FEISHU_CARD_INTERACTION_VERSION = "ocf1";
-function isInteractionKind(value) {
-	return value === "button" || value === "quick" || value === "meta";
-}
-function isMetadataValue(value) {
-	return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-}
-function createFeishuCardInteractionEnvelope(envelope) {
-	return {
-		oc: FEISHU_CARD_INTERACTION_VERSION,
-		...envelope
-	};
-}
-function buildFeishuCardActionTextFallback(event) {
-	const actionValue = event.action.value;
-	if (isRecord$1(actionValue)) {
-		if (typeof actionValue.text === "string") return actionValue.text;
-		if (typeof actionValue.command === "string") return actionValue.command;
-		return JSON.stringify(actionValue);
-	}
-	return String(actionValue);
-}
-function decodeFeishuCardAction(params) {
-	const { event, now = Date.now() } = params;
-	const actionValue = event.action.value;
-	if (!isRecord$1(actionValue) || actionValue.oc !== "ocf1") return {
-		kind: "legacy",
-		text: buildFeishuCardActionTextFallback(event)
-	};
-	if (!isInteractionKind(actionValue.k) || typeof actionValue.a !== "string" || !actionValue.a) return {
-		kind: "invalid",
-		reason: "malformed"
-	};
-	if (actionValue.q !== void 0 && typeof actionValue.q !== "string") return {
-		kind: "invalid",
-		reason: "malformed"
-	};
-	if (actionValue.m !== void 0) {
-		if (!isRecord$1(actionValue.m)) return {
-			kind: "invalid",
-			reason: "malformed"
-		};
-		for (const value of Object.values(actionValue.m)) if (!isMetadataValue(value)) return {
-			kind: "invalid",
-			reason: "malformed"
-		};
-	}
-	if (actionValue.c !== void 0) {
-		if (!isRecord$1(actionValue.c)) return {
-			kind: "invalid",
-			reason: "malformed"
-		};
-		if (actionValue.c.u !== void 0 && typeof actionValue.c.u !== "string") return {
-			kind: "invalid",
-			reason: "malformed"
-		};
-		if (actionValue.c.h !== void 0 && typeof actionValue.c.h !== "string") return {
-			kind: "invalid",
-			reason: "malformed"
-		};
-		if (actionValue.c.s !== void 0 && typeof actionValue.c.s !== "string") return {
-			kind: "invalid",
-			reason: "malformed"
-		};
-		if (actionValue.c.e !== void 0 && !Number.isFinite(actionValue.c.e)) return {
-			kind: "invalid",
-			reason: "malformed"
-		};
-		if (actionValue.c.t !== void 0 && actionValue.c.t !== "p2p" && actionValue.c.t !== "group") return {
-			kind: "invalid",
-			reason: "malformed"
-		};
-		if (typeof actionValue.c.e === "number" && actionValue.c.e < now) return {
-			kind: "invalid",
-			reason: "stale"
-		};
-		const expectedUser = actionValue.c.u?.trim();
-		if (expectedUser && expectedUser !== (event.operator.open_id ?? "").trim()) return {
-			kind: "invalid",
-			reason: "wrong_user"
-		};
-		const expectedChat = actionValue.c.h?.trim();
-		if (expectedChat && expectedChat !== (event.context.chat_id ?? "").trim()) return {
-			kind: "invalid",
-			reason: "wrong_conversation"
-		};
-	}
-	return {
-		kind: "structured",
-		envelope: actionValue
-	};
-}
-//#endregion
 //#region extensions/feishu/src/config-schema.ts
 const ChannelActionsSchema = z.object({ reactions: z.boolean().optional() }).strict().optional();
 const DmPolicySchema = z.enum([
@@ -365,7 +278,7 @@ const FeishuConfigSchema = z.object({
 }).strict().superRefine((value, ctx) => {
 	const defaultAccount = value.defaultAccount?.trim();
 	if (defaultAccount && value.accounts && Object.keys(value.accounts).length > 0) {
-		const normalizedDefaultAccount = normalizeAccountId$1(defaultAccount);
+		const normalizedDefaultAccount = normalizeAccountId$2(defaultAccount);
 		if (!Object.prototype.hasOwnProperty.call(value.accounts, normalizedDefaultAccount)) ctx.addIssue({
 			code: z.ZodIssueCode.custom,
 			path: ["defaultAccount"],
@@ -460,6 +373,556 @@ async function listFeishuDirectoryGroups(params) {
 	}).map((entry) => entry.id));
 }
 //#endregion
+//#region extensions/feishu/src/doctor.ts
+const FEISHU_STATE_DIR = "feishu";
+const BACKUP_PREFIX = "feishu-state-repair";
+const BLANK_USER_MESSAGE_REPAIR_THRESHOLD = 3;
+const SESSION_FILE_INSPECTION_MAX_BYTES = 16 * 1024 * 1024;
+function timestampForPath(now = /* @__PURE__ */ new Date()) {
+	return now.toISOString().replaceAll(":", "-");
+}
+function isRecord$1(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function toFeishuSessionEntry(value) {
+	if (!isRecord$1(value)) return {};
+	return {
+		sessionId: value.sessionId,
+		sessionFile: value.sessionFile
+	};
+}
+function countLabel(count, singular, plural = `${singular}s`) {
+	return `${count} ${count === 1 ? singular : plural}`;
+}
+function existsDir(dir) {
+	try {
+		return fs.statSync(dir).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function existsFile(filePath) {
+	try {
+		return fs.statSync(filePath).isFile();
+	} catch {
+		return false;
+	}
+}
+function safeReadDir(dir) {
+	try {
+		return fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+}
+function isPathWithinRoot(targetPath, rootPath) {
+	const resolvedTarget = path.resolve(targetPath);
+	const resolvedRoot = path.resolve(rootPath);
+	const relative = path.relative(resolvedRoot, resolvedTarget);
+	return Boolean(relative) && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function formatDisplayPath(filePath) {
+	const home = os.homedir();
+	const resolved = path.resolve(filePath);
+	return resolved === home || resolved.startsWith(`${home}${path.sep}`) ? `~${resolved.slice(home.length)}` : resolved;
+}
+function formatFinding(finding) {
+	switch (finding.kind) {
+		case "corrupt-state-json": return `- Feishu local JSON state is corrupt: ${formatDisplayPath(finding.path)}`;
+		case "missing-session-transcript": return `- Feishu session ${finding.sessionKey} points to a missing transcript in ${formatDisplayPath(finding.storePath)}`;
+		case "invalid-session-transcript": return `- Feishu session ${finding.sessionKey} has an invalid transcript (${finding.reason}): ${formatDisplayPath(finding.path)}`;
+		case "blank-user-message-run": return `- Feishu session ${finding.sessionKey} contains ${finding.count} blank user messages: ${formatDisplayPath(finding.path)}`;
+	}
+	return finding;
+}
+function isFeishuSessionStoreKey(key) {
+	const normalized = key.trim().toLowerCase();
+	return /^agent:[^:]+:feishu(?::|$)/.test(normalized) || /^feishu(?::|$)/.test(normalized);
+}
+function isFeishuAcpBindingSessionKey(key) {
+	return /^agent:[^:]+:acp:binding:feishu(?::|$)/.test(key.trim().toLowerCase());
+}
+function normalizeMetadataString(value) {
+	return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function isFeishuSessionEntry(key, value) {
+	if (isFeishuAcpBindingSessionKey(key)) return false;
+	if (isFeishuSessionStoreKey(key)) return true;
+	if (!isRecord$1(value)) return false;
+	if (normalizeMetadataString(value.channel) === "feishu" || normalizeMetadataString(value.lastChannel) === "feishu") return true;
+	if (normalizeMetadataString((isRecord$1(value.route) ? value.route : null)?.channel) === "feishu") return true;
+	if (normalizeMetadataString((isRecord$1(value.deliveryContext) ? value.deliveryContext : null)?.channel) === "feishu") return true;
+	if (normalizeMetadataString((isRecord$1(value.pendingFinalDeliveryContext) ? value.pendingFinalDeliveryContext : null)?.channel) === "feishu") return true;
+	const origin = isRecord$1(value.origin) ? value.origin : null;
+	const originProvider = normalizeMetadataString(origin?.provider);
+	const originSurface = normalizeMetadataString(origin?.surface);
+	const originFrom = normalizeMetadataString(origin?.from);
+	return originProvider === "feishu" || originSurface.startsWith("feishu") || originFrom.startsWith("feishu:");
+}
+function collectConfiguredAgentIds(cfg) {
+	const ids = /* @__PURE__ */ new Set();
+	ids.add(resolveConfiguredDefaultAgentId(cfg));
+	for (const agent of cfg.agents?.list ?? []) if (typeof agent.id === "string" && agent.id.trim()) ids.add(normalizeAgentId(agent.id));
+	return [...ids].toSorted();
+}
+function resolveConfiguredDefaultAgentId(cfg) {
+	const agents = cfg.agents?.list ?? [];
+	const chosen = agents.find((agent) => agent?.default) ?? agents[0];
+	return normalizeAgentId(typeof chosen?.id === "string" && chosen.id.trim() ? chosen.id : "main");
+}
+function collectFeishuSessionTargets(params) {
+	const byStorePath = /* @__PURE__ */ new Map();
+	const addTarget = (target) => {
+		byStorePath.set(path.resolve(target.storePath), {
+			...target,
+			storePath: path.resolve(target.storePath)
+		});
+	};
+	for (const agentId of collectConfiguredAgentIds(params.cfg)) addTarget({
+		agentId,
+		storePath: resolveStorePath(params.cfg.session?.store, {
+			agentId,
+			env: params.env
+		})
+	});
+	const agentsDir = path.join(params.stateDir, "agents");
+	for (const agentDir of safeReadDir(agentsDir)) {
+		if (!agentDir.isDirectory()) continue;
+		const agentId = normalizeAgentId(agentDir.name);
+		const storePath = path.join(agentsDir, agentDir.name, "sessions", "sessions.json");
+		if (existsFile(storePath)) addTarget({
+			agentId,
+			storePath
+		});
+	}
+	return [...byStorePath.values()].toSorted((left, right) => left.storePath.localeCompare(right.storePath));
+}
+function collectJsonFiles(rootDir, limit = 200) {
+	const files = [];
+	const visit = (dir) => {
+		if (files.length >= limit) return;
+		for (const entry of safeReadDir(dir).toSorted((left, right) => left.name.localeCompare(right.name))) {
+			const fullPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				visit(fullPath);
+				continue;
+			}
+			if (entry.isFile() && entry.name.endsWith(".json")) files.push(fullPath);
+			if (files.length >= limit) return;
+		}
+	};
+	if (existsDir(rootDir)) visit(rootDir);
+	return files;
+}
+function collectCorruptFeishuStateJsonFindings(feishuStateDir) {
+	const findings = [];
+	for (const filePath of collectJsonFiles(feishuStateDir)) try {
+		JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	} catch {
+		findings.push({
+			kind: "corrupt-state-json",
+			path: filePath
+		});
+	}
+	return findings;
+}
+function resolveSessionTranscriptCandidates(params) {
+	const candidates = /* @__PURE__ */ new Set();
+	const sessionsDir = path.dirname(params.storePath);
+	const addSafeCandidate = (candidate) => {
+		const resolved = path.isAbsolute(candidate) ? path.resolve(candidate) : path.resolve(sessionsDir, candidate);
+		if (resolved === sessionsDir || !isPathWithinRoot(resolved, sessionsDir)) return;
+		candidates.add(resolved);
+	};
+	if (typeof params.entry.sessionId === "string" && /^[a-z0-9][a-z0-9._-]{0,127}$/i.test(params.entry.sessionId)) {
+		candidates.add(resolveSessionFilePath(params.entry.sessionId, typeof params.entry.sessionFile === "string" ? { sessionFile: params.entry.sessionFile } : void 0, {
+			agentId: params.agentId,
+			sessionsDir
+		}));
+		return [...candidates].toSorted();
+	}
+	if (typeof params.entry.sessionFile === "string" && params.entry.sessionFile.trim()) addSafeCandidate(params.entry.sessionFile.trim());
+	return [...candidates].toSorted();
+}
+function isSessionHeader(value) {
+	return isRecord$1(value) && value.type === "session" && typeof value.id === "string";
+}
+function isBlankUserMessage(value) {
+	if (!isRecord$1(value) || value.type !== "message" || !isRecord$1(value.message)) return false;
+	if (value.message.role !== "user") return false;
+	const content = value.message.content;
+	if (typeof content === "string") return content.trim().length === 0;
+	return Array.isArray(content) && content.length === 0;
+}
+function isUserMessage(value) {
+	return isRecord$1(value) && value.type === "message" && isRecord$1(value.message) && value.message.role === "user";
+}
+function inspectSessionTranscript(params) {
+	let stat;
+	try {
+		stat = fs.statSync(params.transcriptPath);
+	} catch {
+		return null;
+	}
+	if (!stat.isFile()) return {
+		kind: "invalid-session-transcript",
+		sessionKey: params.sessionKey,
+		storePath: params.storePath,
+		path: params.transcriptPath,
+		reason: "not a file"
+	};
+	if (stat.size > SESSION_FILE_INSPECTION_MAX_BYTES) return null;
+	let raw = "";
+	try {
+		raw = fs.readFileSync(params.transcriptPath, "utf-8");
+	} catch {
+		return {
+			kind: "invalid-session-transcript",
+			sessionKey: params.sessionKey,
+			storePath: params.storePath,
+			path: params.transcriptPath,
+			reason: "unreadable"
+		};
+	}
+	const entries = [];
+	let malformedLines = 0;
+	let blankUserMessageRun = 0;
+	let maxBlankUserMessageRun = 0;
+	for (const line of raw.split(/\r?\n/)) {
+		if (!line.trim()) continue;
+		try {
+			const entry = JSON.parse(line);
+			entries.push(entry);
+			if (isBlankUserMessage(entry)) {
+				blankUserMessageRun += 1;
+				maxBlankUserMessageRun = Math.max(maxBlankUserMessageRun, blankUserMessageRun);
+			} else if (isUserMessage(entry)) blankUserMessageRun = 0;
+		} catch {
+			malformedLines += 1;
+		}
+	}
+	if (entries.length === 0) return {
+		kind: "invalid-session-transcript",
+		sessionKey: params.sessionKey,
+		storePath: params.storePath,
+		path: params.transcriptPath,
+		reason: "empty transcript"
+	};
+	if (!isSessionHeader(entries[0])) return {
+		kind: "invalid-session-transcript",
+		sessionKey: params.sessionKey,
+		storePath: params.storePath,
+		path: params.transcriptPath,
+		reason: "invalid session header"
+	};
+	if (malformedLines > 0) return {
+		kind: "invalid-session-transcript",
+		sessionKey: params.sessionKey,
+		storePath: params.storePath,
+		path: params.transcriptPath,
+		reason: `${malformedLines} malformed JSONL line(s)`
+	};
+	if (maxBlankUserMessageRun >= BLANK_USER_MESSAGE_REPAIR_THRESHOLD) return {
+		kind: "blank-user-message-run",
+		sessionKey: params.sessionKey,
+		storePath: params.storePath,
+		path: params.transcriptPath,
+		count: maxBlankUserMessageRun
+	};
+	return null;
+}
+function collectFeishuSessionFindings(params) {
+	const transcriptCandidates = resolveSessionTranscriptCandidates(params);
+	const existing = transcriptCandidates.filter(existsFile);
+	if (transcriptCandidates.length > 0 && existing.length === 0) return [{
+		kind: "missing-session-transcript",
+		sessionKey: params.sessionKey,
+		storePath: params.storePath
+	}];
+	const findings = [];
+	for (const transcriptPath of existing) {
+		const finding = inspectSessionTranscript({
+			sessionKey: params.sessionKey,
+			storePath: params.storePath,
+			transcriptPath
+		});
+		if (finding) findings.push(finding);
+	}
+	return findings;
+}
+function hasCorruptFeishuStateJsonFinding(inspection) {
+	return inspection.findings.some((finding) => finding.kind === "corrupt-state-json");
+}
+function sessionEntryId(storePath, key) {
+	return `${path.resolve(storePath)}\0${key}`;
+}
+function collectRepairSessionEntries(inspection) {
+	const entriesById = /* @__PURE__ */ new Map();
+	for (const entry of inspection.sessionEntries) entriesById.set(sessionEntryId(entry.storePath, entry.key), entry);
+	const repairEntries = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const finding of inspection.findings) {
+		if (finding.kind === "corrupt-state-json") continue;
+		const id = sessionEntryId(finding.storePath, finding.sessionKey);
+		if (seen.has(id)) continue;
+		const entry = entriesById.get(id);
+		if (entry) {
+			repairEntries.push(entry);
+			seen.add(id);
+		}
+	}
+	return repairEntries.toSorted((left, right) => left.storePath.localeCompare(right.storePath) || left.key.localeCompare(right.key));
+}
+function inspectFeishuDoctorState(params) {
+	const env = params.env ?? process.env;
+	const stateDir = resolveStateDir(env, os.homedir);
+	const feishuStateDir = path.join(stateDir, FEISHU_STATE_DIR);
+	const findings = collectCorruptFeishuStateJsonFindings(feishuStateDir);
+	const sessionEntries = [];
+	for (const target of collectFeishuSessionTargets({
+		cfg: params.cfg,
+		env,
+		stateDir
+	})) {
+		const store = loadSessionStore(target.storePath, { skipCache: true });
+		for (const [key, entry] of Object.entries(store).toSorted(([left], [right]) => left.localeCompare(right))) {
+			if (!isFeishuSessionEntry(key, entry)) continue;
+			const sessionEntry = toFeishuSessionEntry(entry);
+			sessionEntries.push({
+				key,
+				storePath: target.storePath,
+				agentId: target.agentId,
+				entry: sessionEntry
+			});
+			findings.push(...collectFeishuSessionFindings({
+				sessionKey: key,
+				storePath: target.storePath,
+				agentId: target.agentId,
+				entry: sessionEntry
+			}));
+		}
+	}
+	return {
+		stateDir,
+		feishuStateDir,
+		findings,
+		sessionEntries
+	};
+}
+function ensureBackupDir(stateDir, now) {
+	const backupDir = path.join(stateDir, "backups", `${BACKUP_PREFIX}-${timestampForPath(now)}`);
+	fs.mkdirSync(backupDir, {
+		recursive: true,
+		mode: 448
+	});
+	return backupDir;
+}
+function resolveUniquePath(candidate) {
+	if (!fs.existsSync(candidate)) return candidate;
+	for (let index = 1; index < 1e3; index += 1) {
+		const next = `${candidate}.${index}`;
+		if (!fs.existsSync(next)) return next;
+	}
+	throw new Error(`Unable to resolve unique path for ${candidate}`);
+}
+function movePathToBackup(params) {
+	if (!fs.existsSync(params.sourcePath)) return false;
+	const targetPath = resolveUniquePath(path.join(params.backupDir, params.relativeTarget));
+	fs.mkdirSync(path.dirname(targetPath), {
+		recursive: true,
+		mode: 448
+	});
+	fs.renameSync(params.sourcePath, targetPath);
+	return true;
+}
+function copyStoreBackup(params) {
+	if (!existsFile(params.storePath)) return;
+	const targetPath = path.join(params.backupDir, "session-stores", params.agentId, path.basename(params.storePath));
+	fs.mkdirSync(path.dirname(targetPath), {
+		recursive: true,
+		mode: 448
+	});
+	fs.copyFileSync(params.storePath, resolveUniquePath(targetPath));
+}
+function collectSessionArtifactPaths(params) {
+	const artifacts = /* @__PURE__ */ new Set();
+	for (const transcriptPath of resolveSessionTranscriptCandidates(params)) {
+		artifacts.add(transcriptPath);
+		if (transcriptPath.endsWith(".jsonl")) {
+			const base = transcriptPath.slice(0, -6);
+			artifacts.add(`${base}.trajectory.jsonl`);
+			artifacts.add(`${base}.trajectory-path.json`);
+		}
+	}
+	return [...artifacts].toSorted();
+}
+function archiveSessionArtifacts(params) {
+	const seen = /* @__PURE__ */ new Set();
+	let archived = 0;
+	for (const entry of params.entries) for (const artifactPath of collectSessionArtifactPaths({
+		storePath: params.storePath,
+		agentId: entry.agentId,
+		entry: entry.entry
+	})) {
+		if (seen.has(artifactPath) || !existsFile(artifactPath)) continue;
+		seen.add(artifactPath);
+		const archivedPath = resolveUniquePath(`${artifactPath}.deleted.${params.archiveTimestamp}`);
+		fs.renameSync(artifactPath, archivedPath);
+		archived += 1;
+	}
+	return archived;
+}
+async function repairFeishuDoctorState(params) {
+	const env = params.env ?? process.env;
+	const now = params.now ?? /* @__PURE__ */ new Date();
+	const inspection = params.inspection ?? inspectFeishuDoctorState({
+		cfg: params.cfg,
+		env
+	});
+	const backupDir = ensureBackupDir(inspection.stateDir, now);
+	const archiveTimestamp = timestampForPath(now);
+	const warnings = [];
+	const stateDirRepairAttempted = hasCorruptFeishuStateJsonFinding(inspection);
+	let rebuiltStateDir = false;
+	if (stateDirRepairAttempted) try {
+		rebuiltStateDir = movePathToBackup({
+			sourcePath: inspection.feishuStateDir,
+			backupDir,
+			relativeTarget: FEISHU_STATE_DIR
+		});
+		fs.mkdirSync(inspection.feishuStateDir, {
+			recursive: true,
+			mode: 448
+		});
+	} catch (error) {
+		warnings.push(`- Failed to rebuild Feishu local state: ${String(error)}`);
+	}
+	const entriesByStore = /* @__PURE__ */ new Map();
+	for (const entry of collectRepairSessionEntries(inspection)) {
+		const existing = entriesByStore.get(entry.storePath);
+		if (existing) existing.entries.push({
+			key: entry.key,
+			entry: entry.entry
+		});
+		else entriesByStore.set(entry.storePath, {
+			agentId: entry.agentId,
+			entries: [{
+				key: entry.key,
+				entry: entry.entry
+			}]
+		});
+	}
+	let removedSessionEntries = 0;
+	let touchedSessionStores = 0;
+	let archivedSessionArtifacts = 0;
+	for (const [storePath, group] of [...entriesByStore.entries()].toSorted(([left], [right]) => left.localeCompare(right))) try {
+		copyStoreBackup({
+			storePath,
+			backupDir,
+			agentId: group.agentId
+		});
+		const keys = new Set(group.entries.map((entry) => entry.key));
+		const removedEntries = await updateSessionStore(storePath, (store) => {
+			const removed = [];
+			for (const key of keys) if (Object.prototype.hasOwnProperty.call(store, key)) {
+				delete store[key];
+				const entry = group.entries.find((candidate) => candidate.key === key);
+				if (entry) removed.push(entry);
+			}
+			return removed;
+		}, {
+			skipMaintenance: true,
+			allowDropAcpMetaSessionKeys: [...keys]
+		});
+		const removed = removedEntries.length;
+		removedSessionEntries += removed;
+		if (removed > 0) {
+			touchedSessionStores += 1;
+			archivedSessionArtifacts += archiveSessionArtifacts({
+				storePath,
+				entries: removedEntries.map((entry) => ({
+					agentId: group.agentId,
+					entry: entry.entry
+				})),
+				archiveTimestamp
+			});
+		}
+	} catch (error) {
+		warnings.push(`- Failed to archive Feishu sessions in ${formatDisplayPath(storePath)}: ${String(error)}`);
+	}
+	return {
+		backupDir,
+		stateDirRepairAttempted,
+		rebuiltStateDir,
+		removedSessionEntries,
+		touchedSessionStores,
+		archivedSessionArtifacts,
+		warnings
+	};
+}
+function formatPreviewWarning(inspection) {
+	const previewFindings = inspection.findings.slice(0, 5).map(formatFinding);
+	const remaining = inspection.findings.length - previewFindings.length;
+	const repairActions = [];
+	if (hasCorruptFeishuStateJsonFinding(inspection)) repairActions.push(`archive ${formatDisplayPath(inspection.feishuStateDir)}`);
+	const repairSessionEntries = collectRepairSessionEntries(inspection);
+	if (repairSessionEntries.length > 0) repairActions.push(`archive artifacts and remove ${countLabel(repairSessionEntries.length, "flagged Feishu-scoped session entry", "flagged Feishu-scoped session entries")}`);
+	const repairSummary = repairActions.length > 0 ? repairActions.join(" and ") : "apply targeted Feishu state cleanup";
+	return [
+		"- Feishu local channel state may need repair.",
+		...previewFindings,
+		...remaining > 0 ? [`- ...and ${remaining} more Feishu state finding(s).`] : [],
+		`- Repair will ${repairSummary}, while preserving Feishu App ID/secret config and healthy session entries.`,
+		"- Run \"openclaw doctor --fix\" to rebuild Feishu local state."
+	].join("\n");
+}
+function formatRepairChange(report) {
+	const stateRepairStatus = report.stateDirRepairAttempted ? report.rebuiltStateDir ? "yes" : "no existing state" : "not needed";
+	return [
+		"Feishu local state repaired.",
+		`- Backup dir: ${formatDisplayPath(report.backupDir)}`,
+		`- Rebuilt Feishu runtime state: ${stateRepairStatus}`,
+		`- Removed ${countLabel(report.removedSessionEntries, "Feishu-scoped session entry", "Feishu-scoped session entries")} from ${countLabel(report.touchedSessionStores, "session store")}.`,
+		`- Archived ${countLabel(report.archivedSessionArtifacts, "session artifact file")}.`,
+		"- Preserved Feishu App ID/secret config."
+	].join("\n");
+}
+function hasConfiguredFeishuChannel(cfg) {
+	return Boolean(cfg.channels?.feishu);
+}
+async function runFeishuDoctorSequence(params) {
+	if (!hasConfiguredFeishuChannel(params.cfg)) return {
+		changeNotes: [],
+		warningNotes: []
+	};
+	const inspection = inspectFeishuDoctorState({
+		cfg: params.cfg,
+		env: params.env
+	});
+	if (inspection.findings.length === 0) return {
+		changeNotes: [],
+		warningNotes: []
+	};
+	if (!params.shouldRepair) return {
+		changeNotes: [],
+		warningNotes: [formatPreviewWarning(inspection)]
+	};
+	const report = await repairFeishuDoctorState({
+		cfg: params.cfg,
+		env: params.env,
+		inspection
+	});
+	return {
+		changeNotes: [formatRepairChange(report)],
+		warningNotes: report.warnings
+	};
+}
+const feishuDoctor = { runConfigSequence: async ({ cfg, env, shouldRepair }) => await runFeishuDoctorSequence({
+	cfg,
+	env,
+	shouldRepair
+}) };
+//#endregion
 //#region extensions/feishu/src/policy.ts
 const FEISHU_PROVIDER_PREFIX_RE = /^(feishu|lark):/i;
 const FEISHU_TYPED_PREFIX_RE = /^(chat|group|channel|user|dm|open_id):/i;
@@ -519,7 +982,7 @@ function createFeishuIngressSubject(params) {
 function createFeishuIngressResolver(params) {
 	return createChannelIngressResolver({
 		channelId: "feishu",
-		accountId: normalizeAccountId(params.accountId) ?? "default",
+		accountId: normalizeAccountId$1(params.accountId) ?? "default",
 		identity: feishuIngressIdentity,
 		cfg: params.cfg,
 		...params.readAllowFromStore ? { readStoreAllowFrom: params.readAllowFromStore } : {}
@@ -625,8 +1088,8 @@ function resolveFeishuReplyPolicy(params) {
 	const resolvedCfg = resolveMergedAccountConfig({
 		channelConfig: feishuCfg,
 		accounts: feishuCfg?.accounts,
-		accountId: normalizeAccountId(params.accountId),
-		normalizeAccountId,
+		accountId: normalizeAccountId$1(params.accountId),
+		normalizeAccountId: normalizeAccountId$1,
 		omitKeys: ["defaultAccount"]
 	});
 	const groupRequireMention = resolveFeishuGroupConfig({
@@ -636,46 +1099,120 @@ function resolveFeishuReplyPolicy(params) {
 	return { requireMention: typeof groupRequireMention === "boolean" ? groupRequireMention : typeof resolvedCfg.requireMention === "boolean" ? resolvedCfg.requireMention : params.groupPolicy !== "open" };
 }
 //#endregion
-//#region extensions/feishu/src/send-result.ts
-function resolveFeishuReceiptKind(msgType) {
-	switch (msgType) {
-		case "audio": return "voice";
-		case "image":
-		case "media":
-		case "file": return "media";
-		case "interactive": return "card";
-		case "post":
-		case "text": return "text";
-		default: return "unknown";
+//#region extensions/feishu/src/presentation-card.ts
+function escapeFeishuCardMarkdownText(text) {
+	return text.replace(/[&<>]/g, (char) => {
+		switch (char) {
+			case "&": return "&amp;";
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			default: return char;
+		}
+	});
+}
+function resolveSafeFeishuButtonUrl(url) {
+	const trimmed = url?.trim();
+	if (!trimmed) return;
+	try {
+		const parsed = new URL(trimmed);
+		return parsed.protocol === "https:" || parsed.protocol === "http:" ? trimmed : void 0;
+	} catch {
+		return;
 	}
 }
-function createFeishuSendReceipt(params) {
-	const messageId = params.messageId?.trim();
-	const chatId = params.chatId.trim();
-	return createMessageReceiptFromOutboundResults({
-		results: messageId ? [{
-			channel: "feishu",
-			messageId,
-			chatId,
-			conversationId: chatId
-		}] : [],
-		...chatId ? { threadId: chatId } : {},
-		kind: params.kind ?? "unknown"
+function resolveFeishuButtonUrl(button) {
+	return button.url ?? button.webApp?.url ?? button.web_app?.url;
+}
+function mapFeishuButtonType(style) {
+	if (style === "primary" || style === "success") return "primary";
+	if (style === "danger") return "danger";
+	return "default";
+}
+function buildFeishuPayloadButton(button) {
+	const behaviors = [];
+	const rendered = {
+		tag: "button",
+		text: {
+			tag: "plain_text",
+			content: button.label
+		},
+		type: mapFeishuButtonType(button.style)
+	};
+	const url = resolveFeishuButtonUrl(button);
+	if (url) {
+		const safeUrl = resolveSafeFeishuButtonUrl(url);
+		if (safeUrl) behaviors.push({
+			type: "open_url",
+			default_url: safeUrl
+		});
+	}
+	if (button.value) behaviors.push({
+		type: "callback",
+		value: createFeishuCardInteractionEnvelope({
+			k: "quick",
+			a: "feishu.payload.button",
+			q: button.value
+		})
 	});
+	if (behaviors.length === 0) return;
+	rendered.behaviors = behaviors;
+	return rendered;
+}
+function buildFeishuCardElementsForBlock(block) {
+	if (block.type === "text") return [{
+		tag: "markdown",
+		content: escapeFeishuCardMarkdownText(block.text)
+	}];
+	if (block.type === "context") return [{
+		tag: "markdown",
+		content: `<font color='grey'>${escapeFeishuCardMarkdownText(block.text)}</font>`
+	}];
+	if (block.type === "divider") return [{ tag: "hr" }];
+	if (block.type === "buttons") return block.buttons.map((button) => buildFeishuPayloadButton(button)).filter((button) => Boolean(button));
+	const labels = block.options.map((option) => `- ${option.label}`).join("\n");
+	return [{
+		tag: "markdown",
+		content: `${escapeFeishuCardMarkdownText(block.placeholder?.trim() || "Options")}:\n${escapeFeishuCardMarkdownText(labels)}`
+	}];
+}
+function resolvePresentationHeaderTemplate(tone) {
+	if (tone === "danger") return "red";
+	if (tone === "warning") return "orange";
+	if (tone === "success") return "green";
+	return "blue";
+}
+function buildFeishuPresentationCardElements(params) {
+	const elements = [];
+	const fallbackText = params.fallbackText?.trim();
+	if (fallbackText) elements.push({
+		tag: "markdown",
+		content: escapeFeishuCardMarkdownText(fallbackText)
+	});
+	for (const block of params.presentation.blocks) for (const element of buildFeishuCardElementsForBlock(block)) elements.push(element);
+	if (elements.length > 0) return elements;
+	return [{
+		tag: "markdown",
+		content: renderMessagePresentationFallbackText({
+			text: params.fallbackText,
+			presentation: params.presentation.title ? {
+				...params.presentation.tone ? { tone: params.presentation.tone } : {},
+				blocks: params.presentation.blocks
+			} : params.presentation
+		})
+	}];
 }
-function assertFeishuMessageApiSuccess(response, errorPrefix) {
-	if (response.code !== 0) throw new Error(`${errorPrefix}: ${response.msg || `code ${response.code}`}`);
-}
-function toFeishuSendResult(response, chatId, kind) {
-	const messageId = response.data?.message_id ?? "unknown";
+function buildFeishuPresentationCard(params) {
 	return {
-		messageId,
-		chatId,
-		receipt: createFeishuSendReceipt({
-			messageId,
-			chatId,
-			kind
-		})
+		schema: "2.0",
+		config: { width_mode: "fill" },
+		...params.presentation.title ? { header: {
+			title: {
+				tag: "plain_text",
+				content: params.presentation.title
+			},
+			template: resolvePresentationHeaderTemplate(params.presentation.tone)
+		} } : {},
+		body: { elements: buildFeishuPresentationCardElements(params) }
 	};
 }
 //#endregion
@@ -756,19 +1293,15 @@ const t = createSetupTranslator();
 const channel = "feishu";
 const SCAN_TO_CREATE_TP = "ob_cli_app";
 const FEISHU_SETUP_FLOW_KEY = "_flow";
-function normalizeString(value) {
-	if (typeof value !== "string") return;
-	return value.trim() || void 0;
-}
 function isFeishuConfigured(cfg) {
 	const feishuCfg = cfg.channels?.feishu;
 	const isAppIdConfigured = (value) => {
-		if (normalizeString(value)) return true;
+		if (normalizeOptionalString(value)) return true;
 		if (!value || typeof value !== "object") return false;
 		const rec = value;
-		const source = normalizeString(rec.source)?.toLowerCase();
-		const id = normalizeString(rec.id);
-		if (source === "env" && id) return Boolean(normalizeString(process.env[id]));
+		const source = normalizeOptionalString(rec.source)?.toLowerCase();
+		const id = normalizeOptionalString(rec.id);
+		if (source === "env" && id) return Boolean(normalizeOptionalString(process.env[id]));
 		return hasConfiguredSecretInput$1(value);
 	};
 	const topLevelConfigured = isAppIdConfigured(feishuCfg?.appId) && hasConfiguredSecretInput$1(feishuCfg?.appSecret);
@@ -984,7 +1517,7 @@ async function runNewAppFlow(params) {
 		await noteFeishuCredentialHelp(prompter);
 		appId = await promptFeishuAppId({
 			prompter,
-			initialValue: normalizeString(process.env.FEISHU_APP_ID)
+			initialValue: normalizeOptionalString(process.env.FEISHU_APP_ID)
 		});
 		const appSecretResult = await promptSingleChannelSecretInput({
 			cfg: next,
@@ -1049,11 +1582,11 @@ async function runEditFlow(params) {
 	const next = params.cfg;
 	const feishuCfg = next.channels?.feishu;
 	const resolveAppIdLabel = (value) => {
-		const asString = normalizeString(value);
+		const asString = normalizeOptionalString(value);
 		if (asString) return asString;
 		if (value && typeof value === "object") {
 			const rec = value;
-			if (normalizeString(rec.source) && normalizeString(rec.id)) return normalizeString(process.env[rec.id]) ?? `env:${String(rec.id)}`;
+			if (normalizeOptionalString(rec.source) && normalizeOptionalString(rec.id)) return normalizeOptionalString(process.env[rec.id]) ?? `env:${String(rec.id)}`;
 			if (hasConfiguredSecretInput$1(value)) return "(configured)";
 		}
 	};
@@ -1171,12 +1704,13 @@ function readBooleanParam(params, keys) {
 	}
 }
 function hasLegacyFeishuCardCommandValue(actionValue) {
-	return isRecord$1(actionValue) && actionValue.oc !== "ocf1" && (Boolean(typeof actionValue.command === "string" && actionValue.command.trim()) || Boolean(typeof actionValue.text === "string" && actionValue.text.trim()));
+	return isRecord$2(actionValue) && actionValue.oc !== "ocf1" && (Boolean(typeof actionValue.command === "string" && actionValue.command.trim()) || Boolean(typeof actionValue.text === "string" && actionValue.text.trim()));
 }
 function containsLegacyFeishuCardCommandValue(node) {
 	if (Array.isArray(node)) return node.some((item) => containsLegacyFeishuCardCommandValue(item));
-	if (!isRecord$1(node)) return false;
+	if (!isRecord$2(node)) return false;
 	if (node.tag === "button" && hasLegacyFeishuCardCommandValue(node.value)) return true;
+	if (node.tag === "button" && Array.isArray(node.behaviors) && node.behaviors.some((behavior) => isRecord$2(behavior) && hasLegacyFeishuCardCommandValue(behavior.value))) return true;
 	return Object.values(node).some((value) => containsLegacyFeishuCardCommandValue(value));
 }
 const meta = {
@@ -1189,7 +1723,7 @@ const meta = {
 	aliases: ["lark"],
 	order: 70
 };
-const loadFeishuChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-C8KEo0lg.js"), "feishuChannelRuntime");
+const loadFeishuChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-ItBg9SfS.js"), "feishuChannelRuntime");
 function toFeishuMessageSendResult(result, kind) {
 	const receipt = result.receipt ?? createFeishuSendReceipt({
 		messageId: result.messageId,
@@ -1220,30 +1754,6 @@ const feishuMessageAdapter = defineChannelMessageAdapter({
 		}
 	}
 });
-function buildFeishuPresentationCard(params) {
-	const fallbackPresentation = {
-		...params.presentation.tone ? { tone: params.presentation.tone } : {},
-		blocks: params.presentation.blocks
-	};
-	return {
-		schema: "2.0",
-		config: { width_mode: "fill" },
-		...params.presentation.title ? { header: {
-			title: {
-				tag: "plain_text",
-				content: params.presentation.title
-			},
-			template: "blue"
-		} } : {},
-		body: { elements: [{
-			tag: "markdown",
-			content: renderMessagePresentationFallbackText({
-				text: params.fallbackText,
-				presentation: fallbackPresentation
-			})
-		}] }
-	};
-}
 async function createFeishuActionClient(account) {
 	const { createFeishuClient } = await import("./client-BnH2fRL2.js").then((n) => n.t);
 	return createFeishuClient(account);
@@ -1544,6 +2054,7 @@ const feishuPlugin = createChatChannelPlugin({
 		},
 		mentions: { stripPatterns: () => ["<at user_id=\"[^\"]*\">[^<]*</at>"] },
 		reload: { configPrefixes: ["channels.feishu"] },
+		doctor: feishuDoctor,
 		configSchema: buildChannelConfigSchema(FeishuConfigSchema),
 		config: {
 			...feishuConfigAdapter,
@@ -2032,7 +2543,7 @@ const feishuPlugin = createChatChannelPlugin({
 			})
 		}),
 		gateway: { startAccount: async (ctx) => {
-			const { monitorFeishuProvider } = await import("./monitor-CPSt9A7K.js");
+			const { monitorFeishuProvider } = await import("./monitor-gFxvkDyO.js");
 			const account = resolveFeishuRuntimeAccount({
 				cfg: ctx.cfg,
 				accountId: ctx.accountId
@@ -2112,4 +2623,4 @@ const feishuPlugin = createChatChannelPlugin({
 	}
 });
 //#endregion
-export { listFeishuDirectoryPeers as _, setFeishuNamedAccountEnabled$1 as a, decodeFeishuCardAction as b, toFeishuSendResult as c, resolveFeishuDmIngressAccess as d, resolveFeishuGroupConfig as f, listFeishuDirectoryGroups as g, resolveFeishuReplyPolicy as h, feishuSetupAdapter as i, hasExplicitFeishuGroupConfig as l, resolveFeishuGroupSenderActivationIngressAccess as m, feishuSetupWizard as n, assertFeishuMessageApiSuccess as o, resolveFeishuGroupConversationIngressAccess as p, runFeishuLogin as r, resolveFeishuReceiptKind as s, feishuPlugin as t, normalizeFeishuAllowEntry as u, buildFeishuCardActionTextFallback as v, createFeishuCardInteractionEnvelope as y };
+export { setFeishuNamedAccountEnabled$1 as a, normalizeFeishuAllowEntry as c, resolveFeishuGroupConversationIngressAccess as d, resolveFeishuGroupSenderActivationIngressAccess as f, listFeishuDirectoryPeers as h, feishuSetupAdapter as i, resolveFeishuDmIngressAccess as l, listFeishuDirectoryGroups as m, feishuSetupWizard as n, buildFeishuPresentationCardElements as o, resolveFeishuReplyPolicy as p, runFeishuLogin as r, hasExplicitFeishuGroupConfig as s, feishuPlugin as t, resolveFeishuGroupConfig as u };