gsd-pi 2.76.0-dev.82e249f7b → 2.76.0-dev.97807402

package/src/resources/extensions/gsd/tests/ready-phrase-no-files-4573.test.ts

@@ -0,0 +1,388 @@
+/**
+ * GSD-2 / guided-flow — regression tests for #4573
+ *
+ * Covers two recovery paths:
+ *   - maybeHandleReadyPhraseWithoutFiles: nudge when LLM emits
+ *     "Milestone M001 ready." without writing CONTEXT.md / ROADMAP.md
+ *   - maybeHandleEmptyIntentTurn: nudge when LLM narrates intent but
+ *     emits no tool-use blocks
+ */
+
+import { describe, test, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  setPendingAutoStart,
+  clearPendingAutoStart,
+  maybeHandleReadyPhraseWithoutFiles,
+  maybeHandleEmptyIntentTurn,
+  resetEmptyTurnCounter,
+} from "../guided-flow.ts";
+
+// ─── Test harness ──────────────────────────────────────────────────────────
+
+interface MockCapture {
+  notifies: Array<{ msg: string; level: string }>;
+  messages: Array<{ payload: any; options: any }>;
+}
+
+function mkCapture(): MockCapture {
+  return { notifies: [], messages: [] };
+}
+
+function mkCtx(cap: MockCapture): any {
+  return {
+    ui: {
+      notify: (msg: string, level: string) => {
+        cap.notifies.push({ msg, level });
+      },
+    },
+  };
+}
+
+function mkPi(cap: MockCapture, opts: { sendThrows?: boolean } = {}): any {
+  return {
+    sendMessage: (payload: any, options: any) => {
+      if (opts.sendThrows) throw new Error("send failed");
+      cap.messages.push({ payload, options });
+    },
+    setActiveTools: () => undefined,
+    getActiveTools: () => [],
+  };
+}
+
+function mkBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-4573-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  return base;
+}
+
+function assistantMsg(text: string, opts: { toolUse?: boolean } = {}): any {
+  const content: any[] = [];
+  if (text) content.push({ type: "text", text });
+  if (opts.toolUse) content.push({ type: "tool_use", name: "whatever", input: {} });
+  return { role: "assistant", content };
+}
+
+// ─── ready-phrase recovery (Layer 2) ───────────────────────────────────────
+
+describe("#4573 maybeHandleReadyPhraseWithoutFiles", () => {
+  beforeEach(() => {
+    clearPendingAutoStart();
+    resetEmptyTurnCounter();
+  });
+
+  test("no pending entry → no-op", () => {
+    const cap = mkCapture();
+    const event = { messages: [assistantMsg("Milestone M001 ready.")] };
+    const handled = maybeHandleReadyPhraseWithoutFiles(event);
+    assert.equal(handled, false);
+    assert.equal(cap.messages.length, 0);
+  });
+
+  test("pending entry, ready phrase, no files → notify + sendMessage", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleReadyPhraseWithoutFiles({
+        messages: [assistantMsg("Milestone M001 ready.")],
+      });
+      assert.equal(handled, true);
+      assert.equal(cap.messages.length, 1);
+      assert.equal(cap.messages[0].payload.customType, "gsd-ready-no-files");
+      assert.equal(cap.messages[0].options.triggerTurn, true);
+      assert.ok(
+        cap.notifies.some((n) => /rejected/.test(n.msg)),
+        "user notified about rejection",
+      );
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("retry cap — after MAX_READY_REJECTS the nudge stops and entry clears", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const event = { messages: [assistantMsg("Milestone M001 ready.")] };
+
+      const first = maybeHandleReadyPhraseWithoutFiles(event);
+      const second = maybeHandleReadyPhraseWithoutFiles(event);
+      const third = maybeHandleReadyPhraseWithoutFiles(event); // > MAX
+
+      assert.equal(first, true);
+      assert.equal(second, true);
+      assert.equal(third, true); // still returns true (handled via give-up)
+      assert.equal(cap.messages.length, 2, "only 2 nudges sent (MAX_READY_REJECTS=2)");
+      assert.ok(
+        cap.notifies.some((n) => /Stopping auto-nudge/.test(n.msg)),
+        "gives up with error notify",
+      );
+
+      // After giving up, a fresh re-entry starts clean
+      const fourth = maybeHandleReadyPhraseWithoutFiles(event);
+      assert.equal(fourth, false, "pending entry was cleared — nothing to handle");
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("files present → no nudge (happy path already fired)", () => {
+    const base = mkBase();
+    try {
+      writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# ctx");
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleReadyPhraseWithoutFiles({
+        messages: [assistantMsg("Milestone M001 ready.")],
+      });
+      assert.equal(handled, false);
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("last message lacks ready phrase → no-op", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleReadyPhraseWithoutFiles({
+        messages: [assistantMsg("Let me think about the slices first.")],
+      });
+      assert.equal(handled, false);
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("fresh entry after give-up resets counter", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      // First cycle: exhaust cap
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const event = { messages: [assistantMsg("Milestone M001 ready.")] };
+      maybeHandleReadyPhraseWithoutFiles(event);
+      maybeHandleReadyPhraseWithoutFiles(event);
+      maybeHandleReadyPhraseWithoutFiles(event); // clears entry
+
+      // New /gsd run — re-seeds entry; counter must be 0 again
+      cap.messages.length = 0;
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleReadyPhraseWithoutFiles(event);
+      assert.equal(handled, true);
+      assert.equal(cap.messages.length, 1, "fresh entry fires nudge again");
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+});
+
+// ─── empty-turn recovery (Layer 3) ────────────────────────────────────────
+
+describe("#4573 maybeHandleEmptyIntentTurn", () => {
+  beforeEach(() => {
+    clearPendingAutoStart();
+    resetEmptyTurnCounter();
+  });
+
+  test("no pending entry + isAuto false → no-op (interactive discuss is user-driven)", () => {
+    const event = { messages: [assistantMsg("I'll write the CONTEXT.md now.")] };
+    const handled = maybeHandleEmptyIntentTurn(event, false);
+    assert.equal(handled, false);
+  });
+
+  test("text-only turn WITHOUT commit phrase → not flagged (legitimate text)", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg("Here is the roadmap preview — three slices.")] },
+        false,
+      );
+      assert.equal(handled, false);
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("text-only turn ending in question → treated as user-handoff, not flagged", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg("Ready to write, or want to adjust?")] },
+        false,
+      );
+      assert.equal(handled, false);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("commit-intent phrase WITHOUT tool call → nudge fires", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg("I'll now write the CONTEXT.md file.")] },
+        false,
+      );
+      assert.equal(handled, true);
+      assert.equal(cap.messages.length, 1);
+      assert.equal(cap.messages[0].payload.customType, "gsd-empty-turn-recovery");
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("commit-intent WITH tool-use block → not flagged", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg("I'll write the file now.", { toolUse: true })] },
+        false,
+      );
+      assert.equal(handled, false);
+      assert.equal(cap.messages.length, 0);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("ready phrase is NOT treated as empty-turn (handled by other recovery path)", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const handled = maybeHandleEmptyIntentTurn(
+        { messages: [assistantMsg("Milestone M001 ready.")] },
+        false,
+      );
+      assert.equal(handled, false);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("empty-turn retry cap — stops after MAX_EMPTY_TURN_RETRIES", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const event = { messages: [assistantMsg("I'll write the CONTEXT.md file.")] };
+
+      maybeHandleEmptyIntentTurn(event, false); // 1
+      maybeHandleEmptyIntentTurn(event, false); // 2
+      const third = maybeHandleEmptyIntentTurn(event, false); // > cap
+
+      assert.equal(cap.messages.length, 2, "only 2 nudges sent");
+      assert.equal(third, false, "after cap, no further injection");
+      assert.ok(
+        cap.notifies.some((n) => /Stopping auto-nudge/.test(n.msg)),
+        "user notified of give-up",
+      );
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+
+  test("resetEmptyTurnCounter clears state after a successful tool-use turn", () => {
+    const base = mkBase();
+    try {
+      const cap = mkCapture();
+      setPendingAutoStart(base, {
+        basePath: base,
+        milestoneId: "M001",
+        ctx: mkCtx(cap),
+        pi: mkPi(cap),
+      });
+      const event = { messages: [assistantMsg("I'll write the CONTEXT.md file.")] };
+
+      maybeHandleEmptyIntentTurn(event, false); // 1
+      maybeHandleEmptyIntentTurn(event, false); // 2 — at cap
+      resetEmptyTurnCounter(); // simulate a successful tool-use turn in between
+
+      cap.messages.length = 0;
+      const after = maybeHandleEmptyIntentTurn(event, false);
+      assert.equal(after, true, "counter reset — nudge fires again");
+      assert.equal(cap.messages.length, 1);
+    } finally {
+      clearPendingAutoStart();
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/restore-tools-after-discuss.test.ts

@@ -45,9 +45,15 @@ describe('restore tools after discuss flow scoping (#3628)', () => {
   })
 
   it('savedTools is restored after sendMessage', () => {
-    // Find the sendMessage call
-    const sendMsg = src.indexOf('triggerTurn: true')
-    assert.ok(sendMsg !== -1, 'sendMessage with triggerTurn must exist')
+    // #4573: guided-flow.ts now contains multiple `triggerTurn: true` calls
+    // (ready-phrase and empty-turn recovery paths). The discuss-flow scoping
+    // sendMessage is the one that follows `savedTools = currentTools`, so
+    // anchor the search there rather than at the first `triggerTurn: true`.
+    const savedToolsAssign = src.indexOf('savedTools = currentTools')
+    assert.ok(savedToolsAssign !== -1, 'savedTools = currentTools must exist')
+
+    const sendMsg = src.indexOf('triggerTurn: true', savedToolsAssign)
+    assert.ok(sendMsg !== -1, 'discuss-flow sendMessage with triggerTurn must exist after savedTools capture')
 
     // After sendMessage, savedTools should be restored via setActiveTools
     const afterSend = src.slice(sendMsg, sendMsg + 500)

package/src/resources/extensions/gsd/tests/save-gate-result-render.test.ts

@@ -0,0 +1,95 @@
+/**
+ * Regression test suite for save_gate_result renderResult.
+ *
+ * Verifies that renderResult does not print "undefined: undefined" when
+ * `details` is empty, and that the error fallback does not produce a
+ * duplicated `Error: Error:` prefix when `content[0].text` already starts
+ * with `Error:`.
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { registerDbTools } from '../bootstrap/db-tools.ts';
+
+function makeMockPi() {
+  const tools: any[] = [];
+  return {
+    registerTool: (tool: any) => tools.push(tool),
+    tools,
+  } as any;
+}
+
+const fakeTheme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+function getSaveGateResultTool() {
+  const pi = makeMockPi();
+  registerDbTools(pi);
+  const tool = pi.tools.find((t: any) => t.name === 'gsd_save_gate_result');
+  assert.ok(tool, 'gsd_save_gate_result should be registered');
+  return tool;
+}
+
+test('save_gate_result renderResult falls back to content text when details is empty', () => {
+  const tool = getSaveGateResultTool();
+  const result = {
+    content: [{ type: 'text', text: 'Gate Q3 result saved: verdict=pass' }],
+    details: {},
+    isError: false,
+  };
+  const rendered = tool.renderResult(result, {}, fakeTheme);
+  const text = String(rendered.content ?? rendered.text ?? rendered);
+  assert.ok(!text.includes('undefined'), `got: ${text}`);
+  assert.ok(
+    text.includes('Gate Q3') || text.includes('verdict=pass'),
+    `expected content summary — got: ${text}`,
+  );
+});
+
+test('save_gate_result renderResult uses structured details when present', () => {
+  const tool = getSaveGateResultTool();
+  const result = {
+    content: [{ type: 'text', text: 'Gate Q3 result saved: verdict=flag' }],
+    details: { operation: 'save_gate_result', gateId: 'Q3', verdict: 'flag' },
+    isError: false,
+  };
+  const rendered = tool.renderResult(result, {}, fakeTheme);
+  const text = String(rendered.content ?? rendered.text ?? rendered);
+  assert.ok(text.includes('Q3'), `got: ${text}`);
+  assert.ok(text.includes('flag'), `got: ${text}`);
+  assert.ok(!text.includes('undefined'), `got: ${text}`);
+});
+
+test('save_gate_result renderResult shows error from content when details.error is missing', () => {
+  const tool = getSaveGateResultTool();
+  const result = {
+    content: [{ type: 'text', text: 'Error: Invalid gateId "Z1"' }],
+    details: {},
+    isError: true,
+  };
+  const rendered = tool.renderResult(result, {}, fakeTheme);
+  const text = String(rendered.content ?? rendered.text ?? rendered);
+  assert.ok(
+    text.includes('Invalid gateId') || text.includes('Error'),
+    `got: ${text}`,
+  );
+  assert.ok(!text.includes('undefined'), `got: ${text}`);
+});
+
+test('save_gate_result renderResult does not duplicate Error: prefix', () => {
+  const tool = getSaveGateResultTool();
+  const result = {
+    content: [{ type: 'text', text: 'Error: Invalid gateId "Z1"' }],
+    details: {},
+    isError: true,
+  };
+  const rendered = tool.renderResult(result, {}, fakeTheme);
+  const text = String(rendered.content ?? rendered.text ?? rendered);
+  assert.ok(
+    !/Error:\s*Error:/i.test(text),
+    `expected a single Error: prefix — got: ${text}`,
+  );
+  assert.ok(text.includes('Invalid gateId'), `got: ${text}`);
+});

package/src/resources/extensions/gsd/tests/session-start-footer.test.ts

@@ -1,19 +1,15 @@
 /**
  * session-start-footer.test.ts
  *
- * Verifies that register-hooks.ts suppresses the built-in footer by calling
- * ctx.ui.setFooter(hideFooter) in both session_start and session_switch when
- * isAutoActive() is true.
+ * Verifies that register-hooks.ts suppresses the gsd-health widget (not the
+ * built-in footer) when isAutoActive() is true, and that setFooter is never
+ * called by the extension in either session_start or session_switch.
  *
  * Testing strategy:
- *   Two layers:
- *   1. Source-code regression guard: ensures the guard and setFooter call are
- *      structurally present in register-hooks.ts for both event handlers.
- *      (node:test does not support mock.module without --experimental-test-module-mocks,
- *       so structural analysis is the correct approach here.)
+ *   1. Source-code regression guards: structural checks on register-hooks.ts.
  *   2. Behavioral integration test: fires the live session_start handler with a
- *      fake ctx when isAutoActive() is false (its default at test time) and
- *      confirms setFooter is NOT called — verifying the guard is conditional.
+ *      fake ctx when isAutoActive() is false (default) and confirms neither
+ *      setFooter nor setWidget("gsd-health") is called.
  *
  * Relates to #4314.
  */
@@ -35,16 +31,14 @@ const HOOKS_SOURCE = readFileSync(
 
 // ─── Source-code regression guards ──────────────────────────────────────────
 
-test("register-hooks.ts imports hideFooter from auto-dashboard", () => {
+test("register-hooks.ts does NOT import hideFooter", () => {
   assert.ok(
-    HOOKS_SOURCE.includes('import { hideFooter } from "../auto-dashboard.js"') ||
-    HOOKS_SOURCE.includes("import { hideFooter } from '../auto-dashboard.js'"),
-    "register-hooks.ts must import hideFooter from auto-dashboard.js",
+    !HOOKS_SOURCE.includes("hideFooter"),
+    "register-hooks.ts must not reference hideFooter — footer is no longer swapped in auto mode",
   );
 });
 
-test("session_start handler calls ctx.ui.setFooter(hideFooter) when isAutoActive()", () => {
-  // Locate the session_start handler body (up to the next pi.on call)
+test("session_start handler guards initHealthWidget with !isAutoActive()", () => {
   const sessionStartIdx = HOOKS_SOURCE.indexOf('"session_start"');
   assert.ok(sessionStartIdx > -1, "session_start handler must exist");
 
@@ -58,20 +52,23 @@ test("session_start handler calls ctx.ui.setFooter(hideFooter) when isAutoActive
     "session_start handler must call isAutoActive()",
   );
   assert.ok(
-    sessionStartBody.includes("ctx.ui.setFooter(hideFooter)"),
-    "session_start handler must call ctx.ui.setFooter(hideFooter)",
+    sessionStartBody.includes("initHealthWidget"),
+    "session_start handler must reference initHealthWidget",
+  );
+  assert.ok(
+    !sessionStartBody.includes("setFooter"),
+    "session_start handler must NOT call setFooter",
   );
 
-  // Guard must wrap the setFooter call
   const guardIdx = sessionStartBody.indexOf("isAutoActive()");
-  const setFooterIdx = sessionStartBody.indexOf("ctx.ui.setFooter(hideFooter)");
+  const healthIdx = sessionStartBody.indexOf("initHealthWidget");
   assert.ok(
-    guardIdx < setFooterIdx,
-    "isAutoActive() guard must appear before ctx.ui.setFooter(hideFooter) in session_start",
+    guardIdx < healthIdx,
+    "isAutoActive() guard must appear before initHealthWidget in session_start",
   );
 });
 
-test("session_switch handler calls ctx.ui.setFooter(hideFooter) when isAutoActive()", () => {
+test("session_switch handler suppresses gsd-health when isAutoActive()", () => {
   const sessionSwitchIdx = HOOKS_SOURCE.indexOf('"session_switch"');
   assert.ok(sessionSwitchIdx > -1, "session_switch handler must exist");
 
@@ -85,21 +82,18 @@ test("session_switch handler calls ctx.ui.setFooter(hideFooter) when isAutoActiv
     "session_switch handler must call isAutoActive()",
   );
   assert.ok(
-    sessionSwitchBody.includes("ctx.ui.setFooter(hideFooter)"),
-    "session_switch handler must call ctx.ui.setFooter(hideFooter)",
+    sessionSwitchBody.includes('setWidget("gsd-health", undefined)'),
+    "session_switch handler must call setWidget(\"gsd-health\", undefined) when auto is active",
   );
-
-  const guardIdx = sessionSwitchBody.indexOf("isAutoActive()");
-  const setFooterIdx = sessionSwitchBody.indexOf("ctx.ui.setFooter(hideFooter)");
   assert.ok(
-    guardIdx < setFooterIdx,
-    "isAutoActive() guard must appear before ctx.ui.setFooter(hideFooter) in session_switch",
+    !sessionSwitchBody.includes("setFooter"),
+    "session_switch handler must NOT call setFooter",
   );
 });
 
-// ─── Behavioral test: setFooter NOT called when auto-mode is inactive ────────
+// ─── Behavioral test: neither setFooter nor health suppression when auto inactive ─
 
-test("session_start does NOT call setFooter when isAutoActive() is false (default)", async (t) => {
+test("session_start does NOT call setFooter or suppress gsd-health when isAutoActive() is false", async (t) => {
   const dir = join(
     tmpdir(),
     `gsd-footer-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
@@ -114,6 +108,7 @@ test("session_start does NOT call setFooter when isAutoActive() is false (defaul
   });
 
   let setFooterCallCount = 0;
+  let healthWidgetHideCount = 0;
 
   const handlers = new Map<string, (event: unknown, ctx: any) => Promise<void> | void>();
   const pi = {
@@ -137,17 +132,14 @@ test("session_start does NOT call setFooter when isAutoActive() is false (defaul
       },
       setWorkingMessage: () => {},
       onTerminalInput: () => () => {},
-      setWidget: () => {},
+      setWidget: (key: string, value: unknown) => {
+        if (key === "gsd-health" && value === undefined) healthWidgetHideCount++;
+      },
     },
     sessionManager: { getSessionId: () => null },
     model: null,
   } as any);
 
-  // isAutoActive() is false at test time (no auto session started),
-  // so setFooter must not be called.
-  assert.equal(
-    setFooterCallCount,
-    0,
-    "setFooter must NOT be called when isAutoActive() returns false",
-  );
+  assert.equal(setFooterCallCount, 0, "setFooter must NOT be called when isAutoActive() is false");
+  assert.equal(healthWidgetHideCount, 0, "gsd-health must NOT be hidden when isAutoActive() is false");
 });