fix(skills): watch skill roots that appear mid-session, drop unused schema

Review feedback on #2606: watchSkillDirs now polls directories that do
not exist yet (e.g. a repo .claude/skills created after the watch
started) and attaches a watcher once they appear; the unused
skillsChangedEvent schema is removed (tRPC output validation does not
apply to async-generator subscriptions in our version).

Generated-By: PostHog Code
Task-Id: f4e84f1a-19c9-490c-9b98-47787a7dddcf

Author: k11kirky

packages/workspace-server/src/services/skills/schemas.ts

@@ -74,10 +74,6 @@ export const deleteSkillInput = z.object({
   skillPath: z.string(),
 });
 
-export const skillsChangedEvent = z.object({
-  changed: z.literal(true),
-});
-
 export type SkillInfo = z.infer<typeof skillInfo>;
 export type SkillScope = z.infer<typeof skillScope>;
 export type CreateSkillInput = z.infer<typeof createSkillInput>;

packages/workspace-server/src/services/skills/skills.test.ts

@@ -218,6 +218,35 @@ describe("watchSkillDirs", () => {
     const generator = makeService().watchSkillDirs([]);
     expect(await generator.next()).toEqual({ value: undefined, done: true });
   });
+
+  it(
+    "picks up a skills dir created after the watch starts",
+    { timeout: 15_000 },
+    async () => {
+      const service = makeService();
+      const controller = new AbortController();
+      const lateDir = path.join(root, "late-repo", ".claude", "skills");
+      const generator = service.watchSkillDirs([lateDir], controller.signal);
+
+      const firstEvent = generator.next();
+      await new Promise((r) => setTimeout(r, 100));
+      await mkdir(lateDir, { recursive: true });
+
+      const result = await Promise.race([
+        firstEvent,
+        new Promise<never>((_, reject) =>
+          setTimeout(
+            () => reject(new Error("timed out waiting for change event")),
+            10_000,
+          ),
+        ),
+      ]);
+      expect(result).toEqual({ value: { changed: true }, done: false });
+
+      controller.abort();
+      await generator.return(undefined);
+    },
+  );
 });
 
 describe("createSkill", () => {

packages/workspace-server/src/services/skills/skills.ts

@@ -25,6 +25,7 @@ import { serializeSkillMarkdown } from "./write-skill-frontmatter";
 const MAX_SKILL_FILES = 500;
 const MAX_SKILL_FILE_BYTES = 2 * 1024 * 1024;
 const SKILLS_WATCH_DEBOUNCE_MS = 300;
+const MISSING_DIR_POLL_MS = 2000;
 const SKILL_DIR_NAME_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
 const MAX_SKILL_DIR_NAME_LENGTH = 64;
 
@@ -182,18 +183,23 @@ export class SkillsService {
    */
   async *watchSkills(signal?: AbortSignal): AsyncGenerator<{ changed: true }> {
     const userRoot = path.join(os.homedir(), ".claude", "skills");
-    // The user root is ours to create; repo roots are only watched if present.
+    // The user root is ours to create; repo roots are watched as soon as
+    // they appear (watchSkillDirs polls for dirs that don't exist yet).
     await fs.promises.mkdir(userRoot, { recursive: true }).catch(() => {});
     const folders = await this.folders.getFolders();
     const dirs = [
       userRoot,
       ...folders.map((f) => path.join(f.path, ".claude", "skills")),
-    ].filter((dir) => fs.existsSync(dir));
+    ];
 
     yield* this.watchSkillDirs(dirs, signal);
   }
 
-  /** Merges watchers over the given directories into one debounced stream. */
+  /**
+   * Merges watchers over the given directories into one debounced stream.
+   * Directories that don't exist yet (e.g. a repo's `.claude/skills` created
+   * mid-session) are polled and picked up once they appear.
+   */
   async *watchSkillDirs(
     dirs: string[],
     signal?: AbortSignal,
@@ -208,6 +214,12 @@ export class SkillsService {
     for (const dir of dirs) {
       void (async () => {
         try {
+          if (!(await dirExists(dir))) {
+            if (!(await waitForDir(dir, signal))) return;
+            // The new root may already contain skills — that's a change too.
+            pending = true;
+            wake();
+          }
           for await (const _batch of this.watcher.watch(dir, {}, signal)) {
             pending = true;
             wake();
@@ -340,6 +352,22 @@ function validateSkillDirName(name: string): void {
   }
 }
 
+function dirExists(dir: string): Promise<boolean> {
+  return fs.promises
+    .access(dir)
+    .then(() => true)
+    .catch(() => false);
+}
+
+/** Polls until the directory exists. Resolves false if aborted first. */
+async function waitForDir(dir: string, signal?: AbortSignal): Promise<boolean> {
+  while (!signal?.aborted) {
+    if (await dirExists(dir)) return true;
+    await delay(MISSING_DIR_POLL_MS, signal);
+  }
+  return false;
+}
+
 function delay(ms: number, signal?: AbortSignal): Promise<void> {
   return new Promise((resolve) => {
     const timer = setTimeout(done, ms);