clearCodeModeNamespacesForPlugin(pluginId);

```

Use `unregisterCodeModeNamespace(namespaceId)` only when removing one known

namespace. Tests can call `clearCodeModeNamespacesForTest()` to avoid leaking

registrations across cases.

Code-mode cleanup is plugin-owned; clear the plugin's namespace registrations

when its lifecycle ends instead of keeping per-namespace teardown handles. Tests

can call `clearCodeModeNamespacesForTest()` to avoid leaking registrations

across cases.

### Test checklist

} from "../infra/exec-approvals.js";

import { requestHeartbeat } from "../infra/heartbeat-wake.js";

import {

isDangerousHostInheritedEnvVarName,

sanitizeHostInheritedEnvEntry,

} from "../infra/host-env-security.js";

import { findPathKey, mergePathPrepend, removePathPrepend } from "../infra/path-prepend.js";

}

return sanitized;

}

/** Validates caller-provided host env, rejecting dangerous vars and PATH overrides. */

export function validateHostEnv(env: Record<string, string>): void {

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

const upperKey = key.toUpperCase();

// 1. Block known dangerous variables (Fail Closed)

if (isDangerousHostInheritedEnvVarName(upperKey)) {

throw new Error(

`Security Violation: Environment variable '${key}' is forbidden during host execution.`,

);

}

// 2. Strictly block PATH modification on host

// Allowing custom PATH on the gateway/node can lead to binary hijacking.

if (upperKey === "PATH") {

throw new Error(

"Security Violation: Custom 'PATH' variable is forbidden during host execution.",

);

}

}

}

/** Default retained aggregate output cap for exec sessions. */

export const DEFAULT_MAX_OUTPUT = clampWithDefault(

readEnvInt("OPENCLAW_BASH_MAX_OUTPUT_CHARS", "PI_BASH_MAX_OUTPUT_CHARS"),

senderIsOwner: params.senderIsOwner,

};

}

/** Runs the legacy Claude CLI wrapper through the generic CLI runner. */

export async function runClaudeCliAgent(

params: RunClaudeCliAgentParams,

): Promise<EmbeddedAgentRunResult> {

return runCliAgent(buildRunClaudeCliAgentParams(params));

}

registryState.registrations.set(normalized.id, normalized);

}

/** Removes one namespace registration by id. */

export function unregisterCodeModeNamespace(namespaceId: string): boolean {

return registryState.registrations.delete(namespaceId.trim());

}

/** Lists registered namespaces in deterministic id order. */

export function listCodeModeNamespaces(): RegisteredCodeModeNamespace[] {

return [...registryState.registrations.values()].toSorted((a, b) => a.id.localeCompare(b.id));

"Preserve all opaque identifiers exactly as written (no shortening or reconstruction), " +

"including UUIDs, hashes, IDs, hostnames, IPs, ports, URLs, and file names.";

const HANDOFF_INSTRUCTIONS = [

"Generate a concise recovery briefing for a new LLM taking over this session.",

"The previous model hit a quota limit and you are providing the context for a smooth handoff.",

"",

"LEADER HIERARCHY REINFORCEMENT:",

"- Explicitly state that the new model is the LEADER (Orchestrator).",

"- Identify any active autonomous units (like AutoClaw) as SUBORDINATES.",

"- Instruct the new model to NOT perform the subordinate's task, but to supervise and provide strategic commands.",

"",

"MUST CAPTURE:",

"- Current high-level goal and project path.",

"- Status of the latest tool executions (especially AutoClaw/Subagents).",

"- Critical files currently being modified.",

"- Pending items and next intended steps.",

].join("\n");

/** Optional instruction policy for preserving identifiers during compaction. */

export type CompactionSummarizationInstructions = {

identifierPolicy?: AgentCompactionIdentifierPolicy;

});

}

/**

* Generates a concise handoff summary for model transitions, enforcing a 4000 token limit.

*/

export async function summarizeForHandoff(params: {

messages: AgentMessage[];

model: NonNullable<ExtensionContext["model"]>;

apiKey: string;

headers?: Record<string, string>;

signal: AbortSignal;

maxChunkTokens: number;

contextWindow: number;

customInstructions?: string;

summarizationInstructions?: CompactionSummarizationInstructions;

}): Promise<string> {

const custom = params.customInstructions?.trim();

const handoffInstructions = custom

? `${HANDOFF_INSTRUCTIONS}\n\n${custom}`

: HANDOFF_INSTRUCTIONS;

// Use a hard cap of 4000 tokens for the handoff summary as per plan

const handoffMaxTokens = 4000;

return summarizeWithFallback({

...params,

reserveTokens: SUMMARIZATION_OVERHEAD_TOKENS,

maxChunkTokens: Math.min(params.maxChunkTokens, handoffMaxTokens),

customInstructions: handoffInstructions,

});

}

/** Resolves a positive context-window token count from model metadata. */

export function resolveContextWindowTokens(model?: ExtensionContext["model"]): number {

const effective =

/**

* Google/Gemini-specific embedded-agent runtime helpers.

*/

import { isGemma4ModelId } from "../../shared/google-models.js";

import { sanitizeGoogleTurnOrdering } from "./bootstrap.js";

/** Detects Google-owned embedded runtime APIs. */

export function isGoogleModelApi(api?: string | null): boolean {

return api === "google-gemini-cli" || api === "google-generative-ai";

}

/** Returns true for Gemma models whose reasoning payload must be stripped. */

export function isGemma4ModelRequiringReasoningStrip(modelId?: string | null): boolean {

return isGemma4ModelId(modelId);

}

// Re-exported from the helper barrel so Google-specific callers do not import

// bootstrap internals directly.

export { sanitizeGoogleTurnOrdering };

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

abortEmbeddedAgentRunMock: vi.fn(),

requestEmbeddedRunModelSwitchMock: vi.fn(),

consumeEmbeddedRunModelSwitchMock: vi.fn(),

resolveDefaultModelForAgentMock: vi.fn(),

resolvePersistedSelectedModelRefMock: vi.fn(),

loadSessionStoreMock: vi.fn(),

abortEmbeddedAgentRun: (...args: unknown[]) => state.abortEmbeddedAgentRunMock(...args),

requestEmbeddedRunModelSwitch: (...args: unknown[]) =>

state.requestEmbeddedRunModelSwitchMock(...args),

consumeEmbeddedRunModelSwitch: (...args: unknown[]) =>

state.consumeEmbeddedRunModelSwitchMock(...args),

}));

vi.mock("./model-selection.js", async () => {

beforeEach(() => {

state.abortEmbeddedAgentRunMock.mockReset().mockReturnValue(false);

state.requestEmbeddedRunModelSwitchMock.mockReset();

state.consumeEmbeddedRunModelSwitchMock.mockReset();

state.embeddedAgentModuleImported = false;

state.resolveDefaultModelForAgentMock

.mockReset()

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

import {

abortEmbeddedAgentRun,

consumeEmbeddedRunModelSwitch,

requestEmbeddedRunModelSwitch,

type EmbeddedRunModelSwitchRequest,

} from "./embedded-agent-runner/runs.js";

return true;

}

export function consumeLiveSessionModelSwitch(

sessionId: string,

): LiveSessionModelSelection | undefined {

return consumeEmbeddedRunModelSwitch(sessionId);

}

function isAlreadyAppliedOpenAICodexRuntimePromotion(

current: { provider: string; model: string },

next: LiveSessionModelSelection,