gsd-pi 2.52.0 → 2.53.0-dev.07ffe51

package/src/resources/extensions/gsd/tests/auto-stale-lock-self-kill.test.ts

@@ -0,0 +1,87 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { writeLock, readCrashLock, clearLock } from "../crash-recovery.ts";
+import { checkRemoteAutoSession, stopAutoRemote } from "../auto.ts";
+
+function makeTmpProject(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-stale-lock-test-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+// ─── checkRemoteAutoSession: own-PID filtering (#2730) ───────────────────
+
+test("#2730: checkRemoteAutoSession returns { running: false } when lock PID matches current process", (t) => {
+  const dir = makeTmpProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // Write a lock with the current process PID — simulates a stale lock
+  // left behind after step-mode exit without full cleanup.
+  writeLock(dir, "execute-task", "M001/S01/T01");
+
+  const lock = readCrashLock(dir);
+  assert.ok(lock, "lock file should exist");
+  assert.equal(lock!.pid, process.pid, "lock should have our PID");
+
+  const result = checkRemoteAutoSession(dir);
+  assert.equal(result.running, false, "own PID must not be treated as a remote session");
+});
+
+test("#2730: checkRemoteAutoSession still detects a genuine remote session (different PID)", (t) => {
+  const dir = makeTmpProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // Use parent PID — guaranteed alive, guaranteed not our PID.
+  const remotePid = process.ppid;
+  const lockData = {
+    pid: remotePid,
+    startedAt: new Date().toISOString(),
+    unitType: "execute-task",
+    unitId: "M001/S01/T02",
+    unitStartedAt: new Date().toISOString(),
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
+
+  const result = checkRemoteAutoSession(dir);
+  assert.equal(result.running, true, "different live PID should be detected as running");
+  assert.equal(result.pid, remotePid);
+});
+
+// ─── stopAutoRemote: self-kill prevention (#2730) ────────────────────────
+
+test("#2730: stopAutoRemote does not send SIGTERM when lock PID matches current process", (t) => {
+  const dir = makeTmpProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // Write a lock with our own PID
+  writeLock(dir, "execute-task", "M001/S01/T01");
+
+  const result = stopAutoRemote(dir);
+  assert.equal(result.found, false, "own PID must not be signalled");
+
+  // The lock should be cleared as part of the self-detection cleanup
+  assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "stale self-lock should be cleared");
+});
+
+test("#2730: stopAutoRemote clears stale lock from dead remote process without error", (t) => {
+  const dir = makeTmpProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // Simulate a stale lock from a process that no longer exists
+  const lockData = {
+    pid: 9999999,
+    startedAt: "2026-03-01T00:00:00Z",
+    unitType: "plan-slice",
+    unitId: "M001/S02",
+    unitStartedAt: "2026-03-01T00:05:00Z",
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
+
+  const result = stopAutoRemote(dir);
+  assert.equal(result.found, false, "dead remote PID should not be reported as found");
+  assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "stale lock should be cleaned up");
+});

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

@@ -0,0 +1,80 @@
+/**
+ * auto-worktree-auto-resolve.test.ts — Unit tests for isSafeToAutoResolve.
+ *
+ * Covers: .gsd/ state files, build artifacts (.tsbuildinfo, .pyc, __pycache__,
+ * .DS_Store, .map), and rejection of real source files.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  isSafeToAutoResolve,
+  SAFE_AUTO_RESOLVE_PATTERNS,
+} from "../auto-worktree.ts";
+
+describe("isSafeToAutoResolve", () => {
+  // ─── .gsd/ state files ───────────────────────────────────────────────────
+  test("returns true for .gsd/ prefixed paths", () => {
+    assert.ok(isSafeToAutoResolve(".gsd/STATE.md"));
+    assert.ok(isSafeToAutoResolve(".gsd/milestones/M001/CONTEXT.md"));
+    assert.ok(isSafeToAutoResolve(".gsd/gsd.db"));
+  });
+
+  // ─── Build artifact patterns ─────────────────────────────────────────────
+  test("returns true for .tsbuildinfo files", () => {
+    assert.ok(isSafeToAutoResolve("tsconfig.tsbuildinfo"));
+    assert.ok(isSafeToAutoResolve("dist/tsconfig.tsbuildinfo"));
+  });
+
+  test("returns true for .pyc files", () => {
+    assert.ok(isSafeToAutoResolve("module.pyc"));
+    assert.ok(isSafeToAutoResolve("src/utils/helpers.pyc"));
+  });
+
+  test("returns true for __pycache__/ paths", () => {
+    assert.ok(isSafeToAutoResolve("src/__pycache__/module.cpython-311.pyc"));
+    assert.ok(isSafeToAutoResolve("lib/__pycache__/foo.py"));
+  });
+
+  test("returns true for .DS_Store files", () => {
+    assert.ok(isSafeToAutoResolve(".DS_Store"));
+    assert.ok(isSafeToAutoResolve("src/.DS_Store"));
+  });
+
+  test("returns true for .map source map files", () => {
+    assert.ok(isSafeToAutoResolve("dist/index.js.map"));
+    assert.ok(isSafeToAutoResolve("out/bundle.css.map"));
+  });
+
+  // ─── Real source files (should NOT be auto-resolved) ─────────────────────
+  test("returns false for .ts source files", () => {
+    assert.ok(!isSafeToAutoResolve("src/index.ts"));
+    assert.ok(!isSafeToAutoResolve("lib/utils.ts"));
+  });
+
+  test("returns false for .js source files", () => {
+    assert.ok(!isSafeToAutoResolve("src/index.js"));
+    assert.ok(!isSafeToAutoResolve("lib/helpers.js"));
+  });
+
+  test("returns false for .py source files", () => {
+    assert.ok(!isSafeToAutoResolve("src/main.py"));
+    assert.ok(!isSafeToAutoResolve("scripts/deploy.py"));
+  });
+
+  test("returns false for config and data files", () => {
+    assert.ok(!isSafeToAutoResolve("package.json"));
+    assert.ok(!isSafeToAutoResolve("tsconfig.json"));
+    assert.ok(!isSafeToAutoResolve("README.md"));
+  });
+
+  // ─── SAFE_AUTO_RESOLVE_PATTERNS export ────────────────────────────────────
+  test("SAFE_AUTO_RESOLVE_PATTERNS is a non-empty array of RegExp", () => {
+    assert.ok(Array.isArray(SAFE_AUTO_RESOLVE_PATTERNS));
+    assert.ok(SAFE_AUTO_RESOLVE_PATTERNS.length > 0);
+    for (const pattern of SAFE_AUTO_RESOLVE_PATTERNS) {
+      assert.ok(pattern instanceof RegExp);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/auto-worktree-milestone-merge.test.ts

@@ -77,7 +77,7 @@ function addSliceToMilestone(
   run(`git branch -d ${sliceBranch}`, wtPath);
 }
 
-describe("auto-worktree-milestone-merge", () => {
+describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
   const savedCwd = process.cwd();
   const tempDirs: string[] = [];
 

package/src/resources/extensions/gsd/tests/collect-from-manifest.test.ts

@@ -227,6 +227,45 @@ test("collectSecretsFromManifest: manifest statuses are updated after collection
 		"KEY_TO_SKIP should have status 'skipped' after user skipped it");
 });
 
+test("collectSecretsFromManifest: applied keys hydrate process.env for the running session", async (t) => {
+	const { collectSecretsFromManifest } = await loadOrchestrator();
+
+	const tmp = makeTempDir("manifest-live-env");
+	const envKey = "CONTEXT7_API_KEY";
+	const saved = process.env[envKey];
+	t.after(() => {
+		if (saved === undefined) delete process.env[envKey];
+		else process.env[envKey] = saved;
+		rmSync(tmp, { recursive: true, force: true });
+	});
+
+	delete process.env[envKey];
+
+	const manifest = makeManifest([
+		{ key: envKey, status: "pending" },
+	]);
+	await writeManifestFile(tmp, manifest);
+
+	let callIndex = 0;
+	const mockCtx = {
+		cwd: tmp,
+		hasUI: true,
+		ui: {
+			custom: async (_factory: any) => {
+				callIndex++;
+				if (callIndex <= 1) return null; // summary screen dismiss
+				return "c7_live_test_key";
+			},
+		},
+	};
+
+	const result = await collectSecretsFromManifest(tmp, "M001", mockCtx as any);
+
+	assert.ok(result.applied.includes(envKey), "CONTEXT7_API_KEY should be applied");
+	assert.equal(process.env[envKey], "c7_live_test_key",
+		"applied keys should be available through process.env without restarting");
+});
+
 // ─── showSecretsSummary: render output ────────────────────────────────────────
 
 test("showSecretsSummary: produces lines with correct status glyphs for each entry status", async () => {

package/src/resources/extensions/gsd/tests/git-service.test.ts

@@ -287,9 +287,9 @@ describe('git-service', async () => {
 
 
   const tempDir = mkdtempSync(join(tmpdir(), "gsd-git-service-test-"));
-  run("git init -b main", tempDir);
-  run('git config user.name "Pi Test"', tempDir);
-  run('git config user.email "pi@example.com"', tempDir);
+  runGit(tempDir, ["init", "-b", "main"]);
+  runGit(tempDir, ["config", "user.name", "Pi Test"]);
+  runGit(tempDir, ["config", "user.email", "pi@example.com"]);
 
   // runGit should work on a valid repo
   const branch = runGit(tempDir, ["branch", "--show-current"]);
@@ -334,13 +334,13 @@ describe('git-service', async () => {
 
   function initTempRepo(): string {
     const dir = mkdtempSync(join(tmpdir(), "gsd-git-t02-"));
-    run("git init -b main", dir);
-    run('git config user.name "Pi Test"', dir);
-    run('git config user.email "pi@example.com"', dir);
+    runGit(dir, ["init", "-b", "main"]);
+    runGit(dir, ["config", "user.name", "Pi Test"]);
+    runGit(dir, ["config", "user.email", "pi@example.com"]);
     // Need an initial commit so HEAD exists
     createFile(dir, ".gitkeep", "");
-    run("git add -A", dir);
-    run('git commit -m "init"', dir);
+    runGit(dir, ["add", "-A"]);
+    runGit(dir, ["commit", "-m", "init"]);
     return dir;
   }
 
@@ -577,12 +577,12 @@ describe('git-service', async () => {
 
   function initBranchTestRepo(): string {
     const dir = mkdtempSync(join(tmpdir(), "gsd-git-t03-"));
-    run("git init -b main", dir);
-    run('git config user.name "Pi Test"', dir);
-    run('git config user.email "pi@example.com"', dir);
+    runGit(dir, ["init", "-b", "main"]);
+    runGit(dir, ["config", "user.name", "Pi Test"]);
+    runGit(dir, ["config", "user.email", "pi@example.com"]);
     createFile(dir, ".gitkeep", "");
-    run("git add -A", dir);
-    run('git commit -m "init"', dir);
+    runGit(dir, ["add", "-A"]);
+    runGit(dir, ["commit", "-m", "init"]);
     return dir;
   }
 
@@ -618,12 +618,12 @@ describe('git-service', async () => {
   {
     // master-only repo
     const repo = mkdtempSync(join(tmpdir(), "gsd-git-t03-master-"));
-    run("git init -b master", repo);
-    run('git config user.name "Pi Test"', repo);
-    run('git config user.email "pi@example.com"', repo);
+    runGit(repo, ["init", "-b", "master"]);
+    runGit(repo, ["config", "user.name", "Pi Test"]);
+    runGit(repo, ["config", "user.email", "pi@example.com"]);
     createFile(repo, ".gitkeep", "");
-    run("git add -A", repo);
-    run('git commit -m "init"', repo);
+    runGit(repo, ["add", "-A"]);
+    runGit(repo, ["commit", "-m", "init"]);
 
     const svc = new GitServiceImpl(repo);
     assert.deepStrictEqual(svc.getMainBranch(), "master", "getMainBranch returns master when only master exists");
@@ -635,11 +635,11 @@ describe('git-service', async () => {
   // S05: Enhanced features — snapshots, pre-merge checks
   // ═══════════════════════════════════════════════════════════════════════
 
-  // ─── createSnapshot: prefs enabled ─────────────────────────────────────
+  // ─── createSnapshot: default (enabled) ─────────────────────────────────
 
-  test('createSnapshot: enabled', () => {
+  test('createSnapshot: enabled by default when prefs omitted', () => {
     const repo = initBranchTestRepo();
-    const svc = new GitServiceImpl(repo, { snapshots: true });
+    const svc = new GitServiceImpl(repo);
 
     // Create a branch with a commit
     run("git checkout -b gsd/M001/S01", repo);
@@ -675,6 +675,39 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  // ─── runPreMergeCheck: default (auto-detect) ──────────────────────────
+
+  test('runPreMergeCheck: auto-detects when prefs omitted', () => {
+    const repo = initBranchTestRepo();
+    createFile(repo, "package.json", JSON.stringify({
+      name: "test-default",
+      scripts: { test: 'node -e "process.exit(0)"' },
+    }));
+    run("git add -A", repo);
+    run('git commit -m "add package.json"', repo);
+
+    // No pre_merge_check pref set — should auto-detect and run
+    const svc = new GitServiceImpl(repo);
+    const result: PreMergeCheckResult = svc.runPreMergeCheck();
+
+    assert.deepStrictEqual(result.passed, true, "runPreMergeCheck auto-detects and passes when prefs omitted");
+    assert.ok(!result.skipped, "runPreMergeCheck is not skipped when prefs omitted and package.json exists");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test('runPreMergeCheck: gracefully skips when prefs omitted and no package.json', () => {
+    const repo = initBranchTestRepo();
+    // No package.json — auto-detect should skip gracefully
+    const svc = new GitServiceImpl(repo);
+    const result: PreMergeCheckResult = svc.runPreMergeCheck();
+
+    assert.deepStrictEqual(result.passed, true, "runPreMergeCheck passes when no package.json (skip)");
+    assert.deepStrictEqual(result.skipped, true, "runPreMergeCheck skips when no test runner detected");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ─── runPreMergeCheck: pass ────────────────────────────────────────────
 
   test('runPreMergeCheck: pass', () => {
@@ -1082,9 +1115,9 @@ describe('git-service', async () => {
   test('untrackRuntimeFiles', async () => {
     const { untrackRuntimeFiles } = await import("../gitignore.ts");
     const repo = mkdtempSync(join(tmpdir(), "gsd-untrack-"));
-    run("git init -b main", repo);
-    run("git config user.email test@test.com", repo);
-    run("git config user.name Test", repo);
+    runGit(repo, ["init", "-b", "main"]);
+    runGit(repo, ["config", "user.email", "test@test.com"]);
+    runGit(repo, ["config", "user.name", "Test"]);
 
     // Create and track runtime files (simulates pre-.gitignore state)
     mkdirSync(join(repo, ".gsd", "activity"), { recursive: true });
@@ -1095,8 +1128,8 @@ describe('git-service', async () => {
     writeFileSync(join(repo, ".gsd", "activity", "log.jsonl"), "{}");
     writeFileSync(join(repo, ".gsd", "runtime", "data.json"), "{}");
     writeFileSync(join(repo, "src.ts"), "code");
-    run("git add -A", repo);
-    run("git commit -m init", repo);
+    runGit(repo, ["add", "-A"]);
+    runGit(repo, ["commit", "-m", "init"]);
 
     // Precondition: runtime files are tracked
     const trackedBefore = run("git ls-files .gsd/", repo);
@@ -1131,11 +1164,12 @@ describe('git-service', async () => {
 
   test('smartStage excludes runtime files, allows milestone artifacts', () => {
     const repo = mkdtempSync(join(tmpdir(), "gsd-smart-stage-excludes-"));
-    run("git init -b main", repo);
-    run("git config user.email test@test.com", repo);
-    run("git config user.name Test", repo);
+    runGit(repo, ["init", "-b", "main"]);
+    runGit(repo, ["config", "user.email", "test@test.com"]);
+    runGit(repo, ["config", "user.name", "Test"]);
     writeFileSync(join(repo, "README.md"), "init");
-    run("git add -A && git commit -m init", repo);
+    runGit(repo, ["add", "-A"]);
+    runGit(repo, ["commit", "-m", "init"]);
 
     // Create .gsd/ runtime files + milestone artifacts + a normal source file
     mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });

package/src/resources/extensions/gsd/tests/milestone-report-path.test.ts

@@ -0,0 +1,51 @@
+/**
+ * milestone-report-path.test.ts — Regression test for milestone report path resolution.
+ *
+ * When running in a worktree, milestone reports must be written to the
+ * original project root (originalBasePath), not the worktree path (basePath).
+ *
+ * Covers: _resolveReportBasePath from auto/phases.ts
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { _resolveReportBasePath } from "../auto/phases.ts";
+
+describe("_resolveReportBasePath", () => {
+  test("uses originalBasePath when set (worktree scenario)", () => {
+    const session = {
+      originalBasePath: "/projects/my-app",
+      basePath: "/projects/my-app/.claude/worktrees/agent-abc123",
+    };
+
+    assert.equal(_resolveReportBasePath(session), "/projects/my-app");
+  });
+
+  test("falls back to basePath when originalBasePath is empty", () => {
+    const session = {
+      originalBasePath: "",
+      basePath: "/projects/my-app",
+    };
+
+    assert.equal(_resolveReportBasePath(session), "/projects/my-app");
+  });
+
+  test("falls back to basePath when originalBasePath is undefined", () => {
+    const session = {
+      originalBasePath: undefined as unknown as string,
+      basePath: "/projects/my-app",
+    };
+
+    assert.equal(_resolveReportBasePath(session), "/projects/my-app");
+  });
+
+  test("uses originalBasePath even when basePath differs", () => {
+    const session = {
+      originalBasePath: "/home/user/repo",
+      basePath: "/tmp/worktree-xyz",
+    };
+
+    assert.equal(_resolveReportBasePath(session), "/home/user/repo");
+  });
+});