gsd-pi 2.37.1 → 2.38.0-dev.63ad7e5

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

@@ -360,4 +360,115 @@ console.log('\n=== Clean slice plan: no plan-quality issues ===');
   assertEq(planQualityIssues.length, 0, 'clean slice plan produces no empty_task_entry issues');
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// validateTaskPlanContent — missing output file paths
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== validateTaskPlanContent: missing output file paths ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something.
+
+## Steps
+
+1. Do the thing
+
+## Verification
+
+- Check it works
+
+## Expected Output
+
+This task produces the main output.
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const outputIssues = issues.filter(i => i.ruleId === 'missing_output_file_paths');
+  assertTrue(outputIssues.length >= 1, 'Expected Output without file paths triggers missing_output_file_paths');
+}
+
+console.log('\n=== validateTaskPlanContent: valid output file paths ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something.
+
+## Steps
+
+1. Do the thing
+
+## Verification
+
+- Check it works
+
+## Expected Output
+
+- \`src/types.ts\` — New type definitions
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const outputIssues = issues.filter(i => i.ruleId === 'missing_output_file_paths');
+  assertEq(outputIssues.length, 0, 'Expected Output with file paths does not trigger warning');
+}
+
+console.log('\n=== validateTaskPlanContent: missing input file paths (info severity) ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something.
+
+## Steps
+
+1. Do the thing
+
+## Verification
+
+- Check it works
+
+## Inputs
+
+Prior task summary insights about the architecture.
+
+## Expected Output
+
+- \`src/output.ts\` — Output file
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const inputIssues = issues.filter(i => i.ruleId === 'missing_input_file_paths');
+  assertTrue(inputIssues.length >= 1, 'Inputs without file paths triggers missing_input_file_paths');
+  if (inputIssues.length > 0) {
+    assertEq(inputIssues[0].severity, 'info', 'missing_input_file_paths is info severity (not warning)');
+  }
+}
+
+console.log('\n=== validateTaskPlanContent: no Expected Output section at all ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something.
+
+## Steps
+
+1. Do the thing
+
+## Verification
+
+- Check it works
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const outputIssues = issues.filter(i => i.ruleId === 'missing_output_file_paths');
+  assertTrue(outputIssues.length >= 1, 'Missing Expected Output section triggers missing_output_file_paths');
+}
+
 report();

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

@@ -208,30 +208,25 @@ test("git fields comprehensive validation", () => {
   assert.equal(preferences.git?.isolation, "branch");
 });
 
-test("auto_visualize, auto_report, compression_strategy, context_selection validate correctly", () => {
+test("auto_visualize, auto_report, context_selection validate correctly", () => {
   const { preferences, errors } = validatePreferences({
     auto_visualize: true,
     auto_report: false,
-    compression_strategy: "compress",
     context_selection: "smart",
   });
   assert.equal(errors.length, 0);
   assert.equal(preferences.auto_visualize, true);
   assert.equal(preferences.auto_report, false);
-  assert.equal(preferences.compression_strategy, "compress");
   assert.equal(preferences.context_selection, "smart");
 });
 
-test("auto_visualize, auto_report, compression_strategy, context_selection reject invalid values", () => {
+test("auto_visualize, auto_report, context_selection reject invalid values", () => {
   const { errors: e1 } = validatePreferences({ auto_visualize: "yes" as never });
   assert.ok(e1.some(e => e.includes("auto_visualize")));
 
   const { errors: e2 } = validatePreferences({ auto_report: 1 as never });
   assert.ok(e2.some(e => e.includes("auto_report")));
 
-  const { errors: e3 } = validatePreferences({ compression_strategy: "shrink" as never });
-  assert.ok(e3.some(e => e.includes("compression_strategy")));
-
   const { errors: e4 } = validatePreferences({ context_selection: "partial" as never });
   assert.ok(e4.some(e => e.includes("context_selection")));
 });

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

@@ -0,0 +1,59 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const promptsDir = join(process.cwd(), "src/resources/extensions/gsd/prompts");
+
+function readPrompt(name: string): string {
+  return readFileSync(join(promptsDir, `${name}.md`), "utf-8");
+}
+
+test("reactive-execute prompt keeps task summaries with subagents and avoids batch commits", () => {
+  const prompt = readPrompt("reactive-execute");
+  assert.match(prompt, /subagent-written summary as authoritative/i);
+  assert.match(prompt, /Do NOT create a batch commit/i);
+  assert.doesNotMatch(prompt, /\*\*Write task summaries\*\*/i);
+  assert.doesNotMatch(prompt, /\*\*Commit\*\* all changes/i);
+});
+
+test("run-uat prompt branches on dynamic UAT mode and supports runtime evidence", () => {
+  const prompt = readPrompt("run-uat");
+  assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`\{\{uatType\}\}`/);
+  assert.match(prompt, /uatType:\s*\{\{uatType\}\}/);
+  assert.match(prompt, /live-runtime/);
+  assert.match(prompt, /browser\/runtime\/network/i);
+  assert.match(prompt, /NEEDS-HUMAN/);
+  assert.doesNotMatch(prompt, /uatType:\s*artifact-driven/);
+});
+
+test("workflow-start prompt defaults to autonomy instead of per-phase confirmation", () => {
+  const prompt = readPrompt("workflow-start");
+  assert.match(prompt, /Keep moving by default/i);
+  assert.match(prompt, /Decision gates, not ceremony/i);
+  assert.doesNotMatch(prompt, /confirm with the user before proceeding/i);
+  assert.doesNotMatch(prompt, /Gate between phases/i);
+});
+
+test("discuss prompt allows implementation questions when they materially matter", () => {
+  const prompt = readPrompt("discuss");
+  assert.match(prompt, /Lead with experience, but ask implementation when it materially matters/i);
+  assert.match(prompt, /one gate, not two/i);
+  assert.doesNotMatch(prompt, /Questions must be about the experience, not the implementation/i);
+});
+
+test("guided discussion prompts avoid wrap-up prompts after every round", () => {
+  const milestonePrompt = readPrompt("guided-discuss-milestone");
+  const slicePrompt = readPrompt("guided-discuss-slice");
+  assert.match(milestonePrompt, /Do \*\*not\*\* ask a meta "ready to wrap up\?" question after every round/i);
+  assert.match(slicePrompt, /Do \*\*not\*\* ask a meta "ready to wrap up\?" question after every round/i);
+  assert.doesNotMatch(milestonePrompt, /I think I have a solid picture of this milestone\. Ready to wrap up/i);
+  assert.doesNotMatch(slicePrompt, /I think I have a solid picture of this slice\. Ready to wrap up/i);
+});
+
+test("guided-resume-task prompt preserves recovery state until work is superseded", () => {
+  const prompt = readPrompt("guided-resume-task");
+  assert.match(prompt, /Do \*\*not\*\* delete the continue file immediately/i);
+  assert.match(prompt, /successfully completed or you have written a newer summary\/continue artifact/i);
+  assert.doesNotMatch(prompt, /Delete the continue file after reading it/i);
+});