lsd-pi 1.0.0 → 1.1.1

package/src/resources/extensions/gsd/tests/dev-engine-wrapper.test.ts

@@ -1,314 +0,0 @@
-/**
- * dev-engine-wrapper.test.ts — Contract tests for the dev engine wrapper layer (S02).
- *
- * Tests bridgeDispatchAction mapping, DevWorkflowEngine delegation,
- * DevExecutionPolicy stubs, resolver routing, kill switch, and
- * auto.ts engine ID accessors.
- */
-
-import test, { describe, before, after } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-// ── bridgeDispatchAction mapping ────────────────────────────────────────────
-
-describe("bridgeDispatchAction", () => {
-  test("maps dispatch action with step fields", async () => {
-    const { bridgeDispatchAction } = await import(
-      "../dev-workflow-engine.ts"
-    );
-    const result = bridgeDispatchAction({
-      action: "dispatch",
-      unitType: "execute-task",
-      unitId: "T01",
-      prompt: "do stuff",
-      matchedRule: "foo",
-    } as any);
-
-    assert.equal(result.action, "dispatch");
-    assert.ok("step" in result);
-    const step = (result as any).step;
-    assert.equal(step.unitType, "execute-task");
-    assert.equal(step.unitId, "T01");
-    assert.equal(step.prompt, "do stuff");
-  });
-
-  test("maps stop action with reason and level", async () => {
-    const { bridgeDispatchAction } = await import(
-      "../dev-workflow-engine.ts"
-    );
-    const result = bridgeDispatchAction({
-      action: "stop",
-      reason: "done",
-      level: "info",
-      matchedRule: "bar",
-    } as any);
-
-    assert.equal(result.action, "stop");
-    assert.equal((result as any).reason, "done");
-    assert.equal((result as any).level, "info");
-  });
-
-  test("maps skip action", async () => {
-    const { bridgeDispatchAction } = await import(
-      "../dev-workflow-engine.ts"
-    );
-    const result = bridgeDispatchAction({
-      action: "skip",
-      matchedRule: "baz",
-    } as any);
-
-    assert.equal(result.action, "skip");
-  });
-});
-
-// ── DevWorkflowEngine ───────────────────────────────────────────────────────
-
-describe("DevWorkflowEngine", () => {
-  test("engineId is 'dev'", async () => {
-    const { DevWorkflowEngine } = await import("../dev-workflow-engine.ts");
-    const engine = new DevWorkflowEngine();
-    assert.equal(engine.engineId, "dev");
-  });
-
-  test("deriveState returns EngineState with expected fields", async (t) => {
-    const { DevWorkflowEngine } = await import("../dev-workflow-engine.ts");
-    const engine = new DevWorkflowEngine();
-
-    // Create a minimal temp .gsd structure for deriveState
-    const tempDir = mkdtempSync(join(tmpdir(), "gsd-engine-test-"));
-    mkdirSync(join(tempDir, ".gsd", "milestones"), { recursive: true });
-
-    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
-
-    const state = await engine.deriveState(tempDir);
-
-    assert.equal(typeof state.phase, "string", "phase should be a string");
-    assert.ok(
-      "currentMilestoneId" in state,
-      "state should have currentMilestoneId",
-    );
-    assert.ok(
-      "activeSliceId" in state,
-      "state should have activeSliceId",
-    );
-    assert.ok(
-      "activeTaskId" in state,
-      "state should have activeTaskId",
-    );
-    assert.equal(
-      typeof state.isComplete,
-      "boolean",
-      "isComplete should be boolean",
-    );
-    assert.ok("raw" in state, "state should have raw field");
-  });
-
-  test("reconcile returns continue for non-complete state", async () => {
-    const { DevWorkflowEngine } = await import("../dev-workflow-engine.ts");
-    const engine = new DevWorkflowEngine();
-
-    const state = {
-      phase: "executing",
-      currentMilestoneId: "M001",
-      activeSliceId: "S01",
-      activeTaskId: "T01",
-      isComplete: false,
-      raw: {},
-    };
-
-    const result = await engine.reconcile(state, {
-      unitType: "execute-task",
-      unitId: "T01",
-      startedAt: Date.now() - 1000,
-      finishedAt: Date.now(),
-    });
-
-    assert.equal(result.outcome, "continue");
-  });
-
-  test("reconcile returns milestone-complete for complete state", async () => {
-    const { DevWorkflowEngine } = await import("../dev-workflow-engine.ts");
-    const engine = new DevWorkflowEngine();
-
-    const state = {
-      phase: "complete",
-      currentMilestoneId: "M001",
-      activeSliceId: null,
-      activeTaskId: null,
-      isComplete: true,
-      raw: {},
-    };
-
-    const result = await engine.reconcile(state, {
-      unitType: "execute-task",
-      unitId: "T01",
-      startedAt: Date.now() - 1000,
-      finishedAt: Date.now(),
-    });
-
-    assert.equal(result.outcome, "milestone-complete");
-  });
-
-  test("getDisplayMetadata returns expected fields", async () => {
-    const { DevWorkflowEngine } = await import("../dev-workflow-engine.ts");
-    const engine = new DevWorkflowEngine();
-
-    const state = {
-      phase: "executing",
-      currentMilestoneId: "M001",
-      activeSliceId: "S01",
-      activeTaskId: "T01",
-      isComplete: false,
-      raw: {},
-    };
-
-    const meta = engine.getDisplayMetadata(state);
-
-    assert.ok("engineLabel" in meta, "should have engineLabel");
-    assert.ok("currentPhase" in meta, "should have currentPhase");
-    assert.ok("progressSummary" in meta, "should have progressSummary");
-    assert.ok("stepCount" in meta, "should have stepCount");
-    assert.equal(meta.engineLabel, "GSD Dev");
-  });
-});
-
-// ── DevExecutionPolicy stubs ────────────────────────────────────────────────
-
-describe("DevExecutionPolicy", () => {
-  test("verify returns 'continue'", async () => {
-    const { DevExecutionPolicy } = await import(
-      "../dev-execution-policy.ts"
-    );
-    const policy = new DevExecutionPolicy();
-    const result = await policy.verify("execute-task", "T01", {
-      basePath: "/tmp",
-    });
-    assert.equal(result, "continue");
-  });
-
-  test("selectModel returns null", async () => {
-    const { DevExecutionPolicy } = await import(
-      "../dev-execution-policy.ts"
-    );
-    const policy = new DevExecutionPolicy();
-    const result = await policy.selectModel("execute-task", "T01", {
-      basePath: "/tmp",
-    });
-    assert.equal(result, null);
-  });
-
-  test("recover returns { outcome: 'retry' }", async () => {
-    const { DevExecutionPolicy } = await import(
-      "../dev-execution-policy.ts"
-    );
-    const policy = new DevExecutionPolicy();
-    const result = await policy.recover("execute-task", "T01", {
-      basePath: "/tmp",
-    });
-    assert.deepEqual(result, { outcome: "retry" });
-  });
-
-  test("closeout returns { committed: false, artifacts: [] }", async () => {
-    const { DevExecutionPolicy } = await import(
-      "../dev-execution-policy.ts"
-    );
-    const policy = new DevExecutionPolicy();
-    const result = await policy.closeout("execute-task", "T01", {
-      basePath: "/tmp",
-      startedAt: Date.now(),
-    });
-    assert.deepEqual(result, { committed: false, artifacts: [] });
-  });
-
-  test("prepareWorkspace resolves without error", async () => {
-    const { DevExecutionPolicy } = await import(
-      "../dev-execution-policy.ts"
-    );
-    const policy = new DevExecutionPolicy();
-    await assert.doesNotReject(
-      () => policy.prepareWorkspace("/tmp", "M001"),
-      "prepareWorkspace should resolve without error",
-    );
-  });
-});
-
-// ── Resolver routing ────────────────────────────────────────────────────────
-
-describe("Resolver routing", () => {
-  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");
-    assert.ok(result.policy, "should return policy");
-    assert.equal(result.engine.engineId, "dev");
-  });
-
-  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");
-    assert.ok(result.policy, "should return policy");
-    assert.equal(result.engine.engineId, "dev");
-  });
-
-  test("resolveEngine throws for unknown activeEngineId without activeRunDir", async () => {
-    const { resolveEngine } = await import("../engine-resolver.ts");
-    assert.throws(
-      () => resolveEngine({ activeEngineId: "unknown" }),
-      /requires activeRunDir/,
-      "should throw when activeRunDir is missing for non-dev engine",
-    );
-  });
-});
-
-// ── Kill switch ─────────────────────────────────────────────────────────────
-
-describe("Kill switch (GSD_ENGINE_BYPASS)", () => {
-  const originalBypass = process.env.GSD_ENGINE_BYPASS;
-
-  after(() => {
-    // Restore original env var state
-    if (originalBypass === undefined) {
-      delete process.env.GSD_ENGINE_BYPASS;
-    } else {
-      process.env.GSD_ENGINE_BYPASS = originalBypass;
-    }
-  });
-
-  test("GSD_ENGINE_BYPASS=1 does not affect resolveEngine (bypass checked in autoLoop)", async (t) => {
-    const { resolveEngine } = await import("../engine-resolver.ts");
-    process.env.GSD_ENGINE_BYPASS = "1";
-    t.after(() => delete process.env.GSD_ENGINE_BYPASS);
-
-    // resolveEngine should still resolve normally — bypass is checked in autoLoop
-    const { engine } = resolveEngine({ activeEngineId: null });
-    assert.ok(engine, "should return an engine even with bypass set");
-  });
-});
-
-// ── auto.ts engine ID accessors ─────────────────────────────────────────────
-
-describe("auto.ts engine ID accessors", () => {
-  test("setActiveEngineId / getActiveEngineId round-trip", async () => {
-    const { setActiveEngineId, getActiveEngineId } = await import(
-      "../auto.ts"
-    );
-
-    setActiveEngineId("dev");
-    assert.equal(
-      getActiveEngineId(),
-      "dev",
-      "getActiveEngineId should return 'dev' after setting",
-    );
-
-    setActiveEngineId(null);
-    assert.equal(
-      getActiveEngineId(),
-      null,
-      "getActiveEngineId should return null after setting null",
-    );
-  });
-});

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

@@ -1,136 +0,0 @@
-/**
- * Unit tests for diff-context.ts — diff-aware context module.
- * Tests git-based file discovery and relevance ranking.
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { tmpdir } from "node:os";
-import { mkdtempSync } from "node:fs";
-import { join } from "node:path";
-
-import {
-  getRecentlyChangedFiles,
-  getChangedFilesWithContext,
-  rankFilesByRelevance,
-} from "../diff-context.js";
-
-// ─── getRecentlyChangedFiles ────────────────────────────────────────────────
-
-describe("diff-context: getRecentlyChangedFiles", () => {
-  it("returns an array of file paths in the current git repo", async () => {
-    // Use the project root — guaranteed to be a git repo
-    const cwd = process.cwd();
-    const files = await getRecentlyChangedFiles(cwd);
-
-    assert.ok(Array.isArray(files), "should return an array");
-    // The result may be empty if the repo is totally clean with no recent
-    // commits, but the function should not throw.
-  });
-
-  it("respects maxFiles option", async () => {
-    const cwd = process.cwd();
-    const files = await getRecentlyChangedFiles(cwd, { maxFiles: 3 });
-
-    assert.ok(files.length <= 3, "should not exceed maxFiles");
-  });
-
-  it("returns empty array for non-git directory", async () => {
-    const tmp = mkdtempSync(join(tmpdir(), "diff-ctx-test-"));
-    const files = await getRecentlyChangedFiles(tmp);
-
-    assert.deepStrictEqual(files, [], "should return empty array for non-git dir");
-  });
-
-  it("returns deduplicated paths", async () => {
-    const cwd = process.cwd();
-    const files = await getRecentlyChangedFiles(cwd, { maxFiles: 100 });
-    const unique = new Set(files);
-
-    assert.equal(files.length, unique.size, "should have no duplicates");
-  });
-});
-
-// ─── getChangedFilesWithContext ─────────────────────────────────────────────
-
-describe("diff-context: getChangedFilesWithContext", () => {
-  it("returns array of ChangedFileInfo objects", async () => {
-    const cwd = process.cwd();
-    const infos = await getChangedFilesWithContext(cwd);
-
-    assert.ok(Array.isArray(infos), "should return an array");
-
-    for (const info of infos) {
-      assert.ok(typeof info.path === "string", "path should be a string");
-      assert.ok(
-        ["modified", "added", "deleted", "staged"].includes(info.changeType),
-        `changeType should be valid, got: ${info.changeType}`,
-      );
-      if (info.linesChanged !== undefined) {
-        assert.ok(typeof info.linesChanged === "number", "linesChanged should be a number");
-      }
-    }
-  });
-
-  it("returns empty array for non-git directory", async () => {
-    const tmp = mkdtempSync(join(tmpdir(), "diff-ctx-test2-"));
-    const infos = await getChangedFilesWithContext(tmp);
-
-    assert.deepStrictEqual(infos, [], "should return empty array for non-git dir");
-  });
-});
-
-// ─── rankFilesByRelevance ───────────────────────────────────────────────────
-
-describe("diff-context: rankFilesByRelevance", () => {
-  it("places changed files before unchanged files", () => {
-    const allFiles = ["a.ts", "b.ts", "c.ts", "d.ts"];
-    const changed = ["c.ts", "a.ts"];
-
-    const ranked = rankFilesByRelevance(allFiles, changed);
-
-    // Changed files come first, sorted by changedFiles priority (c before a)
-    assert.equal(ranked[0], "c.ts");
-    assert.equal(ranked[1], "a.ts");
-    // Unchanged files follow in original order
-    assert.equal(ranked[2], "b.ts");
-    assert.equal(ranked[3], "d.ts");
-  });
-
-  it("preserves order of changed files based on changedFiles priority", () => {
-    const allFiles = ["x.ts", "y.ts", "z.ts", "w.ts"];
-    const changed = ["z.ts", "x.ts"]; // z has higher priority (index 0)
-
-    const ranked = rankFilesByRelevance(allFiles, changed);
-
-    assert.equal(ranked[0], "z.ts", "z.ts should be first (higher priority in changedFiles)");
-    assert.equal(ranked[1], "x.ts", "x.ts should be second");
-  });
-
-  it("returns unchanged files in original order when no changed files match", () => {
-    const allFiles = ["a.ts", "b.ts", "c.ts"];
-    const changed = ["x.ts", "y.ts"]; // none match
-
-    const ranked = rankFilesByRelevance(allFiles, changed);
-
-    assert.deepStrictEqual(ranked, ["a.ts", "b.ts", "c.ts"]);
-  });
-
-  it("handles empty inputs gracefully", () => {
-    assert.deepStrictEqual(rankFilesByRelevance([], []), []);
-    assert.deepStrictEqual(rankFilesByRelevance(["a.ts"], []), ["a.ts"]);
-    assert.deepStrictEqual(rankFilesByRelevance([], ["a.ts"]), []);
-  });
-
-  it("handles all files being changed", () => {
-    const allFiles = ["a.ts", "b.ts"];
-    const changed = ["b.ts", "a.ts"];
-
-    const ranked = rankFilesByRelevance(allFiles, changed);
-
-    // Both are changed, so sorted by changedFiles order: b first, then a
-    assert.equal(ranked[0], "b.ts");
-    assert.equal(ranked[1], "a.ts");
-    assert.equal(ranked.length, 2);
-  });
-});

package/src/resources/extensions/gsd/tests/discord-invite-links.test.ts

@@ -1,47 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-/**
- * Validates that all Discord invite links in user-facing files point to valid,
- * consistent invite URLs — not expired vanity links.
- *
- * Regression test for https://github.com/gsd-build/gsd-2/issues/2699
- */
-
-const ROOT = process.cwd();
-
-/** Canonical Discord invite for the GSD community. */
-const VALID_INVITE = "https://discord.com/invite/nKXTsAcmbT";
-
-/** Files that contain user-facing Discord invite links. */
-const FILES_WITH_INVITE_LINKS: string[] = [
-  "README.md",
-  "docs/what-is-pi/15-pi-packages-the-ecosystem.md",
-];
-
-describe("Discord invite links (#2699)", () => {
-  for (const relPath of FILES_WITH_INVITE_LINKS) {
-    it(`${relPath} contains only the canonical Discord invite`, () => {
-      const content = readFileSync(join(ROOT, relPath), "utf8");
-
-      // Extract all Discord invite URLs (discord.gg/X or discord.com/invite/X)
-      const invitePattern = /https?:\/\/(?:discord\.gg|discord\.com\/invite)\/[A-Za-z0-9]+/g;
-      const matches = content.match(invitePattern);
-
-      assert.ok(
-        matches && matches.length > 0,
-        `Expected at least one Discord invite link in ${relPath}`,
-      );
-
-      for (const link of matches) {
-        assert.equal(
-          link,
-          VALID_INVITE,
-          `Invalid Discord invite in ${relPath}: found "${link}", expected "${VALID_INVITE}"`,
-        );
-      }
-    });
-  }
-});

package/src/resources/extensions/gsd/tests/discuss-empty-db-fallback.test.ts

@@ -1,127 +0,0 @@
-/**
- * discuss-empty-db-fallback.test.ts — Tests for #2892.
- *
- * When the DB is open but empty (e.g., after crash/truncation),
- * getMilestoneSlices() returns [] and showDiscuss() incorrectly declares
- * "All slices are complete." The fix adds a roadmap fallback: when the DB
- * returns zero slices but a ROADMAP file exists, parse slices from the
- * roadmap instead of treating zero slices as "all complete."
- */
-
-import { describe, test } from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import { parseRoadmapSlices } from "../roadmap-slices.ts";
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-function readGuidedFlowSource(): string {
-  const thisFile = fileURLToPath(import.meta.url);
-  const thisDir = dirname(thisFile);
-  return readFileSync(join(thisDir, "..", "guided-flow.ts"), "utf-8");
-}
-
-const SAMPLE_ROADMAP = `# M012 Roadmap
-
-## Slices
-- [ ] **S01: Core setup** \`risk:low\` \`depends:[]\`
-  > After this: basic project scaffolding works
-- [ ] **S02: Auth module** \`risk:medium\` \`depends:[S01]\`
-  > After this: users can log in
-- [ ] **S03: Dashboard** \`risk:low\` \`depends:[S02]\`
-  > After this: dashboard renders
-`;
-
-// ─── Tests ───────────────────────────────────────────────────────────────────
-
-describe("discuss-empty-db-fallback (#2892)", () => {
-
-  test("1. parseRoadmapSlices extracts slices from a valid ROADMAP", () => {
-    const slices = parseRoadmapSlices(SAMPLE_ROADMAP);
-    assert.strictEqual(slices.length, 3, "should parse 3 slices from sample roadmap");
-    assert.strictEqual(slices[0]!.id, "S01");
-    assert.strictEqual(slices[1]!.id, "S02");
-    assert.strictEqual(slices[2]!.id, "S03");
-    // All slices are incomplete ([ ] not [x])
-    assert.ok(slices.every(s => !s.done), "all slices should be incomplete");
-  });
-
-  test("2. guided-flow imports parseRoadmapSlices for roadmap fallback", () => {
-    const source = readGuidedFlowSource();
-    assert.ok(
-      source.includes("parseRoadmapSlices"),
-      "guided-flow must import parseRoadmapSlices to support roadmap fallback when DB is empty",
-    );
-  });
-
-  test("3. guided-flow has roadmap fallback when normSlices is empty but roadmapContent exists", () => {
-    const source = readGuidedFlowSource();
-    // The fix must add a fallback that checks normSlices.length === 0 && roadmapContent
-    // and repopulates normSlices from the roadmap before the pendingSlices guard.
-    //
-    // Pattern: after DB query produces normSlices, if empty + roadmap exists,
-    // fall back to parseRoadmapSlices(roadmapContent).
-    const fallbackPattern = /normSlices\.length\s*===\s*0\s*&&\s*roadmapContent/;
-    assert.ok(
-      fallbackPattern.test(source),
-      "guided-flow must check normSlices.length === 0 && roadmapContent to trigger roadmap fallback",
-    );
-  });
-
-  test("4. guided-flow no longer has unguarded pendingSlices === 0 exit after DB-only query", () => {
-    const source = readGuidedFlowSource();
-    // Extract the showDiscuss function body
-    const fnMatch = source.match(
-      /async function showDiscuss\s*\([^)]*\)[^{]*\{([\s\S]*?)\nfunction\s/,
-    );
-    assert.ok(!!fnMatch, "showDiscuss function body must be found");
-
-    if (fnMatch) {
-      const body = fnMatch[1]!;
-      // After the DB query block (isDbAvailable/getMilestoneSlices), there should
-      // be a roadmap fallback BEFORE the pendingSlices.length === 0 check.
-      // Find the getMilestoneSlices call and the pendingSlices === 0 check
-      const dbQueryIdx = body.indexOf("getMilestoneSlices");
-      const fallbackIdx = body.indexOf("parseRoadmapSlices");
-      const pendingGuardIdx = body.indexOf('pendingSlices.length === 0');
-
-      assert.ok(dbQueryIdx > 0, "getMilestoneSlices call must exist");
-      assert.ok(fallbackIdx > 0, "parseRoadmapSlices fallback must exist");
-      assert.ok(pendingGuardIdx > 0, "pendingSlices.length === 0 guard must exist");
-      assert.ok(
-        fallbackIdx > dbQueryIdx && fallbackIdx < pendingGuardIdx,
-        "parseRoadmapSlices fallback must appear BETWEEN DB query and pendingSlices === 0 guard",
-      );
-    }
-  });
-
-  test("5. roadmap-parsed slices map to NormSlice format with done=false by default", () => {
-    // When falling back to roadmap, incomplete slices ([ ]) should map to done:false,
-    // ensuring they appear as pending and are NOT falsely reported as complete.
-    const slices = parseRoadmapSlices(SAMPLE_ROADMAP);
-    const normSlices = slices.map(s => ({ id: s.id, done: s.done, title: s.title }));
-    const pendingSlices = normSlices.filter(s => !s.done);
-    assert.strictEqual(pendingSlices.length, 3,
-      "all 3 incomplete roadmap slices should be pending — not falsely treated as complete");
-  });
-
-  test("6. roadmap with completed slices correctly reports them as done", () => {
-    const completedRoadmap = `# M012 Roadmap
-
-## Slices
-- [x] **S01: Core setup** \`risk:low\` \`depends:[]\`
-  > After this: basic project scaffolding works
-- [ ] **S02: Auth module** \`risk:medium\` \`depends:[S01]\`
-  > After this: users can log in
-- [x] **S03: Dashboard** \`risk:low\` \`depends:[S02]\`
-  > After this: dashboard renders
-`;
-    const slices = parseRoadmapSlices(completedRoadmap);
-    const normSlices = slices.map(s => ({ id: s.id, done: s.done, title: s.title }));
-    const pendingSlices = normSlices.filter(s => !s.done);
-    assert.strictEqual(pendingSlices.length, 1, "only S02 should be pending");
-    assert.strictEqual(pendingSlices[0]!.id, "S02");
-  });
-});

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

@@ -1,15 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-const promptPath = join(process.cwd(), "src/resources/extensions/gsd/prompts/discuss.md");
-const discussPrompt = readFileSync(promptPath, "utf-8");
-
-test("discuss prompt: resilient vision framing", () => {
-  const hardenedPattern = /Say exactly:\s*"What's the vision\?"/;
-  assert.ok(!hardenedPattern.test(discussPrompt), "prompt no longer uses exact-verbosity lock");
-  assert.ok(discussPrompt.includes('Ask: "What\'s the vision?" once'), "prompt asks for vision exactly once");
-  assert.ok(discussPrompt.includes("Special handling"), "prompt documents special handling");
-  assert.ok(discussPrompt.includes('instead of repeating "What\'s the vision?"'), "prompt forbids repeating");
-});