"packages/memory-host-sdk/src/host/session-files.ts",

"src/acp/runtime/session-meta.ts",

"src/agents/acp-spawn.ts",

"src/agents/auth-profiles/session-override.ts",

"src/agents/embedded-agent-runner/compaction-successor-transcript.ts",

"src/agents/embedded-agent-runner/run/attempt.ts",

"src/agents/embedded-agent-runner/tool-result-truncation.ts",

"src/agents/embedded-agent-runner/transcript-rewrite.ts",

"src/agents/embedded-agent-runner/transcript-runtime-state.ts",

"src/auto-reply/reply/abort.ts",

"src/agents/subagent-control.ts",

"src/agents/subagent-registry-helpers.ts",

"src/auto-reply/reply/agent-runner-helpers.ts",

"src/auto-reply/reply/agent-runner.ts",

"src/auto-reply/reply/commands-subagents/action-info.ts",

export const migratedSessionAccessorWriteFiles = new Set([

"src/acp/runtime/session-meta.ts",

"src/agents/auth-profiles/session-override.ts",

"src/agents/command/attempt-execution.shared.ts",

"src/agents/command/session-store.ts",

"src/agents/embedded-agent-runner/run.ts",

"src/agents/embedded-agent-runner/run/attempt.ts",

"src/agents/live-model-switch.ts",

"src/agents/main-session-restart-recovery.ts",

"src/auto-reply/reply/abort.ts",

"src/agents/subagent-control.ts",

"src/agents/subagent-registry-helpers.ts",

"src/auto-reply/reply/abort-cutoff.runtime.ts",

"src/auto-reply/reply/agent-runner-cli-dispatch.ts",

"src/auto-reply/reply/agent-runner-execution.ts",

import { ensureAuthProfileStore, hasAnyAuthProfileStoreSource } from "../auth-profiles/store.js";

import { isProfileInCooldown } from "../auth-profiles/usage.js";

const sessionStoreRuntimeLoader = createLazyImportLoader(

() => import("../../config/sessions/store.runtime.js"),

const sessionAccessorLoader = createLazyImportLoader(

() => import("../../config/sessions/session-accessor.js"),

);

// Session-store writes are lazy-loaded so read-only auth resolution paths do not

// import persistence code unless an override must be updated.

function loadSessionStoreRuntime() {

return sessionStoreRuntimeLoader.load();

// Session accessor writes are lazy-loaded so read-only auth resolution paths do

// not import persistence code unless an override must be updated.

function loadSessionAccessor() {

return sessionAccessorLoader.load();

}

// Current session overrides are only valid when the selected provider can use

sessionStore[sessionKey] = sessionEntry;

if (storePath) {

await (

await loadSessionStoreRuntime()

).updateSessionStore(storePath, (store) => {

store[sessionKey] = sessionEntry;

});

await loadSessionAccessor()

).patchSessionEntry(

{ storePath, sessionKey },

() => sessionEntry,

{ fallbackEntry: sessionEntry, replaceEntry: true },

);

}

}

sessionStore[sessionKey] = sessionEntry;

if (storePath) {

await (

await loadSessionStoreRuntime()

).updateSessionStore(storePath, (storeLocal) => {

storeLocal[sessionKey] = sessionEntry;

});

await loadSessionAccessor()

).patchSessionEntry(

{ storePath, sessionKey },

() => sessionEntry,

{ fallbackEntry: sessionEntry, replaceEntry: true },

);

}

}

updateSessionStore: (...args: unknown[]) => state.updateSessionStoreMock(...args),

}));

vi.mock("../config/sessions/session-accessor.js", () => ({

loadSessionEntry: (scope: { sessionKey: string }) => {

const store = state.loadSessionStoreMock(scope) as Record<string, unknown> | undefined;

return store?.[scope.sessionKey];

},

patchSessionEntry: (...args: unknown[]) => state.updateSessionStoreMock(...args),

}));

vi.mock("../config/sessions/paths.js", () => ({

resolveStorePath: (...args: unknown[]) => state.resolveStorePathMock(...args),

}));

state.updateSessionStoreMock

.mockReset()

.mockImplementation(

async (_path: string, updater: (store: Record<string, unknown>) => void) => {

const store: Record<string, unknown> = {};

updater(store);

async (

scope: { sessionKey: string },

updater: (

entry: Record<string, unknown>,

) => Promise<Record<string, unknown> | null> | Record<string, unknown> | null,

) => {

const store = state.loadSessionStoreMock(scope) as Record<

string,

Record<string, unknown>

>;

const entry = store?.[scope.sessionKey];

if (!entry) {

return null;

}

const next = await updater(entry);

if (!next) {

return entry;

}

for (const key of Object.keys(entry)) {

delete entry[key];

}

Object.assign(entry, next);

return entry;

},

);

});

modelOverride: "claude-opus-4-6",

};

state.loadSessionStoreMock.mockReturnValue({ main: sessionEntry });

state.updateSessionStoreMock.mockImplementation(

async (_path: string, updater: (store: Record<string, unknown>) => void) => {

const store: Record<string, typeof sessionEntry> = { main: sessionEntry };

updater(store);

},

);

const { shouldSwitchToLiveModel } = await loadModule();

it("deletes liveModelSwitchPending from the session entry", async () => {

const sessionEntry = { liveModelSwitchPending: true, sessionId: "s-1" };

state.updateSessionStoreMock.mockImplementation(

async (_path: string, updater: (store: Record<string, unknown>) => void) => {

const store: Record<string, typeof sessionEntry> = { main: sessionEntry };

updater(store);

},

);

state.loadSessionStoreMock.mockReturnValue({ main: sessionEntry });

const { clearLiveModelSwitchPending } = await loadModule();

import { normalizeOptionalString } from "@openclaw/normalization-core/string-coerce";

import { resolveStorePath } from "../config/sessions/paths.js";

import { loadSessionStore, updateSessionStore } from "../config/sessions/store.js";

import { patchSessionEntry } from "../config/sessions/session-accessor.js";

import { loadSessionStore } from "../config/sessions/store.js";

import {

normalizeStoredOverrideModel,

resolveDefaultModelForAgent,

if (!storePath) {

return;

}

await updateSessionStore(storePath, (store) => {

const entry = store[sessionKey];

if (entry) {

delete entry.liveModelSwitchPending;

}

});

await patchSessionEntry(

{ storePath, sessionKey },

(entry) => {

const next = { ...entry };

delete next.liveModelSwitchPending;

return next;

},

{ replaceEntry: true },

);

}

import os from "node:os";

import path from "node:path";

import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";

import type {

SessionAccessScope,

SessionEntryPatchContext,

SessionEntryPatchOptions,

} from "../config/sessions/session-accessor.js";

import type { SessionEntry } from "../config/sessions/types.js";

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

import type { CallGatewayOptions } from "../gateway/call.js";

testing.setDepsForTest({

abortEmbeddedAgentRun: () => false,

clearSessionQueues: () => ({ followupCleared: 0, laneCleared: 0, keys: [] }),

updateSessionStore: async <T>(

storePath: string,

mutator: (store: Record<string, SessionEntry>) => Promise<T> | T,

patchSessionEntry: async (

scope: SessionAccessScope,

patcher: (

entry: SessionEntry,

context: SessionEntryPatchContext,

) => Promise<Partial<SessionEntry> | null> | Partial<SessionEntry> | null,

options: SessionEntryPatchOptions = {},

) => {

const store = JSON.parse(fs.readFileSync(storePath, "utf-8")) as Record<string, SessionEntry>;

const result = await mutator(store);

fs.writeFileSync(storePath, JSON.stringify(store, null, 2), "utf-8");

return result;

if (!scope.storePath) {

return null;

}

const store = JSON.parse(fs.readFileSync(scope.storePath, "utf-8")) as Record<

string,

SessionEntry

>;

const entry = store[scope.sessionKey];

if (!entry) {

return null;

}

const patch = await patcher(entry, { existingEntry: { ...entry } });

if (!patch) {

return entry;

}

const next = options.replaceEntry ? (patch as SessionEntry) : { ...entry, ...patch };

store[scope.sessionKey] = next;

fs.writeFileSync(scope.storePath, JSON.stringify(store, null, 2), "utf-8");

return next;

},

...overrides,

});

});

setSubagentControlDepsForTest({

updateSessionStore: async () => {

patchSessionEntry: async () => {

throw new Error("session store unavailable");

},

});

import type { ClearSessionQueueResult } from "../auto-reply/reply/queue.js";

import { resolveSubagentLabel, sortSubagentRuns } from "../auto-reply/reply/subagents-utils.js";

import { resolveStorePath } from "../config/sessions/paths.js";

import { loadSessionStore, updateSessionStore } from "../config/sessions/store.js";

import { loadSessionEntry, patchSessionEntry } from "../config/sessions/session-accessor.js";

import type { SessionEntry } from "../config/sessions/types.js";

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

import { callGateway } from "../gateway/call.js";

const steerRateLimit = new Map<string, number>();

type GatewayCaller = typeof callGateway;

type UpdateSessionStore = typeof updateSessionStore;

type PatchSessionEntry = typeof patchSessionEntry;

type AbortEmbeddedAgentRun = (sessionId: string) => boolean;

type ClearSessionQueues = (keys: Array<string | undefined>) => ClearSessionQueueResult;

const defaultSubagentControlDeps = {

callGateway,

updateSessionStore,

patchSessionEntry,

};

let subagentControlDeps: {

callGateway: GatewayCaller;

updateSessionStore: UpdateSessionStore;

patchSessionEntry: PatchSessionEntry;

abortEmbeddedAgentRun?: AbortEmbeddedAgentRun;

clearSessionQueues?: ClearSessionQueues;

} = defaultSubagentControlDeps;

}

if (resolved.entry) {

try {

await subagentControlDeps.updateSessionStore(resolved.storePath, (store) => {

const current = store[childSessionKey];

if (!current) {

return;

}

current.abortedLastRun = true;

current.updatedAt = Date.now();

store[childSessionKey] = current;

});

await subagentControlDeps.patchSessionEntry(

{ storePath: resolved.storePath, sessionKey: childSessionKey },

(current) => ({

...current,

abortedLastRun: true,

updatedAt: Date.now(),

}),

{ replaceEntry: true },

);

} catch (error) {

logVerbose(

`subagents control kill: failed to persist abortedLastRun for ${childSessionKey}: ${formatErrorMessage(error)}`,

const targetSessionKey = params.entry.childSessionKey;

const parsed = parseAgentSessionKey(targetSessionKey);

const storePath = resolveStorePath(params.cfg.session?.store, { agentId: parsed?.agentId });

const store = loadSessionStore(storePath);

const targetSessionEntry = store[targetSessionKey];

const targetSessionEntry = loadSessionEntry({

storePath,

sessionKey: targetSessionKey,

clone: false,

});

const targetSessionId =

typeof targetSessionEntry?.sessionId === "string" && targetSessionEntry.sessionId.trim()

? targetSessionEntry.sessionId.trim()

setDepsForTest(

overrides?: Partial<{

callGateway: GatewayCaller;

updateSessionStore: UpdateSessionStore;

patchSessionEntry: PatchSessionEntry;

abortEmbeddedAgentRun: AbortEmbeddedAgentRun;

clearSessionQueues: ClearSessionQueues;

}>,