openclaw-lark-multi-agent 1.8.19 → 1.8.21

package/dist/message-store.d.ts

@@ -8,8 +8,10 @@ export interface ChatInfo {
     members: string;
     /** Comma-separated member names */
     memberNames: string;
-    /** Which bot owns this chat (for p2p isolation) */
+    /** Display label of the p2p owner; not a durable identity once pinned. */
     ownerBot: string;
+    /** Stable application identity of the p2p owner. Empty on legacy rows. */
+    ownerAppId?: string;
     /** Legacy chat-level free discussion flag; per-bot mode is authoritative. */
     freeDiscussion: boolean;
     verbose: boolean;
@@ -169,7 +171,7 @@ export declare class MessageStore {
     recoverUnsentReservations(bot: string): number;
     saveAdmission(sessionKey: string, submissionId: string, state: string, record: object): void;
     listAdmissions(sessionKey: string): any[];
-    stopExactRun(sessionKey: string, runId: string): void;
+    stopExactRun(sessionKey: string, runId: string, userStopped?: boolean): void;
     isStoppedObservation(sessionKey: string, runId: string): boolean;
     hasUnconfirmedRunDelivery(bot: string, chat: string, runId: string): boolean;
     /** UI-only witness of an exact run's visible reply in the original Bot/chat.
@@ -188,6 +190,27 @@ export declare class MessageStore {
     hasYieldedObservation(sessionKey: string): boolean;
     getRunObservation(sessionKey: string, runId: string): any;
     runObservationState(sessionKey: string, runId: string): string | undefined;
+    /** Observed reply latency for this chat, from real delivered replies.
+     *
+     * Used to size the "input still unconfirmed" window. A fixed short timer
+     * misfired on slow sessions where nearly every legitimate reply took longer
+     * than the timer, producing a false "not confirmed" notice for a run that
+     * was in fact progressing normally. Returns null when there is no history. */
+    observedReplyLatencyMs(bot: string, chat: string): number | null;
+    /** True only when THIS run was explicitly stopped by the user.
+     *
+     * Distinct from a retired observation: a group /stop retires every bot's
+     * observation on the shared session, which is NOT a user request to kill
+     * each individual run. */
+    isExplicitlyStoppedObservation(sessionKey: string, runId: string): boolean;
+    /** Retire session-scoped observation, but NEVER a run whose committed
+     * terminal reply has already been observed.
+     *
+     * A run with terminalObserved=true holds a COMPUTED answer. Retiring its
+     * observation (via /stop, /reset or an abort) removes the only durable
+     * custody that answer has, so recoverExactRuns can never deliver it and the
+     * computed reply is silently lost. A run without a terminal observation has
+     * nothing to deliver yet and may be retired normally. */
     stopSessionObservations(sessionKey: string): void;
     settleExactRunReactions(sessionKey: string, runId: string): void;
     finishRunObservation(sessionKey: string, runId: string, state?: string): void;
@@ -209,6 +232,23 @@ export declare class MessageStore {
     isInsertionReserved(bot: string, chat: string, row: number): boolean;
     stopInsertionAtEpoch(bot: string, chat: string, row: number, epoch: number): void;
     stopInsertions(bot: string, chat: string): void;
+    /** Group-scoped stop cleanup: every bot in this chat, not just the caller.
+     * A bare /stop in a multi-bot group is executed by ONE bot, but each bot keeps
+     * its own pending_triggers / insertion_custody / dispatch_custody / reaction
+     * rows for the same chat. Stopping only the executing bot left the others
+     * believing the chat was still busy, so their next message was queued and
+     * never dispatched. */
+    stopChatForAllBots(chat: string, exceptBot?: string): {
+        stoppedInsertions: number;
+        clearedTriggers: number;
+        clearedCustody: number;
+    };
+    /** Same predicate as stopInsertions, but reports how many rows it retired. */
+    stopInsertionsCount(bot: string, chat: string): number;
+    /** Drop a bot's dispatch custody for a chat regardless of owner/batch
+     * identity. forceExpireQueueOwner can no-op when the local queue owner is
+     * already gone, which used to strand the row forever. */
+    clearDispatchCustodyForChat(bot: string, chat: string): number;
     hasUnknownDeliveryOperation(outbox: number): boolean;
     /** Includes non-visible uploads/doc creation: absence of a message_id is
      * not proof that no SDK effect has been attempted or accepted. */
@@ -333,6 +373,10 @@ export declare class MessageStore {
         runId: string;
     }, content: string, attachmentsJson: string): boolean;
     hasRunFinalDelivery(botName: string, chatId: string, p: ErrorProvenance, confirmed: boolean): boolean;
+    /** Compatibility is exact provenance/legacy key + original app/epoch, never
+     * text similarity. Existing attempted/unknown/delivered rows retain custody;
+     * this lookup neither requeues nor edits historical deliveries. */
+    findRunErrorOwner(bot: string, chat: string, p: ErrorProvenance): DeliveryOutboxItem | undefined;
     renewUnsentErrorDelivery(id: number, content: string, contentHash: string, metadata: string): void;
     /** Withdraw only an unsent error notice. Never claim it was delivered or touch a result row. */
     withdrawErrorDelivery(id: number): void;
@@ -421,6 +465,21 @@ export declare class MessageStore {
      * guard shutting everyone down after N total bot messages.
      */
     getBotStreak(chatId: string, botName: string): number;
+    /** Authorize the already app-specific SDK's private chat. The first event
+     * pins a new chat; a matching legacy label may be backfilled. Thereafter only
+     * the exact application pin authorizes access, including across bot renames.
+     * Existing unowned/mismatched/malformed rows fail closed, not first-claim wins.
+     * This operation changes no history, sync, pending input or delivery state. */
+    claimP2pOwner(chatId: string, botName: string, appId: string): boolean;
+    /** Operator-only CAS after independently verifying the original account.
+     * No runtime caller: a retired legacy label alone cannot prove app ownership.
+     * Idempotent for the exact destination, refuses any conflicting existing pin.
+     * Preserves cache metadata/timestamps and every business/history table.
+     * verifiedPreviousOwnerBot is an explicit independently verified old scope
+     * when an earlier operator repair already replaced the legacy cache label. */
+    migrateLegacyP2pOwner(chatId: string, expectedOwnerBot: string, botName: string, appId: string, verifiedPreviousOwnerBot?: string): boolean;
+    private rememberP2pOwnerAlias;
+    private validOwnerAppId;
     upsertChatInfo(info: ChatInfo): void;
     setFreeDiscussion(chatId: string, on: boolean): void;
     setVerbose(chatId: string, verbose: boolean): void;
@@ -458,6 +517,13 @@ export declare class MessageStore {
      */
     markBotProcessed(botName: string, messageId: string): void;
     tryMarkBotProcessed(botName: string, messageId: string): boolean;
+    /** Private-only monotonic ingress fence. Write even for an owner-rejected
+     * event: a rejected input is a tombstone, never permission to retry after a
+     * rename. Legacy name tombstones are consulted ONLY in a pinned/explicitly
+     * verified owner scope (plus the existing current-name fence), never inferred
+     * from message history or mentions. Each duplicate promotes only its own ID;
+     * no historical name ledger is copied or renamed. Ownership is checked later. */
+    tryMarkP2pProcessed(appId: string, chatId: string, botName: string, messageId: string): boolean;
     createGoJob(j: {
         botName: string;
         chatId: string;

package/dist/message-store.js

@@ -1,4 +1,4 @@
-import { errorIdentity } from "./terminal-errors.js";
+import { closedStopReason, errorNoticeIdentity, errorIdentity } from "./terminal-errors.js";
 import Database from "better-sqlite3";
 import { resolve } from "path";
 import { mkdirSync } from "fs";
@@ -258,9 +258,10 @@ export class MessageStore {
     listAdmissions(sessionKey) {
         return this.db.prepare('SELECT * FROM admission_custody WHERE session_key=? ORDER BY rowid DESC LIMIT 100').all(sessionKey).map(r => ({ ...JSON.parse(r.record_json), submissionId: r.submission_id, state: r.state }));
     }
-    stopExactRun(sessionKey, runId) {
-        this.db.prepare(`INSERT INTO run_observations VALUES(?,?,'{}','stopped',0)
-      ON CONFLICT(session_key,run_id) DO UPDATE SET state='stopped'`).run(sessionKey, runId);
+    stopExactRun(sessionKey, runId, userStopped = false) {
+        const record = userStopped ? { userStopped: true } : {};
+        this.db.prepare(`INSERT INTO run_observations VALUES(?,?,?,'stopped',0)
+      ON CONFLICT(session_key,run_id) DO UPDATE SET state='stopped', record_json=json_patch(run_observations.record_json,excluded.record_json)`).run(sessionKey, runId, JSON.stringify(record));
     }
     isStoppedObservation(sessionKey, runId) {
         return !!this.db.prepare("SELECT 1 FROM run_observations WHERE session_key=? AND run_id=? AND state='stopped'").get(sessionKey, runId);
@@ -329,8 +330,45 @@ export class MessageStore {
     runObservationState(sessionKey, runId) {
         return this.db.prepare('SELECT state FROM run_observations WHERE session_key=? AND run_id=?').get(sessionKey, runId)?.state;
     }
+    /** Observed reply latency for this chat, from real delivered replies.
+     *
+     * Used to size the "input still unconfirmed" window. A fixed short timer
+     * misfired on slow sessions where nearly every legitimate reply took longer
+     * than the timer, producing a false "not confirmed" notice for a run that
+     * was in fact progressing normally. Returns null when there is no history. */
+    observedReplyLatencyMs(bot, chat) {
+        // p90 over real delivered replies. MAX would be dominated by a single
+        // pathological outlier and inflate the window for every later request.
+        const sql = "SELECT (d.delivered_at - m.timestamp) AS lat FROM delivered_replies d" +
+            " JOIN messages m ON m.id=d.trigger_message_row_id" +
+            " WHERE d.bot_name=? AND d.chat_id=? AND d.delivered_at > m.timestamp AND m.timestamp > 0" +
+            " ORDER BY d.delivered_at DESC LIMIT 30";
+        const rows = this.db.prepare(sql).all(bot, chat);
+        const lats = rows.map(r => Number(r.lat)).filter(x => Number.isFinite(x) && x > 0).sort((a, b) => a - b);
+        if (!lats.length)
+            return null;
+        const p90 = lats[Math.min(lats.length - 1, Math.floor(lats.length * 0.9))];
+        return Number.isFinite(p90) && p90 > 0 ? p90 : null;
+    }
+    /** True only when THIS run was explicitly stopped by the user.
+     *
+     * Distinct from a retired observation: a group /stop retires every bot's
+     * observation on the shared session, which is NOT a user request to kill
+     * each individual run. */
+    isExplicitlyStoppedObservation(sessionKey, runId) {
+        const row = this.db.prepare("SELECT 1 FROM run_observations WHERE session_key=? AND run_id=? AND state='stopped' AND json_extract(record_json,'$.userStopped')=1").get(sessionKey, runId);
+        return !!row;
+    }
+    /** Retire session-scoped observation, but NEVER a run whose committed
+     * terminal reply has already been observed.
+     *
+     * A run with terminalObserved=true holds a COMPUTED answer. Retiring its
+     * observation (via /stop, /reset or an abort) removes the only durable
+     * custody that answer has, so recoverExactRuns can never deliver it and the
+     * computed reply is silently lost. A run without a terminal observation has
+     * nothing to deliver yet and may be retired normally. */
     stopSessionObservations(sessionKey) {
-        this.db.prepare("UPDATE run_observations SET state='stopped' WHERE session_key=? AND state IN ('observing','outbox_owned')").run(sessionKey);
+        this.db.prepare("UPDATE run_observations SET state='stopped' WHERE session_key=? AND state IN ('observing','outbox_owned') AND json_extract(record_json,'$.terminalObserved') IS NOT 1").run(sessionKey);
     }
     settleExactRunReactions(sessionKey, runId) {
         const targets = this.db.prepare('SELECT bot_name,chat_id FROM run_delivery_targets WHERE run_id=?').all(runId);
@@ -406,6 +444,45 @@ export class MessageStore {
     stopInsertions(bot, chat) {
         this.db.prepare("UPDATE insertion_custody SET state='stopped' WHERE bot_name=? AND chat_id=? AND (state NOT IN ('committed','ordinary') OR state='ordinary' AND json_type(record_json,'$.followupAdmissionGuard')='object')").run(bot, chat);
     }
+    /** Group-scoped stop cleanup: every bot in this chat, not just the caller.
+     * A bare /stop in a multi-bot group is executed by ONE bot, but each bot keeps
+     * its own pending_triggers / insertion_custody / dispatch_custody / reaction
+     * rows for the same chat. Stopping only the executing bot left the others
+     * believing the chat was still busy, so their next message was queued and
+     * never dispatched. */
+    stopChatForAllBots(chat, exceptBot) {
+        const bots = this.db.prepare("SELECT DISTINCT bot_name FROM pending_triggers WHERE chat_id=? UNION SELECT DISTINCT bot_name FROM insertion_custody WHERE chat_id=? UNION SELECT DISTINCT bot_name FROM dispatch_custody WHERE chat_id=? UNION SELECT DISTINCT bot_name FROM reaction_custody WHERE chat_id=?").all(chat, chat, chat, chat).map((r) => r.bot_name);
+        let stoppedInsertions = 0, clearedTriggers = 0, clearedCustody = 0;
+        for (const bot of bots) {
+            if (bot === exceptBot) {
+                // The executing bot already bumped its own epoch and cancelled its own
+                // reaction intents; touching them again would desynchronize its
+                // in-memory generation from the durable one.
+                stoppedInsertions += this.stopInsertionsCount(bot, chat);
+                clearedTriggers += this.clearAllPendingTriggers(bot, chat);
+                clearedCustody += this.clearDispatchCustodyForChat(bot, chat);
+                continue;
+            }
+            // Invalidate every epoch-scoped record for this bot/chat: a stale
+            // dispatch_custody with an old stopEpoch can never be released later.
+            this.bumpStopGeneration(bot, chat);
+            this.cancelReactionIntents(bot, chat, this.getStopGeneration(bot, chat));
+            stoppedInsertions += this.stopInsertionsCount(bot, chat);
+            clearedTriggers += this.clearAllPendingTriggers(bot, chat);
+            clearedCustody += this.clearDispatchCustodyForChat(bot, chat);
+        }
+        return { stoppedInsertions, clearedTriggers, clearedCustody };
+    }
+    /** Same predicate as stopInsertions, but reports how many rows it retired. */
+    stopInsertionsCount(bot, chat) {
+        return this.db.prepare("UPDATE insertion_custody SET state='stopped' WHERE bot_name=? AND chat_id=? AND (state NOT IN ('committed','ordinary') OR state='ordinary' AND json_type(record_json,'$.followupAdmissionGuard')='object')").run(bot, chat).changes;
+    }
+    /** Drop a bot's dispatch custody for a chat regardless of owner/batch
+     * identity. forceExpireQueueOwner can no-op when the local queue owner is
+     * already gone, which used to strand the row forever. */
+    clearDispatchCustodyForChat(bot, chat) {
+        return this.db.prepare("DELETE FROM dispatch_custody WHERE bot_name=? AND chat_id=?").run(bot, chat).changes;
+    }
     hasUnknownDeliveryOperation(outbox) {
         return !!this.db.prepare(`SELECT 1 FROM delivery_operations o WHERE outbox_id=? AND state IN ('attempted','unknown')
       AND NOT EXISTS(SELECT 1 FROM delivery_receipt_custody k WHERE k.outbox_id=o.outbox_id AND k.operation_key=o.operation_key) LIMIT 1`).get(outbox);
@@ -772,7 +849,7 @@ export class MessageStore {
         this.db.prepare('UPDATE go_action_lifecycle SET state=?,receipt_json=? WHERE go_id=? AND action_key=? AND state!=?').run(state, receipt === undefined ? '' : JSON.stringify(receipt), goId, actionKey, 'accepted');
     }
     observeRunError(botName, chatId, provenance) {
-        const noticeId = errorIdentity(provenance.sessionKey, provenance.runId);
+        const noticeId = errorNoticeIdentity(provenance);
         const previous = this.getErrorNotice(botName, chatId, noticeId);
         if (previous) {
             if (provenance.userStop) {
@@ -783,8 +860,8 @@ export class MessageStore {
             }
             // A committed transcript abort is weaker than a gateway terminal error.
             // One stronger envelope can wake a parked observation; repeats cannot.
-            const terminalChat = (p) => p.source === "chat" && (p.state === "error" || (p.state === "final" && p.stopReason === "error"));
-            if (!provenance.userStop && !previous.provenance.userStop && terminalChat(provenance) && !terminalChat(previous.provenance)
+            const terminalChat = (p) => p.source === "chat" && (p.state === "error" || p.state === 'aborted' && !!closedStopReason(p.stopReason) || (p.state === "final" && p.stopReason === "error"));
+            if (!provenance.userStop && !previous.provenance.userStop && terminalChat(provenance) && (!terminalChat(previous.provenance) || !!closedStopReason(provenance.stopReason) && !closedStopReason(previous.provenance.stopReason))
                 && ["pending", "parked"].includes(previous.status)) {
                 previous.provenance = provenance;
                 previous.status = "pending";
@@ -842,8 +919,45 @@ export class MessageStore {
       AND json_extract(delivery_meta_json,'$.provenance.final')=1
       AND json_extract(delivery_meta_json,'$.provenance.sessionKey')=?
       AND json_extract(delivery_meta_json,'$.provenance.runId')=?
+      AND (? IS NULL OR json_extract(delivery_meta_json,'$.botIdentity')=?)
+      AND (? IS NULL OR json_extract(delivery_meta_json,'$.deliveryStopEpoch')=?)
+      AND (? IS NULL OR json_extract(delivery_meta_json,'$.provenance.sessionId') IS NULL OR json_extract(delivery_meta_json,'$.provenance.sessionId')=?)
       AND ${confirmed ? "status='delivered'" : "status IN ('pending','delivering')"} LIMIT 1`)
-            .get(botName, chatId, p.sessionKey, p.runId));
+            .get(botName, chatId, p.sessionKey, p.runId, p.sessionId ? p.botIdentity ?? null : null, p.sessionId ? p.botIdentity ?? null : null, p.sessionId ? p.stopEpoch ?? null : null, p.sessionId ? p.stopEpoch ?? null : null, p.sessionId ?? null, p.sessionId ?? null));
+    }
+    /** Compatibility is exact provenance/legacy key + original app/epoch, never
+     * text similarity. Existing attempted/unknown/delivered rows retain custody;
+     * this lookup neither requeues nor edits historical deliveries. */
+    findRunErrorOwner(bot, chat, p) {
+        const target = this.getDeliveryRunTarget(bot, chat, p.runId);
+        const oldKey = `run-error:${errorIdentity(p.sessionKey, p.runId)}`;
+        const triggerKey = target?.triggerId ? `trigger:${target.triggerId}:provider-error` : '';
+        const rows = this.db.prepare(`SELECT * FROM delivery_outbox WHERE bot_name=? AND chat_id=?
+      AND source_type IN ('run_error','provider_error') AND (delivery_key IN (?,?,?) OR
+        json_extract(CASE WHEN json_valid(delivery_meta_json) THEN delivery_meta_json ELSE '{}' END,'$.provenance.runId')=?) ORDER BY id LIMIT 100`)
+            .all(bot, chat, oldKey, triggerKey, `run-error:${errorNoticeIdentity(p)}`, p.runId);
+        for (const row of rows) {
+            let meta;
+            try {
+                meta = JSON.parse(row.delivery_meta_json);
+            }
+            catch {
+                continue;
+            }
+            if (p.botIdentity && meta.botIdentity !== p.botIdentity || p.stopEpoch !== undefined && meta.deliveryStopEpoch !== p.stopEpoch)
+                continue;
+            const q = meta.provenance;
+            if (q?.runId && q.runId !== p.runId || q?.sessionKey && q.sessionKey !== p.sessionKey)
+                continue;
+            if (p.sessionId && q?.sessionId && q.sessionId !== p.sessionId)
+                continue;
+            const exact = q?.runId === p.runId && q.sessionKey === p.sessionKey;
+            const legacy = row.delivery_key === oldKey || row.delivery_key === triggerKey && target?.sessionKey === p.sessionKey &&
+                (p.stopEpoch === undefined || target.stopGeneration === p.stopEpoch) && (!p.sessionId || !target.sessionId || target.sessionId === p.sessionId);
+            if (exact || legacy)
+                return this.mapDelivery(row);
+        }
+        return undefined;
     }
     renewUnsentErrorDelivery(id, content, contentHash, metadata) {
         this.db.prepare(`UPDATE delivery_outbox SET status='pending',content=?,content_hash=?,delivery_meta_json=?,updated_at=?
@@ -921,6 +1035,18 @@ export class MessageStore {
         PRIMARY KEY (bot_name, message_id)
       );
 
+      -- Private ingress dedup only: neither table grants chat ownership or
+      -- changes name-scoped sessions, sync, triggers, delivery or group routing.
+      CREATE TABLE IF NOT EXISTS p2p_processed_events (
+        app_id TEXT NOT NULL, chat_id TEXT NOT NULL, message_id TEXT NOT NULL,
+        PRIMARY KEY (app_id, chat_id, message_id)
+      );
+      CREATE TABLE IF NOT EXISTS p2p_owner_aliases (
+        app_id TEXT NOT NULL, chat_id TEXT NOT NULL, bot_name TEXT NOT NULL,
+        proof TEXT NOT NULL CHECK(proof IN ('pinned_owner','verified_migration')),
+        PRIMARY KEY (app_id, chat_id, bot_name)
+      );
+
       -- Tracks recalled human messages. Recalled messages are kept in the raw
       -- message ledger for audit, but excluded from future OpenClaw context and
       -- pending trigger processing.
@@ -1183,6 +1309,13 @@ export class MessageStore {
         catch {
             // Column already exists
         }
+        // Additive only: never infer ownership from a retired display name. Legacy
+        // rows are pinned lazily only when their existing owner label still matches.
+        this.db.transaction(() => {
+            if (!this.db.prepare('PRAGMA table_info(chat_info)').all().some(row => row.name === 'owner_app_id')) {
+                this.db.exec(`ALTER TABLE chat_info ADD COLUMN owner_app_id TEXT NOT NULL DEFAULT ''`);
+            }
+        }).immediate();
         // Migration: add trigger_kind column if missing
         try {
             this.db.exec(`ALTER TABLE messages ADD COLUMN trigger_kind TEXT NOT NULL DEFAULT 'normal'`);
@@ -1727,10 +1860,87 @@ export class MessageStore {
         return count;
     }
     // --- Chat info ---
+    /** Authorize the already app-specific SDK's private chat. The first event
+     * pins a new chat; a matching legacy label may be backfilled. Thereafter only
+     * the exact application pin authorizes access, including across bot renames.
+     * Existing unowned/mismatched/malformed rows fail closed, not first-claim wins.
+     * This operation changes no history, sync, pending input or delivery state. */
+    claimP2pOwner(chatId, botName, appId) {
+        if (!chatId || !botName?.trim() || !this.validOwnerAppId(appId))
+            return false;
+        return this.db.transaction(() => {
+            const row = this.db.prepare('SELECT chat_type,owner_bot,owner_app_id FROM chat_info WHERE chat_id=?').get(chatId);
+            if (!row) {
+                this.db.prepare(`INSERT INTO chat_info(chat_id,chat_type,chat_name,owner_bot,owner_app_id,updated_at)
+          VALUES(?,'p2p','私聊',?,?,?)`).run(chatId, botName, appId, Date.now());
+                this.rememberP2pOwnerAlias(chatId, appId, botName, 'pinned_owner');
+                return true;
+            }
+            if (row.chat_type !== 'p2p')
+                return false;
+            if (row.owner_app_id === '') {
+                if (row.owner_bot !== botName)
+                    return false;
+                const pinned = this.db.prepare(`UPDATE chat_info SET owner_app_id=? WHERE chat_id=? AND chat_type='p2p' AND owner_bot=? AND owner_app_id=''`)
+                    .run(appId, chatId, botName).changes === 1;
+                if (pinned)
+                    this.rememberP2pOwnerAlias(chatId, appId, botName, 'pinned_owner');
+                return pinned;
+            }
+            if (!this.validOwnerAppId(row.owner_app_id) || row.owner_app_id !== appId)
+                return false;
+            // Preserve the proven previous scope BEFORE replacing the readable label.
+            this.rememberP2pOwnerAlias(chatId, appId, row.owner_bot, 'pinned_owner');
+            if (row.owner_bot !== botName) {
+                const renamed = this.db.prepare(`UPDATE chat_info SET owner_bot=? WHERE chat_id=? AND chat_type='p2p' AND owner_app_id=?`)
+                    .run(botName, chatId, appId).changes === 1;
+                if (renamed)
+                    this.rememberP2pOwnerAlias(chatId, appId, botName, 'pinned_owner');
+                return renamed;
+            }
+            return true;
+        }).immediate();
+    }
+    /** Operator-only CAS after independently verifying the original account.
+     * No runtime caller: a retired legacy label alone cannot prove app ownership.
+     * Idempotent for the exact destination, refuses any conflicting existing pin.
+     * Preserves cache metadata/timestamps and every business/history table.
+     * verifiedPreviousOwnerBot is an explicit independently verified old scope
+     * when an earlier operator repair already replaced the legacy cache label. */
+    migrateLegacyP2pOwner(chatId, expectedOwnerBot, botName, appId, verifiedPreviousOwnerBot) {
+        if (!chatId || !expectedOwnerBot?.trim() || !botName?.trim() || !this.validOwnerAppId(appId)
+            || (verifiedPreviousOwnerBot !== undefined && !verifiedPreviousOwnerBot.trim()))
+            return false;
+        return this.db.transaction(() => {
+            const migrated = this.db.prepare(`UPDATE chat_info SET owner_bot=?,owner_app_id=?
+        WHERE chat_id=? AND chat_type='p2p' AND owner_bot=? AND owner_app_id=''`)
+                .run(botName, appId, chatId, expectedOwnerBot).changes === 1;
+            const row = this.db.prepare('SELECT chat_type,owner_bot,owner_app_id FROM chat_info WHERE chat_id=?').get(chatId);
+            if (row?.chat_type !== 'p2p' || row.owner_bot !== botName || row.owner_app_id !== appId)
+                return false;
+            if (migrated)
+                this.rememberP2pOwnerAlias(chatId, appId, expectedOwnerBot, 'verified_migration');
+            this.rememberP2pOwnerAlias(chatId, appId, botName, 'pinned_owner');
+            if (verifiedPreviousOwnerBot !== undefined)
+                this.rememberP2pOwnerAlias(chatId, appId, verifiedPreviousOwnerBot, 'verified_migration');
+            return true;
+        }).immediate();
+    }
+    rememberP2pOwnerAlias(chatId, appId, botName, proof) {
+        if (typeof botName !== 'string' || !botName.trim())
+            return;
+        this.db.prepare('INSERT OR IGNORE INTO p2p_owner_aliases(app_id,chat_id,bot_name,proof) VALUES(?,?,?,?)')
+            .run(appId, chatId, botName, proof);
+    }
+    validOwnerAppId(value) {
+        // Exact, opaque identity, not a display name. Do not normalize malformed
+        // pins into either a valid identity or the empty legacy sentinel.
+        return typeof value === 'string' && /^[A-Za-z0-9_-]+$/.test(value);
+    }
     upsertChatInfo(info) {
         this.db.prepare(`
-      INSERT INTO chat_info (chat_id, chat_type, chat_name, members, member_names, verbose, free_discussion, owner_bot, discuss, discuss_max_rounds, chairman_bot, locale, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO chat_info (chat_id, chat_type, chat_name, members, member_names, verbose, free_discussion, owner_bot, owner_app_id, discuss, discuss_max_rounds, chairman_bot, locale, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT (chat_id) DO UPDATE SET
         chat_type = excluded.chat_type,
         chat_name = excluded.chat_name,
@@ -1738,13 +1948,13 @@ export class MessageStore {
         member_names = excluded.member_names,
         verbose = excluded.verbose,
         free_discussion = excluded.free_discussion,
-        owner_bot = CASE WHEN excluded.owner_bot != '' THEN excluded.owner_bot ELSE chat_info.owner_bot END,
+        owner_bot = CASE WHEN chat_info.chat_type = 'p2p' THEN chat_info.owner_bot WHEN excluded.owner_bot != '' THEN excluded.owner_bot ELSE chat_info.owner_bot END,
         discuss = CASE WHEN excluded.discuss != 0 THEN excluded.discuss ELSE chat_info.discuss END,
         discuss_max_rounds = CASE WHEN excluded.discuss_max_rounds != 10 THEN excluded.discuss_max_rounds ELSE chat_info.discuss_max_rounds END,
         chairman_bot = CASE WHEN excluded.chairman_bot != '' THEN excluded.chairman_bot ELSE chat_info.chairman_bot END,
         locale = CASE WHEN excluded.locale != '' THEN excluded.locale ELSE chat_info.locale END,
         updated_at = excluded.updated_at
-    `).run(info.chatId, info.chatType, info.chatName, info.members, info.memberNames, info.verbose ? 1 : 0, info.freeDiscussion ? 1 : 0, info.ownerBot || '', info.discuss ? 1 : 0, info.discussMaxRounds || 10, info.chairmanBot || '', info.locale || '', info.updatedAt);
+    `).run(info.chatId, info.chatType, info.chatName, info.members, info.memberNames, info.verbose ? 1 : 0, info.freeDiscussion ? 1 : 0, info.ownerBot || '', info.ownerAppId ?? '', info.discuss ? 1 : 0, info.discussMaxRounds || 10, info.chairmanBot || '', info.locale || '', info.updatedAt);
     }
     setFreeDiscussion(chatId, on) {
         this.db.prepare(`UPDATE chat_info SET free_discussion = ? WHERE chat_id = ?`).run(on ? 1 : 0, chatId);
@@ -1868,6 +2078,7 @@ export class MessageStore {
             members: row.members,
             memberNames: row.member_names,
             ownerBot: row.owner_bot || '',
+            ownerAppId: row.owner_app_id,
             freeDiscussion: !!row.free_discussion,
             verbose: !!row.verbose,
             discuss: !!row.discuss,
@@ -1886,6 +2097,7 @@ export class MessageStore {
             members: r.members,
             memberNames: r.member_names,
             ownerBot: r.owner_bot || '',
+            ownerAppId: r.owner_app_id,
             freeDiscussion: !!r.free_discussion,
             verbose: !!r.verbose,
             discuss: !!r.discuss,
@@ -1926,6 +2138,30 @@ export class MessageStore {
         const result = this.db.prepare(`INSERT OR IGNORE INTO processed_events (bot_name, message_id) VALUES (?, ?)`).run(botName, messageId);
         return result.changes === 1;
     }
+    /** Private-only monotonic ingress fence. Write even for an owner-rejected
+     * event: a rejected input is a tombstone, never permission to retry after a
+     * rename. Legacy name tombstones are consulted ONLY in a pinned/explicitly
+     * verified owner scope (plus the existing current-name fence), never inferred
+     * from message history or mentions. Each duplicate promotes only its own ID;
+     * no historical name ledger is copied or renamed. Ownership is checked later. */
+    tryMarkP2pProcessed(appId, chatId, botName, messageId) {
+        if (!this.validOwnerAppId(appId) || !chatId || !botName?.trim() || !messageId)
+            return false;
+        return this.db.transaction(() => {
+            const owner = this.db.prepare('SELECT chat_type,owner_bot,owner_app_id FROM chat_info WHERE chat_id=?').get(chatId);
+            if (owner?.chat_type === 'p2p' && owner.owner_app_id === appId) {
+                // Intake dedup runs before metadata refresh/startup can replace a label.
+                this.rememberP2pOwnerAlias(chatId, appId, owner.owner_bot, 'pinned_owner');
+            }
+            const legacyDuplicate = !!this.db.prepare(`SELECT 1 FROM p2p_owner_aliases a
+        JOIN processed_events p ON p.bot_name=a.bot_name
+        WHERE a.app_id=? AND a.chat_id=? AND p.message_id=? LIMIT 1`).get(appId, chatId, messageId);
+            const freshApp = this.db.prepare('INSERT OR IGNORE INTO p2p_processed_events(app_id,chat_id,message_id) VALUES(?,?,?)')
+                .run(appId, chatId, messageId).changes === 1;
+            const freshName = this.tryMarkBotProcessed(botName, messageId);
+            return freshApp && freshName && !legacyDuplicate;
+        }).immediate();
+    }
     // --- Go / Go-Checker supervision (DESIGN.md §10) ---
     createGoJob(j) {
         const now = Date.now();

package/dist/openclaw-client.d.ts

@@ -72,10 +72,6 @@ export type ChatAttachment = {
 };
 export declare const GATEWAY_PROTOCOL_MIN = 4;
 export declare const GATEWAY_PROTOCOL_MAX = 4;
-/**
- * OpenClaw Gateway WebSocket client.
- * Full agent pipeline — tools, memory, skills, context management by OpenClaw.
- */
 export declare class OpenClawClient {
     private goEvidenceObservers;
     /** Raw full event observer. Observation is NOT a Feishu delivery receipt. */
@@ -234,8 +230,6 @@ export declare class OpenClawClient {
      */
     private isGenericChatError;
     private resolveTerminalChatError;
-    private formatTerminalRunError;
-    private formatDurationSeconds;
     private isRecoverableAgentError;
     createSession(params: {
         key: string;