feat(worker): resolve and seed session skills before each run

tests/ClaudeDo.Worker.Tests/External/AddSubtaskToolTests.cs

@@ -69,7 +69,7 @@ public sealed class AddSubtaskToolTests : IDisposable
         var argsBuilder = new ClaudeArgsBuilder();
         var state = TaskStateServiceBuilder.Build(dbFactory).State;
         var runner = new TaskRunner(fake, dbFactory, broadcaster, wtManager, argsBuilder, cfg,
-            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore());
+            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore(), new FakeSessionSkillSeeder());
         var waker = new ClaudeDo.Worker.Queue.QueueWaker();
         var picker = new ClaudeDo.Worker.Queue.QueuePicker(dbFactory);
         var overrideSlot = new OverrideSlotService(dbFactory, runner, NullLogger<OverrideSlotService>.Instance);

tests/ClaudeDo.Worker.Tests/External/BatchMcpToolsTests.cs

@@ -87,7 +87,7 @@ public sealed class BatchMcpToolsTests : IDisposable
         var wtManager = new WorktreeManager(new GitService(), dbFactory, cfg, NullLogger<WorktreeManager>.Instance);
         var state = TaskStateServiceBuilder.Build(dbFactory).State;
         var runner = new TaskRunner(new FakeClaudeProcess(), dbFactory, broadcaster, wtManager, new ClaudeArgsBuilder(), cfg,
-            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore());
+            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore(), new FakeSessionSkillSeeder());
         var overrideSlot = new OverrideSlotService(dbFactory, runner, NullLogger<OverrideSlotService>.Instance);
         return new QueueService(dbFactory, runner, cfg, NullLogger<QueueService>.Instance,
             new QueueWaker(), new QueuePicker(dbFactory), overrideSlot, state);

tests/ClaudeDo.Worker.Tests/External/ExternalMcpServiceTests.cs

@@ -149,7 +149,7 @@ public sealed class ExternalMcpServiceTests : IDisposable
         var argsBuilder = new ClaudeArgsBuilder();
         var state = TaskStateServiceBuilder.Build(dbFactory).State;
         var runner = new TaskRunner(fake, dbFactory, broadcaster, wtManager, argsBuilder, cfg,
-            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore());
+            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore(), new FakeSessionSkillSeeder());
         var waker = new ClaudeDo.Worker.Queue.QueueWaker();
         var picker = new ClaudeDo.Worker.Queue.QueuePicker(dbFactory);
         var overrideSlot = new OverrideSlotService(dbFactory, runner, NullLogger<OverrideSlotService>.Instance);

tests/ClaudeDo.Worker.Tests/Infrastructure/FakeSessionSkillSeeder.cs

@@ -0,0 +1,18 @@
+using System.Collections.Concurrent;
+using ClaudeDo.Worker.Skills;
+
+namespace ClaudeDo.Worker.Tests.Infrastructure;
+
+public sealed class FakeSessionSkillSeeder : ISessionSkillSeeder
+{
+    public int CallCount;
+    public readonly record struct Call(string WorkingDir, IReadOnlyList<string> SkillNames, bool IsWorktree);
+    public readonly ConcurrentQueue<Call> Calls = new();
+
+    public Task SeedAsync(string workingDir, IReadOnlyList<string> skillNames, bool isWorktree, CancellationToken ct)
+    {
+        Interlocked.Increment(ref CallCount);
+        Calls.Enqueue(new Call(workingDir, skillNames, isWorktree));
+        return Task.CompletedTask;
+    }
+}

tests/ClaudeDo.Worker.Tests/Runner/ContinueAsyncExceptionTests.cs

@@ -36,7 +36,7 @@ public sealed class ContinueAsyncExceptionTests : IDisposable
         var state = TaskStateServiceBuilder.Build(dbFactory).State;
         var wt = new WorktreeManager(new ClaudeDo.Data.Git.GitService(), dbFactory, _cfg, NullLogger<WorktreeManager>.Instance);
         return new TaskRunner(claude, dbFactory, broadcaster, wt, new ClaudeArgsBuilder(), _cfg,
-            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore());
+            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore(), new FakeSessionSkillSeeder());
     }
 
     [Fact]

tests/ClaudeDo.Worker.Tests/Runner/SkillResolutionTests.cs

@@ -0,0 +1,44 @@
+using ClaudeDo.Worker.Runner;
+using Xunit;
+
+namespace ClaudeDo.Worker.Tests.Runner;
+
+public class SkillResolutionTests
+{
+    [Fact]
+    public void Null_and_empty_sources_contribute_nothing()
+        => Assert.Empty(TaskRunner.UnionSkillNames(null, "", "   ", "[]"));
+
+    [Fact]
+    public void Single_source_is_returned_in_order()
+        => Assert.Equal(["a", "b"], TaskRunner.UnionSkillNames("""["a","b"]"""));
+
+    [Fact]
+    public void Unions_across_task_list_global_levels()
+    {
+        var result = TaskRunner.UnionSkillNames("""["a"]""", """["b"]""", """["c"]""");
+        Assert.Equal(["a", "b", "c"], result);
+    }
+
+    [Fact]
+    public void Dedups_ordinal_preserving_first_occurrence_order()
+    {
+        var result = TaskRunner.UnionSkillNames("""["a","b"]""", """["b","c"]""", """["a","d"]""");
+        Assert.Equal(["a", "b", "c", "d"], result);
+    }
+
+    [Fact]
+    public void Dedup_is_case_sensitive_ordinal()
+    {
+        var result = TaskRunner.UnionSkillNames("""["Foo"]""", """["foo"]""");
+        Assert.Equal(["Foo", "foo"], result);
+    }
+
+    [Fact]
+    public void Malformed_json_is_ignored_not_thrown()
+        => Assert.Equal(["a"], TaskRunner.UnionSkillNames("not json", """["a"]"""));
+
+    [Fact]
+    public void Blank_entries_within_array_are_skipped()
+        => Assert.Equal(["a"], TaskRunner.UnionSkillNames("""["a", "", "   ", null]"""));
+}

tests/ClaudeDo.Worker.Tests/Runner/SkillSeedingWireTests.cs

@@ -0,0 +1,141 @@
+using ClaudeDo.Data;
+using ClaudeDo.Data.Git;
+using ClaudeDo.Data.Models;
+using ClaudeDo.Data.Repositories;
+using ClaudeDo.Worker.Config;
+using ClaudeDo.Worker.Hub;
+using ClaudeDo.Worker.Runner;
+using ClaudeDo.Worker.Tests.Infrastructure;
+using Microsoft.Extensions.Logging.Abstractions;
+using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
+using Xunit;
+
+namespace ClaudeDo.Worker.Tests.Runner;
+
+/// Verifies that ResolveConfigAsync's skill resolution (union of task/list/global,
+/// filtered to what's actually installed in the registry) reaches the seeder call
+/// before Claude is invoked.
+public sealed class SkillSeedingWireTests : IDisposable
+{
+    private readonly DbFixture _db = new();
+    private readonly string _tempDir;
+    private readonly WorkerConfig _cfg;
+
+    public SkillSeedingWireTests()
+    {
+        _tempDir = Path.Combine(Path.GetTempPath(), $"cd_skillwire_{Guid.NewGuid():N}");
+        Directory.CreateDirectory(_tempDir);
+        _cfg = new WorkerConfig { SandboxRoot = _tempDir, LogRoot = _tempDir };
+    }
+
+    public void Dispose() { _db.Dispose(); try { Directory.Delete(_tempDir, true); } catch { } }
+
+    private (TaskRunner Runner, FakeSessionSkillSeeder Seeder) BuildRunner()
+    {
+        var dbFactory = _db.CreateFactory();
+        var state = TaskStateServiceBuilder.Build(dbFactory).State;
+        var wt = new WorktreeManager(new GitService(), dbFactory, _cfg, NullLogger<WorktreeManager>.Instance);
+        var fake = new FakeClaudeProcess((_, _, _, _, _) =>
+            Task.FromResult(new RunResult { ExitCode = 0, ResultMarkdown = "ok" }));
+        var seeder = new FakeSessionSkillSeeder();
+        var runner = new TaskRunner(fake, dbFactory, new HubBroadcaster(new CapturingHubContext()), wt,
+            new ClaudeArgsBuilder(), _cfg, NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(),
+            new AttachmentStore(), seeder);
+        return (runner, seeder);
+    }
+
+    private async Task SeedInstalledSkillAsync(string name)
+    {
+        using var ctx = _db.CreateContext();
+        await new SessionSkillRepository(ctx).UpsertAsync(new SessionSkillEntity
+        {
+            Name = name,
+            SourceUrl = "https://example.test/repo.git",
+            PinnedRef = "deadbeef",
+            Subpath = $"skills/{name}",
+            Description = "test skill",
+            AddedAt = DateTimeOffset.UtcNow,
+        });
+    }
+
+    [Fact]
+    public async Task Union_of_task_list_global_skills_reaches_seeder_when_all_installed()
+    {
+        await SeedInstalledSkillAsync("alpha");
+        await SeedInstalledSkillAsync("beta");
+        await SeedInstalledSkillAsync("gamma");
+
+        var dbFactory = _db.CreateFactory();
+        using (var ctx = _db.CreateContext())
+        {
+            ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", WorkingDir = null, CreatedAt = DateTime.UtcNow });
+            ctx.ListConfigs.Add(new ListConfigEntity { ListId = "l1", SessionSkills = """["beta"]""" });
+            ctx.Tasks.Add(new TaskEntity
+            {
+                Id = "t1", ListId = "l1", Title = "Task", Status = TaskStatus.Idle,
+                CreatedAt = DateTime.UtcNow, SessionSkills = """["alpha"]""",
+            });
+            // AppSettingsRepository.UpdateAsync doesn't round-trip SessionSkills yet (out of
+            // scope here), so seed the singleton row directly.
+            await new AppSettingsRepository(ctx).GetAsync();
+            ctx.AppSettings.First(s => s.Id == AppSettingsEntity.SingletonId).SessionSkills = """["gamma"]""";
+            await ctx.SaveChangesAsync();
+        }
+
+        var (runner, seeder) = BuildRunner();
+        using (var ctx = _db.CreateContext())
+            await runner.RunAsync((await new TaskRepository(ctx).GetByIdAsync("t1"))!, "slot-1", CancellationToken.None);
+
+        Assert.Single(seeder.Calls);
+        var call = seeder.Calls.Single();
+        Assert.Equal(["alpha", "beta", "gamma"], call.SkillNames);
+        Assert.False(call.IsWorktree);
+    }
+
+    [Fact]
+    public async Task Unknown_skill_names_are_dropped_before_seeding()
+    {
+        await SeedInstalledSkillAsync("known");
+
+        var dbFactory = _db.CreateFactory();
+        using (var ctx = _db.CreateContext())
+        {
+            ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", WorkingDir = null, CreatedAt = DateTime.UtcNow });
+            ctx.Tasks.Add(new TaskEntity
+            {
+                Id = "t1", ListId = "l1", Title = "Task", Status = TaskStatus.Idle,
+                CreatedAt = DateTime.UtcNow, SessionSkills = """["known","not-installed"]""",
+            });
+            await ctx.SaveChangesAsync();
+        }
+
+        var (runner, seeder) = BuildRunner();
+        using (var ctx = _db.CreateContext())
+            await runner.RunAsync((await new TaskRepository(ctx).GetByIdAsync("t1"))!, "slot-1", CancellationToken.None);
+
+        Assert.Single(seeder.Calls);
+        Assert.Equal(["known"], seeder.Calls.Single().SkillNames);
+    }
+
+    [Fact]
+    public async Task No_skills_configured_seeds_empty_list()
+    {
+        var dbFactory = _db.CreateFactory();
+        using (var ctx = _db.CreateContext())
+        {
+            ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", WorkingDir = null, CreatedAt = DateTime.UtcNow });
+            ctx.Tasks.Add(new TaskEntity
+            {
+                Id = "t1", ListId = "l1", Title = "Task", Status = TaskStatus.Idle, CreatedAt = DateTime.UtcNow,
+            });
+            await ctx.SaveChangesAsync();
+        }
+
+        var (runner, seeder) = BuildRunner();
+        using (var ctx = _db.CreateContext())
+            await runner.RunAsync((await new TaskRepository(ctx).GetByIdAsync("t1"))!, "slot-1", CancellationToken.None);
+
+        Assert.Single(seeder.Calls);
+        Assert.Empty(seeder.Calls.Single().SkillNames);
+    }
+}

tests/ClaudeDo.Worker.Tests/Runner/StandaloneChildrenRoutingTests.cs

@@ -45,7 +45,7 @@ public sealed class StandaloneChildrenRoutingTests : IDisposable
         var state = TaskStateServiceBuilder.Build(dbFactory).State;
         var wt = new WorktreeManager(new GitService(), dbFactory, _cfg, NullLogger<WorktreeManager>.Instance);
         var runner = new TaskRunner(fake, dbFactory, broadcaster, wt, new ClaudeArgsBuilder(), _cfg,
-            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore());
+            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore(), new FakeSessionSkillSeeder());
 
         using (var ctx = _db.CreateContext())
             await runner.RunAsync((await new TaskRepository(ctx).GetByIdAsync("p1"))!, "slot-1", default, alreadyClaimed: true);
@@ -72,7 +72,7 @@ public sealed class StandaloneChildrenRoutingTests : IDisposable
         var state = TaskStateServiceBuilder.Build(dbFactory).State;
         var wt = new WorktreeManager(new GitService(), dbFactory, _cfg, NullLogger<WorktreeManager>.Instance);
         var runner = new TaskRunner(fake, dbFactory, new HubBroadcaster(new CapturingHubContext()), wt,
-            new ClaudeArgsBuilder(), _cfg, NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore());
+            new ClaudeArgsBuilder(), _cfg, NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore(), new FakeSessionSkillSeeder());
 
         using (var ctx = _db.CreateContext())
             await runner.RunAsync((await new TaskRepository(ctx).GetByIdAsync("solo"))!, "slot-1", default, alreadyClaimed: true);

tests/ClaudeDo.Worker.Tests/Runner/StartRunningGuardTests.cs

@@ -33,7 +33,7 @@ public sealed class StartRunningGuardTests : IDisposable
         var state = TaskStateServiceBuilder.Build(dbFactory).State;
         var wt = new WorktreeManager(new ClaudeDo.Data.Git.GitService(), dbFactory, _cfg, NullLogger<WorktreeManager>.Instance);
         return new TaskRunner(claude, dbFactory, new HubBroadcaster(new CapturingHubContext()), wt,
-            new ClaudeArgsBuilder(), _cfg, NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore());
+            new ClaudeArgsBuilder(), _cfg, NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore(), new FakeSessionSkillSeeder());
     }
 
     [Fact]

tests/ClaudeDo.Worker.Tests/Services/QueueServiceSlotGuardTests.cs

@@ -54,7 +54,7 @@ public sealed class QueueServiceSlotGuardTests : IDisposable
         var argsBuilder = new ClaudeArgsBuilder();
         var state = TaskStateServiceBuilder.Build(dbFactory).State;
         var runner = new TaskRunner(fake, dbFactory, broadcaster, wtManager, argsBuilder, _cfg,
-            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore());
+            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore(), new FakeSessionSkillSeeder());
         _waker = new QueueWaker();
         var picker = new QueuePicker(dbFactory);
         var overrideSlot = new OverrideSlotService(dbFactory, runner, NullLogger<OverrideSlotService>.Instance);

tests/ClaudeDo.Worker.Tests/Services/QueueServiceTests.cs

@@ -55,7 +55,7 @@ public sealed class QueueServiceTests : IDisposable
         var argsBuilder = new ClaudeArgsBuilder();
         var state = TaskStateServiceBuilder.Build(dbFactory).State;
         var runner = new TaskRunner(fake, dbFactory, broadcaster, wtManager, argsBuilder, _cfg,
-            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore());
+            NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(), new AttachmentStore(), new FakeSessionSkillSeeder());
         _waker = new QueueWaker();
         var picker = new QueuePicker(dbFactory);
         var overrideSlot = new OverrideSlotService(dbFactory, runner, NullLogger<OverrideSlotService>.Instance);

tests/ClaudeDo.Worker.Tests/Skills/SessionSkillSeederTests.cs

@@ -0,0 +1,135 @@
+using ClaudeDo.Worker.Skills;
+using ClaudeDo.Worker.Tests.Infrastructure;
+using Microsoft.Extensions.Logging.Abstractions;
+using Xunit;
+
+namespace ClaudeDo.Worker.Tests.Skills;
+
+public sealed class SessionSkillSeederTests : IDisposable
+{
+    private readonly string _rootDir;
+    private readonly string _skillsRoot;
+    private readonly string _workingDir;
+
+    public SessionSkillSeederTests()
+    {
+        _rootDir = Path.Combine(Path.GetTempPath(), $"claudedo_seeder_test_{Guid.NewGuid():N}");
+        _skillsRoot = Path.Combine(_rootDir, "session-skills");
+        _workingDir = Path.Combine(_rootDir, "workdir");
+        Directory.CreateDirectory(_skillsRoot);
+        Directory.CreateDirectory(_workingDir);
+    }
+
+    public void Dispose()
+    {
+        try { Directory.Delete(_rootDir, recursive: true); } catch { /* best effort */ }
+    }
+
+    private SessionSkillSeeder CreateSeeder() => new(NullLogger<SessionSkillSeeder>.Instance, _skillsRoot);
+
+    private void WriteInstalledSkill(string name, string fileName = "SKILL.md", string content = "# body")
+    {
+        var dir = Path.Combine(_skillsRoot, name);
+        Directory.CreateDirectory(dir);
+        File.WriteAllText(Path.Combine(dir, fileName), content);
+    }
+
+    [Fact]
+    public async Task SeedAsync_copies_skill_files_into_dot_claude_skills()
+    {
+        const string skillName = "ponytail";
+        WriteInstalledSkill(skillName);
+        var seeder = CreateSeeder();
+
+        await seeder.SeedAsync(_workingDir, [skillName], isWorktree: false, CancellationToken.None);
+
+        var destFile = Path.Combine(_workingDir, ".claude", "skills", skillName, "SKILL.md");
+        Assert.True(File.Exists(destFile));
+        Assert.Equal("# body", File.ReadAllText(destFile));
+    }
+
+    [Fact]
+    public async Task SeedAsync_empty_list_creates_no_dot_claude_dir()
+    {
+        var seeder = CreateSeeder();
+
+        await seeder.SeedAsync(_workingDir, [], isWorktree: false, CancellationToken.None);
+
+        Assert.False(Directory.Exists(Path.Combine(_workingDir, ".claude")));
+    }
+
+    [Fact]
+    public async Task SeedAsync_missing_source_skill_logs_warning_and_does_not_throw()
+    {
+        var seeder = CreateSeeder();
+
+        await seeder.SeedAsync(_workingDir, ["does-not-exist"], isWorktree: false, CancellationToken.None);
+
+        Assert.False(Directory.Exists(Path.Combine(_workingDir, ".claude", "skills", "does-not-exist")));
+    }
+
+    [Fact]
+    public async Task SeedAsync_re_seeding_is_idempotent_and_overwrites()
+    {
+        const string skillName = "ponytail";
+        WriteInstalledSkill(skillName, content: "v1");
+        var seeder = CreateSeeder();
+        await seeder.SeedAsync(_workingDir, [skillName], isWorktree: false, CancellationToken.None);
+
+        WriteInstalledSkill(skillName, content: "v2");
+        await seeder.SeedAsync(_workingDir, [skillName], isWorktree: false, CancellationToken.None);
+
+        var destFile = Path.Combine(_workingDir, ".claude", "skills", skillName, "SKILL.md");
+        Assert.Equal("v2", File.ReadAllText(destFile));
+    }
+
+    [Fact]
+    public async Task SeedAsync_non_worktree_does_not_touch_git_exclude()
+    {
+        // _workingDir is a plain directory (no .git), so a git call would throw if attempted.
+        WriteInstalledSkill("ponytail");
+        var seeder = CreateSeeder();
+
+        await seeder.SeedAsync(_workingDir, ["ponytail"], isWorktree: false, CancellationToken.None);
+
+        // No exception means git rev-parse was correctly skipped for isWorktree=false.
+        Assert.True(Directory.Exists(Path.Combine(_workingDir, ".claude", "skills", "ponytail")));
+    }
+
+    [Fact]
+    public async Task SeedAsync_worktree_appends_exclude_line_once()
+    {
+        if (!GitRepoFixture.IsGitAvailable()) return;
+
+        using var repo = new GitRepoFixture();
+        WriteInstalledSkill("ponytail");
+        var seeder = CreateSeeder();
+
+        await seeder.SeedAsync(repo.RepoDir, ["ponytail"], isWorktree: true, CancellationToken.None);
+
+        var excludeFile = Path.Combine(repo.RepoDir, ".git", "info", "exclude");
+        Assert.True(File.Exists(excludeFile));
+        var lines = await File.ReadAllLinesAsync(excludeFile);
+        Assert.Single(lines, l => l.Trim() == "/.claude/skills/ponytail/");
+
+        // Re-seed: exclude line must not be duplicated.
+        await seeder.SeedAsync(repo.RepoDir, ["ponytail"], isWorktree: true, CancellationToken.None);
+        var linesAfter = await File.ReadAllLinesAsync(excludeFile);
+        Assert.Single(linesAfter, l => l.Trim() == "/.claude/skills/ponytail/");
+    }
+
+    [Fact]
+    public async Task SeedAsync_worktree_seeded_skill_path_is_ignored_by_git_status()
+    {
+        if (!GitRepoFixture.IsGitAvailable()) return;
+
+        using var repo = new GitRepoFixture();
+        WriteInstalledSkill("ponytail");
+        var seeder = CreateSeeder();
+
+        await seeder.SeedAsync(repo.RepoDir, ["ponytail"], isWorktree: true, CancellationToken.None);
+
+        var status = GitRepoFixture.RunGit(repo.RepoDir, "status", "--porcelain");
+        Assert.Equal(string.Empty, status.Trim());
+    }
+}