gsd-pi 2.65.0-dev.d0517ff → 2.66.0

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

@@ -0,0 +1,189 @@
+// GSD2 — Tests for auditOrphanedMilestoneBranches bootstrap audit
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { auditOrphanedMilestoneBranches } from "../auto-start.ts";
+import { openDatabase, closeDatabase, insertMilestone, updateMilestoneStatus } from "../gsd-db.ts";
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+/** Create a temp git repo with .gsd structure and DB. */
+function createRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "orphan-audit-test-")));
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  run("git branch -M main", dir);
+
+  // Create .gsd structure on disk (not tracked in git)
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+
+  return dir;
+}
+
+describe("auditOrphanedMilestoneBranches", () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = createRepo();
+    openDatabase(join(dir, ".gsd", "gsd.db"));
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("no milestone branches → no-op", () => {
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+    assert.deepStrictEqual(result.recovered, []);
+    assert.deepStrictEqual(result.warnings, []);
+  });
+
+  test("skips in none isolation mode", () => {
+    // Create a milestone branch that would otherwise be detected
+    run("git branch milestone/M001", dir);
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "none");
+    assert.deepStrictEqual(result.recovered, []);
+    assert.deepStrictEqual(result.warnings, []);
+
+    // Branch should still exist
+    const branches = run("git branch --list milestone/M001", dir);
+    assert.ok(branches.includes("milestone/M001"), "branch should be preserved in none mode");
+  });
+
+  test("deletes merged branch for completed milestone", () => {
+    // Create milestone branch from main (so it's already merged)
+    run("git branch milestone/M001", dir);
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.ok(result.recovered.length > 0, "should have recovered actions");
+    assert.ok(
+      result.recovered.some(r => r.includes("Deleted merged branch milestone/M001")),
+      "should report branch deletion",
+    );
+    assert.deepStrictEqual(result.warnings, []);
+
+    // Branch should be gone
+    const branches = run("git branch --list milestone/M001", dir);
+    assert.deepStrictEqual(branches, "", "branch should be deleted");
+  });
+
+  test("warns about unmerged branch for completed milestone", () => {
+    // Create milestone branch with divergent commits (not merged into main)
+    run("git checkout -b milestone/M001", dir);
+    writeFileSync(join(dir, "feature.txt"), "new feature\n");
+    run("git add feature.txt", dir);
+    run("git commit -m \"add feature on milestone branch\"", dir);
+    run("git checkout main", dir);
+
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.deepStrictEqual(result.recovered, [], "should not delete unmerged branch");
+    assert.ok(result.warnings.length > 0, "should have warnings");
+    assert.ok(
+      result.warnings.some(w => w.includes("NOT merged")),
+      "should warn about unmerged branch",
+    );
+
+    // Branch should still exist (data safety)
+    const branches = run("git branch --list milestone/M001", dir);
+    assert.ok(branches.includes("milestone/M001"), "unmerged branch must be preserved");
+  });
+
+  test("skips active (non-complete) milestone branches", () => {
+    run("git branch milestone/M001", dir);
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.deepStrictEqual(result.warnings, []);
+
+    // Branch should still exist
+    const branches = run("git branch --list milestone/M001", dir);
+    assert.ok(branches.includes("milestone/M001"), "active milestone branch should be preserved");
+  });
+
+  test("cleans up orphaned worktree directory for merged milestone", () => {
+    // Create milestone branch (merged — same as main)
+    run("git branch milestone/M001", dir);
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    // Create orphaned worktree directory
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, "leftover.txt"), "orphaned file\n");
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.ok(result.recovered.length > 0, "should have recovered actions");
+    assert.ok(
+      result.recovered.some(r => r.includes("worktree directory")),
+      "should report worktree cleanup",
+    );
+
+    // Worktree directory should be cleaned up
+    assert.ok(!existsSync(wtDir), "orphaned worktree directory should be removed");
+  });
+
+  test("handles multiple milestones with mixed states", () => {
+    // M001: complete, branch merged → should clean up
+    run("git branch milestone/M001", dir);
+    insertMilestone({ id: "M001", title: "First", status: "complete" });
+
+    // M002: active, branch exists → should skip
+    run("git branch milestone/M002", dir);
+    insertMilestone({ id: "M002", title: "Second", status: "active" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    // M001 should be cleaned up
+    assert.ok(
+      result.recovered.some(r => r.includes("M001")),
+      "should clean up completed M001",
+    );
+
+    // M002 should not be touched
+    const branches = run("git branch --list milestone/M002", dir);
+    assert.ok(branches.includes("milestone/M002"), "active M002 branch should be preserved");
+  });
+
+  test("works in branch isolation mode", () => {
+    run("git branch milestone/M001", dir);
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "branch");
+
+    assert.ok(result.recovered.length > 0, "should work in branch mode too");
+    assert.ok(
+      result.recovered.some(r => r.includes("Deleted merged branch")),
+      "should delete branch in branch mode",
+    );
+  });
+
+  test("handles milestone in DB but no branch (no-op)", () => {
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    assert.deepStrictEqual(result.recovered, []);
+    assert.deepStrictEqual(result.warnings, []);
+  });
+});

package/src/resources/extensions/gsd/tests/pre-execution-checks.test.ts

@@ -1083,11 +1083,77 @@ describe("checkTaskOrdering false positive regression (#3677)", () => {
     const results = checkTaskOrdering(tasks, "/tmp");
     assert.equal(results.length, 0, "Normalized task.files path should not trigger a false positive");
   });
+
+  test("annotated inputs still trigger ordering violations against later plain outputs", () => {
+    const tasks = [
+      createTask({
+        id: "T01",
+        sequence: 0,
+        files: [],
+        inputs: ["`later.ts` — needed first"],
+        expected_output: [],
+      }),
+      createTask({
+        id: "T02",
+        sequence: 1,
+        files: [],
+        inputs: [],
+        expected_output: ["later.ts"],
+      }),
+    ];
+
+    const results = checkTaskOrdering(tasks, "/tmp");
+    assert.equal(results.length, 1, "Annotated inputs should still match later plain expected_output entries");
+    assert.equal(results[0].target, "`later.ts` — needed first");
+    assert.ok(results[0].message.includes("sequence violation"));
+  });
 });
 
 // ─── checkFilePathConsistency additional edge cases ──────────────────────────
 
 describe("checkFilePathConsistency additional edge cases", () => {
+  test("annotated inputs match files that already exist on disk", () => {
+    const tempDir = join(tmpdir(), `pre-exec-test-annotated-input-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    writeFileSync(join(tempDir, "existing.ts"), "// content");
+
+    try {
+      const tasks = [
+        createTask({
+          id: "T01",
+          files: [],
+          inputs: ["`existing.ts` — file already on disk"],
+          expected_output: [],
+        }),
+      ];
+
+      const results = checkFilePathConsistency(tasks, tempDir);
+      assert.equal(results.length, 0, "Annotated inputs should resolve to the on-disk file path");
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  test("plain inputs match prior annotated expected outputs", () => {
+    const tasks = [
+      createTask({
+        id: "T01",
+        files: [],
+        inputs: [],
+        expected_output: ["`generated.ts` — created earlier"],
+      }),
+      createTask({
+        id: "T02",
+        files: [],
+        inputs: ["generated.ts"],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, "/tmp");
+    assert.equal(results.length, 0, "Prior annotated expected_output entries should satisfy later plain inputs");
+  });
+
   test("inputs referencing glob-like patterns should not crash", () => {
     // A glob pattern in inputs is unusual but should be handled gracefully.
     // The file won't exist on disk, so it should produce a blocking result.

package/src/resources/extensions/gsd/tests/subagent-agent-discovery.test.ts

@@ -42,3 +42,50 @@ test("discoverAgents falls back to legacy .pi/agents when needed", (t) => {
 	assert.equal(discovery.projectAgentsDir, agentsDir);
 	assert.deepEqual(discovery.agents.map((agent) => agent.name), ["ping"]);
 });
+
+test("discoverAgents accepts tools frontmatter as a YAML list", (t) => {
+	const root = makeProjectRoot(t);
+	const agentsDir = join(root, ".gsd", "agents");
+	mkdirSync(agentsDir, { recursive: true });
+	writeFileSync(
+		join(agentsDir, "reviewer.md"),
+		[
+			"---",
+			"name: reviewer",
+			"description: review agent",
+			"tools:",
+			"  - bash",
+			"  - read",
+			"---",
+			"Review code",
+			"",
+		].join("\n"),
+	);
+
+	const discovery = discoverAgents(root, "project");
+
+	assert.deepEqual(discovery.agents.map((agent) => agent.name), ["reviewer"]);
+	assert.deepEqual(discovery.agents[0]?.tools, ["bash", "read"]);
+});
+
+test("discoverAgents still accepts comma-separated tools frontmatter", (t) => {
+	const root = makeProjectRoot(t);
+	const agentsDir = join(root, ".gsd", "agents");
+	mkdirSync(agentsDir, { recursive: true });
+	writeFileSync(
+		join(agentsDir, "reviewer.md"),
+		[
+			"---",
+			"name: reviewer",
+			"description: review agent",
+			"tools: bash, read",
+			"---",
+			"Review code",
+			"",
+		].join("\n"),
+	);
+
+	const discovery = discoverAgents(root, "project");
+
+	assert.deepEqual(discovery.agents[0]?.tools, ["bash", "read"]);
+});

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

@@ -25,6 +25,33 @@ export interface AgentDiscoveryResult {
 	projectAgentsDir: string | null;
 }
 
+interface AgentFrontmatter extends Record<string, unknown> {
+	name?: string;
+	description?: string;
+	tools?: string | string[];
+	model?: string;
+}
+
+function parseAgentTools(value: string | string[] | undefined): string[] | undefined {
+	if (typeof value === "string") {
+		const tools = value
+			.split(",")
+			.map((tool) => tool.trim())
+			.filter(Boolean);
+		return tools.length > 0 ? tools : undefined;
+	}
+
+	if (Array.isArray(value)) {
+		const tools = value
+			.flatMap((tool) => typeof tool === "string" ? tool.split(",") : [])
+			.map((tool) => tool.trim())
+			.filter(Boolean);
+		return tools.length > 0 ? tools : undefined;
+	}
+
+	return undefined;
+}
+
 function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig[] {
 	const agents: AgentConfig[] = [];
 
@@ -51,16 +78,13 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
 			continue;
 		}
 
-		const { frontmatter, body } = parseFrontmatter<Record<string, string>>(content);
+		const { frontmatter, body } = parseFrontmatter<AgentFrontmatter>(content);
 
-		if (!frontmatter.name || !frontmatter.description) {
+		if (typeof frontmatter.name !== "string" || typeof frontmatter.description !== "string") {
 			continue;
 		}
 
-		const tools = frontmatter.tools
-			?.split(",")
-			.map((t: string) => t.trim())
-			.filter(Boolean);
+		const tools = parseAgentTools(frontmatter.tools);
 
 		agents.push({
 			name: frontmatter.name,

package/dist/web/standalone/.next/static/chunks/app/page-0c485498795110d6.js

@@ -1 +0,0 @@
-(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[8974],{2600:(e,t,n)=>{Promise.resolve().then(n.bind(n,66919))},5214:(e,t,n)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),Object.defineProperty(t,"workAsyncStorage",{enumerable:!0,get:function(){return r.workAsyncStorageInstance}});let r=n(17828)},17828:(e,t,n)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),Object.defineProperty(t,"workAsyncStorageInstance",{enumerable:!0,get:function(){return r}});let r=(0,n(64054).createAsyncLocalStorage)()},21957:(e,t,n)=>{"use strict";function r({moduleIds:e}){return null}Object.defineProperty(t,"__esModule",{value:!0}),Object.defineProperty(t,"PreloadChunks",{enumerable:!0,get:function(){return r}}),n(95155),n(47650),n(5214),n(2451),n(53887)},37206:(e,t,n)=>{"use strict";n.d(t,{default:()=>u.a});var r=n(75707),u=n.n(r)},41112:(e,t,n)=>{"use strict";function r({reason:e,children:t}){return t}Object.defineProperty(t,"__esModule",{value:!0}),Object.defineProperty(t,"BailoutToCSR",{enumerable:!0,get:function(){return r}}),n(1980)},64054:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n={bindSnapshot:function(){return s},createAsyncLocalStorage:function(){return a},createSnapshot:function(){return i}};for(var r in n)Object.defineProperty(t,r,{enumerable:!0,get:n[r]});let u=Object.defineProperty(Error("Invariant: AsyncLocalStorage accessed in runtime where it is not available"),"__NEXT_ERROR_CODE",{value:"E504",enumerable:!1,configurable:!0});class l{disable(){throw u}getStore(){}run(){throw u}exit(){throw u}enterWith(){throw u}static bind(e){return e}}let o="u">typeof globalThis&&globalThis.AsyncLocalStorage;function a(){return o?new o:new l}function s(e){return o?o.bind(e):l.bind(e)}function i(){return o?o.snapshot():function(e,...t){return e(...t)}}},66919:(e,t,n)=>{"use strict";n.r(t),n.d(t,{default:()=>l});var r=n(95155);let u=(0,n(37206).default)(()=>Promise.all([n.e(1838),n.e(6079),n.e(4986),n.e(2008),n.e(6502)]).then(n.bind(n,46502)).then(e=>e.GSDAppShell),{loadableGenerated:{webpack:()=>[46502]},ssr:!1,loading:()=>(0,r.jsx)("div",{className:"flex h-screen items-center justify-center bg-background text-sm text-muted-foreground",children:"Loading workspace…"})});function l(){return(0,r.jsx)(u,{})}},68635:(e,t,n)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),Object.defineProperty(t,"default",{enumerable:!0,get:function(){return s}});let r=n(95155),u=n(12115),l=n(41112);function o(e){return{default:e&&"default"in e?e.default:e}}n(21957);let a={loader:()=>Promise.resolve(o(()=>null)),loading:null,ssr:!0},s=function(e){let t={...a,...e},n=(0,u.lazy)(()=>t.loader().then(o)),s=t.loading;function i(e){let o=s?(0,r.jsx)(s,{isLoading:!0,pastDelay:!0,error:null}):null,a=!t.ssr||!!t.loading,i=a?u.Suspense:u.Fragment,c=t.ssr?(0,r.jsxs)(r.Fragment,{children:[null,(0,r.jsx)(n,{...e})]}):(0,r.jsx)(l.BailoutToCSR,{reason:"next/dynamic",children:(0,r.jsx)(n,{...e})});return(0,r.jsx)(i,{...a?{fallback:o}:{},children:c})}return i.displayName="LoadableComponent",i}},75707:(e,t,n)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),Object.defineProperty(t,"default",{enumerable:!0,get:function(){return u}});let r=n(73623)._(n(68635));function u(e,t){let n={};"function"==typeof e&&(n.loader=e);let u={...n,...t};return(0,r.default)({...u,modules:u.loadableGenerated?.modules})}("function"==typeof t.default||"object"==typeof t.default&&null!==t.default)&&void 0===t.default.__esModule&&(Object.defineProperty(t.default,"__esModule",{value:!0}),Object.assign(t.default,t),e.exports=t.default)}},e=>{e.O(0,[8441,3794,7358],()=>e(e.s=2600)),_N_E=e.O()}]);

package/dist/web/standalone/.next/static/chunks/main-app-fdab67f7802d7832.js

@@ -1 +0,0 @@
-(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[7358],{19393:()=>{},55548:(e,s,n)=>{Promise.resolve().then(n.t.bind(n,27123,23)),Promise.resolve().then(n.t.bind(n,61304,23)),Promise.resolve().then(n.t.bind(n,78616,23)),Promise.resolve().then(n.t.bind(n,64777,23)),Promise.resolve().then(n.t.bind(n,57121,23)),Promise.resolve().then(n.t.bind(n,74581,23)),Promise.resolve().then(n.t.bind(n,90484,23)),Promise.resolve().then(n.bind(n,86869))}},e=>{var s=s=>e(e.s=s);e.O(0,[8441,3794],()=>(s(83861),s(55548))),_N_E=e.O()}]);

package/dist/web/standalone/.next/static/chunks/next/dist/client/components/builtin/global-error-459824ffb8c323dd.js

@@ -1 +0,0 @@
-(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[9337],{43946:(e,s,_)=>{Promise.resolve().then(_.t.bind(_,27123,23))}},e=>{e.O(0,[8441,3794,7358],()=>e(e.s=43946)),_N_E=e.O()}]);