openclaw-lark-multi-agent 1.8.10 → 1.8.11

package/dist/feishu-bot.js

@@ -1319,11 +1319,20 @@ export class FeishuBot {
             return;
         // Session creation/model setup is not agent admission. Initialize a truly
         // new chat before asking for its live activity; never infer idle from a
-        // missing describe response. Setup errors keep the existing queue error path.
+        // missing describe response. A failed setup is not dispatch-idle evidence;
+        // retain this never-attempted input for paced reconciliation as well.
         try {
             await this.ensureSession(chatId);
         }
         catch {
+            if (unsubmitted() && !this.queueRuns.has(chatId) && !this.store.getDispatchCustody(this.config.name, chatId)) {
+                const row = this.store.getInsertion(this.config.name, chatId, rowId);
+                if (!row || row.state === 'pending' && row.activityUnbound && !row.attempted && !row.expectedRunId)
+                    this.store.saveInsertion(this.config.name, chatId, rowId, row?.insertionId || JSON.stringify([this.config.appId, chatId, messageId]), 'pending', {
+                        messageId, text, stopEpoch: epoch, sessionKey: this.getSessionKey(chatId), activityUnbound: true, attempted: false, expectedRunId: '',
+                        reason: 'session setup unavailable; retained without dispatch-idle proof',
+                    }, Date.now() + 5000);
+            }
             return;
         }
         if (!unsubmitted() || this.queueRuns.has(chatId) || this.store.getDispatchCustody(this.config.name, chatId))
@@ -1344,8 +1353,8 @@ export class FeishuBot {
         if (current ? fresh?.insertionId !== current.insertionId || fresh.state !== 'pending' || fresh.attempted === true || !fresh.activityUnbound || !!fresh.expectedRunId : !!fresh)
             return;
         const compatible = !activity.sessionId || !status.sessionId || activity.sessionId === status.sessionId;
-        const idle = compatible && !status.archived && !activity.archived && !activity.busyConfirmed &&
-            (status.idleConfirmed && !!status.sessionId || activity.idleConfirmed && !!activity.sessionId);
+        const idle = compatible && !status.running && !status.archived && !activity.archived && !activity.busyConfirmed &&
+            activity.idleConfirmed === true && !!activity.sessionId;
         if (idle) {
             if (current)
                 this.store.saveInsertion(this.config.name, chatId, rowId, current.insertionId, 'ordinary', { ...current, activityUnbound: false });
@@ -1374,11 +1383,9 @@ export class FeishuBot {
             return this.stopGeneration(chatId) === epoch && now?.id === saved.id && now?.batchId === saved.batchId && now?.runId === saved.runId &&
                 this.queueOwners.get(chatId) === local && (!local || local.batch === batch && local.runId === runId && (local.admitted === true || local.yielded === true) && local.collecting === true);
         };
-        if (!saved.yielded) {
-            const activity = await this.openclawClient.getSessionDispatchStatus?.(this.getSessionKey(chatId)).catch(() => null);
-            if (!unchanged() || !activity?.idleConfirmed || activity.archived || activity.sessionId !== saved.sessionId)
-                return false;
-        }
+        const activity = await this.openclawClient.getSessionDispatchStatus?.(this.getSessionKey(chatId)).catch(() => null);
+        if (!unchanged() || !activity?.idleConfirmed || activity.busyConfirmed || activity.archived || activity.sessionId !== saved.sessionId)
+            return false;
         const status = await this.openclawClient.getSessionRuntimeStatus(this.getSessionKey(chatId)).catch(() => null);
         if (!unchanged() || !status?.idleConfirmed || status.archived || status.sessionId !== saved.sessionId)
             return false;
@@ -1556,18 +1563,12 @@ export class FeishuBot {
                     const status = await this.openclawClient.getSessionRuntimeStatus(item.sessionKey).catch(() => null);
                     if (!stillCurrent())
                         continue;
-                    const rootSettled = await this.openclawClient.exactRunSettled?.(item.expectedRunId);
-                    if (!stillCurrent())
-                        continue;
-                    const activity = !owner && !rootSettled && status?.idleConfirmed ? await this.openclawClient.getSessionDispatchStatus?.(item.sessionKey).catch(() => null) : null;
+                    const activity = status?.idleConfirmed ? await this.openclawClient.getSessionDispatchStatus?.(item.sessionKey).catch(() => null) : null;
                     if (!stillCurrent())
                         continue;
-                    const currentIdle = activity?.idleConfirmed === true && activity.sessionId === item.sessionId && !activity.archived && status?.sessionId === item.sessionId;
+                    const currentIdle = activity?.idleConfirmed === true && !activity.busyConfirmed && activity.sessionId === item.sessionId && !activity.archived && status?.sessionId === item.sessionId;
                     const unchanged = this.queueOwners.get(chatId) === owner && owner?.batch === batchAtCheck && owner?.runId === runAtCheck;
-                    const target = this.store.getDeliveryRunTarget(this.config.name, chatId, item.expectedRunId);
-                    const dispatchReleased = target?.dispatchReleased === true && target.dispatchOwnerId === item.ownerId && target.dispatchBatchId === item.batchId &&
-                        target.sessionId === item.sessionId && status?.sessionId === item.sessionId && !status?.archived;
-                    if ((rootSettled === true || dispatchReleased || currentIdle) && status?.idleConfirmed === true && unchanged) {
+                    if (currentIdle && status?.idleConfirmed === true && unchanged) {
                         state = 'ordinary';
                         // Never expire a successor merely to schedule the old input.
                         if (runAtCheck === item.expectedRunId)

package/dist/openclaw-client.d.ts

@@ -71,6 +71,7 @@ export declare class OpenClawClient {
     /** Deduplicates 2026.8 canonical `agent.stream=tool` events against legacy
      * `stream=item` mirrors when a runtime emits both representations. */
     private recentToolEventKeys;
+    private privateInputToolCalls;
     private sessionSettlementCallbacks;
     private sessionMessageCallbacks;
     private progressCallbacks;
@@ -138,9 +139,18 @@ export declare class OpenClawClient {
     connect(): Promise<void>;
     private _doConnect;
     private extractVisibleUserText;
+    /** Role is presentation, not authorship. Core's public forwarded-message
+     * projection preserves these input markers even when it changes user to
+     * assistant. Stream events without a message/role remain supported; never
+     * inspect run-level inputProvenance (a real reply may answer such an input). */
+    private isInputRecord;
     private extractVisibleAssistantText;
     private isVerboseTranscriptEnabled;
     private clearVerboseAssistantState;
+    /** Internal message tools carry private input, not assistant narration.
+     * Redact before buffering as well as progress callbacks (including failure
+     * summaries). Preserve tool identity/phase for activity and acceptance logic. */
+    private redactPrivateInputTool;
     /** Render protocol-4 structured tool args/results without `[object Object]`.
      * Prefer useful, non-secret fields and keep the fallback bounded. */
     private formatToolValue;

package/dist/openclaw-client.js

@@ -82,6 +82,7 @@ export class OpenClawClient {
     /** Deduplicates 2026.8 canonical `agent.stream=tool` events against legacy
      * `stream=item` mirrors when a runtime emits both representations. */
     recentToolEventKeys = new Map();
+    privateInputToolCalls = new Set();
     sessionSettlementCallbacks = new Map();
     sessionMessageCallbacks = new Map();
     progressCallbacks = new Map();
@@ -344,6 +345,16 @@ export class OpenClawClient {
                             p.reject(new Error(`RPC error: ${JSON.stringify(frame.error)}`));
                     }
                 }
+                if (frame.event === 'agent' && ['tool', 'item'].includes(frame.payload?.stream))
+                    this.redactPrivateInputTool(frame.payload);
+                // Public transcript projections can render an INPUT as role=assistant
+                // (forwarded sessions_send / internal receipts). Reject its structured
+                // identity before any collector, proactive callback or progress buffer.
+                // Do not classify by text, run ownership, or a wrapping prompt prefix:
+                // genuine replies/quotes and external Cron/child outputs remain valid.
+                if ((frame.event === 'chat' ||
+                    frame.event === 'agent' && ['assistant', 'chatDelta'].includes(frame.payload?.stream)) && this.isInputRecord(frame.payload))
+                    return;
                 // Agent events — store per session key
                 if (frame.event === "agent" || frame.event === "chat") {
                     const sk = frame.payload?.sessionKey || "__default__";
@@ -412,7 +423,8 @@ export class OpenClawClient {
                         if (bucket.length > 2048)
                             bucket.splice(0, bucket.length - 2048);
                 }
-                if (frame.type === "event" && ["agent", "chat", "session.message"].includes(frame.event)) {
+                if (frame.type === "event" && ["agent", "chat", "session.message"].includes(frame.event) &&
+                    !(frame.event === 'session.message' && this.isInputRecord(frame.payload))) {
                     for (const observer of this.goEvidenceObservers) {
                         try {
                             observer({ channel: frame.event, payload: frame.payload });
@@ -448,7 +460,8 @@ export class OpenClawClient {
                         // in correct time order and flip the reaction to Get.
                         this.handleSteerConsumption(rawKey, visibleUserText);
                     }
-                    const visibleAssistantText = this.extractVisibleAssistantText(msg);
+                    const inputRecord = this.isInputRecord(frame.payload);
+                    const visibleAssistantText = inputRecord ? "" : this.extractVisibleAssistantText(msg);
                     if (visibleAssistantText) {
                         if (!this.agentEvents.has(rawKey))
                             this.agentEvents.set(rawKey, []);
@@ -459,7 +472,8 @@ export class OpenClawClient {
                             data: { deltaText: visibleAssistantText, delta: visibleAssistantText, replace: true },
                         });
                     }
-                    this.handleProactiveSessionMessage(rawKey, msg, frame.payload.runId, frame.payload.sessionId);
+                    if (!inputRecord)
+                        this.handleProactiveSessionMessage(rawKey, msg, frame.payload.runId, frame.payload.sessionId);
                     for (const wake of this.eventCollectors)
                         wake();
                     // Tool calls in assistant messages — skip, using agent item events instead
@@ -598,8 +612,26 @@ export class OpenClawClient {
             .join("\n")
             .trim();
     }
+    /** Role is presentation, not authorship. Core's public forwarded-message
+     * projection preserves these input markers even when it changes user to
+     * assistant. Stream events without a message/role remain supported; never
+     * inspect run-level inputProvenance (a real reply may answer such an input). */
+    isInputRecord(record) {
+        if (!record || typeof record !== 'object')
+            return false;
+        if (typeof record.role === 'string' && record.role !== 'assistant')
+            return true;
+        if (['external_user', 'inter_session', 'internal_system'].includes(record.provenance?.kind))
+            return true;
+        if (record.senderSession && typeof record.senderSession === 'object')
+            return true;
+        const inputKey = record.idempotencyKey ?? record.__openclaw?.idempotencyKey;
+        if (typeof inputKey === 'string' && inputKey.endsWith(':user'))
+            return true;
+        return this.isInputRecord(record.message) || this.isInputRecord(record.data);
+    }
     extractVisibleAssistantText(msg, options = {}) {
-        if (msg?.role !== "assistant")
+        if (msg?.role !== "assistant" || this.isInputRecord(msg))
             return "";
         const content = msg.content;
         // Extract only visible text parts and ignore thinking/tool blocks.
@@ -638,13 +670,48 @@ export class OpenClawClient {
             this.verboseAssistantLastTouched.delete(key);
         }
     }
+    /** Internal message tools carry private input, not assistant narration.
+     * Redact before buffering as well as progress callbacks (including failure
+     * summaries). Preserve tool identity/phase for activity and acceptance logic. */
+    redactPrivateInputTool(payload) {
+        const data = payload?.data;
+        if (!data || payload.stream === 'item' && data.kind !== 'tool')
+            return;
+        const name = String(data.name || data.toolName || '').split('.').pop();
+        const eventId = String(data.toolCallId || data.itemId || data.id || '').replace(/^(?:tool|command):/, '');
+        const key = JSON.stringify([this.canonicalSessionKey(payload.sessionKey || ''), payload.runId || '', eventId]);
+        let args = data.input ?? data.args ?? data.meta;
+        if (typeof args === 'string') {
+            try {
+                args = JSON.parse(args);
+            }
+            catch {
+                args = undefined;
+            }
+        }
+        const wrapped = name === 'tool_call' && /(?:^|[.:])sessions_(?:send|yield)$/.test(String(args?.id || ''));
+        const privateBody = name === 'sessions_send' || name === 'sessions_yield' || wrapped;
+        if (privateBody && eventId) {
+            this.privateInputToolCalls.add(key);
+            if (this.privateInputToolCalls.size > 2048)
+                this.privateInputToolCalls.delete(this.privateInputToolCalls.values().next().value);
+        }
+        if (!privateBody && !this.privateInputToolCalls.has(key))
+            return;
+        payload.data = Object.fromEntries(['kind', 'phase', 'name', 'toolName', 'toolCallId', 'itemId', 'id', 'isError'].filter(k => data[k] !== undefined).map(k => [k, data[k]]));
+    }
     /** Render protocol-4 structured tool args/results without `[object Object]`.
      * Prefer useful, non-secret fields and keep the fallback bounded. */
     formatToolValue(value, toolName, phase) {
         // sessions_yield.message is private resumed context. Do not mirror its
         // arguments/results (including JSON strings) into process cards or verbose
         // tool replies. This is redaction only, never evidence of a handoff.
-        if (toolName === "sessions_yield")
+        if (toolName === "sessions_yield" || toolName === "sessions_send")
+            return "";
+        // Generic public-tool wrapper: redact only the internal send operation,
+        // not all tool bodies or outputs. Its returned body can echo the input.
+        if (toolName === 'tool_call' && value && typeof value === 'object' &&
+            /(?:^|[.:])sessions_send$/.test(String(value.id || '')))
             return "";
         if (value === null || value === undefined || value === "")
             return "";
@@ -779,6 +846,8 @@ export class OpenClawClient {
         return true;
     }
     handleVerboseAssistantStream(payload) {
+        if (this.isInputRecord(payload))
+            return;
         const rawKey = payload?.sessionKey || "";
         if (!rawKey)
             return;
@@ -806,6 +875,8 @@ export class OpenClawClient {
         }
     }
     handleProactiveSessionMessage(rawKey, msg, runId, sessionId) {
+        if (this.isInputRecord(msg))
+            return false;
         const shortKey = rawKey.replace(/^agent:[^:]+:/, "");
         // Proactive assistant text messages. Cron/session-targeted runs often emit
         // structured content arrays rather than a plain string. Extract only visible
@@ -2123,16 +2194,93 @@ export class OpenClawClient {
      * terminal caches. Unknown/missing fields never authorize scheduling. */
     async getSessionDispatchStatus(sessionKey) {
         let timer;
+        const key = this.canonicalSessionKey(sessionKey), deadline = Date.now() + 1500;
+        // One budget covers the entire public pending scan, not 1500ms per page.
+        // Retained interrupted/cancelled inputs are recovery records, NOT runnable
+        // queue entries. Never delete, mutate or replay them to prove schedulability.
+        const scan = async () => {
+            let sessionId, total, before;
+            const seen = new Set(), cursors = new Set();
+            let headSignature = '';
+            const unknown = () => ({ idleConfirmed: false, sessionId });
+            const validId = (value) => value === undefined || typeof value === 'string' && !!value.trim();
+            for (let page = 0; page < 32; page++) {
+                const history = await this.rpc('chat.history', { sessionKey: key, limit: 20, ...(before ? { pendingBefore: before } : {}) }, 1500);
+                if (Date.now() >= deadline)
+                    return unknown();
+                const info = history?.sessionInfo;
+                const id = info?.sessionId || history?.sessionId;
+                if (!validId(info?.sessionId) || !validId(history?.sessionId) || history?.sessionKey !== key || typeof id !== 'string' || !id.trim() ||
+                    info?.sessionId && history?.sessionId && info.sessionId !== history.sessionId || sessionId && sessionId !== id)
+                    return unknown();
+                sessionId = id;
+                const base = { sessionId, archived: info?.archived === true };
+                if (base.archived)
+                    return { ...base, idleConfirmed: false };
+                if (info?.hasActiveRun === true || history?.inFlightRun)
+                    return { ...base, idleConfirmed: false, busyConfirmed: true,
+                        activeRunId: typeof history?.inFlightRun?.runId === 'string' ? history.inFlightRun.runId : undefined };
+                const pending = history?.pendingInputs;
+                if (!Number.isSafeInteger(pending?.total) || pending.total < 0 || total !== undefined && total !== pending.total)
+                    return unknown();
+                total = pending.total;
+                if (pending.queuedCount !== undefined && (!Number.isSafeInteger(pending.queuedCount) || pending.queuedCount < 0))
+                    return unknown();
+                if (pending.queuedCount > 0)
+                    return { ...base, idleConfirmed: false, busyConfirmed: true };
+                // Legacy empty pending responses omit items. Only total=0 can safely
+                // support that shape; a hidden/nonempty retained set is never guessed.
+                const items = pending.items === undefined && total === 0 ? [] : pending.items;
+                if (!Array.isArray(items))
+                    return unknown();
+                for (const item of items) {
+                    if (typeof item?.id !== 'string' || !item.id || !['queued', 'cancelled', 'interrupted'].includes(item.state) || seen.has(item.id))
+                        return unknown();
+                    seen.add(item.id);
+                    if (item.state === 'queued')
+                        return { ...base, idleConfirmed: false, busyConfirmed: true };
+                }
+                if (seen.size > total)
+                    return unknown();
+                const next = pending.nextBefore;
+                if (next !== undefined && (!Number.isSafeInteger(next) || next <= 0 || cursors.has(next) || before !== undefined && next >= before))
+                    return unknown();
+                const signature = JSON.stringify([id, total, info?.hasActiveRun, items.map((item) => [item.id, item.state]), next]);
+                if (page === 0)
+                    headSignature = signature;
+                if (next !== undefined) {
+                    cursors.add(next);
+                    before = next;
+                    continue;
+                }
+                if (info?.hasActiveRun !== false || seen.size !== total)
+                    return unknown();
+                if (page > 0) {
+                    // Pagination is not an atomic snapshot. Re-read the current head and
+                    // identity/activity before returning positive evidence to local CAS.
+                    const head = await this.rpc('chat.history', { sessionKey: key, limit: 20 }, 1500);
+                    const hi = head?.sessionInfo, hp = head?.pendingInputs, hid = hi?.sessionId || head?.sessionId;
+                    if (!validId(hi?.sessionId) || !validId(head?.sessionId) || head?.sessionKey !== key || hid !== id || hi?.sessionId && head?.sessionId && hi.sessionId !== head.sessionId)
+                        return unknown();
+                    if (hi?.archived === true)
+                        return { ...base, archived: true, idleConfirmed: false };
+                    if (hi?.hasActiveRun === true || head?.inFlightRun || Number.isSafeInteger(hp?.queuedCount) && hp.queuedCount > 0)
+                        return { ...base, idleConfirmed: false, busyConfirmed: true, activeRunId: typeof head?.inFlightRun?.runId === 'string' ? head.inFlightRun.runId : undefined };
+                    if (hp?.total !== total || hp?.queuedCount !== undefined && (!Number.isSafeInteger(hp.queuedCount) || hp.queuedCount < 0))
+                        return unknown();
+                    if (Array.isArray(hp?.items) && hp.items.some((item) => typeof item?.id === 'string' && item.id && item.state === 'queued'))
+                        return { ...base, idleConfirmed: false, busyConfirmed: true };
+                    if (!Array.isArray(hp?.items) || JSON.stringify([hid, hp.total, hi?.hasActiveRun, hp.items.map((item) => [item?.id, item?.state]), hp.nextBefore]) !== headSignature)
+                        return unknown();
+                }
+                return { ...base, idleConfirmed: true, busyConfirmed: false };
+            }
+            return unknown();
+        };
         try {
-            const key = this.canonicalSessionKey(sessionKey);
-            const history = await Promise.race([this.rpc('chat.history', { sessionKey: key, limit: 1 }, 1500),
-                new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('activity lookup timeout')), 1500); })]);
-            const info = history?.sessionInfo;
-            return { idleConfirmed: history?.sessionKey === key && info?.hasActiveRun === false &&
-                    history?.pendingInputs?.total === 0 && !history?.inFlightRun && info?.archived !== true,
-                sessionId: info?.sessionId || history?.sessionId, archived: info?.archived === true,
-                activeRunId: history?.sessionKey === key && typeof history?.inFlightRun?.runId === 'string' ? history.inFlightRun.runId : undefined,
-                busyConfirmed: history?.sessionKey === key && (info?.hasActiveRun === true || !!history?.inFlightRun || history?.pendingInputs?.total > 0) };
+            return await Promise.race([scan(), new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error('activity lookup timeout')), 1500);
+                })]);
         }
         catch {
             return { idleConfirmed: false };
@@ -2447,6 +2595,8 @@ export class OpenClawClient {
             ? { state: "stopped", reason: "exact_run_abort_receipt" } : verdict;
     }
     extractTextFromChatMessage(message) {
+        if (this.isInputRecord(message))
+            return "";
         const parts = Array.isArray(message?.content) ? message.content : [];
         return parts.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n").trim();
     }
@@ -3147,6 +3297,7 @@ export class OpenClawClient {
         this.verboseAssistantSent.clear();
         this.verboseAssistantLastTouched.clear();
         this.lastToolNamesByItemId.clear();
+        this.privateInputToolCalls.clear();
         this.recentToolEventKeys.clear();
         this.pendingSteerTexts.clear();
         this.steerConsumedCallbacks.clear();

package/docs/releases/1.8.11.md

@@ -0,0 +1,47 @@
+# 1.8.11 candidate — retained pending inputs and output attribution
+
+Local offline-tested candidate only. This note does not assert publication,
+runtime activation, real-model execution or Feishu delivery verification.
+
+## Correctness changes
+
+- Public `pendingInputs.total` counts retained records, not runnable work.
+  Complete, identity-matched `interrupted`/`cancelled` records no longer keep a
+  session perpetually busy. Queued inputs, real active runs and in-flight work
+  still block ordinary admission. Nothing clears or replays Gateway pending
+  records, SQLite business rows or stopped work.
+- Dispatch inspection follows `nextBefore` as `pendingBefore`, with a 20-row
+  request limit, a finite page cap and one 1500 ms overall budget. Missing or
+  hidden records, malformed states/identities, duplicate IDs/cursors and changed
+  page identity/total remain unknown. Multi-page idle proof rechecks the head;
+  this is conservative observation, not a transactional Gateway snapshot.
+- Every ordinary handoff uses positive matching dispatch-idle evidence, rather
+  than allowing describe-only idle to bypass unknown dispatch state. Existing
+  owner/batch/session/stop/admission-window fencing remains in force.
+  Proven never-attempted local inputs recover through ordinary paced/startup
+  admission; accepted, attempted/unknown and stopped inputs are not replayed.
+- Public transcript forwarding can display an input with `role:assistant`.
+  Structured input provenance, sender-session markers and public `:user` input
+  identities are now excluded before collector, proactive business delivery
+  and assistant progress sinks. Missing runId does not turn an input mirror
+  into an assistant reply. Internal send/yield tool bodies are also redacted
+  before progress/transcript buffering, including identified wrapper results.
+- Filtering is based on structured input identity, not body-prefix stripping,
+  quote matching, external run IDs, or the provenance of the *run's input*.
+  Genuine assistant partial/final output, literal quotations of the reported
+  wrapper, ordinary external/Cron results and real continuation replies retain
+  their existing output paths. Input receipts and SDK acceptance callbacks
+  retain their separate acknowledgment semantics.
+
+## Verification boundaries
+
+Offline tests exercise the actual WS receiver, Client/Bot collectors, progress
+cards, durable MessageStore/outbox and public SDK fixtures. Synthetic transports
+are explicitly distinguished from an incident raw-frame capture and from live
+platform acceptance. Public producer modules were inspected only as source;
+no private hashed helper was imported or executed and no OpenClaw host file was
+changed. The coordinated `lma-core` plugin remains **0.2.0**.
+
+Deployment, activation and live acceptance remain separate owner-controlled
+steps. This candidate does not repair individual historical business rows or
+retry already-delivered/internal input mirrors.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "1.8.10",
+  "version": "1.8.11",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {
@@ -74,7 +74,8 @@
     "plugins/lma-core/package.json",
     "plugins/lma-core/README.md",
     "docs/releases/1.8.5.md",
-    "docs/releases/1.8.10.md"
+    "docs/releases/1.8.10.md",
+    "docs/releases/1.8.11.md"
   ],
   "engines": {
     "node": ">=22"