gsd-pi 2.76.0 → 2.77.0-dev.1594b263e

package/src/resources/extensions/gsd/tests/pre-execution-checks.test.ts

@@ -140,6 +140,25 @@ import type { Request } from 'express';
     assert.ok(packages.includes("typescript"));
     assert.ok(!packages.includes("-D"));
   });
+
+  // Regression tests for #4388: prose containing `from "..."` must not produce false-positive packages
+  test("does not treat prose 'from \"What's Next\"' as a package name (#4388)", () => {
+    const desc = 'Build the feature described from "What\'s Next" in the roadmap';
+    const packages = extractPackageReferences(desc);
+    assert.deepEqual(packages, [], `prose 'from "What\\'s Next"' must not produce package names, got: ${JSON.stringify(packages)}`);
+  });
+
+  test("does not treat prose \"from 'master'\" as a package name (#4388)", () => {
+    const desc = "Review changes from 'master' branch before merging";
+    const packages = extractPackageReferences(desc);
+    assert.deepEqual(packages, [], `prose "from 'master'" must not produce package names, got: ${JSON.stringify(packages)}`);
+  });
+
+  test("still extracts import statements in code blocks after #4388 fix", () => {
+    const desc = "```typescript\nimport express from 'express';\nimport { Router } from 'express';\n```";
+    const packages = extractPackageReferences(desc);
+    assert.ok(packages.includes("express"), "import...from in code blocks must still be recognized");
+  });
 });
 
 // ─── File Path Consistency Tests ─────────────────────────────────────────────
@@ -1580,6 +1599,221 @@ describe("checkTaskOrdering directory inputs (#4446)", () => {
   });
 });
 
+// ─── Regression Tests: checkTaskOrdering false positive for pre-execution refs (#4071) ──
+
+describe("checkTaskOrdering false positive for pre-execution refs (#4071)", () => {
+  test("completed task at higher index does not trigger ordering violation for its outputs", () => {
+    // Scenario: after a replan, a completed task at higher array index has already
+    // created a file. A new earlier-sequence task reads that file. Since the
+    // completed task already ran, its output is available regardless of disk state.
+    // checkTaskOrdering must not flag this as a sequence violation.
+    const tasks = [
+      createTask({
+        id: "T_NEW",
+        sequence: 1,
+        status: "pending",
+        inputs: ["artifacts/setup.json"],
+        expected_output: [],
+      }),
+      createTask({
+        id: "T_SETUP",
+        sequence: 5,
+        status: "completed",
+        inputs: [],
+        expected_output: ["artifacts/setup.json"],
+      }),
+    ];
+
+    const results = checkTaskOrdering(tasks, "/tmp");
+    assert.equal(
+      results.length,
+      0,
+      "completed task outputs must not trigger ordering violations for earlier-sequence tasks that read them",
+    );
+  });
+
+  test("pending task at higher index still triggers ordering violation", () => {
+    // A PENDING task at higher index creating a file is a real violation.
+    // Only completed tasks get the exemption.
+    const tasks = [
+      createTask({
+        id: "T01",
+        sequence: 1,
+        status: "pending",
+        inputs: ["artifacts/output.json"],
+        expected_output: [],
+      }),
+      createTask({
+        id: "T02",
+        sequence: 5,
+        status: "pending",
+        inputs: [],
+        expected_output: ["artifacts/output.json"],
+      }),
+    ];
+
+    const results = checkTaskOrdering(tasks, "/tmp");
+    assert.equal(
+      results.length,
+      1,
+      "pending task at higher index must still be flagged as ordering violation",
+    );
+    assert.equal(results[0].blocking, true);
+    assert.ok(results[0].message.includes("T01"));
+    assert.ok(results[0].message.includes("T02"));
+    assert.ok(results[0].message.includes("sequence violation"));
+  });
+
+  test("pending-first then completed-later: completed replaces pending in fileCreators (#4572)", () => {
+    // Regression for CodeRabbit Major finding on PR #4572:
+    // fileCreators only stored the FIRST task for a given path. If a PENDING task at
+    // array index 1 was registered first, and a COMPLETED task at array index 2 also
+    // declared the same output path, the completed entry was discarded. Line ~529 then
+    // saw a pending creator with index > i and incorrectly fired a sequence violation
+    // for the reader at array index 0.
+    //
+    // Scenario: path first declared by pending task (index 1), then by completed task
+    // (index 2). Reader is at index 0. Without the fix a violation fires; with the fix
+    // the completed entry replaces the pending entry and grants the exemption.
+    const tasks = [
+      // array index 0 — reads the shared path
+      createTask({
+        id: "T_READER",
+        sequence: 1,
+        status: "pending",
+        inputs: ["shared/artifact.json"],
+        expected_output: [],
+      }),
+      // array index 1 — pending producer (visited first during map build)
+      createTask({
+        id: "T_PENDING_PRODUCER",
+        sequence: 5,
+        status: "pending",
+        inputs: [],
+        expected_output: ["shared/artifact.json"],
+      }),
+      // array index 2 — completed producer (visited second; must replace pending entry)
+      createTask({
+        id: "T_COMPLETED_PRODUCER",
+        sequence: 2,
+        status: "completed",
+        inputs: [],
+        expected_output: ["shared/artifact.json"],
+      }),
+    ];
+
+    // Without the fix: creator = T_PENDING_PRODUCER (index 1), !creator.completed && 1 > 0 → violation.
+    // With the fix:    creator = T_COMPLETED_PRODUCER (index 2), creator.completed → no violation.
+    const results = checkTaskOrdering(tasks, "/tmp");
+    assert.equal(
+      results.length,
+      0,
+      "completed producer must replace pending producer in fileCreators and suppress false violation",
+    );
+  });
+
+  test("completed task output exemption applies regardless of whether file exists on disk", (t) => {
+    // The completed-task exemption must work even when the file is not on disk
+    // (e.g., the file was a temporary artifact that was cleaned up after the task ran).
+    const tempDir = join(tmpdir(), `pre-exec-completed-task-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    // File deliberately NOT created on disk — completed task ran in a prior session
+    const tasks = [
+      createTask({
+        id: "T_MAIN",
+        sequence: 0,
+        status: "pending",
+        inputs: ["generated/config.json"],
+        expected_output: [],
+      }),
+      createTask({
+        id: "T_INIT",
+        sequence: 10,
+        status: "completed",
+        inputs: [],
+        expected_output: ["generated/config.json"],
+      }),
+    ];
+
+    const results = checkTaskOrdering(tasks, tempDir);
+    assert.equal(
+      results.length,
+      0,
+      "completed task exemption must apply even when file is absent from disk",
+    );
+  });
+});
+
+describe("checkFilePathConsistency completed-task output exemption (#4071)", () => {
+  test("completed task at higher index does not cause false positive for file it produced", (t) => {
+    // Parallel to the checkTaskOrdering fix: checkFilePathConsistency also uses
+    // getExpectedOutputsUpTo which historically only looked at prior-index tasks.
+    // A completed task at a higher index has already run and its outputs are available.
+    const tempDir = join(tmpdir(), `pre-exec-fc-completed-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    // File is NOT on disk — completed task ran in a prior session and file was cleaned
+    const tasks = [
+      createTask({
+        id: "T_MAIN",
+        sequence: 1,
+        status: "pending",
+        inputs: ["artifacts/config.json"],
+        expected_output: [],
+      }),
+      createTask({
+        id: "T_SETUP",
+        sequence: 10,
+        status: "completed",
+        inputs: [],
+        expected_output: ["artifacts/config.json"],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(
+      results.length,
+      0,
+      "completed task at higher index should satisfy inputs of pending tasks that read its outputs",
+    );
+  });
+
+  test("pending task at higher index still causes a missing-file error", (t) => {
+    const tempDir = join(tmpdir(), `pre-exec-fc-pending-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T01",
+        sequence: 1,
+        status: "pending",
+        inputs: ["artifacts/output.json"],
+        expected_output: [],
+      }),
+      createTask({
+        id: "T02",
+        sequence: 10,
+        status: "pending",
+        inputs: [],
+        expected_output: ["artifacts/output.json"],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(
+      results.length,
+      1,
+      "pending task at higher index must still be flagged — the file is not available yet",
+    );
+    assert.equal(results[0].blocking, true);
+    assert.equal(results[0].target, "artifacts/output.json");
+  });
+});
+
 describe("checkFilePathConsistency self-referential inputs (#4459)", () => {
   test("input that is also in the same task's expected_output is not blocking when missing on disk", (t) => {
     const tempDir = join(tmpdir(), `pre-exec-self-output-${Date.now()}`);
@@ -1645,3 +1879,125 @@ describe("checkFilePathConsistency self-referential inputs (#4459)", () => {
     );
   });
 });
+
+// ─── Regression Tests: quote-wrapped inputs treated as literal paths (#3747) ──
+
+describe("checkFilePathConsistency quote-wrapped annotation (#3747)", () => {
+  test("double-quoted path annotation is stripped before path check", (t) => {
+    // Plan documents sometimes emit `"src/foo.ts"` (double-quote wrapped) as an
+    // input value. The checker must strip the quotes before checking existence so
+    // it doesn't produce a false-positive "file not found" error.
+    const tempDir = join(tmpdir(), `pre-exec-quote-${Date.now()}`);
+    mkdirSync(join(tempDir, "src"), { recursive: true });
+    writeFileSync(join(tempDir, "src/foo.ts"), "// content");
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T01",
+        inputs: ['"src/foo.ts"'],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(
+      results.length,
+      0,
+      "Double-quoted path should be stripped and resolved to the real file",
+    );
+  });
+
+  test("single-quoted path annotation is stripped before path check", (t) => {
+    const tempDir = join(tmpdir(), `pre-exec-squote-${Date.now()}`);
+    mkdirSync(join(tempDir, "src"), { recursive: true });
+    writeFileSync(join(tempDir, "src/bar.ts"), "// content");
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T01",
+        inputs: ["'src/bar.ts'"],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(
+      results.length,
+      0,
+      "Single-quoted path should be stripped and resolved to the real file",
+    );
+  });
+
+  test("backtick-only wrapped path without annotation resolves correctly", (t) => {
+    // The bare form `src/foo.ts` (no dash annotation) must also work
+    const tempDir = join(tmpdir(), `pre-exec-backtick-bare-${Date.now()}`);
+    mkdirSync(join(tempDir, "src"), { recursive: true });
+    writeFileSync(join(tempDir, "src/baz.ts"), "// content");
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T01",
+        inputs: ["`src/baz.ts`"],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(
+      results.length,
+      0,
+      "Bare backtick-wrapped path should resolve to the real file",
+    );
+  });
+
+  test("prose value with spaces inside quotes is skipped (not a path)", () => {
+    // "some description text" contains spaces — should not be checked as a path
+    const tasks = [
+      createTask({
+        id: "T01",
+        inputs: ['"some description text"'],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, "/tmp");
+    assert.equal(
+      results.length,
+      0,
+      "Quoted prose with spaces should not be treated as a file path",
+    );
+  });
+
+  test("17-error scenario: mixed annotated inputs produce 0 blocking errors", (t) => {
+    // Reproduces the M004-ej6j88/S07 scenario from issue #3747 where a plan with
+    // multiple backtick- and quote-wrapped input strings causes 17 false blocking errors.
+    const tempDir = join(tmpdir(), `pre-exec-3747-scenario-${Date.now()}`);
+    mkdirSync(join(tempDir, "src"), { recursive: true });
+    writeFileSync(join(tempDir, "src/foo.ts"), "// content");
+    writeFileSync(join(tempDir, "src/bar.ts"), "// content");
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const tasks = [
+      createTask({
+        id: "T01",
+        inputs: [
+          "`src/foo.ts`",
+          '"src/bar.ts"',
+          "some description text",
+          "Existing enum definition",
+        ],
+        expected_output: [],
+      }),
+    ];
+
+    const results = checkFilePathConsistency(tasks, tempDir);
+    assert.equal(
+      results.length,
+      0,
+      "Annotated file paths and prose inputs should produce zero blocking errors",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/pre-execution-pause-wiring.test.ts

@@ -191,7 +191,12 @@ function createFailingTasks(): void {
       estimate: "1h",
       files: [],
       verify: "npm test",
-      inputs: ["nonexistent-file-that-does-not-exist.ts"],
+      inputs: [
+        "nonexistent-file-that-does-not-exist.ts",
+        "missing-second-file.ts",
+        "missing-third-file.ts",
+        "missing-fourth-file.ts",
+      ],
       expectedOutput: [],
       observabilityImpact: "",
     },
@@ -308,6 +313,32 @@ describe("Pre-execution checks → pauseAuto wiring", () => {
         String(call.arguments[0]).includes("Pre-execution checks failed")
     );
     assert.ok(errorNotify, "Should show error notification about pre-execution check failure");
+    const errorMessage = String(errorNotify.arguments[0]);
+    assert.match(
+      errorMessage,
+      /Pre-execution checks failed: \d+ blocking issue/,
+      "failure notification should include the blocking issue count",
+    );
+    assert.ok(
+      errorMessage.includes("[file] nonexistent-file-that-does-not-exist.ts: Task T01 references"),
+      "failure notification should include category, target, and message details",
+    );
+    assert.ok(
+      errorMessage.includes("[file] missing-third-file.ts: Task T01 references"),
+      "failure notification should include up to three actionable check details",
+    );
+    assert.ok(
+      !errorMessage.includes("missing-fourth-file.ts"),
+      "failure notification should truncate details beyond the display limit",
+    );
+    assert.ok(
+      errorMessage.includes("...and 1 more"),
+      "failure notification should summarize truncated blocking checks",
+    );
+    assert.ok(
+      errorMessage.includes(join(".gsd", "milestones", "M001", "slices", "S01", "S01-PRE-EXEC-VERIFY.json")),
+      "failure notification should point to the relative pre-exec evidence file path",
+    );
   });
 
   test("pauseAuto is called when enhanced_verification_strict: true and pre-execution returns warn", async () => {

package/src/resources/extensions/gsd/tests/preferences-worktree-sync.test.ts

@@ -12,6 +12,7 @@ import assert from "node:assert/strict";
 import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 test("#2684: preferences files are NOT in ROOT_STATE_FILES (forward-only sync)", () => {
   const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
@@ -49,7 +50,7 @@ test("copyPlanningArtifacts prefers canonical PREFERENCES.md with lowercase fall
   assert.ok(fnIdx !== -1, "copyPlanningArtifacts function exists");
 
   // Extract function body (up to the next top-level function)
-  const fnBody = src.slice(fnIdx, fnIdx + 2200);
+  const fnBody = extractSourceRegion(src, "function copyPlanningArtifacts");
 
   assert.ok(
     fnBody.includes("PROJECT_PREFERENCES_FILE") && fnBody.includes("LEGACY_PROJECT_PREFERENCES_FILE"),

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

@@ -186,6 +186,45 @@ test("flat_rate_providers is a recognized preference key (no warning)", () => {
   );
 });
 
+test("slice_parallel preferences validate and pass through", () => {
+  const { preferences, errors, warnings } = validatePreferences({
+    slice_parallel: { enabled: true, max_workers: 8 },
+  });
+
+  assert.equal(errors.length, 0);
+  assert.equal(warnings.filter(w => w.includes("slice_parallel")).length, 0);
+  assert.deepEqual(preferences.slice_parallel, { enabled: true, max_workers: 8 });
+});
+
+test("slice_parallel rejects invalid values and warns on unknown keys", () => {
+  const { preferences, errors, warnings } = validatePreferences({
+    slice_parallel: {
+      enabled: "yes",
+      max_workers: 9,
+      future_mode: true,
+    },
+  } as any);
+
+  assert.ok(errors.some(e => e.includes("slice_parallel.enabled")), "should reject non-boolean enabled");
+  assert.ok(errors.some(e => e.includes("slice_parallel.max_workers")), "should reject max_workers outside 1..8");
+  assert.ok(warnings.some(w => w.includes('unknown slice_parallel key "future_mode"')));
+  assert.equal(preferences.slice_parallel, undefined);
+});
+
+test("slice_parallel numeric max_workers is bounded to 1..8", () => {
+  const low = validatePreferences({ slice_parallel: { max_workers: 1 } });
+  const high = validatePreferences({ slice_parallel: { max_workers: 8 } });
+  const tooLow = validatePreferences({ slice_parallel: { max_workers: 0 } });
+  const tooHigh = validatePreferences({ slice_parallel: { max_workers: 9 } });
+
+  assert.equal(low.errors.length, 0);
+  assert.equal(low.preferences.slice_parallel?.max_workers, 1);
+  assert.equal(high.errors.length, 0);
+  assert.equal(high.preferences.slice_parallel?.max_workers, 8);
+  assert.ok(tooLow.errors.some(e => e.includes("slice_parallel.max_workers")));
+  assert.ok(tooHigh.errors.some(e => e.includes("slice_parallel.max_workers")));
+});
+
 test("valid values pass through correctly", () => {
   const { preferences: p1 } = validatePreferences({ budget_enforcement: "halt" });
   assert.equal(p1.budget_enforcement, "halt");
@@ -606,6 +645,44 @@ test("loadEffectiveGSDPreferences preserves experimental prefs across global+pro
   }
 });
 
+test("loadEffectiveGSDPreferences exposes slice_parallel prefs to runtime callers", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-slice-parallel-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-slice-parallel-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "version: 1",
+        "slice_parallel:",
+        "  enabled: true",
+        "  max_workers: 3",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const loaded = loadEffectiveGSDPreferences();
+    assert.notEqual(loaded, null);
+    assert.equal(loaded!.preferences.slice_parallel?.enabled, true);
+    assert.equal(loaded!.preferences.slice_parallel?.max_workers, 3);
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
 test("preferences paths use canonical uppercase filenames", () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;
@@ -632,6 +709,39 @@ test("preferences paths use canonical uppercase filenames", () => {
   }
 });
 
+test("explicit base path preference loading survives a deleted cwd (#4498)", (t) => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-prefs-base-project-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-prefs-base-home-"));
+  const deletedCwd = mkdtempSync(join(tmpdir(), "gsd-prefs-deleted-cwd-"));
+
+  t.after(() => {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+    rmSync(deletedCwd, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    "---\nversion: 1\nlanguage: Swedish\ngit:\n  isolation: worktree\n---\n",
+    "utf-8",
+  );
+
+  process.env.GSD_HOME = tempGsdHome;
+  process.chdir(deletedCwd);
+  rmSync(deletedCwd, { recursive: true, force: true });
+
+  const loaded = loadEffectiveGSDPreferences(tempProject);
+  assert.notEqual(loaded, null);
+  assert.equal(loaded!.preferences.language, "Swedish");
+  assert.equal(getIsolationMode(tempProject), "worktree");
+});
+
 test("uppercase PREFERENCES.md wins over legacy lowercase preferences.md", () => {
   const originalCwd = process.cwd();
   const originalGsdHome = process.env.GSD_HOME;

package/src/resources/extensions/gsd/tests/prefs-wizard-coverage.test.ts

@@ -0,0 +1,44 @@
+// Guard test — every key in KNOWN_PREFERENCE_KEYS must be reachable from the
+// /gsd prefs wizard.  Without this guard, a new preference can be added to the
+// schema without anyone wiring it into the TUI, silently re-creating the gap
+// this test exists to prevent.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+
+import { KNOWN_PREFERENCE_KEYS } from "../preferences-types.ts";
+
+// Keys exposed via a dedicated command rather than the wizard.  They're still
+// reachable by the user, just not inside the category menu flow.  If you add a
+// new key here, add a comment explaining where it lives.
+const EXPOSED_OUTSIDE_WIZARD = new Set<string>([
+  "version",          // auto-managed by writePreferencesFile
+  "modelOverrides",   // advanced routing — edit PREFERENCES.md directly (not in KNOWN_PREFERENCE_KEYS)
+  "context_mode",     // advanced sandbox config (gsd_exec + compaction) — enabled by default; edit PREFERENCES.md directly to tune timeouts/caps. Wizard coverage tracked separately.
+]);
+
+test("every KNOWN_PREFERENCE_KEYS entry is reachable from the wizard source", () => {
+  const src = readFileSync(
+    new URL("../commands-prefs-wizard.ts", import.meta.url),
+    "utf-8",
+  );
+
+  const missing: string[] = [];
+  for (const key of KNOWN_PREFERENCE_KEYS) {
+    if (EXPOSED_OUTSIDE_WIZARD.has(key)) continue;
+    // The key must appear somewhere in the wizard — either as a direct
+    // prefs[...] / pref reference, or in the orderedKeys serialization list.
+    // A plain substring match is enough because all prefs-wizard references
+    // use the exact key name.
+    if (!src.includes(`"${key}"`) && !src.includes(`.${key}`)) {
+      missing.push(key);
+    }
+  }
+
+  assert.deepEqual(
+    missing,
+    [],
+    `These preference keys are in KNOWN_PREFERENCE_KEYS but are not referenced anywhere in the /gsd prefs wizard — they cannot be configured through the UI. Either add wizard coverage or add them to EXPOSED_OUTSIDE_WIZARD with an explanatory comment:\n${missing.join("\n")}`,
+  );
+});

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

@@ -64,6 +64,18 @@ describe("prompt-cache-optimizer: classifySection", () => {
     assert.equal(classifySection("overrides"), "semi-static");
   });
 
+  // Regression: issue #4719 — KNOWLEDGE falls through to dynamic default.
+  // Knowledge content is reused across all tasks within a milestone, so it
+  // must be classified as semi-static to qualify for prefix caching when the
+  // cache optimizer is wired into the prompt path.
+  it("classifies knowledge as semi-static (issue #4719)", () => {
+    assert.equal(classifySection("knowledge"), "semi-static");
+  });
+
+  it("classifies project-knowledge as semi-static (issue #4719)", () => {
+    assert.equal(classifySection("project-knowledge"), "semi-static");
+  });
+
   it("classifies task-plan as dynamic", () => {
     assert.equal(classifySection("task-plan"), "dynamic");
   });

package/src/resources/extensions/gsd/tests/prompt-loader-extension-dir.test.ts

@@ -0,0 +1,49 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { join } from "node:path";
+
+import { resolveExtensionDirFromCandidates } from "../prompt-loader.ts";
+
+function makeExists(paths: Set<string>): (path: string) => boolean {
+  return (path: string) => paths.has(path);
+}
+
+test("resolveExtensionDirFromCandidates prefers user-local dir when both trees are valid", () => {
+  const moduleDir = "/npm/global/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    join(moduleDir, "templates", "task-summary.md"),
+    join(agentDir, "prompts"),
+    join(agentDir, "templates", "task-summary.md"),
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, agentDir);
+});
+
+test("resolveExtensionDirFromCandidates rejects module dir missing task-summary template", () => {
+  const moduleDir = "/npm/global/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    // Missing module templates/task-summary.md on purpose.
+    join(agentDir, "prompts"),
+    join(agentDir, "templates", "task-summary.md"),
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, agentDir);
+});
+
+test("resolveExtensionDirFromCandidates falls back to prompts-only dir when neither tree is fully valid", () => {
+  const moduleDir = "/npm/global/gsd";
+  const agentDir = "/home/user/.gsd/agent/extensions/gsd";
+  const paths = new Set<string>([
+    join(moduleDir, "prompts"),
+    // Neither side has templates/task-summary.md.
+  ]);
+
+  const resolved = resolveExtensionDirFromCandidates(moduleDir, agentDir, makeExists(paths));
+  assert.equal(resolved, moduleDir);
+});