openclaw-lark-multi-agent 1.5.1 → 1.7.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

@@ -74,9 +74,114 @@ export interface PendingErrorNotice {
     hasObservedContinuingTask?: boolean;
     recoveryProbeUsed?: boolean;
 }
+export type GoJobRow = {
+    id: number;
+    botName: string;
+    chatId: string;
+    goal: string;
+    acceptance: string;
+    state: "STARTING" | "WAITING_WORK" | "CHECKING" | "FOLLOWUP_QUEUED" | "COMPLETING" | "COMPLETED" | "PAUSED" | "BLOCKED" | "STOPPED";
+    executorSessionKey: string;
+    executorSessionId: string;
+    checkerSessionKey: string;
+    checkerModel: string;
+    revision: number;
+    continueCount: number;
+    waitStreak: number;
+    stagnantCount: number;
+    parseRetries: number;
+    evidenceWatermark: number;
+    lastMissingJson: string;
+    lastVerdict: string;
+    lastVerdictSummary: string;
+    pauseReason: string;
+    createdAt: number;
+    updatedAt: number;
+};
 export declare class MessageStore {
     private db;
     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;
@@ -210,5 +315,42 @@ export declare class MessageStore {
      */
     markBotProcessed(botName: string, messageId: string): void;
     tryMarkBotProcessed(botName: string, messageId: string): boolean;
+    createGoJob(j: {
+        botName: string;
+        chatId: string;
+        goal: string;
+        acceptance: string;
+        executorSessionKey: string;
+        executorSessionId: string;
+        checkerSessionKey: string;
+        checkerModel: string;
+        state?: "STARTING" | "WAITING_WORK";
+    }): number;
+    private rowToGoJob;
+    getActiveGoJob(botName: string, chatId: string): GoJobRow | null;
+    getGoJobById(id: number): GoJobRow | null;
+    listActiveGoJobs(botName?: string): GoJobRow[];
+    /** CAS update: only applies when the current revision matches. Returns success. */
+    updateGoJobCas(id: number, expectedRevision: number, patch: Partial<Record<"state" | "pauseReason" | "continueCount" | "waitStreak" | "stagnantCount" | "parseRetries" | "evidenceWatermark" | "lastMissingJson" | "lastVerdict" | "lastVerdictSummary" | "executorSessionId", unknown>>): boolean;
+    /** Insert evidence; returns the new event seq, or -1 when deduplicated. */
+    insertGoEvent(goId: number, sourceKey: string, kind: string, content: string): number;
+    listGoEventsSince(goId: number, afterSeq: number): Array<{
+        seq: number;
+        kind: string;
+        sourceKey: string;
+        content: string;
+        delivered: number;
+    }>;
+    maxGoEventSeq(goId: number): number;
+    insertGoCheck(goId: number, checkId: string, evidenceMaxSeq: number): boolean;
+    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

@@ -11,6 +11,207 @@ export class MessageStore {
         this.db = new Database(path);
         this.db.pragma("journal_mode = WAL");
         this.init();
+        this.initGoTables();
+    }
+    /** Go / Go-Checker supervision state (design: artifacts/lma-go-checker-design-20260917 §10). */
+    initGoTables() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS go_jobs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        bot_name TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        goal TEXT NOT NULL,
+        acceptance TEXT NOT NULL DEFAULT '',
+        state TEXT NOT NULL DEFAULT 'WAITING_WORK',
+        executor_session_key TEXT NOT NULL,
+        executor_session_id TEXT NOT NULL DEFAULT '',
+        checker_session_key TEXT NOT NULL,
+        checker_model TEXT NOT NULL,
+        revision INTEGER NOT NULL DEFAULT 1,
+        continue_count INTEGER NOT NULL DEFAULT 0,
+        wait_streak INTEGER NOT NULL DEFAULT 0,
+        stagnant_count INTEGER NOT NULL DEFAULT 0,
+        parse_retries INTEGER NOT NULL DEFAULT 0,
+        evidence_watermark INTEGER NOT NULL DEFAULT 0,
+        last_missing_json TEXT NOT NULL DEFAULT '[]',
+        last_verdict TEXT NOT NULL DEFAULT '',
+        last_verdict_summary TEXT NOT NULL DEFAULT '',
+        pause_reason TEXT NOT NULL DEFAULT '',
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_go_jobs_active ON go_jobs(bot_name, chat_id, state);
+      CREATE TABLE IF NOT EXISTS go_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        go_id INTEGER NOT NULL,
+        source_key TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        content TEXT NOT NULL,
+        delivered INTEGER NOT NULL DEFAULT 1,
+        created_at INTEGER NOT NULL,
+        UNIQUE(go_id, source_key)
+      );
+      CREATE TABLE IF NOT EXISTS go_checks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        go_id INTEGER NOT NULL,
+        check_id TEXT NOT NULL,
+        evidence_max_seq INTEGER NOT NULL,
+        state TEXT NOT NULL DEFAULT 'pending',
+        action TEXT NOT NULL DEFAULT '',
+        summary TEXT NOT NULL DEFAULT '',
+        raw TEXT NOT NULL DEFAULT '',
+        created_at INTEGER NOT NULL,
+        UNIQUE(go_id, check_id)
+      );
+      CREATE TABLE IF NOT EXISTS go_actions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        go_id INTEGER NOT NULL,
+        action_key TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        payload TEXT NOT NULL DEFAULT '',
+        receipt TEXT NOT NULL DEFAULT '',
+        done INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        UNIQUE(go_id, action_key)
+      );
+      CREATE TABLE IF NOT EXISTS go_model_prefs (
+        bot_name TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        model TEXT,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY(bot_name, chat_id)
+      );
+    `);
+    }
+    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);
@@ -1123,7 +1324,116 @@ 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;
     }
+    // --- Go / Go-Checker supervision (DESIGN.md §10) ---
+    createGoJob(j) {
+        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 (?, ?, ?, ?, ?, ?, ?, ?, ?, 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) {
+        return {
+            id: row.id, botName: row.bot_name, chatId: row.chat_id, goal: row.goal, acceptance: row.acceptance,
+            state: row.state, executorSessionKey: row.executor_session_key, executorSessionId: row.executor_session_id,
+            checkerSessionKey: row.checker_session_key, checkerModel: row.checker_model, revision: row.revision,
+            continueCount: row.continue_count, waitStreak: row.wait_streak, stagnantCount: row.stagnant_count,
+            parseRetries: row.parse_retries, evidenceWatermark: row.evidence_watermark,
+            lastMissingJson: row.last_missing_json, lastVerdict: row.last_verdict, lastVerdictSummary: row.last_verdict_summary,
+            pauseReason: row.pause_reason, createdAt: row.created_at, updatedAt: row.updated_at,
+        };
+    }
+    getActiveGoJob(botName, chatId) {
+        const row = this.db.prepare(`SELECT * FROM go_jobs WHERE bot_name=? AND chat_id=? AND state NOT IN ('COMPLETED','STOPPED') ORDER BY id DESC LIMIT 1`).get(botName, chatId);
+        return row ? this.rowToGoJob(row) : null;
+    }
+    getGoJobById(id) {
+        const row = this.db.prepare(`SELECT * FROM go_jobs WHERE id=?`).get(id);
+        return row ? this.rowToGoJob(row) : null;
+    }
+    listActiveGoJobs(botName) {
+        const rows = botName
+            ? this.db.prepare(`SELECT * FROM go_jobs WHERE bot_name=? AND state NOT IN ('COMPLETED','STOPPED')`).all(botName)
+            : this.db.prepare(`SELECT * FROM go_jobs WHERE state NOT IN ('COMPLETED','STOPPED')`).all();
+        return rows.map((r) => this.rowToGoJob(r));
+    }
+    /** CAS update: only applies when the current revision matches. Returns success. */
+    updateGoJobCas(id, expectedRevision, patch) {
+        const sets = [];
+        const vals = [];
+        const colMap = {
+            state: "state", pauseReason: "pause_reason", continueCount: "continue_count", waitStreak: "wait_streak",
+            stagnantCount: "stagnant_count", parseRetries: "parse_retries", evidenceWatermark: "evidence_watermark",
+            lastMissingJson: "last_missing_json", lastVerdict: "last_verdict", lastVerdictSummary: "last_verdict_summary",
+            executorSessionId: "executor_session_id",
+        };
+        for (const [k, v] of Object.entries(patch)) {
+            const col = colMap[k];
+            if (!col)
+                continue;
+            sets.push(`${col}=?`);
+            vals.push(v);
+        }
+        if (sets.length === 0)
+            return false;
+        sets.push("revision=revision+1", "updated_at=?");
+        vals.push(Date.now());
+        const r = this.db.prepare(`UPDATE go_jobs SET ${sets.join(", ")} WHERE id=? AND revision=?`).run(...vals, id, expectedRevision);
+        return r.changes === 1;
+    }
+    /** Insert evidence; returns the new event seq, or -1 when deduplicated. */
+    insertGoEvent(goId, sourceKey, kind, content) {
+        const r = this.db.prepare(`INSERT OR IGNORE INTO go_events (go_id, source_key, kind, content, delivered, created_at) VALUES (?, ?, ?, ?, 1, ?)`)
+            .run(goId, sourceKey, kind, content, Date.now());
+        if (r.changes === 0)
+            return -1;
+        return Number(r.lastInsertRowid);
+    }
+    listGoEventsSince(goId, afterSeq) {
+        const rows = this.db.prepare(`SELECT id, kind, source_key, content, delivered FROM go_events WHERE go_id=? AND id>? ORDER BY id`).all(goId, afterSeq);
+        return rows.map((r) => ({ seq: r.id, kind: r.kind, sourceKey: r.source_key, content: r.content, delivered: r.delivered }));
+    }
+    maxGoEventSeq(goId) {
+        const r = this.db.prepare(`SELECT MAX(id) AS m FROM go_events WHERE go_id=?`).get(goId);
+        return r?.m || 0;
+    }
+    insertGoCheck(goId, checkId, evidenceMaxSeq) {
+        return this.db.prepare(`INSERT OR IGNORE INTO go_checks (go_id, check_id, evidence_max_seq, state, created_at) VALUES (?, ?, ?, 'pending', ?)`)
+            .run(goId, checkId, evidenceMaxSeq, Date.now()).changes === 1;
+    }
+    finishGoCheck(goId, checkId, state, action, summary, raw) {
+        this.db.prepare(`UPDATE go_checks SET state=?, action=?, summary=?, raw=? WHERE go_id=? AND check_id=?`)
+            .run(state, action, summary, raw.slice(0, 4000), goId, checkId);
+    }
+    /** 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) {
+        this.db.prepare(`INSERT INTO go_model_prefs (bot_name, chat_id, model, updated_at) VALUES (?, ?, ?, ?)
+      ON CONFLICT(bot_name, chat_id) DO UPDATE SET model=excluded.model, updated_at=excluded.updated_at`)
+            .run(botName, chatId, model, Date.now());
+    }
+    getGoModelPref(botName, chatId) {
+        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();
     }
 }