@cjhyy/code-shell-core 0.9.6 → 0.9.7

package/dist/engine/engine.js

@@ -20,6 +20,8 @@ import { loadPluginHooks } from "../plugins/loadPluginHooks.js";
 import { pluginAgentDirs } from "../plugins/installer/loadPluginAgents.js";
 import { runShellHook, shellHookMatches } from "../hooks/shell-runner.js";
 import { ContextManager } from "../context/manager.js";
+import { SessionContextNotes } from "../context/notes.js";
+import { loadSection } from "../prompt/section-loader.js";
 import { CONTEXT_PACKAGE_MAX_OUTPUT_TOKENS, buildAnchoredSummaryMessage, buildContextPackagePromptFromSerialized, estimateTokens, groupMessagesByApiRound, serializeContextPackageMessages, clampContextRatios as clampContextRatiosImpl, } from "../context/compaction.js";
 import { PromptComposer } from "../prompt/composer.js";
 import { SessionManager, isEphemeralSessionState, sessionsRoot, } from "../session/session-manager.js";
@@ -699,6 +701,9 @@ export class Engine {
     setBrowserBridge(bridge) {
         this.config.browserBridge = bridge;
     }
+    setChildHostBindings(factory) {
+        this.config.createChildHostBindings = factory;
+    }
     /** Inject the host-backed workspace bridge after construction. */
     setWorkspaceBridge(bridge) {
         this.config.workspaceBridge = bridge;
@@ -994,6 +999,12 @@ export class Engine {
         }
         return sessionProfile ?? explicitProfile;
     }
+    resolveContextStrategy(profile) {
+        return (this.config.contextStrategy ??
+            this.getSettingsManager().get().context?.strategy ??
+            profile?.contextStrategy ??
+            "summary");
+    }
     async runExclusive(task, options) {
         // Freeze permission context once, before the first await. Per-turn protocol
         // overrides live only for this run; persistent setPermissionMode/setPlanMode
@@ -1125,6 +1136,9 @@ export class Engine {
         const { messages: openedMessages, freshImageMessage, resumedFromDisk, claimClientMessageId, releaseClientMessageId, } = openedResult.opened;
         const session = openedResult.opened.session;
         let messages = openedMessages;
+        toolCtx.contextStrategy = this.resolveContextStrategy(profile);
+        const contextNotes = toolCtx.contextStrategy === "notes" ? new SessionContextNotes(session.transcript) : undefined;
+        toolCtx.contextNotes = contextNotes;
         // A host-owned time/topic boundary must be applied only after the current
         // user message exists in the transcript (it is the exclusive end anchor),
         // yet before this turn assembles prompts or calls the model. Doing this as
@@ -1145,12 +1159,21 @@ export class Engine {
                         : {}),
                 };
                 const before = estimateTokens(messages);
+                let archiveStrategy = "range";
                 if (options.archiveBeforeCurrentTurn.summary) {
                     await this.appendArchiveMarker(session.state.sessionId, {
                         ...anchors,
                         summary: options.archiveBeforeCurrentTurn.summary,
                     });
                 }
+                else if (!freshImageMessage &&
+                    contextNotes &&
+                    this.tryNotesRollover(contextNotes, messages)) {
+                    // The note covers its own cursor; any newer messages remain verbatim.
+                    this.compactedMessagesBySession.delete(session.state.sessionId);
+                    session.state.contextUsageAnchor = undefined;
+                    archiveStrategy = "notes";
+                }
                 else {
                     await this.archiveTurnRange(session.state.sessionId, { start: 0, end: 0 }, anchors);
                 }
@@ -1164,7 +1187,7 @@ export class Engine {
                 if (archived.before > archived.after) {
                     options.onStream?.({
                         type: "context_compact",
-                        strategy: "range",
+                        strategy: archiveStrategy,
                         before: archived.before,
                         after: archived.after,
                     });
@@ -1219,7 +1242,7 @@ export class Engine {
                 sessionProfileOverrides,
                 runPlanMode,
             });
-            const { llmClient, fullSystemPrompt, dynamicContextMsg, userContextMsg } = await this.assembleRunPrompts({
+            const { llmClient, fullSystemPrompt, dynamicContextMsg, userContextMsg, retainedContextMessages, } = await this.assembleRunPrompts({
                 session,
                 messages,
                 hookMessages,
@@ -1269,6 +1292,7 @@ export class Engine {
                 releaseClientMessageId,
                 freshImageMessage,
                 dynamicContextMsg,
+                retainedContextMessages,
             });
             let result;
             let firstGoalTermination;
@@ -1524,17 +1548,21 @@ export class Engine {
             promptComposer.buildDynamicContextMessage(),
         ]);
         const fullSystemPrompt = composeRunSystemPrompt({
-            baseSystemPrompt,
+            baseSystemPrompt: toolDefs.some((tool) => tool.name === "SaveContextNote")
+                ? `${baseSystemPrompt}\n\n${loadSection("context-notes")}`
+                : baseSystemPrompt,
             profile,
             profileParams,
         });
         const userContextMsg = promptComposer.buildUserContextMessage();
+        const priorMessages = new Set(messages);
         assembleRunMessages({
             messages,
             userContextMsg,
             hookMessages,
             dynamicContextMsg,
         });
+        const retainedContextMessages = messages.filter((message) => !priorMessages.has(message) && message !== dynamicContextMsg);
         this.lastSessionId = session.state.sessionId;
         this.lastMessages = messages;
         // Wire up LLM summarization for context compaction
@@ -1550,7 +1578,13 @@ export class Engine {
         contextManager.initReplacementStateFromMessages(messages);
         // Two summarizers with DIFFERENT quality needs (see the run loop wiring for
         // the aux-model summarizer set up alongside the ModelFacade).
-        return { llmClient, fullSystemPrompt, dynamicContextMsg, userContextMsg };
+        return {
+            llmClient,
+            fullSystemPrompt,
+            dynamicContextMsg,
+            userContextMsg,
+            retainedContextMessages,
+        };
     }
     /**
      * Seed the run's {@link ContextManager}, emit the early `session_started`
@@ -1651,6 +1685,7 @@ export class Engine {
         // built-ins and product capabilities.
         const subAgentSpawner = createSubAgentSpawner({
             parentConfig: this.config,
+            getParentSessionId: () => getSession().state.sessionId,
             parentSandbox: sandboxConfig,
             presetName: this.preset.name,
             cwd,
@@ -1667,7 +1702,12 @@ export class Engine {
                 createChild: (config) => new Engine(config),
                 runChild: async (config, childTask, childOptions) => {
                     const child = new Engine(config);
-                    return child.run(childTask, childOptions);
+                    try {
+                        return await child.run(childTask, childOptions);
+                    }
+                    finally {
+                        await child.dispose();
+                    }
                 },
             },
         });
@@ -1723,7 +1763,7 @@ export class Engine {
      * phases consume cross back out.
      */
     async wireRunLoop(args) {
-        const { session, sid, task, cwd, options, profileMaxTurns, toolCtx, toolExecutor, contextManager, llmClient, auxSummaryClient, fullSystemPrompt, toolDefs, claimClientMessageId, releaseClientMessageId, freshImageMessage, dynamicContextMsg, } = args;
+        const { session, sid, task, cwd, options, profileMaxTurns, toolCtx, toolExecutor, contextManager, llmClient, auxSummaryClient, fullSystemPrompt, toolDefs, claimClientMessageId, releaseClientMessageId, freshImageMessage, dynamicContextMsg, retainedContextMessages, } = args;
         // eslint-disable-next-line prefer-const
         let turnLoop;
         const accounting = createRunUsageAccounting({
@@ -1846,6 +1886,7 @@ export class Engine {
             normalizedGoal,
             freshImageMessage,
             dynamicContextMsg,
+            retainedContextMessages,
             usageBaseline,
             getRunUsage,
             recordCumulativeUsage,
@@ -2031,6 +2072,7 @@ export class Engine {
         const mcpServers = this.config.mcpServers ?? {};
         const mcpDisabled = profile?.disableMcp === true;
         await connectRunMcp({
+            toolContext: toolCtx,
             mcpServers,
             mcpDisabled,
             getManager: () => this.mcpManager,
@@ -2094,13 +2136,17 @@ export class Engine {
      * published through the `publishGoalJudgeContext` callback.
      */
     buildTurnLoop(args) {
-        const { modelFacade, toolExecutor, contextManager, session, fullSystemPrompt, toolDefs, sid, options, profileMaxTurns, cwd, claimClientMessageId, releaseClientMessageId, toolCtx, persistedRunGoal, goalHookHandler, normalizedGoal, freshImageMessage, dynamicContextMsg, usageBaseline, getRunUsage, recordCumulativeUsage, publishGoalJudgeContext, } = args;
+        const { modelFacade, toolExecutor, contextManager, session, fullSystemPrompt, toolDefs, sid, options, profileMaxTurns, cwd, claimClientMessageId, releaseClientMessageId, toolCtx, persistedRunGoal, goalHookHandler, normalizedGoal, freshImageMessage, dynamicContextMsg, retainedContextMessages, usageBaseline, getRunUsage, recordCumulativeUsage, publishGoalJudgeContext, } = args;
         // Surface compaction events to the UI so the user knows when context was trimmed.
         // Buffer the most recent event so TurnLoop can drain it and emit the
         // post_compact hook on the next turn (ContextManager itself doesn't
         // know about HookRegistry — the buffer is the seam).
         let pendingCompactInfo = null;
         contextManager.setOnCompact((info) => {
+            if (info.strategy === "notes") {
+                session.state.contextUsageAnchor = undefined;
+                this.compactedMessagesBySession.delete(sid);
+            }
             pendingCompactInfo = info;
             options?.onStream?.({ type: "context_compact", ...info });
         });
@@ -2109,6 +2155,7 @@ export class Engine {
             model: modelFacade,
             toolExecutor,
             contextManager,
+            contextNotes: toolCtx.contextNotes instanceof SessionContextNotes ? toolCtx.contextNotes : undefined,
             hooks: this.hooks,
             transcript: session.transcript,
             systemPrompt: fullSystemPrompt,
@@ -2228,6 +2275,7 @@ export class Engine {
             signal: options?.signal,
             freshImageMessages: freshImageMessage ? [freshImageMessage] : undefined,
             volatileContextMessages: dynamicContextMsg ? [dynamicContextMsg] : undefined,
+            retainedContextMessages,
             // Goal mode: the active goal is surfaced to the on_stop handler via
             // ctx.data.goal; the GoalStopHook (registered above) judges it.
             goal: normalizedGoal,
@@ -2849,10 +2897,17 @@ export class Engine {
             cached.push({ role: "assistant", content });
         }
     }
-    /**
-     * Force context compaction on a session.
-     * Returns token stats before/after.
-     */
+    /** Attempt the durable note path without issuing a separate model request. */
+    tryNotesRollover(notes, messages) {
+        try {
+            notes.requestRollover();
+            return notes.applyRollover(messages);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Force context compaction and return token stats before/after. */
     async forceCompact(sessionId) {
         const effectiveSessionId = sessionId ?? this.lastSessionId;
         if (!effectiveSessionId) {
@@ -2861,6 +2916,19 @@ export class Engine {
         const session = this.sessionManager.resume(effectiveSessionId);
         const sourceMessages = this.compactedMessagesBySession.get(effectiveSessionId) ?? session.transcript.toMessages();
         const before = estimateTokens(sourceMessages);
+        const profile = [...this.behaviorProfiles.values()].find((candidate) => candidate.activateForSessionKinds?.includes(session.state.kind ?? "work"));
+        if (this.resolveContextStrategy(profile) === "notes") {
+            const compacted = this.tryNotesRollover(new SessionContextNotes(session.transcript), sourceMessages);
+            if (compacted) {
+                this.compactedMessagesBySession.set(effectiveSessionId, compacted);
+                session.state.contextUsageAnchor = undefined;
+                this.lastContextManager = undefined;
+                this.persistRunProgress(session.state);
+                this.lastSessionId = effectiveSessionId;
+                this.lastMessages = compacted;
+                return { before, after: estimateTokens(compacted), strategy: "notes" };
+            }
+        }
         const contextManager = await this.prepareContextManagerForSession(effectiveSessionId, session, sourceMessages, "force_compact");
         // Manual /compact emits its UI boundary at the protocol layer from the
         // final before/after result. Capture the tier here, but avoid reusing a

package/dist/engine/run-tooling.d.ts

@@ -64,6 +64,7 @@ export declare function connectRunMcp(args: {
     runtimePool: MCPManager | undefined;
     toolRegistry: ToolRegistry;
     engineForConnect: Parameters<MCPManager["connectAll"]>[1];
+    toolContext?: Parameters<MCPManager["connectAll"]>[3];
     emitNotificationHook: (payload: Record<string, unknown>) => void;
 }): Promise<void>;
 /**
@@ -74,12 +75,14 @@ export declare function connectRunMcp(args: {
  */
 export interface ToolVisibilityInputs {
     cwd: string;
+    contextStrategy?: "summary" | "notes";
     workspace?: ToolContext["workspace"];
     hasGoal: boolean;
     sessionId?: string;
     settingsScope?: SettingsScope;
     /** Host identity a guard may require, e.g. Panel needs `"desktop"`. */
     host?: string;
+    hasBrowserAutomation?: boolean;
     isSubAgent?: boolean;
     behaviorProfile?: string;
     sessionMessageTargets?: readonly import("../session/session-message.js").SessionMessageTarget[];

package/dist/engine/run-tooling.js

@@ -126,30 +126,26 @@ export function buildRunPermissionPipeline(args) {
 }
 /** engine.ts L1986-2003 —— MCP 连接(Runtime 池优先,回退 per-Engine)。 */
 export async function connectRunMcp(args) {
-    // Connect MCP servers (if configured and not already connected).
-    // B1: prefer the Runtime-owned MCPManager so all sessions in a
-    // worker share one set of connections. Falling back to a
-    // per-Engine instance keeps the null-runtime path (tests, ad-hoc
-    // scripts) working.
-    const mcpServers = args.mcpServers;
-    const mcpDisabled = args.mcpDisabled;
-    if (!mcpDisabled && Object.keys(mcpServers).length > 0 && !args.getManager()) {
-        if (args.runtimePool) {
-            args.setManager(args.runtimePool);
-        }
-        else {
-            args.setManager(new MCPManager(args.toolRegistry));
-        }
-        await args.getManager().connectAll(mcpServers, args.engineForConnect, (event) => {
-            // Fire-and-forget onto the notification hook: hosts/plugins learn
-            // about MCP availability changes without polling the pool.
-            args.emitNotificationHook({
-                kind: event.type,
-                server: event.server,
-                ...(event.error ? { error: event.error } : {}),
-            });
-        });
+    // A pool may outlive a run and the engine registry may predate discovery.
+    // Refresh scope and the engine's MCP-only view on every run (including cwd
+    // and project changes); identical scopes still share a single transport.
+    const enabledServers = args.mcpDisabled ? {} : args.mcpServers;
+    if (!args.getManager() && Object.keys(enabledServers).length > 0) {
+        args.setManager(args.runtimePool ?? new MCPManager(args.toolRegistry));
     }
+    const manager = args.getManager();
+    if (!manager)
+        return;
+    await manager.connectAll(enabledServers, args.engineForConnect, (event) => {
+        args.emitNotificationHook({
+            kind: event.type,
+            server: event.server,
+            ...(event.error ? { error: event.error } : {}),
+        });
+    }, args.toolContext);
+    manager.syncToolsToRegistry(args.toolRegistry, args.toolContext, new Set(Object.entries(enabledServers)
+        .filter(([, config]) => config.enabled !== false)
+        .map(([name]) => name)));
 }
 /**
  * Build the availability-guard context for a tool surface.
@@ -167,11 +163,15 @@ export async function connectRunMcp(args) {
 export function buildToolVisibility(inputs) {
     return {
         cwd: inputs.cwd,
+        ...(inputs.contextStrategy ? { contextStrategy: inputs.contextStrategy } : {}),
         ...(inputs.workspace ? { workspace: inputs.workspace } : {}),
         hasGoal: inputs.hasGoal,
         ...(inputs.sessionId ? { sessionId: inputs.sessionId } : {}),
         ...(inputs.settingsScope ? { settingsScope: inputs.settingsScope } : {}),
         ...(inputs.host !== undefined ? { host: inputs.host } : {}),
+        ...(inputs.hasBrowserAutomation !== undefined
+            ? { hasBrowserAutomation: inputs.hasBrowserAutomation }
+            : {}),
         ...(inputs.isSubAgent !== undefined ? { isSubAgent: inputs.isSubAgent } : {}),
         ...(inputs.behaviorProfile !== undefined ? { behaviorProfile: inputs.behaviorProfile } : {}),
         ...(inputs.sessionMessageTargets?.length
@@ -188,11 +188,13 @@ export function assembleRunToolDefs(args) {
     const guardCwd = args.guardCwd;
     const toolVisibility = buildToolVisibility({
         cwd: guardCwd,
+        contextStrategy: toolCtx.contextNotes ? toolCtx.contextStrategy : undefined,
         workspace: toolCtx.workspace,
         hasGoal: args.hasRunnableGoal,
         sessionId: toolCtx.sessionId,
         settingsScope: args.settingsScope,
         host: args.builtinToolHost,
+        hasBrowserAutomation: toolCtx.browser !== undefined,
         isSubAgent: args.isSubAgent,
         behaviorProfile: args.behaviorProfileId,
         sessionMessageTargets: toolCtx.sessionMessages?.targets,

package/dist/engine/run-types.d.ts

@@ -22,6 +22,8 @@ export type RunBehaviorMode = string;
  */
 export interface RunBehaviorProfile {
     id: string;
+    /** Default context policy; explicit Engine/settings choices take precedence. */
+    contextStrategy?: "summary" | "notes";
     /** Appended to the system prompt after config.appendSystemPrompt. */
     systemPromptAppend?: string;
     /** Hard tool allowlist for the run (model visibility + execution gate). */
@@ -186,6 +188,8 @@ export type AgentRuntimeProgressEvent = {
     usage: TokenUsage;
 };
 export interface ChildEngineRuntime {
+    /** Release child-local resources after the entire supervised lifetime settles. */
+    dispose?(): void | Promise<void>;
     run(task: string, options?: EngineRunOptions): Promise<EngineResult>;
     setAgentControlStateListener(listener: ((state: LiveChildState) => void) | undefined): void;
     setAgentDirectionsDeliveredListener?(listener: ((envelopeIds: string[]) => void) | undefined): void;

package/dist/engine/subagent-spawner.d.ts

@@ -17,6 +17,9 @@ export declare function resolveChildMcpServers(allowlist: string[] | undefined,
 export declare function wrapChildStream(destination: StreamCallback | undefined, agentId: string): StreamCallback | undefined;
 export interface CreateSubAgentSpawnerDeps {
     parentConfig: EngineConfig;
+    parentSessionId?: string;
+    /** Tool context is assembled before the run session is initialized. */
+    getParentSessionId?: () => string;
     /** Fully resolved sandbox for this parent run, including settings layers. */
     parentSandbox: SandboxConfig;
     presetName: AgentPresetName;

package/dist/engine/subagent-spawner.js

@@ -252,7 +252,11 @@ export function createSubAgentSpawner(deps) {
                 maxContextTokens: deps.parentConfig.maxContextTokens ?? 200_000,
                 sessionStorageDir: deps.parentConfig.sessionStorageDir,
                 headless: deps.parentConfig.headless,
-                readOnlySession: request.readOnlySession,
+                readOnlySession: deps.parentConfig.readOnlySession || request.readOnlySession,
+                projectTrusted: deps.parentConfig.projectTrusted,
+                allowBackgroundShells: deps.parentConfig.allowBackgroundShells,
+                approvalBackend: deps.parentConfig.approvalBackend,
+                approvalRouter: deps.parentConfig.approvalRouter,
                 skillAllowlist: request.skillAllowlist,
                 sandbox: resolveChildSandbox(request.sandboxMode, deps.parentSandbox),
                 mcpServers: resolveChildMcpServers(request.mcpAllowlist, deps.parentConfig.mcpServers),
@@ -261,28 +265,55 @@ export function createSubAgentSpawner(deps) {
             };
             const destination = request.streamOverride ?? deps.parentStream;
             const childSessionId = request.resumeSessionId ?? request.agentId;
-            if (deps.childRunner.createChild && request.runtimeGeneration !== undefined) {
-                const runtime = deps.childRunner.createChild(childConfig);
-                const supervisor = new ChildRunSupervisor(runtime, childSessionId, request.runtimeGeneration);
-                const ownerToken = nanoid();
-                const bound = request.bindLiveControl?.(supervisor, ownerToken);
-                supervisor.setCloseIntake(() => request.closeLiveControl?.(supervisor, bound && bound !== true ? bound : undefined));
-                if (bound === false) {
-                    throw new Error(`child session ${childSessionId} already has a live transcript writer`);
+            const parentSessionId = deps.getParentSessionId?.() ?? deps.parentSessionId;
+            const host = parentSessionId
+                ? deps.parentConfig.createChildHostBindings?.({
+                    parentSessionId,
+                    sessionId: childSessionId,
+                    signal: request.signal,
+                })
+                : undefined;
+            if (host) {
+                childConfig.browserBridge = host.browserBridge;
+                childConfig.askUser = host.askUser;
+                childConfig.injectCredentialToBrowser = host.injectCredentialToBrowser;
+                childConfig.approvalBackend = host.approvalBackend ?? childConfig.approvalBackend;
+            }
+            let runtime;
+            try {
+                if (deps.childRunner.createChild && request.runtimeGeneration !== undefined) {
+                    runtime = deps.childRunner.createChild(childConfig);
+                    const supervisor = new ChildRunSupervisor(runtime, childSessionId, request.runtimeGeneration);
+                    const ownerToken = nanoid();
+                    const bound = request.bindLiveControl?.(supervisor, ownerToken);
+                    supervisor.setCloseIntake(() => request.closeLiveControl?.(supervisor, bound && bound !== true ? bound : undefined));
+                    if (bound === false) {
+                        throw new Error(`child session ${childSessionId} already has a live transcript writer`);
+                    }
+                    host?.activate?.();
+                    return await supervisor.run(request.prompt, {
+                        signal: request.signal,
+                        onStream: wrapChildRuntimeStream(destination, request.agentId, request.onProgressEvent),
+                        sessionId: childSessionId,
+                        onAgentProgress: request.onAgentProgress,
+                    });
                 }
-                return await supervisor.run(request.prompt, {
+                host?.activate?.();
+                const result = await deps.childRunner.runChild(childConfig, request.prompt, {
                     signal: request.signal,
                     onStream: wrapChildRuntimeStream(destination, request.agentId, request.onProgressEvent),
                     sessionId: childSessionId,
-                    onAgentProgress: request.onAgentProgress,
                 });
+                return result;
+            }
+            finally {
+                try {
+                    host?.dispose();
+                }
+                finally {
+                    await runtime?.dispose?.();
+                }
             }
-            const result = await deps.childRunner.runChild(childConfig, request.prompt, {
-                signal: request.signal,
-                onStream: wrapChildRuntimeStream(destination, request.agentId, request.onProgressEvent),
-                sessionId: childSessionId,
-            });
-            return result;
         },
     };
 }

package/dist/engine/turn-loop.d.ts

@@ -11,6 +11,7 @@ import type { LiveChildState } from "../tool-system/builtin/agent-registry.js";
 import { ModelFacade } from "./model-facade.js";
 import { ToolExecutor } from "../tool-system/executor.js";
 import { ContextManager } from "../context/manager.js";
+import type { SessionContextNotes } from "../context/notes.js";
 import { HookRegistry } from "../hooks/registry.js";
 import type { GoalJudgeRuntimeContext } from "../hooks/goal-stop-hook.js";
 import type { PromptCacheDiagnosticSample } from "./prompt-cache-diagnostics.js";
@@ -34,6 +35,8 @@ export interface TurnLoopConfig {
      * summarized into durable history. Engine uses this for dynamicContext.
      */
     volatileContextMessages?: Iterable<Message>;
+    /** Current instructions and lifecycle hooks, reattached after a notes transition. */
+    retainedContextMessages?: Iterable<Message>;
     /**
      * Fired after each turn boundary is recorded. Lets the engine flush an
      * up-to-date snapshot to state.json mid-run, so a long run doesn't leave
@@ -66,6 +69,7 @@ export interface TurnLoopDeps {
     model: ModelFacade;
     toolExecutor: ToolExecutor;
     contextManager: ContextManager;
+    contextNotes?: SessionContextNotes;
     hooks: HookRegistry;
     transcript: Transcript;
     systemPrompt: string;
@@ -295,6 +299,12 @@ export declare class TurnLoop {
      * to the tail when that boundary was rewritten or compaction changed length.
      */
     private restoreVolatileAfterContextManagement;
+    private noteReminderIssued;
+    private readonly retainedHookMessages;
+    private readonly pendingContextReminders;
+    private appendContextReminder;
+    /** Called only before a model step or after every result in a tool batch is recorded. */
+    private applyNotesRollover;
     private manageContextMessages;
     private manageContextMessagesSync;
     private markPendingImagesConsumed;