openclaw-lark-multi-agent 1.8.4 → 1.8.6

package/dist/session-status.d.ts

@@ -5,6 +5,8 @@ export type SessionRuntimeStatus = {
     status: string;
     running: boolean;
     checkedAt: number;
+    /** Positive public activity evidence, never inferred from !running. */
+    idleConfirmed?: boolean;
     contextUsedTokens?: number;
     contextLimitTokens?: number;
 };

package/dist/session-status.js

@@ -14,6 +14,7 @@ export function normalizeSessionRuntimeStatus(value) {
     const contextUsedTokens = session?.totalTokensFresh !== false && typeof used === "number" && Number.isFinite(used) && used >= 0 ? used : undefined;
     const contextLimitTokens = typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? limit : undefined;
     return { status: running ? "running" : status, running, checkedAt: Date.now(),
+        ...(session?.hasActiveRun === false && !running ? { idleConfirmed: true } : {}),
         ...(contextUsedTokens !== undefined ? { contextUsedTokens } : {}),
         ...(contextLimitTokens !== undefined ? { contextLimitTokens } : {}),
     };

package/docs/releases/1.8.5.md

@@ -0,0 +1,65 @@
+# 1.8.5 — reliability candidate (not published)
+
+- Long silent tools/API calls have no LMA 24-hour failure horizon. Ten-minute
+  silence changes presentation only; exact-run custody survives disconnect and
+  process restart in LMA-owned SQLite. Queries have short independent deadlines.
+- Superseded observers transfer exact-run delivery custody synchronously. Failed
+  replacement admission leaves a healthy old collector alive. Admission, owner,
+  actual batch and persistent stop generations fence late work and UI updates.
+- Inbound requests start with Typing. Get requires actual accepted custody, never
+  local queueing, send initiation, a boolean eligibility value or `in_flight`.
+  DONE belongs to the exact settled task. UI API failure is independently retried
+  and cannot block admission or result delivery.
+- Body, file/image/document and supplemental outputs share durable platform
+  operation receipts and atomic context/checkpoint registration. Unknown platform
+  outcomes fence retry/fallback. Exact platform IDs deduplicate echoes; independent
+  identical-text tasks remain distinct. Confirmed partial chunks are recoverable.
+- Historical context preview/explicit registration (never resend):
+  `node scripts/audit-delivery-context.mjs --db <explicit-path> --bot <name>`.
+  `--register --outbox <id> --chat <id> --verified-message-id <actual-id>` requires
+  independently verified receipts. Upgrade does **not** auto-backfill live history.
+
+## Persistent real-time insertion (coordinated bridge + lma-core 0.2.0)
+
+- Busy-session inputs reserve durable message custody before ingress awaits.
+  Short submit/query RPCs and one paced bridge recovery scheduler retain the
+  original input beyond 3/8 seconds and hours of not-ready observations. There
+  is no insertion age deadline or automatic ordinary-send timeout fallback.
+- The production plugin now actually invokes the **public**
+  `queueAgentHarnessMessage(..., { onQueueAccepted })`. Only the backend's
+  `onQueueAccepted(true)` is persisted as acceptance and drives Get. Immediate
+  SDK `true` means an attempt, not a receipt. SDK `false` or explicit callback
+  `false` is a no-effect refusal and permits paced retry of the original target.
+- Stable input ID + payload/session-generation/run/stop identity and fsynced
+  plugin attempt journal make late callbacks queryable after RPC timeout or
+  disconnect. Restart preserves accepted/unknown. Missing callbacks, missing
+  journals after a possible attempt and crash ambiguity stay **unknown**, never
+  ordinary-replayed; `queueIdentity` is NOT assumed to deduplicate host effects.
+- Canonical bot/session generation, archive/reset and persistent stop epochs
+  fence admission and reactions. Lifecycle + public exact-terminal observations
+  prevent a known ended original run from being SDK-retargeted to its successor.
+  Only an input proven never dispatched to the backend, with confirmed original
+  terminal and session idle, is explicitly handed back to the ordinary queue
+  once, with a status notice. Successor runs in the same session are legitimate
+  session work, not a different chat; they are not silently selected by retries.
+
+### Honest public-runtime boundary (not a feature-disable gate)
+
+`atomicRunBound` remains **false**: public SDK resolution plus queue invocation
+is synchronous locally, but the host offers no portable final-effect original-
+run CAS across awaited backend preparation. We do **not** claim that stronger
+host guarantee or model consumption. It is not a prerequisite for the user's
+current-session input semantics, so builtin insertion is enabled with truthful
+callback receipts instead of being universally `capability_blocked`.
+
+Both inspected builtin versions implement the acceptance callback. A legacy or
+alternative backend that never calls it remains **acceptance unknown** with no
+Get/no automatic resend. Real public-SDK typed synthetic-harness and application
+integration tests execute queue methods; these are offline transport conformance,
+not live model/Feishu acceptance or proof that every optional backend supports
+callbacks. No private SDK imports, synthetic authority, host DB edits or system
+installation changes are involved.
+
+This coordinated protocol candidate requires the matching bridge and lma-core
+plugin. This file is release preparation, **not permission to publish, deploy or
+restart anything**.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-lark-multi-agent",
-  "version": "1.8.4",
+  "version": "1.8.6",
   "description": "Multi-bot Lark/Feishu bridge for OpenClaw, with per-bot model routing and isolated sessions",
   "type": "module",
   "scripts": {
@@ -13,7 +13,8 @@
     "prepack": "npm run build",
     "prepublishOnly": "npm test && npm pack --dry-run",
     "build:go-plugin": "tsc -p plugins/lma-go/tsconfig.json",
-    "build:core-plugin": "tsc -p plugins/lma-core/tsconfig.json"
+    "build:core-plugin": "tsc -p plugins/lma-core/tsconfig.json",
+    "test:sdk-contract": "tsc --noEmit --strict --target ES2022 --module ESNext --moduleResolution bundler --skipLibCheck tests/reliability-public-sdk.test.ts"
   },
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.73.3",
@@ -67,7 +68,12 @@
     "README.md",
     "README.zh-CN.md",
     "LICENSE",
-    "SECURITY.md"
+    "SECURITY.md",
+    "plugins/lma-core/dist",
+    "plugins/lma-core/openclaw.plugin.json",
+    "plugins/lma-core/package.json",
+    "plugins/lma-core/README.md",
+    "docs/releases/1.8.5.md"
   ],
   "engines": {
     "node": ">=22"

package/plugins/lma-core/README.md

@@ -0,0 +1,83 @@
+# lma-core
+
+The single consolidated LMA gateway plugin. Replaces:
+
+- `lma-steer` 0.1.1 → steer module (`lma.steer`)
+- `lma-go` 0.1.0 → go module (`lma.go.bind/capabilities/snapshot`, `before_tool_call` guard)
+
+plus the new compaction R&D module (`lma.core.capabilities`).
+
+## Why one plugin
+
+Each extra plugin is one more manifest + allowlist + upgrade path that can
+silently fail to load (two production incidents in one week proved it).
+lma-core keeps ALL gateway method names and the persisted go-bindings path
+(`<stateDir>/lma-go/bindings.json`) unchanged, so the LMA bridge and existing
+state migrate with zero changes.
+
+## Gateway methods
+
+| Method | Scope | Purpose |
+|---|---|---|
+| `lma.steer` | (bridge) | Durable session-input submit/query; actual backend callback acceptance |
+| `lma.steer.stop` | (bridge) | Persist session stop-epoch cutoff; late old attempts cannot revive |
+| `lma.steer.capabilities` | (bridge) | Truthful acceptance/atomic-target capability report |
+| `lma.go.bind` | operator.admin | Persist a checker tool-isolation binding |
+| `lma.go.capabilities` | operator.read | Report Go module capability surface |
+| `lma.go.snapshot` | operator.read | Session-scoped task snapshot |
+| `lma.core.capabilities` | operator.read | Module inventory + compaction strategy report |
+
+## Compaction R&D (Phase 1)
+
+Custom compaction (tool-trim: drop tool payload, keep text) is being built as
+a gateway-sanctioned projection — the transcript stays intact; only the model
+context gets filtered. Phase 1 ships the capability report and an
+env-gated api-surface probe (`LMA_CORE_LOG_API=1` logs the plugin api's
+enumerable surface at registration) so Phase 2 targets real hook names
+(candidates: `llmInputHook`, `Before/AfterCompactionHook`, ContextEngine
+projections).
+
+## Build
+
+```bash
+cd plugins/lma-core && ../../node_modules/.bin/tsc -p tsconfig.json
+```
+
+(Repo root `npm run build:core-plugin` runs the same.)
+
+## 0.2.0 persistent callback-confirmed insertion
+
+`lma.steer.capabilities` returns protocol 2, `acceptanceCallback:true`,
+`durableAttempts:true`, `sessionGenerationBound:true`, **`atomicRunBound:false`**.
+The latter is a disclosed public-host limitation, not a gate disabling insertion.
+
+`lma.steer` requires `sessionKey`, `text`, stable `insertionId`, `expectedRunId`,
+`expectedSessionId`, and integer `stopEpoch`. The bridge pins these before its
+attempt journal and drives paced recovery; the method returns promptly rather
+than holding an RPC for readiness/acceptance. `queryOnly:true` never queues.
+The plugin synchronously resolves/checks/dispatches using public SDK exports,
+fsyncs an unknown-attempt fence before queue invocation, and records the actual
+`onQueueAccepted(true/false)` asynchronously under that exact attempt identity.
+No `deliveryTimeoutMs` or unverified cross-version abort behavior is assumed.
+
+- SDK immediate false: no queue dispatch, pending/no-effect, safe paced retry.
+- SDK immediate true: attempt/unknown; only backend callback true permits Get.
+- Explicit callback false: no-effect refusal; retries remain original-target
+  scoped and paced, never a switch to whatever run happens to be current.
+- No callback, lost journal after attempt, crash at/before dispatch: unknown,
+  never a retry or ordinary fallback. Stable queue ID is not host idempotency.
+- Delayed callback true: durable accepted, readable on later query/restart.
+- Stop/reset epoch or changed generation/archive: cancel/pause, no migration.
+- Exact old-run terminal + proven never dispatched + positive session idle: the bridge
+  explicitly releases the original pending input to ordinary custody once.
+
+The journal lives under `<OPENCLAW_STATE_DIR>/lma-core/steer-custody` (default
+`~/.openclaw`). Only explicit never-attempted `capability_blocked` records from
+an earlier local candidate are migrated; attempted uncertainty is not erased.
+No OpenClaw internal DB, private hashed imports, handle replacement or invented
+source authority is used. Backend acceptance is not model consumption or DONE.
+
+Both inspected builtin SDK versions call the acceptance callback. Backends that
+omit it stay explicitly unconfirmed and cannot get Get. The public SDK does not
+provide final-effect original-run CAS across backend awaits: session generation
+and observed lifecycle fencing must not be advertised as that stronger promise.

package/plugins/lma-core/dist/compaction.js

@@ -0,0 +1,82 @@
+/**
+ * lma-core :: compaction module (Phase 1: capability surface)
+ * -----------------------------------------------------------
+ * Home of the custom compaction R&D (user directive 2026-10-10: tool-trim —
+ * drop tool payload, keep text — via the gateway's sanctioned internals
+ * instead of external storage writes).
+ *
+ * Phase 1 ships:
+ *  - `lma.core.capabilities`: module inventory + compaction strategy report.
+ *  - Registration-time api-surface probe (env LMA_CORE_LOG_API=1): logs the
+ *    plugin api's enumerable surface so Phase 2 can target the real
+ *    llm-input / compaction hook names instead of guessing.
+ *
+ * Phase 2 (next): tool-trim projection using the discovered hooks
+ * (candidates from the SDK: runAgentHarnessLlmInputHook,
+ * Before/AfterCompactionHook, ContextEngine projections).
+ */
+export function registerCompaction(api) {
+    if (process.env.LMA_CORE_LOG_API === "1") {
+        try {
+            const surface = Object.getOwnPropertyNames(Object.getPrototypeOf(api) ?? {})
+                .concat(Object.keys(api ?? {}));
+            const unique = Array.from(new Set(surface)).sort();
+            console.log(`[lma-core] compaction probe: plugin api surface (${unique.length}): ${unique.join(", ")}`);
+        }
+        catch (err) {
+            console.warn(`[lma-core] compaction probe failed:`, err.message);
+        }
+    }
+    api.registerGatewayMethod("lma.core.probe", ({ respond }) => {
+        // Phase-2 R&D: dump the live plugin api + runtime surface (names only,
+        // no values — nothing sensitive) so toolTrim targets real methods.
+        const surface = (obj, depth = 0) => {
+            if (!obj || typeof obj !== "object" || depth > 2)
+                return typeof obj;
+            const out = {};
+            let keys = [];
+            try {
+                keys = Object.keys(obj);
+            }
+            catch {
+                return "inaccessible";
+            }
+            try {
+                const proto = Object.getPrototypeOf(obj);
+                if (proto && proto !== Object.prototype) {
+                    keys = Array.from(new Set([...Object.getOwnPropertyNames(proto), ...keys]));
+                }
+            }
+            catch { /* ignore */ }
+            for (const k of keys.slice(0, 120)) {
+                let v;
+                try {
+                    v = obj[k];
+                }
+                catch {
+                    out[k] = "getter-threw";
+                    continue;
+                }
+                out[k] = typeof v === "function" ? "fn" : surface(v, depth + 1);
+            }
+            return out;
+        };
+        respond(true, { api: surface(api), version: "0.1.0" });
+    }, { scope: "operator.read" });
+    api.registerGatewayMethod("lma.core.capabilities", ({ respond }) => {
+        respond(true, {
+            plugin: "lma-core",
+            modules: ["steer", "go", "compaction"],
+            methods: ["lma.steer", "lma.go.bind", "lma.go.capabilities", "lma.go.snapshot", "lma.core.capabilities"],
+            compaction: {
+                rpcStrategies: ["semantic (LLM summarize)", "maxLines (transcript tail truncate)"],
+                toolTrim: {
+                    status: "phase-1-probe",
+                    target: "projection-style: keep transcript intact, filter tool payload from model context",
+                    candidateHooks: ["llmInputHook", "beforeCompactionHook", "contextEngineProjection"],
+                },
+            },
+            version: "0.1.0",
+        });
+    }, { scope: "operator.read" });
+}

package/plugins/lma-core/dist/go-policy.js

@@ -0,0 +1,25 @@
+export function checkTool(bindings, event, ctx) {
+    for (const b of bindings) {
+        // Deny also on changed/missing generation: an old checker must not become unrestricted.
+        if (ctx.sessionKey === b.checkerSessionKey || ctx.sessionId === b.checkerSessionId)
+            return { block: true, blockReason: "LMA Go message-review Checker cannot invoke tools" };
+    }
+}
+export function parseBindings(value) {
+    if (!Array.isArray(value))
+        throw new Error("bindings must be an array");
+    const seen = new Set();
+    return value.map((item) => {
+        if (!item || typeof item !== "object")
+            throw new Error("invalid binding");
+        for (const k of ["checkerSessionKey", "checkerSessionId", "executorSessionKey", "executorSessionId"])
+            if (typeof item[k] !== "string" || !item[k].trim())
+                throw new Error(`missing ${k}`);
+        if (!item.checkerSessionKey.startsWith("agent:") || !item.executorSessionKey.startsWith("agent:"))
+            throw new Error("canonical session keys required");
+        if (item.checkerSessionKey === item.executorSessionKey || item.checkerSessionId === item.executorSessionId || seen.has(item.checkerSessionKey))
+            throw new Error("ambiguous binding");
+        seen.add(item.checkerSessionKey);
+        return { ...item };
+    });
+}

package/plugins/lma-core/dist/go-registry.js

@@ -0,0 +1,37 @@
+import { mkdirSync, readFileSync, writeFileSync, renameSync } from "node:fs";
+import { dirname } from "node:path";
+import { parseBindings } from "./go-policy.js";
+/** Atomic persisted restriction registry. Never auto-unbind on restart/stop. */
+export class GoPolicyRegistry {
+    path;
+    bindings;
+    constructor(path, initial = []) {
+        this.path = path;
+        let value;
+        try {
+            value = JSON.parse(readFileSync(path, "utf8"));
+        }
+        catch (e) {
+            if (e.code !== "ENOENT")
+                throw e;
+            value = initial;
+        }
+        this.bindings = parseBindings(value);
+    }
+    list() { return this.bindings.map(b => ({ ...b })); }
+    bind(value) {
+        const [binding] = parseBindings([value]);
+        const previous = this.bindings.find(b => b.checkerSessionKey === binding.checkerSessionKey);
+        if (previous) {
+            if (JSON.stringify(previous) !== JSON.stringify(binding))
+                throw new Error("Binding identity conflict");
+            return;
+        }
+        const next = parseBindings([...this.bindings, binding]);
+        mkdirSync(dirname(this.path), { recursive: true });
+        const temp = `${this.path}.tmp`;
+        writeFileSync(temp, JSON.stringify(next), { mode: 0o600 });
+        renameSync(temp, this.path);
+        this.bindings = next;
+    }
+}

package/plugins/lma-core/dist/go.js

@@ -0,0 +1,42 @@
+import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
+import { join } from "node:path";
+import { checkTool } from "./go-policy.js";
+import { GoPolicyRegistry } from "./go-registry.js";
+/**
+ * lma-core :: go module
+ * ---------------------
+ * Exact-identity persisted Go tool enforcement for the independent LMA Go
+ * Checker (message-review checkers may not invoke tools).
+ *
+ * Gateway methods (names kept identical to the former standalone lma-go
+ * plugin): `lma.go.bind`, `lma.go.capabilities`, `lma.go.snapshot`.
+ * The persisted registry path is also unchanged
+ * (`<stateDir>/lma-go/bindings.json`) so existing bindings carry over.
+ */
+export function registerGo(api) {
+    const registry = new GoPolicyRegistry(join(resolveStateDir(), "lma-go", "bindings.json"), api.pluginConfig?.bindings ?? []);
+    api.on("before_tool_call", (event, ctx) => checkTool(registry.list(), event, ctx), { priority: 10000 });
+    api.registerGatewayMethod("lma.go.bind", ({ params, respond }) => {
+        try {
+            registry.bind(params.binding);
+            respond(true, { persisted: true, binding: params.binding });
+        }
+        catch (e) {
+            respond(false, undefined, { code: "INVALID_REQUEST", message: e.message });
+        }
+    }, { scope: "operator.admin" });
+    api.registerGatewayMethod("lma.go.capabilities", ({ respond }) => {
+        respond(true, { mode: "independent", checkerToolsIsolated: true, taskQuery: true,
+            atomicSnapshot: false, nativeGoalAuthority: false });
+    }, { scope: "operator.read" });
+    api.registerGatewayMethod("lma.go.snapshot", ({ params, respond }) => {
+        if (typeof params.sessionKey !== "string" || typeof params.sessionId !== "string") {
+            respond(false, undefined, { code: "INVALID_REQUEST", message: "exact session identity required" });
+            return;
+        }
+        const tasks = api.runtime.tasks.runs.bindSession({ sessionKey: params.sessionKey }).list();
+        respond(true, { sessionKey: params.sessionKey, requestedSessionId: params.sessionId, tasks,
+            queryAvailable: true, atomicSnapshot: false,
+            boundaries: ["tasks scoped to canonical key; adapter pins generation and run ids", "LMA checks its own queue and delivery ledger"] });
+    }, { scope: "operator.read" });
+}

package/plugins/lma-core/dist/index.js

@@ -0,0 +1,29 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { registerSteer } from "./steer.js";
+import { registerGo } from "./go.js";
+import { registerCompaction } from "./compaction.js";
+import { registerToolTrim } from "./tooltrim.js";
+/**
+ * lma-core — the single consolidated LMA gateway plugin
+ * ------------------------------------------------------
+ * Replaces the former standalone plugins:
+ *   - lma-steer (0.1.1)  -> steer module   (`lma.steer`)
+ *   - lma-go    (0.1.0)  -> go module      (`lma.go.*`, before_tool_call guard)
+ * plus the new compaction R&D module (`lma.core.capabilities`).
+ *
+ * One manifest, one allowlist entry, one upgrade path. All gateway method
+ * names and the persisted go-bindings path are unchanged, so the LMA bridge
+ * and existing state migrate with zero changes.
+ */
+export default definePluginEntry({
+    id: "lma-core",
+    name: "LMA Core",
+    description: "Consolidated LMA plugin: mid-run steer injection, Go checker tool enforcement, custom compaction R&D.",
+    register(api) {
+        registerSteer(api);
+        registerGo(api);
+        registerCompaction(api);
+        registerToolTrim(api);
+        console.log("[lma-core] registered: steer (lma.steer), go (lma.go.*), compaction (lma.core.*), tooltrim (lma.core.compact.tooltrim)");
+    },
+});

package/plugins/lma-core/dist/steer.js

@@ -0,0 +1,212 @@
+import { resolveActiveEmbeddedRunSessionId, queueAgentHarnessMessage, onAgentEvent } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, writeFileSync, openSync, fsyncSync, closeSync } from "node:fs";
+import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
+import { join } from "node:path";
+const canonical = (key) => /^agent:/.test(key) ? key : `agent:main:${key}`;
+const nonempty = (value) => typeof value === 'string' && !!value.trim();
+/** Short submit/query RPCs. The bridge owns one paced recovery scheduler, so
+ * callback lifetime is independent of the RPC deadline. Resolve + queue are
+ * synchronous on one event-loop turn. This is session-generation custody and
+ * observed lifecycle fencing, NOT a host final-effect original-run CAS. */
+export function registerSteer(api) {
+    const dir = join(resolveStateDir(), 'lma-core', 'steer-custody');
+    const active = new Map(), ended = new Set();
+    const unsubscribe = onAgentEvent(event => {
+        if (!event.sessionKey || !event.runId || event.stream !== 'lifecycle')
+            return;
+        const key = canonical(event.sessionKey), phase = String(event.data?.phase);
+        if (['end', 'error'].includes(phase)) {
+            ended.add(`${key}\0${event.runId}`);
+            if (active.get(key)?.runId === event.runId)
+                active.delete(key);
+            if (ended.size > 2048)
+                ended.delete(ended.values().next().value);
+        }
+        else if (phase === 'start') {
+            const startedAt = Number(event.data?.startedAt) || event.ts;
+            if ((active.get(key)?.startedAt ?? 0) > startedAt)
+                return;
+            active.set(key, { runId: event.runId, sessionId: event.sessionId, startedAt });
+            if (active.size > 512)
+                active.delete(active.keys().next().value);
+        }
+    });
+    const pathFor = (id) => join(dir, createHash('sha256').update(id).digest('hex') + '.json');
+    const readJson = (path) => { try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return;
+        throw e;
+    } };
+    // Durable no-replay fence, including power/process loss around rename.
+    const writeJson = (path, value) => {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const temp = path + '.tmp';
+        writeFileSync(temp, JSON.stringify(value), { mode: 0o600 });
+        const fd = openSync(temp, 'r+');
+        try {
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        renameSync(temp, path);
+        // Windows permits opening some directories but fsync then fails EPERM.
+        // The file is already durable+renamed: never report a false failed attempt.
+        if (process.platform !== 'win32') {
+            const parent = openSync(dir, 'r');
+            try {
+                fsyncSync(parent);
+            }
+            finally {
+                closeSync(parent);
+            }
+        }
+    };
+    const read = (id) => readJson(pathFor(id));
+    const save = (record) => { record.ordinaryEligible = record.attempted === false && record.everAttempted !== true; writeJson(pathFor(record.insertionId), record); };
+    const stopPath = (key) => pathFor(`session-stop:${key}`);
+    const cutoff = (key) => readJson(stopPath(key))?.epoch ?? 0;
+    api.registerGatewayMethod('lma.steer.capabilities', ({ respond }) => respond(true, { protocol: 2, atomicRunBound: false,
+        acceptanceCallback: true, durableAttempts: true, sessionGenerationBound: true,
+        reason: 'Backend callback confirms acceptance, not consumption. Original-run final-effect CAS is unavailable.' }));
+    api.registerGatewayMethod('lma.steer.stop', ({ params, respond }) => {
+        try {
+            if (!nonempty(params.sessionKey) || !Number.isSafeInteger(params.stopEpoch))
+                throw new Error('sessionKey and stopEpoch required');
+            const key = canonical(params.sessionKey), epoch = Math.max(cutoff(key), params.stopEpoch);
+            writeJson(stopPath(key), { epoch });
+            respond(true, { sessionKey: key, stopEpoch: epoch });
+        }
+        catch (error) {
+            respond(false, undefined, { code: 'INTERNAL', message: String(error) });
+        }
+    });
+    api.registerGatewayMethod('lma.steer', ({ params, respond }) => {
+        if (!nonempty(params.sessionKey) || !nonempty(params.text) || !nonempty(params.insertionId) || !nonempty(params.expectedRunId) ||
+            !nonempty(params.expectedSessionId) || !Number.isSafeInteger(params.stopEpoch)) {
+            respond(false, undefined, { code: 'INVALID_REQUEST', message: 'Immutable input, session/run identity and stopEpoch required' });
+            return;
+        }
+        const key = canonical(params.sessionKey);
+        try {
+            let old = read(params.insertionId);
+            const textHash = createHash('sha256').update(params.text).digest('hex');
+            // Upgrade the prior unpublished no-effect candidate's journal only.
+            // Never reinterpret an attempted/unknown row as safe to send.
+            if (old && old.status === 'capability_blocked' && old.attempted === false &&
+                old.textHash === textHash && old.sessionKey === key && old.expectedRunId === params.expectedRunId &&
+                (!old.sessionId || old.sessionId === params.expectedSessionId)) {
+                old = { ...old, sessionId: params.expectedSessionId, stopEpoch: params.stopEpoch, status: 'pending', attempt: 0 };
+                save(old);
+            }
+            if (old && (old.textHash !== textHash || old.sessionKey !== key || old.expectedRunId !== params.expectedRunId ||
+                old.sessionId !== params.expectedSessionId || old.stopEpoch !== params.stopEpoch))
+                throw new Error('Immutable insertion identity/payload mismatch');
+            if (params.queryOnly === true && !old) {
+                respond(true, { insertionId: params.insertionId, expectedRunId: params.expectedRunId, sessionId: params.expectedSessionId,
+                    status: 'unknown', attempted: true, reason: 'journal unavailable; not replayed' });
+                return;
+            }
+            const record = old || { insertionId: params.insertionId, sessionKey: key, expectedRunId: params.expectedRunId, textHash,
+                sessionId: params.expectedSessionId, stopEpoch: params.stopEpoch, status: 'pending', attempted: false, attempt: 0 };
+            if (params.cancel === true || record.stopEpoch < cutoff(key)) {
+                record.status = 'stopped';
+                save(record);
+                respond(true, record);
+                return;
+            }
+            if (record.attempted || record.status !== 'pending' || params.queryOnly === true) {
+                respond(true, record);
+                return;
+            }
+            if (params.originalRunEnded === true || ended.has(`${key}\0${record.expectedRunId}`)) {
+                record.status = 'target_ended';
+                record.reason = 'original run ended without an insertion attempt';
+                save(record);
+                respond(true, record);
+                return;
+            }
+            const observedRun = active.get(key);
+            if (observedRun && observedRun.runId !== record.expectedRunId && (!observedRun.sessionId || observedRun.sessionId === record.sessionId)) {
+                // A same-session successor is not a generation/authorization change.
+                // Wait for the original exact terminal; never SDK-retarget this retry.
+                record.reason = 'target_not_ready';
+                save(record);
+                respond(true, record);
+                return;
+            }
+            const sessionId = resolveActiveEmbeddedRunSessionId(key);
+            if (!sessionId) {
+                record.reason = 'target_not_ready';
+                save(record);
+                respond(true, record);
+                return;
+            }
+            if (record.sessionId !== sessionId) {
+                record.status = 'target_changed';
+                record.reason = 'session generation changed; no automatic migration';
+                save(record);
+                respond(true, record);
+                return;
+            }
+            // Crash even just BEFORE queue invocation remains unknown. queueIdentity
+            // is an item identity, NEVER a host dedupe/retry token.
+            const previouslyAttempted = record.everAttempted === true;
+            record.everAttempted = true;
+            record.attempted = true;
+            record.status = 'unknown';
+            record.attempt++;
+            record.reason = 'awaiting_backend_acceptance';
+            save(record);
+            const attempt = record.attempt;
+            const queued = queueAgentHarnessMessage(sessionId, params.text, { steeringMode: 'all', queueIdentity: `${record.insertionId}:${attempt}`,
+                onQueueAccepted: (accepted) => {
+                    try {
+                        const current = read(record.insertionId);
+                        if (!current || current.attempt !== attempt || current.acceptedAt)
+                            return;
+                        if (current.status === 'stopped' || current.stopEpoch < cutoff(key)) {
+                            current.status = 'stopped';
+                            if (accepted)
+                                current.acceptanceAfterStop = true;
+                        }
+                        else if (accepted) {
+                            current.status = 'accepted';
+                            current.acceptedAt = Date.now();
+                            current.reason = 'backend_onQueueAccepted_true';
+                        }
+                        else {
+                            current.status = 'pending';
+                            current.attempted = false;
+                            current.reason = 'backend_rejected_no_effect';
+                        }
+                        save(current);
+                    }
+                    catch (error) {
+                        // No durable receipt -> no Get/retry. Never throw into a backend
+                        // after it accepted input, including an asynchronous callback.
+                        api.logger?.warn?.(`lma.steer callback journal failure: ${String(error)}`);
+                    }
+                } });
+            if (!queued) {
+                const current = read(record.insertionId);
+                if (current.attempt === attempt && !current.acceptedAt) {
+                    current.everAttempted = previouslyAttempted;
+                    current.attempted = false;
+                    current.status = 'pending';
+                    current.reason = 'target_not_ready';
+                    save(current);
+                }
+            }
+            respond(true, read(record.insertionId));
+        }
+        catch (error) {
+            respond(false, undefined, { code: 'INTERNAL', message: `lma.steer: ${error instanceof Error ? error.message : String(error)}` });
+        }
+    });
+    return unsubscribe;
+}