gsd-pi 2.41.0-dev.9446b20 → 2.41.0-dev.97349b1

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

@@ -404,6 +404,8 @@ export interface HookStatusEntry {
 
 // ─── Database Types (Decisions & Requirements) ────────────────────────────
 
+export type DecisionMadeBy = "human" | "agent" | "collaborative";
+
 export interface Decision {
   seq: number; // auto-increment primary key
   id: string; // e.g. "D001"
@@ -413,6 +415,7 @@ export interface Decision {
   choice: string; // the specific choice made
   rationale: string; // why this choice
   revisable: string; // whether/when revisable
+  made_by: DecisionMadeBy; // who made the decision: human, agent, or collaborative
   superseded_by: string | null; // ID of superseding decision, or null
 }
 

package/src/resources/extensions/gsd/workflow-templates.ts

@@ -8,10 +8,21 @@
 import { readFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
 
-const __extensionDir = dirname(fileURLToPath(import.meta.url));
+const __extensionDir = resolveGsdExtensionDir();
 const registryPath = join(__extensionDir, "workflow-templates", "registry.json");
 
+/** Resolve the GSD extension dir with fallback to ~/.gsd/agent/extensions/gsd/. */
+function resolveGsdExtensionDir(): string {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  if (existsSync(join(moduleDir, "workflow-templates"))) return moduleDir;
+  const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+  const agentGsdDir = join(gsdHome, "agent", "extensions", "gsd");
+  if (existsSync(join(agentGsdDir, "workflow-templates"))) return agentGsdDir;
+  return moduleDir;
+}
+
 // ─── Types ───────────────────────────────────────────────────────────────────
 
 export interface TemplateEntry {

package/src/resources/extensions/gsd/worktree-manager.ts

@@ -286,11 +286,26 @@ export function removeWorktree(
   name: string,
   opts: { deleteBranch?: boolean; force?: boolean; branch?: string } = {},
 ): void {
-  const wtPath = worktreePath(basePath, name);
-  const resolvedWtPath = existsSync(wtPath) ? realpathSync(wtPath) : wtPath;
+  let wtPath = worktreePath(basePath, name);
   const branch = opts.branch ?? worktreeBranchName(name);
   const { deleteBranch = true, force = true } = opts;
 
+  // Resolve the ACTUAL worktree path from git's worktree list.
+  // The computed path may differ when .gsd/ is (or was) a symlink to an
+  // external state directory — git resolves symlinks at worktree creation
+  // time, so its registered path points to the resolved external location.
+  // If syncStateToProjectRoot later creates a real .gsd/ directory that
+  // shadows the symlink, the computed path diverges from git's record.
+  try {
+    const entries = nativeWorktreeList(basePath);
+    const entry = entries.find(e => e.branch === branch);
+    if (entry?.path) {
+      wtPath = entry.path;
+    }
+  } catch { /* fall back to computed path */ }
+
+  const resolvedWtPath = existsSync(wtPath) ? realpathSync(wtPath) : wtPath;
+
   // If we're inside the worktree, move out first — git can't remove an in-use directory
   const cwd = process.cwd();
   const resolvedCwd = existsSync(cwd) ? realpathSync(cwd) : cwd;
@@ -306,12 +321,12 @@ export function removeWorktree(
     return;
   }
 
-  // Remove worktree (force if requested, to handle dirty worktrees)
-  try { nativeWorktreeRemove(basePath, wtPath, force); } catch { /* may fail */ }
+  // Remove worktree using the resolved path (force if requested, to handle dirty worktrees)
+  try { nativeWorktreeRemove(basePath, resolvedWtPath, force); } catch { /* may fail */ }
 
   // If the directory is still there (e.g. locked), try harder with force
-  if (existsSync(wtPath)) {
-    try { nativeWorktreeRemove(basePath, wtPath, true); } catch { /* may fail */ }
+  if (existsSync(resolvedWtPath)) {
+    try { nativeWorktreeRemove(basePath, resolvedWtPath, true); } catch { /* may fail */ }
   }
 
   // Prune stale entries so git knows the worktree is gone

package/src/resources/extensions/gsd/worktree-resolver.ts

@@ -28,7 +28,7 @@ export interface WorktreeResolverDeps {
     basePath: string,
     milestoneId: string,
     roadmapContent: string,
-  ) => { pushed: boolean };
+  ) => { pushed: boolean; codeFilesChanged: boolean };
   syncWorktreeStateBack: (
     mainBasePath: string,
     worktreePath: string,
@@ -371,10 +371,23 @@ export class WorktreeResolver {
           milestoneId,
           roadmapContent,
         );
-        ctx.notify(
-          `Milestone ${milestoneId} merged to main.${mergeResult.pushed ? " Pushed to remote." : ""}`,
-          "info",
-        );
+        if (mergeResult.codeFilesChanged) {
+          ctx.notify(
+            `Milestone ${milestoneId} merged to main.${mergeResult.pushed ? " Pushed to remote." : ""}`,
+            "info",
+          );
+        } else {
+          // (#1906) Milestone produced only .gsd/ metadata — no actual code was
+          // merged. This typically means the LLM wrote planning artifacts
+          // (summaries, roadmaps) but never implemented the code. Surface this
+          // clearly so the user knows the milestone is not truly complete.
+          ctx.notify(
+            `WARNING: Milestone ${milestoneId} merged to main but contained NO code changes — only .gsd/ metadata files. ` +
+              `The milestone summary may describe planned work that was never implemented. ` +
+              `Review the milestone output and re-run if code is missing.`,
+            "warning",
+          );
+        }
       } else {
         // No roadmap at either location — teardown but PRESERVE the branch so
         // commits are not orphaned. The user can merge manually later (#1573).
@@ -478,10 +491,18 @@ export class WorktreeResolver {
       // Rebuild GitService after merge (branch HEAD changed)
       this.rebuildGitService();
 
-      ctx.notify(
-        `Milestone ${milestoneId} merged (branch mode).${mergeResult.pushed ? " Pushed to remote." : ""}`,
-        "info",
-      );
+      if (mergeResult.codeFilesChanged) {
+        ctx.notify(
+          `Milestone ${milestoneId} merged (branch mode).${mergeResult.pushed ? " Pushed to remote." : ""}`,
+          "info",
+        );
+      } else {
+        ctx.notify(
+          `WARNING: Milestone ${milestoneId} merged (branch mode) but contained NO code changes — only .gsd/ metadata. ` +
+            `Review the milestone output and re-run if code is missing.`,
+          "warning",
+        );
+      }
       debugLog("WorktreeResolver", {
         action: "mergeAndExit",
         milestoneId,

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

@@ -516,12 +516,16 @@ async function runSingleAgentInCmuxSplit(
 		const bundledPaths = (process.env.GSD_BUNDLED_EXTENSION_PATHS ?? "").split(path.delimiter).map((s) => s.trim()).filter(Boolean);
 		const extensionArgs = bundledPaths.flatMap((p) => ["--extension", p]);
 		const processArgs = [process.env.GSD_BIN_PATH!, ...extensionArgs, ...buildSubagentProcessArgs(agent, task, tmpPromptPath)];
+		// Normalize all paths to forward slashes before embedding in bash strings.
+		// On Windows, backslashes are interpreted as escape characters by bash,
+		// mangling paths like C:\Users\user into C:Useruser (#1436).
+		const bashPath = (p: string) => shellEscape(p.replaceAll("\\", "/"));
 		const innerScript = [
-			`cd ${shellEscape(cwd ?? defaultCwd)}`,
+			`cd ${bashPath(cwd ?? defaultCwd)}`,
 			"set -o pipefail",
-			`${shellEscape(process.execPath)} ${processArgs.map(shellEscape).join(" ")} 2> >(tee ${shellEscape(stderrPath)} >&2) | tee ${shellEscape(stdoutPath)}`,
+			`${bashPath(process.execPath)} ${processArgs.map(a => bashPath(a)).join(" ")} 2> >(tee ${bashPath(stderrPath)} >&2) | tee ${bashPath(stdoutPath)}`,
 			"status=${PIPESTATUS[0]}",
-			`printf '%s' "$status" > ${shellEscape(exitPath)}`,
+			`printf '%s' "$status" > ${bashPath(exitPath)}`,
 		].join("; ");
 
 		const sent = await cmuxClient.sendSurface(cmuxSurfaceId, `bash -lc ${shellEscape(innerScript)}`);

package/src/resources/extensions/voice/index.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 import { shortcutDesc } from "../shared/mod.js";
 import type { AssistantMessage } from "@gsd/pi-ai";
 import { isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
-import { spawn, execSync, type ChildProcess } from "node:child_process";
+import { spawn, execFileSync, type ChildProcess } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -32,7 +32,7 @@ function linuxPython(): string {
 function ensureBinary(): boolean {
 	if (fs.existsSync(RECOGNIZER_BIN)) return true;
 	try {
-		execSync(`swiftc "${SWIFT_SRC}" -o "${RECOGNIZER_BIN}" -framework Speech -framework AVFoundation`, {
+		execFileSync("swiftc", [SWIFT_SRC, "-o", RECOGNIZER_BIN, "-framework", "Speech", "-framework", "AVFoundation"], {
 			timeout: 60000,
 		});
 		return true;
@@ -54,7 +54,7 @@ function ensureLinuxReady(ctx: ExtensionContext): boolean {
 
 	// Check python3 exists
 	try {
-		execSync("which python3", { stdio: "pipe" });
+		execFileSync("which", ["python3"], { stdio: "pipe" });
 	} catch {
 		ctx.ui.notify("Voice: python3 not found — install with: sudo apt install python3", "error");
 		return false;
@@ -63,7 +63,7 @@ function ensureLinuxReady(ctx: ExtensionContext): boolean {
 	// Check that sounddevice is importable
 	const py = linuxPython();
 	try {
-		execSync(`${py} -c "import sounddevice"`, {
+		execFileSync(py, ["-c", "import sounddevice"], {
 			stdio: "pipe",
 			timeout: 10000,
 		});