### Changes

- Agents/compaction: preserve scoped background exec/process session references across embedded compaction and after-turn runtime contexts without exposing sessions from unrelated scopes. Fixes #79284. (#79307) Thanks @TurboTheTurtle.

### Fixes

- Plugin SDK: keep activated linked plugin runtime facades loadable when bundled plugin fallback is disabled. Thanks @shakkernerd.

import { formatDurationCompact } from "../infra/format-time/format-duration.js";

import { listRunningSessions } from "./bash-process-registry.js";

import { deriveSessionName } from "./bash-tools.shared.js";

const DEFAULT_ACTIVE_PROCESS_LIMIT = 8;

const MAX_COMMAND_LABEL_CHARS = 140;

export type ActiveProcessSessionReference = {

sessionId: string;

status: "running";

pid?: number;

startedAt: number;

runtimeMs: number;

cwd?: string;

command: string;

name: string;

tail?: string;

truncated: boolean;

};

function truncate(value: string, maxChars: number): string {

if (value.length <= maxChars) {

return value;

}

if (maxChars <= 1) {

return value.slice(0, maxChars);

}

return `${value.slice(0, Math.max(0, maxChars - 3))}...`;

}

export function listActiveProcessSessionReferences(params: {

scopeKey?: string;

now?: number;

limit?: number;

}): ActiveProcessSessionReference[] {

const scopeKey = params.scopeKey?.trim();

if (!scopeKey) {

return [];

}

const now = params.now ?? Date.now();

const limit =

typeof params.limit === "number" && Number.isFinite(params.limit) && params.limit > 0

? Math.floor(params.limit)

: DEFAULT_ACTIVE_PROCESS_LIMIT;

return listRunningSessions()

.filter((session) => session.backgrounded)

.filter((session) => session.scopeKey === scopeKey)

.toSorted((left, right) => right.startedAt - left.startedAt)

.slice(0, limit)

.map((session) => ({

sessionId: session.id,

status: "running" as const,

pid: session.pid ?? session.child?.pid,

startedAt: session.startedAt,

runtimeMs: Math.max(0, now - session.startedAt),

cwd: session.cwd,

command: session.command,

name: truncate(

deriveSessionName(session.command) || session.command,

MAX_COMMAND_LABEL_CHARS,

),

tail: session.tail,

truncated: session.truncated,

}));

}

export function formatActiveProcessSessionReference(

session: ActiveProcessSessionReference,

): string {

const runtime = formatDurationCompact(session.runtimeMs) ?? "unknown";

const pid = typeof session.pid === "number" ? ` pid=${session.pid}` : "";

const cwd = session.cwd ? ` cwd=${session.cwd}` : "";

return `${session.sessionId} ${session.status} ${runtime}${pid}${cwd} :: ${session.name}`;

}

vi.doMock("./lanes.js", () => ({

resolveSessionLane: vi.fn(() => "test-session-lane"),

resolveEmbeddedSessionLane: vi.fn(() => "test-session-lane"),

resolveGlobalLane: vi.fn(() => "test-global-lane"),

}));

vi.doMock("../pi-tools.js", () => ({

createOpenClawCodingTools: createOpenClawCodingToolsMock,

resolveProcessToolScopeKey: ({

scopeKey,

sessionKey,

sessionId,

agentId,

}: {

scopeKey?: string;

sessionKey?: string;

sessionId?: string;

agentId?: string;

}) => scopeKey ?? sessionKey ?? sessionId ?? (agentId ? `agent:${agentId}` : undefined),

}));

vi.doMock("./replay-history.js", () => ({

resolveRunModelFallbacksOverride,

resolveSessionAgentIds,

} from "../agent-scope.js";

import { listActiveProcessSessionReferences } from "../bash-process-references.js";

import {

makeBootstrapWarn,

resolveBootstrapContextForRun,

applyPiCompactionSettingsFromConfig,

isSilentOverflowProneModel,

} from "../pi-settings.js";

import { createOpenClawCodingTools } from "../pi-tools.js";

import { createOpenClawCodingTools, resolveProcessToolScopeKey } from "../pi-tools.js";

import { wrapStreamFnTextTransforms } from "../plugin-text-transforms.js";

import { registerProviderStreamForModel } from "../provider-stream.js";

import { collectRuntimeChannelCapabilities } from "../runtime-capabilities.js";

channel: runtimeChannel,

capabilities: runtimeCapabilities,

channelActions,

activeProcessSessions: listActiveProcessSessionReferences({

scopeKey: resolveProcessToolScopeKey({

sessionKey: sandboxSessionKey,

agentId: sessionAgentId,

}),

}),

};

const sandboxInfo = buildEmbeddedSandboxInfo(sandbox, params.bashElevated);

const reasoningTagHint = isReasoningTagProvider(provider, {

import { describe, expect, it } from "vitest";

import { afterEach, describe, expect, it } from "vitest";

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

import { addSession, resetProcessRegistryForTests } from "../bash-process-registry.js";

import { createProcessSessionFixture } from "../bash-process-registry.test-helpers.js";

import {

buildEmbeddedCompactionRuntimeContext,

resolveEmbeddedCompactionTarget,

} from "./compaction-runtime-context.js";

describe("buildEmbeddedCompactionRuntimeContext", () => {

afterEach(() => {

resetProcessRegistryForTests();

});

it("preserves sender and current message routing for compaction", () => {

const result = buildEmbeddedCompactionRuntimeContext({

sessionKey: "agent:main:thread:1",

expect(result.authProfileId).toBe("ollama:default");

});

it("preserves scoped active process session references for compaction", () => {

const active = createProcessSessionFixture({

id: "sess-active",

command: "sleep 600",

backgrounded: true,

pid: 1234,

startedAt: 1_000,

});

active.scopeKey = "agent:main:thread:1";

const other = createProcessSessionFixture({

id: "sess-other",

command: "sleep 600",

backgrounded: true,

});

other.scopeKey = "agent:other";

addSession(active);

addSession(other);

const result = buildEmbeddedCompactionRuntimeContext({

sessionKey: "agent:main:thread:1",

workspaceDir: "/tmp/workspace",

agentDir: "/tmp/agent",

config: {} as OpenClawConfig,

});

expect(result.activeProcessSessions).toEqual([

expect.objectContaining({

sessionId: "sess-active",

status: "running",

command: "sleep 600",

pid: 1234,

}),

]);

expect(result.activeProcessSessions).not.toEqual(

expect.arrayContaining([expect.objectContaining({ sessionId: "sess-other" })]),

);

});

it("omits active process session references when no safe scope is available", () => {

const active = createProcessSessionFixture({

id: "sess-active",

command: "sleep 600",

backgrounded: true,

});

active.scopeKey = "agent:main:thread:1";

addSession(active);

const result = buildEmbeddedCompactionRuntimeContext({

workspaceDir: "/tmp/workspace",

agentDir: "/tmp/agent",

config: {} as OpenClawConfig,

});

expect(result.activeProcessSessions).toBeUndefined();

});

it("applies runtime defaults when resolving the effective compaction target", () => {

expect(

resolveEmbeddedCompactionTarget({

import type { SourceReplyDeliveryMode } from "../../auto-reply/get-reply-options.types.js";

import type { ReasoningLevel, ThinkLevel } from "../../auto-reply/thinking.js";

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

import {

listActiveProcessSessionReferences,

type ActiveProcessSessionReference,

} from "../bash-process-references.js";

import type { ExecElevatedDefaults } from "../bash-tools.js";

import type { SkillSnapshot } from "../skills.js";

extraSystemPrompt?: string;

sourceReplyDeliveryMode?: SourceReplyDeliveryMode;

ownerNumbers?: string[];

activeProcessSessions?: ActiveProcessSessionReference[];

};

/**

extraSystemPrompt?: string;

sourceReplyDeliveryMode?: SourceReplyDeliveryMode;

ownerNumbers?: string[];

activeProcessSessions?: ActiveProcessSessionReference[];

}): EmbeddedCompactionRuntimeContext {

const resolved = resolveEmbeddedCompactionTarget({

config: params.config,

provider: params.provider,

modelId: params.modelId,

authProfileId: params.authProfileId,

});

const processScopeKey = params.sessionKey?.trim();

const activeProcessSessions =

params.activeProcessSessions ??

listActiveProcessSessionReferences({

scopeKey: processScopeKey,

});

return {

sessionKey: params.sessionKey ?? undefined,

messageChannel: params.messageChannel ?? undefined,

extraSystemPrompt: params.extraSystemPrompt,

sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,

ownerNumbers: params.ownerNumbers,

...(activeProcessSessions.length > 0 ? { activeProcessSessions } : {}),

};

}

vi.doMock("../../process/command-queue.js", () => ({

enqueueCommandInLane: vi.fn((_lane: string, task: () => unknown) => task()),

clearCommandLane: vi.fn(() => 0),

}));

vi.doMock("../../utils/message-channel.js", () => ({

vi.doMock("./lanes.js", () => ({

resolveSessionLane: vi.fn(() => "session-lane"),

resolveEmbeddedSessionLane: vi.fn(() => "session-lane"),

resolveGlobalLane: vi.fn(() => "global-lane"),

}));

markAuthProfileGood,

markAuthProfileUsed,

} from "../auth-profiles.js";

import { listActiveProcessSessionReferences } from "../bash-process-references.js";

import {

resolveSessionKeyForRequest,

resolveStoredSessionKeyForSessionId,

parseImageSizeError,

pickFallbackThinkingLevel,

} from "../pi-embedded-helpers.js";

import { resolveProcessToolScopeKey } from "../pi-tools.js";

import { resolveProviderIdForAuth } from "../provider-auth-aliases.js";

import { runAgentCleanupStep } from "../run-cleanup-timeout.js";

import { buildAgentRuntimeAuthPlan } from "../runtime-plan/auth.js";

extraSystemPrompt: params.extraSystemPrompt,

sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,

ownerNumbers: params.ownerNumbers,

activeProcessSessions: listActiveProcessSessionReferences({

scopeKey: resolveProcessToolScopeKey({

sessionKey: params.sandboxSessionKey?.trim() || params.sessionKey,

sessionId: activeSessionId,

agentId: sessionAgentId,

}),

}),

}),

...resolveContextEngineCapabilities({

config: params.config,

extraSystemPrompt: params.extraSystemPrompt,

sourceReplyDeliveryMode: params.sourceReplyDeliveryMode,

ownerNumbers: params.ownerNumbers,

activeProcessSessions: listActiveProcessSessionReferences({

scopeKey: resolveProcessToolScopeKey({

sessionKey: params.sandboxSessionKey?.trim() || params.sessionKey,

sessionId: activeSessionId,

agentId: sessionAgentId,

}),

}),

}),

...resolveContextEngineCapabilities({

config: params.config,

const musicGenerationTaskStatusMocks = vi.hoisted(() => ({

buildActiveMusicGenerationTaskPromptContextForSession: vi.fn(),

buildMusicGenerationTaskStatusDetails: vi.fn(() => ({})),

buildMusicGenerationTaskStatusText: vi.fn(() => "Music generation task status"),

findActiveMusicGenerationTaskForSession: vi.fn(),

MUSIC_GENERATION_TASK_KIND: "music_generation",

}));

const videoGenerationTaskStatusMocks = vi.hoisted(() => ({

buildActiveVideoGenerationTaskPromptContextForSession: vi.fn(),

buildVideoGenerationTaskStatusDetails: vi.fn(() => ({})),

buildVideoGenerationTaskStatusText: vi.fn(() => "Video generation task status"),

findActiveVideoGenerationTaskForSession: vi.fn(),

getVideoGenerationTaskProviderId: vi.fn(),

isActiveVideoGenerationTask: vi.fn(() => false),

VIDEO_GENERATION_TASK_KIND: "video_generation",

}));

const hostHookStateMocks = vi.hoisted(() => ({