@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.75048e7

package/src/resources/extensions/gsd/tests/merge-closeout-consistency-gate.test.ts

@@ -0,0 +1,63 @@
+// Project/App: gsd-pi
+// File Purpose: Regression tests for DB-backed closeout consistency before merge.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { mergeMilestoneToMain } from "../auto-worktree.ts";
+import { closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function createRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "merge-closeout-gate-")));
+  git(["init"], dir);
+  git(["config", "user.email", "test@test.com"], dir);
+  git(["config", "user.name", "Test"], dir);
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  git(["add", "."], dir);
+  git(["commit", "-m", "init"], dir);
+  git(["branch", "-M", "main"], dir);
+
+  git(["checkout", "-b", "milestone/M001"], dir);
+  writeFileSync(join(dir, "feature.ts"), "export const feature = true;\n");
+  git(["add", "feature.ts"], dir);
+  git(["commit", "-m", "feat: milestone work"], dir);
+  git(["checkout", "main"], dir);
+  return dir;
+}
+
+test("mergeMilestoneToMain blocks when project DB closeout is still open", () => {
+  const savedCwd = process.cwd();
+  const repo = createRepo();
+  try {
+    assert.equal(openDatabase(join(repo, ".gsd", "gsd.db")), true);
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+
+    const mainHeadBefore = git(["rev-parse", "main"], repo);
+    process.chdir(repo);
+
+    assert.throws(
+      () => mergeMilestoneToMain(repo, "M001", "# M001\n- [x] **S01: Done**\n"),
+      /closeout-consistency-blocked/,
+    );
+
+    assert.equal(git(["rev-parse", "main"], repo), mainHeadBefore);
+    assert.equal(git(["branch", "--show-current"], repo), "main");
+  } finally {
+    closeDatabase();
+    process.chdir(savedCwd);
+    if (existsSync(repo)) rmSync(repo, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/merge-db-cycle.test.ts

@@ -15,7 +15,7 @@ import { delimiter, join } from "node:path";
 import { execFileSync } from "node:child_process";
 
 import { mergeMilestoneToMain } from "../auto-worktree.ts";
-import { closeDatabase, openDatabase } from "../gsd-db.ts";
+import { closeDatabase, insertAssessment, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 import { GIT_NO_PROMPT_ENV } from "../git-constants.js";
 import { _clearGsdRootCache } from "../paths.ts";
 import { _resetServiceCache } from "../worktree.ts";
@@ -145,6 +145,15 @@ test("mergeMilestoneToMain keeps the Windows DB cycle closed through squash merg
 
     withPlatform("win32", () => {
       assert.equal(openDatabase(join(repo, ".gsd", "gsd.db")), true);
+      insertMilestone({ id: "M001", title: "Windows DB cycle", status: "complete" });
+      insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+      insertAssessment({
+        path: "milestones/M001/M001-VALIDATION.md",
+        milestoneId: "M001",
+        status: "pass",
+        scope: "milestone-validation",
+        fullContent: "verdict: pass",
+      });
       assert.equal(existsSync(join(repo, ".gsd", "gsd.db-shm")), true);
 
       process.env.PATH = `${bin}${delimiter}${originalPath}`;

package/src/resources/extensions/gsd/tests/migration-auto-check.test.ts

@@ -102,8 +102,8 @@ test("migration auto-check preserves empty DB and reports explicit recovery", as
     assert.equal(result.action, "recovery-required");
     assert.equal(result.reason, "db-empty");
     assert.deepEqual(result.afterDb, { milestones: 0, slices: 0, tasks: 0 });
-    assert.equal(result.recoveryCommand, "/gsd recover");
-    assert.match(result.message ?? "", /run `\/gsd recover`/);
+    assert.equal(result.recoveryCommand, "/gsd recover --confirm");
+    assert.match(result.message ?? "", /run `\/gsd recover --confirm`/);
     assert.equal(getAllMilestones().length, 0);
     assert.equal(getSliceTasks("M001", "S01").length, 0);
   } finally {
@@ -125,7 +125,7 @@ test("migration auto-check preserves DB on hierarchy count mismatch", async () =
     assert.equal(result.reason, "count-mismatch");
     assert.deepEqual(result.beforeDb, { milestones: 1, slices: 1, tasks: 0 });
     assert.deepEqual(result.afterDb, { milestones: 1, slices: 1, tasks: 0 });
-    assert.equal(result.recoveryCommand, "/gsd recover");
+    assert.equal(result.recoveryCommand, "/gsd recover --confirm");
     assert.equal(getSliceTasks("M001", "S01").length, 0);
   } finally {
     cleanup(base);

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

@@ -6,7 +6,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { openDatabase, insertMilestone, closeDatabase } from "../gsd-db.js";
+import { openDatabase, insertAssessment, insertMilestone, insertSlice, closeDatabase } from "../gsd-db.js";
 import {
   isMilestoneCloseoutSettled,
   evaluateCompleteMilestoneDispatch,
@@ -39,6 +39,14 @@ test("isMilestoneCloseoutSettled requires DB closed and summary artifact", async
   mkdirSync(join(base, ".gsd"), { recursive: true });
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M001", title: "Done", status: "complete" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+  insertAssessment({
+    path: "milestones/M001/M001-VALIDATION.md",
+    milestoneId: "M001",
+    status: "pass",
+    scope: "milestone-validation",
+    fullContent: "verdict: pass",
+  });
   const milestoneDir = join(base, ".gsd", "milestones", "M001");
   mkdirSync(milestoneDir, { recursive: true });
   writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), "# Milestone Summary\n");

package/src/resources/extensions/gsd/tests/new-milestone-discuss-routing.test.ts

@@ -13,10 +13,10 @@ test("dispatchNewMilestoneDiscuss uses discuss.md only on greenfield projects",
 
   assert.match(fnBody, /findMilestoneIds\(basePath\)\.length === 0/);
   assert.match(fnBody, /prepareAndBuildDiscussPrompt/);
-  assert.match(fnBody, /loadPrompt\("guided-discuss-milestone"/);
+  assert.match(fnBody, /buildDiscussMilestonePrompt/);
   assert.match(
     fnBody,
-    /if \(isGreenfield\)[\s\S]*prepareAndBuildDiscussPrompt[\s\S]*loadPrompt\("guided-discuss-milestone"/,
+    /if \(isGreenfield\)[\s\S]*prepareAndBuildDiscussPrompt[\s\S]*buildDiscussMilestonePrompt/,
     "greenfield branch must precede guided-discuss-milestone branch",
   );
 });
@@ -24,7 +24,7 @@ test("dispatchNewMilestoneDiscuss uses discuss.md only on greenfield projects",
 test("dispatchNewMilestoneDiscuss uses milestone-specific preparation guidance", () => {
   const source = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
   const fnBody = extractSourceRegion(source, "async function dispatchNewMilestoneDiscuss(");
-  assert.match(fnBody, /buildDiscussPreparationContext\(ctx, basePath, "milestone"\)/);
+  assert.match(fnBody, /buildDiscussPreparationContext\(ctx, basePath, "milestone", true\)/);
 });
 
 test("launchNextMilestoneDiscuss routes through dispatchNewMilestoneDiscuss for normal path", () => {

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -22,23 +22,31 @@ import { tmpdir } from "node:os";
 
 import { loadSkills } from "@gsd/pi-coding-agent";
 import {
-  buildResearchSlicePrompt,
+  buildCompleteSlicePrompt,
   buildParallelResearchSlicesPrompt,
+  buildResearchSlicePrompt,
 } from "../auto-prompts.ts";
 
 const SKILL_NAME = "testskill";
+const COMPLETE_SLICE_SKILL_NAME = "complete-slice-policies";
 const SKILL_ACTIVATION_SUBSTRING = `Call Skill({ skill: '${SKILL_NAME}' })`;
+const COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING = `Call Skill({ skill: '${COMPLETE_SLICE_SKILL_NAME}' })`;
 
 const tmpDirs: string[] = [];
 let savedCwd: string | undefined;
 
-function setupProjectWithSkill(): string {
+function setupProjectWithSkill(options: {
+  skillName?: string;
+  preferencesLines?: string[];
+} = {}): string {
+  const skillName = options.skillName ?? SKILL_NAME;
   const base = mkdtempSync(join(tmpdir(), "gsd-worker-skill-int-"));
   tmpDirs.push(base);
 
   // Milestone roadmap — buildResearchSlicePrompt inlines the roadmap excerpt.
   const milestoneDir = join(base, ".gsd", "milestones", "M001");
-  mkdirSync(join(milestoneDir, "slices", "S01"), { recursive: true });
+  const sliceOneDir = join(milestoneDir, "slices", "S01");
+  mkdirSync(join(sliceOneDir, "tasks"), { recursive: true });
   mkdirSync(join(milestoneDir, "slices", "S02"), { recursive: true });
   writeFileSync(
     join(milestoneDir, "M001-ROADMAP.md"),
@@ -55,27 +63,41 @@ function setupProjectWithSkill(): string {
     ].join("\n"),
     "utf-8",
   );
+  writeFileSync(
+    join(sliceOneDir, "S01-PLAN.md"),
+    [
+      "# S01: Alpha",
+      "",
+      "**Goal:** Verify worker x skill prompt plumbing.",
+      "**Demo:** Rendered prompts include the skill activation block.",
+      "",
+      "## Tasks",
+      "- [x] **T01: Task** `est:10m`",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
 
   // Project preferences — buildSkillActivationBlock picks these up via
   // loadEffectiveGSDPreferences(), which reads from `${cwd}/.gsd/PREFERENCES.md`.
   writeFileSync(
     join(base, ".gsd", "PREFERENCES.md"),
-    ["---", `always_use_skills:`, `  - ${SKILL_NAME}`, "---", ""].join("\n"),
+    ["---", ...(options.preferencesLines ?? [`always_use_skills:`, `  - ${skillName}`]), "---", ""].join("\n"),
     "utf-8",
   );
 
   // Project-scoped skill — resolveSkillReference scans `${cwd}/.agents/skills/`.
-  const skillDir = join(base, ".agents", "skills", SKILL_NAME);
+  const skillDir = join(base, ".agents", "skills", skillName);
   mkdirSync(skillDir, { recursive: true });
   writeFileSync(
     join(skillDir, "SKILL.md"),
     [
       "---",
-      `name: ${SKILL_NAME}`,
+      `name: ${skillName}`,
       `description: Integration-test skill for worker × skill prompt plumbing.`,
       "---",
       "",
-      `# ${SKILL_NAME}`,
+      `# ${skillName}`,
       "",
       "Test skill body.",
     ].join("\n"),
@@ -122,6 +144,31 @@ test("worker prompt (buildResearchSlicePrompt) includes <skill_activation> from
   );
 });
 
+test("complete-slice prompt includes <skill_activation> from unit-specific skill_rules", async () => {
+  const base = setupProjectWithSkill({
+    skillName: COMPLETE_SLICE_SKILL_NAME,
+    preferencesLines: [
+      "skill_rules:",
+      "  - when: complete-slice",
+      "    use:",
+      `      - ${COMPLETE_SLICE_SKILL_NAME}`,
+    ],
+  });
+  savedCwd = process.cwd();
+  process.chdir(base);
+
+  const prompt = await buildCompleteSlicePrompt("M001", "Test Milestone", "S01", "Alpha", base, "minimal");
+
+  assert.ok(
+    prompt.includes("<skill_activation>"),
+    "complete-slice prompt should contain a <skill_activation> block",
+  );
+  assert.ok(
+    prompt.includes(COMPLETE_SLICE_SKILL_ACTIVATION_SUBSTRING),
+    `complete-slice prompt should reference the skill-rule skill '${COMPLETE_SLICE_SKILL_NAME}'`,
+  );
+});
+
 test("subagent dispatch prompt (buildParallelResearchSlicesPrompt) carries <skill_activation> into each embedded per-slice section", async () => {
   const base = setupProjectWithSkill();
   savedCwd = process.cwd();

package/src/resources/extensions/gsd/tests/plan-slice-prompt.test.ts

@@ -83,6 +83,15 @@ test("plan-slice prompt: compact planning gates survive template substitution",
   assert.ok(!result.includes("{{"));
 });
 
+test("plan-slice prompt: absence checks use negated quiet searches", () => {
+  const result = loadPrompt("plan-slice", { ...BASE_VARS, commitInstruction: "Do not commit." });
+  assert.ok(result.includes("For absence checks"));
+  assert.ok(result.includes("`! grep -q 'pattern' file`"));
+  assert.ok(result.includes("`! rg -q 'pattern' file`"));
+  assert.ok(result.includes("do not use `grep -c` or `rg -c`"));
+  assert.ok(result.includes("count commands exit 1 when they find zero matches"));
+});
+
 test("plan-slice prompt: footer references gsd_plan_slice tool, not direct write", () => {
   const result = loadPrompt("plan-slice", { ...BASE_VARS, commitInstruction: "Do not commit." });
   assert.ok(

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

@@ -6,7 +6,7 @@ import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, getSlice, getSliceTasks, getTask, getGateResults, updateTaskStatus } from '../gsd-db.ts';
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getSlice, getSliceTasks, getTask, getGateResults, updateTaskStatus } from '../gsd-db.ts';
 import { handlePlanSlice } from '../tools/plan-slice.ts';
 import { parsePlan } from '../parsers-legacy.ts';
 import { parseTaskPlanFile } from '../files.ts';
@@ -265,6 +265,44 @@ test('handlePlanSlice renders plan artifacts under worktree-local .gsd while usi
   }
 });
 
+test('handlePlanSlice preserves completed task closeout state when replanning the same task', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+    insertTask({
+      id: 'T01',
+      sliceId: 'S02',
+      milestoneId: 'M001',
+      title: 'Completed implementation',
+      status: 'complete',
+      oneLiner: 'Completed implementation',
+      narrative: 'Already finished.',
+      verificationResult: 'passed',
+      fullSummaryMd: '# T01 Summary\n\nAlready finished.\n',
+    });
+
+    const before = getTask('M001', 'S02', 'T01');
+    assert.equal(before?.status, 'complete');
+    assert.ok(before?.completed_at, 'completed task should have a completion timestamp');
+    assert.equal(before?.full_summary_md, '# T01 Summary\n\nAlready finished.\n');
+
+    const result = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const after = getTask('M001', 'S02', 'T01');
+    assert.equal(after?.status, 'complete', 'replanning must not reset completed task status to pending');
+    assert.equal(after?.completed_at, before?.completed_at, 'replanning must not clear completed_at');
+    assert.equal(after?.full_summary_md, before?.full_summary_md, 'replanning must not clear task summary content');
+    assert.equal(after?.verification_result, 'passed', 'replanning must not clear closeout verification');
+    assert.equal(after?.description, 'Implement the slice planning handler.', 'planning fields should still refresh');
+    assert.equal(getTask('M001', 'S02', 'T02')?.status, 'pending', 'new tasks are still inserted as pending');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice advances DB-derived state out of planning immediately', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/post-unit-hooks.test.ts

@@ -11,6 +11,7 @@ import {
   resetHookState,
   isRetryPending,
   consumeRetryTrigger,
+  consumeGateBlock,
   resolveHookArtifactPath,
   runPreDispatchHooks,
   persistHookState,
@@ -20,6 +21,7 @@ import {
   formatHookStatus,
   triggerHookManually,
 } from "../post-unit-hooks.ts";
+import { invalidateAllCaches } from "../cache.ts";
 
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
 
@@ -29,6 +31,11 @@ function createFixtureBase(): string {
   return base;
 }
 
+function writeHookPreferences(base: string, hookYaml: string): void {
+  writeFileSync(join(base, ".gsd", "PREFERENCES.md"), `---\npost_unit_hooks:\n${hookYaml}\n---\n`, "utf-8");
+  invalidateAllCaches();
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Phase 1: Post-Unit Hook Tests
 // ═══════════════════════════════════════════════════════════════════════════
@@ -104,6 +111,156 @@ test('consumeRetryTrigger clears state', () => {
   assert.ok(!isRetryPending(), "no retry initially");
 });
 
+test('Advisory hook keeps artifact idempotency without verdict frontmatter', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: docs-hint
+    after:
+      - execute-task
+    prompt: Review docs
+    artifact: DOCS-HINT.md
+`);
+    writeFileSync(resolveHookArtifactPath(base, "M001/S01/T01", "DOCS-HINT.md"), "plain advisory note", "utf-8");
+
+    const result = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.deepStrictEqual(result, null, "existing advisory artifact remains idempotent");
+    assert.deepStrictEqual(consumeGateBlock(), null, "advisory hook does not create gate block");
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('Blocking hook skips only after passing frontmatter verdict', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: security-review
+    after:
+      - execute-task
+    prompt: Review security
+    artifact: SECURITY-REVIEW.md
+    criticality: blocking
+`);
+    writeFileSync(
+      resolveHookArtifactPath(base, "M001/S01/T01", "SECURITY-REVIEW.md"),
+      "---\nverdict: pass\n---\n\nNo blocking findings.\n",
+      "utf-8",
+    );
+
+    const result = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.deepStrictEqual(result, null, "passing gate artifact is idempotent");
+    assert.deepStrictEqual(consumeGateBlock(), null, "passing gate does not block");
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('Blocking hook reruns invalid artifact once then blocks at cycle budget', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: security-review
+    after:
+      - execute-task
+    prompt: Review security
+    artifact: SECURITY-REVIEW.md
+    criticality: blocking
+`);
+    writeFileSync(resolveHookArtifactPath(base, "M001/S01/T01", "SECURITY-REVIEW.md"), "partial output", "utf-8");
+
+    const dispatch = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.ok(dispatch, "invalid gate artifact dispatches the blocking hook");
+    assert.equal(dispatch.unitType, "hook/security-review");
+
+    const afterHook = checkPostUnitHooks("hook/security-review", "M001/S01/T01", base);
+    assert.deepStrictEqual(afterHook, null, "no further hook dispatch after max_cycles=1");
+    const block = consumeGateBlock();
+    assert.ok(block, "gate block is recorded");
+    assert.equal(block.hookName, "security-review");
+    assert.match(block.reason, /missing frontmatter verdict/);
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('Blocking hook restored from disk does not trust artifact without clean hook completion', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: security-review
+    after:
+      - execute-task
+    prompt: Review security
+    artifact: SECURITY-REVIEW.md
+    criticality: blocking
+    max_cycles: 2
+`);
+    const firstDispatch = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.ok(firstDispatch, "gate dispatches first cycle");
+    persistHookState(base);
+
+    writeFileSync(
+      resolveHookArtifactPath(base, "M001/S01/T01", "SECURITY-REVIEW.md"),
+      "---\noutcome:\n  verdict: pass\n---\n",
+      "utf-8",
+    );
+
+    resetHookState();
+    restoreHookState(base);
+
+    const resumed = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.ok(resumed, "persisted active gate reruns when clean hook completion was not observed");
+    assert.equal(resumed.unitType, "hook/security-review");
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test('Blocking hook needs-rework verdict requests trigger unit retry', () => {
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    writeHookPreferences(base, `  - name: review-arbiter
+    after:
+      - execute-task
+    prompt: Review task
+    artifact: REVIEW-DEBATE.md
+    criticality: blocking
+    max_cycles: 2
+    on_block:
+      action: retry-unit
+`);
+    const dispatch = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assert.ok(dispatch, "gate dispatches");
+    writeFileSync(
+      resolveHookArtifactPath(base, "M001/S01/T01", "REVIEW-DEBATE.md"),
+      "---\nverdict: needs-rework\n---\n\nRework required.\n",
+      "utf-8",
+    );
+
+    const afterHook = checkPostUnitHooks("hook/review-arbiter", "M001/S01/T01", base);
+    assert.deepStrictEqual(afterHook, null, "needs-rework routes via retry signal");
+    assert.ok(isRetryPending(), "retry is pending");
+    assert.deepStrictEqual(consumeRetryTrigger(), {
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+    });
+  } finally {
+    resetHookState();
+    invalidateAllCaches();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 // ─── Variable substitution in prompts ──────────────────────────────────────
 test('Variable substitution', () => {
   const base = "/project";