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

package/src/resources/extensions/gsd/tests/run-uat.test.ts

@@ -29,7 +29,11 @@ const worktreePromptsDir = join(__dirname, '..', 'prompts');
 function loadPromptFromWorktree(name: string, vars: Record<string, string> = {}): string {
   const path = join(worktreePromptsDir, `${name}.md`);
   let content = readFileSync(path, 'utf-8');
-  for (const [key, value] of Object.entries(vars)) {
+  const effectiveVars = {
+    skillActivation: 'If no installed skill clearly matches this unit, skip explicit skill activation and continue with the required workflow.',
+    ...vars,
+  };
+  for (const [key, value] of Object.entries(effectiveVars)) {
     content = content.replaceAll(`{{${key}}}`, value);
   }
   return content.trim();
@@ -210,7 +214,7 @@ async function main(): Promise<void> {
   const sliceId = 'S01';
   const uatPath = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
   const uatResultPath = '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md';
-  const uatType = 'artifact-driven';
+  const uatType = 'live-runtime';
   const inlinedContext = '<!-- no context -->';
 
   let promptResult: string | undefined;
@@ -246,13 +250,21 @@ async function main(): Promise<void> {
     promptResult?.includes(uatResultPath) ?? false,
     `prompt contains uatResultPath value after substitution`,
   );
+  assertTrue(
+    promptResult?.includes(`Detected UAT mode:** \`${uatType}\``) ?? false,
+    `prompt contains detected dynamic uatType value "${uatType}" after substitution`,
+  );
+  assertTrue(
+    promptResult?.includes(`uatType: ${uatType}`) ?? false,
+    `prompt contains dynamic uatType frontmatter value "${uatType}" after substitution`,
+  );
   assertTrue(
     !/\{\{[^}]+\}\}/.test(promptResult ?? ''),
     'no unreplaced {{...}} tokens remain after variable substitution',
   );
   assertTrue(
-    /artifact|execute|run/i.test(promptResult ?? ''),
-    'prompt contains artifact-driven execution language (artifact/execute/run)',
+    /browser|runtime|execute|run/i.test(promptResult ?? ''),
+    'prompt contains runtime execution language (browser/runtime/execute/run)',
   );
   assertTrue(
     !/surfaced for human review/i.test(promptResult ?? ''),

package/src/resources/extensions/gsd/tests/skill-activation.test.ts

@@ -0,0 +1,140 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { loadSkills } from "@gsd/pi-coding-agent";
+import { buildSkillActivationBlock } from "../auto-prompts.js";
+import type { GSDPreferences } from "../preferences.js";
+
+function makeTempBase(): string {
+  return mkdtempSync(join(tmpdir(), "gsd-skill-activation-"));
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+function writeSkill(base: string, name: string, description: string): void {
+  const dir = join(base, "skills", name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "SKILL.md"), `---\nname: ${name}\ndescription: ${description}\n---\n\n# ${name}\n`);
+}
+
+function loadOnlyTestSkills(base: string): void {
+  loadSkills({ cwd: base, includeDefaults: false, skillPaths: [join(base, "skills")] });
+}
+
+function buildBlock(
+  base: string,
+  params: Partial<Parameters<typeof buildSkillActivationBlock>[0]> = {},
+  preferences: GSDPreferences = {},
+): string {
+  return buildSkillActivationBlock({
+    base,
+    milestoneId: "M001",
+    sliceId: "S01",
+    ...params,
+    preferences,
+  });
+}
+
+test("buildSkillActivationBlock matches installed skills from task context", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "react", "Use for React components, hooks, JSX, and frontend UI work.");
+    writeSkill(base, "swiftui", "Use for SwiftUI views, iOS layout, and Apple platform UI work.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, {
+      sliceTitle: "Build React dashboard",
+      taskId: "T01",
+      taskTitle: "Implement React settings panel",
+    });
+
+    assert.match(result, /<skill_activation>/);
+    assert.match(result, /Call Skill\('react'\)/);
+    assert.doesNotMatch(result, /swiftui/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildSkillActivationBlock includes always_use_skills from preferences", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "testing", "Use for test setup, assertions, and verification patterns.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, { taskTitle: "Unrelated task title" }, {
+      always_use_skills: ["testing"],
+    });
+
+    assert.match(result, /Call Skill\('testing'\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildSkillActivationBlock includes skill_rules matches and task-plan skills_used", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "prisma", "Use for Prisma schema, migrations, and ORM queries.");
+    writeSkill(base, "accessibility", "Use for accessibility, aria attributes, and keyboard support.");
+    loadOnlyTestSkills(base);
+
+    const taskPlan = [
+      "---",
+      "skills_used:",
+      "  - accessibility",
+      "---",
+      "# T01: Example",
+    ].join("\n");
+
+    const result = buildBlock(base, {
+      taskTitle: "Update prisma schema",
+      taskPlanContent: taskPlan,
+    }, {
+      skill_rules: [{ when: "prisma database schema", use: ["prisma"] }],
+    });
+
+    assert.match(result, /Call Skill\('accessibility'\)/);
+    assert.match(result, /Call Skill\('prisma'\)/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildSkillActivationBlock honors avoid_skills", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "react", "Use for React components and frontend UI work.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, {
+      taskTitle: "Implement React settings panel",
+    }, {
+      avoid_skills: ["react"],
+    });
+
+    assert.equal(result, "");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("buildSkillActivationBlock falls back cleanly when nothing matches", () => {
+  const base = makeTempBase();
+  try {
+    writeSkill(base, "swiftui", "Use for SwiftUI apps.");
+    loadOnlyTestSkills(base);
+
+    const result = buildBlock(base, {
+      taskTitle: "Plain text docs task",
+    });
+
+    assert.equal(result, "");
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/types.ts

@@ -61,6 +61,16 @@ export interface TaskPlanEntry {
   verify?: string; // e.g. "run tests" — extracted from "- Verify:" subline
 }
 
+export interface TaskPlanFrontmatter {
+  estimated_steps?: number; // optional scope estimate for plan quality validator
+  estimated_files?: number; // optional file-count estimate for scope warning heuristics
+  skills_used: string[]; // installed skill slugs/names to hand off to execute-task prompts
+}
+
+export interface TaskPlanFile {
+  frontmatter: TaskPlanFrontmatter;
+}
+
 // ─── Verification Gate ─────────────────────────────────────────────────────
 
 /** Result of a single verification command execution */
@@ -423,7 +433,6 @@ export interface Requirement {
 
 // ─── Parallel Orchestration Types ────────────────────────────────────────
 
-export type CompressionStrategy = "truncate" | "compress";
 export type ContextSelectionMode = "full" | "smart";
 
 export type MergeStrategy = "per-slice" | "per-milestone";
@@ -479,3 +488,11 @@ export interface ReactiveExecutionState {
   };
   updatedAt: string;
 }
+
+export interface BrowserFlowResult {
+  url: string;
+  passed: boolean;
+  checksTotal: number;
+  checksPassed: number;
+  duration: number;
+}

package/src/resources/extensions/gsd/verification-evidence.ts

@@ -37,6 +37,21 @@ export interface AuditWarningJSON {
   fixAvailable: boolean;
 }
 
+export interface BrowserEvidenceCheckJSON {
+  description: string;
+  passed: boolean;
+  actual?: string;
+  evidence?: string;
+  error?: string;
+}
+
+export interface BrowserEvidenceJSON {
+  url: string;
+  passed: boolean;
+  checks: BrowserEvidenceCheckJSON[];
+  duration: number;
+}
+
 export interface EvidenceJSON {
   schemaVersion: 1;
   taskId: string;
@@ -49,6 +64,7 @@ export interface EvidenceJSON {
   maxRetries?: number;
   runtimeErrors?: RuntimeErrorJSON[];
   auditWarnings?: AuditWarningJSON[];
+  browser?: BrowserEvidenceJSON;
 }
 
 /**

package/src/resources/extensions/gsd/visualizer-data.ts

@@ -3,7 +3,7 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { deriveState } from './state.js';
 import { parseRoadmap, parsePlan, parseSummary, loadFile } from './files.js';
-import { findMilestoneIds } from './guided-flow.js';
+import { findMilestoneIds } from './milestone-ids.js';
 import { resolveMilestoneFile, resolveSliceFile, resolveGsdRootFile } from './paths.js';
 import {
   getLedger,

package/src/resources/extensions/mcp-client/index.ts

@@ -114,6 +114,22 @@ function getServerConfig(name: string): McpServerConfig | undefined {
 	return readConfigs().find((s) => s.name === name);
 }
 
+/** Resolve ${VAR} references in env values against process.env. */
+function resolveEnv(env: Record<string, string>): Record<string, string> {
+	const resolved: Record<string, string> = {};
+	for (const [key, value] of Object.entries(env)) {
+		if (typeof value === "string") {
+			resolved[key] = value.replace(
+				/\$\{([^}]+)\}/g,
+				(_match, varName) => process.env[varName] ?? "",
+			);
+		} else {
+			resolved[key] = value;
+		}
+	}
+	return resolved;
+}
+
 async function getOrConnect(name: string, signal?: AbortSignal): Promise<Client> {
 	const existing = connections.get(name);
 	if (existing) return existing.client;
@@ -128,7 +144,7 @@ async function getOrConnect(name: string, signal?: AbortSignal): Promise<Client>
 		transport = new StdioClientTransport({
 			command: config.command,
 			args: config.args,
-			env: config.env ? { ...process.env, ...config.env } as Record<string, string> : undefined,
+			env: config.env ? { ...process.env, ...resolveEnv(config.env) } as Record<string, string> : undefined,
 			cwd: config.cwd,
 			stderr: "pipe",
 		});

package/src/resources/extensions/remote-questions/status.ts

@@ -7,6 +7,10 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { readPromptRecord } from "./store.js";
 
+function getGsdHome(): string {
+  return process.env.GSD_HOME || join(homedir(), ".gsd");
+}
+
 export interface LatestPromptSummary {
   id: string;
   status: string;
@@ -14,7 +18,7 @@ export interface LatestPromptSummary {
 }
 
 export function getLatestPromptSummary(): LatestPromptSummary | null {
-  const runtimeDir = join(homedir(), ".gsd", "runtime", "remote-questions");
+  const runtimeDir = join(getGsdHome(), "runtime", "remote-questions");
   if (!existsSync(runtimeDir)) return null;
   const files = readdirSync(runtimeDir).filter((f) => f.endsWith(".json"));
   if (files.length === 0) return null;

package/src/resources/extensions/remote-questions/store.ts

@@ -7,8 +7,12 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import type { RemotePrompt, RemotePromptRecord, RemotePromptRef, RemoteAnswer, RemotePromptStatus } from "./types.js";
 
+function getGsdHome(): string {
+  return process.env.GSD_HOME || join(homedir(), ".gsd");
+}
+
 function runtimeDir(): string {
-  return join(homedir(), ".gsd", "runtime", "remote-questions");
+  return join(getGsdHome(), "runtime", "remote-questions");
 }
 
 function recordPath(id: string): string {

package/src/resources/extensions/search-the-web/provider.ts

@@ -17,7 +17,8 @@ import { resolveSearchProviderFromPreferences } from '../gsd/preferences.js'
 // Compute authFilePath locally instead of importing from app-paths.ts,
 // because extensions are copied to ~/.gsd/agent/extensions/ at runtime
 // where the relative import '../../../app-paths.ts' doesn't resolve.
-const authFilePath = join(homedir(), '.gsd', 'agent', 'auth.json')
+const gsdHome = process.env.GSD_HOME || join(homedir(), '.gsd')
+const authFilePath = join(gsdHome, 'agent', 'auth.json')
 
 export type SearchProvider = 'tavily' | 'brave' | 'ollama'
 export type SearchProviderPreference = SearchProvider | 'auto'

package/src/resources/extensions/shared/frontmatter.ts

@@ -50,7 +50,7 @@ export function parseFrontmatterMap(lines: string[]): Record<string, unknown> {
     }
 
     // Array item (2-space indent)
-    const arrayMatch = line.match(/^  - (.*)$/);
+    const arrayMatch = line.match(/^  - ?(.*)$/);
     if (arrayMatch && currentKey) {
       // If there's a pending nested object, push it
       if (currentObj && Object.keys(currentObj).length > 0) {

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

@@ -57,8 +57,10 @@ function encodeCwd(cwd: string): string {
 	return cwd.replace(/\//g, "--");
 }
 
+const gsdHome = process.env.GSD_HOME || path.join(os.homedir(), ".gsd");
+
 function getIsolationBaseDir(cwd: string, taskId: string): string {
-	return path.join(os.homedir(), ".gsd", "wt", encodeCwd(cwd), taskId);
+	return path.join(gsdHome, "wt", encodeCwd(cwd), taskId);
 }
 
 // Track active isolation dirs for cleanup on exit

package/src/resources/extensions/ttsr/rule-loader.ts

@@ -8,6 +8,8 @@
 import { readdirSync, readFileSync, existsSync } from "node:fs";
 import { join, basename } from "node:path";
 import { homedir } from "node:os";
+
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 import type { Rule } from "./ttsr-manager.js";
 import { splitFrontmatter, parseFrontmatterMap } from "../shared/frontmatter.js";
 
@@ -59,7 +61,7 @@ function scanDir(dir: string): Rule[] {
  * Project rules override global rules with the same name.
  */
 export function loadRules(cwd: string): Rule[] {
-	const globalDir = join(homedir(), ".gsd", "agent", "rules");
+	const globalDir = join(gsdHome, "agent", "rules");
 	const projectDir = join(cwd, ".gsd", "rules");
 
 	const globalRules = scanDir(globalDir);