openclaw-lark-multi-agent 1.6.0 → 1.8.0

package/dist/go-execution.d.ts

@@ -0,0 +1,10 @@
+/** An authoritative terminal result of one generation-pinned, admitted executor run.
+ * Admission, terminal result and platform delivery receipts are separate facts. */
+export type GoExecutorResult = {
+    sessionKey: string;
+    sessionId: string;
+    runId: string;
+    disposition: "visible" | "silent" | "empty" | "error";
+    text: string;
+    error?: string;
+};

package/dist/go-execution.js

@@ -0,0 +1 @@
+export {};

package/dist/go-runtime-gate.d.ts

@@ -0,0 +1,32 @@
+/** Pure adapter contract. Independent queries are observations, not a global atomic snapshot. */
+export type GoRuntimeSnapshot = {
+    sessionKey: string;
+    sessionId: string;
+    goalId: string;
+    goalRevision: number;
+    executorRunIds: string[];
+    checkerRunId: string;
+    complete: boolean;
+    archived: boolean;
+    independent?: boolean;
+    queryAvailable?: boolean;
+    running?: boolean;
+    atomicSnapshot?: boolean;
+    queuedInputs: number;
+    recoverableInputs: number;
+    pendingDeliveries: number;
+    tasks: Array<{
+        taskId: string;
+        runId: string;
+        parentTaskId: string | null;
+        state: string;
+        deliveryState: string;
+    }>;
+};
+export declare function goSnapshotBlocked(s: GoRuntimeSnapshot, expected: {
+    sessionKey: string;
+    sessionId: string;
+    goalId: string;
+    goalRevision: number;
+    executorRunIds: string[];
+}): string | null;

package/dist/go-runtime-gate.js

@@ -0,0 +1,56 @@
+export function goSnapshotBlocked(s, expected) {
+    if (!s.independent && (!s.checkerRunId || !expected.executorRunIds.length || expected.executorRunIds.some(id => !id)))
+        return "missing run identity";
+    if (s.independent ? !s.queryAvailable : !s.complete)
+        return "incomplete snapshot";
+    if (s.independent && s.queuedInputs !== 0)
+        return "pending or unknown input/delivery";
+    if (s.independent && s.running !== false)
+        return "active or unknown session";
+    if (s.archived || s.sessionKey !== expected.sessionKey || s.sessionId !== expected.sessionId || (!s.independent && (s.goalId !== expected.goalId || s.goalRevision !== expected.goalRevision)))
+        return "identity/version changed";
+    if (!s.independent && [s.queuedInputs, s.recoverableInputs, s.pendingDeliveries].some(n => !Number.isSafeInteger(n) || n !== 0))
+        return "pending or unknown input/delivery";
+    if (!s.independent && (new Set(s.executorRunIds).size !== s.executorRunIds.length || s.executorRunIds.length !== expected.executorRunIds.length || expected.executorRunIds.some(id => !s.executorRunIds.includes(id))))
+        return "run association changed";
+    const byId = new Map(s.tasks.map(t => [t.taskId, t]));
+    if (byId.size !== s.tasks.length)
+        return "duplicate task identity";
+    for (const task of s.tasks) {
+        const visited = new Set();
+        let cursor = task;
+        while (cursor) {
+            if (visited.has(cursor.taskId))
+                return "cyclic task ancestry";
+            visited.add(cursor.taskId);
+            cursor = cursor.parentTaskId ? byId.get(cursor.parentTaskId) : undefined;
+        }
+    }
+    const related = new Set(s.tasks.filter(t => expected.executorRunIds.includes(t.runId)).map(t => t.taskId));
+    // Fixed point, not ordering/prefix inference. Exclude no task just because its text says checker.
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const t of s.tasks)
+            if (t.parentTaskId && related.has(t.parentTaskId) && !related.has(t.taskId)) {
+                related.add(t.taskId);
+                changed = true;
+            }
+    }
+    for (const t of s.tasks) {
+        if (t.parentTaskId && !byId.has(t.parentTaskId))
+            return "missing ancestor";
+        if (!related.has(t.taskId) && !s.independent)
+            continue;
+        if (t.runId === s.checkerRunId)
+            return "checker/executor association conflict";
+        if (!["completed", "failed", "cancelled"].includes(t.state))
+            return "active or unknown task";
+        if (!["delivered", "not_required"].includes(t.deliveryState))
+            return "pending or unknown task return";
+    }
+    // Each root run needs explicit terminal state evidence; absence is never idle.
+    if (!s.independent && expected.executorRunIds.some(id => !s.tasks.some(t => t.runId === id)))
+        return "missing root run";
+    return null;
+}

package/dist/message-store.d.ts

@@ -103,6 +103,85 @@ export declare class MessageStore {
     constructor(dbPath?: string);
     /** Go / Go-Checker supervision state (design: artifacts/lma-go-checker-design-20260917 §10). */
     private initGoTables;
+    private ensureGoIntegrationSchema;
+    bindGoNativeIdentity(goId: number, identity: {
+        nativeGoalId?: string;
+        executorSessionId: string;
+        checkerSessionId: string;
+        checkerRunId?: string;
+        executorRunIds: string[];
+        goalUpdatedAt?: number;
+        goalRevision?: number | null;
+    }): void;
+    getGoNativeIdentity(goId: number): any;
+    setGoCriteria(goId: number, criteria: Array<{
+        id: string;
+        text: string;
+    }>): void;
+    getGoCriteria(goId: number): Array<{
+        id: string;
+        text: string;
+    }>;
+    getGoDeliveryOperation(goId: number, key: string): any;
+    recordGoDeliveryOperation(goId: number, key: string, state: "attempted" | "accepted" | "unknown" | "rejected", response?: unknown): void;
+    /** Durable initial-execution intent, separate from the at-most-once send ledger. */
+    createGoBootstrap(goId: number): void;
+    getGoBootstrap(goId: number): string | null;
+    finishGoBootstrap(goId: number, state: "done" | "superseded"): void;
+    isGoActionComplete(goId: number, actionKey: string): boolean;
+    listGoSends(goId: number): Array<{
+        actionKey: string;
+        idempotencyKey: string;
+        sessionKey: string;
+        sessionId: string;
+    }>;
+    recordGoRunResult(goId: number, actionKey: string, result: {
+        state: "complete" | "unknown";
+        text?: string;
+        runId: string;
+        executorResult?: import("./go-execution.js").GoExecutorResult;
+    }): void;
+    getGoRunResult(goId: number, actionKey: string): any;
+    listUnknownGoRunResults(goId: number): Array<{
+        actionKey: string;
+        runId: string;
+        sessionKey: string;
+        sessionId: string;
+    }>;
+    hasUnknownGoRunResults(goId: number): boolean;
+    associateGoAdmittedRun(goId: number, runId: string, executor: boolean): void;
+    /** Durable delivery ownership includes completed/stopped jobs, not only active ones. */
+    ownsGoExecutorRun(botName: string, chatId: string, sessionKey: string, sessionId: string, runId: string): boolean;
+    recordGoVisibleEvidence(goId: number, sourceKey: string, payload: {
+        sessionId: string;
+        runId: string;
+        kind: string;
+        text: string;
+        attachments: unknown[];
+    }): boolean;
+    recordGoDeliveryReceipt(goId: number, sourceKey: string, receipt: unknown): void;
+    listGoVisibleEvidence(goId: number): any[];
+    bindGoSendIdentity(goId: number, actionKey: string, identity: {
+        sessionKey: string;
+        sessionId: string;
+    }): void;
+    listUnresolvedGoSends(goId: number): Array<{
+        actionKey: string;
+        idempotencyKey: string;
+        sessionKey: string;
+        sessionId: string;
+    }>;
+    recordGoActionAttempt(goId: number, actionKey: string): {
+        state: string;
+        idempotency_key: string;
+        receipt_json: string;
+    } | undefined;
+    getGoActionLifecycle(goId: number, actionKey: string): {
+        state: string;
+        idempotency_key: string;
+        receipt_json: string;
+    } | undefined;
+    recordGoActionOutcome(goId: number, actionKey: string, state: 'accepted' | 'unknown', receipt?: unknown): void;
     observeRunError(botName: string, chatId: string, provenance: ErrorProvenance): PendingErrorNotice;
     getErrorNotice(botName: string, chatId: string, noticeId: string): PendingErrorNotice | undefined;
     saveErrorNotice(record: PendingErrorNotice): void;
@@ -245,6 +324,7 @@ export declare class MessageStore {
         executorSessionId: string;
         checkerSessionKey: string;
         checkerModel: string;
+        state?: "STARTING" | "WAITING_WORK";
     }): number;
     private rowToGoJob;
     getActiveGoJob(botName: string, chatId: string): GoJobRow | null;
@@ -266,8 +346,11 @@ export declare class MessageStore {
     finishGoCheck(goId: number, checkId: string, state: string, action: string, summary: string, raw: string): void;
     /** Idempotent action claim: returns true when newly claimed (caller performs the action), false when it already existed. */
     claimGoAction(goId: number, actionKey: string, kind: string, payload: string): boolean;
+    hasUnresolvedGoActions(goId: number): boolean;
     completeGoAction(goId: number, actionKey: string, receipt: string): void;
     setGoModelPref(botName: string, chatId: string, model: string | null): void;
     getGoModelPref(botName: string, chatId: string): string | null;
+    private closeObservers;
+    onClose(callback: () => void): () => boolean;
     close(): void;
 }

package/dist/message-store.js

@@ -83,6 +83,136 @@ export class MessageStore {
       );
     `);
     }
+    ensureGoIntegrationSchema() {
+        this.db.exec(`CREATE TABLE IF NOT EXISTS go_native_bindings (
+      go_id INTEGER PRIMARY KEY, identity_json TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS go_action_lifecycle (
+      go_id INTEGER NOT NULL, action_key TEXT NOT NULL, state TEXT NOT NULL,
+      idempotency_key TEXT NOT NULL, receipt_json TEXT NOT NULL DEFAULT '',
+      PRIMARY KEY(go_id, action_key));
+      CREATE TABLE IF NOT EXISTS go_visible_evidence (
+      go_id INTEGER NOT NULL, source_key TEXT NOT NULL, payload_json TEXT NOT NULL,
+      receipt_json TEXT NOT NULL DEFAULT '', PRIMARY KEY(go_id, source_key));`);
+    }
+    bindGoNativeIdentity(goId, identity) {
+        this.ensureGoIntegrationSchema();
+        this.db.prepare('INSERT INTO go_native_bindings VALUES (?, ?)').run(goId, JSON.stringify(identity));
+    }
+    getGoNativeIdentity(goId) {
+        this.ensureGoIntegrationSchema();
+        const row = this.db.prepare('SELECT identity_json FROM go_native_bindings WHERE go_id=?').get(goId);
+        return row ? JSON.parse(row.identity_json) : null;
+    }
+    setGoCriteria(goId, criteria) {
+        this.db.exec("CREATE TABLE IF NOT EXISTS go_criteria(go_id INTEGER PRIMARY KEY,criteria_json TEXT NOT NULL)");
+        this.db.prepare("INSERT OR REPLACE INTO go_criteria VALUES (?,?)").run(goId, JSON.stringify(criteria));
+    }
+    getGoCriteria(goId) {
+        this.db.exec("CREATE TABLE IF NOT EXISTS go_criteria(go_id INTEGER PRIMARY KEY,criteria_json TEXT NOT NULL)");
+        const row = this.db.prepare("SELECT criteria_json FROM go_criteria WHERE go_id=?").get(goId);
+        return row ? JSON.parse(row.criteria_json) : [];
+    }
+    getGoDeliveryOperation(goId, key) {
+        this.db.exec("CREATE TABLE IF NOT EXISTS go_delivery_operations(go_id INTEGER,operation_key TEXT,state TEXT,response_json TEXT,PRIMARY KEY(go_id,operation_key))");
+        return this.db.prepare("SELECT * FROM go_delivery_operations WHERE go_id=? AND operation_key=?").get(goId, key);
+    }
+    recordGoDeliveryOperation(goId, key, state, response) {
+        this.getGoDeliveryOperation(goId, key);
+        this.db.prepare("INSERT INTO go_delivery_operations VALUES (?,?,?,?) ON CONFLICT(go_id,operation_key) DO UPDATE SET state=excluded.state,response_json=excluded.response_json WHERE go_delivery_operations.state!='accepted'").run(goId, key, state, response === undefined ? "" : JSON.stringify(response));
+    }
+    /** Durable initial-execution intent, separate from the at-most-once send ledger. */
+    createGoBootstrap(goId) {
+        this.db.exec("CREATE TABLE IF NOT EXISTS go_bootstrap(go_id INTEGER PRIMARY KEY,state TEXT NOT NULL)");
+        this.db.prepare("INSERT OR IGNORE INTO go_bootstrap VALUES (?,'pending')").run(goId);
+    }
+    getGoBootstrap(goId) {
+        this.db.exec("CREATE TABLE IF NOT EXISTS go_bootstrap(go_id INTEGER PRIMARY KEY,state TEXT NOT NULL)");
+        return this.db.prepare("SELECT state FROM go_bootstrap WHERE go_id=?").get(goId)?.state ?? null;
+    }
+    finishGoBootstrap(goId, state) {
+        this.getGoBootstrap(goId);
+        this.db.prepare("UPDATE go_bootstrap SET state=? WHERE go_id=?").run(state, goId);
+    }
+    isGoActionComplete(goId, actionKey) {
+        return this.db.prepare("SELECT done FROM go_actions WHERE go_id=? AND action_key=?").get(goId, actionKey)?.done === 1;
+    }
+    listGoSends(goId) {
+        this.listUnresolvedGoSends(goId);
+        return this.db.prepare("SELECT s.*,l.idempotency_key FROM go_send_identities s JOIN go_action_lifecycle l ON s.go_id=l.go_id AND s.action_key=l.action_key WHERE s.go_id=?").all(goId)
+            .map(r => ({ actionKey: r.action_key, idempotencyKey: r.idempotency_key, ...JSON.parse(r.identity_json) }));
+    }
+    recordGoRunResult(goId, actionKey, result) {
+        this.db.exec("CREATE TABLE IF NOT EXISTS go_run_results(go_id INTEGER,action_key TEXT,result_json TEXT,PRIMARY KEY(go_id,action_key))");
+        this.db.prepare("INSERT OR REPLACE INTO go_run_results VALUES (?,?,?)").run(goId, actionKey, JSON.stringify(result));
+    }
+    getGoRunResult(goId, actionKey) {
+        this.db.exec("CREATE TABLE IF NOT EXISTS go_run_results(go_id INTEGER,action_key TEXT,result_json TEXT,PRIMARY KEY(go_id,action_key))");
+        const row = this.db.prepare("SELECT result_json FROM go_run_results WHERE go_id=? AND action_key=?").get(goId, actionKey);
+        return row ? JSON.parse(row.result_json) : null;
+    }
+    listUnknownGoRunResults(goId) {
+        this.getGoRunResult(goId, "");
+        this.listUnresolvedGoSends(goId);
+        return this.db.prepare("SELECT r.action_key,r.result_json,s.identity_json FROM go_run_results r JOIN go_send_identities s ON r.go_id=s.go_id AND r.action_key=s.action_key WHERE r.go_id=?").all(goId).flatMap(r => {
+            const result = JSON.parse(r.result_json);
+            return result.state === "unknown" ? [{ actionKey: r.action_key, runId: result.runId, ...JSON.parse(r.identity_json) }] : [];
+        });
+    }
+    hasUnknownGoRunResults(goId) {
+        this.getGoRunResult(goId, "");
+        return this.db.prepare("SELECT result_json FROM go_run_results WHERE go_id=?").all(goId).some(r => JSON.parse(r.result_json).state === "unknown");
+    }
+    associateGoAdmittedRun(goId, runId, executor) {
+        const identity = this.getGoNativeIdentity(goId);
+        if (!identity)
+            throw new Error("Missing independent identity");
+        if (executor)
+            identity.executorRunIds = [...new Set([...identity.executorRunIds, runId])];
+        else
+            identity.checkerRunId = runId;
+        this.db.prepare("UPDATE go_native_bindings SET identity_json=? WHERE go_id=?").run(JSON.stringify(identity), goId);
+    }
+    /** Durable delivery ownership includes completed/stopped jobs, not only active ones. */
+    ownsGoExecutorRun(botName, chatId, sessionKey, sessionId, runId) {
+        this.ensureGoIntegrationSchema();
+        return this.db.prepare("SELECT j.executor_session_key,j.executor_session_id,b.identity_json FROM go_jobs j JOIN go_native_bindings b ON j.id=b.go_id WHERE j.bot_name=? AND j.chat_id=? AND j.executor_session_id=?").all(botName, chatId, sessionId)
+            .some(row => [row.executor_session_key, `agent:main:${row.executor_session_key}`].includes(sessionKey) && JSON.parse(row.identity_json).executorRunIds.includes(runId));
+    }
+    recordGoVisibleEvidence(goId, sourceKey, payload) {
+        this.ensureGoIntegrationSchema();
+        return this.db.prepare('INSERT OR IGNORE INTO go_visible_evidence (go_id,source_key,payload_json) VALUES (?,?,?)').run(goId, sourceKey, JSON.stringify(payload)).changes === 1;
+    }
+    recordGoDeliveryReceipt(goId, sourceKey, receipt) {
+        this.ensureGoIntegrationSchema();
+        this.db.prepare('UPDATE go_visible_evidence SET receipt_json=? WHERE go_id=? AND source_key=?').run(JSON.stringify(receipt), goId, sourceKey);
+    }
+    listGoVisibleEvidence(goId) {
+        this.ensureGoIntegrationSchema();
+        return this.db.prepare('SELECT * FROM go_visible_evidence WHERE go_id=? ORDER BY rowid').all(goId)
+            .map(r => ({ sourceKey: r.source_key, ...JSON.parse(r.payload_json), receipt: r.receipt_json ? JSON.parse(r.receipt_json) : null }));
+    }
+    bindGoSendIdentity(goId, actionKey, identity) {
+        this.db.exec("CREATE TABLE IF NOT EXISTS go_send_identities(go_id INTEGER,action_key TEXT,identity_json TEXT,PRIMARY KEY(go_id,action_key))");
+        this.db.prepare("INSERT OR IGNORE INTO go_send_identities VALUES (?,?,?)").run(goId, actionKey, JSON.stringify(identity));
+    }
+    listUnresolvedGoSends(goId) {
+        this.db.exec("CREATE TABLE IF NOT EXISTS go_send_identities(go_id INTEGER,action_key TEXT,identity_json TEXT,PRIMARY KEY(go_id,action_key))");
+        return this.db.prepare("SELECT s.*,l.idempotency_key FROM go_send_identities s JOIN go_action_lifecycle l ON s.go_id=l.go_id AND s.action_key=l.action_key WHERE s.go_id=? AND l.state!='accepted'").all(goId).map(r => ({ actionKey: r.action_key, idempotencyKey: r.idempotency_key, ...JSON.parse(r.identity_json) }));
+    }
+    recordGoActionAttempt(goId, actionKey) {
+        this.ensureGoIntegrationSchema();
+        const idempotencyKey = `lma-go:${goId}:${actionKey}`;
+        this.db.prepare("INSERT OR IGNORE INTO go_action_lifecycle (go_id,action_key,state,idempotency_key) VALUES (?,?,'attempted',?)").run(goId, actionKey, idempotencyKey);
+        return this.getGoActionLifecycle(goId, actionKey);
+    }
+    getGoActionLifecycle(goId, actionKey) {
+        this.ensureGoIntegrationSchema();
+        return this.db.prepare('SELECT * FROM go_action_lifecycle WHERE go_id=? AND action_key=?').get(goId, actionKey);
+    }
+    recordGoActionOutcome(goId, actionKey, state, receipt) {
+        this.ensureGoIntegrationSchema();
+        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 previous = this.getErrorNotice(botName, chatId, noticeId);
@@ -1199,8 +1329,8 @@ export class MessageStore {
         const now = Date.now();
         const r = this.db.prepare(`INSERT INTO go_jobs
       (bot_name, chat_id, goal, acceptance, state, executor_session_key, executor_session_id, checker_session_key, checker_model, revision, created_at, updated_at)
-      VALUES (?, ?, ?, ?, 'WAITING_WORK', ?, ?, ?, ?, 1, ?, ?)`)
-            .run(j.botName, j.chatId, j.goal, j.acceptance, j.executorSessionKey, j.executorSessionId, j.checkerSessionKey, j.checkerModel, now, now);
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`)
+            .run(j.botName, j.chatId, j.goal, j.acceptance, j.state || "WAITING_WORK", j.executorSessionKey, j.executorSessionId, j.checkerSessionKey, j.checkerModel, now, now);
         return Number(r.lastInsertRowid);
     }
     rowToGoJob(row) {
@@ -1278,10 +1408,15 @@ export class MessageStore {
     }
     /** Idempotent action claim: returns true when newly claimed (caller performs the action), false when it already existed. */
     claimGoAction(goId, actionKey, kind, payload) {
+        this.recordGoActionAttempt(goId, actionKey);
         return this.db.prepare(`INSERT OR IGNORE INTO go_actions (go_id, action_key, kind, payload, done, created_at) VALUES (?, ?, ?, ?, 0, ?)`)
             .run(goId, actionKey, kind, payload, Date.now()).changes === 1;
     }
+    hasUnresolvedGoActions(goId) {
+        return !!this.db.prepare(`SELECT 1 FROM go_actions WHERE go_id=? AND done=0 LIMIT 1`).get(goId) || this.listUnresolvedGoSends(goId).length > 0 || this.hasUnknownGoRunResults(goId);
+    }
     completeGoAction(goId, actionKey, receipt) {
+        this.recordGoActionOutcome(goId, actionKey, "accepted", receipt);
         this.db.prepare(`UPDATE go_actions SET done=1, receipt=? WHERE go_id=? AND action_key=?`).run(receipt.slice(0, 500), goId, actionKey);
     }
     setGoModelPref(botName, chatId, model) {
@@ -1293,7 +1428,12 @@ export class MessageStore {
         const r = this.db.prepare(`SELECT model FROM go_model_prefs WHERE bot_name=? AND chat_id=?`).get(botName, chatId);
         return r?.model ?? null;
     }
+    closeObservers = new Set();
+    onClose(callback) { this.closeObservers.add(callback); return () => this.closeObservers.delete(callback); }
     close() {
+        for (const observer of this.closeObservers)
+            observer();
+        this.closeObservers.clear();
         this.db.close();
     }
 }

package/dist/openclaw-client.d.ts

@@ -1,3 +1,4 @@
+import type { GoExecutorResult } from "./go-execution.js";
 import { type ErrorProvenance, type ProactiveMessageMeta } from "./terminal-errors.js";
 import { SessionWaitPaused, type SessionRuntimeStatus } from "./session-status.js";
 import { OpenClawConfig } from "./config.js";
@@ -33,6 +34,12 @@ export declare const GATEWAY_PROTOCOL_MAX = 4;
  * 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. */
+    observeGoEvidence(callback: (event: {
+        channel: string;
+        payload: unknown;
+    }) => void): () => void;
     private config;
     private ws;
     private pending;
@@ -212,6 +219,16 @@ export declare class OpenClawClient {
     ensureModel(sessionKey: string, expectedModel: string): Promise<boolean>;
     deleteSession(key: string, deleteTranscript?: boolean): Promise<any>;
     resetSession(key: string): Promise<any>;
+    /** One-shot ToolTrim compaction: route the native semantic compaction
+     *  through the lma-core plugin's lma-tooltrim provider (keep text, keep only
+     *  the 10 most recent tool calls, drop the rest of the tool payload).
+     *  Orchestration (validated E2E 2026-10-10): config.set {raw, baseHash} →
+     *  sessions.compact → restore the original config (always). */
+    toolTrimCompact(key: string, keepRecentToolCalls?: number): Promise<any>;
+    /** Explicit LLM-summarize compaction (/compact semantic). Since lma-tooltrim
+     *  is the persistent default provider, temporarily unset it so the built-in
+     *  summarization pipeline runs, then restore the original config (always). */
+    semanticCompact(key: string): Promise<any>;
     compactSession(key: string, options?: {
         maxLines?: number;
     }): Promise<any>;
@@ -236,6 +253,113 @@ export declare class OpenClawClient {
     private releaseChatSendSlot;
     private acquireMaintenanceSlot;
     private releaseMaintenanceSlot;
+    /** Public native Goal protocol. Completion deliberately unavailable without host revision CAS. */
+    createGoNativeGoal(p: {
+        sessionKey: string;
+        sessionId: string;
+        objective: string;
+        operationId: string;
+        issuedAtMs: number;
+    }): Promise<any>;
+    readGoNativeGoal(sessionKey: string, sessionId: string): Promise<{
+        session: any;
+        goal: any;
+        revisionCAS: "unsupported";
+    }>;
+    updateGoNativeGoal(p: {
+        sessionKey: string;
+        sessionId: string;
+        goalId: string;
+        operationId: string;
+        issuedAtMs: number;
+        action: "edit" | "pause" | "resume" | "block";
+        objective?: string;
+        note?: string;
+    }): Promise<any>;
+    /** Admission receipt, not delivery. No restore, random retry key, or generation fallback. */
+    sendGoGuarded(p: {
+        sessionKey: string;
+        sessionId: string;
+        expectedLeafEntryId: string | null;
+        message: string;
+        idempotencyKey: string;
+    }): Promise<{
+        runId: any;
+        sessionId: string;
+        idempotencyKey: string;
+        raw: any;
+    }>;
+    /** Checker collection accepts only the admitted run, never a session-key fallback. */
+    collectGoRun(p: {
+        runId: string;
+        sessionKey: string;
+        sessionId?: string;
+        timeoutMs: number;
+    }): Promise<string>;
+    /** Public committed terminalReply is the authority, including explicit empty
+     * and terminal error. Stream prefaces, lifecycle end alone and timeout are not. */
+    readGoExecutorRunResult(p: {
+        sessionKey: string;
+        sessionId: string;
+        runId: string;
+    }, waitMs?: number): Promise<GoExecutorResult | null>;
+    collectGoExecutorRun(p: {
+        sessionKey: string;
+        sessionId: string;
+        runId: string;
+        timeoutMs: number;
+    }): Promise<GoExecutorResult>;
+    readGoRunResult(p: {
+        sessionKey: string;
+        sessionId: string;
+        runId: string;
+    }): Promise<string | null>;
+    /** Public generation-pinned original input receipts; absence is unknown, not permission to resend. */
+    reconcileGoSend(p: {
+        sessionKey: string;
+        sessionId: string;
+        idempotencyKey: string;
+    }): Promise<{
+        runId: any;
+        sessionId: string;
+        raw: any;
+    } | null>;
+    bindGoPolicy(binding: Record<string, string>): Promise<any>;
+    /** History publicly projects active leaf/run/recovery; describe alone does not. */
+    getGoSessionInfo(sessionKey: string): Promise<{
+        session: any;
+    }>;
+    verifyGoSafety(_executorKey: string): Promise<{
+        checkerToolsIsolated: boolean;
+        exactTaskAndDeliveryGate: boolean;
+        guardedSend: boolean;
+    }>;
+    initializeGoRuntime(p: {
+        goId: number;
+        goal: string;
+        executorSessionKey: string;
+        executorSessionId: string;
+        checkerSessionKey: string;
+        checkerSessionId: string;
+    }): Promise<{
+        executorSessionId: string;
+        checkerSessionId: string;
+        checkerRunId: string;
+        executorRunIds: never[];
+    }>;
+    readGoRuntimeSnapshot(sessionKey: string, sessionId: string): Promise<{
+        sessionKey: string;
+        sessionId: string;
+        archived: boolean;
+        complete: boolean;
+        independent: boolean;
+        atomicSnapshot: boolean;
+        queryAvailable: boolean;
+        running: any;
+        activeRunIds: any;
+        queuedInputs: any;
+        tasks: any;
+    }>;
     chatSend(params: {
         sessionKey: string;
         message: string;