feat(memory): add autoSkill background project skill extraction

packages/cli/src/config/config.ts

@@ -30,6 +30,7 @@ import {
   NativeLspService,
   isBareMode,
   isToolEnabled,
+  type ConfigParameters,
   type MCPServerConfig,
 } from '@qwen-code/qwen-code-core';
 import { extensionsCommand } from '../commands/extensions.js';
@@ -1171,7 +1172,7 @@ export async function loadCliConfig(
 
   const modelProvidersConfig = settings.modelProviders;
 
-  const config = new Config({
+  const configParams: ConfigParameters = {
     sessionId,
     sessionData,
     embeddingModel: DEFAULT_QWEN_EMBEDDING_MODEL,
@@ -1301,6 +1302,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
@@ -1338,7 +1342,9 @@ export async function loadCliConfig(
             : undefined,
         }
       : undefined,
-  });
+  };
+
+  const config = new Config(configParams);
 
   if (lspEnabled) {
     try {

packages/cli/src/config/settingsSchema.ts

@@ -1329,6 +1329,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

@@ -93,6 +93,8 @@ describe('runNonInteractive', () => {
     sendMessageStream: Mock;
     getChatRecordingService: Mock;
     getChat: Mock;
+    consumePendingMemoryTaskPromises: Mock;
+    recordCompletedToolCall: Mock;
   };
   let mockGetDebugResponses: Mock;
 
@@ -148,6 +150,8 @@ describe('runNonInteractive', () => {
 
     mockGeminiClient = {
       sendMessageStream: vi.fn(),
+      consumePendingMemoryTaskPromises: vi.fn().mockReturnValue([]),
+      recordCompletedToolCall: vi.fn(),
       getChatRecordingService: vi.fn(() => ({
         initialize: vi.fn(),
         recordMessage: vi.fn(),
@@ -193,6 +197,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()
@@ -404,6 +409,15 @@ describe('runNonInteractive', () => {
       { type: SendMessageType.ToolResult },
     );
     expect(processStdoutSpy).toHaveBeenCalledWith('Final answer\n');
+    // Verify recordCompletedToolCall is called with the tool name and args.
+    expect(mockGeminiClient.recordCompletedToolCall).toHaveBeenCalledWith(
+      'testTool',
+      { arg1: 'value1' },
+    );
+    // Verify consumePendingMemoryTaskPromises is called at the end of the session.
+    expect(
+      mockGeminiClient.consumePendingMemoryTaskPromises,
+    ).toHaveBeenCalled();
   });
 
   it('should handle error during tool execution and should send error back to the model', async () => {

packages/cli/src/nonInteractiveCli.ts

@@ -536,6 +536,12 @@ export async function runNonInteractive(
             }
 
             adapter.emitToolResult(finalRequestInfo, toolResponse);
+            config
+              .getGeminiClient()
+              .recordCompletedToolCall(
+                finalRequestInfo.name,
+                finalRequestInfo.args as Record<string, unknown>,
+              );
 
             if (toolResponse.responseParts) {
               toolResponseParts.push(...toolResponse.responseParts);
@@ -674,6 +680,12 @@ export async function runNonInteractive(
                   }
 
                   adapter.emitToolResult(requestInfo, toolResponse);
+                  config
+                    .getGeminiClient()
+                    .recordCompletedToolCall(
+                      requestInfo.name,
+                      requestInfo.args as Record<string, unknown>,
+                    );
 
                   if (toolResponse.responseParts) {
                     itemToolResponseParts.push(...toolResponse.responseParts);
@@ -798,6 +810,12 @@ export async function runNonInteractive(
             await new Promise((r) => setTimeout(r, 100));
           }
 
+          const memoryTaskPromises = config
+            .getGeminiClient()
+            .consumePendingMemoryTaskPromises();
+          if (memoryTaskPromises.length > 0) {
+            await Promise.allSettled(memoryTaskPromises);
+          }
           finalizeOneShotMonitors();
 
           const metrics = uiTelemetryService.getMetrics();

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

@@ -52,6 +52,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

@@ -1898,6 +1898,13 @@ export const useGeminiStream = (
         (t) => !t.request.isClientInitiated,
       );
 
+      for (const toolCall of geminiTools) {
+        geminiClient?.recordCompletedToolCall(
+          toolCall.request.name,
+          toolCall.request.args as Record<string, unknown>,
+        );
+      }
+
       if (geminiTools.length === 0) {
         return;
       }

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

@@ -368,6 +368,9 @@ export class AgentCore {
     const toolsList: FunctionDeclaration[] = [];
 
     const excludedFromSubagents = EXCLUDED_TOOLS_FOR_SUBAGENTS;
+    // When a subagent has an explicit tools list (not wildcard), only the
+    // recursive-spawn guard (AgentTool) is enforced.
+    const recursionGuardOnly = new Set<string>([ToolNames.AGENT]);
 
     if (this.toolConfig) {
       const asStrings = this.toolConfig.tools.filter(
@@ -388,13 +391,22 @@ export class AgentCore {
             .filter((t) => !(t.name && excludedFromSubagents.has(t.name))),
         );
       } else {
+        // Explicit tool list: apply the full subagent exclusion set (not just
+        // the recursion guard). This prevents control-plane tools
+        // (CRON_CREATE, TASK_STOP, SEND_MESSAGE, etc.) from leaking into
+        // explicitly-configured subagents that happen to list them.
         toolsList.push(
           ...toolRegistry.getFunctionDeclarationsFiltered(
             asStrings.filter((name) => !excludedFromSubagents.has(name)),
           ),
         );
       }
-      toolsList.push(...onlyInlineDecls);
+      // Also filter inline FunctionDeclaration[] passed directly in toolConfig.
+      toolsList.push(
+        ...onlyInlineDecls.filter(
+          (d) => !(d.name && recursionGuardOnly.has(d.name)),
+        ),
+      );
     } else {
       // Inherit all available tools by default when not specified.
       toolsList.push(

packages/core/src/config/config.ts

@@ -538,6 +538,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 false. */
+  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
@@ -768,6 +770,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) */
@@ -969,6 +972,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
@@ -2294,6 +2298,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