gsd-pi 2.80.0-dev.3065f7bfa → 2.80.0-dev.488219eb6

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

@@ -9,12 +9,13 @@
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdtempSync, mkdirSync, readFileSync, writeFileSync, rmSync, readdirSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
 import { PROJECT_FILES, classifyProject } from "../detection.js";
+import { _shouldProceedWithInvalidRepoClassificationForTest } from "../auto/phases.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -86,19 +87,19 @@ test("PROJECT_FILES is exported and contains expected multi-ecosystem entries",
   assert.ok(PROJECT_FILES.includes("Package.swift"), "includes Swift marker");
 });
 
-test("runUnitPhase fails closed when classification returns invalid-repo", () => {
-  const source = readFileSync(join(process.cwd(), "src/resources/extensions/gsd/auto/phases.ts"), "utf-8");
-  const invalidRepoBranch = source.slice(
-    source.indexOf('projectClassification.kind === "invalid-repo"'),
-    source.indexOf('projectClassification.kind === "greenfield"'),
+test("invalid-repo classification only proceeds when the git marker was already confirmed", () => {
+  assert.equal(
+    _shouldProceedWithInvalidRepoClassificationForTest("missing .git", true),
+    true,
+  );
+  assert.equal(
+    _shouldProceedWithInvalidRepoClassificationForTest("missing .git", false),
+    false,
+  );
+  assert.equal(
+    _shouldProceedWithInvalidRepoClassificationForTest("permission denied", true),
+    false,
   );
-
-  assert.match(invalidRepoBranch, /projectClassification\.reason === "missing \.git" && hasGit/);
-  assert.match(invalidRepoBranch, /project classification could not confirm \.git/);
-  assert.match(invalidRepoBranch, /ctx\.ui\.notify\(msg,\s*"error"\)/);
-  assert.match(invalidRepoBranch, /await deps\.stopAuto\(ctx,\s*pi,\s*msg\)/);
-  assert.match(invalidRepoBranch, /return \{ action: "break", reason: "worktree-invalid" \}/);
-  assert.match(invalidRepoBranch, /classified as invalid-repo/);
 });
 
 describe("health check with git repo", () => {

package/src/resources/extensions/gsd/tests/worktree-main-branch.test.ts

@@ -1,25 +1,27 @@
-/**
- * Regression test for #3461: createAutoWorktree must use git.main_branch
- * preference when META.json integration branch is absent.
- */
+// GSD-2 — Auto-worktree main branch preference regression tests.
+
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 
-test("auto-worktree.ts includes main_branch preference in startPoint fallback (#3461)", () => {
-  const src = readFileSync(
-    join(import.meta.dirname, "..", "auto-worktree.ts"),
-    "utf-8",
+import { _resolveAutoWorktreeStartPointForTest } from "../auto-worktree.ts";
+
+test("auto-worktree start point prefers milestone integration branch", () => {
+  const startPoint = _resolveAutoWorktreeStartPointForTest(
+    "release/integration",
+    "dev",
+    () => true,
   );
-  // The fix adds gitPrefs?.main_branch to the startPoint fallback chain
-  assert.ok(
-    src.includes("gitPrefs?.main_branch") || src.includes("prefs.main_branch"),
-    "createAutoWorktree must check git.main_branch preference before falling back to nativeDetectMainBranch",
+
+  assert.equal(startPoint, "release/integration");
+});
+
+test("auto-worktree start point uses git.main_branch only when it exists", () => {
+  assert.equal(
+    _resolveAutoWorktreeStartPointForTest(null, "dev", (branch) => branch === "dev"),
+    "dev",
   );
-  assert.match(
-    src,
-    /nativeBranchExists\(basePath,\s*gitPrefs\.main_branch\)/,
-    "createAutoWorktree must validate git.main_branch exists before using it",
+  assert.equal(
+    _resolveAutoWorktreeStartPointForTest(null, "stale", () => false),
+    undefined,
   );
 });

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

@@ -529,6 +529,42 @@ test("exitMilestone commits, tears down, and resets basePath", () => {
   assert.equal(findCalls(deps.calls, "invalidateAllCaches").length, 1);
 });
 
+test("exitMilestone moves cwd to project root before teardown", (t) => {
+  const originalCwd = process.cwd();
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-exit-cwd-")));
+  const wtPath = join(base, ".gsd", "worktrees", "M001");
+  mkdirSync(wtPath, { recursive: true });
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  process.chdir(wtPath);
+  const s = makeSession({
+    basePath: wtPath,
+    originalBasePath: base,
+  });
+  const deps = makeDeps({
+    isInAutoWorktree: () => true,
+  });
+  deps.teardownAutoWorktree = (
+    teardownBasePath: string,
+    milestoneId: string,
+    opts?: { preserveBranch?: boolean },
+  ) => {
+    deps.calls.push({ fn: "teardownAutoWorktree", args: [teardownBasePath, milestoneId, opts] });
+    assert.equal(process.cwd(), base);
+    rmSync(wtPath, { recursive: true, force: true });
+  };
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  resolver.exitMilestone("M001", ctx);
+
+  assert.equal(process.cwd(), base);
+  assert.equal(s.basePath, base);
+});
+
 test("exitMilestone is no-op when not in worktree", () => {
   const s = makeSession();
   const deps = makeDeps({

package/src/resources/extensions/gsd/tests/zero-slice-roadmap-guided.test.ts

@@ -1,19 +1,25 @@
-/**
- * Regression test for #3441: guided flow must treat a roadmap with zero
- * parseable slices the same as no roadmap — offer "Create roadmap" not "Go auto".
- */
+// GSD-2 — Guided roadmap slice detection regression tests.
+
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 
-test("guided-flow checks roadmap slice count before offering auto (#3441)", () => {
-  const src = readFileSync(
-    join(import.meta.dirname, "..", "guided-flow.ts"),
-    "utf-8",
+import { _roadmapHasParseableSlicesForTest } from "../guided-flow.ts";
+
+test("guided flow treats placeholder roadmaps with zero slices as not runnable", () => {
+  assert.equal(
+    _roadmapHasParseableSlicesForTest("# M001 Roadmap\n\nPlanning notes only.\n"),
+    false,
   );
-  assert.ok(
-    src.includes("roadmapHasSlices") || src.includes("parseRoadmapSlices"),
-    "Guided flow must parse roadmap for slices before deciding which options to show",
+});
+
+test("guided flow accepts roadmaps with parseable slices", () => {
+  assert.equal(
+    _roadmapHasParseableSlicesForTest([
+      "# M001 Roadmap",
+      "",
+      "## Slices",
+      "- [ ] **S01: First slice** `risk:low` `depends:[]`",
+    ].join("\n")),
+    true,
   );
 });

package/src/resources/extensions/gsd/tools/complete-milestone.ts

@@ -32,21 +32,21 @@ export interface CompleteMilestoneParams {
   oneLiner: string;
   narrative: string;
   verificationPassed: boolean;
-  /** @optional — defaults to "Not provided." when omitted by models with limited tool-calling */
+  /** @optional — empty/omitted renders as "Not provided." */
   successCriteriaResults?: string;
-  /** @optional — defaults to "Not provided." when omitted */
+  /** @optional — empty/omitted renders as "Not provided." */
   definitionOfDoneResults?: string;
-  /** @optional — defaults to "Not provided." when omitted */
+  /** @optional — empty/omitted renders as "Not provided." */
   requirementOutcomes?: string;
-  /** @optional — defaults to [] when omitted */
+  /** @optional — empty/omitted renders as "(none)" */
   keyDecisions?: string[];
-  /** @optional — defaults to [] when omitted */
+  /** @optional — empty/omitted renders as "(none)" */
   keyFiles?: string[];
-  /** @optional — defaults to [] when omitted */
+  /** @optional — empty/omitted renders as "(none)" */
   lessonsLearned?: string[];
-  /** @optional — defaults to "None." when omitted */
+  /** @optional — empty/omitted renders as "None." */
   followUps?: string;
-  /** @optional — defaults to "None." when omitted */
+  /** @optional — empty/omitted renders as "None." */
   deviations?: string;
   /** Optional caller-provided identity for audit trail */
   actorName?: string;
@@ -61,8 +61,7 @@ export interface CompleteMilestoneResult {
   alreadyComplete?: boolean;
 }
 
-function renderMilestoneSummaryMarkdown(params: CompleteMilestoneParams): string {
-  const now = new Date().toISOString();
+function renderMilestoneSummaryMarkdown(params: CompleteMilestoneParams, completedAt: string): string {
   const displayTitle = stripIdPrefix(params.title, params.milestoneId);
 
   // Apply defaults for optional enrichment fields (#2771)
@@ -86,7 +85,7 @@ function renderMilestoneSummaryMarkdown(params: CompleteMilestoneParams): string
 id: ${params.milestoneId}
 title: "${displayTitle}"
 status: complete
-completed_at: ${now}
+completed_at: ${completedAt}
 key_decisions:
 ${keyDecisionsYaml}
 key_files:
@@ -105,15 +104,15 @@ ${params.narrative}
 
 ## Success Criteria Results
 
-${params.successCriteriaResults ?? "Not provided."}
+${params.successCriteriaResults || "Not provided."}
 
 ## Definition of Done Results
 
-${params.definitionOfDoneResults ?? "Not provided."}
+${params.definitionOfDoneResults || "Not provided."}
 
 ## Requirement Outcomes
 
-${params.requirementOutcomes ?? "Not provided."}
+${params.requirementOutcomes || "Not provided."}
 
 ## Deviations
 
@@ -193,7 +192,7 @@ export async function handleCompleteMilestone(
   }
 
   // ── Filesystem operations (outside transaction) ─────────────────────────
-  const summaryMd = renderMilestoneSummaryMarkdown(params);
+  const summaryMd = renderMilestoneSummaryMarkdown(params, completedAt);
 
   let summaryPath: string;
   const milestoneDir = resolveMilestonePath(basePath, params.milestoneId);

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -85,7 +85,7 @@ function taskGateFieldForId(
  * Normalize a list parameter that may arrive as a string (newline-delimited
  * bullet list from the LLM) into a string array (#3361).
  */
-function normalizeListParam(value: unknown): string[] {
+export function normalizeListParam(value: unknown): string[] {
   if (Array.isArray(value)) return value.map(String);
   if (typeof value === "string" && value.trim()) {
     return value.split(/\n/).map(s => s.replace(/^[\s\-*•]+/, "").trim()).filter(Boolean);

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

@@ -476,19 +476,47 @@ export class WorktreeResolver {
         phase: "auto-commit-failed",
         error: err instanceof Error ? err.message : String(err),
       });
+      ctx.notify(
+        `Auto-commit before exiting ${milestoneId} failed: ${err instanceof Error ? err.message : String(err)}. Branch ${this.deps.autoWorktreeBranch(milestoneId)} is preserved for recovery.`,
+        "warning",
+      );
     }
 
+    if (this.s.originalBasePath) {
+      try {
+        process.chdir(this.s.originalBasePath);
+      } catch (err) {
+        debugLog("WorktreeResolver", {
+          action: "exitMilestone",
+          milestoneId,
+          phase: "pre-teardown-chdir-failed",
+          originalBasePath: this.s.originalBasePath,
+          error: err instanceof Error ? err.message : String(err),
+        });
+        ctx.notify(
+          `Could not leave milestone worktree before cleanup: ${err instanceof Error ? err.message : String(err)}. Branch ${this.deps.autoWorktreeBranch(milestoneId)} is preserved for recovery.`,
+          "warning",
+        );
+      }
+    }
+
+    let teardownFailed = false;
     try {
       this.deps.teardownAutoWorktree(this.s.originalBasePath, milestoneId, {
         preserveBranch: opts?.preserveBranch ?? false,
       });
     } catch (err) {
+      teardownFailed = true;
       debugLog("WorktreeResolver", {
         action: "exitMilestone",
         milestoneId,
         phase: "teardown-failed",
         error: err instanceof Error ? err.message : String(err),
       });
+      ctx.notify(
+        `Worktree cleanup failed for ${milestoneId}: ${err instanceof Error ? err.message : String(err)}. Branch ${this.deps.autoWorktreeBranch(milestoneId)} is preserved for recovery.`,
+        "warning",
+      );
     }
 
     this.restoreToProjectRoot();
@@ -498,7 +526,12 @@ export class WorktreeResolver {
       result: "done",
       basePath: this.s.basePath,
     });
-    ctx.notify(`Exited worktree for ${milestoneId}`, "info");
+    ctx.notify(
+      teardownFailed
+        ? `Worktree exit for ${milestoneId} needs manual cleanup.`
+        : `Exited worktree for ${milestoneId}`,
+      teardownFailed ? "warning" : "info",
+    );
   }
 
   // ── Merge and Exit ─────────────────────────────────────────────────────

package/src/resources/skills/create-gsd-extension/templates/templates.test.ts

@@ -3,56 +3,102 @@
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync, readdirSync, statSync } from "node:fs";
-import { join, dirname, relative } from "node:path";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import ts from "typescript";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const skillRoot = join(__dirname, "..");
-
-function walk(dir: string): string[] {
-	const out: string[] = [];
-	for (const entry of readdirSync(dir)) {
-		const full = join(dir, entry);
-		if (statSync(full).isDirectory()) {
-			out.push(...walk(full));
-		} else {
-			out.push(full);
-		}
+
+const extensionApiStubs = `
+declare module "@gsd/pi-coding-agent" {
+	export interface ExtensionContext {
+		hasUI: boolean;
+		sessionManager: { getBranch(): Array<{ type: string; message: { role?: string; toolName?: string; details?: unknown } }> };
+		ui: { notify(message: string, level: string): void; custom<T>(view: unknown): Promise<T> };
+	}
+	export interface ExtensionAPI {
+		on(event: string, handler: (event: unknown, ctx: ExtensionContext) => unknown): void;
+		registerTool(tool: Record<string, unknown>): void;
+		registerCommand(name: string, command: {
+			description: string;
+			handler: (args: string, ctx: ExtensionContext) => unknown;
+		}): void;
 	}
-	return out;
+}
+
+declare module "@sinclair/typebox" {
+	export const Type: {
+		Object(shape: Record<string, unknown>): unknown;
+		Optional(schema: unknown): unknown;
+		String(options?: Record<string, unknown>): unknown;
+		Number(options?: Record<string, unknown>): unknown;
+	};
+}
+
+declare module "@gsd/pi-ai" {
+	export function StringEnum<T extends readonly string[]>(values: T): unknown;
+}
+
+declare module "@gsd/pi-tui" {
+	export class Text {
+		constructor(text: string, x: number, y: number);
+	}
+	export function truncateToWidth(text: string, width: number): string;
+	export function matchesKey(data: string, key: string): boolean;
+	export const Key: { escape: string };
+}
+`;
+
+function renderTemplate(template: string): string {
+	return template
+		.replaceAll("{{EXTENSION_NAME}}", "Sample Extension")
+		.replaceAll("{{DESCRIPTION}}", "Sample extension")
+		.replaceAll("{{CAPABILITIES_LIST}}", "- sample")
+		.replaceAll("{{tool_name}}", "sample_tool")
+		.replaceAll("{{Tool Label}}", "Sample Tool")
+		.replaceAll("{{Tool description for LLM}}", "Sample tool description")
+		.replaceAll("{{command_name}}", "sample")
+		.replaceAll("{{Command description}}", "Sample command")
+		.replaceAll("{{ItemType}}", "SampleItem")
+		.replaceAll("{{ToolDetails}}", "SampleToolDetails")
+		.replaceAll("{{Description for LLM}}", "Sample stateful tool description")
+		.replaceAll("{{items}}", "items")
+		.replaceAll("{{Items}}", "Items");
 }
 
 describe("extension templates use @gsd/* imports", () => {
 	const templates = ["extension-skeleton.ts", "stateful-tool-skeleton.ts"];
 
 	for (const template of templates) {
-		it(`${template} uses @gsd/pi-coding-agent (not @mariozechner)`, () => {
-			const content = readFileSync(join(__dirname, template), "utf-8");
-			assert.ok(content.includes("@gsd/pi-coding-agent"), `Expected @gsd/pi-coding-agent import in ${template}`);
-			assert.ok(!content.includes("@mariozechner/"), `Found stale @mariozechner/ import in ${template}`);
-		});
-	}
+		it(`${template} renders as a compilable extension module`, () => {
+			const dir = mkdtempSync(join(tmpdir(), "create-gsd-extension-template-"));
+			try {
+				const stubsPath = join(dir, "extension-api-stubs.d.ts");
+				const renderedPath = join(dir, template);
+				writeFileSync(stubsPath, extensionApiStubs, "utf-8");
+				const rendered = renderTemplate(readFileSync(join(__dirname, template), "utf-8"));
+				writeFileSync(renderedPath, rendered, "utf-8");
 
-	it("extension-skeleton.ts uses @gsd/pi-ai for StringEnum", () => {
-		const content = readFileSync(join(__dirname, "extension-skeleton.ts"), "utf-8");
-		assert.ok(content.includes("@gsd/pi-ai"), "Expected @gsd/pi-ai import");
-	});
-
-	it("stateful-tool-skeleton.ts uses @gsd/pi-tui", () => {
-		const content = readFileSync(join(__dirname, "stateful-tool-skeleton.ts"), "utf-8");
-		assert.ok(content.includes("@gsd/pi-tui"), "Expected @gsd/pi-tui import");
-	});
-
-	it("no @mariozechner/ references anywhere in create-gsd-extension/", () => {
-		const offenders: string[] = [];
-		for (const file of walk(skillRoot)) {
-			if (file.endsWith("templates.test.ts")) continue;
-			const content = readFileSync(file, "utf-8");
-			if (content.includes("@mariozechner/")) {
-				offenders.push(relative(skillRoot, file));
+				const program = ts.createProgram([stubsPath, renderedPath], {
+					allowJs: false,
+					esModuleInterop: true,
+					module: ts.ModuleKind.NodeNext,
+					moduleResolution: ts.ModuleResolutionKind.NodeNext,
+					noEmit: true,
+					skipLibCheck: true,
+					strict: false,
+					target: ts.ScriptTarget.ES2022,
+				});
+				const diagnostics = ts.getPreEmitDiagnostics(program).filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+				assert.deepEqual(
+					diagnostics.map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")),
+					[],
+				);
+			} finally {
+				rmSync(dir, { recursive: true, force: true });
 			}
-		}
-		assert.deepEqual(offenders, [], `Stale @mariozechner/ references found in: ${offenders.join(", ")}`);
-	});
+		});
+	}
 });