gsd-pi 2.73.1 → 2.74.0-dev.b741afb

package/src/resources/extensions/gsd/tests/native-git-bridge-exec-fallback.test.ts

@@ -0,0 +1,140 @@
+// native-git-bridge-exec-fallback.test.ts — regression for #4180
+//
+// nativeCommit, nativeIsRepo, and nativeResetHard used execSync() (string
+// command) in their fallback paths. On Windows, execSync spawns cmd.exe which
+// cannot resolve git when Git for Windows is installed via MSYS2/bash but not
+// in cmd.exe's PATH. All other fallback paths in this file use execFileSync()
+// which invokes the binary directly — these three must do the same.
+//
+// Static-analysis tests fail before the fix (source still has execSync calls)
+// and pass after (replaced with execFileSync). Integration tests verify the
+// fallback functions behave correctly on all platforms.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+import { nativeIsRepo, nativeCommit, nativeResetHard } from "../native-git-bridge.js";
+
+// ─── Static analysis ──────────────────────────────────────────────────────
+// Verify the fallback paths of the three affected functions do not call the
+// raw execSync() string-command variant. Replacing all execFileSync( tokens
+// first ensures we match only the bare execSync( form.
+
+const SRC_PATH = join(import.meta.dirname, "..", "native-git-bridge.ts");
+
+function extractFunctionBody(src: string, fnName: string): string {
+  const idx = src.indexOf(`export function ${fnName}`);
+  if (idx === -1) throw new Error(`${fnName} not found in source`);
+  return src.slice(idx, idx + 1500);
+}
+
+function hasRawExecSync(body: string): boolean {
+  const withoutFileSync = body.replace(/execFileSync\(/g, "__FILESYNC__");
+  return withoutFileSync.includes("execSync(");
+}
+
+describe("native-git-bridge #4180: fallback paths use execFileSync not execSync", () => {
+  const src = readFileSync(SRC_PATH, "utf-8");
+
+  test("nativeIsRepo fallback does not use raw execSync", () => {
+    const body = extractFunctionBody(src, "nativeIsRepo");
+    assert.equal(
+      hasRawExecSync(body),
+      false,
+      "nativeIsRepo fallback must use execFileSync to avoid cmd.exe PATH failures on Windows",
+    );
+  });
+
+  test("nativeCommit fallback does not use raw execSync", () => {
+    const body = extractFunctionBody(src, "nativeCommit");
+    assert.equal(
+      hasRawExecSync(body),
+      false,
+      "nativeCommit fallback must use execFileSync to avoid cmd.exe PATH failures on Windows",
+    );
+  });
+
+  test("nativeResetHard fallback does not use raw execSync", () => {
+    const body = extractFunctionBody(src, "nativeResetHard");
+    assert.equal(
+      hasRawExecSync(body),
+      false,
+      "nativeResetHard fallback must use execFileSync to avoid cmd.exe PATH failures on Windows",
+    );
+  });
+});
+
+// ─── Integration tests ────────────────────────────────────────────────────
+// Verify correct runtime behaviour through the fallback path (native module
+// is disabled by default in tests — GSD_ENABLE_NATIVE_GSD_GIT is not set).
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+describe("native-git-bridge #4180: fallback runtime behaviour", () => {
+  let repo: string;
+
+  beforeEach(() => {
+    repo = mkdtempSync(join(tmpdir(), "ngb4180-"));
+    git(["init"], repo);
+    git(["config", "user.email", "test@test.com"], repo);
+    git(["config", "user.name", "Test"], repo);
+    writeFileSync(join(repo, "file.txt"), "initial\n");
+    git(["add", "."], repo);
+    git(["commit", "-m", "init"], repo);
+  });
+
+  afterEach(() => {
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test("nativeIsRepo returns true for a valid git repository", () => {
+    assert.equal(nativeIsRepo(repo), true);
+  });
+
+  test("nativeIsRepo returns false for a plain directory", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "ngb4180-notrepo-"));
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    assert.equal(nativeIsRepo(dir), false);
+  });
+
+  test("nativeCommit commits staged changes and returns non-null output", () => {
+    writeFileSync(join(repo, "file.txt"), "modified\n");
+    git(["add", "."], repo);
+
+    const result = nativeCommit(repo, "test: regression commit #4180");
+    assert.ok(result !== null, "should return output string for a successful commit");
+
+    const subject = git(["log", "-1", "--format=%s"], repo);
+    assert.equal(subject, "test: regression commit #4180");
+  });
+
+  test("nativeCommit returns null when nothing is staged", () => {
+    const result = nativeCommit(repo, "test: nothing staged");
+    assert.equal(result, null);
+  });
+
+  test("nativeCommit respects the allowEmpty option", () => {
+    const result = nativeCommit(repo, "test: empty commit #4180", { allowEmpty: true });
+    assert.ok(result !== null, "allow-empty commit should return output");
+
+    const subject = git(["log", "-1", "--format=%s"], repo);
+    assert.equal(subject, "test: empty commit #4180");
+  });
+
+  test("nativeResetHard discards unstaged working tree changes", () => {
+    writeFileSync(join(repo, "file.txt"), "dirty content\n");
+
+    const statusBefore = git(["status", "--short"], repo);
+    assert.ok(statusBefore.length > 0, "repo should be dirty before reset");
+
+    nativeResetHard(repo);
+
+    const content = readFileSync(join(repo, "file.txt"), "utf-8");
+    assert.equal(content, "initial\n", "file should be restored to HEAD content after hard reset");
+  });
+});

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

@@ -134,6 +134,53 @@ test("invalid value types produce errors and fall back to undefined", () => {
   }
 });
 
+test("flat_rate_providers: accepts string array", () => {
+  const { errors, preferences } = validatePreferences({
+    flat_rate_providers: ["my-proxy", "private-cli"],
+  });
+  assert.equal(errors.length, 0);
+  assert.deepEqual(preferences.flat_rate_providers, ["my-proxy", "private-cli"]);
+});
+
+test("flat_rate_providers: trims whitespace and drops empty entries", () => {
+  const { errors, preferences } = validatePreferences({
+    flat_rate_providers: ["  my-proxy  ", "", "   ", "private-cli"],
+  });
+  assert.equal(errors.length, 0);
+  assert.deepEqual(preferences.flat_rate_providers, ["my-proxy", "private-cli"]);
+});
+
+test("flat_rate_providers: non-array rejected", () => {
+  const { errors } = validatePreferences({
+    flat_rate_providers: "my-proxy" as any,
+  });
+  assert.ok(
+    errors.some(e => e.includes("flat_rate_providers")),
+    "should error on non-array value",
+  );
+});
+
+test("flat_rate_providers: non-string elements rejected", () => {
+  const { errors } = validatePreferences({
+    flat_rate_providers: ["ok", 123 as any, "also-ok"],
+  });
+  assert.ok(
+    errors.some(e => e.includes("flat_rate_providers")),
+    "should error when array contains non-strings",
+  );
+});
+
+test("flat_rate_providers is a recognized preference key (no warning)", () => {
+  const { warnings } = validatePreferences({
+    flat_rate_providers: ["my-proxy"],
+  });
+  assert.equal(
+    warnings.filter(w => w.includes("flat_rate_providers")).length,
+    0,
+    "flat_rate_providers must be in KNOWN_PREFERENCE_KEYS",
+  );
+});
+
 test("valid values pass through correctly", () => {
   const { preferences: p1 } = validatePreferences({ budget_enforcement: "halt" });
   assert.equal(p1.budget_enforcement, "halt");

package/src/resources/extensions/gsd/tests/single-writer-invariant.test.ts

@@ -0,0 +1,180 @@
+// Structural invariant: gsd-db.ts is the single writer for .gsd/gsd.db.
+//
+// No file under src/resources/extensions/gsd/ may issue raw write SQL
+// (INSERT/UPDATE/DELETE/REPLACE) or raw transaction control (BEGIN/COMMIT/
+// ROLLBACK via `.exec(...)`) against the engine database. Every bypass must
+// route through a typed wrapper exported from gsd-db.ts.
+//
+// Allowlist:
+// - gsd-db.ts itself — the single writer
+// - unit-ownership.ts — manages a separate .gsd/unit-claims.db for
+//   cross-worktree claim races; intentionally outside this invariant
+// - tests/** — fixtures and direct DB inspection are fair game
+//
+// When this test fails, do not add a new suppression. Instead:
+// 1. Add a typed wrapper to gsd-db.ts that captures the SQL
+// 2. Switch the flagged site to call the wrapper
+//
+// See `.claude/plans/joyful-doodling-pony.md` for the full rationale.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, readdirSync } from "node:fs";
+import { join, relative } from "node:path";
+
+const gsdDir = join(process.cwd(), "src/resources/extensions/gsd");
+
+const ALLOWLIST = new Set([
+  "gsd-db.ts",
+  "unit-ownership.ts",
+]);
+
+/** Walk the gsd extension dir and return all .ts files outside tests/. */
+function walkTsFiles(root: string): string[] {
+  const out: string[] = [];
+  const stack: string[] = [root];
+
+  while (stack.length > 0) {
+    const dir = stack.pop()!;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const ent of entries) {
+      const full = join(dir, ent.name);
+      if (ent.isDirectory()) {
+        // Skip tests/ — fixtures and direct DB inspection are expected there
+        if (ent.name === "tests") continue;
+        stack.push(full);
+        continue;
+      }
+      if (!ent.isFile()) continue;
+      if (!ent.name.endsWith(".ts")) continue;
+      // Skip dotfiles and backup/generated files
+      if (ent.name.startsWith(".")) continue;
+      out.push(full);
+    }
+  }
+
+  return out;
+}
+
+interface Violation {
+  file: string;
+  line: number;
+  snippet: string;
+  kind: string;
+}
+
+// Match .prepare("... INSERT|UPDATE|DELETE|REPLACE ...") in any quoting style.
+const PREPARE_WRITE_RE = /\.prepare\s*\(\s*[`'"][^`'"]*\b(INSERT|UPDATE|DELETE|REPLACE)\b/i;
+
+// Match .exec("... INSERT|UPDATE|DELETE|REPLACE ...") or raw BEGIN/COMMIT/ROLLBACK.
+const EXEC_WRITE_RE = /\.exec\s*\(\s*[`'"][^`'"]*\b(INSERT|UPDATE|DELETE|REPLACE|BEGIN|COMMIT|ROLLBACK)\b/i;
+
+test("no module outside gsd-db.ts issues raw write SQL against the engine DB", () => {
+  const files = walkTsFiles(gsdDir);
+  assert.ok(files.length >= 20, `Expected at least 20 .ts files under gsd/, found ${files.length}`);
+
+  const violations: Violation[] = [];
+
+  for (const abs of files) {
+    const rel = relative(gsdDir, abs);
+    const base = rel.split("/").pop()!;
+    if (ALLOWLIST.has(base)) continue;
+
+    let content: string;
+    try {
+      content = readFileSync(abs, "utf-8");
+    } catch {
+      continue;
+    }
+
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      const prepareMatch = PREPARE_WRITE_RE.exec(line);
+      if (prepareMatch) {
+        violations.push({
+          file: rel,
+          line: i + 1,
+          snippet: line.trim(),
+          kind: `prepare(${prepareMatch[1].toUpperCase()})`,
+        });
+      }
+
+      const execMatch = EXEC_WRITE_RE.exec(line);
+      if (execMatch) {
+        violations.push({
+          file: rel,
+          line: i + 1,
+          snippet: line.trim(),
+          kind: `exec(${execMatch[1].toUpperCase()})`,
+        });
+      }
+    }
+  }
+
+  if (violations.length > 0) {
+    const lines = violations.map(
+      (v) => `  ${v.file}:${v.line} [${v.kind}] — ${v.snippet}`,
+    );
+    assert.fail(
+      `Found ${violations.length} raw write SQL bypass(es) outside gsd-db.ts:\n` +
+        lines.join("\n") +
+        "\n\nEach of these must be replaced with a typed wrapper exported from gsd-db.ts.",
+    );
+  }
+});
+
+test("gsd-db.ts exports the expected single-writer wrappers", async () => {
+  // Positive assertion — fail loudly if the module layout changes so this
+  // structural test can't silently become a no-op.
+  const db = await import("../gsd-db.js");
+
+  const expected = [
+    "deleteDecisionById",
+    "deleteRequirementById",
+    "deleteArtifactByPath",
+    "clearEngineHierarchy",
+    "insertOrIgnoreSlice",
+    "insertOrIgnoreTask",
+    "setSliceReplanTriggeredAt",
+    "upsertQualityGate",
+    "restoreManifest",
+    "bulkInsertLegacyHierarchy",
+    "readTransaction",
+    "insertMemoryRow",
+    "rewriteMemoryId",
+    "updateMemoryContentRow",
+    "incrementMemoryHitCount",
+    "supersedeMemoryRow",
+    "markMemoryUnitProcessed",
+    "decayMemoriesBefore",
+    "supersedeLowestRankedMemories",
+  ];
+
+  for (const name of expected) {
+    assert.ok(
+      typeof (db as Record<string, unknown>)[name] === "function",
+      `gsd-db.ts must export ${name} as a function`,
+    );
+  }
+});
+
+test("the invariant test touches every .ts module under gsd/ (sanity check)", () => {
+  const files = walkTsFiles(gsdDir);
+  // Rough sanity: ensure we're not accidentally walking an empty tree
+  assert.ok(files.length >= 30, `Expected to scan at least 30 .ts files, scanned ${files.length}`);
+
+  // Spot-check a couple of known files that must be included
+  const rels = files.map((f) => relative(gsdDir, f));
+  assert.ok(rels.includes("gsd-db.ts"), "walker must include gsd-db.ts");
+  assert.ok(rels.includes("memory-store.ts"), "walker must include memory-store.ts");
+  assert.ok(rels.includes("workflow-manifest.ts"), "walker must include workflow-manifest.ts");
+});
+

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

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

package/src/resources/extensions/gsd/tests/token-profile.test.ts

@@ -263,6 +263,6 @@ test("dispatch: phase skip guards return null (not stop)", () => {
   const researchGuard = dispatchSrc.match(/skip_research\).*?return null/s);
   assert.ok(researchGuard, "skip_research guard should return null (fall-through)");
 
-  const reassessGuard = dispatchSrc.match(/reassess_after_slice\).*?return null/s);
+  const reassessGuard = dispatchSrc.match(/reassess_after_slice.*?return null/s);
   assert.ok(reassessGuard, "reassess_after_slice guard should return null (fall-through)");
 });

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

@@ -0,0 +1,179 @@
+// gsd-pi — Regression tests for the validate-milestone stuck-loop guard (#4094)
+
+import { describe, test, mock, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { tmpdir } from "node:os";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+import { runPostUnitVerification, type VerificationContext } from "../auto-verification.ts";
+import { AutoSession } from "../auto/session.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+
+let tempDir: string;
+let dbPath: string;
+let originalCwd: string;
+
+function makeMockCtx() {
+  return {
+    ui: {
+      notify: mock.fn(),
+      setStatus: () => {},
+      setWidget: () => {},
+      setFooter: () => {},
+    },
+    model: { id: "test-model" },
+  } as any;
+}
+
+function makeMockPi() {
+  return {
+    sendMessage: mock.fn(),
+    setModel: mock.fn(async () => true),
+  } as any;
+}
+
+function makeMockSession(basePath: string, unitType: string, unitId: string): AutoSession {
+  const s = new AutoSession();
+  s.basePath = basePath;
+  s.active = true;
+  s.pendingVerificationRetry = null;
+  s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
+  return s;
+}
+
+function setupTestEnvironment(): void {
+  originalCwd = process.cwd();
+  tempDir = join(tmpdir(), `validate-milestone-guard-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(tempDir, { recursive: true });
+
+  const milestoneDir = join(tempDir, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+
+  process.chdir(tempDir);
+  _clearGsdRootCache();
+
+  dbPath = join(tempDir, ".gsd", "gsd.db");
+  openDatabase(dbPath);
+  invalidateAllCaches();
+}
+
+function cleanupTestEnvironment(): void {
+  try { process.chdir(originalCwd); } catch { /* ignore */ }
+  try { closeDatabase(); } catch { /* ignore */ }
+  try { rmSync(tempDir, { recursive: true, force: true }); } catch { /* ignore */ }
+}
+
+function writeValidationFile(verdict: string): void {
+  const path = join(tempDir, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+  const content = `---
+verdict: ${verdict}
+remediation_round: 1
+---
+
+# Milestone Validation: M001
+
+## Verdict Rationale
+Test fixture
+`;
+  writeFileSync(path, content, "utf-8");
+  invalidateAllCaches();
+}
+
+describe("validate-milestone stuck-loop guard (#4094)", () => {
+  beforeEach(() => setupTestEnvironment());
+  afterEach(() => cleanupTestEnvironment());
+
+  test("pauses when verdict=needs-remediation and all slices are closed", async () => {
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Slice 2", status: "done" });
+    writeValidationFile("needs-remediation");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, "validate-milestone", "M001");
+
+    const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
+
+    assert.equal(result, "pause");
+    assert.equal(pauseAutoMock.mock.callCount(), 1);
+    assert.equal(ctx.ui.notify.mock.callCount(), 1);
+    const notifyArgs = ctx.ui.notify.mock.calls[0].arguments;
+    assert.match(notifyArgs[0], /needs-remediation/);
+    assert.equal(notifyArgs[1], "error");
+  });
+
+  test("treats skipped slices as closed", async () => {
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Slice 2", status: "skipped" });
+    writeValidationFile("needs-remediation");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, "validate-milestone", "M001");
+
+    const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
+
+    assert.equal(result, "pause");
+    assert.equal(pauseAutoMock.mock.callCount(), 1);
+  });
+
+  test("continues when verdict=needs-remediation but a queued remediation slice exists", async () => {
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Remediation", status: "queued" });
+    writeValidationFile("needs-remediation");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, "validate-milestone", "M001");
+
+    const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
+
+    assert.equal(result, "continue");
+    assert.equal(pauseAutoMock.mock.callCount(), 0);
+  });
+
+  test("continues when verdict is pass", async () => {
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
+    writeValidationFile("pass");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, "validate-milestone", "M001");
+
+    const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
+
+    assert.equal(result, "continue");
+    assert.equal(pauseAutoMock.mock.callCount(), 0);
+  });
+
+  test("continues when no VALIDATION file exists yet", async () => {
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, "validate-milestone", "M001");
+
+    const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
+
+    assert.equal(result, "continue");
+    assert.equal(pauseAutoMock.mock.callCount(), 0);
+  });
+});