gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

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

@@ -22,7 +22,7 @@ import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { discoverCommands, runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit, isLikelyCommand } from "../verification-gate.ts";
+import { discoverCommands, runVerificationGate, runVerificationGateForTargets, formatFailureContext, captureRuntimeErrors, runDependencyAudit, isLikelyCommand, validateVerificationCommand } from "../verification-gate.ts";
 import type { CaptureRuntimeErrorsOptions, DependencyAuditOptions } from "../verification-gate.ts";
 import { validatePreferences } from "../preferences.ts";
 
@@ -187,6 +187,21 @@ describe("verification-gate: discovery", () => {
     assert.deepStrictEqual(result.commands, ["npm run test"]);
   });
 
+  test("non-ASCII prose taskPlanVerify is rejected, falls through to package.json", () => {
+    writeFileSync(
+      join(tmp, "package.json"),
+      JSON.stringify({ scripts: { test: "vitest" } }),
+    );
+    const result = discoverCommands({
+      // Chinese prose: "All commands output one line of JSONL; go test ./... passes"
+      taskPlanVerify: "所有 命令 输出 一行 JSONL go test ./... 通过",
+      cwd: tmp,
+    });
+    // Non-ASCII prose should be rejected, so it falls through to package.json
+    assert.equal(result.source, "package-json");
+    assert.deepStrictEqual(result.commands, ["npm run test"]);
+  });
+
   test("prose taskPlanVerify with no package.json → source none", () => {
     const result = discoverCommands({
       taskPlanVerify: "Verify the output matches expected format and all fields are present",
@@ -215,6 +230,122 @@ describe("verification-gate: discovery", () => {
     assert.equal(result.source, "task-plan");
     assert.deepStrictEqual(result.commands, ["npm run test"]);
   });
+
+  test("taskPlanVerify rejects piped pytest command", () => {
+    const result = discoverCommands({
+      taskPlanVerify: "python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5",
+      cwd: tmp,
+    });
+    assert.equal(result.source, "none");
+    assert.deepStrictEqual(result.commands, []);
+  });
+
+  test("Python project with tests discovers pytest when package.json is absent", () => {
+    mkdirSync(join(tmp, "tests"));
+    writeFileSync(join(tmp, "tests", "test_sample.py"), "def test_sample():\n    assert True\n");
+    writeFileSync(
+      join(tmp, "pyproject.toml"),
+      `[project]
+name = "sample"
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+`,
+    );
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "python-project");
+    assert.deepStrictEqual(result.commands, ["python3 -m pytest"]);
+  });
+
+  test("dependency-free Node project with root test file discovers node test command", () => {
+    writeFileSync(join(tmp, "test-todo-cli.js"), "require('node:test')('ok', () => {});\n");
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "node-test-file");
+    assert.deepStrictEqual(result.commands, ["node test-todo-cli.js"]);
+  });
+
+  test("dependency-free Node test discovery is lower priority than Python pytest", () => {
+    mkdirSync(join(tmp, "tests"), { recursive: true });
+    writeFileSync(join(tmp, "tests", "test_sample.py"), "def test_sample():\n    assert True\n");
+    writeFileSync(join(tmp, "sample.test.js"), "require('node:test')('ok', () => {});\n");
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "python-project");
+    assert.deepStrictEqual(result.commands, ["python3 -m pytest"]);
+  });
+
+  test("Python project with nested Python test file discovers pytest", () => {
+    mkdirSync(join(tmp, "tests", "unit"), { recursive: true });
+    writeFileSync(join(tmp, "tests", "unit", "sample_test.py"), "def test_sample():\n    assert True\n");
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "python-project");
+    assert.deepStrictEqual(result.commands, ["python3 -m pytest"]);
+  });
+
+  test("Python project with pytest.ini discovers pytest", () => {
+    writeFileSync(join(tmp, "pytest.ini"), "[pytest]\npythonpath = .\n");
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "python-project");
+    assert.deepStrictEqual(result.commands, ["python3 -m pytest"]);
+  });
+
+  test("Python project with explicit pyproject pytest marker discovers pytest", () => {
+    writeFileSync(
+      join(tmp, "pyproject.toml"),
+      `[tool.pytest]
+pythonpath = ["."]
+`,
+    );
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "python-project");
+    assert.deepStrictEqual(result.commands, ["python3 -m pytest"]);
+  });
+
+  test("Python project markers without pytest evidence do not discover pytest", () => {
+    mkdirSync(join(tmp, "tests"));
+    writeFileSync(join(tmp, "tests", "README.md"), "# tests\n");
+    writeFileSync(
+      join(tmp, "pyproject.toml"),
+      `[project]
+name = "sample"
+dependencies = ["pytest-cov"]
+`,
+    );
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "none");
+    assert.deepStrictEqual(result.commands, []);
+  });
+
+  test("Python project with setup.cfg alone does not discover pytest", () => {
+    writeFileSync(join(tmp, "setup.cfg"), "[tool:pytest]\npythonpath = .\n");
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "none");
+    assert.deepStrictEqual(result.commands, []);
+  });
+
+  test("Python project with tox.ini alone does not discover pytest", () => {
+    writeFileSync(join(tmp, "tox.ini"), "[pytest]\npythonpath = .\n");
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "none");
+    assert.deepStrictEqual(result.commands, []);
+  });
 });
 
 // ─── Execution Tests ─────────────────────────────────────────────────────────
@@ -345,6 +476,49 @@ describe("verification-gate: execution", () => {
     // The stdout should contain the tmp dir path (resolving symlinks)
     assert.ok(result.checks[0].stdout.trim().length > 0, "pwd should produce output");
   });
+
+  test("multi-target execution runs verification in each repository root", () => {
+    const frontend = join(tmp, "frontend");
+    const backend = join(tmp, "backend");
+    mkdirSync(frontend, { recursive: true });
+    mkdirSync(backend, { recursive: true });
+
+    const result = runVerificationGateForTargets({
+      targets: [
+        { id: "frontend", cwd: frontend },
+        { id: "backend", cwd: backend },
+      ],
+      preferenceCommands: ["pwd"],
+    });
+
+    assert.equal(result.checks.length, 2);
+    assert.equal(result.checks[0].command, "[frontend] pwd");
+    assert.equal(result.checks[1].command, "[backend] pwd");
+    assert.ok(result.checks[0].stdout.includes("frontend"));
+    assert.ok(result.checks[1].stdout.includes("backend"));
+    assert.equal(result.discoverySource, "preference");
+  });
+
+  test("multi-target execution falls back to per-repo package.json discovery", () => {
+    const frontend = join(tmp, "frontend");
+    const backend = join(tmp, "backend");
+    mkdirSync(frontend, { recursive: true });
+    mkdirSync(backend, { recursive: true });
+    writeFileSync(join(frontend, "package.json"), JSON.stringify({ scripts: { test: "echo front-ok" } }), "utf-8");
+    writeFileSync(join(backend, "package.json"), JSON.stringify({ scripts: { test: "echo back-ok" } }), "utf-8");
+
+    const result = runVerificationGateForTargets({
+      targets: [
+        { id: "frontend", cwd: frontend },
+        { id: "backend", cwd: backend },
+      ],
+    });
+
+    assert.equal(result.checks.length, 2);
+    assert.equal(result.checks[0].command, "[frontend] npm run test");
+    assert.equal(result.checks[1].command, "[backend] npm run test");
+    assert.equal(result.discoverySource, "package-json");
+  });
 });
 
 // ─── Preference Validation Tests ─────────────────────────────────────────────
@@ -445,6 +619,10 @@ test("isLikelyCommand: prose descriptions are rejected", () => {
   assert.equal(isLikelyCommand("Build succeeds without errors or warnings"), false);
 });
 
+test("isLikelyCommand: non-ASCII prose descriptions are rejected", () => {
+  assert.equal(isLikelyCommand("所有 命令 输出 一行 JSONL go test ./... 通过"), false);
+});
+
 test("isLikelyCommand: empty or whitespace-only strings are rejected", () => {
   assert.equal(isLikelyCommand(""), false);
   assert.equal(isLikelyCommand("   "), false);
@@ -455,6 +633,15 @@ test("isLikelyCommand: short lowercase tokens without flags are accepted (could
   assert.equal(isLikelyCommand("mycheck"), true);
 });
 
+test("validateVerificationCommand rejects shell control syntax", () => {
+  assert.deepEqual(validateVerificationCommand("python3 -m pytest tests/ -q --tb=short").ok, true);
+  const result = validateVerificationCommand("python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5");
+  assert.equal(result.ok, false);
+  if (!result.ok) {
+    assert.match(result.reason, /shell control syntax/);
+  }
+});
+
 // ─── Additional Preference Validation Tests (T02) ──────────────────────────
 
 test("verification-gate: verification_commands produces no unknown-key warnings", () => {

package/src/resources/extensions/gsd/tests/verification-verdict.test.ts

@@ -0,0 +1,78 @@
+// Project/App: GSD-2
+// File Purpose: Tests for host-owned auto-mode verification verdict policy.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { decideVerificationVerdict } from "../verification-verdict.ts";
+import type { VerificationResult } from "../types.ts";
+
+function makeResult(overrides: Partial<VerificationResult> = {}): VerificationResult {
+  return {
+    passed: true,
+    checks: [],
+    discoverySource: "none",
+    timestamp: 1,
+    ...overrides,
+  };
+}
+
+test("execute-task fails closed when no host-owned checks are discovered", () => {
+  const verdict = decideVerificationVerdict("execute-task", makeResult());
+
+  assert.equal(verdict.passed, false);
+  assert.equal(verdict.reason, "no-host-checks");
+  assert.equal(verdict.retryable, false);
+  assert.match(verdict.failureContext, /No runnable host-owned verification command/);
+});
+
+test("non execute-task units preserve no-check pass semantics", () => {
+  const verdict = decideVerificationVerdict("plan-slice", makeResult());
+
+  assert.equal(verdict.passed, true);
+  assert.equal(verdict.reason, "passed");
+});
+
+test("execute-task command failure remains retryable verification failure", () => {
+  const verdict = decideVerificationVerdict(
+    "execute-task",
+    makeResult({
+      passed: false,
+      discoverySource: "package-json",
+      checks: [
+        {
+          command: "npm test",
+          exitCode: 1,
+          stdout: "",
+          stderr: "failed",
+          durationMs: 10,
+        },
+      ],
+    }),
+  );
+
+  assert.equal(verdict.passed, false);
+  assert.equal(verdict.reason, "checks-failed");
+  assert.equal(verdict.retryable, true);
+});
+
+test("execute-task passes when a discovered host check succeeds", () => {
+  const verdict = decideVerificationVerdict(
+    "execute-task",
+    makeResult({
+      discoverySource: "preference",
+      checks: [
+        {
+          command: "npm test",
+          exitCode: 0,
+          stdout: "ok",
+          stderr: "",
+          durationMs: 10,
+        },
+      ],
+    }),
+  );
+
+  assert.equal(verdict.passed, true);
+  assert.equal(verdict.reason, "passed");
+});

package/src/resources/extensions/gsd/tests/workflow-kernel.test.ts

@@ -165,6 +165,13 @@ test("decideFinalizeResult maps break results to stop decisions", () => {
   );
 });
 
+test("decideFinalizeResult maps step-wizard breaks to completed step exits", () => {
+  assert.deepEqual(
+    decideFinalizeResult({ action: "break", reason: "step-wizard" }),
+    { action: "complete-and-break" },
+  );
+});
+
 test("decideFinalizeResult maps continue and next results", () => {
   assert.deepEqual(
     decideFinalizeResult({ action: "continue" }),

package/src/resources/extensions/gsd/tests/workflow-mcp.test.ts

@@ -375,7 +375,7 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
               estimate: "10m",
               files: ["src/resources/extensions/gsd/workflow-mcp.ts"],
               verify: "node --test",
-              inputs: ["M001-ROADMAP.md"],
+              inputs: [".gsd/milestones/M001/M001-ROADMAP.md"],
               expectedOutput: ["S01-PLAN.md", "T01-PLAN.md"],
             },
           ],
@@ -746,3 +746,21 @@ test("transport compatibility still blocks units whose MCP tools are not exposed
   assert.match(error ?? "", /requires secure_env_collect/);
   assert.match(error ?? "", /currently exposes only/);
 });
+
+test("transport compatibility accepts MCP-namespaced runtime tools", () => {
+  const error = getWorkflowTransportSupportError(
+    "claude-code",
+    ["gsd_summary_save"],
+    {
+      projectRoot: "/tmp/project",
+      env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+      surface: "auto-mode",
+      unitType: "research-slice",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+      activeTools: ["mcp__gsd-workflow__gsd_summary_save"],
+    },
+  );
+
+  assert.equal(error, null);
+});

package/src/resources/extensions/gsd/tests/workflow-memory-pressure.test.ts

@@ -4,7 +4,10 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { measureMemoryPressure } from "../auto/workflow-memory-pressure.ts";
+import {
+  measureMemoryPressure,
+  shouldCheckMemoryPressure,
+} from "../auto/workflow-memory-pressure.ts";
 
 const mb = 1024 * 1024;
 
@@ -69,3 +72,20 @@ test("measureMemoryPressure falls back when heap limit cannot be read", () => {
     pct: 0.25,
   });
 });
+
+test("shouldCheckMemoryPressure covers the first auto-mode iteration", () => {
+  assert.equal(shouldCheckMemoryPressure(1, 5), true);
+  assert.equal(shouldCheckMemoryPressure(2, 5), false);
+  assert.equal(shouldCheckMemoryPressure(5, 5), true);
+});
+
+test("shouldCheckMemoryPressure rejects invalid intervals", () => {
+  assert.throws(
+    () => shouldCheckMemoryPressure(1, 0),
+    /positive integer/,
+  );
+  assert.throws(
+    () => shouldCheckMemoryPressure(1, 1.5),
+    /positive integer/,
+  );
+});

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

@@ -10,6 +10,7 @@ import {
   closeDatabase,
   _getAdapter,
   insertGateRow,
+  insertAssessment,
   upsertRequirement,
   getAllMilestones,
 } from "../gsd-db.ts";
@@ -26,6 +27,7 @@ import {
   executeTaskComplete,
   executeMilestoneStatus,
   executeSliceComplete,
+  executeSliceReopen,
   executeValidateMilestone,
 } from "../tools/workflow-tool-executors.ts";
 
@@ -146,6 +148,117 @@ test("executeTaskComplete coerces string verificationEvidence entries", async ()
   }
 });
 
+test("executeSliceComplete preserves omitted optional requirement arrays", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    await inProjectDir(base, () => executePlanMilestone({
+      milestoneId: "M001",
+      title: "Requirement preservation",
+      vision: "Ensure omitted arrays are not coerced to empties.",
+      slices: [
+        {
+          sliceId: "S01",
+          title: "Slice",
+          risk: "medium",
+          depends: [],
+          demo: "demo",
+          goal: "goal",
+          successCriteria: "done",
+          proofLevel: "integration",
+          integrationClosure: "closed",
+          observabilityImpact: "covered",
+        },
+      ],
+    }, base));
+    await inProjectDir(base, () => executePlanSlice({
+      milestoneId: "M001",
+      sliceId: "S01",
+      goal: "goal",
+      tasks: [
+        {
+          taskId: "T01",
+          title: "Task",
+          description: "desc",
+          estimate: "5m",
+          files: ["src/a.ts"],
+          verify: "node --test",
+          inputs: ["in"],
+          expectedOutput: ["out"],
+        },
+      ],
+    }, base));
+    await inProjectDir(base, () => executeTaskComplete({
+      milestoneId: "M001",
+      sliceId: "S01",
+      taskId: "T01",
+      oneLiner: "done",
+      narrative: "done",
+      verification: "ok",
+    }, base));
+
+    const result = await inProjectDir(base, () => executeSliceComplete({
+      milestoneId: "M001",
+      sliceId: "S01",
+      sliceTitle: "Slice",
+      oneLiner: "done",
+      narrative: "done",
+      verification: "ok",
+      uatContent: "ok",
+      requirementsAdvanced: [{ id: "R010", how: "advanced" }],
+      requirementsValidated: [{ id: "R010", proof: "validated" }],
+    }, base));
+
+    assert.equal(result.details.operation, "complete_slice");
+    const summaryPath = String(result.details.summaryPath);
+    const summary = readFileSync(summaryPath, "utf-8");
+    assert.match(summary, /R010 — advanced/);
+    assert.match(summary, /R010 — validated/);
+
+    const reopenResult = await inProjectDir(base, () => executeSliceReopen({
+      milestoneId: "M001",
+      sliceId: "S01",
+      reason: "validate idempotent overwrite behavior",
+    }, base));
+    assert.equal(reopenResult.details.operation, "reopen_slice");
+    await inProjectDir(base, () => executeTaskComplete({
+      milestoneId: "M001",
+      sliceId: "S01",
+      taskId: "T01",
+      oneLiner: "done (updated)",
+      narrative: "done (updated)",
+      verification: "ok",
+    }, base));
+
+    const recallResult = await inProjectDir(base, () => executeSliceComplete({
+      milestoneId: "M001",
+      sliceId: "S01",
+      sliceTitle: "Slice",
+      oneLiner: "done (updated)",
+      narrative: "done (updated)",
+      verification: "ok",
+      uatContent: "ok",
+    }, base));
+
+    assert.equal(recallResult.details.operation, "complete_slice");
+    const recallSummaryPath = String(recallResult.details.summaryPath);
+    const recallSummary = readFileSync(recallSummaryPath, "utf-8");
+    assert.match(
+      recallSummary,
+      /R010 — advanced/,
+      "requirementsAdvanced should be preserved from first call",
+    );
+    assert.match(
+      recallSummary,
+      /R010 — validated/,
+      "requirementsValidated should be preserved from first call",
+    );
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeMilestoneStatus returns milestone metadata and slice counts", async () => {
   const base = makeTmpBase();
   try {
@@ -246,7 +359,7 @@ test("executePlanSlice writes task planning state and rendered plan artifacts",
           estimate: "15m",
           files: ["src/resources/extensions/gsd/tools/workflow-tool-executors.ts"],
           verify: "node --test",
-          inputs: ["ROADMAP.md"],
+          inputs: [".gsd/milestones/M001/M001-ROADMAP.md"],
           expectedOutput: ["S01-PLAN.md", "T01-PLAN.md"],
         },
       ],
@@ -360,6 +473,38 @@ test("executeValidateMilestone persists validation artifact and gate records", a
   }
 });
 
+test("executeValidateMilestone rejects verificationClasses that omit planned Operational class", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M002", "Milestone Two");
+    const db = _getAdapter();
+    db!.prepare("UPDATE milestones SET verification_operational = ? WHERE id = ?").run(
+      "Camoufox subprocess lifecycle/cleanup proof",
+      "M002",
+    );
+    seedSlice("M002", "S02", "complete");
+
+    const result = await inProjectDir(base, () => executeValidateMilestone({
+      milestoneId: "M002",
+      verdict: "pass",
+      remediationRound: 0,
+      successCriteriaChecklist: "- [x] Works",
+      sliceDeliveryAudit: "| Slice | Result |\n| --- | --- |\n| S02 | pass |",
+      crossSliceIntegration: "No cross-slice issues.",
+      requirementCoverage: "All requirements covered.",
+      verificationClasses: "| Check | Result |\n| --- | --- |\n| Generic verification | PASS |",
+      verdictRationale: "Everything passed.",
+    }, base));
+
+    assert.equal(result.isError, true);
+    assert.match(String(result.details.error), /must include canonical row "Operational"/);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeCompleteMilestone sanitizes raw params and writes milestone summary", async () => {
   const base = makeTmpBase();
   try {
@@ -371,6 +516,13 @@ test("executeCompleteMilestone sanitizes raw params and writes milestone summary
     db!.prepare(
       "INSERT OR REPLACE INTO tasks (milestone_id, slice_id, id, title, status) VALUES (?, ?, ?, ?, ?)",
     ).run("M003", "S03", "T03", "Task T03", "complete");
+    insertAssessment({
+      path: join(".gsd", "milestones", "M003", "M003-VALIDATION.md"),
+      milestoneId: "M003",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nValidated.",
+    });
 
     const rawParams = {
       milestoneId: "M003",

package/src/resources/extensions/gsd/tests/worktree-git-pathspec.test.ts

@@ -0,0 +1,39 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { _gitPathspecForWorktreePath } from "../auto-worktree.ts";
+
+function run(cmd: string, args: string[], cwd: string): string {
+  return execFileSync(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+describe("worktree git pathspec", () => {
+  test("skips external GSD bookkeeping directories outside the git work-tree", () => {
+    const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-pathspec-")));
+    const repo = join(root, "project");
+    const externalGsd = join(root, ".gsd", "projects", "abc123");
+
+    try {
+      mkdirSync(repo, { recursive: true });
+      mkdirSync(join(externalGsd, "milestones", "M002-wa00fm"), { recursive: true });
+      mkdirSync(join(externalGsd, "runtime", "units"), { recursive: true });
+      run("git", ["init"], repo);
+      writeFileSync(join(repo, "README.md"), "# test\n");
+
+      assert.equal(
+        _gitPathspecForWorktreePath(repo, join(externalGsd, "milestones", "M002-wa00fm")),
+        null,
+      );
+      assert.equal(
+        _gitPathspecForWorktreePath(repo, join(externalGsd, "runtime", "units")),
+        null,
+      );
+    } finally {
+      if (existsSync(root)) rmSync(root, { recursive: true, force: true });
+    }
+  });
+});