feat: proactive skill suggestions via dream skill gap detection (#55)

Adds a new dream pass — skill gap detection — that reviews the
accumulated conversation log for recurring request patterns and saves
new skills directly to the skill store before the existing skill
consolidation pass runs (which deduplicates them automatically).

- DreamOptions: SkillGapEnabled (default true) + SkillGapDirectivePath
- DreamService: RunSkillGapDetectionPassAsync runs between memory
  consolidation and skill consolidation; loads directive from file or
  built-in fallback; groups log entries by session; lists existing
  skills so the LLM avoids duplicates; parses { "toSave": [...] } JSON
- BuiltInSkillGapDirective enforces 2-occurrence threshold, name/
  summary/content format rules, and an empty-result contract
- SkillGapResultDto / SkillGapEntryDto DTOs alongside existing DTOs

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: rockfordlhotka

src/RockBot.Host.Abstractions/DreamOptions.cs

@@ -42,4 +42,13 @@ public sealed class DreamOptions
     /// When the file does not exist, a built-in fallback directive is used.
     /// </summary>
     public string PreferenceDirectivePath { get; set; } = "pref-dream.md";
+
+    /// <summary>Whether the skill gap detection pass is enabled.</summary>
+    public bool SkillGapEnabled { get; set; } = true;
+
+    /// <summary>
+    /// Path to the skill gap detection directive file, relative to <see cref="AgentProfileOptions.BasePath"/>.
+    /// When the file does not exist, a built-in fallback directive is used.
+    /// </summary>
+    public string SkillGapDirectivePath { get; set; } = "skill-gap.md";
 }

src/RockBot.Host/DreamService.cs

@@ -33,6 +33,7 @@ internal sealed class DreamService : IHostedService, IDisposable
     private string? _skillDreamDirective;
     private string? _skillOptimizeDirective;
     private string? _prefDreamDirective;
+    private string? _skillGapDirective;
 
     public DreamService(
         ILongTermMemory memory,
@@ -120,6 +121,19 @@ public Task StartAsync(CancellationToken cancellationToken)
                 _logger.LogInformation("DreamService: loaded pref directive from {Path}", prefDirectivePath);
         }
 
+        if (_skillStore is not null && _conversationLog is not null)
+        {
+            var skillGapDirectivePath = ResolvePath(_options.SkillGapDirectivePath, _profileOptions.BasePath);
+            _skillGapDirective = File.Exists(skillGapDirectivePath)
+                ? File.ReadAllText(skillGapDirectivePath)
+                : BuiltInSkillGapDirective;
+
+            if (!File.Exists(skillGapDirectivePath))
+                _logger.LogWarning("DreamService: skill gap directive not found at {Path}; using built-in fallback", skillGapDirectivePath);
+            else
+                _logger.LogInformation("DreamService: loaded skill gap directive from {Path}", skillGapDirectivePath);
+        }
+
         _timer = new Timer(
             state => { _ = DreamAsync(); },
             null,
@@ -280,6 +294,9 @@ private async Task DreamAsync()
                     entry.Id, entry.Category ?? "(none)", entry.Content);
             }
 
+            if (_skillStore is not null)
+                await RunSkillGapDetectionPassAsync();
+
             if (_skillStore is not null)
                 await ConsolidateSkillsAsync();
 
@@ -682,6 +699,97 @@ private async Task OptimizeSkillsAsync()
             deleted, saved);
     }
 
+    /// <summary>
+    /// Scans the conversation log for recurring request patterns that would benefit
+    /// from a reusable skill and saves any discovered skills directly to the skill store.
+    /// Runs before skill consolidation so that the consolidation pass can deduplicate
+    /// any new skills alongside existing ones.
+    /// </summary>
+    private async Task RunSkillGapDetectionPassAsync()
+    {
+        if (_conversationLog is null || _skillStore is null || !_options.SkillGapEnabled)
+            return;
+
+        var entries = await _conversationLog.ReadAllAsync();
+        if (entries.Count == 0)
+        {
+            _logger.LogDebug("DreamService: skill gap detection — no log entries; skipping");
+            return;
+        }
+
+        var existingSkills = await _skillStore.ListAsync();
+
+        _logger.LogInformation(
+            "DreamService: skill gap detection pass — {EntryCount} log entries, {SkillCount} existing skills",
+            entries.Count, existingSkills.Count);
+
+        // Build user message: turns grouped by session + existing skill catalog
+        var userMessage = new StringBuilder();
+        userMessage.AppendLine("Review the following conversation log for recurring request patterns:");
+        userMessage.AppendLine();
+
+        var bySession = entries
+            .GroupBy(e => e.SessionId)
+            .ToDictionary(g => g.Key, g => g.ToList());
+
+        foreach (var (sessionId, sessionEntries) in bySession)
+        {
+            userMessage.AppendLine($"## Session: {sessionId}");
+            foreach (var e in sessionEntries)
+                userMessage.AppendLine($"[{e.Role}] {e.Content}");
+            userMessage.AppendLine();
+        }
+
+        if (existingSkills.Count > 0)
+        {
+            userMessage.AppendLine("## Existing skills (do not duplicate these):");
+            foreach (var s in existingSkills)
+                userMessage.AppendLine($"- {s.Name}: {s.Summary}");
+            userMessage.AppendLine();
+        }
+
+        var messages = new List<ChatMessage>
+        {
+            new(ChatRole.System, _skillGapDirective ?? BuiltInSkillGapDirective),
+            new(ChatRole.User, userMessage.ToString())
+        };
+
+        var response = await _llmClient.GetResponseAsync(messages, new ChatOptions());
+        var raw = response.Text?.Trim() ?? string.Empty;
+        var json = ExtractJsonObject(raw);
+
+        if (string.IsNullOrEmpty(json))
+        {
+            _logger.LogWarning("DreamService: skill gap LLM returned no parseable JSON; skipping");
+            return;
+        }
+
+        _logger.LogDebug("DreamService: skill gap JSON ({Length} chars): {Json}", json.Length, json);
+
+        var result = JsonSerializer.Deserialize<SkillGapResultDto>(json, JsonOptions);
+        var saved = 0;
+
+        foreach (var dto in result?.ToSave ?? [])
+        {
+            if (string.IsNullOrWhiteSpace(dto.Name) || string.IsNullOrWhiteSpace(dto.Content))
+                continue;
+
+            var skill = new Skill(
+                Name: dto.Name.Trim(),
+                Summary: dto.Summary?.Trim() ?? string.Empty,
+                Content: dto.Content.Trim(),
+                CreatedAt: DateTimeOffset.UtcNow,
+                UpdatedAt: DateTimeOffset.UtcNow,
+                LastUsedAt: null);
+
+            await _skillStore.SaveAsync(skill);
+            saved++;
+            _logger.LogDebug("DreamService: skill gap created new skill '{Name}'", skill.Name);
+        }
+
+        _logger.LogInformation("DreamService: skill gap detection complete — {Saved} new skill(s) created", saved);
+    }
+
     /// <summary>
     /// Analyzes the accumulated conversation log for durable user preference patterns
     /// and saves inferred preferences as tagged memory entries.
@@ -866,6 +974,27 @@ Only improve skills where the failure is clearly addressable by better instructi
         If no improvements are warranted, return: { "toDelete": [], "toSave": [] }
         """;
 
+    private const string BuiltInSkillGapDirective = """
+        You are a skill gap detection assistant. Review the conversation log for recurring request
+        patterns that would benefit from a reusable skill.
+
+        Only suggest a new skill when the same type of request appears 2 or more times across
+        different sessions, or with clear recurring intent in a single session.
+
+        Existing skills are listed below — do not suggest skills already adequately covered by them.
+
+        Return ONLY a JSON object:
+        { "toSave": [ { "name": "...", "summary": "...", "content": "..." } ] }
+
+        Rules:
+        - name: short, lowercase, hyphen-separated (e.g. "summarize-emails", "daily-standup")
+        - summary: one sentence, 15 words or fewer
+        - content: step-by-step instructions the agent should follow when executing this skill
+        - Only suggest skills with clear, repeatable value across sessions
+
+        If no recurring patterns warrant a new skill, return: { "toSave": [] }
+        """;
+
     private const string BuiltInPrefDirective = """
         You are a user preference inference assistant. Review the conversation log for durable, recurring preference patterns.
         Look for: formatting preferences, comment style, tool corrections, topic clusters, and communication style signals.
@@ -913,4 +1042,8 @@ private sealed record PrefEntryDto(
         string? Category,
         IReadOnlyList<string>? Tags,
         IReadOnlyDictionary<string, string>? Metadata);
+
+    private sealed record SkillGapResultDto(List<SkillGapEntryDto>? ToSave);
+
+    private sealed record SkillGapEntryDto(string Name, string? Summary, string Content);
 }