gsd-pi 2.63.0-dev.026d309 → 2.63.0-dev.351157b

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -412,6 +412,16 @@ test("unrecognized format warning is emitted at most once (#2373)", () => {
   }
 });
 
+test("parsePreferencesMarkdown parses heading+list format without frontmatter (#2036)", () => {
+  // A GSD agent recovery session wrote preferences in markdown heading+list
+  // format instead of YAML frontmatter. Since the heading+list fallback parser
+  // was added, this format is now handled gracefully.
+  const content = "## Git\n\n- isolation: none\n";
+  const result = parsePreferencesMarkdown(content);
+  assert.notEqual(result, null, "heading+list content should be parsed");
+  assert.deepStrictEqual(result!.git, { isolation: "none" });
+});
+
 // ── Experimental preferences ─────────────────────────────────────────────────
 
 test("experimental.rtk: true is accepted and stored", () => {

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -231,6 +231,31 @@ test("complete-slice prompt uses camelCase parameter names matching TypeBox sche
   assert.match(toolCallLine!, /sliceId/);
 });
 
+// ─── File system safety: complete-slice parity with complete-milestone (#2935) ──
+
+test("complete-slice prompt includes filesystem safety guard against EISDIR", () => {
+  const prompt = readPrompt("complete-slice");
+  assert.match(
+    prompt,
+    /File system safety/i,
+    "complete-slice.md must include a 'File system safety' instruction to prevent EISDIR errors when the LLM passes a directory path to the read tool"
+  );
+  assert.match(
+    prompt,
+    /never pass.*directory path.*directly to the.*read.*tool/i,
+    "complete-slice.md must warn against passing directory paths to the read tool"
+  );
+});
+
+test("complete-milestone prompt still has its filesystem safety guard (regression)", () => {
+  const prompt = readPrompt("complete-milestone");
+  assert.match(
+    prompt,
+    /File system safety/i,
+    "complete-milestone.md must keep its filesystem safety guard"
+  );
+});
+
 test("reactive-execute prompt references tool calls instead of checkbox updates", () => {
   const prompt = readPrompt("reactive-execute");
   assert.doesNotMatch(prompt, /checkbox updates/);

package/src/resources/extensions/gsd/tests/roadmap-slices.test.ts

@@ -133,6 +133,19 @@ test("parseRoadmapSlices: table with glyph completion markers (#2841)", () => {
   assert.equal(slices[3]?.done, true);
 });
 
+test("parseRoadmapSlices: table with heavy check mark U+2714 (#2940)", () => {
+  const tableContent = [
+    "# M003: Heavy Check", "", "## Slices", "",
+    "| Slice | Title | Risk | Status |", "|---|---|---|---|",
+    "| S01 | First | Low | \u2714 |",
+    "| S02 | Second | High | Pending |", "",
+  ].join("\n");
+  const slices = parseRoadmapSlices(tableContent);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.done, true, "U+2714 heavy check mark should mark slice as done");
+  assert.equal(slices[1]?.done, false);
+});
+
 test("parseRoadmapSlices: table with dependencies column (#1736)", () => {
   const tableContent = [
     "# M004: Deps", "", "## Slices", "",
@@ -393,3 +406,59 @@ test("parseRoadmapSlices: indented H3 headers under ## Slices (#2567)", () => {
   assert.equal(slices[1]?.id, "S02");
   assert.equal(slices[1]?.title, "Build");
 });
+
+// ── Regression tests for #1884: ✅ (U+2705) completion marker ──────────────
+
+test("parseRoadmapSlices: prose headers with ✅ suffix detected as done (#1884)", () => {
+  const proseContent = `# M013: Prose Roadmap
+
+### S01: Plan Limits & Billing Foundation ✅
+All tasks done.
+
+### S02: Usage Tracking
+Not done yet.
+
+### S03: Notification System ✅
+Also done.
+`;
+  const slices = parseRoadmapSlices(proseContent);
+  assert.equal(slices.length, 3);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.done, true, "S01 with trailing ✅ should be done");
+  assert.equal(slices[0]?.title, "Plan Limits & Billing Foundation");
+  assert.equal(slices[1]?.done, false);
+  assert.equal(slices[2]?.done, true, "S03 with trailing ✅ should be done");
+  assert.equal(slices[2]?.title, "Notification System");
+});
+
+test("parseRoadmapSlices: prose headers with ✅ prefix before title detected as done (#1884)", () => {
+  const proseContent = `# M014: Prose
+
+## ✅ S01: Done Slice
+Complete.
+
+## S02: Pending Slice
+Not done.
+`;
+  const slices = parseRoadmapSlices(proseContent);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.done, true, "prefix ✅ should mark as done");
+  assert.equal(slices[0]?.title, "Done Slice");
+  assert.equal(slices[1]?.done, false);
+});
+
+test("parseRoadmapSlices: prose headers with ✅ after separator detected as done (#1884)", () => {
+  const proseContent = `# M015: Prose
+
+## S01: ✅ First Feature
+Done.
+
+## S02: Second Feature
+Not done.
+`;
+  const slices = parseRoadmapSlices(proseContent);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.done, true, "✅ after colon should mark as done");
+  assert.equal(slices[0]?.title, "First Feature");
+  assert.equal(slices[1]?.done, false);
+});

package/src/resources/extensions/gsd/tests/shared-wal.test.ts

@@ -68,6 +68,36 @@ describe('shared-wal', async () => {
       'forward-slash worktree path resolves correctly');
   }
 
+  // ─── Test (e1): external-state worktree resolves to project state DB (#2952) ───
+  console.log('\n=== shared-wal: resolve external-state worktree path (#2952) ===');
+  {
+    // External-state layout: ~/.gsd/projects/<hash>/worktrees/<MID>
+    // Should resolve to:     ~/.gsd/projects/<hash>/gsd.db
+    const stateRoot = '/home/user/.gsd/projects/a1b2c3d4';
+    const worktreePath = join(stateRoot, 'worktrees', 'M002');
+    const result = resolveProjectRootDbPath(worktreePath);
+    assert.deepStrictEqual(result, join(stateRoot, 'gsd.db'),
+      'external-state worktree path resolves to project state DB (#2952)');
+  }
+
+  // ─── Test (e2): external-state worktree nested subdir (#2952) ─────────
+  console.log('\n=== shared-wal: resolve external-state worktree nested subdir (#2952) ===');
+  {
+    const stateRoot = '/home/user/.gsd/projects/deadbeef42';
+    const nestedPath = join(stateRoot, 'worktrees', 'M003', 'src', 'lib');
+    const result = resolveProjectRootDbPath(nestedPath);
+    assert.deepStrictEqual(result, join(stateRoot, 'gsd.db'),
+      'external-state nested worktree subdir resolves to project state DB (#2952)');
+  }
+
+  // ─── Test (e3): external-state worktree with forward slashes (#2952) ──
+  console.log('\n=== shared-wal: resolve external-state worktree forward-slash (#2952) ===');
+  {
+    const result = resolveProjectRootDbPath('/Users/dev/.gsd/projects/cafe0123/worktrees/M001');
+    assert.deepStrictEqual(result, join('/Users/dev/.gsd/projects/cafe0123', 'gsd.db'),
+      'external-state forward-slash worktree path resolves correctly (#2952)');
+  }
+
   // ─── Test (e): Concurrent writes — 3 connections to same WAL DB ───────
   console.log('\n=== shared-wal: concurrent writes via WAL ===');
   {

package/src/resources/extensions/gsd/tests/slice-context-injection.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Regression test: S##-CONTEXT.md from slice discussion must be
+ * injected into all 5 downstream prompt builders (#3452).
+ *
+ * Scans auto-prompts.ts for the 5 builder functions and verifies
+ * each one resolves and inlines the slice-level CONTEXT file.
+ */
+
+import { describe, test } 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 autoPromptsPath = join(__dirname, "..", "auto-prompts.ts");
+const source = readFileSync(autoPromptsPath, "utf-8");
+
+const BUILDERS = [
+  "buildResearchSlicePrompt",
+  "buildPlanSlicePrompt",
+  "buildCompleteSlicePrompt",
+  "buildReplanSlicePrompt",
+  "buildReassessRoadmapPrompt",
+];
+
+describe("slice CONTEXT.md injection into prompt builders (#3452)", () => {
+  for (const builder of BUILDERS) {
+    test(`${builder} resolves slice CONTEXT file`, () => {
+      // Find the function body
+      const fnStart = source.indexOf(`export async function ${builder}`);
+      assert.ok(fnStart !== -1, `${builder} should exist in auto-prompts.ts`);
+
+      // Get a reasonable chunk after the function start (enough to cover the inlining section)
+      const chunk = source.slice(fnStart, fnStart + 3000);
+
+      // Must resolve the slice CONTEXT path
+      assert.ok(
+        chunk.includes('resolveSliceFile(base, mid,') && chunk.includes('"CONTEXT"'),
+        `${builder} should call resolveSliceFile with "CONTEXT"`,
+      );
+
+      // Must inline it with inlineFileOptional
+      assert.ok(
+        chunk.includes('Slice Context'),
+        `${builder} should inline slice CONTEXT with a "Slice Context" label`,
+      );
+    });
+  }
+});

package/src/resources/extensions/gsd/tests/slice-parallel-conflict.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Tests for slice-level parallel conflict detection.
+ * Verifies hasFileConflict() correctly identifies when two slices
+ * touch too many of the same files to safely run in parallel.
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { hasFileConflict } from "../slice-parallel-conflict.js";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-slice-conflict-test-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function writeSlicePlan(base: string, mid: string, sid: string, content: string): void {
+  const dir = join(base, ".gsd", "milestones", mid, sid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "PLAN.md"), content, "utf-8");
+}
+
+describe("hasFileConflict", () => {
+  let base: string;
+
+  beforeEach(() => {
+    base = makeTmpBase();
+  });
+
+  afterEach(() => {
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  it("two slices with >5 overlapping file paths → blocked (true)", () => {
+    const planA = `# Plan S01
+## Tasks
+- T01: Update src/auth/login.ts
+- T02: Update src/auth/register.ts
+- T03: Update src/auth/session.ts
+- T04: Update src/auth/middleware.ts
+- T05: Update src/auth/types.ts
+- T06: Update src/auth/utils.ts
+`;
+    const planB = `# Plan S02
+## Tasks
+- T01: Refactor src/auth/login.ts
+- T02: Refactor src/auth/register.ts
+- T03: Refactor src/auth/session.ts
+- T04: Refactor src/auth/middleware.ts
+- T05: Refactor src/auth/types.ts
+- T06: Refactor src/auth/utils.ts
+`;
+    writeSlicePlan(base, "M001", "S01", planA);
+    writeSlicePlan(base, "M001", "S02", planB);
+    assert.equal(hasFileConflict(base, "M001", "S01", "S02"), true);
+  });
+
+  it("two slices with 0 overlapping paths → allowed (false)", () => {
+    const planA = `# Plan S01
+## Tasks
+- T01: Create src/api/routes.ts
+- T02: Create src/api/handlers.ts
+`;
+    const planB = `# Plan S02
+## Tasks
+- T01: Create src/ui/components.ts
+- T02: Create src/ui/styles.ts
+`;
+    writeSlicePlan(base, "M001", "S01", planA);
+    writeSlicePlan(base, "M001", "S02", planB);
+    assert.equal(hasFileConflict(base, "M001", "S01", "S02"), false);
+  });
+
+  it("missing PLAN.md → conservative block (true)", () => {
+    // Only create one slice's plan
+    writeSlicePlan(base, "M001", "S01", "# Plan\n- T01: src/foo.ts");
+    // S02 has no plan at all
+    assert.equal(hasFileConflict(base, "M001", "S01", "S02"), true);
+  });
+
+  it("one slice empty plan → allowed (false)", () => {
+    writeSlicePlan(base, "M001", "S01", "# Plan S01\n## Tasks\n- T01: Create src/foo.ts");
+    writeSlicePlan(base, "M001", "S02", "# Plan S02\n## Tasks\n(no tasks yet)");
+    assert.equal(hasFileConflict(base, "M001", "S01", "S02"), false);
+  });
+});

package/src/resources/extensions/gsd/tests/slice-parallel-eligibility.test.ts

@@ -0,0 +1,95 @@
+/**
+ * Tests for slice-level parallel eligibility.
+ * Verifies getEligibleSlices() correctly determines which slices
+ * can run in parallel based on dependency satisfaction.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { getEligibleSlices } from "../slice-parallel-eligibility.js";
+
+describe("getEligibleSlices", () => {
+  it("diamond DAG: S01 done, S02 depends:[S01], S03 depends:[S01] → both eligible", () => {
+    const slices = [
+      { id: "S01", done: true, depends: [] },
+      { id: "S02", done: false, depends: ["S01"] },
+      { id: "S03", done: false, depends: ["S01"] },
+    ];
+    const completed = new Set(["S01"]);
+    const result = getEligibleSlices(slices, completed);
+    const ids = result.map(s => s.id);
+    assert.deepStrictEqual(ids.sort(), ["S02", "S03"]);
+  });
+
+  it("linear chain: S01→S02→S03, only S01 done → only S02 eligible", () => {
+    const slices = [
+      { id: "S01", done: true, depends: [] },
+      { id: "S02", done: false, depends: ["S01"] },
+      { id: "S03", done: false, depends: ["S02"] },
+    ];
+    const completed = new Set(["S01"]);
+    const result = getEligibleSlices(slices, completed);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].id, "S02");
+  });
+
+  it("no deps declared: S01 done, S02 no deps, S03 no deps → only S02 eligible (positional fallback)", () => {
+    const slices = [
+      { id: "S01", done: true, depends: [] },
+      { id: "S02", done: false, depends: [] },
+      { id: "S03", done: false, depends: [] },
+    ];
+    const completed = new Set(["S01"]);
+    const result = getEligibleSlices(slices, completed);
+    // Positional fallback: when no deps declared, only the first non-done slice
+    // after all positionally-earlier slices are done is eligible
+    assert.equal(result.length, 1);
+    assert.equal(result[0].id, "S02");
+  });
+
+  it("all done: empty result", () => {
+    const slices = [
+      { id: "S01", done: true, depends: [] },
+      { id: "S02", done: true, depends: ["S01"] },
+      { id: "S03", done: true, depends: ["S02"] },
+    ];
+    const completed = new Set(["S01", "S02", "S03"]);
+    const result = getEligibleSlices(slices, completed);
+    assert.equal(result.length, 0);
+  });
+
+  it("empty input: empty result", () => {
+    const result = getEligibleSlices([], new Set());
+    assert.equal(result.length, 0);
+  });
+
+  it("mixed deps and no-deps: only dep-satisfied slices with explicit deps are eligible alongside positional", () => {
+    const slices = [
+      { id: "S01", done: true, depends: [] },
+      { id: "S02", done: false, depends: ["S01"] },  // explicit dep satisfied
+      { id: "S03", done: false, depends: [] },         // no deps, positional fallback
+      { id: "S04", done: false, depends: ["S01"] },  // explicit dep satisfied
+    ];
+    const completed = new Set(["S01"]);
+    const result = getEligibleSlices(slices, completed);
+    const ids = result.map(s => s.id);
+    // S02 and S04 have explicit deps satisfied; S03 has no deps but
+    // positionally S02 (before it) is not done, so S03 is blocked by positional rule
+    assert.ok(ids.includes("S02"), "S02 should be eligible (dep on S01 satisfied)");
+    assert.ok(ids.includes("S04"), "S04 should be eligible (dep on S01 satisfied)");
+  });
+
+  it("unsatisfied dependency blocks slice", () => {
+    const slices = [
+      { id: "S01", done: false, depends: [] },
+      { id: "S02", done: false, depends: ["S01"] },
+    ];
+    const completed = new Set<string>();
+    const result = getEligibleSlices(slices, completed);
+    // S01 has no deps and is first → eligible by positional
+    // S02 depends on S01 which is not completed → blocked
+    assert.equal(result.length, 1);
+    assert.equal(result[0].id, "S01");
+  });
+});

package/src/resources/extensions/gsd/tests/slice-parallel-orchestrator.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Structural tests for slice-level parallel orchestrator.
+ * Verifies the orchestrator module exists and has the correct shape,
+ * env var usage, and preference gating.
+ */
+
+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("slice-parallel-orchestrator structural tests", () => {
+  it("orchestrator uses GSD_SLICE_LOCK env var", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes("GSD_SLICE_LOCK"),
+      "Orchestrator must use GSD_SLICE_LOCK env var to isolate slice workers",
+    );
+  });
+
+  it("orchestrator sets GSD_PARALLEL_WORKER=1 to prevent nesting", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes("GSD_PARALLEL_WORKER"),
+      "Orchestrator must set GSD_PARALLEL_WORKER to prevent nested parallel",
+    );
+  });
+
+  it("maxWorkers default is 2", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    // Check that default max workers is 2 (in opts.maxWorkers ?? 2 or similar)
+    assert.ok(
+      source.includes("maxWorkers") && source.includes("2"),
+      "Default maxWorkers should be 2",
+    );
+  });
+
+  it("orchestrator imports GSD_MILESTONE_LOCK for milestone isolation", () => {
+    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
+    assert.ok(
+      source.includes("GSD_MILESTONE_LOCK"),
+      "Orchestrator must also pass GSD_MILESTONE_LOCK for milestone context",
+    );
+  });
+});
+
+describe("slice_parallel preference gating", () => {
+  it("preferences-types.ts includes slice_parallel in interface", () => {
+    const source = readFileSync(join(gsdDir, "preferences-types.ts"), "utf-8");
+    assert.ok(
+      source.includes("slice_parallel"),
+      "GSDPreferences should have slice_parallel field",
+    );
+  });
+
+  it("slice_parallel is in KNOWN_PREFERENCE_KEYS", () => {
+    const source = readFileSync(join(gsdDir, "preferences-types.ts"), "utf-8");
+    assert.ok(
+      source.includes('"slice_parallel"'),
+      'KNOWN_PREFERENCE_KEYS should include "slice_parallel"',
+    );
+  });
+
+  it("state.ts checks GSD_SLICE_LOCK for slice isolation", () => {
+    const source = readFileSync(join(gsdDir, "state.ts"), "utf-8");
+    assert.ok(
+      source.includes("GSD_SLICE_LOCK"),
+      "State derivation should check GSD_SLICE_LOCK for slice-level parallel isolation",
+    );
+  });
+
+  it("auto.ts imports slice parallel orchestrator when enabled", () => {
+    const source = readFileSync(join(gsdDir, "auto.ts"), "utf-8");
+    assert.ok(
+      source.includes("slice_parallel") || source.includes("slice-parallel"),
+      "auto.ts should reference slice_parallel for dispatch gating",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/tool-invocation-error-loop-break.test.ts

@@ -0,0 +1,103 @@
+/**
+ * Regression tests for #2883: gsd_complete_slice tool invocation fails with
+ * JSON truncation, causing stuck retry loop.
+ *
+ * When a GSD tool is invoked with malformed/truncated JSON arguments, the tool
+ * execution fails (isError: true). But postUnitPreVerification only checks if
+ * the expected artifact exists on disk — it does not know the tool itself failed.
+ * When the artifact is missing (because the tool never ran), it sets up
+ * pendingVerificationRetry, re-dispatching the same unit with the same truncated
+ * input, creating a stuck loop.
+ *
+ * The fix adds a `lastToolInvocationError` field to AutoSession. When a GSD tool
+ * execution ends with isError, the error is recorded. postUnitPreVerification
+ * checks this field before retrying — if a tool invocation error occurred, it
+ * pauses auto-mode instead of retrying.
+ */
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { AutoSession } from "../auto/session.ts";
+
+// ─── AutoSession.lastToolInvocationError field ───────────────────────────
+
+describe("#2883: tool invocation error tracking on AutoSession", () => {
+  test("lastToolInvocationError defaults to null", () => {
+    const s = new AutoSession();
+    assert.equal(s.lastToolInvocationError, null);
+  });
+
+  test("lastToolInvocationError is cleared on reset()", () => {
+    const s = new AutoSession();
+    s.lastToolInvocationError = "Validation failed for tool gsd_complete_slice";
+    assert.ok(s.lastToolInvocationError);
+    s.reset();
+    assert.equal(s.lastToolInvocationError, null);
+  });
+
+  test("lastToolInvocationError can store truncated JSON error", () => {
+    const s = new AutoSession();
+    const errorMsg = "Expected ',' or '}' in JSON at position 4096";
+    s.lastToolInvocationError = errorMsg;
+    assert.equal(s.lastToolInvocationError, errorMsg);
+  });
+});
+
+// ─── isToolInvocationError classifier ────────────────────────────────────
+
+import { isToolInvocationError } from "../auto-tool-tracking.ts";
+
+describe("#2883: isToolInvocationError classification", () => {
+  test("detects JSON validation failure pattern", () => {
+    assert.equal(
+      isToolInvocationError("Validation failed for tool gsd_complete_slice: Expected ',' or '}' in JSON"),
+      true,
+    );
+  });
+
+  test("detects truncated JSON parse error", () => {
+    assert.equal(
+      isToolInvocationError("Expected ',' or '}' in JSON at position 4096"),
+      true,
+    );
+  });
+
+  test("detects Unexpected end of JSON input", () => {
+    assert.equal(
+      isToolInvocationError("Unexpected end of JSON input"),
+      true,
+    );
+  });
+
+  test("detects Unexpected token in JSON", () => {
+    assert.equal(
+      isToolInvocationError("Unexpected token < in JSON at position 0"),
+      true,
+    );
+  });
+
+  test("detects 'Validation failed for tool' prefix", () => {
+    assert.equal(
+      isToolInvocationError("Validation failed for tool gsd_slice_complete"),
+      true,
+    );
+  });
+
+  test("returns false for normal tool errors (business logic)", () => {
+    assert.equal(
+      isToolInvocationError("Slice S01 is already complete"),
+      false,
+    );
+  });
+
+  test("returns false for empty string", () => {
+    assert.equal(isToolInvocationError(""), false);
+  });
+
+  test("returns false for generic error", () => {
+    assert.equal(isToolInvocationError("Something went wrong"), false);
+  });
+
+  test("returns false for network errors (handled elsewhere)", () => {
+    assert.equal(isToolInvocationError("ECONNRESET"), false);
+  });
+});