@cjhyy/code-shell-core 0.7.1 → 0.8.0

package/dist/credentials/access.js

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { credentialAllowsEnvExposure, credentialSecretHint, } from "./types.js";
 import { CredentialStore } from "./store.js";
 import { formatNetscapeCookies, parseCookieJar } from "./cookie-jar.js";
-import { parseOAuthCredentialSecret, shouldRefreshOAuthCredential, summarizeOAuthCredentialSecret, } from "./oauth.js";
+import { parseOAuthCredentialSecret, isBrowserOAuthLinkCredential, resolveLinkCredentialAccessToken, shouldRefreshOAuthCredential, summarizeOAuthCredentialSecret, } from "./oauth.js";
 import { refreshToken } from "../services/oauth.js";
 const COOKIE_FILE_PREFIX = "codeshell-cred-cookie-";
 const COOKIE_FILE_MAX_AGE_MS = 30 * 60 * 1000;
@@ -19,6 +19,7 @@ export function getCredentialAccess() {
 export function createIpcCredentialAccess(transport) {
     let snapshot = { revision: 0, entries: [] };
     let nextId = 1;
+    const subscribers = new Set();
     const pending = new Map();
     transport.onMessage((msg) => {
         if ("method" in msg && msg.method === "desktop/credentialSnapshot") {
@@ -28,6 +29,14 @@ export function createIpcCredentialAccess(transport) {
                     revision: params.revision,
                     entries: params.entries,
                 };
+                for (const listener of subscribers) {
+                    try {
+                        listener();
+                    }
+                    catch {
+                        // One consumer must not break the credential snapshot transport.
+                    }
+                }
             }
             return;
         }
@@ -81,6 +90,10 @@ export function createIpcCredentialAccess(transport) {
                 return {};
             return { ...(scope === "project" ? entry.envProject : entry.envFull) };
         },
+        subscribe(listener) {
+            subscribers.add(listener);
+            return () => subscribers.delete(listener);
+        },
         async resolveValue(req) {
             const result = (await request("desktop/credentialResolve", req));
             if (typeof result?.value !== "string")
@@ -121,7 +134,9 @@ function toMetadata(cred) {
         ...(credentialAllowsEnvExposure(cred.type) ? {} : { exposeAsEnv: undefined }),
         hasSecret: available,
         secretHint: available ? credentialSecretHint(cred.type, secret) : undefined,
-        ...(cred.type === "oauth" ? { oauthStatus: summarizeOAuthCredentialSecret(secret) } : {}),
+        ...(cred.type === "oauth" || isBrowserOAuthLinkCredential(cred)
+            ? { oauthStatus: summarizeOAuthCredentialSecret(secret) }
+            : {}),
     };
 }
 function cloneMetadata(list) {
@@ -155,7 +170,13 @@ export const localCredentialAccess = {
         if (!cred || !isCredentialSecretAvailable(cred.secret)) {
             throw new Error(`credential "${req.id}" is unavailable`);
         }
-        return cred.secret;
+        if (req.purpose === "link" &&
+            (cred.type !== "link" ||
+                cred.meta?.linkExecutionRuntime !== "local" ||
+                !cred.meta.linkProvider)) {
+            throw new Error(`credential "${req.id}" is not a local Link credential`);
+        }
+        return req.purpose === "link" ? resolveLinkCredentialAccessToken(cred) : cred.secret;
     },
     async resolveOAuthAccess(req) {
         return resolveLocalOAuthAccess(req.id, Boolean(req.forceRefresh));

package/dist/credentials/index.d.ts

@@ -4,7 +4,7 @@ export { type EncryptionCipher, PlaintextCipher, setDefaultCredentialCipher, get
 export { getCredentialAccess, setDefaultCredentialAccess, createIpcCredentialAccess, localCredentialAccess, credentialAccessScope, isCredentialSecretAvailable, materializeCookieSecret, type CredentialAccess, type CredentialAccessScope, type CredentialMetadata, type CredentialSnapshot, type CredentialSnapshotEntry, } from "./access.js";
 export type { Credential, CredentialType, CredentialStoreFile, OAuthCredentialPublicStatus, OAuthCredentialSecret, OAuthTokenResponse, } from "./types.js";
 export { credentialAllowsEnvExposure, credentialSecretHint } from "./types.js";
-export { buildOAuthRefreshRequest, isOAuthAccessTokenExpired, oauthCredentialStatus, parseOAuthCredentialSecret, mergeOAuthTokenResponse, shouldRefreshOAuthCredential, summarizeOAuthCredentialSecret, type OAuthClockOptions, type OAuthRefreshHandler, type OAuthRefreshRequest, } from "./oauth.js";
+export { buildOAuthRefreshRequest, isBrowserOAuthLinkCredential, isOAuthAccessTokenExpired, oauthCredentialStatus, parseOAuthCredentialSecret, resolveLinkCredentialAccessToken, mergeOAuthTokenResponse, shouldRefreshOAuthCredential, summarizeOAuthCredentialSecret, type OAuthClockOptions, type OAuthRefreshHandler, type OAuthRefreshRequest, } from "./oauth.js";
 export { formatNetscapeCookies, parseCookieJar, type CookieLike } from "./cookie-jar.js";
 export { useCredentialToolDef, useCredentialToolDefFor, useCredentialTool, sweepStaleCredentialCookies, } from "./use-credential-tool.js";
 export { credentialUseGate } from "./use-gate.js";

package/dist/credentials/index.js

@@ -2,7 +2,7 @@ export { CredentialStore } from "./store.js";
 export { PlaintextCipher, setDefaultCredentialCipher, getDefaultCredentialCipher, } from "./cipher.js";
 export { getCredentialAccess, setDefaultCredentialAccess, createIpcCredentialAccess, localCredentialAccess, credentialAccessScope, isCredentialSecretAvailable, materializeCookieSecret, } from "./access.js";
 export { credentialAllowsEnvExposure, credentialSecretHint } from "./types.js";
-export { buildOAuthRefreshRequest, isOAuthAccessTokenExpired, oauthCredentialStatus, parseOAuthCredentialSecret, mergeOAuthTokenResponse, shouldRefreshOAuthCredential, summarizeOAuthCredentialSecret, } from "./oauth.js";
+export { buildOAuthRefreshRequest, isBrowserOAuthLinkCredential, isOAuthAccessTokenExpired, oauthCredentialStatus, parseOAuthCredentialSecret, resolveLinkCredentialAccessToken, mergeOAuthTokenResponse, shouldRefreshOAuthCredential, summarizeOAuthCredentialSecret, } from "./oauth.js";
 export { formatNetscapeCookies, parseCookieJar } from "./cookie-jar.js";
 export { useCredentialToolDef, useCredentialToolDefFor, useCredentialTool, sweepStaleCredentialCookies, } from "./use-credential-tool.js";
 export { credentialUseGate } from "./use-gate.js";

package/dist/credentials/oauth.d.ts

@@ -1,4 +1,4 @@
-import type { OAuthCredentialPublicStatus, OAuthCredentialSecret, OAuthTokenResponse } from "./types.js";
+import type { Credential, OAuthCredentialPublicStatus, OAuthCredentialSecret, OAuthTokenResponse } from "./types.js";
 export interface OAuthClockOptions {
     now?: number | (() => number);
     skewMs?: number;
@@ -14,6 +14,9 @@ export interface OAuthRefreshRequest {
 }
 export type OAuthRefreshHandler = (req: OAuthRefreshRequest) => Promise<OAuthCredentialSecret>;
 export declare function parseOAuthCredentialSecret(secret: string): OAuthCredentialSecret;
+export declare function isBrowserOAuthLinkCredential(credential: Pick<Credential, "type" | "meta">): boolean;
+/** Return only the bearer token from a Link secret, never its refresh material. */
+export declare function resolveLinkCredentialAccessToken(credential: Pick<Credential, "type" | "secret" | "meta">): string | undefined;
 /** Merge and validate an OAuth token endpoint response without losing rotation state. */
 export declare function mergeOAuthTokenResponse(previous: OAuthCredentialSecret | undefined, response: OAuthTokenResponse, opts?: {
     now?: number;

package/dist/credentials/oauth.js

@@ -56,6 +56,8 @@ export function parseOAuthCredentialSecret(secret) {
     }
     const expiresAt = optionalString(raw.expiresAt);
     parseExpiresAt(expiresAt);
+    const refreshTokenExpiresAt = optionalString(raw.refreshTokenExpiresAt);
+    parseExpiresAt(refreshTokenExpiresAt);
     const tokenType = optionalString(raw.tokenType);
     if (tokenType && tokenType.toLowerCase() !== "bearer") {
         throw new Error("OAuth credential tokenType must be Bearer");
@@ -65,6 +67,7 @@ export function parseOAuthCredentialSecret(secret) {
         accessToken,
         refreshToken: optionalString(raw.refreshToken),
         expiresAt,
+        refreshTokenExpiresAt,
         tokenType,
         scope: optionalString(raw.scope),
         scopes: optionalStringArray(raw.scopes),
@@ -94,6 +97,17 @@ export function parseOAuthCredentialSecret(secret) {
             : undefined,
     };
 }
+export function isBrowserOAuthLinkCredential(credential) {
+    return credential.type === "link" && credential.meta?.linkAuthSource === "browser-oauth";
+}
+/** Return only the bearer token from a Link secret, never its refresh material. */
+export function resolveLinkCredentialAccessToken(credential) {
+    if (!credential.secret)
+        return undefined;
+    return isBrowserOAuthLinkCredential(credential)
+        ? parseOAuthCredentialSecret(credential.secret).accessToken
+        : credential.secret;
+}
 /** Merge and validate an OAuth token endpoint response without losing rotation state. */
 export function mergeOAuthTokenResponse(previous, response, opts = {}) {
     const accessToken = optionalString(response.access_token);

package/dist/credentials/store.d.ts

@@ -13,6 +13,13 @@ export interface MaskedCredential extends Omit<Credential, "secret"> {
  */
 export declare class CredentialStore {
     private readonly cwd?;
+    /**
+     * Override the user-scope store directory (the `~/.code-shell` layer;
+     * `credentials.json` lives directly inside it). Absent → today's
+     * behavior: `join(userHome(), ".code-shell")` resolved per call.
+     * Injection point for identity-scoped server deployments.
+     */
+    private readonly userDirOverride?;
     private readonly cipher;
     /**
      * @param cwd     project root for the project-scope store (undefined → user only).
@@ -22,7 +29,14 @@ export declare class CredentialStore {
      *                returns PLAINTEXT secrets; encryption is applied only at the
      *                disk boundary (read decrypts, write encrypts).
      */
-    constructor(cwd?: string | undefined, cipher?: EncryptionCipher);
+    constructor(cwd?: string | undefined, cipher?: EncryptionCipher, 
+    /**
+     * Override the user-scope store directory (the `~/.code-shell` layer;
+     * `credentials.json` lives directly inside it). Absent → today's
+     * behavior: `join(userHome(), ".code-shell")` resolved per call.
+     * Injection point for identity-scoped server deployments.
+     */
+    userDirOverride?: string | undefined);
     private pathFor;
     /**
      * Decrypt a stored secret to plaintext. A value this cipher can't decrypt

package/dist/credentials/store.js

@@ -5,6 +5,7 @@ import { credentialAllowsEnvExposure, credentialSecretHint, } from "./types.js";
 import { getDefaultCredentialCipher } from "./cipher.js";
 import { logger } from "../logging/logger.js";
 import { summarizeOAuthCredentialSecret } from "./oauth.js";
+import { isBrowserOAuthLinkCredential } from "./oauth.js";
 /** 测试可经 process.env.HOME 覆盖(镜像 settings/manager.ts userHome)。 */
 function userHome() {
     return process.env.HOME ?? homedir();
@@ -16,6 +17,7 @@ const EMPTY = { version: 1, credentials: [] };
  */
 export class CredentialStore {
     cwd;
+    userDirOverride;
     cipher;
     /**
      * @param cwd     project root for the project-scope store (undefined → user only).
@@ -25,13 +27,22 @@ export class CredentialStore {
      *                returns PLAINTEXT secrets; encryption is applied only at the
      *                disk boundary (read decrypts, write encrypts).
      */
-    constructor(cwd, cipher) {
+    constructor(cwd, cipher, 
+    /**
+     * Override the user-scope store directory (the `~/.code-shell` layer;
+     * `credentials.json` lives directly inside it). Absent → today's
+     * behavior: `join(userHome(), ".code-shell")` resolved per call.
+     * Injection point for identity-scoped server deployments.
+     */
+    userDirOverride) {
         this.cwd = cwd;
+        this.userDirOverride = userDirOverride;
         this.cipher = cipher ?? getDefaultCredentialCipher();
     }
     pathFor(scope) {
-        if (scope === "user")
-            return join(userHome(), ".code-shell", "credentials.json");
+        if (scope === "user") {
+            return join(this.userDirOverride ?? join(userHome(), ".code-shell"), "credentials.json");
+        }
         if (!this.cwd)
             return undefined;
         return join(this.cwd, ".code-shell", "credentials.json");
@@ -188,7 +199,9 @@ export class CredentialStore {
                 ...(credentialAllowsEnvExposure(c.type) ? {} : { exposeAsEnv: undefined }),
                 hasSecret: typeof secret === "string" && secret.length > 0,
                 secretHint: credentialSecretHint(c.type, secret),
-                ...(c.type === "oauth" ? { oauthStatus: summarizeOAuthCredentialSecret(secret) } : {}),
+                ...(c.type === "oauth" || isBrowserOAuthLinkCredential(c)
+                    ? { oauthStatus: summarizeOAuthCredentialSecret(secret) }
+                    : {}),
             };
         });
     }

package/dist/credentials/types.d.ts

@@ -21,6 +21,8 @@ export interface OAuthCredentialSecret {
     refreshToken?: string;
     /** ISO-8601 expiry time for accessToken. Missing means "unknown", not expired. */
     expiresAt?: string;
+    /** Optional ISO-8601 expiry time for a rotating refresh token. */
+    refreshTokenExpiresAt?: string;
     /** Upstream token type, usually Bearer. Stored for round-trip/debugging. */
     tokenType?: string;
     /** Space-delimited OAuth scope string returned by many token endpoints. */
@@ -110,6 +112,28 @@ export interface Credential {
         domain?: string;
         scope?: "domain" | "all";
         switchMode?: "clear" | "merge";
+        /** 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. */
+        linkConnectionMethod?: string;
+        /** Where Link actions execute. Local is preferred when both runtimes are usable. */
+        linkExecutionRuntime?: "local" | "server";
+        /** How a local Link credential was obtained without exposing its secret to the renderer. */
+        linkAuthSource?: "manual-token" | "github-cli" | "cli-session" | "browser-oauth";
+        /** Fixed execution adapter. CLI bindings never resolve or copy a provider token. */
+        linkExecutionBackend?: "http-token" | "cli";
+        /** False for provider-owned Link secrets that must only flow through LinkAction. */
+        agentExposable?: boolean;
+        /** Stable upstream account/user id returned by the provider validation endpoint. */
+        linkAccountId?: string;
+        /** Human-readable upstream account label shown in the Link page. */
+        linkAccountLabel?: string;
+        /** Safe resource labels returned during validation for a compact Link card preview. */
+        linkResourceLabels?: string[];
+        /** Provider Action ids enabled for this connection. */
+        linkCapabilityIds?: string[];
+        /** ISO timestamp of the last successful live provider validation. */
+        linkLastVerifiedAt?: string;
         /** OAuth provider/integration id, e.g. "figma". */
         oauthProvider?: string;
         /** MCP server identity associated with an advanced OAuth login. */

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

@@ -24,6 +24,13 @@ const BASE_DESCRIPTION = "Use a stored credential (token / API key / login cooki
     "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.";
+function isAgentExposableCredential(credential) {
+    if (credential.meta?.agentExposable === false)
+        return false;
+    return !(credential.type === "link" &&
+        credential.meta?.linkExecutionRuntime === "local" &&
+        credential.meta.linkProvider);
+}
 export const useCredentialToolDef = {
     name: TOOL_NAME,
     description: BASE_DESCRIPTION,
@@ -47,7 +54,7 @@ export const useCredentialToolDef = {
  */
 export function useCredentialToolDefFor(cwd) {
     try {
-        const list = getCredentialAccess().listMasked(cwd, "full");
+        const list = getCredentialAccess().listMasked(cwd, "full").filter(isAgentExposableCredential);
         if (list.length === 0)
             return useCredentialToolDef;
         const names = list.map((c) => `${c.id} (${c.type})`).join(", ");
@@ -113,6 +120,7 @@ export async function useCredentialTool(args, ctx) {
     if (!id) {
         const credentials = access
             .listMasked(cwd, scope)
+            .filter(isAgentExposableCredential)
             .map((c) => ({ id: c.id, label: c.label, type: c.type }));
         return json({ kind: "list", credentials });
     }
@@ -120,6 +128,12 @@ export async function useCredentialTool(args, ctx) {
     if (!cred) {
         return json({ kind: "error", error: `凭证不存在: "${id}"。调用本工具(无参)可列出可用凭证。` });
     }
+    if (!isAgentExposableCredential(cred)) {
+        return json({
+            kind: "error",
+            error: `凭证「${cred.label}」只能通过 Link Action 使用，不能读取原始 Token。`,
+        });
+    }
     // 取值前过门
     const ask = ctx?.askUser
         ? (q, opts) => ctx.askUser(q, opts)

package/dist/engine/auxiliary-pipeline.d.ts

@@ -0,0 +1,40 @@
+import type { LLMConfig, TokenUsage } from "../types.js";
+import { createLLMClient } from "../llm/client-factory.js";
+import type { ModelPool } from "../llm/model-pool.js";
+import type { SettingsManager } from "../settings/manager.js";
+import type { ToolRegistry } from "../tool-system/registry.js";
+import type { ToolContext } from "../tool-system/context.js";
+import type { Transcript } from "../session/transcript.js";
+import type { CumulativeUsageCounters } from "../session/usage.js";
+import type { EngineConfig } from "./types.js";
+export type EngineLlmClient = Awaited<ReturnType<typeof createLLMClient>>;
+export interface ResolvedAuxClient {
+    client: EngineLlmClient;
+    maxContextTokens: number;
+}
+export interface MemoriesConfig {
+    maxCount?: number;
+    maxAge?: number;
+    extractionModel?: string;
+    autoExtract?: boolean;
+}
+export declare function sameLlmIdentity(a: LLMConfig, b: LLMConfig): boolean;
+export declare function buildSummarizeFn(client: EngineLlmClient, recordCumulativeUsage?: (usage: TokenUsage) => CumulativeUsageCounters): (prompt: string, signal?: AbortSignal) => Promise<string>;
+export declare class AuxiliaryPipeline {
+    private readonly deps;
+    private auxClientCache?;
+    constructor(deps: {
+        config: () => EngineConfig;
+        settings: () => SettingsManager;
+        modelPool: () => ModelPool;
+        toolRegistry: () => ToolRegistry;
+        toolContext: () => ToolContext;
+    });
+    buildSummarizeFn(client: EngineLlmClient, recordCumulativeUsage?: (usage: TokenUsage) => CumulativeUsageCounters): (prompt: string, signal?: AbortSignal) => Promise<string>;
+    readMemoriesConfig(): MemoriesConfig | undefined;
+    resolveAuxClient(fallback: EngineLlmClient): Promise<EngineLlmClient>;
+    resolveAuxClientWithMetadata(fallback: EngineLlmClient, fallbackMaxContextTokens?: number): Promise<ResolvedAuxClient>;
+    runMemoryPipeline(transcript: Transcript, sessionId: string, cwd: string, primaryClient: EngineLlmClient, recordBilledUsage?: (usage: TokenUsage) => void): Promise<void>;
+    private runDreamLoop;
+    private resolveExtractionClient;
+}

package/dist/engine/auxiliary-pipeline.js

@@ -0,0 +1,181 @@
+import { createLLMClient } from "../llm/client-factory.js";
+import { logger } from "../logging/logger.js";
+import { sanitizeContent } from "../logging/sanitize-messages.js";
+import { MemoryOrchestrator } from "../services/memory-orchestrator.js";
+import { runDreamConsolidation } from "../services/dream-consolidation.js";
+import { resolveAuxKey } from "./aux-key.js";
+export function sameLlmIdentity(a, b) {
+    return (a.model === b.model &&
+        (a.baseUrl ?? undefined) === (b.baseUrl ?? undefined) &&
+        (a.provider ?? undefined) === (b.provider ?? undefined) &&
+        (a.providerKind ?? undefined) === (b.providerKind ?? undefined) &&
+        (a.maxTokens ?? undefined) === (b.maxTokens ?? undefined) &&
+        JSON.stringify(a.reasoning ?? null) === JSON.stringify(b.reasoning ?? null));
+}
+export function buildSummarizeFn(client, recordCumulativeUsage) {
+    return async (prompt, signal) => {
+        const response = await client.createMessage({
+            systemPrompt: "You are a conversation summarizer. Be concise and factual.",
+            messages: [{ role: "user", content: prompt }],
+            tools: [],
+            maxTokens: 1024,
+            billingEnabled: true,
+            requestVisible: false,
+            reasoning: { mode: "off" },
+            signal,
+        });
+        if (response.usage)
+            recordCumulativeUsage?.(response.usage);
+        return response.text;
+    };
+}
+export class AuxiliaryPipeline {
+    deps;
+    auxClientCache;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    buildSummarizeFn(client, recordCumulativeUsage) {
+        return buildSummarizeFn(client, recordCumulativeUsage);
+    }
+    readMemoriesConfig() {
+        try {
+            return this.deps.settings().get().memories;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async resolveAuxClient(fallback) {
+        return (await this.resolveAuxClientWithMetadata(fallback)).client;
+    }
+    async resolveAuxClientWithMetadata(fallback, fallbackMaxContextTokens = 200_000) {
+        let auxKey;
+        try {
+            const settings = this.deps.settings();
+            settings.invalidate();
+            auxKey = resolveAuxKey(settings.get());
+        }
+        catch {
+            return { client: fallback, maxContextTokens: fallbackMaxContextTokens };
+        }
+        if (!auxKey)
+            return { client: fallback, maxContextTokens: fallbackMaxContextTokens };
+        const modelPool = this.deps.modelPool();
+        const entry = modelPool.get(auxKey);
+        if (entry && sameLlmIdentity(modelPool.toLLMConfig(entry), this.deps.config().llm)) {
+            return {
+                client: fallback,
+                maxContextTokens: entry.maxContextTokens ?? fallbackMaxContextTokens,
+            };
+        }
+        if (this.auxClientCache?.key === auxKey) {
+            return {
+                client: this.auxClientCache.client,
+                maxContextTokens: entry?.maxContextTokens ?? fallbackMaxContextTokens,
+            };
+        }
+        if (!entry) {
+            logger.warn("engine.aux_model_missing", { auxModelKey: auxKey });
+            return { client: fallback, maxContextTokens: fallbackMaxContextTokens };
+        }
+        try {
+            const client = await createLLMClient(modelPool.toLLMConfig(entry), this.deps.config().clientDefaults);
+            this.auxClientCache = { key: auxKey, client };
+            return {
+                client,
+                maxContextTokens: entry.maxContextTokens ?? fallbackMaxContextTokens,
+            };
+        }
+        catch (error) {
+            logger.warn("engine.aux_model_build_failed", {
+                auxModelKey: auxKey,
+                error: error.message,
+            });
+            return { client: fallback, maxContextTokens: fallbackMaxContextTokens };
+        }
+    }
+    async runMemoryPipeline(transcript, sessionId, cwd, primaryClient, recordBilledUsage) {
+        try {
+            const llmClient = await this.resolveExtractionClient(primaryClient);
+            const messages = transcript
+                .toMessages()
+                .filter((message) => message.role === "user" || message.role === "assistant");
+            if (messages.length < 8)
+                return;
+            const plainMessages = messages.map((message) => {
+                const safe = sanitizeContent(message.content);
+                return {
+                    role: message.role,
+                    content: typeof safe === "string" ? safe : JSON.stringify(safe),
+                };
+            });
+            const memories = this.readMemoriesConfig();
+            const orchestrator = new MemoryOrchestrator({
+                callLLM: async (systemPrompt, userMessage) => {
+                    const response = await llmClient.createMessage({
+                        systemPrompt,
+                        messages: [{ role: "user", content: userMessage }],
+                        tools: [],
+                        maxTokens: 1024,
+                        billingEnabled: true,
+                        requestVisible: false,
+                        reasoning: { mode: "off" },
+                    });
+                    if (response.usage)
+                        recordBilledUsage?.(response.usage);
+                    return response.text;
+                },
+                runDream: async ({ projectDir }) => this.runDreamLoop({
+                    projectDir,
+                    llmClient,
+                    sessionId,
+                    recordBilledUsage,
+                }),
+                projectDir: cwd,
+                maxCount: memories?.maxCount,
+                autoExtract: memories?.autoExtract,
+            });
+            await orchestrator.run(plainMessages, sessionId);
+        }
+        catch (error) {
+            logger.warn("engine.memory_pipeline_failed", {
+                sessionId,
+                error: error.message,
+            });
+        }
+    }
+    async runDreamLoop(options) {
+        const { ran } = await runDreamConsolidation({
+            llmClient: options.llmClient,
+            toolRegistry: this.deps.toolRegistry(),
+            toolContext: this.deps.toolContext(),
+            projectDir: options.projectDir,
+            sessionId: options.sessionId,
+            onUsage: options.recordBilledUsage,
+        });
+        return ran;
+    }
+    async resolveExtractionClient(primaryClient) {
+        const key = this.readMemoriesConfig()?.extractionModel;
+        const modelPool = this.deps.modelPool();
+        if (key) {
+            const entry = modelPool.get(key);
+            if (entry) {
+                try {
+                    return await createLLMClient(modelPool.toLLMConfig(entry), this.deps.config().clientDefaults);
+                }
+                catch (error) {
+                    logger.warn("engine.extraction_model_build_failed", {
+                        extractionModel: key,
+                        error: error.message,
+                    });
+                }
+            }
+            else {
+                logger.warn("engine.extraction_model_missing", { extractionModel: key });
+            }
+        }
+        return this.resolveAuxClient(primaryClient);
+    }
+}

package/dist/{settings → engine}/disk-defaults.d.ts

@@ -1,5 +1,5 @@
-import type { ValidatedSettings } from "./schema.js";
-import type { EngineConfig } from "../engine/types.js";
+import type { ValidatedSettings } from "../settings/schema.js";
+import type { EngineConfig } from "./types.js";
 /**
  * The subset of EngineConfig the config hot-reload ("layer 2") pushes onto an
  * already-running session's `this.config`. These are the "disk-default" fields:

package/dist/{settings → engine}/disk-defaults.js

@@ -1,4 +1,4 @@
-import { personalizationFrom } from "./personalization.js";
+import { personalizationFrom } from "../settings/personalization.js";
 import { mergePluginMcpServers } from "../plugins/installer/loadPluginMcp.js";
 /**
  * Derive the disk-default config patch from freshly-read settings.
@@ -19,7 +19,10 @@ export function diskDefaultsFrom(settings,
 effectiveDisabledPlugins) {
     const agent = settings.agent ?? {};
     return {
-        preset: agent.preset,
+        // preset 优先级：用户显式 agent.preset > 激活数字人的 profile.preset >
+        // capability 默认（resolveAgentPreset 内）。settings 已含合并后的
+        // project 层，profile 子树随之而来。
+        preset: agent.preset ?? settings.profile?.preset,
         customSystemPrompt: agent.customSystemPrompt,
         appendSystemPrompt: agent.appendSystemPrompt,
         ...personalizationFrom(agent),

package/dist/engine/dynamic-tool-defs.d.ts

@@ -15,5 +15,9 @@ import type { AgentDefinitionRegistry } from "../agent/agent-definition-registry
  *
  * Non-matching tools are returned by identity (no allocation). Pure: it never
  * mutates the input or any shared const.
+ *
+ * Run-scoped rewrites (e.g. DelegateWork's closed workspace enum) do NOT live
+ * here — a builtin owns those via its exposure.rewriteDefinition hook, applied
+ * by Engine.run() before this function.
  */
 export declare function applyDynamicToolDef(t: ToolDefinition, agentDefinitions: AgentDefinitionRegistry | undefined, guardCwd: string): ToolDefinition;

package/dist/engine/dynamic-tool-defs.js

@@ -17,6 +17,10 @@ import { useCredentialToolDefFor } from "../credentials/use-credential-tool.js";
  *
  * Non-matching tools are returned by identity (no allocation). Pure: it never
  * mutates the input or any shared const.
+ *
+ * Run-scoped rewrites (e.g. DelegateWork's closed workspace enum) do NOT live
+ * here — a builtin owns those via its exposure.rewriteDefinition hook, applied
+ * by Engine.run() before this function.
  */
 export function applyDynamicToolDef(t, agentDefinitions, guardCwd) {
     if (t.name === "Agent") {