gsd-pi 2.38.0-dev.96dc7fb → 2.38.0-dev.98b44dc

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -80,66 +80,28 @@ test("buildHealthLines: initialized state shows continue setup copy", () => {
   ]);
 });
 
-test("buildHealthLines: active state leads with execution summary", () => {
-  const lines = buildHealthLines(activeData({
-    executionStatus: "Executing",
-    executionTarget: "Plan S01",
-    progress: {
-      milestones: { done: 0, total: 1 },
-      slices: { done: 0, total: 3 },
-      tasks: { done: 0, total: 5 },
-    },
-  }));
-
-  assert.equal(lines.length, 2);
-  assert.equal(lines[0], "  GSD  Executing - Plan S01");
-  assert.match(lines[1]!, /Progress: M 0\/1 · S 0\/3 · T 0\/5/);
-});
-
-test("buildHealthLines: active state keeps issues secondary", () => {
-  const lines = buildHealthLines(activeData({
-    executionStatus: "Planning",
-    executionTarget: "Execute T03",
-    providerIssue: "✗ Anthropic (Claude) key missing",
-    environmentWarningCount: 1,
-    budgetSpent: 0.42,
-  }));
-
-  assert.equal(lines.length, 2);
-  assert.equal(lines[0], "  GSD  Planning - Execute T03");
-  assert.match(lines[1]!, /✗ Anthropic \(Claude\) key missing/);
-  assert.match(lines[1]!, /Env: 1 warning/);
-  assert.match(lines[1]!, /Spent: 42\.0¢/);
-});
-
-test("buildHealthLines: blocked state explains wait reason", () => {
-  const lines = buildHealthLines(activeData({
-    executionStatus: "Blocked",
-    executionTarget: "waiting on unmet deps: M001",
-    blocker: "M002 is waiting on unmet deps: M001",
-  }));
-
-  assert.equal(lines[0], "  GSD  Blocked - waiting on unmet deps: M001");
+test("buildHealthLines: active state with ledger-driven spend shows spent summary", () => {
+  const lines = buildHealthLines(activeData({ budgetSpent: 0.42 }));
+  assert.equal(lines.length, 1);
+  assert.match(lines[0]!, /● System OK/);
+  assert.match(lines[0]!, /Spent: 42\.0¢/);
 });
 
-test("buildHealthLines: paused state can omit secondary line", () => {
-  const lines = buildHealthLines(activeData({
-    executionStatus: "Paused",
-    executionTarget: "waiting to resume",
-  }));
-
-  assert.deepEqual(lines, ["  GSD  Paused - waiting to resume"]);
+test("buildHealthLines: active state with budget ceiling shows percent summary", () => {
+  const lines = buildHealthLines(activeData({ budgetSpent: 2.5, budgetCeiling: 10 }));
+  assert.equal(lines.length, 1);
+  assert.match(lines[0]!, /Budget: \$2\.50\/\$10\.00 \(25%\)/);
 });
 
-test("buildHealthLines: active state with budget ceiling shows percent summary", () => {
+test("buildHealthLines: active state with issues reports issue summary", () => {
   const lines = buildHealthLines(activeData({
-    executionStatus: "Executing",
-    executionTarget: "Plan S01",
-    budgetSpent: 2.5,
-    budgetCeiling: 10,
+    providerIssue: "✗ OpenAI key missing",
+    environmentErrorCount: 1,
   }));
-  assert.equal(lines.length, 2);
-  assert.match(lines[1]!, /Budget: \$2\.50\/\$10\.00 \(25%\)/);
+  assert.equal(lines.length, 1);
+  assert.match(lines[0]!, /✗ 2 issues/);
+  assert.match(lines[0]!, /✗ OpenAI key missing/);
+  assert.match(lines[0]!, /Env: 1 error/);
 });
 
 test("detectHealthWidgetProjectState: metrics file alone does not imply project", () => {

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

@@ -1,4 +1,4 @@
-import { parseRoadmap, parsePlan, parseSummary, parseContinue, parseRequirementCounts, parseSecretsManifest, formatSecretsManifest } from '../files.ts';
+import { parseRoadmap, parsePlan, parseTaskPlanFile, parseSummary, parseContinue, parseRequirementCounts, parseSecretsManifest, formatSecretsManifest } from '../files.ts';
 import { createTestContext } from './test-helpers.ts';
 
 const { assertEq, assertTrue, report } = createTestContext();
@@ -241,7 +241,15 @@ console.log('\n=== parseRoadmap: missing risk defaults to low ===');
 
 console.log('\n=== parsePlan: full plan ===');
 {
-  const content = `# S01: Parser Test Suite
+  const content = `---
+estimated_steps: 6
+estimated_files: 3
+skills_used:
+  - typescript
+  - testing
+---
+
+# S01: Parser Test Suite
 
 **Goal:** All 5 parsers have test coverage with edge cases.
 **Demo:** \`node --test tests/parsers.test.ts\` passes with zero failures.
@@ -267,6 +275,13 @@ console.log('\n=== parsePlan: full plan ===');
 - \`files.ts\` — update parseSummary
 `;
 
+  const taskPlan = parseTaskPlanFile(content);
+  assertEq(taskPlan.frontmatter.estimated_steps, 6, 'task plan frontmatter estimated_steps');
+  assertEq(taskPlan.frontmatter.estimated_files, 3, 'task plan frontmatter estimated_files');
+  assertEq(taskPlan.frontmatter.skills_used.length, 2, 'task plan frontmatter skills_used count');
+  assertEq(taskPlan.frontmatter.skills_used[0], 'typescript', 'first task plan skill');
+  assertEq(taskPlan.frontmatter.skills_used[1], 'testing', 'second task plan skill');
+
   const p = parsePlan(content);
 
   assertEq(p.id, 'S01', 'plan id');
@@ -295,6 +310,97 @@ console.log('\n=== parsePlan: full plan ===');
   assertTrue(p.filesLikelyTouched[0].includes('tests/parsers.test.ts'), 'first file');
 }
 
+console.log('\n=== parseTaskPlanFile: defaults missing frontmatter fields ===');
+{
+  const content = `# T01: Minimal task plan
+
+## Description
+
+No frontmatter here.
+`;
+
+  const taskPlan = parseTaskPlanFile(content);
+  assertEq(taskPlan.frontmatter.estimated_steps, undefined, 'estimated_steps defaults undefined');
+  assertEq(taskPlan.frontmatter.estimated_files, undefined, 'estimated_files defaults undefined');
+  assertEq(taskPlan.frontmatter.skills_used.length, 0, 'skills_used defaults empty array');
+}
+
+console.log('\n=== parseTaskPlanFile: accepts scalar skills_used and numeric strings ===');
+{
+  const content = `---
+estimated_steps: "9"
+estimated_files: "4"
+skills_used: react-best-practices
+---
+
+# T02: Scalar skill handoff
+`;
+
+  const taskPlan = parseTaskPlanFile(content);
+  assertEq(taskPlan.frontmatter.estimated_steps, 9, 'string estimated_steps parsed');
+  assertEq(taskPlan.frontmatter.estimated_files, 4, 'string estimated_files parsed');
+  assertEq(taskPlan.frontmatter.skills_used.length, 1, 'scalar skills_used normalized to array');
+  assertEq(taskPlan.frontmatter.skills_used[0], 'react-best-practices', 'scalar skill preserved');
+}
+
+console.log('\n=== parseTaskPlanFile: filters blank skills_used items ===');
+{
+  const content = `---
+skills_used:
+  - react
+  -
+  - testing
+---
+
+# T03: Blank skills filtered
+`;
+
+  const taskPlan = parseTaskPlanFile(content);
+  assertEq(taskPlan.frontmatter.skills_used.length, 2, 'blank skill entries removed');
+  assertEq(taskPlan.frontmatter.skills_used[0], 'react', 'first remaining skill');
+  assertEq(taskPlan.frontmatter.skills_used[1], 'testing', 'second remaining skill');
+}
+
+console.log('\n=== parseTaskPlanFile: invalid numeric frontmatter ignored ===');
+{
+  const content = `---
+estimated_steps: many
+estimated_files: unknown
+---
+
+# T04: Invalid estimates
+`;
+
+  const taskPlan = parseTaskPlanFile(content);
+  assertEq(taskPlan.frontmatter.estimated_steps, undefined, 'invalid estimated_steps ignored');
+  assertEq(taskPlan.frontmatter.estimated_files, undefined, 'invalid estimated_files ignored');
+}
+
+console.log('\n=== parseTaskPlanFile: parsePlan ignores task-plan frontmatter ===');
+{
+  const content = `---
+estimated_steps: 2
+estimated_files: 1
+skills_used:
+  - react
+---
+
+# S11: Frontmatter Compatible
+
+**Goal:** Plan parser ignores task-plan handoff metadata.
+**Demo:** Slice content still parses.
+
+## Tasks
+
+- [ ] **T01: Compatible task** \`est:5m\`
+  Description.
+`;
+
+  const p = parsePlan(content);
+  assertEq(p.id, 'S11', 'plan id still parsed with frontmatter');
+  assertEq(p.tasks.length, 1, 'task still parsed with frontmatter');
+}
+
 console.log('\n=== parsePlan: multi-line task description concatenation ===');
 {
   const content = `# S02: Multi-line Test
@@ -324,16 +430,36 @@ console.log('\n=== parsePlan: multi-line task description concatenation ===');
   const p = parsePlan(content);
 
   assertEq(p.tasks.length, 2, 'two tasks');
-  // Multi-line descriptions should be concatenated with spaces
   assertTrue(p.tasks[0].description.includes('First line'), 'T01 desc has first line');
   assertTrue(p.tasks[0].description.includes('Second line'), 'T01 desc has second line');
   assertTrue(p.tasks[0].description.includes('Third line'), 'T01 desc has third line');
-  // Verify concatenation with space separator
   assertTrue(p.tasks[0].description.includes('description. Second'), 'lines joined with space');
-
   assertEq(p.tasks[1].description, 'Just one line.', 'T02 single-line desc');
 }
 
+console.log('\n=== parsePlan: frontmatter does not pollute task descriptions ===');
+{
+  const content = `---
+estimated_steps: 2
+estimated_files: 1
+skills_used:
+  - react
+---
+
+# S12: Frontmatter + multiline
+
+## Tasks
+
+- [ ] **T01: Multi-line Task** \`est:30m\`
+  First line of description.
+  Second line of description.
+`;
+
+  const p = parsePlan(content);
+  assertEq(p.tasks.length, 1, 'one task parsed with frontmatter');
+  assertEq(p.tasks[0].description, 'First line of description. Second line of description.', 'frontmatter excluded from description');
+}
+
 console.log('\n=== parsePlan: task with missing estimate ===');
 {
   const content = `# S03: No Estimate
@@ -351,12 +477,10 @@ console.log('\n=== parsePlan: task with missing estimate ===');
 `;
 
   const p = parsePlan(content);
-
   assertEq(p.tasks.length, 2, 'two tasks parsed');
   assertEq(p.tasks[0].id, 'T01', 'T01 id');
   assertEq(p.tasks[0].title, 'No Estimate Task', 'T01 title without estimate');
   assertEq(p.tasks[0].done, false, 'T01 not done');
-  // The estimate backtick text appears in description if present, but parser doesn't crash without it
   assertEq(p.tasks[1].id, 'T02', 'T02 id');
 }
 
@@ -379,7 +503,6 @@ console.log('\n=== parsePlan: empty tasks section ===');
 `;
 
   const p = parsePlan(content);
-
   assertEq(p.id, 'S04', 'plan id with empty tasks');
   assertEq(p.tasks.length, 0, 'no tasks');
   assertEq(p.mustHaves.length, 1, 'one must-have');
@@ -398,7 +521,6 @@ console.log('\n=== parsePlan: no H1 ===');
 `;
 
   const p = parsePlan(content);
-
   assertEq(p.id, '', 'empty id without H1');
   assertEq(p.title, '', 'empty title without H1');
   assertEq(p.goal, 'A plan without a heading.', 'goal still parsed');
@@ -408,8 +530,6 @@ console.log('\n=== parsePlan: no H1 ===');
 
 console.log('\n=== parsePlan: task estimate backtick in description ===');
 {
-  // The `est:45m` text appears after the bold closing but before the description lines
-  // It should end up as part of the description or be ignored gracefully
   const content = `# S05: Estimate Handling
 
 **Goal:** Test estimate text handling.
@@ -425,9 +545,6 @@ console.log('\n=== parsePlan: task estimate backtick in description ===');
   assertEq(p.tasks.length, 1, 'one task');
   assertEq(p.tasks[0].id, 'T01', 'task id');
   assertEq(p.tasks[0].title, 'With Estimate', 'title excludes estimate');
-  // The `est:45m` backtick text after ** is not part of the title or description
-  // It's on the same line after the regex match captures, so it's in the remainder
-  // The description should be the continuation lines
   assertTrue(p.tasks[0].description.includes('Main description'), 'description from continuation line');
 }
 

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

@@ -26,8 +26,21 @@ const BASE_VARS = {
   inlinedContext: "--- test inlined context ---",
   dependencySummaries: "", executorContextConstraints: "",
   sourceFilePaths: "- **Requirements**: `.gsd/REQUIREMENTS.md`",
+  skillActivation: "Load the relevant skills.",
 };
 
+const DEFAULT_SKILL_ACTIVATION = "If a `GSD Skill Preferences` block is present in system context, use it and the `<available_skills>` catalog in your system prompt to decide which skills to load and follow for this unit, without relaxing required verification or artifact rules.";
+
+function loadPromptWithDefaultSkillActivation(name: string, vars: Record<string, string> = {}): string {
+  return loadPrompt(name, { skillActivation: DEFAULT_SKILL_ACTIVATION, ...vars });
+}
+
+function promptUsesSkillActivation(name: string): boolean {
+  const path = join(worktreePromptsDir, `${name}.md`);
+  const content = readFileSync(path, "utf-8");
+  return content.includes("{{skillActivation}}");
+}
+
 test("plan-slice prompt: commit instruction says do not commit (external state)", () => {
   const result = loadPrompt("plan-slice", { ...BASE_VARS, commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally." });
   assert.ok(result.includes("Do not commit planning artifacts"));
@@ -40,3 +53,199 @@ test("plan-slice prompt: all variables substituted", () => {
   assert.ok(result.includes("M001"));
   assert.ok(result.includes("S01"));
 });
+
+test("domain-work prompts use skillActivation placeholder", () => {
+  const prompts = [
+    "research-milestone",
+    "plan-milestone",
+    "research-slice",
+    "plan-slice",
+    "execute-task",
+    "guided-research-slice",
+    "guided-plan-milestone",
+    "guided-plan-slice",
+    "guided-execute-task",
+    "guided-resume-task",
+  ];
+
+  for (const name of prompts) {
+    assert.ok(promptUsesSkillActivation(name), `${name}.md should contain {{skillActivation}}`);
+  }
+});
+
+test("skillActivation default leaves no unresolved placeholder", () => {
+  const result = loadPromptWithDefaultSkillActivation("execute-task", {
+    workingDirectory: "/tmp/test-project",
+    milestoneId: "M001",
+    sliceId: "S01",
+    sliceTitle: "Test Slice",
+    taskId: "T01",
+    taskTitle: "Implement feature",
+    planPath: ".gsd/milestones/M001/slices/S01/S01-PLAN.md",
+    taskPlanPath: ".gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md",
+    taskPlanInline: "Task plan",
+    slicePlanExcerpt: "Slice excerpt",
+    carryForwardSection: "Carry forward",
+    resumeSection: "Resume",
+    priorTaskLines: "- (no prior tasks)",
+    taskSummaryPath: "/tmp/test-project/.gsd/milestones/M001/slices/S01/tasks/T01-SUMMARY.md",
+    inlinedTemplates: "Template",
+    verificationBudget: "~10K chars",
+    overridesSection: "",
+  });
+
+  assert.ok(!result.includes("{{skillActivation}}"));
+  assert.ok(result.includes(DEFAULT_SKILL_ACTIVATION));
+});
+
+test("custom skillActivation is substituted into execute-task", () => {
+  const result = loadPrompt("execute-task", {
+    workingDirectory: "/tmp/test-project",
+    milestoneId: "M001",
+    sliceId: "S01",
+    sliceTitle: "Test Slice",
+    taskId: "T01",
+    taskTitle: "Implement feature",
+    planPath: ".gsd/milestones/M001/slices/S01/S01-PLAN.md",
+    taskPlanPath: ".gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md",
+    taskPlanInline: "Task plan",
+    slicePlanExcerpt: "Slice excerpt",
+    carryForwardSection: "Carry forward",
+    resumeSection: "Resume",
+    priorTaskLines: "- (no prior tasks)",
+    taskSummaryPath: "/tmp/test-project/.gsd/milestones/M001/slices/S01/tasks/T01-SUMMARY.md",
+    inlinedTemplates: "Template",
+    verificationBudget: "~10K chars",
+    overridesSection: "",
+    skillActivation: "Load React and accessibility skills first.",
+  });
+
+  assert.ok(result.includes("Load React and accessibility skills first."));
+  assert.ok(!result.includes("{{skillActivation}}"));
+});
+
+test("guided execute prompt substitutes skillActivation", () => {
+  const result = loadPrompt("guided-execute-task", {
+    milestoneId: "M001",
+    sliceId: "S01",
+    taskId: "T01",
+    taskTitle: "Implement feature",
+    inlinedTemplates: "Template",
+    skillActivation: "Load React skill first.",
+  });
+
+  assert.ok(result.includes("Load React skill first."));
+  assert.ok(!result.includes("{{skillActivation}}"));
+});
+
+test("guided resume prompt substitutes skillActivation", () => {
+  const result = loadPrompt("guided-resume-task", {
+    milestoneId: "M001",
+    sliceId: "S01",
+    skillActivation: "Load debugging skill first.",
+  });
+
+  assert.ok(result.includes("Load debugging skill first."));
+  assert.ok(!result.includes("{{skillActivation}}"));
+});
+
+test("research-milestone prompt substitutes skillActivation", () => {
+  const result = loadPrompt("research-milestone", {
+    workingDirectory: "/tmp/test-project",
+    milestoneId: "M001",
+    milestoneTitle: "Test Milestone",
+    milestonePath: ".gsd/milestones/M001",
+    contextPath: ".gsd/milestones/M001/M001-CONTEXT.md",
+    outputPath: "/tmp/test-project/.gsd/milestones/M001/M001-RESEARCH.md",
+    inlinedContext: "Context",
+    skillDiscoveryMode: "manual",
+    skillDiscoveryInstructions: " Discover skills manually.",
+    skillActivation: "Load research skills first.",
+  });
+
+  assert.ok(result.includes("Load research skills first."));
+  assert.ok(!result.includes("{{skillActivation}}"));
+});
+
+test("research-slice prompt substitutes skillActivation", () => {
+  const result = loadPrompt("research-slice", {
+    workingDirectory: "/tmp/test-project",
+    milestoneId: "M001",
+    sliceId: "S01",
+    sliceTitle: "Test Slice",
+    slicePath: ".gsd/milestones/M001/slices/S01",
+    roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md",
+    contextPath: ".gsd/milestones/M001/M001-CONTEXT.md",
+    milestoneResearchPath: ".gsd/milestones/M001/M001-RESEARCH.md",
+    outputPath: "/tmp/test-project/.gsd/milestones/M001/slices/S01/S01-RESEARCH.md",
+    inlinedContext: "Context",
+    dependencySummaries: "",
+    skillDiscoveryMode: "manual",
+    skillDiscoveryInstructions: " Discover skills manually.",
+    skillActivation: "Load slice research skills first.",
+  });
+
+  assert.ok(result.includes("Load slice research skills first."));
+  assert.ok(!result.includes("{{skillActivation}}"));
+});
+
+test("plan-milestone prompt substitutes skillActivation", () => {
+  const result = loadPrompt("plan-milestone", {
+    workingDirectory: "/tmp/test-project",
+    milestoneId: "M001",
+    milestoneTitle: "Test Milestone",
+    milestonePath: ".gsd/milestones/M001",
+    contextPath: ".gsd/milestones/M001/M001-CONTEXT.md",
+    researchPath: ".gsd/milestones/M001/M001-RESEARCH.md",
+    researchOutputPath: "/tmp/test-project/.gsd/milestones/M001/M001-RESEARCH.md",
+    outputPath: "/tmp/test-project/.gsd/milestones/M001/M001-ROADMAP.md",
+    secretsOutputPath: "/tmp/test-project/.gsd/milestones/M001/M001-SECRETS.md",
+    inlinedContext: "Context",
+    sourceFilePaths: "- source",
+    skillDiscoveryMode: "manual",
+    skillDiscoveryInstructions: " Discover skills manually.",
+    skillActivation: "Load milestone planning skills first.",
+  });
+
+  assert.ok(result.includes("Load milestone planning skills first."));
+  assert.ok(!result.includes("{{skillActivation}}"));
+});
+
+test("guided plan milestone prompt substitutes skillActivation", () => {
+  const result = loadPrompt("guided-plan-milestone", {
+    milestoneId: "M001",
+    milestoneTitle: "Test Milestone",
+    secretsOutputPath: ".gsd/milestones/M001/M001-SECRETS.md",
+    inlinedTemplates: "Templates",
+    skillActivation: "Load guided planning skills first.",
+  });
+
+  assert.ok(result.includes("Load guided planning skills first."));
+  assert.ok(!result.includes("{{skillActivation}}"));
+});
+
+test("guided plan slice prompt substitutes skillActivation", () => {
+  const result = loadPrompt("guided-plan-slice", {
+    milestoneId: "M001",
+    sliceId: "S01",
+    sliceTitle: "Test Slice",
+    inlinedTemplates: "Templates",
+    skillActivation: "Load guided slice planning skills first.",
+  });
+
+  assert.ok(result.includes("Load guided slice planning skills first."));
+  assert.ok(!result.includes("{{skillActivation}}"));
+});
+
+test("guided research slice prompt substitutes skillActivation", () => {
+  const result = loadPrompt("guided-research-slice", {
+    milestoneId: "M001",
+    sliceId: "S01",
+    sliceTitle: "Test Slice",
+    inlinedTemplates: "Templates",
+    skillActivation: "Load guided research skills first.",
+  });
+
+  assert.ok(result.includes("Load guided research skills first."));
+  assert.ok(!result.includes("{{skillActivation}}"));
+});

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);
+});

package/src/resources/extensions/gsd/tests/repo-identity-worktree.test.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { externalGsdRoot, ensureGsdSymlink } from "../repo-identity.ts";
+import { repoIdentity, externalGsdRoot, ensureGsdSymlink, validateProjectId } from "../repo-identity.ts";
 import { createTestContext } from "./test-helpers.ts";
 
 const { assertEq, assertTrue, report } = createTestContext();
@@ -57,6 +57,26 @@ async function main(): Promise<void> {
     assertEq(preservedDirState, join(worktreePath, ".gsd"), "worktree .gsd directory is left in place for sync-based refresh");
     assertTrue(lstatSync(join(worktreePath, ".gsd")).isDirectory(), "worktree .gsd directory remains a directory");
     assertTrue(existsSync(join(worktreePath, ".gsd", "milestones", "stale.txt")), "existing worktree .gsd directory contents remain available for sync logic");
+
+    console.log("\n=== GSD_PROJECT_ID overrides computed repo hash ===");
+    process.env.GSD_PROJECT_ID = "my-project";
+    assertEq(repoIdentity(base), "my-project", "repoIdentity returns GSD_PROJECT_ID when set");
+    assertEq(externalGsdRoot(base), join(stateDir, "projects", "my-project"), "externalGsdRoot uses GSD_PROJECT_ID");
+    delete process.env.GSD_PROJECT_ID;
+
+    console.log("\n=== GSD_PROJECT_ID falls back to hash when unset ===");
+    const hashIdentity = repoIdentity(base);
+    assertTrue(/^[0-9a-f]{12}$/.test(hashIdentity), "repoIdentity returns 12-char hex hash when GSD_PROJECT_ID is unset");
+
+    console.log("\n=== validateProjectId rejects invalid values ===");
+    for (const invalid of ["has spaces", "path/traversal", "dot..dot", "back\\slash"]) {
+      assertTrue(!validateProjectId(invalid), `validateProjectId rejects invalid value: "${invalid}"`);
+    }
+
+    console.log("\n=== validateProjectId accepts valid values ===");
+    for (const valid of ["my-project", "foo_bar", "abc123", "A-Z_0-9"]) {
+      assertTrue(validateProjectId(valid), `validateProjectId accepts valid value: "${valid}"`);
+    }
   } finally {
     delete process.env.GSD_STATE_DIR;
     rmSync(base, { recursive: true, force: true });