gsd-pi 2.37.1-dev.d3ace49 → 2.38.0-dev.361f5e3

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

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

@@ -210,7 +210,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 +246,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/worktree.test.ts

@@ -11,6 +11,7 @@ import {
   getMainBranch,
   getSliceBranchName,
   parseSliceBranch,
+  resolveProjectRoot,
   setActiveMilestoneId,
   SLICE_BRANCH_RE,
 } from "../worktree.ts";
@@ -165,6 +166,52 @@ async function main(): Promise<void> {
     rmSync(repo, { recursive: true, force: true });
   }
 
+  // ── detectWorktreeName: symlink-resolved paths ───────────────────────────
+  console.log("\n=== detectWorktreeName (symlink-resolved paths) ===");
+  assertEq(
+    detectWorktreeName("/Users/fran/.gsd/projects/89e1c9ad49bf/worktrees/M001"),
+    "M001",
+    "detects milestone in symlink-resolved path",
+  );
+  assertEq(
+    detectWorktreeName("/Users/fran/.gsd/projects/abc123/worktrees/M002/subdir"),
+    "M002",
+    "detects milestone with trailing subdir in symlink-resolved path",
+  );
+  assertEq(
+    detectWorktreeName("/Users/fran/.gsd/projects/abc123"),
+    null,
+    "returns null for project root without worktrees segment",
+  );
+  assertEq(
+    detectWorktreeName("/foo/.gsd/worktrees/M001"),
+    "M001",
+    "still detects direct layout path",
+  );
+
+  // ── resolveProjectRoot: symlink-resolved paths ──────────────────────────
+  console.log("\n=== resolveProjectRoot (symlink-resolved paths) ===");
+  assertEq(
+    resolveProjectRoot("/Users/fran/.gsd/projects/89e1c9ad49bf/worktrees/M001"),
+    "/Users/fran",
+    "resolves to user home for symlink-resolved path",
+  );
+  assertEq(
+    resolveProjectRoot("/foo/.gsd/worktrees/M001"),
+    "/foo",
+    "still resolves direct layout path",
+  );
+  assertEq(
+    resolveProjectRoot("/some/repo"),
+    "/some/repo",
+    "returns unchanged for non-worktree path",
+  );
+  assertEq(
+    resolveProjectRoot("/data/.gsd/projects/deadbeef/worktrees/M003/nested"),
+    "/data",
+    "resolves correctly with nested subdirs after worktree name",
+  );
+
   rmSync(base, { recursive: true, force: true });
   report();
 }

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

@@ -423,7 +423,6 @@ export interface Requirement {
 
 // ─── Parallel Orchestration Types ────────────────────────────────────────
 
-export type CompressionStrategy = "truncate" | "compress";
 export type ContextSelectionMode = "full" | "smart";
 
 export type MergeStrategy = "per-slice" | "per-milestone";

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/gsd/worktree.ts

@@ -67,40 +67,60 @@ export function captureIntegrationBranch(basePath: string, milestoneId: string,
 
 // ─── Pure Utility Functions (unchanged) ────────────────────────────────────
 
+/**
+ * Find the worktrees segment in a path, supporting both direct
+ * (`/.gsd/worktrees/`) and symlink-resolved (`/.gsd/projects/<hash>/worktrees/`)
+ * layouts.  When `.gsd` is a symlink to `~/.gsd/projects/<hash>`, resolved
+ * paths contain the intermediate `projects/<hash>/` segment that the old
+ * single-marker check missed.
+ */
+function findWorktreeSegment(normalizedPath: string): { gsdIdx: number; afterWorktrees: number } | null {
+  // Direct layout: /.gsd/worktrees/<name>
+  const directMarker = "/.gsd/worktrees/";
+  const idx = normalizedPath.indexOf(directMarker);
+  if (idx !== -1) {
+    return { gsdIdx: idx, afterWorktrees: idx + directMarker.length };
+  }
+  // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/<name>
+  const symlinkRe = /\/\.gsd\/projects\/[a-f0-9]+\/worktrees\//;
+  const match = normalizedPath.match(symlinkRe);
+  if (match && match.index !== undefined) {
+    return { gsdIdx: match.index, afterWorktrees: match.index + match[0].length };
+  }
+  return null;
+}
+
 /**
  * Detect the active worktree name from the current working directory.
  * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
  */
 export function detectWorktreeName(basePath: string): string | null {
   const normalizedPath = basePath.replaceAll("\\", "/");
-  const marker = "/.gsd/worktrees/";
-  const idx = normalizedPath.indexOf(marker);
-  if (idx === -1) return null;
-  const afterMarker = normalizedPath.slice(idx + marker.length);
+  const seg = findWorktreeSegment(normalizedPath);
+  if (!seg) return null;
+  const afterMarker = normalizedPath.slice(seg.afterWorktrees);
   const name = afterMarker.split("/")[0];
   return name || null;
 }
 
 /**
  * Resolve the project root from a path that may be inside a worktree.
- * If the path contains `/.gsd/worktrees/<name>/`, returns the portion
- * before `/.gsd/`. Otherwise returns the input unchanged.
+ * If the path contains a worktrees segment, returns the portion before
+ * `/.gsd/`. Otherwise returns the input unchanged.
  *
  * Use this in commands that call `process.cwd()` to ensure they always
  * operate against the real project root, not a worktree subdirectory.
  */
 export function resolveProjectRoot(basePath: string): string {
   const normalizedPath = basePath.replaceAll("\\", "/");
-  const marker = "/.gsd/worktrees/";
-  const idx = normalizedPath.indexOf(marker);
-  if (idx === -1) return basePath;
-  // Return the original path up to the .gsd/ marker (un-normalized)
-  // Account for potential OS-specific separators
+  const seg = findWorktreeSegment(normalizedPath);
+  if (!seg) return basePath;
+  // Return the original path up to the /.gsd/ boundary
   const sep = basePath.includes("\\") ? "\\" : "/";
-  const markerOs = `${sep}.gsd${sep}worktrees${sep}`;
-  const idxOs = basePath.indexOf(markerOs);
-  if (idxOs !== -1) return basePath.slice(0, idxOs);
-  return basePath.slice(0, idx);
+  const gsdMarker = `${sep}.gsd${sep}`;
+  const gsdIdx = basePath.indexOf(gsdMarker);
+  if (gsdIdx !== -1) return basePath.slice(0, gsdIdx);
+  return basePath.slice(0, seg.gsdIdx);
 }
 
 /**

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

@@ -7,6 +7,8 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { readPromptRecord } from "./store.js";
 
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+
 export interface LatestPromptSummary {
   id: string;
   status: string;
@@ -14,7 +16,7 @@ export interface LatestPromptSummary {
 }
 
 export function getLatestPromptSummary(): LatestPromptSummary | null {
-  const runtimeDir = join(homedir(), ".gsd", "runtime", "remote-questions");
+  const runtimeDir = join(gsdHome, "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,10 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import type { RemotePrompt, RemotePromptRecord, RemotePromptRef, RemoteAnswer, RemotePromptStatus } from "./types.js";
 
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+
 function runtimeDir(): string {
-  return join(homedir(), ".gsd", "runtime", "remote-questions");
+  return join(gsdHome, "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/subagent/index.ts

@@ -452,7 +452,7 @@ async function runSingleAgent(
 
 async function runSingleAgentInCmuxSplit(
 	cmuxClient: CmuxClient,
-	direction: "right" | "down",
+	directionOrSurfaceId: "right" | "down" | string,
 	defaultCwd: string,
 	agents: AgentConfig[],
 	agentName: string,
@@ -503,7 +503,12 @@ async function runSingleAgentInCmuxSplit(
 		const stdoutPath = path.join(tmpOutputDir, "stdout.jsonl");
 		const stderrPath = path.join(tmpOutputDir, "stderr.log");
 		const exitPath = path.join(tmpOutputDir, "exit.code");
-		const cmuxSurfaceId = await cmuxClient.createSplit(direction);
+		// Accept either a pre-created surface ID or a direction to create a new split
+		const isDirection = directionOrSurfaceId === "right" || directionOrSurfaceId === "down"
+			|| directionOrSurfaceId === "left" || directionOrSurfaceId === "up";
+		const cmuxSurfaceId = isDirection
+			? await cmuxClient.createSplit(directionOrSurfaceId as "right" | "down" | "left" | "up")
+			: directionOrSurfaceId;
 		if (!cmuxSurfaceId) {
 			return runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, signal, onUpdate, makeDetails);
 		}
@@ -806,12 +811,16 @@ export default function (pi: ExtensionAPI) {
 				const MAX_RETRIES = 1; // Retry failed tasks once
 				const batchId = crypto.randomUUID();
 				const batchSize = params.tasks.length;
+				// Pre-create a grid layout for cmux splits so agents get a clean tiled arrangement
+				const gridSurfaces = cmuxSplitsEnabled
+					? await cmuxClient.createGridLayout(Math.min(batchSize, MAX_CONCURRENCY))
+					: [];
 				const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
 					const workerId = registerWorker(t.agent, t.task, index, batchSize, batchId);
 					const runTask = () => cmuxSplitsEnabled
 						? runSingleAgentInCmuxSplit(
 							cmuxClient,
-							index % 2 === 0 ? "right" : "down",
+							gridSurfaces[index] ?? (index % 2 === 0 ? "right" : "down"),
 							ctx.cwd,
 							agents,
 							t.agent,

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