openclaw-lark-multi-agent 1.8.8 → 1.8.10

package/dist/message-store.js

@@ -28,6 +28,7 @@ export class MessageStore {
       CREATE TABLE IF NOT EXISTS reaction_custody(bot_name TEXT NOT NULL,chat_id TEXT NOT NULL,row_id INTEGER NOT NULL,record_json TEXT NOT NULL,
         PRIMARY KEY(bot_name,chat_id,row_id));
       CREATE TABLE IF NOT EXISTS run_delivery_targets(bot_name TEXT NOT NULL,chat_id TEXT NOT NULL,run_id TEXT NOT NULL,record_json TEXT NOT NULL,PRIMARY KEY(bot_name,chat_id,run_id));
+      CREATE TABLE IF NOT EXISTS dispatch_custody(bot_name TEXT NOT NULL,chat_id TEXT NOT NULL,record_json TEXT NOT NULL,PRIMARY KEY(bot_name,chat_id));
       CREATE TABLE IF NOT EXISTS admission_custody(session_key TEXT NOT NULL,submission_id TEXT PRIMARY KEY,state TEXT NOT NULL,record_json TEXT NOT NULL);
       CREATE TABLE IF NOT EXISTS run_observations (
         session_key TEXT NOT NULL, run_id TEXT NOT NULL, record_json TEXT NOT NULL,
@@ -81,6 +82,38 @@ export class MessageStore {
         const row = this.db.prepare('SELECT record_json FROM run_delivery_targets WHERE bot_name=? AND chat_id=? AND run_id=?').get(bot, chat, runId);
         return row ? JSON.parse(row.record_json) : null;
     }
+    /** Scheduling custody is independent of exact-run result custody. */
+    saveDispatchCustody(bot, chat, record) {
+        this.db.prepare('INSERT OR REPLACE INTO dispatch_custody VALUES(?,?,?)').run(bot, chat, JSON.stringify(record));
+    }
+    getDispatchCustody(bot, chat) {
+        const row = this.db.prepare('SELECT record_json FROM dispatch_custody WHERE bot_name=? AND chat_id=?').get(bot, chat);
+        const item = row ? JSON.parse(row.record_json) : null;
+        return item?.stopEpoch === this.getStopGeneration(bot, chat) ? item : null;
+    }
+    clearDispatchCustody(bot, chat, ownerId, batchId) {
+        return this.db.prepare(`DELETE FROM dispatch_custody WHERE bot_name=? AND chat_id=?
+      AND json_extract(record_json,'$.id')=? AND json_extract(record_json,'$.batchId')=?`).run(bot, chat, ownerId, batchId).changes === 1;
+    }
+    /** Atomic release of proven never-attempted reservations only. Unknown and
+     * accepted inputs retain their exact target and never enter ordinary drain. */
+    releaseDispatchCustody(bot, chat, ownerId, batchId) {
+        return this.db.transaction(() => {
+            const custody = this.getDispatchCustody(bot, chat);
+            if (!custody || !this.clearDispatchCustody(bot, chat, ownerId, batchId))
+                return false;
+            this.db.prepare(`UPDATE run_delivery_targets SET record_json=json_set(record_json,'$.dispatchReleased',json('true'),
+        '$.dispatchOwnerId',?,'$.dispatchBatchId',?,'$.sessionId',?) WHERE bot_name=? AND chat_id=? AND run_id=?`)
+                .run(ownerId, batchId, custody.sessionId, bot, chat, custody.runId);
+            this.db.prepare(`UPDATE insertion_custody SET state='ordinary',next_check_at=0,
+        record_json=json_set(record_json,'$.reason','current session confirmed schedulable; no backend attempt')
+        WHERE bot_name=? AND chat_id=? AND state='pending'
+        AND COALESCE(json_extract(record_json,'$.attempted'),0)=0
+        AND json_extract(record_json,'$.ownerId')=? AND json_extract(record_json,'$.batchId')=?
+        AND json_extract(record_json,'$.stopEpoch')=?`).run(bot, chat, ownerId, batchId, this.getStopGeneration(bot, chat));
+            return true;
+        })();
+    }
     /** Reserved is persisted before the send-attempt callback; dispatching is
      * persisted before the RPC. Only reserved + unchanged stop generation proves
      * no business effect and may be restored on startup. Unknown never replays. */
@@ -116,6 +149,9 @@ export class MessageStore {
         return !!this.db.prepare("SELECT 1 FROM run_observations WHERE session_key=? AND run_id=? AND state='stopped'").get(sessionKey, runId);
     }
     settleRunReactionIntents(bot, chat, runId) {
+        this.db.prepare(`UPDATE insertion_custody SET state='committed' WHERE bot_name=? AND chat_id=? AND state='accepted'
+      AND json_extract(record_json,'$.expectedRunId')=? AND json_extract(record_json,'$.stopEpoch')=?`)
+            .run(bot, chat, runId, this.getStopGeneration(bot, chat));
         this.db.prepare(`UPDATE reaction_custody SET record_json=json_set(record_json,'$.desired','DONE')
       WHERE bot_name=? AND chat_id=? AND json_extract(record_json,'$.runId')=?
       AND json_extract(record_json,'$.desired') IN ('Get','Typing')
@@ -127,9 +163,16 @@ export class MessageStore {
     }
     saveRunObservation(sessionKey, runId, record, nextCheckAt = Date.now()) {
         this.db.prepare(`INSERT INTO run_observations VALUES(?,?,?,'observing',?)
-      ON CONFLICT(session_key,run_id) DO UPDATE SET record_json=excluded.record_json,next_check_at=excluded.next_check_at
+      ON CONFLICT(session_key,run_id) DO UPDATE SET record_json=json_patch(run_observations.record_json,excluded.record_json),next_check_at=excluded.next_check_at
       WHERE run_observations.state='observing'`).run(sessionKey, runId, JSON.stringify(record), nextCheckAt);
     }
+    hasYieldedObservation(sessionKey) {
+        return !!this.db.prepare(`SELECT 1 FROM run_observations WHERE session_key=? AND json_extract(record_json,'$.yielded')=1 LIMIT 1`).get(sessionKey);
+    }
+    getRunObservation(sessionKey, runId) {
+        const row = this.db.prepare('SELECT record_json,state FROM run_observations WHERE session_key=? AND run_id=?').get(sessionKey, runId);
+        return row ? { ...JSON.parse(row.record_json), state: row.state } : null;
+    }
     runObservationState(sessionKey, runId) {
         return this.db.prepare('SELECT state FROM run_observations WHERE session_key=? AND run_id=?').get(sessionKey, runId)?.state;
     }
@@ -159,6 +202,26 @@ export class MessageStore {
       ON CONFLICT(bot_name,chat_id,message_row_id) DO UPDATE SET state=excluded.state,record_json=excluded.record_json,next_check_at=excluded.next_check_at
       WHERE insertion_custody.state NOT IN ('stopped','committed')`).run(bot, chat, row, id, JSON.stringify(record), state, next);
     }
+    /** Purge still-pending insertion status notices once the insertion resolves
+     *  (accepted/ordinary): a stale "unknown" notice must not fire after Get. */
+    deletePendingInsertionNotices(bot, chat, insertionId) {
+        const r = this.db.prepare(`DELETE FROM delivery_outbox WHERE bot_name=? AND chat_id=? AND delivery_key LIKE ? AND status='pending'`)
+            .run(bot, chat, `insertion:${insertionId}:%`);
+        return r.changes;
+    }
+    /** Reminder intent and its outbox row commit together. Never write a stale
+     * reconciliation snapshot over a later accepted/stopped insertion. */
+    queueInsertionUnknownNotice(bot, chat, row, delivery) {
+        return this.db.transaction(() => {
+            const current = this.getInsertion(bot, chat, row);
+            if (current?.state !== 'unknown' || current.stopEpoch !== this.getStopGeneration(bot, chat) || current.unknownNotified ||
+                !Number.isFinite(current.unknownSince) || Date.now() - current.unknownSince < 45_000)
+                return false;
+            this.enqueueDelivery(delivery);
+            this.saveInsertion(bot, chat, row, current.insertionId, 'unknown', { ...current, unknownNotified: true }, Date.now() + 15_000);
+            return true;
+        })();
+    }
     claimInsertionAttempt(bot, chat, row) {
         return this.db.prepare(`UPDATE insertion_custody SET state='dispatching',record_json=json_set(record_json,'$.attempted',json('true'))
       WHERE bot_name=? AND chat_id=? AND message_row_id=? AND state='pending'`).run(bot, chat, row).changes === 1;
@@ -176,6 +239,10 @@ export class MessageStore {
         const item = this.getInsertion(bot, chat, row);
         return !!item && !['ordinary', 'stopped'].includes(item.state);
     }
+    stopInsertionAtEpoch(bot, chat, row, epoch) {
+        this.db.prepare(`UPDATE insertion_custody SET state='stopped' WHERE bot_name=? AND chat_id=? AND message_row_id=?
+      AND json_extract(record_json,'$.stopEpoch')=? AND state NOT IN ('committed','ordinary')`).run(bot, chat, row, epoch);
+    }
     stopInsertions(bot, chat) {
         this.db.prepare("UPDATE insertion_custody SET state='stopped' WHERE bot_name=? AND chat_id=? AND state NOT IN ('committed','ordinary')").run(bot, chat);
     }

package/dist/openclaw-client.d.ts

@@ -155,8 +155,8 @@ export declare class OpenClawClient {
      * Collect agent reply by polling accumulated events.
      * Matches by initial runId OR sessionKey to handle multi-turn tool calling
      * where OpenClaw creates new runIds for each tool-call round.
-     * Existing event/anchor matching is retained. After 30 minutes of silence,
-     * reconcile the original run instead of aborting or treating a draft as final.
+     * Existing event/anchor matching is retained. Foreground effective silence
+     * triggers read-only reconciliation, never a task-lifetime cutoff or draft final.
      * Explicit terminal/error/disconnect paths keep their existing behavior.
      */
     private collectReply;
@@ -192,7 +192,7 @@ export declare class OpenClawClient {
      * expectedSessionId, so describe first, then patch archived=false.
      */
     unarchiveSession(key: string): Promise<boolean>;
-    getSessionStatus(key: string): Promise<any>;
+    getSessionStatus(key: string, timeoutMs?: number): Promise<any>;
     injectAssistantMessage(params: {
         sessionKey: string;
         message: string;
@@ -203,6 +203,7 @@ export declare class OpenClawClient {
      * missing/legacy plugin observations stay pending without blind mutation. */
     exactRunSettled(runId: string): Promise<boolean>;
     cancelSteerSession(sessionKey: string, stopEpoch: number): Promise<void>;
+    private readinessCause;
     steer(sessionKey: string, text: string, displayText?: string, identity?: {
         insertionId: string;
         expectedRunId: string;
@@ -251,9 +252,19 @@ export declare class OpenClawClient {
      *  Used when queue custody is revoked or a new chat.send takes over, so a
      *  stale poller cannot steal the replacement batch's frames (2026-10-16). */
     revokeSessionCollectors(sessionKey: string, reason: string): number;
+    waitForSessionStop(sessionKey: string): Promise<void>;
     getSessionRuntimeStatus(sessionKey: string): Promise<SessionRuntimeStatus>;
+    /** Strong public current-session activity, independent of expired root
+     * terminal caches. Unknown/missing fields never authorize scheduling. */
+    getSessionDispatchStatus(sessionKey: string): Promise<{
+        idleConfirmed: boolean;
+        sessionId?: string;
+        archived?: boolean;
+        activeRunId?: string;
+        busyConfirmed?: boolean;
+    }>;
     private classifyWaitTimeout;
-    getSessionInfo(sessionKey: string): Promise<any>;
+    getSessionInfo(sessionKey: string, timeoutMs?: number): Promise<any>;
     /**
      * Ensure session is using the expected model. If not, patch it back.
      * Returns true if a correction was made.
@@ -283,6 +294,11 @@ export declare class OpenClawClient {
     private trackChatEventSession;
     inspectRunError(provenance: ErrorProvenance): Promise<import("./terminal-errors.js").ErrorVerdict>;
     private extractTextFromChatMessage;
+    private continuationChecks;
+    /** A child/requester continuation is not automatically its parent's final.
+     * Public task parentage selects the original root; only that exact root's
+     * committed terminalReply may enter its old trigger/outbox. */
+    private handoffLinkedContinuation;
     private emitProactiveForSession;
     private suppressSessionKeys;
     private releaseSuppressedSessionKeysAfter;
@@ -415,9 +431,14 @@ export declare class OpenClawClient {
         /** Called after chat.send RPC succeeds and OpenClaw has accepted the user message. */
         onSubmitted?: (runId: string) => void | Promise<void>;
         /** Identifies collection target; not an acceptance receipt. */
-        onRunIdentified?: (runId: string) => void | Promise<void>;
+        onRunIdentified?: (runId: string, identity?: {
+            sessionId?: string;
+        }) => void | Promise<void>;
         onProgress?: (event: ProgressEvent) => void | Promise<void>;
         onWaitPaused?: (notice: SessionWaitPaused) => void | Promise<void>;
+        /** Synchronous durable scheduling handoff; never a task settlement. */
+        onYieldHandoff?: (runId: string) => void;
+        onCollectionStarted?: (runId: string) => void;
     }): Promise<string>;
     private shouldInjectBridgeAttachmentHint;
     private bridgeAttachmentHint;
@@ -452,9 +473,14 @@ export declare class OpenClawClient {
         /** Called after chat.send RPC succeeds and OpenClaw has accepted the combined message. */
         onSubmitted?: (runId: string) => void | Promise<void>;
         /** Identifies collection target; not an acceptance receipt. */
-        onRunIdentified?: (runId: string) => void | Promise<void>;
+        onRunIdentified?: (runId: string, identity?: {
+            sessionId?: string;
+        }) => void | Promise<void>;
         onProgress?: (event: ProgressEvent) => void | Promise<void>;
         onWaitPaused?: (notice: SessionWaitPaused) => void | Promise<void>;
+        /** Synchronous durable scheduling handoff; never a task settlement. */
+        onYieldHandoff?: (runId: string) => void;
+        onCollectionStarted?: (runId: string) => void;
     }): Promise<string>;
     private formatContextLines;
     private writeContextSyncFile;