gsd-pi 2.49.0 → 2.50.0-dev.d210a87

package/src/resources/extensions/gsd/tests/session-lock-transient-read.test.ts

@@ -0,0 +1,223 @@
+/**
+ * session-lock-transient-read.test.ts — Tests for transient lock file unreadability (#2324).
+ *
+ * Regression coverage for:
+ *   #2324  onCompromised declares lock lost when the lock file is temporarily
+ *          unreadable (NFS/CIFS latency, macOS APFS snapshot, concurrent process
+ *          briefly holding the file).
+ *
+ * Tests:
+ *   - readExistingLockDataWithRetry retries on transient read failure
+ *   - readExistingLockDataWithRetry returns data when file becomes readable after retries
+ *   - readExistingLockDataWithRetry returns null only when ALL retries exhausted
+ *   - onCompromised does not declare compromise when lock file is transiently unreadable
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, renameSync, unlinkSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { execSync, spawn } from 'node:child_process';
+
+import {
+  acquireSessionLock,
+  getSessionLockStatus,
+  releaseSessionLock,
+  readExistingLockDataWithRetry,
+  type SessionLockData,
+} from '../session-lock.ts';
+import { gsdRoot } from '../paths.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+async function main(): Promise<void> {
+
+  // ─── 1. readExistingLockDataWithRetry succeeds on first read when file is fine ─
+  console.log('\n=== 1. readExistingLockDataWithRetry reads file normally ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-transient-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const lockFile = join(gsdRoot(base), 'auto.lock');
+      const lockData: SessionLockData = {
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        unitType: 'execute-task',
+        unitId: 'M001/S01/T01',
+        unitStartedAt: new Date().toISOString(),
+        sessionFile: 'test-session.json',
+      };
+      writeFileSync(lockFile, JSON.stringify(lockData, null, 2));
+
+      const result = readExistingLockDataWithRetry(lockFile);
+      assertTrue(result !== null, 'data returned for readable file');
+      assertEq(result!.pid, process.pid, 'correct PID read');
+      assertEq(result!.sessionFile, 'test-session.json', 'correct sessionFile read');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 2. readExistingLockDataWithRetry returns null for truly missing file ──
+  console.log('\n=== 2. readExistingLockDataWithRetry returns null for missing file ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-transient-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const lockFile = join(gsdRoot(base), 'auto.lock');
+      // File doesn't exist
+      const result = readExistingLockDataWithRetry(lockFile, { maxAttempts: 2, delayMs: 10 });
+      assertEq(result, null, 'null for truly missing file after retries');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 3. readExistingLockDataWithRetry recovers after transient rename ──────
+  console.log('\n=== 3. readExistingLockDataWithRetry recovers after transient unavailability ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-transient-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const lockFile = join(gsdRoot(base), 'auto.lock');
+      const tmpFile = lockFile + '.hidden';
+      const lockData: SessionLockData = {
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        unitType: 'execute-task',
+        unitId: 'M001/S01/T01',
+        unitStartedAt: new Date().toISOString(),
+        sessionFile: 'recovery-session.json',
+      };
+      writeFileSync(lockFile, JSON.stringify(lockData, null, 2));
+
+      // Simulate transient unavailability: move file away, spawn a child process
+      // to restore it after 100ms. The child runs outside our event loop so it
+      // fires even during busy-wait retries.
+      renameSync(lockFile, tmpFile);
+      spawn('bash', ['-c', `sleep 0.1 && mv "${tmpFile}" "${lockFile}"`], { stdio: 'ignore', detached: true }).unref();
+
+      // With retries (3 attempts, 200ms delay), it should recover on 2nd or 3rd attempt
+      const result = readExistingLockDataWithRetry(lockFile, { maxAttempts: 3, delayMs: 200 });
+      assertTrue(result !== null, 'data recovered after transient unavailability');
+      if (result) {
+        assertEq(result.pid, process.pid, 'correct PID after recovery');
+        assertEq(result.sessionFile, 'recovery-session.json', 'correct sessionFile after recovery');
+      }
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 4. readExistingLockDataWithRetry recovers from transient permission error ─
+  console.log('\n=== 4. readExistingLockDataWithRetry recovers from transient permission error ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-transient-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const lockFile = join(gsdRoot(base), 'auto.lock');
+      const lockData: SessionLockData = {
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        unitType: 'execute-task',
+        unitId: 'M001/S01/T01',
+        unitStartedAt: new Date().toISOString(),
+        sessionFile: 'perm-session.json',
+      };
+      writeFileSync(lockFile, JSON.stringify(lockData, null, 2));
+
+      // Remove read permission to simulate NFS/CIFS latency, then spawn a child
+      // to restore permissions after 100ms (runs outside our event loop).
+      chmodSync(lockFile, 0o000);
+      spawn('bash', ['-c', `sleep 0.1 && chmod 644 "${lockFile}"`], { stdio: 'ignore', detached: true }).unref();
+
+      const result = readExistingLockDataWithRetry(lockFile, { maxAttempts: 3, delayMs: 200 });
+      assertTrue(result !== null, 'data recovered after transient permission error');
+      if (result) {
+        assertEq(result.pid, process.pid, 'correct PID after permission recovery');
+      }
+
+      // Ensure permissions restored for cleanup
+      try { chmodSync(lockFile, 0o644); } catch { /* best-effort */ }
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 5. getSessionLockStatus does not false-positive on transient read failure ─
+  console.log('\n=== 5. getSessionLockStatus tolerates transient lock file unavailability ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-transient-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const result = acquireSessionLock(base);
+      assertTrue(result.acquired, 'lock acquired');
+
+      // Validate works initially
+      const status1 = getSessionLockStatus(base);
+      assertTrue(status1.valid, 'lock valid before transient failure');
+
+      // Temporarily hide the lock file
+      const lockFile = join(gsdRoot(base), 'auto.lock');
+      const tmpFile = lockFile + '.hidden';
+      renameSync(lockFile, tmpFile);
+
+      // Schedule restoration
+      setTimeout(() => {
+        try { renameSync(tmpFile, lockFile); } catch { /* best-effort */ }
+      }, 30);
+
+      // Small delay to ensure restoration runs, then check — with the OS lock
+      // still held, getSessionLockStatus should return valid=true even if the
+      // lock file was briefly missing (it checks _releaseFunction first).
+      await new Promise(r => setTimeout(r, 60));
+      const status2 = getSessionLockStatus(base);
+      assertTrue(status2.valid, 'lock still valid after transient file disappearance (OS lock held)');
+
+      // Restore if not yet restored
+      try { renameSync(tmpFile, lockFile); } catch { /* already restored */ }
+
+      releaseSessionLock(base);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 6. Retry defaults: 3 attempts with 200ms delay ────────────────────────
+  console.log('\n=== 6. Default retry params: function works with defaults ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-transient-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const lockFile = join(gsdRoot(base), 'auto.lock');
+      const lockData: SessionLockData = {
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        unitType: 'execute-task',
+        unitId: 'M001/S01/T01',
+        unitStartedAt: new Date().toISOString(),
+        sessionFile: 'status-session.json',
+      };
+      writeFileSync(lockFile, JSON.stringify(lockData, null, 2));
+
+      // Call with no options — uses defaults (3 attempts, 200ms)
+      const result = readExistingLockDataWithRetry(lockFile);
+      assertTrue(result !== null, 'default params work for readable file');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

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

@@ -113,12 +113,12 @@ test("postUnitPostVerification pushes to sidecarQueue for hooks", () => {
   assert.ok(triageSectionStart > -1, "auto-post-unit.ts must have a triage check section");
   const hookSection = source.slice(hookSectionStart, triageSectionStart);
   assert.ok(
-    hookSection.includes("s.sidecarQueue.push("),
-    "hook section must push to s.sidecarQueue",
+    hookSection.includes("enqueueSidecar(") || hookSection.includes("s.sidecarQueue.push("),
+    "hook section must enqueue to sidecarQueue (via enqueueSidecar or direct push)",
   );
   assert.ok(
-    hookSection.includes('kind: "hook"'),
-    "hook sidecar item must have kind: 'hook'",
+    hookSection.includes('"hook"'),
+    "hook sidecar item must reference kind 'hook'",
   );
 });
 
@@ -132,12 +132,12 @@ test("postUnitPostVerification pushes to sidecarQueue for triage", () => {
   assert.ok(quickTaskSectionStart > -1, "auto-post-unit.ts must have a quick-task dispatch section");
   const triageSection = source.slice(triageSectionStart, quickTaskSectionStart);
   assert.ok(
-    triageSection.includes("s.sidecarQueue.push("),
-    "triage section must push to s.sidecarQueue",
+    triageSection.includes("enqueueSidecar(") || triageSection.includes("s.sidecarQueue.push("),
+    "triage section must enqueue to sidecarQueue (via enqueueSidecar or direct push)",
   );
   assert.ok(
-    triageSection.includes('kind: "triage"'),
-    "triage sidecar item must have kind: 'triage'",
+    triageSection.includes('"triage"'),
+    "triage sidecar item must reference kind 'triage'",
   );
 });
 
@@ -149,12 +149,12 @@ test("postUnitPostVerification pushes to sidecarQueue for quick-tasks", () => {
   assert.ok(quickTaskSectionStart > -1, "auto-post-unit.ts must have a quick-task dispatch section");
   const quickTaskSection = source.slice(quickTaskSectionStart);
   assert.ok(
-    quickTaskSection.includes("s.sidecarQueue.push("),
-    "quick-task section must push to s.sidecarQueue",
+    quickTaskSection.includes("enqueueSidecar(") || quickTaskSection.includes("s.sidecarQueue.push("),
+    "quick-task section must enqueue to sidecarQueue (via enqueueSidecar or direct push)",
   );
   assert.ok(
-    quickTaskSection.includes('kind: "quick-task"'),
-    "quick-task sidecar item must have kind: 'quick-task'",
+    quickTaskSection.includes('"quick-task"'),
+    "quick-task sidecar item must reference kind 'quick-task'",
   );
 });
 

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

@@ -75,7 +75,7 @@ test("buildSkillActivationBlock activates skills via prefer_skills when context
       prefer_skills: ["react"],
     });
 
-    assert.match(result, /Call Skill\('react'\)/);
+    assert.match(result, /Call Skill\(\{ skill: 'react' \}\)/);
     assert.doesNotMatch(result, /swiftui/);
   } finally {
     cleanup(base);
@@ -92,7 +92,7 @@ test("buildSkillActivationBlock includes always_use_skills from preferences usin
       always_use_skills: ["swift-testing"],
     });
 
-    assert.equal(result, "<skill_activation>Call Skill('swift-testing').</skill_activation>");
+    assert.equal(result, "<skill_activation>Call Skill({ skill: 'swift-testing' }).</skill_activation>");
   } finally {
     cleanup(base);
   }
@@ -120,8 +120,8 @@ test("buildSkillActivationBlock includes skill_rules matches and task-plan skill
       skill_rules: [{ when: "prisma database schema", use: ["prisma"] }],
     });
 
-    assert.match(result, /Call Skill\('accessibility'\)/);
-    assert.match(result, /Call Skill\('prisma'\)/);
+    assert.match(result, /Call Skill\(\{ skill: 'accessibility' \}\)/);
+    assert.match(result, /Call Skill\(\{ skill: 'prisma' \}\)/);
   } finally {
     cleanup(base);
   }
@@ -191,3 +191,43 @@ test("buildSkillActivationBlock does not activate skills from extraContext or ta
     cleanup(base);
   }
 });
+
+test("buildSkillActivationBlock rejects skill names with special characters", () => {
+  const base = makeTempBase();
+  try {
+    // Skill names with quotes, braces, or other non-alphanumeric characters are
+    // rejected by the SAFE_SKILL_NAME guard to prevent prompt injection.
+    writeSkill(base, "my-skill's", "Skill with apostrophe in name.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, {}, {
+      always_use_skills: ["my-skill's"],
+    });
+
+    // Unsafe skill name is filtered out — empty result
+    assert.equal(result, "");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildSkillActivationBlock allows valid skill names and rejects invalid ones", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "react", "React skill.");
+    writeSkill(base, "bad'name", "Injection attempt.");
+    writeSkill(base, "good-skill-2", "Another valid skill.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, {}, {
+      always_use_skills: ["react", "bad'name", "good-skill-2"],
+    });
+
+    assert.match(result, /skill_activation/);
+    assert.match(result, /Call Skill\(\{ skill: 'react' \}\)/);
+    assert.match(result, /Call Skill\(\{ skill: 'good-skill-2' \}\)/);
+    assert.doesNotMatch(result, /bad'name/);
+  } finally {
+    cleanup(base);
+  }
+});

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

@@ -0,0 +1,193 @@
+/**
+ * Unit tests for GSD Skill Catalog — pack matching logic.
+ *
+ * Exercises matchPacksForProject() to verify that project signals
+ * correctly map to skill packs.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { PROJECT_FILES } from "../detection.ts";
+import { GREENFIELD_STACKS, SKILL_CATALOG, matchPacksForProject } from "../skill-catalog.ts";
+import type { ProjectSignals } from "../detection.ts";
+
+function makeSignals(overrides: Partial<ProjectSignals> = {}): ProjectSignals {
+  return {
+    detectedFiles: [],
+    isGitRepo: false,
+    isMonorepo: false,
+    xcodePlatforms: [],
+    hasCI: false,
+    hasTests: false,
+    verificationCommands: [],
+    ...overrides,
+  };
+}
+
+function packLabels(signals: ProjectSignals): string[] {
+  return matchPacksForProject(signals).map((p) => p.label);
+}
+
+// ── matchAlways packs are always included ────────────────────────────────────
+
+test("matchPacksForProject: always includes matchAlways packs", () => {
+  const labels = packLabels(makeSignals());
+  assert.ok(labels.includes("Skill Discovery"), "should include Skill Discovery");
+  assert.ok(labels.includes("Skill Authoring"), "should include Skill Authoring");
+  assert.ok(labels.includes("Browser Automation"), "should include Browser Automation");
+  assert.ok(labels.includes("Document Handling"), "should include Document Handling");
+  assert.ok(labels.includes("Code Review & Quality"), "should include Code Review & Quality");
+  assert.ok(labels.includes("Git Advanced Workflows"), "should include Git Advanced Workflows");
+});
+
+// ── Language matching ────────────────────────────────────────────────────────
+
+test("matchPacksForProject: Python language matches Python packs", () => {
+  const labels = packLabels(makeSignals({ primaryLanguage: "python", detectedFiles: ["pyproject.toml"] }));
+  assert.ok(labels.includes("Python"), "should include Python");
+  assert.ok(labels.includes("Python Advanced"), "should include Python Advanced");
+});
+
+test("matchPacksForProject: Rust language matches Rust packs", () => {
+  const labels = packLabels(makeSignals({ primaryLanguage: "rust", detectedFiles: ["Cargo.toml"] }));
+  assert.ok(labels.includes("Rust"), "should include Rust");
+  assert.ok(labels.includes("Rust Async Patterns"), "should include Rust Async Patterns");
+});
+
+test("matchPacksForProject: Go language matches Go packs", () => {
+  const labels = packLabels(makeSignals({ primaryLanguage: "go", detectedFiles: ["go.mod"] }));
+  assert.ok(labels.includes("Go"), "should include Go");
+  assert.ok(labels.includes("Go Concurrency Patterns"), "should include Go Concurrency Patterns");
+});
+
+test("matchPacksForProject: JS/TS matches web frontend packs", () => {
+  const labels = packLabels(makeSignals({ primaryLanguage: "javascript/typescript", detectedFiles: ["package.json"] }));
+  assert.ok(labels.includes("React & Web Frontend"), "should include React");
+  assert.ok(labels.includes("TypeScript & JS Development"), "should include TS/JS Dev");
+  assert.ok(labels.includes("React State & Patterns"), "should include React State");
+  assert.ok(labels.includes("shadcn/ui"), "should include shadcn");
+  assert.ok(labels.includes("Frontend Design & UX"), "should include Frontend Design");
+});
+
+// ── File matching ────────────────────────────────────────────────────────────
+
+test("matchPacksForProject: angular.json triggers Angular packs", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["angular.json"] }));
+  assert.ok(labels.includes("Angular"), "should include Angular");
+  assert.ok(labels.includes("Angular Migration"), "should include Angular Migration");
+});
+
+test("matchPacksForProject: next.config.ts triggers Next.js packs", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["next.config.ts"] }));
+  assert.ok(labels.includes("Next.js"), "should include Next.js");
+  assert.ok(labels.includes("Next.js App Router Patterns"), "should include Next.js App Router");
+});
+
+test("matchPacksForProject: *.vue triggers Vue.js", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["*.vue"] }));
+  assert.ok(labels.includes("Vue.js"), "should include Vue.js");
+});
+
+test("matchPacksForProject: Chart.yaml triggers Kubernetes", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["Chart.yaml"] }));
+  assert.ok(labels.includes("Kubernetes"), "should include Kubernetes");
+});
+
+test("matchPacksForProject: hardhat.config.ts triggers Blockchain", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["hardhat.config.ts"] }));
+  assert.ok(labels.includes("Blockchain & Web3"), "should include Blockchain & Web3");
+});
+
+test("matchPacksForProject: tailwind.config.ts triggers Tailwind CSS", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["tailwind.config.ts"] }));
+  assert.ok(labels.includes("Tailwind CSS"), "should include Tailwind CSS");
+});
+
+// ── Xcode platform matching ─────────────────────────────────────────────────
+
+test("matchPacksForProject: iphoneos triggers iOS packs", () => {
+  const labels = packLabels(makeSignals({ xcodePlatforms: ["iphoneos"] }));
+  assert.ok(labels.includes("iOS App Frameworks"), "should include iOS App Frameworks");
+  assert.ok(labels.includes("iOS Data Frameworks"), "should include iOS Data Frameworks");
+  assert.ok(labels.includes("iOS AI & ML"), "should include iOS AI & ML");
+  assert.ok(labels.includes("iOS Engineering"), "should include iOS Engineering");
+  assert.ok(labels.includes("iOS Hardware"), "should include iOS Hardware");
+  assert.ok(labels.includes("iOS Platform"), "should include iOS Platform");
+});
+
+// ── Isolation checks — packs that should NOT match ──────────────────────────
+
+test("matchPacksForProject: FastAPI does not match generic Python", () => {
+  const labels = packLabels(makeSignals({ primaryLanguage: "python", detectedFiles: ["pyproject.toml"] }));
+  assert.ok(!labels.includes("FastAPI"), "FastAPI should NOT match generic Python projects");
+});
+
+test("matchPacksForProject: FastAPI matches when dep:fastapi detected", () => {
+  const labels = packLabels(makeSignals({ primaryLanguage: "python", detectedFiles: ["pyproject.toml", "dep:fastapi"] }));
+  assert.ok(labels.includes("FastAPI"), "FastAPI should match when dep:fastapi is in detectedFiles");
+});
+
+test("matchPacksForProject: Spring Boot does not match via language alone", () => {
+  // Simulate Android project: has java/kotlin language but no root pom.xml/build.gradle
+  const labels = packLabels(makeSignals({ primaryLanguage: "java/kotlin", detectedFiles: ["app/build.gradle"] }));
+  assert.ok(!labels.includes("Java & Spring Boot"), "Spring Boot should NOT match via language alone");
+});
+
+test("matchPacksForProject: Spring Boot matches only dep:spring-boot", () => {
+  const positive = packLabels(makeSignals({ detectedFiles: ["dep:spring-boot"] }));
+  assert.ok(positive.includes("Java & Spring Boot"), "should include Spring Boot pack when dependency marker exists");
+
+  const androidLike = packLabels(makeSignals({ detectedFiles: ["build.gradle", "app/build.gradle"], primaryLanguage: "java/kotlin" }));
+  assert.ok(!androidLike.includes("Java & Spring Boot"), "generic Gradle + Android markers should not imply Spring Boot");
+});
+
+test("matchPacksForProject: Unity does not include Godot", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["ProjectSettings/ProjectVersion.txt"] }));
+  assert.ok(labels.includes("Unity"), "should include Unity");
+  assert.ok(!labels.includes("Godot"), "should NOT include Godot");
+});
+
+test("matchPacksForProject: Godot does not include Unity", () => {
+  const labels = packLabels(makeSignals({ detectedFiles: ["project.godot"] }));
+  assert.ok(labels.includes("Godot"), "should include Godot");
+  assert.ok(!labels.includes("Unity"), "should NOT include Unity");
+});
+
+test("matchPacksForProject: .NET backend patterns match F# and solution markers", () => {
+  const fsprojLabels = packLabels(makeSignals({ detectedFiles: ["*.fsproj"], primaryLanguage: "fsharp" }));
+  assert.ok(fsprojLabels.includes(".NET Backend Patterns"), "should include generic .NET backend patterns for F# projects");
+  assert.ok(!fsprojLabels.includes(".NET & C#"), "should not include C#-specific pack for F# projects");
+
+  const slnLabels = packLabels(makeSignals({ detectedFiles: ["*.sln"], primaryLanguage: "dotnet" }));
+  assert.ok(slnLabels.includes(".NET Backend Patterns"), "should include generic .NET backend patterns for solution files");
+});
+
+test("SKILL_CATALOG: every matchFiles entry is backed by detection", () => {
+  const knownMarkers = new Set<string>([
+    ...PROJECT_FILES,
+    "*.sqlite",
+    "*.sql",
+    "*.csproj",
+    "*.fsproj",
+    "*.sln",
+    "*.vue",
+    "dep:fastapi",
+    "dep:spring-boot",
+  ]);
+
+  for (const pack of SKILL_CATALOG) {
+    for (const marker of pack.matchFiles ?? []) {
+      assert.ok(knownMarkers.has(marker), `Unknown detection marker: ${marker} (pack: ${pack.label})`);
+    }
+  }
+});
+
+test("GREENFIELD_STACKS: every pack label resolves to SKILL_CATALOG", () => {
+  const labels = new Set(SKILL_CATALOG.map((pack) => pack.label));
+
+  for (const stack of GREENFIELD_STACKS) {
+    for (const packLabel of stack.packs) {
+      assert.ok(labels.has(packLabel), `Unknown pack label: ${packLabel} (stack: ${stack.id})`);
+    }
+  }
+});

package/src/resources/extensions/gsd/tests/terminated-transient.test.ts

@@ -47,3 +47,27 @@ test("#2309: rate limits are still transient", () => {
   assert.equal(rlResult.isTransient, true, "rate limits are still transient");
   assert.equal(rlResult.isRateLimit, true, "rate limits are flagged as rate limits");
 });
+
+// --- #2572: stream-truncation JSON parse errors should be transient ---
+
+test("#2572: 'Expected double-quoted property name' (truncated stream) is transient", () => {
+  const result = classifyProviderError("Expected double-quoted property name in JSON at position 23 (line 1 column 24)");
+  assert.equal(result.isTransient, true, "truncated-stream JSON parse error should be transient");
+  assert.equal(result.isRateLimit, false, "not a rate limit");
+  assert.equal(result.suggestedDelayMs, 15_000, "should use 15s backoff like connection errors");
+});
+
+test("#2572: 'Unexpected end of JSON input' (truncated stream) is transient", () => {
+  const result = classifyProviderError("Unexpected end of JSON input");
+  assert.equal(result.isTransient, true, "'Unexpected end of JSON input' should be transient");
+});
+
+test("#2572: 'Unexpected token' in JSON (truncated stream) is transient", () => {
+  const result = classifyProviderError("Unexpected token < in JSON at position 0");
+  assert.equal(result.isTransient, true, "'Unexpected token in JSON' should be transient");
+});
+
+test("#2572: 'SyntaxError' with JSON context (truncated stream) is transient", () => {
+  const result = classifyProviderError("SyntaxError: JSON.parse: unexpected character at line 1 column 1");
+  assert.equal(result.isTransient, true, "'SyntaxError...JSON' should be transient");
+});

package/src/resources/extensions/gsd/tests/tool-naming.test.ts

@@ -44,7 +44,7 @@ console.log('\n── Tool naming: registration count ──');
 const pi = makeMockPi();
 registerDbTools(pi);
 
-assert.deepStrictEqual(pi.tools.length, 26, 'Should register exactly 26 tools (13 canonical + 13 aliases)');
+assert.deepStrictEqual(pi.tools.length, 27, 'Should register exactly 27 tools (13 canonical + 13 aliases + 1 gate tool)');
 
 // ─── Both names exist for each pair ──────────────────────────────────────────
 

package/src/resources/extensions/gsd/tests/triage-dispatch.test.ts

@@ -119,7 +119,7 @@ test("dispatch: triage dispatch keeps the loop in continue mode", () => {
     postUnitSrc.indexOf("// ── Quick-task dispatch"),
   );
   assert.ok(
-    triageBlock.includes('return "continue"'),
+    triageBlock.includes('return "continue"') || triageBlock.includes("return enqueueSidecar("),
     "triage dispatch should return 'continue' after enqueuing sidecar work",
   );
 });
@@ -320,7 +320,7 @@ test("dispatch: quick-task dispatch keeps the loop in continue mode", () => {
     postUnitSrc.indexOf("if (s.stepMode)"),
   );
   assert.ok(
-    quickTaskSection.includes('return "continue"'),
+    quickTaskSection.includes('return "continue"') || quickTaskSection.includes("return enqueueSidecar("),
     "quick-task dispatch should return 'continue' after enqueuing sidecar work",
   );
 });

package/src/resources/extensions/gsd/tests/validate-milestone.test.ts

@@ -6,7 +6,8 @@ import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
 import { deriveState, isValidationTerminal } from "../state.ts";
-import { resolveExpectedArtifactPath, verifyExpectedArtifact, diagnoseExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.ts";
+import { resolveExpectedArtifactPath, diagnoseExpectedArtifact } from "../auto-artifact-paths.ts";
+import { verifyExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.ts";
 import { resolveDispatch, type DispatchContext } from "../auto-dispatch.ts";
 import type { GSDState } from "../types.ts";
 import { clearPathCache } from "../paths.ts";