gsd-pi 2.56.0-dev.b753b00 → 2.57.0-dev.f22a903

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

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { discoverAgents } from "../../subagent/agents.ts";
+
+function makeProjectRoot(t: test.TestContext): string {
+	const root = mkdtempSync(join(tmpdir(), "gsd-subagent-agents-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	return root;
+}
+
+function writeAgent(root: string, configDirName: ".gsd" | ".pi", name = "ping"): string {
+	const agentsDir = join(root, configDirName, "agents");
+	mkdirSync(agentsDir, { recursive: true });
+	writeFileSync(
+		join(agentsDir, `${name}.md`),
+		`---\nname: ${name}\ndescription: ${name} agent\n---\nSay hello\n`,
+	);
+	return agentsDir;
+}
+
+test("discoverAgents finds project agents in .gsd/agents", (t) => {
+	const root = makeProjectRoot(t);
+	const agentsDir = writeAgent(root, ".gsd");
+
+	const discovery = discoverAgents(root, "project");
+
+	assert.equal(discovery.projectAgentsDir, agentsDir);
+	assert.deepEqual(discovery.agents.map((agent) => agent.name), ["ping"]);
+	assert.equal(discovery.agents[0]?.source, "project");
+});
+
+test("discoverAgents falls back to legacy .pi/agents when needed", (t) => {
+	const root = makeProjectRoot(t);
+	const agentsDir = writeAgent(root, ".pi");
+
+	const discovery = discoverAgents(root, "project");
+
+	assert.equal(discovery.projectAgentsDir, agentsDir);
+	assert.deepEqual(discovery.agents.map((agent) => agent.name), ["ping"]);
+});

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

@@ -1,6 +1,6 @@
 import { describe, it, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, existsSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -24,6 +24,7 @@ const VALID_PARAMS = {
   sliceDeliveryAudit: "| S01 | delivered |",
   crossSliceIntegration: "No issues",
   requirementCoverage: "All covered",
+  verificationClasses: "- Contract: covered\n- Integration: covered\n- Operational: gap noted",
   verdictRationale: "Everything checks out",
 };
 
@@ -59,6 +60,27 @@ describe("handleValidateMilestone write ordering (#2725)", () => {
     // Disk file exists
     const filePath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
     assert.ok(existsSync(filePath), "VALIDATION.md should exist on disk");
+    const validationMd = readFileSync(filePath, "utf-8");
+    assert.match(validationMd, /## Verification Class Compliance/);
+    assert.match(validationMd, /- Contract: covered/);
+    assert.match(validationMd, /## Verdict Rationale/);
+  });
+
+  it("omits verification class section when no verification classes are supplied", async () => {
+    base = makeTmpBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001" });
+
+    const result = await handleValidateMilestone(
+      { ...VALID_PARAMS, verificationClasses: undefined },
+      base,
+    );
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+
+    const filePath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+    const validationMd = readFileSync(filePath, "utf-8");
+    assert.doesNotMatch(validationMd, /## Verification Class Compliance/);
   });
 
   it("rolls back DB row when disk write fails", async () => {

package/src/resources/extensions/gsd/tests/validation-gate-patterns.test.ts

@@ -23,9 +23,9 @@ import assert from "node:assert/strict";
 function hasOperationalEvidence(validationContent: string): boolean {
   const structuredMatch =
     validationContent.includes("Operational") &&
-    (validationContent.includes("MET") || validationContent.includes("N/A"));
+    (validationContent.includes("MET") || validationContent.includes("N/A") || validationContent.includes("SATISFIED"));
   const proseMatch =
-    /[Oo]perational[\s:][^\n]*(?:pass|verified|confirmed|met|complete|true|yes|addressed|covered|n\/a|not\s+applicable)/i.test(
+    /[Oo]perational[\s\S]{0,500}?(?:✅|pass|verified|confirmed|met|complete|true|yes|addressed|covered|satisfied|partially|n\/a|not[\s-]+applicable)/i.test(
       validationContent,
     );
   return structuredMatch || proseMatch;
@@ -104,6 +104,48 @@ test('prose: "Operational: complete" passes', () => {
   assert.ok(hasOperationalEvidence(content));
 });
 
+// ─── Issue #2862: checkmark emoji ────────────────────────────────────────────
+
+test('prose: "Operational: ✅" checkmark emoji passes (issue #2862)', () => {
+  const content = `- **Operational:** ✅ DECISIONS.md documents D009-D013`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+// ─── Issue #2866: multi-line, "satisfied", markdown bold ─────────────────────
+
+test('multi-line: verdict on next line after Operational heading passes (issue #2866)', () => {
+  const content = `### Operational Verification
+All endpoints responsive. Health checks pass.`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test('prose: "PARTIALLY SATISFIED" passes (issue #2866)', () => {
+  const content = `Operational class: ⚠️ PARTIALLY SATISFIED`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test('prose: "FULLY SATISFIED" passes (issue #2866)', () => {
+  const content = `**Operational**: FULLY SATISFIED — all monitoring in place.`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test('structured: Operational + SATISFIED passes (issue #2866)', () => {
+  const content = `| Criteria       | Status    |
+| Operational    | SATISFIED |`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test('table with markdown bold: **Operational** passes (issue #2866)', () => {
+  const content = `| **Operational** | ⚠️ Partially satisfied — monitoring gap noted |`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test('multi-line: Operational label and "confirmed" separated by line break passes (issue #2866)', () => {
+  const content = `## Operational
+Smoke tests confirmed all services healthy after deploy.`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
 // ─── Rejection cases ─────────────────────────────────────────────────────────
 
 test("no operational evidence: unrelated content fails", () => {

package/src/resources/extensions/gsd/tests/worktree-db-same-file.test.ts

@@ -0,0 +1,175 @@
+/**
+ * worktree-db-same-file.test.ts — Regression test for #2823.
+ *
+ * Verifies that reconcileWorktreeDb() does not ATTACH a WAL-mode DB file
+ * to itself when the worktree DB path resolves to the same physical file
+ * as the main DB path (shared-WAL / symlink layout).
+ *
+ * Also verifies that the auto-loop classifies "database disk image is
+ * malformed" as an infrastructure error to prevent wasting retries.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  reconcileWorktreeDb,
+  insertDecision,
+} from "../gsd-db.ts";
+import { isInfrastructureError } from "../auto/infra-errors.ts";
+
+// ─── Fix 1 & 2: reconcileWorktreeDb same-file guard ─────────────────
+
+describe("#2823: reconcileWorktreeDb same-file guard", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "gsd-2823-"));
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("returns zero result when both paths resolve to the same file", () => {
+    const mainGsd = join(tmpDir, "main", ".gsd");
+    mkdirSync(mainGsd, { recursive: true });
+    const mainDbPath = join(mainGsd, "gsd.db");
+
+    // Create a real DB at mainDbPath
+    openDatabase(mainDbPath);
+    insertDecision({
+      id: "D001",
+      when_context: "2026-01-01",
+      scope: "M001",
+      decision: "Test decision",
+      choice: "Test choice",
+      rationale: "Test rationale",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+
+    // Create a worktree path that resolves to the same file via symlink
+    const wtGsd = join(tmpDir, "worktree", ".gsd");
+    mkdirSync(join(tmpDir, "worktree"), { recursive: true });
+    symlinkSync(mainGsd, wtGsd, "junction");
+    const worktreeDbPath = join(wtGsd, "gsd.db");
+
+    // Both paths exist and resolve to the same physical file
+    assert.ok(existsSync(mainDbPath), "main DB exists");
+    assert.ok(existsSync(worktreeDbPath), "worktree DB path exists (via symlink)");
+
+    // This should NOT attempt ATTACH — should return zero result
+    const result = reconcileWorktreeDb(mainDbPath, worktreeDbPath);
+
+    assert.equal(result.decisions, 0, "no decisions reconciled");
+    assert.equal(result.requirements, 0, "no requirements reconciled");
+    assert.equal(result.artifacts, 0, "no artifacts reconciled");
+    assert.equal(result.conflicts.length, 0, "no conflicts");
+  });
+
+  test("returns zero result when both paths are identical strings", () => {
+    const mainGsd = join(tmpDir, "project", ".gsd");
+    mkdirSync(mainGsd, { recursive: true });
+    const dbPath = join(mainGsd, "gsd.db");
+
+    openDatabase(dbPath);
+    insertDecision({
+      id: "D001",
+      when_context: "2026-01-01",
+      scope: "M001",
+      decision: "Test",
+      choice: "Test",
+      rationale: "Test",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+
+    // Same exact path — should bail immediately
+    const result = reconcileWorktreeDb(dbPath, dbPath);
+
+    assert.equal(result.decisions, 0);
+    assert.equal(result.conflicts.length, 0);
+  });
+
+  test("still reconciles when paths are genuinely different files", () => {
+    // Main DB
+    const mainGsd = join(tmpDir, "main", ".gsd");
+    mkdirSync(mainGsd, { recursive: true });
+    const mainDbPath = join(mainGsd, "gsd.db");
+
+    openDatabase(mainDbPath);
+    insertDecision({
+      id: "D001",
+      when_context: "2026-01-01",
+      scope: "M001",
+      decision: "Main decision",
+      choice: "Main choice",
+      rationale: "Main rationale",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+    closeDatabase();
+
+    // Create a separate worktree DB with different data
+    const wtGsd = join(tmpDir, "worktree", ".gsd");
+    mkdirSync(wtGsd, { recursive: true });
+    const worktreeDbPath = join(wtGsd, "gsd.db");
+
+    openDatabase(worktreeDbPath);
+    insertDecision({
+      id: "D002",
+      when_context: "2026-01-01",
+      scope: "M001",
+      decision: "WT decision",
+      choice: "WT choice",
+      rationale: "WT rationale",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+    closeDatabase();
+
+    // Re-open main and reconcile — should work normally
+    openDatabase(mainDbPath);
+    const result = reconcileWorktreeDb(mainDbPath, worktreeDbPath);
+
+    assert.ok(
+      result.decisions > 0,
+      "should reconcile decisions from a genuinely different DB",
+    );
+  });
+});
+
+// ─── Fix 3: infrastructure error classification ─────────────────────
+
+describe("#2823: malformed DB classified as infrastructure error", () => {
+  test("database disk image is malformed is detected as infra error", () => {
+    const err = new Error("database disk image is malformed");
+    const code = isInfrastructureError(err);
+    assert.ok(code !== null, "should be classified as infrastructure error");
+    assert.equal(code, "SQLITE_CORRUPT");
+  });
+
+  test("other SQLite errors are not falsely classified", () => {
+    const err = new Error("SQLITE_BUSY: database is locked");
+    const code = isInfrastructureError(err);
+    assert.equal(code, null, "SQLITE_BUSY should not be infra error (it's transient)");
+  });
+});

package/src/resources/extensions/gsd/tools/validate-milestone.ts

@@ -25,6 +25,7 @@ export interface ValidateMilestoneParams {
   sliceDeliveryAudit: string;
   crossSliceIntegration: string;
   requirementCoverage: string;
+  verificationClasses?: string;
   verdictRationale: string;
   remediationPlan?: string;
 }
@@ -55,6 +56,10 @@ ${params.crossSliceIntegration}
 ## Requirement Coverage
 ${params.requirementCoverage}
 
+${params.verificationClasses ? `## Verification Class Compliance
+${params.verificationClasses}
+
+` : ""}
 ## Verdict Rationale
 ${params.verdictRationale}
 `;

package/src/resources/extensions/subagent/agents.ts

@@ -6,6 +6,8 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir, parseFrontmatter } from "@gsd/pi-coding-agent";
 
+const PROJECT_AGENT_DIR_CANDIDATES = [".gsd", ".pi"] as const;
+
 export type AgentScope = "user" | "project" | "both";
 
 export interface AgentConfig {
@@ -85,8 +87,12 @@ function isDirectory(p: string): boolean {
 function findNearestProjectAgentsDir(cwd: string): string | null {
 	let currentDir = cwd;
 	while (true) {
-		const candidate = path.join(currentDir, ".pi", "agents");
-		if (isDirectory(candidate)) return candidate;
+		// Prefer the documented project-local location while preserving support
+		// for older workarounds that placed agents under .pi/agents.
+		for (const configDir of PROJECT_AGENT_DIR_CANDIDATES) {
+			const candidate = path.join(currentDir, configDir, "agents");
+			if (isDirectory(candidate)) return candidate;
+		}
 
 		const parentDir = path.dirname(currentDir);
 		if (parentDir === currentDir) return null;