@cjhyy/code-shell-core 0.9.5 → 0.9.7

package/dist/credentials/store.js

@@ -1,7 +1,7 @@
 import { closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
-import { credentialAllowsEnvExposure, credentialSecretHint, } from "./types.js";
+import { credentialAllowsEnvExposure, credentialSecretHint, isCredentialSecretAvailable, } from "./types.js";
 import { getDefaultCredentialCipher } from "./cipher.js";
 import { logger } from "../logging/logger.js";
 import { summarizeOAuthCredentialSecret } from "./oauth.js";
@@ -329,6 +329,34 @@ export class CredentialStore {
             return true;
         });
     }
+    /**
+     * Update an existing record while holding the store lock. The callback sees
+     * the latest decrypted record and may return undefined to decline the write.
+     * Unlike save(), this never recreates a deleted credential.
+     */
+    updateExisting(scope, id, update) {
+        if (typeof id !== "string" || !id || id.length > MAX_CREDENTIAL_ID_CHARS || id.includes("\0")) {
+            throw new Error("invalid credential id");
+        }
+        let changed = false;
+        this.mutate(scope, (file) => {
+            const idx = file.credentials.findIndex((credential) => credential.id === id);
+            if (idx < 0)
+                return false;
+            const next = update(normalizeCredential(file.credentials[idx], true));
+            if (!next)
+                return false;
+            const normalized = normalizeCredential(next, true);
+            if (normalized.id !== id)
+                throw new Error("credential update cannot change id");
+            file.credentials[idx] = credentialAllowsEnvExposure(normalized.type)
+                ? normalized
+                : { ...normalized, exposeAsEnv: undefined };
+            changed = true;
+            return true;
+        });
+        return changed;
+    }
     remove(scope, id) {
         if (typeof id !== "string" || !id || id.length > MAX_CREDENTIAL_ID_CHARS || id.includes("\0")) {
             throw new Error("invalid credential id");
@@ -350,14 +378,20 @@ export class CredentialStore {
      *     same host-isolation contract as {@link envExposures} and top-level env.
      */
     list(scope = "full") {
+        return this.listWithStatus(scope).credentials;
+    }
+    /** Preserve read failures so diagnostics can distinguish unknown state from an empty store. */
+    listWithStatus(scope = "full") {
         const byId = new Map();
-        if (scope === "full") {
-            for (const c of this.read("user").credentials)
-                byId.set(c.id, c);
+        let readable = true;
+        const scopes = scope === "full" ? ["user", "project"] : ["project"];
+        for (const layer of scopes) {
+            const result = this.readGuarded(layer);
+            readable = readable && result.readable;
+            for (const credential of result.file.credentials)
+                byId.set(credential.id, credential);
         }
-        for (const c of this.read("project").credentials)
-            byId.set(c.id, c); // project wins
-        return [...byId.values()];
+        return { credentials: [...byId.values()], readable };
     }
     resolve(id, scope = "full") {
         return this.list(scope).find((c) => c.id === id);
@@ -397,11 +431,12 @@ export class CredentialStore {
     listMasked(scope = "full") {
         return this.list(scope).map((c) => {
             const { secret, ...rest } = c;
+            const available = isCredentialSecretAvailable(secret);
             return {
                 ...rest,
                 ...(credentialAllowsEnvExposure(c.type) ? {} : { exposeAsEnv: undefined }),
-                hasSecret: typeof secret === "string" && secret.length > 0,
-                secretHint: credentialSecretHint(c.type, secret),
+                hasSecret: available,
+                secretHint: available ? credentialSecretHint(c.type, secret) : undefined,
                 ...(c.type === "oauth" || isBrowserOAuthLinkCredential(c)
                     ? { oauthStatus: summarizeOAuthCredentialSecret(secret) }
                     : {}),

package/dist/credentials/types.d.ts

@@ -10,6 +10,8 @@ export type CredentialType = "token" | "link" | "cookie" | "oauth";
  * values and must remain behind the credential resolver boundary.
  */
 export declare function credentialAllowsEnvExposure(type: CredentialType): boolean;
+/** An unreadable encrypted value is preserved on disk, but is not a usable secret. */
+export declare function isCredentialSecretAvailable(secret: string | undefined): secret is string;
 /** Build a renderer-safe hint without deriving bytes from structured JSON. */
 export declare function credentialSecretHint(type: CredentialType, secret: string | undefined): string | undefined;
 export interface OAuthCredentialSecret {
@@ -112,6 +114,8 @@ export interface Credential {
         domain?: string;
         scope?: "domain" | "all";
         switchMode?: "clear" | "merge";
+        /** Opt in to writing browser-side cookie rotations back to this saved credential. */
+        autoRefreshFromBrowser?: boolean;
         /** Link provider id for credentials owned by a local/server app connection. */
         linkProvider?: string;
         /** Provider-specific connection method, e.g. fine-grained-pat or github-app. */

package/dist/credentials/types.js

@@ -6,6 +6,10 @@
 export function credentialAllowsEnvExposure(type) {
     return type === "token" || type === "link";
 }
+/** An unreadable encrypted value is preserved on disk, but is not a usable secret. */
+export function isCredentialSecretAvailable(secret) {
+    return typeof secret === "string" && secret.length > 0 && !secret.startsWith("enc:");
+}
 /** Build a renderer-safe hint without deriving bytes from structured JSON. */
 export function credentialSecretHint(type, secret) {
     if (!secret)

package/dist/credentials/use-credential-tool.js

@@ -23,7 +23,10 @@ const BASE_DESCRIPTION = "Use a stored credential (token / API key / login cooki
     "or manually exporting credentials. Before `--cookies-from-browser` or retrying an " +
     "authentication failure, check stored credentials here. If `Currently available` names a " +
     "matching id, fetch it directly; otherwise call with NO arguments first to list available " +
-    "credentials (id + label + type), then call again with `id`. Token/link credentials return their secret " +
+    "credentials (id + label + type), then call again with `id`. Provider-owned Link connections " +
+    "and existing CLI sessions are not listed here. Call LinkAction with provider only to check " +
+    "those before concluding " +
+    "a service is disconnected or asking the user to log in. Exposable token credentials return their secret " +
     "value; cookie credentials are materialized to a temporary Netscape cookies.txt file " +
     "(use it as `yt-dlp --cookies <cookiesFile>` / `curl -b <cookiesFile>`). " +
     "Each use is gated by a quick user approval unless auto-approve is on.";
@@ -125,7 +128,14 @@ export async function useCredentialTool(args, ctx) {
             .listMasked(cwd, scope)
             .filter(isAgentExposableCredential)
             .map((c) => ({ id: c.id, label: c.label, type: c.type }));
-        return json({ kind: "list", credentials });
+        return json({
+            kind: "list",
+            credentials,
+            notice: "This list excludes provider-owned Link credentials and CLI login sessions. " +
+                'Call LinkAction with provider only, for example LinkAction({provider: "github"}), ' +
+                "to check saved connections and current CLI authentication; " +
+                "an absent credential here does not mean the service is signed out.",
+        });
     }
     const cred = access.resolveMeta(cwd, id, scope);
     if (!cred) {

package/dist/engine/engine-workspace-authority.js

@@ -104,7 +104,8 @@ export function createAuthorizedSessionMessageService(options) {
     const targets = catalog.filter((target) => target.sessionId !== sourceSessionId);
     return {
         targets,
-        send: async ({ targetSessionId, message }) => {
+        send: async ({ targetSessionId, message, signal }) => {
+            signal?.throwIfAborted();
             const target = targets.find((candidate) => candidate.sessionId === targetSessionId);
             if (!target)
                 throw new Error("target Session is not in the host-authorized project list");
@@ -112,8 +113,14 @@ export function createAuthorizedSessionMessageService(options) {
                 throw new Error("message is required");
             if (message.length > 48_000)
                 throw new Error("message exceeds 48000 characters");
-            await router({ sourceSessionId, target, message, catalog });
-            return target;
+            const receipt = await router({
+                sourceSessionId,
+                target,
+                message,
+                catalog,
+                ...(signal ? { signal } : {}),
+            });
+            return receipt ? { ...target, receipt } : target;
         },
     };
 }

package/dist/engine/engine.d.ts

@@ -158,6 +158,8 @@ export declare class Engine {
      * running goal's turn/budget ceilings mid-run (TODO 3.1). Null when idle.
      */
     private activeTurnLoop;
+    /** Frozen behavior-profile ceiling for the live run's Goal controls. */
+    private activeProfileMaxTurns;
     /**
      * The goal-stop hook of the in-flight goal run, exposed so clearGoal() can
      * unregister it mid-run (the closure holds the now-cleared goal and would
@@ -279,6 +281,7 @@ export declare class Engine {
      * clear "no browser panel" error.
      */
     setBrowserBridge(bridge: import("../tool-system/browser-bridge.js").BrowserBridge | undefined): void;
+    setChildHostBindings(factory: EngineConfig["createChildHostBindings"]): void;
     /** Inject the host-backed workspace bridge after construction. */
     setWorkspaceBridge(bridge: import("../tool-system/workspace-bridge.js").WorkspaceBridge | undefined): void;
     /** Inject the host-backed panel discovery/focus bridge after construction. */
@@ -364,6 +367,7 @@ export declare class Engine {
      * permission-boundary bypass.
      */
     private resolveBehaviorProfile;
+    private resolveContextStrategy;
     private runExclusive;
     /** A receipt write failure must not turn an already finalized model result
      * into a second synthetic failure (or reject the Engine.run contract). */
@@ -459,6 +463,7 @@ export declare class Engine {
      * published through the `publishGoalJudgeContext` callback.
      */
     private buildTurnLoop;
+    private resolveRunMaxTurns;
     private buildSummarizeFn;
     private resolveAuxClient;
     private runMemoryPipeline;
@@ -611,10 +616,9 @@ export declare class Engine {
     migrateSessionMainRoot(sessionId: string, project: import("../types.js").SessionProjectBinding, mainRoot: string): SessionWorkspace;
     releaseSessionWorkspace(sessionId: string): SessionWorkspace | null;
     injectContext(sessionId: string, content: string): void;
-    /**
-     * Force context compaction on a session.
-     * Returns token stats before/after.
-     */
+    /** Attempt the durable note path without issuing a separate model request. */
+    private tryNotesRollover;
+    /** Force context compaction and return token stats before/after. */
     forceCompact(sessionId?: string): Promise<{
         before: number;
         after: number;

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";
@@ -232,6 +234,8 @@ export class Engine {
      * running goal's turn/budget ceilings mid-run (TODO 3.1). Null when idle.
      */
     activeTurnLoop = null;
+    /** Frozen behavior-profile ceiling for the live run's Goal controls. */
+    activeProfileMaxTurns;
     /**
      * The goal-stop hook of the in-flight goal run, exposed so clearGoal() can
      * unregister it mid-run (the closure holds the now-cleared goal and would
@@ -697,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;
@@ -992,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
@@ -1123,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
@@ -1143,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);
                 }
@@ -1162,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,
                     });
@@ -1217,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,
@@ -1251,6 +1276,11 @@ export class Engine {
                 task,
                 cwd,
                 options,
+                profileMaxTurns: typeof profile?.maxTurns === "number" &&
+                    Number.isSafeInteger(profile.maxTurns) &&
+                    profile.maxTurns > 0
+                    ? profile.maxTurns
+                    : undefined,
                 toolCtx,
                 toolExecutor,
                 contextManager,
@@ -1262,6 +1292,7 @@ export class Engine {
                 releaseClientMessageId,
                 freshImageMessage,
                 dynamicContextMsg,
+                retainedContextMessages,
             });
             let result;
             let firstGoalTermination;
@@ -1285,8 +1316,10 @@ export class Engine {
                     this.activeRuntimeGoal = null;
                     this.activePersistedRunGoal = null;
                 }
-                if (this.activeTurnLoop === turnLoop)
+                if (this.activeTurnLoop === turnLoop) {
                     this.activeTurnLoop = null;
+                    this.activeProfileMaxTurns = undefined;
+                }
                 if (this.activeRunSession === session)
                     this.activeRunSession = null;
                 // Run-scoped too: this handler is re-registered every run(), so it must be
@@ -1515,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
@@ -1541,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`
@@ -1642,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,
@@ -1658,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();
+                    }
                 },
             },
         });
@@ -1714,7 +1763,7 @@ export class Engine {
      * phases consume cross back out.
      */
     async wireRunLoop(args) {
-        const { session, sid, task, cwd, options, 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({
@@ -1827,6 +1876,7 @@ export class Engine {
             toolDefs,
             sid,
             options,
+            profileMaxTurns,
             cwd,
             claimClientMessageId,
             releaseClientMessageId,
@@ -1836,6 +1886,7 @@ export class Engine {
             normalizedGoal,
             freshImageMessage,
             dynamicContextMsg,
+            retainedContextMessages,
             usageBaseline,
             getRunUsage,
             recordCumulativeUsage,
@@ -1846,8 +1897,10 @@ export class Engine {
         toolCtx.recordBilledUsage = recordExternalBilledUsage;
         // Expose this run's loop for mid-run extension (TODO 3.1). Top-level only —
         // a sub-agent's loop is its own concern and isn't user-extendable.
-        if (this.config.isSubAgent !== true)
+        if (this.config.isSubAgent !== true) {
             this.activeTurnLoop = turnLoop;
+            this.activeProfileMaxTurns = profileMaxTurns;
+        }
         // Expose this run's session bundle so a mid-run clearGoal() wipes the goal
         // on the very instance this loop keeps saving (see field doc). Top-level
         // only — sub-agents don't carry user-clearable persistent goals.
@@ -2019,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,
@@ -2082,13 +2136,17 @@ export class Engine {
      * published through the `publishGoalJudgeContext` callback.
      */
     buildTurnLoop(args) {
-        const { modelFacade, toolExecutor, contextManager, session, fullSystemPrompt, toolDefs, sid, options, 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 });
         });
@@ -2097,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,
@@ -2146,6 +2205,9 @@ export class Engine {
             releaseClientMessageId,
             setOriginClientMessageId: (clientMessageId) => {
                 toolCtx.originClientMessageId = clientMessageId;
+                const profileId = toolCtx.toolVisibility?.behaviorProfile;
+                const profile = profileId ? this.behaviorProfiles.get(profileId) : undefined;
+                profile?.onUserInputChanged?.(toolCtx.runScopedServices ?? {});
             },
             recordCumulativeUsage,
             onAgentUsage: (usage) => options?.onAgentProgress?.({ type: "usage", usage }),
@@ -2199,7 +2261,7 @@ export class Engine {
             // getting re-blocked by the stop-hook until it's done, and the 100
             // interactive default would silently truncate a long objective. The
             // real backstops are the goal token/time budgets + maxStopBlocks.
-            maxTurns: resolveMaxTurns(this.config.maxTurns, normalizedGoal),
+            maxTurns: this.resolveRunMaxTurns(normalizedGoal, profileMaxTurns),
             // Consecutive stop-block cap: config override > goal.maxStopBlocks >
             // GOAL_DEFAULT_MAX_STOP_BLOCKS(25). The old hardcoded 8 was too tight
             // for complex goals that legitimately get re-blocked while advancing.
@@ -2213,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,
@@ -2253,6 +2316,10 @@ export class Engine {
         });
         return turnLoop;
     }
+    resolveRunMaxTurns(goal, profileMaxTurns) {
+        const resolved = resolveMaxTurns(this.config.maxTurns, goal);
+        return profileMaxTurns === undefined ? resolved : Math.min(resolved, profileMaxTurns);
+    }
     buildSummarizeFn(auxSummaryClient, recordCumulativeUsage) {
         return this.auxiliaryPipeline.buildSummarizeFn(auxSummaryClient, recordCumulativeUsage);
     }
@@ -2717,7 +2784,7 @@ export class Engine {
                     : resumed
                         ? `目标已恢复：${next.objective}`
                         : undefined, {
-                    maxTurns: resolveMaxTurns(this.config.maxTurns, next),
+                    maxTurns: this.resolveRunMaxTurns(next, this.activeProfileMaxTurns),
                     maxStopBlocks: resolveMaxStopBlocks(this.config.maxStopBlocks, next),
                 });
                 if (this.activeGoalHook && !this.activeGoalHookAttached) {
@@ -2830,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) {
@@ -2842,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
@@ -3134,6 +3221,19 @@ export class Engine {
     extendGoalRun(opts) {
         if (!this.activeTurnLoop)
             return null;
+        if (this.activeProfileMaxTurns !== undefined &&
+            typeof opts.addTurns === "number" &&
+            Number.isFinite(opts.addTurns) &&
+            opts.addTurns > 0 &&
+            opts.addTurns <= Number.MAX_SAFE_INTEGER) {
+            // An empty extension is a no-op that returns the live ceilings. Goal
+            // budgets may still grow, but a behavior-profile ceiling cannot.
+            const currentMaxTurns = this.activeTurnLoop.extend({}).maxTurns;
+            return this.activeTurnLoop.extend({
+                ...opts,
+                addTurns: Math.min(opts.addTurns, this.activeProfileMaxTurns - currentMaxTurns),
+            });
+        }
         return this.activeTurnLoop.extend(opts);
     }
     /**

package/dist/engine/prompt-cache-diagnostics.js

@@ -4,6 +4,12 @@ const DEFAULT_MAX_SESSIONS = 256;
 const DROP_MIN_PREVIOUS_TOKENS = 100;
 const DROP_MAX_CURRENT_TOKENS = 64;
 const DROP_RATIO = 0.1;
+// Partial cache invalidation can leave thousands of tokens cached. Require
+// both a halving and a meaningful absolute loss to avoid reporting small
+// fluctuations. Compare cache reads, not hit rates: appending uncached input
+// can lower the hit rate while the reusable prefix remains fully cached.
+const PARTIAL_DROP_MAX_RETAINED_RATIO = 0.5;
+const PARTIAL_DROP_MIN_LOST_TOKENS = 4096;
 /**
  * Session stickiness audit. Semantic, capability, and security switches must
  * take effect on the next request even when they invalidate a cache prefix.
@@ -150,7 +156,10 @@ export class PromptCacheDiagnosticRecorder {
         if (previous.cacheReadTokens < DROP_MIN_PREVIOUS_TOKENS)
             return { kind: "updated" };
         const dropRatio = previous.cacheReadTokens > 0 ? cacheReadTokens / previous.cacheReadTokens : 1;
-        if (cacheReadTokens > DROP_MAX_CURRENT_TOKENS || dropRatio > DROP_RATIO) {
+        const nearColdDrop = cacheReadTokens <= DROP_MAX_CURRENT_TOKENS && dropRatio <= DROP_RATIO;
+        const partialDrop = dropRatio <= PARTIAL_DROP_MAX_RETAINED_RATIO &&
+            previous.cacheReadTokens - cacheReadTokens >= PARTIAL_DROP_MIN_LOST_TOKENS;
+        if (!nearColdDrop && !partialDrop) {
             return { kind: "updated" };
         }
         return {

package/dist/engine/run-goal.js

@@ -10,9 +10,13 @@ import { logger } from "../logging/logger.js";
 /** engine.ts:explicit/stored/fallback 归一化 + 持久化 + goal_set 事件。 */
 export function resolveRunGoal(args) {
     const { options, session, sessionManager, configGoal, isSubAgent, sid, onStream } = args;
-    const explicitGoal = normalizeGoal(options?.goal);
+    const goalDisabled = options?.disableGoal === true;
+    const explicitGoal = goalDisabled ? undefined : normalizeGoal(options?.goal);
     const storedLifecycle = session.state.goalLifecycle;
-    const storedGoal = isSubAgent !== true && storedLifecycle && isGoalLifecycleCurrent(storedLifecycle)
+    const storedGoal = !goalDisabled &&
+        isSubAgent !== true &&
+        storedLifecycle &&
+        isGoalLifecycleCurrent(storedLifecycle)
         ? goalConfigFromLifecycle(storedLifecycle)
         : undefined;
     if (storedGoal &&
@@ -48,7 +52,7 @@ export function resolveRunGoal(args) {
             replaced,
         });
     }
-    const fallbackGoal = normalizeGoal(configGoal);
+    const fallbackGoal = goalDisabled ? undefined : normalizeGoal(configGoal);
     if (fallbackGoal && !fallbackGoal.goalId)
         fallbackGoal.goalId = randomUUID();
     if (fallbackGoal && !fallbackGoal.revision)

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[];