lemura 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.7.0] - 2026-06-13
+
+### Added
+
+- **Progressive skills — model-driven skill selection** (`strategy: 'progressive'`): A third skill strategy alongside `fixed` and `dynamic`. The model sees a lightweight catalog (`name: description`) of progressive skills in its system prompt and decides which to pull in by calling a built-in `load_skill` tool; only the chosen skill's full content is then injected. This is the "progressive disclosure" pattern — the host wires nothing, the agent selects its own skills. Fully backward-compatible (default strategy remains `fixed`).
+- **Built-in `load_skill` tool** (`src/tools/builtin/load_skill.ts`, `createLoadSkillTool`): Auto-registered by `SessionManager` whenever a `progressive` skill is present, and auto-trusted by the tool firewall (it only toggles skill injection, no external side effects). The `name` parameter is constrained to the available progressive skills; unknown names and `maxConcurrent` violations return soft errors that keep the ReAct loop going.
+- **`SkillSelectionConfig`** (`SessionConfig.skillSelection`): Tunes progressive selection — `persistence` (`'per_turn'` default, or `'session'`), `maxConcurrent` (cap on simultaneously loaded skills), and `catalogHeader` (override the catalog preamble). Ignored when no progressive skills are present.
+- **`SkillInjector.buildCatalog(header?)`**: Builds the `name: description` catalog block for progressive skills. Plus `resetProgressiveSkills()`, `getProgressiveSkills()`, and `countEnabledProgressive()` helpers. `enableSkill`/`disableSkill`/`enableByTags`/`disableByTags` now operate on both `dynamic` and `progressive` skills.
+- **Full skill-lifecycle tracing**: `skill_load` now fires for **every registered skill** (not just active ones) and carries an `enabled` flag, so inactive `dynamic`/`progressive` skills are visible from session init. New `skill_enable` trace (`{ name, source: 'load_skill' }`) records the model's selection decision when it loads a progressive skill, and new `skill_reset` trace (`{ skills, reason: 'per_turn' }`) records per-turn clearing. `session_init` reports a `progressive` skill count; `skill_inject` fires for both dynamic and progressive injections.
+- **Tests**: `tests/unit/skills/ProgressiveSkills.test.ts` (catalog, activation, `load_skill` tool, `maxConcurrent`) and new `SessionManager` cases (auto-registration, per-turn vs session persistence).
+
 ## [1.6.0] - 2026-06-05
 
 ### Added

package/README.md

@@ -25,6 +25,7 @@
 ### ✨ Key Features
 
 - **🧠 Dynamic Skill Market**: Switch skills on/off at runtime via tags, names, or tool dependencies.
+- **📖 Progressive Skills**: Let the agent pick its own skills — it reads a catalog and loads only what's relevant via the built-in `load_skill` tool (`strategy: 'progressive'`).
 - **🔌 Native MCP Support**: Connect to any Model Context Protocol server with custom header support (Auth).
 - **🛡️ Tool Firewall**: Fully integrated ask/accept/deny policy layer for secure tool execution — fail-safe by design.
 - **🎯 Goal Maintenance & Verification**: LLM-powered sub-goal decomposition, progress reconciliation, and post-run goal verification that re-enters the loop with full tool access to finish incomplete answers.

package/dist/{agent-BppqfsIZ.d.ts → agent-BcAg3gCz.d.ts}

@@ -1,6 +1,6 @@
 import { I as IToolDefinition, a as IProviderAdapter, b as IContextStrategy, S as ShortTermMemoryRegistry, c as IScratchpadAdapter, T as Turn } from './adapters-CnsgefYR.js';
 import { I as ILogger } from './logger-DxvKliuk.js';
-import { I as ISkill } from './skills-Y6D7zSSw.js';
+import { I as ISkill, S as SkillSelectionConfig } from './skills-DWCC0K1B.js';
 import { I as IRAGAdapter } from './rag-La_Bo-J8.js';
 
 /**
@@ -323,6 +323,17 @@ interface SessionConfig {
      * @since 1.4.0
      */
     activeDynamicTags?: string[];
+    /**
+     * Configuration for model-driven (`progressive`) skill selection. When any
+     * skill in `skills` has `strategy: 'progressive'`, Lemura automatically appends
+     * a skill catalog to the system prompt, registers the built-in `load_skill`
+     * tool (auto-trusted by the firewall), and resets progressive skills according
+     * to `persistence`. This object tunes that behaviour; it is ignored when no
+     * progressive skills are present.
+     *
+     * @since 1.7.0
+     */
+    skillSelection?: SkillSelectionConfig;
     /** RAG adapter */
     ragAdapter?: IRAGAdapter;
     /** Context compression strategies */

package/dist/{agent-B2okLlzq.d.mts → agent-Dus44yQd.d.mts}

@@ -1,6 +1,6 @@
 import { I as IToolDefinition, a as IProviderAdapter, b as IContextStrategy, S as ShortTermMemoryRegistry, c as IScratchpadAdapter, T as Turn } from './adapters-BN6und82.mjs';
 import { I as ILogger } from './logger-DxvKliuk.mjs';
-import { I as ISkill } from './skills-Y6D7zSSw.mjs';
+import { I as ISkill, S as SkillSelectionConfig } from './skills-DWCC0K1B.mjs';
 import { I as IRAGAdapter } from './rag-La_Bo-J8.mjs';
 
 /**
@@ -323,6 +323,17 @@ interface SessionConfig {
      * @since 1.4.0
      */
     activeDynamicTags?: string[];
+    /**
+     * Configuration for model-driven (`progressive`) skill selection. When any
+     * skill in `skills` has `strategy: 'progressive'`, Lemura automatically appends
+     * a skill catalog to the system prompt, registers the built-in `load_skill`
+     * tool (auto-trusted by the firewall), and resets progressive skills according
+     * to `persistence`. This object tunes that behaviour; it is ignored when no
+     * progressive skills are present.
+     *
+     * @since 1.7.0
+     */
+    skillSelection?: SkillSelectionConfig;
     /** RAG adapter */
     ragAdapter?: IRAGAdapter;
     /** Context compression strategies */

package/dist/index.d.mts

@@ -1,12 +1,12 @@
 import { a as IProviderAdapter, d as TranscriptionRequest, e as TranscriptionResponse, f as SynthesisRequest, A as AudioChunk, V as VisionRequest, g as VisionResponse, h as ImageGenRequest, i as ImageGenResponse, M as ModelInfo, C as ContextWindow, T as Turn, j as ContentBlock, I as IToolDefinition } from './adapters-BN6und82.mjs';
 export { k as CompletionChunk, l as CompletionRequest, m as CompletionResponse, b as IContextStrategy, c as IScratchpadAdapter, n as IStorageAdapter, N as NormalizedMessage, o as STMItem, p as STMRegistryConfig, S as ShortTermMemoryRegistry, q as TokenUsage, r as ToolCall, s as ToolContext, t as ToolResult } from './adapters-BN6und82.mjs';
-import { S as SessionConfig, G as Goal, I as IToolResponseProcessor, T as ToolResponseEvaluation, a as IRouterAdapter, b as ToolCategoryInfo, R as RouterDecision, M as MCPServerConfig, c as MCPToolDefinition } from './agent-B2okLlzq.mjs';
-export { d as GoalInjector, e as GoalVerifierResult, f as MCPJsonRpcRequest, g as MCPJsonRpcResponse, h as MCPTransportType, i as MediaConfig, j as ToolDecision, k as ToolExecutionBudget, l as ToolFirewallConfig, m as ToolFirewallRule, n as TraceEvent } from './agent-B2okLlzq.mjs';
+import { S as SessionConfig, G as Goal, I as IToolResponseProcessor, T as ToolResponseEvaluation, a as IRouterAdapter, b as ToolCategoryInfo, R as RouterDecision, M as MCPServerConfig, c as MCPToolDefinition } from './agent-Dus44yQd.mjs';
+export { d as GoalInjector, e as GoalVerifierResult, f as MCPJsonRpcRequest, g as MCPJsonRpcResponse, h as MCPTransportType, i as MediaConfig, j as ToolDecision, k as ToolExecutionBudget, l as ToolFirewallConfig, m as ToolFirewallRule, n as TraceEvent } from './agent-Dus44yQd.mjs';
 export { LemuraAdapterError, LemuraContextOverflowError, LemuraError, LemuraMCPConnectionError, LemuraMCPError, LemuraMCPTimeoutError, LemuraMaxIterationsError, LemuraSkillInjectionError, LemuraToolNotFoundError, LemuraToolTimeoutError, LemuraToolValidationError } from './types/index.mjs';
 import { I as ILogger } from './logger-DxvKliuk.mjs';
 export { L as LogLevel, a as LogMetadata, S as Severity } from './logger-DxvKliuk.mjs';
 export { I as IRAGAdapter, R as RAGDocument, a as RAGIngestOptions, b as RAGIngestRequest, c as RAGIngestResponse, d as RAGQueryRequest, e as RAGQueryResponse, f as RAGResult } from './rag-La_Bo-J8.mjs';
-export { I as ISkill, S as SkillStrategy } from './skills-Y6D7zSSw.mjs';
+export { I as ISkill, S as SkillSelectionConfig, a as SkillStrategy } from './skills-DWCC0K1B.mjs';
 export { OpenAICompatibleAdapter, OpenAICompatibleAdapterConfig, RetryConfig } from './adapters/index.mjs';
 export { ContextManager, HistoryCompressionConfig, HistoryCompressionStrategy, InMemoryScratchpadAdapter, InMemoryStorageAdapter, SandwichCompressionConfig, SandwichCompressionStrategy, ScratchpadStrategy, SummaryInjectionConfig, SummaryInjectionStrategy } from './context/index.mjs';
 import { ToolRegistry } from './tools/index.mjs';
@@ -213,6 +213,8 @@ declare class SessionManager {
     private contextManager;
     private toolRegistry;
     private skillInjector;
+    /** True when any registered skill uses `strategy: 'progressive'`. */
+    private hasProgressiveSkills;
     private context;
     private adapter;
     private config;
@@ -428,6 +430,13 @@ declare class SessionManager {
      * @throws {LemuraMaxIterationsError} When the loop exceeds `maxIterations`
      */
     run(userMessage: string | ContentBlock[]): Promise<string>;
+    /**
+     * Resets progressive skills at the start of a turn when
+     * `skillSelection.persistence` is `'per_turn'` (the default), so each user
+     * message re-decides which skills to load from the catalog. No-op when
+     * persistence is `'session'` or there are no progressive skills.
+     */
+    private _resetProgressiveSkillsForTurn;
     /**
      * Runs the ReAct loop and streams the final assistant response token-by-token.
      *

package/dist/index.d.ts

@@ -1,12 +1,12 @@
 import { a as IProviderAdapter, d as TranscriptionRequest, e as TranscriptionResponse, f as SynthesisRequest, A as AudioChunk, V as VisionRequest, g as VisionResponse, h as ImageGenRequest, i as ImageGenResponse, M as ModelInfo, C as ContextWindow, T as Turn, j as ContentBlock, I as IToolDefinition } from './adapters-CnsgefYR.js';
 export { k as CompletionChunk, l as CompletionRequest, m as CompletionResponse, b as IContextStrategy, c as IScratchpadAdapter, n as IStorageAdapter, N as NormalizedMessage, o as STMItem, p as STMRegistryConfig, S as ShortTermMemoryRegistry, q as TokenUsage, r as ToolCall, s as ToolContext, t as ToolResult } from './adapters-CnsgefYR.js';
-import { S as SessionConfig, G as Goal, I as IToolResponseProcessor, T as ToolResponseEvaluation, a as IRouterAdapter, b as ToolCategoryInfo, R as RouterDecision, M as MCPServerConfig, c as MCPToolDefinition } from './agent-BppqfsIZ.js';
-export { d as GoalInjector, e as GoalVerifierResult, f as MCPJsonRpcRequest, g as MCPJsonRpcResponse, h as MCPTransportType, i as MediaConfig, j as ToolDecision, k as ToolExecutionBudget, l as ToolFirewallConfig, m as ToolFirewallRule, n as TraceEvent } from './agent-BppqfsIZ.js';
+import { S as SessionConfig, G as Goal, I as IToolResponseProcessor, T as ToolResponseEvaluation, a as IRouterAdapter, b as ToolCategoryInfo, R as RouterDecision, M as MCPServerConfig, c as MCPToolDefinition } from './agent-BcAg3gCz.js';
+export { d as GoalInjector, e as GoalVerifierResult, f as MCPJsonRpcRequest, g as MCPJsonRpcResponse, h as MCPTransportType, i as MediaConfig, j as ToolDecision, k as ToolExecutionBudget, l as ToolFirewallConfig, m as ToolFirewallRule, n as TraceEvent } from './agent-BcAg3gCz.js';
 export { LemuraAdapterError, LemuraContextOverflowError, LemuraError, LemuraMCPConnectionError, LemuraMCPError, LemuraMCPTimeoutError, LemuraMaxIterationsError, LemuraSkillInjectionError, LemuraToolNotFoundError, LemuraToolTimeoutError, LemuraToolValidationError } from './types/index.js';
 import { I as ILogger } from './logger-DxvKliuk.js';
 export { L as LogLevel, a as LogMetadata, S as Severity } from './logger-DxvKliuk.js';
 export { I as IRAGAdapter, R as RAGDocument, a as RAGIngestOptions, b as RAGIngestRequest, c as RAGIngestResponse, d as RAGQueryRequest, e as RAGQueryResponse, f as RAGResult } from './rag-La_Bo-J8.js';
-export { I as ISkill, S as SkillStrategy } from './skills-Y6D7zSSw.js';
+export { I as ISkill, S as SkillSelectionConfig, a as SkillStrategy } from './skills-DWCC0K1B.js';
 export { OpenAICompatibleAdapter, OpenAICompatibleAdapterConfig, RetryConfig } from './adapters/index.js';
 export { ContextManager, HistoryCompressionConfig, HistoryCompressionStrategy, InMemoryScratchpadAdapter, InMemoryStorageAdapter, SandwichCompressionConfig, SandwichCompressionStrategy, ScratchpadStrategy, SummaryInjectionConfig, SummaryInjectionStrategy } from './context/index.js';
 import { ToolRegistry } from './tools/index.js';
@@ -213,6 +213,8 @@ declare class SessionManager {
     private contextManager;
     private toolRegistry;
     private skillInjector;
+    /** True when any registered skill uses `strategy: 'progressive'`. */
+    private hasProgressiveSkills;
     private context;
     private adapter;
     private config;
@@ -428,6 +430,13 @@ declare class SessionManager {
      * @throws {LemuraMaxIterationsError} When the loop exceeds `maxIterations`
      */
     run(userMessage: string | ContentBlock[]): Promise<string>;
+    /**
+     * Resets progressive skills at the start of a turn when
+     * `skillSelection.persistence` is `'per_turn'` (the default), so each user
+     * message re-decides which skills to load from the catalog. No-op when
+     * persistence is `'session'` or there are no progressive skills.
+     */
+    private _resetProgressiveSkillsForTurn;
     /**
      * Runs the ReAct loop and streams the final assistant response token-by-token.
      *

package/dist/index.js

@@ -1183,7 +1183,7 @@ var MediaBridge = class {
 };
 
 // src/skills/SkillInjector.ts
-var SkillInjector = class {
+var SkillInjector = class _SkillInjector {
   skills = [];
   constructor(skills = []) {
     this.skills = skills.map((s) => this._normalise(s));
@@ -1199,14 +1199,22 @@ var SkillInjector = class {
   sortSkills() {
     this.skills.sort((a, b) => a.priority - b.priority);
   }
+  /**
+   * Strategies whose skills form an opt-in pool — inactive until explicitly
+   * enabled. Both `dynamic` (host-enabled) and `progressive` (model-enabled via
+   * the `load_skill` tool) behave this way.
+   */
+  _isPoolStrategy(strategy) {
+    return strategy === "dynamic" || strategy === "progressive";
+  }
   /**
    * Normalises a skill to ensure consistent defaults.
-   * For dynamic skills, `enabled` defaults to `false` unless explicitly set.
-   * For fixed skills (or those without a strategy), `enabled` is ignored.
+   * For pool skills (`dynamic` / `progressive`), `enabled` defaults to `false`
+   * unless explicitly set. For `fixed` skills, `enabled` is ignored.
    */
   _normalise(skill) {
     const strategy = skill.strategy ?? "fixed";
-    const enabled = strategy === "dynamic" ? skill.enabled ?? false : true;
+    const enabled = this._isPoolStrategy(strategy) ? skill.enabled ?? false : true;
     return { ...skill, strategy, enabled };
   }
   // -----------------------------------------------------------------------
@@ -1218,42 +1226,76 @@ var SkillInjector = class {
    */
   enableSkill(name) {
     const skill = this.skills.find((s) => s.name === name);
-    if (skill && skill.strategy === "dynamic") {
+    if (skill && this._isPoolStrategy(skill.strategy)) {
       skill.enabled = true;
     }
   }
   /**
-   * Disable a dynamic skill by name.
+   * Disable a pool skill (`dynamic` or `progressive`) by name.
    * Has no effect on fixed skills.
    */
   disableSkill(name) {
     const skill = this.skills.find((s) => s.name === name);
-    if (skill && skill.strategy === "dynamic") {
+    if (skill && this._isPoolStrategy(skill.strategy)) {
       skill.enabled = false;
     }
   }
   /**
-   * Enable all dynamic skills whose `tags` array intersects with `tags`.
+   * Enable all pool skills (`dynamic` / `progressive`) whose `tags` array
+   * intersects with `tags`.
    */
   enableByTags(tags) {
     const tagSet = new Set(tags);
     for (const skill of this.skills) {
-      if (skill.strategy === "dynamic" && skill.tags?.some((t) => tagSet.has(t))) {
+      if (this._isPoolStrategy(skill.strategy) && skill.tags?.some((t) => tagSet.has(t))) {
         skill.enabled = true;
       }
     }
   }
   /**
-   * Disable all dynamic skills whose `tags` array intersects with `tags`.
+   * Disable all pool skills (`dynamic` / `progressive`) whose `tags` array
+   * intersects with `tags`.
    */
   disableByTags(tags) {
     const tagSet = new Set(tags);
     for (const skill of this.skills) {
-      if (skill.strategy === "dynamic" && skill.tags?.some((t) => tagSet.has(t))) {
+      if (this._isPoolStrategy(skill.strategy) && skill.tags?.some((t) => tagSet.has(t))) {
+        skill.enabled = false;
+      }
+    }
+  }
+  /**
+   * Disable every progressive skill. Called by SessionManager between turns when
+   * `skillSelection.persistence` is `'per_turn'` so each turn re-decides from the
+   * catalog. Has no effect on `fixed` or `dynamic` skills.
+   *
+   * @since 1.7.0
+   */
+  resetProgressiveSkills() {
+    for (const skill of this.skills) {
+      if (skill.strategy === "progressive") {
         skill.enabled = false;
       }
     }
   }
+  /**
+   * Returns all progressive skills, regardless of enabled state. Used to detect
+   * whether the catalog / `load_skill` machinery should be activated.
+   *
+   * @since 1.7.0
+   */
+  getProgressiveSkills() {
+    return this.skills.filter((s) => s.strategy === "progressive");
+  }
+  /**
+   * Number of currently-enabled progressive skills. Used to enforce
+   * `skillSelection.maxConcurrent`.
+   *
+   * @since 1.7.0
+   */
+  countEnabledProgressive() {
+    return this.skills.filter((s) => s.strategy === "progressive" && s.enabled === true).length;
+  }
   // -----------------------------------------------------------------------
   // Queries
   // -----------------------------------------------------------------------
@@ -1292,8 +1334,45 @@ var SkillInjector = class {
     return [...tools];
   }
   _isActive(skill) {
-    return skill.strategy !== "dynamic" || skill.enabled === true;
+    return !this._isPoolStrategy(skill.strategy) || skill.enabled === true;
+  }
+  // -----------------------------------------------------------------------
+  // Catalog builder (progressive skills)
+  // -----------------------------------------------------------------------
+  /**
+   * Builds a compact `name: description` catalog of all progressive skills, with
+   * an instructional preamble telling the agent to call `load_skill` for relevant
+   * entries. SessionManager appends this to the system prompt so the model can
+   * decide which skills to pull in — full content is injected only on `load_skill`.
+   *
+   * Returns an empty string when there are no progressive skills (the catalog and
+   * `load_skill` tool are then never activated).
+   *
+   * @param header - Optional override for the instructional preamble.
+   * @returns The catalog block, or `''` when no progressive skills exist.
+   *
+   * @since 1.7.0
+   *
+   * @example
+   * ```typescript
+   * const catalog = injector.buildCatalog();
+   * // You have access to specialized skills...
+   * // Available skills:
+   * // - summarize: Condenses text or documents concisely.
+   * ```
+   */
+  buildCatalog(header) {
+    const progressive = this.getProgressiveSkills();
+    if (progressive.length === 0) return "";
+    const preamble = header ?? _SkillInjector.DEFAULT_CATALOG_HEADER;
+    const lines = progressive.map((s) => `- ${s.name}: ${s.description}`);
+    return `${preamble}
+
+Available skills:
+${lines.join("\n")}`;
   }
+  /** Default instructional preamble for the progressive-skill catalog. */
+  static DEFAULT_CATALOG_HEADER = "You have access to specialized skills. Each provides focused guidance for a particular kind of request. When a skill is relevant to the user's message, call the `load_skill` tool with its name BEFORE answering \u2014 its full instructions will then be injected for you to follow. Load only what is relevant; skip it for small talk or unrelated questions.";
   // -----------------------------------------------------------------------
   // Injection block builder
   // -----------------------------------------------------------------------
@@ -1731,6 +1810,42 @@ function createMediaTools(prefix = defaultPrefix) {
   return [transcribeTool, synthesizeTool, visionTool, imageGenTool];
 }
 
+// src/tools/builtin/load_skill.ts
+var LOAD_SKILL_TOOL_NAME = "load_skill";
+function createLoadSkillTool(injector, config, onLoad) {
+  const progressiveNames = injector.getProgressiveSkills().map((s) => s.name);
+  return {
+    name: LOAD_SKILL_TOOL_NAME,
+    description: `Load a specialized skill by name to get its full instructions for the current turn. Call this when the user's request matches a skill listed in the "Available skills" catalog in your system prompt. Loading a skill injects its detailed guidance, which you should then follow.`,
+    category: "utility",
+    parameters: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "The skill name, exactly as listed in the Available skills catalog.",
+          enum: progressiveNames
+        }
+      },
+      required: ["name"]
+    },
+    async execute(params) {
+      const name = params?.name;
+      if (!name || !progressiveNames.includes(name)) {
+        return `No progressive skill named "${name}". Available: ${progressiveNames.join(", ") || "(none)"}.`;
+      }
+      const max = config?.maxConcurrent;
+      const alreadyEnabled = injector.getActiveSkills().some((s) => s.name === name && s.strategy === "progressive");
+      if (max !== void 0 && !alreadyEnabled && injector.countEnabledProgressive() >= max) {
+        return `Cannot load "${name}": at most ${max} skill(s) may be active at once. Finish or skip a loaded skill first.`;
+      }
+      injector.enableSkill(name);
+      onLoad?.(name);
+      return `Skill "${name}" loaded. Follow its instructions for this response.`;
+    }
+  };
+}
+
 // src/agent/execution/StepCounter.ts
 var StepCounter = class {
   constructor(maxSteps = 20) {
@@ -2693,6 +2808,8 @@ var SessionManager = class {
   contextManager;
   toolRegistry;
   skillInjector;
+  /** True when any registered skill uses `strategy: 'progressive'`. */
+  hasProgressiveSkills = false;
   context;
   adapter;
   config;
@@ -2787,6 +2904,17 @@ var SessionManager = class {
         this.toolRegistry.register(tool);
       }
     }
+    this.hasProgressiveSkills = this.skillInjector.getProgressiveSkills().length > 0;
+    if (this.hasProgressiveSkills) {
+      this.toolRegistry.register(
+        createLoadSkillTool(
+          this.skillInjector,
+          config.skillSelection,
+          // Trace the model's selection decision as a first-class skill event.
+          (name) => this.emitTrace("skill", "skill_enable", { name, source: "load_skill" })
+        )
+      );
+    }
     this.context = {
       systemPrompt: config.systemPrompt || "",
       scratchpad: "",
@@ -2812,11 +2940,12 @@ var SessionManager = class {
       skills: {
         total: (config.skills || []).length,
         active: activeSkills.length,
-        fixed: activeSkills.filter((s) => s.strategy !== "dynamic").length,
-        dynamic: activeSkills.filter((s) => s.strategy === "dynamic").length
+        fixed: activeSkills.filter((s) => s.strategy === "fixed" || s.strategy === void 0).length,
+        dynamic: activeSkills.filter((s) => s.strategy === "dynamic").length,
+        progressive: this.skillInjector.getProgressiveSkills().length
       }
     });
-    for (const skill of activeSkills) {
+    for (const skill of this.skillInjector.getAll()) {
       this.emitTrace("skill", "skill_load", {
         name: skill.name,
         version: skill.version,
@@ -2824,7 +2953,8 @@ var SessionManager = class {
         inject: skill.inject,
         priority: skill.priority,
         tags: skill.tags ?? [],
-        requiredTools: skill.requiredTools ?? []
+        requiredTools: skill.requiredTools ?? [],
+        enabled: skill.enabled === true
       });
     }
   }
@@ -3237,6 +3367,12 @@ Which pending sub-goals are now fully completed?`
   /** Builds the system prompt, injecting skills and goal if configured. */
   buildSystemPrompt(userMessage, iteration = 0) {
     let prompt = this.context.systemPrompt || "";
+    if (this.hasProgressiveSkills) {
+      const catalog = this.skillInjector.buildCatalog(
+        this.config.skillSelection?.catalogHeader
+      );
+      if (catalog) prompt += "\n\n" + catalog;
+    }
     const isStatic = this.config.staticSystemPrompt === true;
     if (!isStatic && this.goalInjector && this.config.goalInjectionPosition !== "pre_turn") {
       const shouldInject = this.goalInjector.shouldInjectThisTurn(
@@ -3264,6 +3400,10 @@ ${planStatus}`;
     );
     if (injectedSkills) {
       prompt += "\n\n" + injectedSkills;
+      const poolInjected = this.skillInjector.getSkillsForInjection("system_prompt").filter((s) => s.strategy === "dynamic" || s.strategy === "progressive").map((s) => s.name);
+      if (poolInjected.length > 0) {
+        this.emitTrace("skill", "skill_inject", { skills: poolInjected, position: "system_prompt" });
+      }
     }
     return prompt.trim();
   }
@@ -3450,6 +3590,9 @@ ${blocks.join("\n\n")}
    * Returns true to proceed, false to block.
    */
   async passesFirewall(toolName, argsJson, toolCallId, toolResults) {
+    if (toolName === LOAD_SKILL_TOOL_NAME && this.hasProgressiveSkills) {
+      return true;
+    }
     const firewall = evaluateToolFirewall(
       this.config.toolFirewall,
       toolName,
@@ -3649,8 +3792,25 @@ ${blocks.join("\n\n")}
   async run(userMessage) {
     if (this.mcpReady) await this.mcpReady;
     await this.ensureScratchpadLoaded();
+    this._resetProgressiveSkillsForTurn();
     return this._executeLoop(userMessage, { label: "run" });
   }
+  /**
+   * Resets progressive skills at the start of a turn when
+   * `skillSelection.persistence` is `'per_turn'` (the default), so each user
+   * message re-decides which skills to load from the catalog. No-op when
+   * persistence is `'session'` or there are no progressive skills.
+   */
+  _resetProgressiveSkillsForTurn() {
+    if (!this.hasProgressiveSkills) return;
+    const persistence = this.config.skillSelection?.persistence ?? "per_turn";
+    if (persistence !== "per_turn") return;
+    const cleared = this.skillInjector.getProgressiveSkills().filter((s) => s.enabled === true).map((s) => s.name);
+    this.skillInjector.resetProgressiveSkills();
+    if (cleared.length > 0) {
+      this.emitTrace("skill", "skill_reset", { skills: cleared, reason: "per_turn" });
+    }
+  }
   /**
    * Runs the ReAct loop and streams the final assistant response token-by-token.
    *
@@ -3670,6 +3830,7 @@ ${blocks.join("\n\n")}
   async *stream(userMessage) {
     if (this.mcpReady) await this.mcpReady;
     await this.ensureScratchpadLoaded();
+    this._resetProgressiveSkillsForTurn();
     const userMessageStr = Array.isArray(userMessage) ? "[Multimodal Content]" : userMessage;
     this.logger.info(`Starting streaming session run`, { model: this.config.model, message: userMessageStr });
     const routeDecision = await this._runRoutingStep(userMessageStr);