@opengsd/gsd-pi 1.0.2-dev.867e002 → 1.0.2-dev.cce3612

package/src/resources/extensions/gsd/tests/post-unit-retry-on-orchestrator-bridge.test.ts

@@ -0,0 +1,93 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { mock } from "node:test";
+
+import { postUnitPostVerification, type PostUnitContext } from "../auto-post-unit.ts";
+import { AutoSession } from "../auto/session.ts";
+import { checkPostUnitHooks, resetHookState, resolveHookArtifactPath } from "../post-unit-hooks.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+import { invalidateAllCaches } from "../cache.ts";
+
+function writePreferences(basePath: string): void {
+  const content = `---
+post_unit_hooks:
+  - name: review-arbiter
+    after:
+      - execute-task
+    prompt: Review {taskId}
+    agent: arbiter
+    artifact: REVIEW-DEBATE.md
+    retry_on: NEEDS-REWORK.md
+    max_cycles: 3
+    enabled: true
+---
+`;
+  writeFileSync(join(basePath, ".gsd", "PREFERENCES.md"), content, "utf-8");
+}
+
+test("post-unit retry_on marks trigger unit as retry in orchestrator before redispatch", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-retry-"));
+  const taskDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
+  mkdirSync(taskDir, { recursive: true });
+
+  try {
+    process.chdir(base);
+    _clearGsdRootCache();
+    invalidateAllCaches();
+    resetHookState();
+    writePreferences(base);
+
+    const hookDispatch = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.ok(hookDispatch, "hook should dispatch for execute-task");
+
+    const retryPath = resolveHookArtifactPath(base, "M001/S01/T01", "NEEDS-REWORK.md");
+    writeFileSync(retryPath, "rework requested", "utf-8");
+
+    const retryActiveUnit = mock.fn(async (_unit: { unitType: string; unitId: string }) => {});
+    const s = new AutoSession();
+    s.basePath = base;
+    s.active = true;
+    s.currentUnit = { type: "hook/review-arbiter", id: "M001/S01/T01", startedAt: Date.now() };
+    s.orchestration = {
+      start: async () => ({ kind: "started" }),
+      advance: async () => ({ kind: "stopped", reason: "unused" }),
+      completeActiveUnit: async () => {},
+      retryActiveUnit,
+      resume: async () => ({ kind: "resumed" }),
+      stop: async (reason: string) => ({ kind: "stopped", reason }),
+      getStatus: () => ({ phase: "running", transitionCount: 0 }),
+    };
+
+    const pctx: PostUnitContext = {
+      s,
+      ctx: {
+        ui: { notify: () => {}, setStatus: () => {}, setWidget: () => {}, setFooter: () => {} },
+        model: { id: "test-model" },
+      } as any,
+      pi: { sendMessage: async () => {}, setModel: async () => true } as any,
+      buildSnapshotOpts: () => ({}),
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => {},
+      updateProgressWidget: () => {},
+    };
+
+    const result = await postUnitPostVerification(pctx);
+    assert.equal(result, "continue");
+    assert.equal(retryActiveUnit.mock.callCount(), 1);
+    assert.deepEqual(retryActiveUnit.mock.calls[0]?.arguments[0], {
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+    });
+  } finally {
+    process.chdir(originalCwd);
+    resetHookState();
+    invalidateAllCaches();
+    _clearGsdRootCache();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/queue-reorder-ui.test.ts

@@ -2,6 +2,7 @@ import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
 import { showQueueReorder } from "../queue-reorder-ui.ts";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 
 const fakeTheme = {
   fg: (_color: string, text: string) => text,
@@ -43,6 +44,51 @@ describe("queue-reorder-ui", () => {
       const joined = lastRender.join("\n");
       assert.ok(joined.includes("M016"), "selected item should stay visible after scrolling");
       assert.ok(lastRender.length <= 16, `overlay should fit terminal max-height, got ${lastRender.length}`);
+      assertFullOuterBorder(lastRender, 100);
+      assert.match(lastRender[0] ?? "", /^╭─ Queue Reorder /);
+      assert.match(lastRender.at(-1) ?? "", /^╰─+╯$/);
+    } finally {
+      if (originalRowsDescriptor) {
+        Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);
+      } else {
+        delete (process.stdout as { rows?: number }).rows;
+      }
+    }
+  });
+
+  test("draws queue scroll thumb beside queue rows when completed rows are shown", async () => {
+    const originalRowsDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "rows");
+    Object.defineProperty(process.stdout, "rows", { value: 12, configurable: true });
+
+    try {
+      const completed = [
+        { id: "M000", title: "Already done" },
+      ];
+      const pending = Array.from({ length: 8 }, (_, idx) => ({
+        id: `M${String(idx + 1).padStart(3, "0")}`,
+        title: `Milestone ${idx + 1}`,
+      }));
+      let rendered: string[] = [];
+
+      const ctx = {
+        hasUI: true,
+        ui: {
+          custom: async (factory: any) => {
+            const component = factory({ requestRender() {} }, fakeTheme, null, () => {});
+            rendered = component.render(80);
+            return null;
+          },
+        },
+      } as any;
+
+      await showQueueReorder(ctx, completed, pending);
+
+      const completedHeader = rendered.find(line => line.includes("Completed:"));
+      const firstQueueRow = rendered.find(line => line.includes("M001"));
+      assert.ok(completedHeader, "completed header should be rendered before queue rows");
+      assert.ok(firstQueueRow, "first queue row should be rendered");
+      assert.match(completedHeader, /│$/);
+      assert.match(firstQueueRow, /┃$/);
     } finally {
       if (originalRowsDescriptor) {
         Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);

package/src/resources/extensions/gsd/tests/register-extension-guard.test.ts

@@ -134,6 +134,72 @@ test("handleRecoverableExtensionProcessError swallows EPIPE without writing a cr
   }
 });
 
+test("handleRecoverableExtensionProcessError tolerates stderr.write throwing EPIPE (re-entry guard)", () => {
+  // process.stderr.write itself can EPIPE; safeStderr() must swallow it so the
+  // handler doesn't re-enter the EPIPE branch and loop forever.
+  const originalWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = (() => {
+    throw Object.assign(new Error("stderr broken pipe"), {
+      code: "EPIPE",
+      syscall: "write",
+    });
+  }) as typeof process.stderr.write;
+
+  try {
+    const handled = handleRecoverableExtensionProcessError(
+      Object.assign(new Error("broken pipe"), {
+        code: "EPIPE",
+        syscall: "write",
+      }),
+    );
+    assert.equal(handled, true);
+  } finally {
+    process.stderr.write = originalWrite;
+  }
+});
+
+// #181: Windows surfaces a closed pipe mid-write as `Error: write EOF` (or
+// `read EOF`) with no `code` set. Both are the same logical condition as POSIX
+// EPIPE and must be swallowed, else they escape to the uncaught-exception path
+// and crash auto-mode workers. These non-storm cases run before the storm test
+// below so the shared storm counter stays under threshold. ECONNRESET is
+// intentionally NOT in this set — see the dedicated "leaves ECONNRESET network
+// errors unhandled" test above.
+test("handleRecoverableExtensionProcessError swallows Windows 'write EOF' (no code)", () => {
+  let stderr = "";
+  const originalWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    stderr += String(chunk);
+    return true;
+  }) as typeof process.stderr.write;
+
+  try {
+    // Mirror the real Windows error: message "write EOF", no `code`, no `syscall`.
+    const handled = handleRecoverableExtensionProcessError(new Error("write EOF"));
+    assert.equal(handled, true);
+    assert.match(stderr, /swallowed write EOF/);
+  } finally {
+    process.stderr.write = originalWrite;
+  }
+});
+
+test("handleRecoverableExtensionProcessError swallows 'read EOF' (no code)", () => {
+  let stderr = "";
+  const originalWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    stderr += String(chunk);
+    return true;
+  }) as typeof process.stderr.write;
+
+  try {
+    const handled = handleRecoverableExtensionProcessError(new Error("read EOF"));
+    assert.equal(handled, true);
+    assert.match(stderr, /swallowed read EOF/);
+  } finally {
+    process.stderr.write = originalWrite;
+  }
+});
+
 test("handleRecoverableExtensionProcessError swallows dead transport control write errors", () => {
   let stderr = "";
   const originalWrite = process.stderr.write.bind(process.stderr);
@@ -153,7 +219,16 @@ test("handleRecoverableExtensionProcessError swallows dead transport control wri
   }
 });
 
-test("handleRecoverableExtensionProcessError swallows write EOF without code", () => {
+test("handleRecoverableExtensionProcessError leaves a plain EOF-substring error unhandled", () => {
+  // Guard against over-matching: only the exact "write EOF"/"read EOF" messages
+  // are the Windows pipe-closed signature; an unrelated error must not be eaten.
+  const handled = handleRecoverableExtensionProcessError(new Error("could not write EOF marker to log"));
+  assert.equal(handled, false);
+});
+
+test("handleRecoverableExtensionProcessError exits on EPIPE storm (>100 within 10s)", () => {
+  // After the storm threshold, the pipe is gone for good — handler must exit
+  // cleanly instead of swallowing forever in a tight CPU loop.
   let stderr = "";
   const originalWrite = process.stderr.write.bind(process.stderr);
   process.stderr.write = ((chunk: string | Uint8Array) => {
@@ -161,18 +236,38 @@ test("handleRecoverableExtensionProcessError swallows write EOF without code", (
     return true;
   }) as typeof process.stderr.write;
 
+  const originalExit = process.exit;
+  const exitCalls: Array<number | undefined> = [];
+  process.exit = ((code?: number) => {
+    exitCalls.push(code);
+    // Don't actually exit; just record the call.
+    return undefined as never;
+  }) as typeof process.exit;
+
   try {
-    const handled = handleRecoverableExtensionProcessError(
-      new Error("write EOF"),
+    const err = Object.assign(new Error("broken pipe"), {
+      code: "EPIPE",
+      syscall: "write",
+    });
+    // Fire well above the 100-event threshold inside the 10s window.
+    for (let i = 0; i < 150; i++) {
+      handleRecoverableExtensionProcessError(err);
+    }
+    assert.ok(
+      exitCalls.length > 0,
+      `expected process.exit to be called during EPIPE storm, got ${exitCalls.length} calls`,
     );
-    assert.equal(handled, true);
-    assert.match(stderr, /swallowed write EOF/);
+    assert.equal(exitCalls[0], 0);
+    assert.match(stderr, /EPIPE storm/);
   } finally {
     process.stderr.write = originalWrite;
+    process.exit = originalExit;
   }
 });
 
-test("handleRecoverableExtensionProcessError swallows read EOF without code", () => {
+test("handleRecoverableExtensionProcessError exits on a Windows 'write EOF' storm too (#181)", () => {
+  // The storm counter is shared across all pipe-closed encodings, so a runaway
+  // Windows `write EOF` loop must trip the same clean-exit guard as EPIPE.
   let stderr = "";
   const originalWrite = process.stderr.write.bind(process.stderr);
   process.stderr.write = ((chunk: string | Uint8Array) => {
@@ -180,13 +275,23 @@ test("handleRecoverableExtensionProcessError swallows read EOF without code", ()
     return true;
   }) as typeof process.stderr.write;
 
+  const originalExit = process.exit;
+  const exitCalls: Array<number | undefined> = [];
+  process.exit = ((code?: number) => {
+    exitCalls.push(code);
+    return undefined as never;
+  }) as typeof process.exit;
+
   try {
-    const handled = handleRecoverableExtensionProcessError(
-      new Error("read EOF"),
-    );
-    assert.equal(handled, true);
-    assert.match(stderr, /swallowed read EOF/);
+    const err = new Error("write EOF");
+    for (let i = 0; i < 150; i++) {
+      handleRecoverableExtensionProcessError(err);
+    }
+    assert.ok(exitCalls.length > 0, "expected process.exit during write EOF storm");
+    assert.equal(exitCalls[0], 0);
+    assert.match(stderr, /write EOF storm/);
   } finally {
     process.stderr.write = originalWrite;
+    process.exit = originalExit;
   }
 });

package/src/resources/extensions/gsd/tests/repository-registry.test.ts

@@ -2,9 +2,10 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { execFileSync } from "node:child_process";
 import { createRepositoryRegistryFromPreferences, defaultRepositoryTargets } from "../repository-registry.ts";
 
 test("repository registry includes implicit project root and declared child repos", (t) => {
@@ -99,3 +100,31 @@ test("defaultRepositoryTargets returns [project] for a parent-mode registry", (t
 
   assert.deepEqual(defaultRepositoryTargets(registry), ["project"]);
 });
+
+test("repository registry keeps project root anchored to .gsd project in monorepo subdirectory", (t) => {
+  const monorepo = mkdtempSync(join(tmpdir(), "gsd-repo-registry-mono-"));
+  t.after(() => rmSync(monorepo, { recursive: true, force: true }));
+  execFileSync("git", ["init"], { cwd: monorepo, stdio: "ignore" });
+
+  const subproject = join(monorepo, "fieldkit-tools");
+  mkdirSync(join(subproject, ".gsd"), { recursive: true });
+  writeFileSync(join(subproject, ".gsd", "PREFERENCES.md"), "---\nversion: 1\n---\n");
+
+  const registry = createRepositoryRegistryFromPreferences(subproject, undefined);
+
+  assert.equal(registry.projectRoot, subproject);
+  assert.equal(registry.byId.get("project")?.root, subproject);
+});
+
+test("repository registry uses external-state worktree checkout as project root", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-repo-registry-external-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  const worktree = join(base, ".gsd", "projects", "abc123", "worktrees", "M001");
+  mkdirSync(worktree, { recursive: true });
+  execFileSync("git", ["init"], { cwd: worktree, stdio: "ignore" });
+
+  const registry = createRepositoryRegistryFromPreferences(worktree, undefined);
+
+  assert.equal(registry.projectRoot, worktree);
+  assert.equal(registry.byId.get("project")?.root, worktree);
+});

package/src/resources/extensions/gsd/tests/show-config-command.test.ts

@@ -7,6 +7,7 @@ import assert from "node:assert/strict";
 
 import { GSDConfigOverlay, formatConfigText } from "../config-overlay.ts";
 import { handleCoreCommand } from "../commands/handlers/core.ts";
+import { assertFullOuterBorder } from "./tui-border-assertions.ts";
 
 const theme = {
   bold: (s: string) => s,
@@ -24,6 +25,9 @@ test("GSDConfigOverlay renders and responds to input", () => {
 
   const lines = overlay.render(60);
   assert.ok(lines.some((line) => line.includes("GSD Configuration")));
+  assertFullOuterBorder(lines, 60);
+  assert.match(lines[0] ?? "", /^╭─ GSD Configuration /);
+  assert.match(lines.at(-1) ?? "", /^╰─+╯$/);
 
   overlay.handleInput("j");
   assert.equal(renderRequests, 1);

package/src/resources/extensions/gsd/tests/skill-discovery.test.ts

@@ -0,0 +1,111 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  appendDiscoveredSkillsFallback,
+  clearSkillSnapshot,
+  detectNewSkills,
+  refreshCatalogForNewSkills,
+  snapshotSkills,
+} from "../skill-discovery.js";
+
+function makeTempHome(): string {
+  return mkdtempSync(join(tmpdir(), "gsd-skill-discovery-"));
+}
+
+async function withTempSkillHome<T>(fn: (home: string) => T | Promise<T>): Promise<T> {
+  const previousHome = process.env.HOME;
+  const previousGsdHome = process.env.GSD_HOME;
+  const home = makeTempHome();
+  process.env.HOME = home;
+  process.env.GSD_HOME = join(home, ".gsd");
+  try {
+    return await fn(home);
+  } finally {
+    clearSkillSnapshot();
+    if (previousHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = previousHome;
+    }
+    if (previousGsdHome === undefined) {
+      delete process.env.GSD_HOME;
+    } else {
+      process.env.GSD_HOME = previousGsdHome;
+    }
+    rmSync(home, { recursive: true, force: true });
+  }
+}
+
+function writeDiskSkill(root: string, name: string, description = `Use for ${name}.`): void {
+  const dir = join(root, name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "SKILL.md"), `---\nname: ${name}\ndescription: ${description}\n---\n\n# ${name}\n`);
+}
+
+test("detectNewSkills detects skills added on disk after the baseline snapshot", async () => {
+  await withTempSkillHome((home) => {
+    const skillsRoot = join(home, ".agents", "skills");
+    writeDiskSkill(skillsRoot, "existing-skill");
+    snapshotSkills();
+
+    writeDiskSkill(skillsRoot, "new-disk-skill", "New disk skill.");
+    const detected = detectNewSkills();
+
+    assert.deepEqual(detected.map(skill => skill.name), ["new-disk-skill"]);
+    assert.equal(detected[0].description, "New disk skill.");
+    assert.equal(detected[0].location, join(skillsRoot, "new-disk-skill", "SKILL.md"));
+  });
+});
+
+test("refreshCatalogForNewSkills retries discovery after reload failure", async () => {
+  await withTempSkillHome(async (home) => {
+    const skillsRoot = join(home, ".agents", "skills");
+    snapshotSkills();
+    writeDiskSkill(skillsRoot, "reload-retry-skill");
+
+    const messages: Array<{ message: string; level: "info" | "warning" }> = [];
+    const failed = await refreshCatalogForNewSkills({
+      reload: async () => { throw new Error("reload failed"); },
+      notify: (message, level) => messages.push({ message, level }),
+    });
+
+    assert.deepEqual(failed.map(skill => skill.name), ["reload-retry-skill"]);
+    assert.deepEqual(detectNewSkills().map(skill => skill.name), ["reload-retry-skill"]);
+    assert.equal(messages[0]?.level, "warning");
+
+    const loaded = await refreshCatalogForNewSkills({
+      reload: async () => {},
+      notify: (message, level) => messages.push({ message, level }),
+    });
+
+    assert.deepEqual(loaded.map(skill => skill.name), ["reload-retry-skill"]);
+    assert.deepEqual(detectNewSkills(), []);
+    assert.ok(messages.some(({ level, message }) => level === "info" && message.includes("reload-retry-skill")));
+  });
+});
+
+test("appendDiscoveredSkillsFallback exposes newly detected skills missing from the prompt", () => {
+  const prompt = appendDiscoveredSkillsFallback("base system prompt", [{
+    name: "fallback-skill",
+    description: "Use when reload fails & skill is needed.",
+    location: "/tmp/fallback-skill/SKILL.md",
+  }]);
+
+  assert.match(prompt, /<newly_discovered_skills>/);
+  assert.match(prompt, /fallback-skill/);
+  assert.match(prompt, /Use when reload fails &amp; skill is needed\./);
+  assert.match(prompt, /\/tmp\/fallback-skill\/SKILL.md/);
+});
+
+test("appendDiscoveredSkillsFallback does not duplicate skills already in the prompt", () => {
+  const prompt = "base system prompt\n/tmp/already-loaded/SKILL.md";
+
+  assert.equal(appendDiscoveredSkillsFallback(prompt, [{
+    name: "already-loaded",
+    description: "Already present.",
+    location: "/tmp/already-loaded/SKILL.md",
+  }]), prompt);
+});

package/src/resources/extensions/gsd/tests/skill-scope-auto.test.ts

@@ -0,0 +1,67 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  applyUnitSkillVisibility,
+  effectiveSkillNamesForUnit,
+  resolveVisibleSkillNames,
+  unitHasSkillManifest,
+} from "../skill-scope.ts";
+
+test("resolveVisibleSkillNames: none policy suppresses catalog", () => {
+  assert.deepEqual(resolveVisibleSkillNames("workflow-preferences"), []);
+  assert.equal(unitHasSkillManifest("workflow-preferences"), true);
+});
+
+test("resolveVisibleSkillNames: wildcard units use full catalog", () => {
+  assert.equal(resolveVisibleSkillNames("execute-task"), undefined);
+  assert.equal(unitHasSkillManifest("execute-task"), false);
+});
+
+test("unitHasSkillManifest: manifest unit types return true", () => {
+  assert.equal(unitHasSkillManifest("research-milestone"), true);
+  assert.equal(unitHasSkillManifest("plan-slice"), true);
+});
+
+test("unitHasSkillManifest: wildcard unit types return false", () => {
+  assert.equal(unitHasSkillManifest("execute-task"), false);
+  assert.equal(unitHasSkillManifest(undefined), false);
+  assert.equal(unitHasSkillManifest("unknown-unit"), false);
+});
+
+test("applyUnitSkillVisibility: sets manifest names for scoped units", () => {
+  let visible: string[] | undefined;
+  applyUnitSkillVisibility({
+    setVisibleSkills: (names) => {
+      visible = names;
+    },
+  }, "research-milestone");
+
+  assert.ok(Array.isArray(visible));
+  assert.ok(visible!.includes("write-docs"));
+  assert.ok(visible!.length < 15);
+});
+
+test("applyUnitSkillVisibility: restores full catalog for wildcard units", () => {
+  let visible: string[] | undefined = ["stale"];
+  applyUnitSkillVisibility({
+    setVisibleSkills: (names) => {
+      visible = names;
+    },
+  }, "execute-task");
+
+  assert.equal(visible, undefined);
+});
+
+test("effectiveSkillNamesForUnit: filters installed names by manifest", () => {
+  const installed = ["write-docs", "review", "frontend-design", "tdd"];
+  const scoped = effectiveSkillNamesForUnit("research-milestone", installed);
+  assert.ok(scoped.includes("write-docs"));
+  assert.ok(!scoped.includes("review"));
+  assert.ok(scoped.length < installed.length);
+});
+
+test("effectiveSkillNamesForUnit: pass-through for wildcard units", () => {
+  const installed = ["write-docs", "review"];
+  assert.deepEqual(effectiveSkillNamesForUnit("execute-task", installed), installed);
+});

package/src/resources/extensions/gsd/tests/skills.test.ts

@@ -0,0 +1,55 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import type { Skill } from "@gsd/pi-coding-agent";
+import {
+  detectNewlyInstalledSkills,
+  getInstalledSkillNames,
+  getInstalledSkills,
+  normalizeSkillName,
+  resolveInstalledSkill,
+  snapshotInstalledSkillNames,
+} from "../skills.js";
+
+function makeSkill(name: string, filePath = `/tmp/${name}/SKILL.md`): Skill {
+  return {
+    name,
+    description: `Use for ${name}.`,
+    filePath,
+    baseDir: `/tmp/${name}`,
+    source: "user",
+    sourceInfo: {
+      path: filePath,
+      source: "local",
+      scope: "user",
+      origin: "top-level",
+      baseDir: `/tmp/${name}`,
+    },
+    disableModelInvocation: false,
+  };
+}
+
+test("normalizeSkillName lowercases and trims", () => {
+  assert.equal(normalizeSkillName("  React-Best  "), "react-best");
+});
+
+test("getInstalledSkills returns explicit override", () => {
+  const skills = [makeSkill("alpha"), makeSkill("beta")];
+  assert.deepEqual(getInstalledSkills(skills).map((s) => s.name), ["alpha", "beta"]);
+});
+
+test("snapshotInstalledSkillNames and detectNewlyInstalledSkills diff normalized names", () => {
+  const baseline = snapshotInstalledSkillNames([makeSkill("alpha")]);
+  const added = detectNewlyInstalledSkills(baseline, [makeSkill("alpha"), makeSkill("Beta")]);
+  assert.deepEqual(added, ["beta"]);
+});
+
+test("getInstalledSkillNames maps skill names", () => {
+  assert.deepEqual(getInstalledSkillNames([makeSkill("tdd")]), ["tdd"]);
+});
+
+test("resolveInstalledSkill matches installed catalog by name", () => {
+  const skills = [makeSkill("react", "/home/user/.gsd/agent/skills/react/SKILL.md")];
+  const result = resolveInstalledSkill("react", "/project", skills);
+  assert.equal(result.skill?.name, "react");
+  assert.equal(result.resolvedPath, "/home/user/.gsd/agent/skills/react/SKILL.md");
+});

package/src/resources/extensions/gsd/tests/start-auto-detached.test.ts

@@ -15,6 +15,13 @@ function readGsdFile(relativePath: string): string {
   return readFileSync(resolve(gsdDir, relativePath), "utf-8");
 }
 
+function firstIndexOfAny(source: string, needles: string[]): number {
+  const indexes = needles
+    .map((needle) => source.indexOf(needle))
+    .filter((index) => index > -1);
+  return indexes.length > 0 ? Math.min(...indexes) : -1;
+}
+
 test("command entrypoints use startAutoDetached instead of awaiting startAuto (#3733)", () => {
   const autoHandlerSrc = readGsdFile("commands/handlers/auto.ts");
   const workflowHandlerSrc = readGsdFile("commands/handlers/workflow.ts");
@@ -145,7 +152,11 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
   const resumeEnterMilestoneIdx = resumeBody.indexOf("buildLifecycle().enterMilestone");
   const dbOpenIdx = bootstrapBody.indexOf("await openProjectDbIfPresent(base);");
   const bootstrapRegisterIdx = bootstrapBody.indexOf("registerAutoWorkerForSession(base);");
-  const enterMilestoneIdx = bootstrapBody.indexOf("buildLifecycle().enterMilestone");
+  const enterMilestoneIdx = firstIndexOfAny(bootstrapBody, [
+    "buildLifecycle().enterMilestone",
+    "lifecycle.enterMilestone",
+    "lifecycle.adoptStrandedMilestone",
+  ]);
 
   assert.ok(startAutoIdx > -1, "startAuto should exist");
   assert.ok(preBootstrapRegisterIdx > -1, "startAuto should register worker before bootstrap");
@@ -158,7 +169,7 @@ test("fresh start registers the auto worker before bootstrap enters worktree flo
   assert.ok(bootstrapIdx > -1, "bootstrapAutoSession should exist");
   assert.ok(dbOpenIdx > -1, "bootstrap should open the project DB");
   assert.ok(bootstrapRegisterIdx > -1, "bootstrap should register worker after DB open");
-  assert.ok(enterMilestoneIdx > -1, "bootstrap should enter milestones through lifecycle");
+  assert.ok(enterMilestoneIdx > -1, "bootstrap should enter or adopt milestones through lifecycle");
   assert.ok(
     preBootstrapRegisterIdx < bootstrapCallIdx,
     "worker registration must happen before bootstrap so enterMilestone can claim milestone leases on first entry",