- Memory, state, diagnostics, and config: split header-too-large embedding batches, keep QMD memory search enabled in transient mode, avoid SQLite WAL on NFS volumes, preserve recovery scheduling outside stuck-session warning backoff, and keep shell environment fallbacks contained in config write tests. (#92650, #92618, #92639, #91247, #92752) Thanks @mushuiyu886, @TurboTheTurtle, @849261680, and @gnanam1990.

- UI/mobile/TUI: preserve dashboard session parent lineage, WebChat backscroll, reset soft command args, sidebar session picker interactivity, collapsed workspace files, resolved `/model` confirmation refs, and stale foreground iOS Gateway reconnects. (#90658, #92622, #91353, #92705, #92779, #92773, #92552) Thanks @luoyanglang, @TurboTheTurtle, @zhouhe-xydt, @NianJiuZst, @shakkernerd, @NarahariRaghava, and @Solvely-Colin.

- Release and test reliability: extend slow Gateway/full-suite watchdogs, split local full-suite shards when throttled, stabilize plugin auth marker fixtures, avoid brittle provider-ref error text, and keep QA Lab bootstrap selection assertions aligned with flow-only scenarios. (#92652)

- Agent routing: route subagent RPC callbacks addressed to an agent-shaped `--to` target to the correct session key instead of falling back to the main session, so WeChat (and other channel) session-key callbacks reach the intended subagent session. (#90231) Thanks @zhangguiping-xydt.

## 2026.6.6

throw new Error("Message (--message) is required");

}

const rawExplicitSessionKey = opts.sessionKey?.trim();

if (!opts.to && !opts.sessionId && !rawExplicitSessionKey && !opts.agentId) {

const requestedSessionId = opts.sessionId?.trim() || undefined;

const rawTo = opts.to?.trim();

const toSessionKey =

!rawExplicitSessionKey && !requestedSessionId && classifySessionKeyShape(rawTo) === "agent"

? rawTo

: undefined;

if (!opts.to && !requestedSessionId && !rawExplicitSessionKey && !opts.agentId) {

throw new Error(

"Pass --to <E.164>, --session-key, --session-id, or --agent to choose a session",

);

classifySessionKeyShape(rawExplicitSessionKey) === "legacy_or_alias" &&

!isUnscopedSessionKeySentinel(rawExplicitSessionKey),

);

const explicitSessionKey = resolveExplicitAgentCommandSessionKey({

rawExplicitSessionKey,

agentIdOverride,

shouldScopeDefaultAgentKey,

cfg,

});

const explicitSessionKey =

toSessionKey ??

resolveExplicitAgentCommandSessionKey({

rawExplicitSessionKey,

agentIdOverride,

shouldScopeDefaultAgentKey,

cfg,

});

if (explicitSessionKey && classifySessionKeyShape(explicitSessionKey) === "malformed_agent") {

throw new Error(

`Invalid --session-key "${explicitSessionKey}". Agent-prefixed session keys must use agent:<agent-id>:<session-key>.`,

});

const runTimeoutOverrideMs = hasExplicitTimeoutOption ? timeoutMs : undefined;

const commandOpts = toSessionKey

? { ...opts, to: undefined, sessionKey: explicitSessionKey }

: opts;

const sessionResolution = resolveSession({

cfg,

to: opts.to,

sessionId: opts.sessionId,

to: commandOpts.to,

sessionId: commandOpts.sessionId,

sessionKey: explicitSessionKey,

agentId: agentIdOverride,

clone: false,

opts.transcriptMessage ?? resolveInternalEventTranscriptBody(message, opts.internalEvents);

return {

opts: commandOpts,

body,

transcriptBody,

cfg,

}

async function agentCommandInternal(

opts: AgentCommandOpts,

initialOpts: AgentCommandOpts,

runtime: RuntimeEnv = defaultRuntime,

deps?: CliDeps,

) {

const resolvedDeps = await resolveAgentCommandDeps(deps);

const isRawModelRun = opts.modelRun === true || opts.promptMode === "none";

const suppressVisibleSessionEffects = opts.sessionEffects === "internal";

const preserveUserFacingSessionModelState = opts.preserveUserFacingSessionModelState === true;

const prepared = await prepareAgentCommandExecution(opts, runtime);

const isRawModelRun = initialOpts.modelRun === true || initialOpts.promptMode === "none";

const suppressVisibleSessionEffects = initialOpts.sessionEffects === "internal";

const preserveUserFacingSessionModelState =

initialOpts.preserveUserFacingSessionModelState === true;

const prepared = await prepareAgentCommandExecution(initialOpts, runtime);

const opts = prepared.opts;

const {

body,

transcriptBody,

import type { OpenClawConfig } from "../../config/types.openclaw.js";

import {

buildAgentMainSessionKey,

classifySessionKeyShape,

DEFAULT_AGENT_ID,

isUnscopedSessionKeySentinel,

normalizeAgentId,

const defaultAgentId = normalizeAgentId(resolveDefaultAgentId(opts.cfg));

const requestedAgentId = opts.agentId?.trim() ? normalizeAgentId(opts.agentId) : undefined;

const requestedSessionId = opts.sessionId?.trim() || undefined;

const requestedSessionKey = opts.sessionKey?.trim() || undefined;

const toSessionKey =

!requestedSessionKey && !requestedSessionId && classifySessionKeyShape(opts.to) === "agent"

? opts.to?.trim()

: undefined;

const explicitSessionKey =

opts.sessionKey?.trim() ||

requestedSessionKey ||

toSessionKey ||

(!requestedSessionId

? resolveExplicitAgentSessionKey({

cfg: opts.cfg,

});

});

it("uses an agent-scoped --to value as the gateway session selector", async () => {

await withTempStore(async () => {

const sessionKey = "agent:main:openclaw-weixin:direct:o9cq802hhmfc@im.wechat";

mockGatewaySuccessReply();

await agentCliCommand({ message: "hi", to: sessionKey }, runtime);

expect(callGateway).toHaveBeenCalledTimes(1);

const request = requireRecord(requireFirstCallArg(callGateway, "gateway"), "gateway request");

const params = requireRecord(request.params, "gateway request params");

expect(params.sessionKey).toBe(sessionKey);

expect(params.to).toBeUndefined();

expect(agentCommand).not.toHaveBeenCalled();

expect(loadAgentSessionModuleMock).not.toHaveBeenCalled();

});

});

it("retries gateway dispatch with shell env fallback only when credentials need it", async () => {

await withTempStore(async ({ store }) => {

const fastConfig = {

async function normalizeSessionKeyOptsForDispatch(opts: AgentCliOpts): Promise<AgentCliOpts> {

const rawSessionKey = opts.sessionKey?.trim();

const rawTo = opts.to?.trim();

if (!rawSessionKey && !opts.sessionId?.trim() && classifySessionKeyShape(rawTo) === "agent") {

return {

...opts,

to: undefined,

sessionKey: rawTo,

};

}

const isLegacySessionKey =

rawSessionKey && classifySessionKeyShape(rawSessionKey) === "legacy_or_alias";

const agentIdRaw = opts.agent?.trim();

import { testing as acpManagerTesting } from "../acp/control-plane/manager.js";

import * as authProfileStoreModule from "../agents/auth-profiles/store.js";

import * as attemptExecutionRuntime from "../agents/command/attempt-execution.runtime.js";

import { deliverAgentCommandResult } from "../agents/command/delivery.runtime.js";

import { runEmbeddedAgent } from "../agents/embedded-agent.js";

import { loadManifestModelCatalog, loadModelCatalog } from "../agents/model-catalog.js";

import * as modelSelectionModule from "../agents/model-selection.js";

});

});

it("rejects agent-scoped to session selectors that conflict with the requested agent", async () => {

await withTempHome(async (home) => {

const store = path.join(home, "sessions.json");

const sessionKey = "agent:main:openclaw-weixin:direct:o9cq802hhmfc@im.wechat";

writeSessionStoreSeed(store, {

[sessionKey]: { sessionId: "wechat-session", updatedAt: Date.now() },

});

mockConfig(home, store, undefined, undefined, [{ id: "main" }, { id: "work" }]);

await expect(

agentCommand({ message: "hi", agentId: "work", to: sessionKey }, runtime),

).rejects.toThrow('Agent id "work" does not match session key agent "main".');

expect(runEmbeddedAgent).not.toHaveBeenCalled();

});

});

it("does not forward agent-scoped to session selectors as delivery targets", async () => {

await withTempHome(async (home) => {

const store = path.join(home, "sessions.json");

const sessionKey = "agent:main:openclaw-weixin:direct:o9cq802hhmfc@im.wechat";

writeSessionStoreSeed(store, {

[sessionKey]: {

sessionId: "wechat-session",

updatedAt: Date.now(),

lastChannel: "telegram",

lastTo: "+1555",

},

});

mockConfig(home, store);

await agentCommand(

{ message: "hi", to: sessionKey, deliver: true, channel: "telegram" },

runtime,

);

const deliveryCall = vi.mocked(deliverAgentCommandResult).mock.calls.at(-1)?.[0] as

| { opts?: { to?: string }; sessionEntry?: { lastTo?: string } }

| undefined;

expect(deliveryCall?.opts?.to).toBeUndefined();

expect(deliveryCall?.sessionEntry?.lastTo).toBe("+1555");

});

});

it("scopes bare explicit session keys to the default agent for embedded runs", async () => {

await withTempHome(async (home) => {

const store = path.join(home, "sessions.json");

expect(result.sessionKey).toBe("agent:main:main");

});

it("uses an agent-scoped --to value as the requested session key", () => {

const sessionKey = "agent:main:openclaw-weixin:direct:o9cq802hhmfc@im.wechat";

mocks.resolveStorePath.mockReturnValue(MAIN_STORE_PATH);

mocks.loadSessionStore.mockReturnValue({

[sessionKey]: { sessionId: "wechat-session", updatedAt: 0 },

});

const result = resolveSessionKeyForRequest({

cfg: baseCfg,

to: sessionKey,

});

expect(result.sessionKey).toBe(sessionKey);

});

it("uses the configured default agent store for new --to sessions", () => {

setupMainAndMybotStorePaths();

mockStoresByPath({