feat(memory): add autoSkill background project skill extraction

packages/cli/src/config/config.ts

@@ -30,6 +30,7 @@ import {
   NativeLspService,
   isBareMode,
   isToolEnabled,
+  type ConfigParameters,
 } from '@qwen-code/qwen-code-core';
 import { extensionsCommand } from '../commands/extensions.js';
 import { hooksCommand } from '../commands/hooks.js';
@@ -1106,7 +1107,7 @@ export async function loadCliConfig(
 
   const modelProvidersConfig = settings.modelProviders;
 
-  const config = new Config({
+  const configParams: ConfigParameters = {
     sessionId,
     sessionData,
     embeddingModel: DEFAULT_QWEN_EMBEDDING_MODEL,
@@ -1231,6 +1232,9 @@ export async function loadCliConfig(
       ? false
       : (settings.memory?.enableManagedAutoMemory ?? true),
     enableManagedAutoDream: settings.memory?.enableManagedAutoDream ?? false,
+    enableAutoSkill: bareMode
+      ? false
+      : (settings.memory?.enableAutoSkill ?? false),
     fastModel: settings.fastModel || undefined,
     // Use separated hooks if provided, otherwise fall back to merged hooks
     userHooks: bareMode
@@ -1268,7 +1272,9 @@ export async function loadCliConfig(
             : undefined,
         }
       : undefined,
-  });
+  };
+
+  const config = new Config(configParams);
 
   if (lspEnabled) {
     try {

packages/cli/src/config/settingsSchema.ts

@@ -1123,6 +1123,16 @@ const SETTINGS_SCHEMA = {
           'Enable automatic consolidation (dream) of collected memories.',
         showInDialog: false,
       },
+      enableAutoSkill: {
+        type: 'boolean',
+        label: 'Enable Auto Skill',
+        category: 'Memory',
+        requiresRestart: false,
+        default: false,
+        description:
+          'Enable background review for reusable project skills after tool-heavy sessions.',
+        showInDialog: false,
+      },
     },
   },
 

packages/cli/src/nonInteractiveCli.test.ts

@@ -109,6 +109,8 @@ describe('runNonInteractive', () => {
 
     mockGeminiClient = {
       sendMessageStream: vi.fn(),
+      consumePendingMemoryTaskPromises: vi.fn().mockReturnValue([]),
+      recordCompletedToolCall: vi.fn(),
       getChatRecordingService: vi.fn(() => ({
         initialize: vi.fn(),
         recordMessage: vi.fn(),
@@ -154,6 +156,7 @@ describe('runNonInteractive', () => {
       getCronScheduler: vi.fn().mockReturnValue(null),
       setModelInvocableCommandsProvider: vi.fn(),
       setModelInvocableCommandsExecutor: vi.fn(),
+      getAutoSkillEnabled: vi.fn().mockReturnValue(false),
       getDisabledSlashCommands: vi.fn().mockReturnValue([]),
       getBackgroundTaskRegistry: vi.fn().mockReturnValue({
         setNotificationCallback: vi.fn(),

packages/cli/src/nonInteractiveCli.ts

@@ -451,6 +451,9 @@ export async function runNonInteractive(
             }
 
             adapter.emitToolResult(finalRequestInfo, toolResponse);
+            config
+              .getGeminiClient()
+              .recordCompletedToolCall(finalRequestInfo.name);
 
             if (toolResponse.responseParts) {
               toolResponseParts.push(...toolResponse.responseParts);
@@ -599,6 +602,9 @@ export async function runNonInteractive(
                   }
 
                   adapter.emitToolResult(requestInfo, toolResponse);
+                  config
+                    .getGeminiClient()
+                    .recordCompletedToolCall(requestInfo.name);
 
                   if (toolResponse.responseParts) {
                     itemToolResponseParts.push(...toolResponse.responseParts);
@@ -713,6 +719,13 @@ export async function runNonInteractive(
             await new Promise((r) => setTimeout(r, 100));
           }
 
+          const memoryTaskPromises = config
+            .getGeminiClient()
+            .consumePendingMemoryTaskPromises();
+          if (memoryTaskPromises.length > 0) {
+            await Promise.allSettled(memoryTaskPromises);
+          }
+
           const metrics = uiTelemetryService.getMetrics();
           const usage = computeUsageFromMetrics(metrics);
           // Get stats for JSON format output

packages/cli/src/ui/hooks/useGeminiStream.test.tsx

@@ -51,6 +51,7 @@ const MockedGeminiClientClass = vi.hoisted(() =>
     this.sendMessageStream = mockSendMessageStream;
     this.addHistory = vi.fn();
     this.consumePendingMemoryTaskPromises = vi.fn().mockReturnValue([]);
+    this.recordCompletedToolCall = vi.fn();
     this.getChatRecordingService = vi.fn().mockReturnValue({
       recordThought: vi.fn(),
       initialize: vi.fn(),

packages/cli/src/ui/hooks/useGeminiStream.ts

@@ -1705,6 +1705,10 @@ export const useGeminiStream = (
         (t) => !t.request.isClientInitiated,
       );
 
+      for (const toolCall of geminiTools) {
+        geminiClient?.recordCompletedToolCall(toolCall.request.name);
+      }
+
       if (geminiTools.length === 0) {
         return;
       }

packages/core/src/agents/runtime/agent-core.ts

@@ -74,6 +74,7 @@ import { type ContextState, templateString } from './agent-headless.js';
  */
 export const EXCLUDED_TOOLS_FOR_SUBAGENTS: ReadonlySet<string> = new Set([
   ToolNames.AGENT,
+  ToolNames.SKILL_MANAGE,
   ToolNames.CRON_CREATE,
   ToolNames.CRON_LIST,
   ToolNames.CRON_DELETE,
@@ -334,7 +335,12 @@ export class AgentCore {
           ),
         );
       }
-      toolsList.push(...onlyInlineDecls);
+      // Also filter inline FunctionDeclaration[] passed directly in toolConfig.
+      toolsList.push(
+        ...onlyInlineDecls.filter(
+          (d) => !(d.name && excludedFromSubagents.has(d.name)),
+        ),
+      );
     } else {
       // Inherit all available tools by default when not specified.
       toolsList.push(

packages/core/src/config/config.ts

@@ -462,6 +462,8 @@ export interface ConfigParameters {
   enableManagedAutoMemory?: boolean;
   /** Enable managed auto-dream consolidation separately from extraction. Defaults to true. */
   enableManagedAutoDream?: boolean;
+  /** Enable automatic project skill review after tool-heavy sessions. Defaults to true. */
+  enableAutoSkill?: boolean;
   /**
    * Lightweight model for background tasks (memory extraction, dream, /btw side questions).
    * When set and valid for the current auth type, forked agents use this model instead of
@@ -690,6 +692,7 @@ export class Config {
   private readonly defaultFileEncoding: FileEncodingType | undefined;
   private readonly enableManagedAutoMemory: boolean;
   private readonly enableManagedAutoDream: boolean;
+  private readonly enableAutoSkill: boolean;
   private fastModel?: string;
   private readonly disableAllHooks: boolean;
   /** User-level hooks (always loaded regardless of trust) */
@@ -886,6 +889,7 @@ export class Config {
     });
     this.enableManagedAutoMemory = params.enableManagedAutoMemory ?? true;
     this.enableManagedAutoDream = params.enableManagedAutoDream ?? false;
+    this.enableAutoSkill = params.enableAutoSkill ?? false;
     this.fastModel = params.fastModel || undefined;
     this.disableAllHooks = params.disableAllHooks ?? false;
     // Store user and project hooks separately for proper source attribution
@@ -2128,6 +2132,10 @@ export class Config {
     return this.enableManagedAutoDream && !this.getBareMode();
   }
 
+  getAutoSkillEnabled(): boolean {
+    return this.enableAutoSkill && !this.getBareMode();
+  }
+
   /**
    * Return the MemoryManager instance created for this Config.
    * Use this to share background-task state (registry, drainer) with memory
@@ -2630,6 +2638,10 @@ export class Config {
       const { SkillTool } = await import('../tools/skill.js');
       return new SkillTool(this);
     });
+    await registerLazy(ToolNames.SKILL_MANAGE, async () => {
+      const { SkillManageTool } = await import('../tools/skill-manage.js');
+      return new SkillManageTool(this);
+    });
     await registerLazy(ToolNames.LS, async () => {
       const { LSTool } = await import('../tools/ls.js');
       return new LSTool(this);

packages/core/src/core/client.test.ts

@@ -390,6 +390,7 @@ describe('Gemini Client (client.ts)', () => {
       getArenaAgentClient: vi.fn().mockReturnValue(null),
       getManagedAutoMemoryEnabled: vi.fn().mockReturnValue(true),
       getMemoryManager: vi.fn().mockReturnValue(mockMemoryManager),
+      getAutoSkillEnabled: vi.fn().mockReturnValue(false),
       getDisableAllHooks: vi.fn().mockReturnValue(true),
       getArenaManager: vi.fn().mockReturnValue(null),
       getMessageBus: vi.fn().mockReturnValue(undefined),

packages/core/src/core/client.ts

@@ -128,6 +128,7 @@ const EMPTY_RELEVANT_AUTO_MEMORY_RESULT: RelevantAutoMemoryPromptResult = {
 export class GeminiClient {
   private chat?: GeminiChat;
   private sessionTurnCount = 0;
+  private toolCallCount = 0;
   private readonly surfacedRelevantAutoMemoryPaths = new Set<string>();
 
   private readonly loopDetector: LoopDetectionService;
@@ -513,18 +514,45 @@ export class GeminiClient {
   private runManagedAutoMemoryBackgroundTasks(
     messageType: SendMessageType,
   ): void {
-    if (messageType !== SendMessageType.UserQuery) {
-      return;
-    }
-
-    if (!this.config.getManagedAutoMemoryEnabled()) {
+    if (
+      messageType !== SendMessageType.UserQuery &&
+      messageType !== SendMessageType.ToolResult
+    ) {
       return;
     }
 
     const projectRoot = this.config.getProjectRoot();
     const sessionId = this.config.getSessionId();
     const history = this.getHistory();
     const mgr = this.config.getMemoryManager();
+    const autoSkillEnabled = this.config.getAutoSkillEnabled();
+
+    if (autoSkillEnabled) {
+      const skillReviewResult = mgr.scheduleSkillReview({
+        projectRoot,
+        sessionId,
+        history,
+        config: this.config,
+        toolCallCount: this.toolCallCount,
+        enabled: autoSkillEnabled,
+        threshold: 20,
+        maxTurns: 8,
+        timeoutMs: 120_000,
+      });
+      if (skillReviewResult.promise) {
+        this.pendingMemoryTaskPromises.push(
+          skillReviewResult.promise.then((record) => {
+            const touched = record.metadata?.['touchedSkillFiles'];
+            return Array.isArray(touched) ? touched.length : 0;
+          }),
+        );
+      }
+    }
+    this.toolCallCount = 0;
+
+    if (!this.config.getManagedAutoMemoryEnabled()) {
+      return;
+    }
 
     const extractPromise = mgr
       .scheduleExtract({
@@ -581,6 +609,14 @@ export class GeminiClient {
     return promises;
   }
 
+  recordCompletedToolCall(toolName: string): void {
+    if (toolName === 'skill_manage') {
+      this.toolCallCount = 0;
+      return;
+    }
+    this.toolCallCount += 1;
+  }
+
   async *sendMessageStream(
     request: PartListUnion,
     signal: AbortSignal,