gsd-pi 2.77.0-dev.58d3d4d6c → 2.77.0-dev.cfd69e714

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

@@ -4,7 +4,13 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { loadSkills } from "@gsd/pi-coding-agent";
-import { buildSkillActivationBlock } from "../auto-prompts.js";
+import {
+  buildPlanMilestonePrompt,
+  buildResearchMilestonePrompt,
+  buildSkillActivationBlock,
+} from "../auto-prompts.js";
+import { warnIfManifestHasMissingSkills } from "../skill-manifest.js";
+import { _resetLogs, drainLogs, setStderrLoggingEnabled } from "../workflow-logger.js";
 import type { GSDPreferences } from "../preferences.js";
 
 function makeTempBase(): string {
@@ -25,6 +31,11 @@ function loadOnlyTestSkills(base: string): void {
   loadSkills({ cwd: base, includeDefaults: false, skillPaths: [join(base, "skills")] });
 }
 
+function writeProjectPreferences(base: string, preferences: string): void {
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), `---\n${preferences}---\n`);
+}
+
 function buildBlock(
   base: string,
   params: Partial<Parameters<typeof buildSkillActivationBlock>[0]> = {},
@@ -231,3 +242,111 @@ test("buildSkillActivationBlock allows valid skill names and rejects invalid one
     cleanup(base);
   }
 });
+
+// ─── Per-unit-type skill manifest (RFC #4779) ─────────────────────────────────
+
+test("buildSkillActivationBlock: explicit always_use_skills bypass the unit-type manifest", () => {
+  const base = makeTempBase();
+  try {
+    // write-docs is in the research-milestone manifest; swiftui is not.
+    // Both are in always_use_skills — a user-explicit source — so BOTH
+    // should activate regardless of the manifest. User intent wins over
+    // unit-type defaults. See RFC #4779 and skill-manifest.ts rationale.
+    writeSkill(base, "write-docs", "Use when writing docs or RFCs.");
+    writeSkill(base, "swiftui", "Use for SwiftUI views.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, { unitType: "research-milestone" }, {
+      always_use_skills: ["write-docs", "swiftui"],
+    });
+
+    assert.match(result, /Call Skill\(\{ skill: 'write-docs' \}\)/);
+    assert.match(result, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildSkillActivationBlock falls through to all skills for unknown unit type", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "swiftui", "Use for SwiftUI views.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, { unitType: "unknown-unit-type" }, {
+      always_use_skills: ["swiftui"],
+    });
+
+    // Unknown unit type = wildcard fallback (pre-manifest behavior).
+    assert.match(result, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildSkillActivationBlock without unitType preserves pre-manifest behavior", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "swiftui", "Use for SwiftUI views.");
+    loadOnlyTestSkills(base);
+
+    // No unitType param — filter should no-op.
+    const result = buildBlock(base, {}, {
+      always_use_skills: ["swiftui"],
+    });
+
+    assert.match(result, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("milestone prompt builders propagate always_use_skills through buildSkillActivationBlock", async () => {
+  const base = makeTempBase();
+  try {
+    // Both skills are in always_use_skills — explicit user intent bypasses
+    // the unit-type manifest, so both activate in both milestone flows.
+    writeSkill(base, "write-docs", "Use when writing docs or RFCs.");
+    writeSkill(base, "swiftui", "Use for SwiftUI views.");
+    writeProjectPreferences(base, "always_use_skills:\n  - write-docs\n  - swiftui\n");
+    loadOnlyTestSkills(base);
+
+    const researchPrompt = await buildResearchMilestonePrompt("M001", "Test", base);
+    assert.match(researchPrompt, /Call Skill\(\{ skill: 'write-docs' \}\)/);
+    assert.match(researchPrompt, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+
+    const planPrompt = await buildPlanMilestonePrompt("M001", "Test", base);
+    assert.match(planPrompt, /Call Skill\(\{ skill: 'write-docs' \}\)/);
+    assert.match(planPrompt, /Call Skill\(\{ skill: 'swiftui' \}\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("skill manifest strict warnings require GSD_SKILL_MANIFEST_STRICT=1", (t) => {
+  const previousStrict = process.env.GSD_SKILL_MANIFEST_STRICT;
+  const previousStderr = setStderrLoggingEnabled(false);
+  t.after(() => {
+    if (previousStrict === undefined) {
+      delete process.env.GSD_SKILL_MANIFEST_STRICT;
+    } else {
+      process.env.GSD_SKILL_MANIFEST_STRICT = previousStrict;
+    }
+    setStderrLoggingEnabled(previousStderr);
+    _resetLogs();
+  });
+
+  process.env.GSD_SKILL_MANIFEST_STRICT = "0";
+  _resetLogs();
+  warnIfManifestHasMissingSkills("research-milestone", new Set());
+  assert.equal(drainLogs().length, 0, "strict=0 must preserve silent behavior");
+
+  process.env.GSD_SKILL_MANIFEST_STRICT = "1";
+  _resetLogs();
+  warnIfManifestHasMissingSkills("research-milestone", new Set());
+  const logs = drainLogs();
+  assert.ok(
+    logs.some(log => log.message.includes("skill-manifest: references uninstalled skill")),
+    "strict=1 should warn about missing manifest entries",
+  );
+});

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

@@ -0,0 +1,112 @@
+// GSD2 + skill-manifest.test — unit coverage for the skill manifest resolver
+//
+// Focused tests for `resolveSkillManifest` and `filterSkillsByManifest`.
+// Covers the wildcard semantics, the newly seeded unit-type entries
+// (complete-milestone, validate-milestone, reassess-roadmap, research-slice,
+// plan-slice, refine-slice, replan-slice, run-uat), and the deliberate
+// wildcard fallback for the execute-task hot path (RFC #4779).
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  resolveSkillManifest,
+  filterSkillsByManifest,
+} from "../skill-manifest.js";
+
+const NEWLY_WIRED_UNIT_TYPES = [
+  "complete-milestone",
+  "validate-milestone",
+  "reassess-roadmap",
+  "research-slice",
+  "plan-slice",
+  "refine-slice",
+  "replan-slice",
+  "run-uat",
+] as const;
+
+test("resolveSkillManifest returns null for undefined unit type (wildcard)", () => {
+  assert.equal(resolveSkillManifest(undefined), null);
+});
+
+test("resolveSkillManifest returns null for unknown unit types (wildcard fallback)", () => {
+  assert.equal(resolveSkillManifest("nonexistent-unit-type"), null);
+});
+
+test("resolveSkillManifest returns null for execute-task (intentional wildcard)", () => {
+  // execute-task is the implementation hot path; allowlisting it requires
+  // per-task skill hints from task-plan frontmatter. Documented in
+  // skill-manifest.ts — regression guard.
+  assert.equal(resolveSkillManifest("execute-task"), null);
+});
+
+for (const unitType of NEWLY_WIRED_UNIT_TYPES) {
+  test(`resolveSkillManifest returns a non-empty allowlist for '${unitType}'`, () => {
+    const allowlist = resolveSkillManifest(unitType);
+    assert.ok(allowlist !== null, `${unitType} should resolve to an allowlist, not wildcard`);
+    assert.ok(allowlist.length > 0, `${unitType} allowlist should not be empty`);
+    // Every entry must be lowercase (normalized).
+    for (const name of allowlist) {
+      assert.equal(name, name.toLowerCase(), `${unitType} entry '${name}' should be lowercase`);
+    }
+  });
+}
+
+test("resolveSkillManifest: slice-level manifests include decompose-into-slices", () => {
+  // Planning-shaped slice flows all benefit from the decomposition skill.
+  // Sanity-check a representative entry from each.
+  for (const unitType of ["research-slice", "plan-slice", "refine-slice", "replan-slice"] as const) {
+    const allowlist = resolveSkillManifest(unitType);
+    assert.ok(
+      allowlist?.includes("decompose-into-slices"),
+      `${unitType} should list decompose-into-slices`,
+    );
+  }
+});
+
+test("resolveSkillManifest: validation / completion flows include verify-before-complete", () => {
+  for (const unitType of ["complete-milestone", "validate-milestone", "run-uat"] as const) {
+    const allowlist = resolveSkillManifest(unitType);
+    assert.ok(
+      allowlist?.includes("verify-before-complete"),
+      `${unitType} should list verify-before-complete`,
+    );
+  }
+});
+
+test("filterSkillsByManifest: pass-through when unit type is unknown", () => {
+  const skills = [{ name: "swiftui" }, { name: "solidity-security" }];
+  const result = filterSkillsByManifest(skills, "nonexistent-unit-type");
+  assert.deepEqual(result, skills);
+});
+
+test("filterSkillsByManifest: pass-through when unitType is undefined", () => {
+  const skills = [{ name: "swiftui" }];
+  const result = filterSkillsByManifest(skills, undefined);
+  assert.deepEqual(result, skills);
+});
+
+test("filterSkillsByManifest: restricts to allowlisted names for known unit type", () => {
+  // research-slice allowlists include decompose-into-slices but not swiftui.
+  const skills = [
+    { name: "decompose-into-slices" },
+    { name: "swiftui" },
+    { name: "write-docs" },
+  ];
+  const result = filterSkillsByManifest(skills, "research-slice");
+  const names = result.map(s => s.name);
+  assert.ok(names.includes("decompose-into-slices"));
+  assert.ok(names.includes("write-docs"));
+  assert.ok(!names.includes("swiftui"));
+});
+
+test("filterSkillsByManifest: matching is case-insensitive via normalize", () => {
+  const skills = [
+    { name: "Write-Docs" }, // different case from manifest entry
+    { name: "SWIFTUI" },
+  ];
+  const result = filterSkillsByManifest(skills, "research-milestone");
+  const names = result.map(s => s.name);
+  assert.ok(names.includes("Write-Docs"));
+  assert.ok(!names.includes("SWIFTUI"));
+});

package/src/resources/extensions/gsd/tests/slice-parallel-orchestrator.test.ts

@@ -6,13 +6,83 @@
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
+import { restoreSliceState } from "../slice-parallel-orchestrator.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const gsdDir = join(__dirname, "..");
 
+function readLinuxProcessStartFingerprint(pid: number): string | null {
+  try {
+    const stat = readFileSync(`/proc/${pid}/stat`, "utf-8");
+    const afterCommand = stat.slice(stat.lastIndexOf(")") + 2).trim();
+    const fields = afterCommand.split(/\s+/);
+    const startTimeTicks = fields[19];
+    return startTimeTicks ? `linux-stat:${startTimeTicks}` : null;
+  } catch {
+    return null;
+  }
+}
+
+function readPsProcessStartFingerprint(pid: number): string | null {
+  try {
+    const raw = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf-8",
+    }).trim().replace(/\s+/g, " ");
+    return raw ? `ps-lstart:${raw}` : null;
+  } catch {
+    return null;
+  }
+}
+
+function readProcessStartFingerprint(pid: number): string | null {
+  return readLinuxProcessStartFingerprint(pid) ?? readPsProcessStartFingerprint(pid);
+}
+
+function makeTempProject(): string {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-slice-parallel-"));
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+  return basePath;
+}
+
+function writeSliceOrchestratorState(
+  basePath: string,
+  worker: {
+    pid: number;
+    workerToken?: string;
+    processStartFingerprint?: string | null;
+  },
+): void {
+  writeFileSync(
+    join(basePath, ".gsd", "slice-orchestrator.json"),
+    JSON.stringify({
+      active: true,
+      workers: [{
+        milestoneId: "M900",
+        sliceId: "S01",
+        pid: worker.pid,
+        workerToken: worker.workerToken,
+        processStartFingerprint: worker.processStartFingerprint,
+        worktreePath: join(basePath, ".gsd", "worktrees", "M900-S01"),
+        startedAt: Date.now(),
+        state: "running",
+        completedUnits: 0,
+        cost: 0,
+      }],
+      totalCost: 0,
+      maxWorkers: 1,
+      startedAt: Date.now(),
+      basePath,
+    }),
+    "utf-8",
+  );
+}
+
 describe("slice-parallel-orchestrator structural tests", () => {
   it("orchestrator uses GSD_SLICE_LOCK env var", () => {
     const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
@@ -46,6 +116,99 @@ describe("slice-parallel-orchestrator structural tests", () => {
       "Orchestrator must also pass GSD_MILESTONE_LOCK for milestone context",
     );
   });
+
+  it("recovery preserves terminal workers for coordinator-side collection", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes('} else if (w.state === "running")') &&
+        source.includes("survivors.push(w);"),
+      "Recovery must only prune dead running workers, not stopped/error workers",
+    );
+  });
+
+  it("recovered PID-only workers are validated before signaling", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes("isRecoveredSliceWorkerAlive(worker)") &&
+        source.includes('process.kill(worker.pid, "SIGTERM")'),
+      "stopSliceParallel must validate recovered worker identity before signaling a PID",
+    );
+  });
+
+  it("persists worker identity for crash recovery", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes("workerToken") &&
+        source.includes("processStartFingerprint") &&
+        source.includes("GSD_SLICE_WORKER_TOKEN"),
+      "Orchestrator must persist stable worker identity metadata for recovered workers",
+    );
+  });
+
+  it("spawn failures remove stale worker state and worktree", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes("sliceState.workers.delete(slice.id)") &&
+        source.includes("removeWorktree(basePath, wtName, { deleteBranch: true, force: true })"),
+      "Failed slice worker spawns must remove stale worker state and clean up the worktree",
+    );
+  });
+});
+
+describe("slice-parallel-orchestrator recovery identity", () => {
+  it("rejects a live PID when the process start fingerprint does not match", () => {
+    const basePath = makeTempProject();
+    try {
+      writeSliceOrchestratorState(basePath, {
+        pid: process.pid,
+        processStartFingerprint: "mismatched-fingerprint",
+      });
+
+      const restored = restoreSliceState(basePath);
+      assert.equal(restored, null, "mismatched fingerprint is treated as a dead worker");
+      assert.equal(
+        existsSync(join(basePath, ".gsd", "slice-orchestrator.json")),
+        false,
+        "state file is removed when no recovered worker identity validates",
+      );
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  it("keeps a recovered worker when PID, token, and process start fingerprint match", async () => {
+    const basePath = makeTempProject();
+    const token = `test-token-${Date.now()}`;
+    const child = spawn(
+      process.execPath,
+      ["-e", "setTimeout(() => {}, 30000)"],
+      {
+        env: { ...process.env, GSD_SLICE_WORKER_TOKEN: token },
+        stdio: "ignore",
+      },
+    );
+
+    try {
+      assert.ok(child.pid, "child process has a pid");
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      const fingerprint = readProcessStartFingerprint(child.pid!);
+      if (!fingerprint) return;
+
+      writeSliceOrchestratorState(basePath, {
+        pid: child.pid!,
+        workerToken: token,
+        processStartFingerprint: fingerprint,
+      });
+
+      const restored = restoreSliceState(basePath);
+      assert.ok(restored, "matching worker identity is restored");
+      assert.equal(restored.workers.length, 1);
+      assert.equal(restored.workers[0].pid, child.pid);
+    } finally {
+      child.kill("SIGTERM");
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
 });
 
 describe("slice_parallel preference gating", () => {

package/src/resources/extensions/gsd/tests/state-machine-full-walkthrough.test.ts

@@ -835,9 +835,9 @@ describe("state-machine-full-walkthrough", () => {
       assert.ok(state.blockers.length > 0, "should have blockers");
     });
 
-    test("no eligible slice (all deps unmet) → fallback picks slice with most deps satisfied", async () => {
+    test("no eligible slice (all deps unmet) → blocked", async () => {
       const base = createFixtureBase();
-      // S01 depends on S00 which doesn't exist — fallback picks S01 anyway
+      // S01 depends on S00 which doesn't exist.
       writeRoadmap(base, "M001", [
         "# M001: Test Milestone",
         "",
@@ -851,9 +851,9 @@ describe("state-machine-full-walkthrough", () => {
       invalidateStateCache();
       const state = await deriveState(base);
 
-      // With partial-dep fallback, S01 is picked despite unmet dep on S00
-      assert.equal(state.phase, "planning");
-      assert.equal(state.activeSlice?.id, "S01");
+      assert.equal(state.phase, "blocked");
+      assert.equal(state.activeSlice, null);
+      assert.ok(state.blockers.some(b => b.includes("No slice eligible")));
     });
   });
 

package/src/resources/extensions/gsd/tests/structured-data-formatter.test.ts

@@ -271,96 +271,15 @@ describe("structured-data-formatter: measureSavings", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Realistic token savings measurement
+// Dropped (#4836): the previous "realistic savings" suite asserted that the
+// compact formatter beat hand-authored "typical markdown" baselines by 30%+.
+// Those baselines were written by the test author to make the assertion pass
+// — they are not the format GSD actually emits anywhere else, so shifting
+// the compact output by any amount could be absorbed by padding the baseline.
+// There was no regression signal.
+//
+// The unit tests above already pin the compact format's structure byte for
+// byte; a genuine regression changes one of those exact-string assertions.
+// If a size-budget guarantee is needed later, capture a real production
+// baseline into a fixture file and assert against a checked-in byte count.
 // ---------------------------------------------------------------------------
-
-describe("structured-data-formatter: realistic savings", () => {
-  it("decisions compact format saves 30%+ vs markdown table", () => {
-    const decisions = [sampleDecision, sampleDecision2];
-
-    // Simulate a typical markdown table
-    const markdownTable = [
-      "| ID   | When       | Scope        | Decision                | Choice                 | Rationale                | Revisable |",
-      "|------|------------|--------------|-------------------------|------------------------|--------------------------|-----------|",
-      "| D001 | M001/S01   | architecture | Use SQLite for storage  | WAL mode, single-writer | Built-in, no external deps | yes       |",
-      "| D002 | M001/S02   | testing      | Unit test all parsers   | node:test framework    | Fast, zero-dependency    | no        |",
-    ].join("\n");
-
-    const compactOutput = formatDecisionsCompact(decisions);
-    const savings = measureSavings(compactOutput, markdownTable);
-    assert.ok(
-      savings >= 30,
-      `expected >=30% savings, got ${savings.toFixed(1)}%`,
-    );
-  });
-
-  it("requirements compact format saves 30%+ vs markdown sections", () => {
-    const requirements = [sampleRequirement, sampleRequirement2];
-
-    // Simulate verbose markdown format with all fields
-    const markdownSections = [
-      "## R001",
-      "",
-      "- **Class:** functional",
-      "- **Status:** active",
-      "- **Description:** Response latency < 200ms for API endpoints",
-      "- **Why:** Critical for user experience",
-      "- **Source:** architecture review",
-      "- **Primary Owner:** S01",
-      "- **Supporting Slices:** S02, S03",
-      "- **Validation:** Load test confirms P99 < 200ms",
-      "- **Notes:** Monitor in production",
-      "",
-      "## R002",
-      "",
-      "- **Class:** non-functional",
-      "- **Status:** active",
-      "- **Description:** Data consistency across writes",
-      "- **Why:** Prevents data loss",
-      "- **Source:** data team review",
-      "- **Primary Owner:** S02",
-      "- **Supporting Slices:** S01",
-      "- **Validation:** Integration test suite",
-      "- **Notes:** Requires WAL mode",
-    ].join("\n");
-
-    const compactOutput = formatRequirementsCompact(requirements);
-    const savings = measureSavings(compactOutput, markdownSections);
-    assert.ok(
-      savings >= 30,
-      `expected >=30% savings, got ${savings.toFixed(1)}%`,
-    );
-  });
-
-  it("task plan compact format saves 30%+ vs markdown sections", () => {
-    const tasks = [sampleTaskDone, sampleTaskPending];
-
-    // Simulate verbose markdown task format
-    const markdownTasks = [
-      "## T01 - Database schema",
-      "",
-      "- **Status:** Done",
-      "- **Estimate:** 30m",
-      "- **Description:** Create tables for decisions and requirements",
-      "- **Files:**",
-      "  - src/db.ts",
-      "  - src/schema.ts",
-      "",
-      "## T02 - API endpoints",
-      "",
-      "- **Status:** Pending",
-      "- **Estimate:** 1h",
-      "- **Description:** REST endpoints for CRUD operations",
-      "- **Files:**",
-      "  - src/api.ts",
-      "- **Verify:** npm test",
-    ].join("\n");
-
-    const compactOutput = formatTaskPlanCompact(tasks);
-    const savings = measureSavings(compactOutput, markdownTasks);
-    assert.ok(
-      savings >= 30,
-      `expected >=30% savings, got ${savings.toFixed(1)}%`,
-    );
-  });
-});