gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/queue-auto-guard.test.ts

@@ -11,203 +11,29 @@
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-// ─── Structural test: verify the guard exists in source ──────────────────────
+import { _setAutoActiveForTest } from "../auto.ts";
+import { handleWorkflowCommand } from "../commands/handlers/workflow.ts";
 
 describe("/gsd queue auto-mode guard (#4704)", () => {
-  it("handleWorkflowCommand checks isAutoActive() before calling showQueue", () => {
-    const src = readFileSync(
-      join(
-        import.meta.dirname,
-        "..",
-        "commands",
-        "handlers",
-        "workflow.ts",
-      ),
-      "utf-8",
-    );
-
-    // Find the queue command block
-    const queueBlockMatch = src.match(
-      /if\s*\(\s*trimmed\s*===\s*"queue"\s*\)\s*\{([\s\S]*?)\n  \}/,
-    );
-    assert.ok(queueBlockMatch, "queue command block exists in handleWorkflowCommand");
-
-    const queueBlock = queueBlockMatch[1];
-
-    // Verify auto-mode guard comes BEFORE showQueue call. Accepts either the
-    // inline isAutoActive() check (Tier 1) or the shared requireNotAutoActive()
-    // helper (Tier 2 / #4712).
-    const guardIndex = Math.max(
-      queueBlock.indexOf("isAutoActive()"),
-      queueBlock.indexOf("requireNotAutoActive("),
-    );
-    const showQueueIndex = queueBlock.indexOf("showQueue(");
-
-    assert.ok(guardIndex !== -1, "auto-mode guard exists in queue command block");
-    assert.ok(showQueueIndex !== -1, "showQueue() call exists in queue command block");
-    assert.ok(
-      guardIndex < showQueueIndex,
-      "auto-mode guard appears before showQueue() call",
-    );
-  });
-
-  it("guard shows error message mentioning /gsd stop", () => {
-    const src = readFileSync(
-      join(
-        import.meta.dirname,
-        "..",
-        "commands",
-        "handlers",
-        "workflow.ts",
-      ),
-      "utf-8",
-    );
-
-    assert.ok(
-      src.includes("cannot run while auto-mode is active"),
-      "error message explains that the command cannot run during auto-mode",
-    );
-    assert.ok(
-      src.includes("/gsd stop"),
-      "error message mentions /gsd stop as the resolution",
-    );
-  });
-
-  it("guard returns true (handled) to prevent falling through", () => {
-    const src = readFileSync(
-      join(
-        import.meta.dirname,
-        "..",
-        "commands",
-        "handlers",
-        "workflow.ts",
-      ),
-      "utf-8",
-    );
-
-    const queueBlockMatch = src.match(
-      /if\s*\(\s*trimmed\s*===\s*"queue"\s*\)\s*\{([\s\S]*?)\n  \}/,
-    );
-    assert.ok(queueBlockMatch);
-    const queueBlock = queueBlockMatch[1];
-
-    // The guard block should have its own return true before showQueue
-    const guardBlock = queueBlock.slice(0, queueBlock.indexOf("showQueue("));
-    assert.ok(
-      guardBlock.includes("return true"),
-      "guard block returns true before showQueue is reached",
-    );
-  });
-});
-
-// ─── .gsd/audit/ runtime classification regression ──────────────────────────
-
-describe(".gsd/audit/ runtime classification (#4704)", () => {
-  it("GSD_RUNTIME_PATTERNS in gitignore.ts includes .gsd/audit/", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "gitignore.ts"),
-      "utf-8",
-    );
-    assert.ok(
-      src.includes('".gsd/audit/"'),
-      ".gsd/audit/ listed in GSD_RUNTIME_PATTERNS",
-    );
-  });
-
-  it("RUNTIME_EXCLUSION_PATHS in git-service.ts includes .gsd/audit/", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "git-service.ts"),
-      "utf-8",
-    );
-    assert.ok(
-      src.includes('".gsd/audit/"'),
-      ".gsd/audit/ listed in RUNTIME_EXCLUSION_PATHS",
-    );
-  });
-
-  it("SKIP_PATHS in worktree-manager.ts includes .gsd/audit/", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "worktree-manager.ts"),
-      "utf-8",
-    );
-    assert.ok(
-      src.includes('".gsd/audit/"'),
-      ".gsd/audit/ listed in SKIP_PATHS",
-    );
-  });
-});
-
-// ─── Windows gsd.db close+reopen around pre-merge stash ─────────────────────
-
-describe("Windows pre-merge DB release (#4704)", () => {
-  it("mergeMilestoneToMain closes gsd.db on win32 before git stash", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "auto-worktree.ts"),
-      "utf-8",
-    );
-
-    // Locate the stash push line and ensure a win32-gated closeDatabase()
-    // call precedes it in the same function scope.
-    const stashIndex = src.indexOf('"stash", "push", "--include-untracked"');
-    assert.ok(stashIndex !== -1, "pre-merge stash push exists");
-
-    const beforeStash = src.slice(0, stashIndex);
-    const win32Index = beforeStash.lastIndexOf('process.platform === "win32"');
-    const closeIndex = beforeStash.lastIndexOf("closeDatabase()");
-
-    assert.ok(win32Index !== -1, "win32 platform guard appears before stash");
-    assert.ok(closeIndex !== -1, "closeDatabase() invoked before stash");
-    assert.ok(
-      win32Index < closeIndex && closeIndex < stashIndex,
-      "platform guard wraps the closeDatabase() call before the stash",
-    );
-  });
-
-  it("openDatabase is called after the stash to reopen the connection", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "auto-worktree.ts"),
-      "utf-8",
-    );
-    const stashIndex = src.indexOf('"stash", "push", "--include-untracked"');
-    const afterStash = src.slice(stashIndex);
-    assert.ok(
-      afterStash.includes("openDatabase("),
-      "openDatabase() called after the pre-merge stash",
-    );
-  });
-
-  it("pre-merge stash targets entries by marker instead of refs/stash or stash@{0}", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "auto-worktree.ts"),
-      "utf-8",
-    );
-
-    assert.ok(src.includes("stashMarker"), "stash marker is tracked");
-    assert.ok(
-      src.includes('"stash", "list", "--format=%gd%x00%s"'),
-      "stash lookup reads ref and message together",
-    );
-    assert.ok(!src.includes('"rev-parse", "refs/stash"'), "refs/stash is not used for identity");
-    assert.ok(!src.includes('["stash", "pop"]'), "stash pop is never unqualified");
-    assert.ok(!src.includes('["stash", "drop"]'), "stash drop is never unqualified");
-  });
-
-  it("stash drop after pop failure requires auto-resolved .gsd conflicts", () => {
-    const src = readFileSync(
-      join(import.meta.dirname, "..", "auto-worktree.ts"),
-      "utf-8",
-    );
-
-    assert.ok(
-      src.includes("gsdUU.length > 0 && nonGsdUU.length === 0"),
-      "stash drop must only run after detected .gsd conflicts were auto-resolved",
-    );
-    assert.ok(
-      src.includes("git stash pop failed without resolvable conflict files; leaving stash for manual recovery"),
-      "non-conflict stash pop failures must leave the stash for manual recovery",
-    );
+  it("returns handled and notifies when auto-mode is active", async () => {
+    const notifications: Array<{ message: string; level?: string }> = [];
+    _setAutoActiveForTest(true);
+    try {
+      const handled = await handleWorkflowCommand("queue", {
+        ui: {
+          notify(message: string, level?: string) {
+            notifications.push({ message, level });
+          },
+        },
+      } as any, {} as any);
+
+      assert.equal(handled, true);
+      assert.deepEqual(notifications, [{
+        message: "/gsd queue cannot run while auto-mode is active.\nStop auto-mode first with /gsd stop, then run /gsd queue.",
+        level: "error",
+      }]);
+    } finally {
+      _setAutoActiveForTest(false);
+    }
   });
 });

package/src/resources/extensions/gsd/tests/quick-auto-guard.test.ts

@@ -6,101 +6,31 @@
  * delegating to handleQuick.
  */
 
-import { describe, it, mock, beforeEach, afterEach } from "node:test";
+import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-// ─── Structural test: verify the guard exists in source ──────────────────────
+import { _setAutoActiveForTest } from "../auto.ts";
+import { handleWorkflowCommand } from "../commands/handlers/workflow.ts";
 
 describe("/gsd quick auto-mode guard (#2417)", () => {
-  it("handleWorkflowCommand checks isAutoActive() before calling handleQuick", () => {
-    // Read the source file and verify the guard is structurally present
-    const src = readFileSync(
-      join(
-        import.meta.dirname,
-        "..",
-        "commands",
-        "handlers",
-        "workflow.ts",
-      ),
-      "utf-8",
-    );
-
-    // Find the quick command block
-    const quickBlockMatch = src.match(
-      /if\s*\(\s*trimmed\s*===\s*"quick"\s*\|\|\s*trimmed\.startsWith\("quick "\)\s*\)\s*\{([\s\S]*?)\n  \}/,
-    );
-    assert.ok(quickBlockMatch, "quick command block exists in handleWorkflowCommand");
-
-    const quickBlock = quickBlockMatch[1];
-
-    // Verify the shared auto-mode guard comes BEFORE handleQuick call.
-    // Accepts either the inline isAutoActive() check (legacy) or the shared
-    // requireNotAutoActive() helper (#4712).
-    const guardIndex = Math.max(
-      quickBlock.indexOf("isAutoActive()"),
-      quickBlock.indexOf("requireNotAutoActive("),
-    );
-    const handleQuickIndex = quickBlock.indexOf("handleQuick(");
-
-    assert.ok(guardIndex !== -1, "auto-mode guard exists in quick command block");
-    assert.ok(handleQuickIndex !== -1, "handleQuick() call exists in quick command block");
-    assert.ok(
-      guardIndex < handleQuickIndex,
-      "auto-mode guard appears before handleQuick() call",
-    );
-  });
-
-  it("guard shows error message mentioning /gsd stop", () => {
-    const src = readFileSync(
-      join(
-        import.meta.dirname,
-        "..",
-        "commands",
-        "handlers",
-        "workflow.ts",
-      ),
-      "utf-8",
-    );
-
-    // The shared helper assembles the message dynamically from the command name,
-    // so assert on the message fragment and the /gsd stop instruction.
-    assert.ok(
-      src.includes("cannot run while auto-mode is active"),
-      "error message explains that the command cannot run during auto-mode",
-    );
-    assert.ok(
-      src.includes("/gsd stop"),
-      "error message mentions /gsd stop as the resolution",
-    );
-  });
-
-  it("guard returns true (handled) to prevent falling through", () => {
-    const src = readFileSync(
-      join(
-        import.meta.dirname,
-        "..",
-        "commands",
-        "handlers",
-        "workflow.ts",
-      ),
-      "utf-8",
-    );
-
-    // After the isAutoActive() check and notify, there should be a `return true`
-    // before the handleQuick call
-    const quickBlockMatch = src.match(
-      /if\s*\(\s*trimmed\s*===\s*"quick"\s*\|\|\s*trimmed\.startsWith\("quick "\)\s*\)\s*\{([\s\S]*?)\n  \}/,
-    );
-    assert.ok(quickBlockMatch);
-    const quickBlock = quickBlockMatch[1];
-
-    // The guard block should have its own return true before handleQuick
-    const guardBlock = quickBlock.slice(0, quickBlock.indexOf("handleQuick("));
-    assert.ok(
-      guardBlock.includes("return true"),
-      "guard block returns true before handleQuick is reached",
-    );
+  it("returns handled and notifies when auto-mode is active", async () => {
+    const notifications: Array<{ message: string; level?: string }> = [];
+    _setAutoActiveForTest(true);
+    try {
+      const handled = await handleWorkflowCommand("quick fix the docs", {
+        ui: {
+          notify(message: string, level?: string) {
+            notifications.push({ message, level });
+          },
+        },
+      } as any, {} as any);
+
+      assert.equal(handled, true);
+      assert.deepEqual(notifications, [{
+        message: "/gsd quick cannot run while auto-mode is active.\nStop auto-mode first with /gsd stop, then run /gsd quick.",
+        level: "error",
+      }]);
+    } finally {
+      _setAutoActiveForTest(false);
+    }
   });
 });

package/src/resources/extensions/gsd/tests/quick-external-gsd.test.ts

@@ -0,0 +1,40 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { buildQuickCommitInstruction } from "../quick.ts";
+
+function git(cwd: string, args: string[]): void {
+  const result = spawnSync("git", args, { cwd, encoding: "utf-8" });
+  assert.equal(result.status, 0, result.stderr || result.stdout);
+}
+
+test("quick task commit instruction does not ask agents to stage external .gsd quick files", { skip: process.platform === "win32" }, () => {
+  const tempRoot = realpathSync(mkdtempSync(join(tmpdir(), "gsd-quick-ext-")));
+  const repo = join(tempRoot, "repo");
+  const externalGsd = join(tempRoot, "state");
+  mkdirSync(repo);
+  mkdirSync(externalGsd);
+
+  const previousCwd = process.cwd();
+  try {
+    git(repo, ["init"]);
+    git(repo, ["config", "user.email", "test@example.com"]);
+    git(repo, ["config", "user.name", "Test User"]);
+    writeFileSync(join(repo, "README.md"), "# Test\n", "utf-8");
+    git(repo, ["add", "README.md"]);
+    git(repo, ["commit", "-m", "init"]);
+    symlinkSync(externalGsd, join(repo, ".gsd"), "dir");
+
+    const instruction = buildQuickCommitInstruction(repo, join(repo, ".gsd"));
+
+    assert.match(instruction, /do not stage or commit `\.gsd\/quick\/\.\.\.`/);
+    assert.match(instruction, /nothing in the project repo to commit/);
+    assert.match(instruction, /Write the quick summary file directly/);
+  } finally {
+    process.chdir(previousCwd);
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/quick-turn-end-cleanup.test.ts

@@ -1,90 +1,61 @@
 /**
- * Tests that cleanupQuickBranch is called on turn_end to squash-merge the
- * quick branch back to the original branch after the agent completes.
- *
- * Relates to #2668: /gsd quick does not squash-merge branch back after agent
- * completes task. cleanupQuickBranch() exists but is never invoked.
- *
- * The fix registers a turn_end hook in register-hooks.ts that calls
- * cleanupQuickBranch() after each turn, which is a no-op when no quick-task
- * state is pending.
+ * Tests that cleanupQuickBranch is wired to turn_end by exercising the
+ * registered hook against a real temporary git repository.
  */
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-// ─── Structural test: verify turn_end hook exists in register-hooks.ts ──────
+import { registerHooks } from "../bootstrap/register-hooks.ts";
 
-describe("quick task turn_end cleanup (#2668)", () => {
-  const hooksSource = readFileSync(
-    join(import.meta.dirname, "..", "bootstrap", "register-hooks.ts"),
-    "utf-8",
-  );
-
-  it("register-hooks.ts loads cleanupQuickBranch from quick.ts", () => {
-    assert.ok(
-      hooksSource.includes("cleanupQuickBranch"),
-      "register-hooks.ts must reference cleanupQuickBranch",
-    );
-
-    // Verify it is loaded from quick.ts (static or lazy), not just mentioned in a comment.
-    const importMatch =
-      hooksSource.match(/import\s*\{[^}]*cleanupQuickBranch[^}]*\}\s*from\s*["'][^"']*quick/) ||
-      hooksSource.match(/const\s+\{\s*cleanupQuickBranch\s*\}\s*=\s*await\s+import\(["'][^"']*quick\.js["']\)/);
-    assert.ok(
-      importMatch,
-      "cleanupQuickBranch must be loaded from quick module",
-    );
-  });
-
-  it("registers a turn_end handler that calls cleanupQuickBranch", () => {
-    // Find the turn_end registration
-    const turnEndMatch = hooksSource.match(
-      /pi\.on\(\s*["']turn_end["']/,
-    );
-    assert.ok(
-      turnEndMatch,
-      "register-hooks.ts must register a turn_end handler",
-    );
-
-    // Extract the turn_end handler body — find everything from the pi.on("turn_end"
-    // to the matching closing });
-    const turnEndIdx = hooksSource.indexOf(turnEndMatch[0]);
-    assert.ok(turnEndIdx !== -1);
-
-    // Get the rest of the source from that point
-    const rest = hooksSource.slice(turnEndIdx);
+function git(cwd: string, args: string[]): string {
+  return execFileSync("git", args, { cwd, encoding: "utf-8" }).trim();
+}
 
-    // The handler must call cleanupQuickBranch
-    // Look for cleanupQuickBranch within the first handler body (up to first `});`)
-    const handlerEnd = rest.indexOf("});");
-    assert.ok(handlerEnd !== -1, "turn_end handler has a closing });");
-
-    const handlerBody = rest.slice(0, handlerEnd);
-    assert.ok(
-      handlerBody.includes("cleanupQuickBranch"),
-      "turn_end handler must call cleanupQuickBranch",
-    );
-  });
-
-  it("turn_end handler calls cleanupQuickBranch without arguments (uses cwd default)", () => {
-    // cleanupQuickBranch(basePath = process.cwd()) — calling without args is correct
-    // because the handler runs in the same process where handleQuick set up cwd
-    const turnEndIdx = hooksSource.indexOf('pi.on("turn_end"') !== -1
-      ? hooksSource.indexOf('pi.on("turn_end"')
-      : hooksSource.indexOf("pi.on('turn_end'");
-    assert.ok(turnEndIdx !== -1);
-
-    const rest = hooksSource.slice(turnEndIdx);
-    const handlerEnd = rest.indexOf("});");
-    const handlerBody = rest.slice(0, handlerEnd);
-
-    // Should call cleanupQuickBranch() — either bare or with no-arg form
-    assert.ok(
-      handlerBody.includes("cleanupQuickBranch("),
-      "turn_end handler invokes cleanupQuickBranch()",
-    );
+describe("quick task turn_end cleanup (#2668)", () => {
+  it("turn_end handler runs cleanupQuickBranch and removes quick-return state", async () => {
+    const repo = mkdtempSync(join(tmpdir(), "gsd-quick-cleanup-"));
+    const oldCwd = process.cwd();
+    try {
+      git(repo, ["init", "-b", "main"]);
+      git(repo, ["config", "user.email", "test@example.com"]);
+      git(repo, ["config", "user.name", "Test User"]);
+      writeFileSync(join(repo, "README.md"), "base\n");
+      git(repo, ["add", "README.md"]);
+      git(repo, ["commit", "-m", "chore: initial"]);
+      git(repo, ["checkout", "-b", "quick/Q1-test"]);
+      writeFileSync(join(repo, "quick.txt"), "quick work\n");
+      git(repo, ["add", "quick.txt"]);
+      git(repo, ["commit", "-m", "test: quick work"]);
+
+      mkdirSync(join(repo, ".gsd", "runtime"), { recursive: true });
+      writeFileSync(join(repo, ".gsd", "runtime", "quick-return.json"), JSON.stringify({
+        basePath: repo,
+        originalBranch: "main",
+        quickBranch: "quick/Q1-test",
+        taskNum: 1,
+        slug: "test",
+        description: "test",
+      }) + "\n");
+
+      const handlers = new Map<string, Function>();
+      registerHooks({ on(event: string, handler: Function) { handlers.set(event, handler); } } as any, []);
+      const turnEnd = handlers.get("turn_end");
+      assert.ok(turnEnd, "turn_end hook should be registered");
+
+      process.chdir(repo);
+      await turnEnd();
+
+      assert.equal(git(repo, ["branch", "--show-current"]), "main");
+      assert.throws(() => git(repo, ["rev-parse", "--verify", "quick/Q1-test"]));
+      assert.equal(existsSync(join(repo, ".gsd", "runtime", "quick-return.json")), false);
+    } finally {
+      process.chdir(oldCwd);
+      rmSync(repo, { recursive: true, force: true });
+    }
   });
 });

package/src/resources/extensions/gsd/tests/reassess-default-optin.test.ts

@@ -5,7 +5,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, readFileSync, rmSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -16,6 +16,8 @@ import {
   type DispatchAction,
   type DispatchContext,
 } from "../auto-dispatch.ts";
+import { buildPlanSlicePrompt } from "../auto-prompts.ts";
+import { registerDbTools } from "../bootstrap/db-tools.ts";
 import { resolveProfileDefaults } from "../preferences-models.ts";
 import type { GSDState } from "../types.ts";
 import type { GSDPreferences } from "../preferences.ts";
@@ -117,16 +119,28 @@ test("ADR-003 §4: burn-max profile opts into dedicated reassess-roadmap dispatc
 });
 
 test("ADR-003 §4: plan-slice prompt and MCP tool agree on reassess sliceChanges shape", () => {
-  const planSlicePrompt = readFileSync(new URL("../prompts/plan-slice.md", import.meta.url), "utf8");
-  assert.match(planSlicePrompt, /gsd_reassess_roadmap/);
-  assert.match(planSlicePrompt, /sliceChanges\.modified/);
-  assert.match(planSlicePrompt, /sliceChanges\.added/);
-  assert.match(planSlicePrompt, /sliceChanges\.removed/);
-
-  const dbToolsSource = readFileSync(new URL("../bootstrap/db-tools.ts", import.meta.url), "utf8");
-  assert.match(dbToolsSource, /name:\s*"gsd_reassess_roadmap"/);
-  assert.match(dbToolsSource, /sliceChanges:\s*Type\.Object/);
-  assert.match(dbToolsSource, /modified:\s*Type\.Array/);
-  assert.match(dbToolsSource, /added:\s*Type\.Array/);
-  assert.match(dbToolsSource, /removed:\s*Type\.Array/);
+  const tools: Record<string, any> = {};
+  registerDbTools({ registerTool(tool: any) { tools[tool.name] = tool; } } as any);
+
+  const reassessTool = tools.gsd_reassess_roadmap;
+  assert.ok(reassessTool, "gsd_reassess_roadmap should be registered");
+  const sliceChanges = reassessTool.parameters.properties.sliceChanges.properties;
+  assert.ok(sliceChanges.modified, "tool schema exposes sliceChanges.modified");
+  assert.ok(sliceChanges.added, "tool schema exposes sliceChanges.added");
+  assert.ok(sliceChanges.removed, "tool schema exposes sliceChanges.removed");
+});
+
+test("ADR-003 §4: rendered plan-slice prompt documents reassess sliceChanges shape", async () => {
+  const base = makeIsolatedBase();
+  try {
+    const msDir = join(base, ".gsd", "milestones", "M001");
+    writeFileSync(join(msDir, "M001-ROADMAP.md"), "# Roadmap\n\n## Slices\n\n- [ ] **S01: First** `risk:low` `depends:[]`\n");
+    const prompt = await buildPlanSlicePrompt("M001", "Test", "S01", "First", base, "minimal");
+    assert.match(prompt, /gsd_reassess_roadmap/);
+    assert.match(prompt, /sliceChanges\.modified/);
+    assert.match(prompt, /sliceChanges\.added/);
+    assert.match(prompt, /sliceChanges\.removed/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
 });