gsd-pi 2.41.0 → 2.42.0-dev.1df898f

package/src/resources/extensions/gsd/tests/engine-interfaces-contract.test.ts

@@ -0,0 +1,271 @@
+/**
+ * engine-interfaces-contract.test.ts — Source-level contract tests for the
+ * engine abstraction layer (S01).
+ *
+ * TypeScript interfaces are erased by --experimental-strip-types, so these
+ * tests use source-level regex assertions on the .ts files to verify shapes.
+ * Runtime assertions cover AutoSession.activeEngineId and resolveEngine().
+ *
+ * Follows the same conventions as auto-session-encapsulation.test.ts.
+ */
+
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ENGINE_TYPES_PATH = join(__dirname, "..", "engine-types.ts");
+const WORKFLOW_ENGINE_PATH = join(__dirname, "..", "workflow-engine.ts");
+const EXECUTION_POLICY_PATH = join(__dirname, "..", "execution-policy.ts");
+const ENGINE_RESOLVER_PATH = join(__dirname, "..", "engine-resolver.ts");
+
+function readSource(path: string): string {
+  return readFileSync(path, "utf-8");
+}
+
+// ── Import smoke tests ──────────────────────────────────────────────────────
+
+describe("Import smoke tests", () => {
+  test("engine-types.ts can be dynamically imported", async () => {
+    const mod = await import("../engine-types.ts");
+    assert.ok(mod, "engine-types.ts should import without error");
+  });
+
+  test("workflow-engine.ts can be dynamically imported", async () => {
+    const mod = await import("../workflow-engine.ts");
+    assert.ok(mod, "workflow-engine.ts should import without error");
+  });
+
+  test("execution-policy.ts can be dynamically imported", async () => {
+    const mod = await import("../execution-policy.ts");
+    assert.ok(mod, "execution-policy.ts should import without error");
+  });
+
+  test("engine-resolver.ts can be dynamically imported", async () => {
+    const mod = await import("../engine-resolver.ts");
+    assert.ok(mod, "engine-resolver.ts should import without error");
+    assert.ok(
+      typeof mod.resolveEngine === "function",
+      "engine-resolver.ts should export resolveEngine function",
+    );
+  });
+});
+
+// ── Leaf-node constraint ────────────────────────────────────────────────────
+
+describe("Leaf-node constraint", () => {
+  test("engine-types.ts has zero imports from GSD modules (only node: allowed)", () => {
+    const source = readSource(ENGINE_TYPES_PATH);
+    const lines = source.split("\n");
+    const violations: string[] = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i]!;
+      // Match import lines that reference relative paths (../ or ./)
+      if (/^import\s/.test(line) && /['"]\.\.?\// .test(line)) {
+        violations.push(`line ${i + 1}: ${line.trim()}`);
+      }
+    }
+
+    assert.equal(
+      violations.length,
+      0,
+      `engine-types.ts must be a leaf node with zero GSD imports. ` +
+      `Only node: imports are allowed.\nViolations:\n${violations.join("\n")}`,
+    );
+  });
+});
+
+// ── EngineState shape ───────────────────────────────────────────────────────
+
+describe("EngineState shape", () => {
+  test("EngineState has all required fields with correct types", () => {
+    const source = readSource(ENGINE_TYPES_PATH);
+
+    const requiredFields = [
+      "phase",
+      "currentMilestoneId",
+      "activeSliceId",
+      "activeTaskId",
+      "isComplete",
+      "raw",
+    ];
+
+    for (const field of requiredFields) {
+      assert.ok(
+        source.includes(field),
+        `EngineState must contain field: ${field}`,
+      );
+    }
+
+    // raw must be typed unknown — not a GSD-specific type
+    assert.ok(
+      /raw:\s*unknown/.test(source),
+      "EngineState.raw must be typed 'unknown', not a GSD-specific type",
+    );
+  });
+});
+
+// ── EngineDispatchAction shape ──────────────────────────────────────────────
+
+describe("EngineDispatchAction shape", () => {
+  test("EngineDispatchAction has dispatch, stop, and skip variants", () => {
+    const source = readSource(ENGINE_TYPES_PATH);
+
+    assert.ok(
+      /action:\s*"dispatch"/.test(source),
+      'EngineDispatchAction must have action: "dispatch" variant',
+    );
+    assert.ok(
+      /action:\s*"stop"/.test(source),
+      'EngineDispatchAction must have action: "stop" variant',
+    );
+    assert.ok(
+      /action:\s*"skip"/.test(source),
+      'EngineDispatchAction must have action: "skip" variant',
+    );
+  });
+});
+
+// ── WorkflowEngine interface shape ──────────────────────────────────────────
+
+describe("WorkflowEngine interface shape", () => {
+  test("WorkflowEngine has engineId and all required methods", () => {
+    const source = readSource(WORKFLOW_ENGINE_PATH);
+
+    const requiredMembers = [
+      "engineId",
+      "deriveState",
+      "resolveDispatch",
+      "reconcile",
+      "getDisplayMetadata",
+    ];
+
+    for (const member of requiredMembers) {
+      assert.ok(
+        source.includes(member),
+        `WorkflowEngine must contain member: ${member}`,
+      );
+    }
+  });
+});
+
+// ── ExecutionPolicy interface shape ─────────────────────────────────────────
+
+describe("ExecutionPolicy interface shape", () => {
+  test("ExecutionPolicy has all required methods", () => {
+    const source = readSource(EXECUTION_POLICY_PATH);
+
+    const requiredMethods = [
+      "prepareWorkspace",
+      "selectModel",
+      "verify",
+      "recover",
+      "closeout",
+    ];
+
+    for (const method of requiredMethods) {
+      assert.ok(
+        source.includes(method),
+        `ExecutionPolicy must contain method: ${method}`,
+      );
+    }
+  });
+});
+
+// ── Resolver stub behavior ──────────────────────────────────────────────────
+
+describe("Resolver stub behavior", () => {
+  test("resolveEngine returns dev engine for null activeEngineId", async () => {
+    const { resolveEngine } = await import("../engine-resolver.ts");
+    const result = resolveEngine({ activeEngineId: null });
+    assert.ok(result.engine, "should return engine for null");
+    assert.equal(
+      result.engine.engineId,
+      "dev",
+      "engine.engineId should be 'dev' for null activeEngineId",
+    );
+  });
+
+  test("resolveEngine returns dev engine for 'dev' activeEngineId", async () => {
+    const { resolveEngine } = await import("../engine-resolver.ts");
+    const result = resolveEngine({ activeEngineId: "dev" });
+    assert.ok(result.engine, "should return engine for 'dev'");
+    assert.equal(
+      result.engine.engineId,
+      "dev",
+      "engine.engineId should be 'dev'",
+    );
+  });
+
+  test("resolveEngine throws for unknown activeEngineId without activeRunDir", async () => {
+    const { resolveEngine } = await import("../engine-resolver.ts");
+    assert.throws(
+      () => resolveEngine({ activeEngineId: "custom-xyz" }),
+      /activeRunDir/,
+      "resolveEngine should throw when custom engine has no activeRunDir",
+    );
+  });
+
+  test("resolveEngine returns custom engine for non-dev activeEngineId with activeRunDir", async () => {
+    const { resolveEngine } = await import("../engine-resolver.ts");
+    const result = resolveEngine({ activeEngineId: "custom-xyz", activeRunDir: "/tmp/test-run" });
+    assert.ok(result.engine, "should return engine for custom ID");
+    assert.equal(
+      result.engine.engineId,
+      "custom",
+      "engine.engineId should be 'custom' for non-dev activeEngineId",
+    );
+  });
+
+  test("ResolvedEngine type is exported (source check)", () => {
+    const source = readSource(ENGINE_RESOLVER_PATH);
+    assert.ok(
+      /export\s+(interface|type)\s+ResolvedEngine/.test(source),
+      "engine-resolver.ts must export ResolvedEngine type",
+    );
+  });
+});
+
+// ── AutoSession.activeEngineId ──────────────────────────────────────────────
+
+describe("AutoSession.activeEngineId", () => {
+  test("defaults to null on a fresh AutoSession", async () => {
+    const { AutoSession } = await import("../auto/session.ts");
+    const session = new AutoSession();
+    assert.equal(
+      session.activeEngineId,
+      null,
+      "activeEngineId should default to null",
+    );
+  });
+
+  test("is null after reset()", async () => {
+    const { AutoSession } = await import("../auto/session.ts");
+    const session = new AutoSession();
+    session.activeEngineId = "dev";
+    session.reset();
+    assert.equal(
+      session.activeEngineId,
+      null,
+      "activeEngineId should be null after reset()",
+    );
+  });
+
+  test("appears in toJSON() output", async () => {
+    const { AutoSession } = await import("../auto/session.ts");
+    const session = new AutoSession();
+    const json = session.toJSON();
+    assert.ok(
+      "activeEngineId" in json,
+      "toJSON() must include activeEngineId",
+    );
+    assert.equal(
+      json.activeEngineId,
+      null,
+      "toJSON().activeEngineId should be null by default",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/exit-command.test.ts

@@ -48,3 +48,58 @@ test("/exit requests graceful shutdown instead of process.exit", async () => {
   assert.equal(stopAutoCalls, 1, "handler should stop auto-mode exactly once before shutdown");
   assert.equal(shutdownCalls, 1, "handler should request graceful shutdown exactly once");
 });
+
+// ─── #1839 regression: ESM cache mismatch must not crash exit ────────────────
+
+test("/exit still shuts down gracefully when stopAuto throws (ESM module cache mismatch)", async () => {
+  const commands = new Map<string, { description?: string; handler: (args: string, ctx: any) => Promise<void> }>();
+
+  const pi = {
+    registerCommand(name: string, options: any) {
+      commands.set(name, options);
+    },
+  };
+
+  // Simulate the ESM cache mismatch: stopAuto throws because a static import
+  // in the dependency chain references an export absent from the cached module.
+  registerExitCommand(pi as any, {
+    async stopAuto() {
+      throw new Error(
+        "The requested module './native-git-bridge.js' does not provide an export named 'nativeAddAllWithExclusions'",
+      );
+    },
+  });
+
+  const exit = commands.get("exit")!;
+
+  let shutdownCalls = 0;
+  const notifications: Array<{ msg: string; level: string }> = [];
+
+  const originalExit = process.exit;
+  process.exit = ((code?: number) => {
+    throw new Error(`process.exit should not be called: ${code ?? "undefined"}`);
+  }) as typeof process.exit;
+
+  try {
+    await exit.handler("", {
+      async shutdown() {
+        shutdownCalls += 1;
+      },
+      ui: {
+        notify(msg: string, level: string) {
+          notifications.push({ msg, level });
+        },
+      },
+    });
+  } finally {
+    process.exit = originalExit;
+  }
+
+  assert.equal(shutdownCalls, 1, "shutdown must still be called even when stopAuto throws");
+  assert.equal(notifications.length, 1, "should emit exactly one warning notification");
+  assert.equal(notifications[0].level, "warning", "notification level should be warning");
+  assert.ok(
+    notifications[0].msg.includes("module version mismatch"),
+    "notification should mention module version mismatch",
+  );
+});

package/src/resources/extensions/gsd/tests/forensics-dedup.test.ts

@@ -0,0 +1,48 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const gsdDir = join(__dirname, "..");
+
+describe("forensics dedup (#2096)", () => {
+  it("forensics_dedup is in KNOWN_PREFERENCE_KEYS", () => {
+    const source = readFileSync(join(gsdDir, "preferences-types.ts"), "utf-8");
+    assert.ok(source.includes('"forensics_dedup"'),
+      "KNOWN_PREFERENCE_KEYS must contain forensics_dedup");
+    assert.ok(source.includes("forensics_dedup?: boolean"),
+      "GSDPreferences must declare forensics_dedup as optional boolean");
+  });
+
+  it("forensics prompt contains {{dedupSection}} placeholder", () => {
+    const prompt = readFileSync(join(gsdDir, "prompts", "forensics.md"), "utf-8");
+    assert.ok(prompt.includes("{{dedupSection}}"),
+      "forensics.md must contain {{dedupSection}} placeholder");
+  });
+
+  it("DEDUP_PROMPT_SECTION contains required search commands", async () => {
+    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
+    assert.ok(source.includes("DEDUP_PROMPT_SECTION"), "forensics.ts must define DEDUP_PROMPT_SECTION");
+    assert.ok(source.includes("gh issue list --repo gsd-build/gsd-2 --state closed"));
+    assert.ok(source.includes("gh pr list --repo gsd-build/gsd-2 --state open"));
+    assert.ok(source.includes("gh pr list --repo gsd-build/gsd-2 --state merged"));
+  });
+
+  it("handleForensics checks forensics_dedup preference", () => {
+    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
+    assert.ok(source.includes("forensics_dedup"),
+      "handleForensics must reference forensics_dedup preference");
+    assert.ok(source.includes("dedupSection"),
+      "handleForensics must pass dedupSection to loadPrompt");
+  });
+
+  it("first-time opt-in shows when preference is undefined", () => {
+    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
+    assert.ok(source.includes("=== undefined"),
+      "first-time detection must check for undefined (not false)");
+    assert.ok(source.includes("Duplicate detection available") || source.includes("duplicate detection"),
+      "opt-in notice must mention duplicate detection");
+  });
+});

package/src/resources/extensions/gsd/tests/forensics-issue-routing.test.ts

@@ -0,0 +1,43 @@
+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("forensics prompt explicitly forbids github_issues tool for issue creation", () => {
+  const prompt = readPrompt("forensics");
+
+  // Must contain an explicit prohibition against using the github_issues tool
+  assert.match(
+    prompt,
+    /Do NOT use the `?github_issues`? tool/i,
+    "Prompt must explicitly prohibit the github_issues tool",
+  );
+});
+
+test("forensics prompt requires gh CLI with --repo gsd-build/gsd-2 for issue creation", () => {
+  const prompt = readPrompt("forensics");
+
+  // Must contain the exact gh CLI command with the correct repo flag
+  assert.match(
+    prompt,
+    /gh issue create --repo gsd-build\/gsd-2/,
+    "Prompt must specify gh issue create --repo gsd-build/gsd-2",
+  );
+});
+
+test("forensics prompt routes issue creation through bash tool, not github_issues", () => {
+  const prompt = readPrompt("forensics");
+
+  // The constraint about using bash tool must be present
+  assert.match(
+    prompt,
+    /`?bash`? tool/i,
+    "Prompt must instruct use of the bash tool for issue creation",
+  );
+});

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

@@ -0,0 +1,133 @@
+/**
+ * Regression tests for #1997: git locale not forced to C.
+ *
+ * Validates that GIT_NO_PROMPT_ENV includes LC_ALL=C so git always produces
+ * English output, and that nativeMergeSquash passes the env to execFileSync.
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { GIT_NO_PROMPT_ENV } from "../git-constants.ts";
+import { nativeAddAllWithExclusions } from "../native-git-bridge.ts";
+import { RUNTIME_EXCLUSION_PATHS } from "../git-service.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function initTempRepo(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-locale-"));
+  git(dir, "init");
+  git(dir, "config", "user.email", "test@test.com");
+  git(dir, "config", "user.name", "Test");
+  // Initial commit so HEAD exists
+  writeFileSync(join(dir, "init.txt"), "init");
+  git(dir, "add", "-A");
+  git(dir, "commit", "-m", "init");
+  return dir;
+}
+
+function createFile(base: string, relPath: string, content: string): void {
+  const full = join(base, relPath);
+  mkdirSync(join(full, ".."), { recursive: true });
+  writeFileSync(full, content);
+}
+
+async function main(): Promise<void> {
+  // ─── GIT_NO_PROMPT_ENV includes LC_ALL=C ─────────────────────────────
+
+  console.log("\n=== GIT_NO_PROMPT_ENV includes LC_ALL=C ===");
+
+  assertEq(
+    GIT_NO_PROMPT_ENV.LC_ALL,
+    "C",
+    "GIT_NO_PROMPT_ENV must set LC_ALL to 'C' to force English git output"
+  );
+
+  assertTrue(
+    "GIT_TERMINAL_PROMPT" in GIT_NO_PROMPT_ENV,
+    "GIT_NO_PROMPT_ENV still contains GIT_TERMINAL_PROMPT"
+  );
+
+  // ─── nativeAddAllWithExclusions: non-English locale does not throw ───
+
+  console.log("\n=== nativeAddAllWithExclusions: non-English locale does not throw ===");
+
+  {
+    // Simulate what happens on a German system: .gsd is gitignored,
+    // exclusion pathspecs trigger an advisory warning exit code 1.
+    // With LC_ALL=C the English stderr guard should match and suppress.
+    const repo = initTempRepo();
+
+    writeFileSync(join(repo, ".gitignore"), ".gsd\n");
+    createFile(repo, ".gsd/STATE.md", "# State");
+    createFile(repo, "src/app.ts", "export const x = 1;");
+
+    // Save original LC_ALL / LANG and force German locale env
+    const origLcAll = process.env.LC_ALL;
+    const origLang = process.env.LANG;
+    process.env.LANG = "de_DE.UTF-8";
+    delete process.env.LC_ALL;
+
+    let threw = false;
+    try {
+      nativeAddAllWithExclusions(repo, RUNTIME_EXCLUSION_PATHS);
+    } catch (e) {
+      threw = true;
+      console.error("  unexpected error:", e);
+    }
+
+    // Restore
+    if (origLcAll !== undefined) process.env.LC_ALL = origLcAll;
+    else delete process.env.LC_ALL;
+    if (origLang !== undefined) process.env.LANG = origLang;
+    else delete process.env.LANG;
+
+    assertTrue(
+      !threw,
+      "nativeAddAllWithExclusions must not throw on non-English locale when .gsd is gitignored (#1997)"
+    );
+
+    const staged = git(repo, "diff", "--cached", "--name-only");
+    assertTrue(staged.includes("src/app.ts"), "real file staged despite German locale");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── nativeMergeSquash: env is passed (merge-squash stderr is English) ─
+
+  console.log("\n=== nativeMergeSquash fallback uses GIT_NO_PROMPT_ENV ===");
+
+  {
+    // We verify indirectly: the source code must pass env: GIT_NO_PROMPT_ENV.
+    // Read the source and check for the pattern. This is a static check.
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "native-git-bridge.ts"),
+      "utf-8"
+    );
+
+    // Find the nativeMergeSquash function and check it uses GIT_NO_PROMPT_ENV
+    const fnStart = src.indexOf("export function nativeMergeSquash");
+    assertTrue(fnStart !== -1, "nativeMergeSquash function exists in source");
+
+    const fnBody = src.slice(fnStart, src.indexOf("\nexport function", fnStart + 1));
+    const hasEnv = fnBody.includes("env: GIT_NO_PROMPT_ENV");
+    assertTrue(
+      hasEnv,
+      "nativeMergeSquash fallback must pass env: GIT_NO_PROMPT_ENV to execFileSync (#1997)"
+    );
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

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

@@ -1411,6 +1411,50 @@ async function main(): Promise<void> {
     rmSync(repo, { recursive: true, force: true });
   }
 
+  // ─── autoCommit: symlinked .gsd does NOT stage milestone artifacts (#2247) ──
+
+  console.log("\n=== autoCommit: symlinked .gsd does NOT stage milestone artifacts (#2247) ===");
+
+  {
+    // When .gsd is a symlink (external state project), .gsd/ files live outside
+    // the repo by design. smartStage() must NOT force-stage them into git — the
+    // .gitignore exclusion is correct and intentional.
+    const repo = initTempRepo();
+
+    // Create an external .gsd directory and symlink it into the repo
+    const externalGsd = mkdtempSync(join(tmpdir(), "gsd-external-symlink-"));
+    mkdirSync(join(externalGsd, "milestones", "M009"), { recursive: true });
+    mkdirSync(join(externalGsd, "activity"), { recursive: true });
+    mkdirSync(join(externalGsd, "runtime"), { recursive: true });
+
+    symlinkSync(externalGsd, join(repo, ".gsd"));
+
+    // .gitignore blocks .gsd (as ensureGitignore would do for symlink projects)
+    writeFileSync(join(repo, ".gitignore"), ".gsd\n");
+    run('git add .gitignore', repo);
+    run('git commit -m "add gitignore"', repo);
+
+    // Simulate new milestone artifacts created during execution
+    writeFileSync(join(externalGsd, "milestones", "M009", "M009-SUMMARY.md"), "# M009 Summary");
+    writeFileSync(join(externalGsd, "milestones", "M009", "S01-SUMMARY.md"), "# S01 Summary");
+    writeFileSync(join(externalGsd, "milestones", "M009", "T01-VERIFY.json"), '{"passed":true}');
+
+    // Also create a normal source file change
+    createFile(repo, "src/feature.ts", "export const feature = true;");
+
+    const svc = new GitServiceImpl(repo);
+    const msg = svc.autoCommit("complete-milestone", "M009");
+    assertTrue(msg !== null, "symlink autoCommit: commit succeeds");
+
+    const committed = run("git show --name-only HEAD", repo);
+    assertTrue(committed.includes("src/feature.ts"), "symlink autoCommit: source file committed");
+    assertTrue(!committed.includes(".gsd/milestones/"),
+      "symlink autoCommit: .gsd/milestones/ files are NOT staged (external state stays external)");
+
+    try { rmSync(repo, { recursive: true, force: true }); } catch {}
+    try { rmSync(externalGsd, { recursive: true, force: true }); } catch {}
+  }
+
   report();
 }