gsd-pi 2.80.0-dev.42bd34838 → 2.80.0-dev.488219eb6

package/src/resources/extensions/gsd/tests/integration/git-locale.test.ts

@@ -7,13 +7,13 @@ import assert from 'node:assert/strict';
  * English output, and that nativeMergeSquash passes the env to execFileSync.
  */
 
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
 import { GIT_NO_PROMPT_ENV } from "../../git-constants.ts";
-import { nativeAddAllWithExclusions } from "../../native-git-bridge.ts";
+import { nativeAddAllWithExclusions, nativeMergeSquash } from "../../native-git-bridge.ts";
 import { RUNTIME_EXCLUSION_PATHS } from "../../git-service.ts";
 function git(cwd: string, ...args: string[]): string {
   return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
@@ -97,23 +97,34 @@ describe('git-locale', async () => {
 
   // ─── nativeMergeSquash: env is passed (merge-squash stderr is English) ─
 
-  test('nativeMergeSquash fallback uses GIT_NO_PROMPT_ENV', () => {
-    // We verify indirectly: the source code must pass env: GIT_NO_PROMPT_ENV.
-    // Read the source and check for the pattern. This is a static check.
-    const src = readFileSync(
-      join(import.meta.dirname, "../..", "native-git-bridge.ts"),
-      "utf-8"
-    );
-
-    // Find the nativeMergeSquash function and check it uses GIT_NO_PROMPT_ENV
-    const fnStart = src.indexOf("export function nativeMergeSquash");
-    assert.ok(fnStart !== -1, "nativeMergeSquash function exists in source");
-
-    const fnBody = src.slice(fnStart, src.indexOf("\nexport function", fnStart + 1));
-    const hasEnv = fnBody.includes("env: GIT_NO_PROMPT_ENV");
-    assert.ok(
-      hasEnv,
-      "nativeMergeSquash fallback must pass env: GIT_NO_PROMPT_ENV to execFileSync (#1997)"
-    );
+  test('nativeMergeSquash succeeds under non-English locale env', () => {
+    const repo = initTempRepo();
+    try {
+      const mainBranch = git(repo, "branch", "--show-current");
+      git(repo, "checkout", "-b", "feature");
+      createFile(repo, "src/feature.ts", "export const feature = true;");
+      git(repo, "add", "-A");
+      git(repo, "commit", "-m", "feat: add feature");
+      git(repo, "checkout", mainBranch);
+
+      const origLcAll = process.env.LC_ALL;
+      const origLang = process.env.LANG;
+      process.env.LANG = "de_DE.UTF-8";
+      delete process.env.LC_ALL;
+      try {
+        const result = nativeMergeSquash(repo, "feature");
+        assert.equal(result.success, true);
+      } finally {
+        if (origLcAll !== undefined) process.env.LC_ALL = origLcAll;
+        else delete process.env.LC_ALL;
+        if (origLang !== undefined) process.env.LANG = origLang;
+        else delete process.env.LANG;
+      }
+
+      const staged = git(repo, "diff", "--cached", "--name-only");
+      assert.ok(staged.includes("src/feature.ts"));
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+    }
   });
 });

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Git service integration and commit-message tests.
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, symlinkSync, readFileSync } from "node:fs";
@@ -211,7 +213,12 @@ describe('git-service', async () => {
   test('buildTaskCommitMessage', () => {
     const msg = buildTaskCommitMessage({
       taskId: "S01/T02",
+      taskDisplayId: "T02",
       taskTitle: "implement user authentication",
+      milestoneId: "M001",
+      milestoneTitle: "User management",
+      sliceId: "S01",
+      sliceTitle: "Authentication",
       oneLiner: "Added JWT-based auth with refresh token rotation",
       keyFiles: ["src/auth.ts", "src/middleware/jwt.ts"],
     });
@@ -220,7 +227,12 @@ describe('git-service', async () => {
     assert.ok(msg.includes("JWT-based auth"), "message includes one-liner content");
     assert.ok(msg.includes("- src/auth.ts"), "message body includes key files");
     assert.ok(msg.includes("- src/middleware/jwt.ts"), "message body includes second key file");
+    assert.ok(msg.includes("GSD context:"), "message includes human GSD context block");
+    assert.ok(msg.includes("- Milestone: M001 - User management"), "message includes milestone name");
+    assert.ok(msg.includes("- Slice: S01 - Authentication"), "message includes slice name");
+    assert.ok(msg.includes("- Task: T02 - implement user authentication"), "message includes task name");
     assert.ok(msg.includes("GSD-Task: S01/T02"), "GSD-Task trailer in body");
+    assert.ok(!msg.includes("chore: auto-commit after execute-task"), "message does not use generic fallback");
   });
 
   test('buildTaskCommitMessage sanitizes subject text', () => {

package/src/resources/extensions/gsd/tests/integration/milestone-transition-worktree.test.ts

@@ -4,8 +4,6 @@
  * Verifies that when auto-mode transitions between milestones, the
  * worktree lifecycle is handled: old worktree merged, new worktree created.
  *
- * Uses source-level checks since the full auto-mode dispatch loop
- * requires the @gsd/pi-coding-agent runtime.
  */
 
 import test from "node:test";
@@ -119,48 +117,3 @@ test("worktree swap on milestone transition: merge old, create new", () => {
     }
   }
 });
-
-// ─── Verify the transition code path exists in auto.ts ──────────────────────
-
-test("auto/phases.ts milestone transition block contains worktree lifecycle", () => {
-  const phasesSrc = readFileSync(
-    join(__dirname, "../..", "auto", "phases.ts"),
-    "utf-8",
-  );
-
-  // The resolver handles worktree merge + enter inside the milestone transition block
-  assert.ok(
-    phasesSrc.includes("Worktree lifecycle on milestone transition"),
-    "auto/phases.ts should contain the worktree lifecycle comment marker",
-  );
-  assert.ok(
-    phasesSrc.includes("resolver.mergeAndExit") && phasesSrc.includes("mid !== s.currentMilestoneId"),
-    "auto/phases.ts should call resolver.mergeAndExit during milestone transition",
-  );
-  assert.ok(
-    phasesSrc.includes("resolver.enterMilestone"),
-    "auto/phases.ts should call resolver.enterMilestone for incoming milestone",
-  );
-});
-
-// ─── Verify worktree-resolver mergeAndExit preserves branch on missing roadmap (#1573) ──
-
-test("worktree-resolver mergeAndExit preserves branch when roadmap is missing (#1573)", () => {
-  const resolverSrc = readFileSync(
-    join(__dirname, "../..", "worktree-resolver.ts"),
-    "utf-8",
-  );
-
-  // The fallback teardown must pass preserveBranch: true to prevent orphaning commits
-  assert.ok(
-    resolverSrc.includes("preserveBranch: true"),
-    "worktree-resolver.ts should pass preserveBranch: true in the no-roadmap fallback",
-  );
-
-  // The worktree path should be tried as a fallback for roadmap resolution
-  assert.ok(
-    resolverSrc.includes("this.s.basePath !== originalBase") ||
-      resolverSrc.includes("roadmap-fallback"),
-    "worktree-resolver.ts should try resolving roadmap from worktree path as fallback",
-  );
-});

package/src/resources/extensions/gsd/tests/interactive-routing-bypass.test.ts

@@ -1,213 +1,71 @@
 // GSD Extension — Interactive Routing Bypass Tests
-// Verifies that dynamic routing is skipped for interactive (guided-flow) dispatches
-// and that model downgrade notifications always fire (#3962).
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
 import test, { describe } 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";
-import { extractSourceRegion } from "./test-helpers.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// ─── Source-level structural tests ──────────────────────────────────────────
-
-const modelSelectionSrc = readFileSync(
-  join(__dirname, "..", "auto-model-selection.ts"),
-  "utf-8",
-);
-
-const guidedFlowSrc = readFileSync(
-  join(__dirname, "..", "guided-flow.ts"),
-  "utf-8",
-);
-
-const autoStartSrc = readFileSync(
-  join(__dirname, "..", "auto-start.ts"),
-  "utf-8",
-);
-
-describe("interactive routing bypass (#3962)", () => {
-  test("selectAndApplyModel accepts isAutoMode parameter", () => {
-    // The function signature should include isAutoMode with a default of true
-    assert.ok(
-      modelSelectionSrc.includes("isAutoMode"),
-      "selectAndApplyModel should have isAutoMode parameter",
-    );
-    assert.ok(
-      modelSelectionSrc.includes("isAutoMode = true"),
-      "isAutoMode should default to true (auto-mode behavior preserved)",
-    );
-  });
-
-  test("routing is disabled when isAutoMode is false", () => {
-    // The code should disable routing when not in auto-mode
-    assert.ok(
-      modelSelectionSrc.includes("if (!isAutoMode)"),
-      "should check isAutoMode flag to disable routing",
-    );
-    assert.ok(
-      modelSelectionSrc.includes("routingConfig.enabled = false"),
-      "should set routingConfig.enabled = false for interactive mode",
-    );
-  });
-
-  test("resolvePreferredModelConfig skips routing synthesis when isAutoMode is false", () => {
-    // resolvePreferredModelConfig should accept isAutoMode and bail early
-    // before synthesizing a routing ceiling from tier_models (#3962 codex review)
-    assert.ok(
-      modelSelectionSrc.includes("function resolvePreferredModelConfig"),
-      "resolvePreferredModelConfig should exist",
-    );
-    // The function should check isAutoMode before routing synthesis
-    const fnIdx = modelSelectionSrc.indexOf("function resolvePreferredModelConfig");
-    const fnBody = extractSourceRegion(modelSelectionSrc, "function resolvePreferredModelConfig");
-    assert.ok(
-      fnBody.includes("isAutoMode"),
-      "resolvePreferredModelConfig should accept isAutoMode parameter",
-    );
-    assert.ok(
-      fnBody.includes("if (!isAutoMode) return undefined"),
-      "should return undefined (skip routing synthesis) when not in auto-mode",
-    );
-  });
-
-  test("selectAndApplyModel threads isAutoMode to resolvePreferredModelConfig", () => {
-    // The call to resolvePreferredModelConfig inside selectAndApplyModel
-    // should pass isAutoMode as the third argument
-    const callSite = "resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode)";
-    assert.ok(
-      modelSelectionSrc.includes(callSite),
-      "selectAndApplyModel should pass isAutoMode to resolvePreferredModelConfig",
-    );
-  });
-
-  test("guided-flow passes isAutoMode=false", () => {
-    // guided-flow.ts should explicitly pass isAutoMode as false
-    assert.ok(
-      guidedFlowSrc.includes("/* isAutoMode */ false"),
-      "guided-flow should pass isAutoMode=false to selectAndApplyModel",
-    );
-  });
-
-  test("auto/phases.ts does NOT pass isAutoMode=false", () => {
-    // auto/phases.ts should use the default (true) — it's auto-mode
-    const phasesSrc = readFileSync(
-      join(__dirname, "..", "auto", "phases.ts"),
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { resolvePreferredModelConfig } from "../auto-model-selection.ts";
+
+function withRoutingPrefs<T>(fn: () => T): T {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-interactive-routing-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-interactive-routing-home-"));
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  tier_models:",
+        "    light: gpt-4o-mini",
+        "    standard: claude-sonnet-4-6",
+        "    heavy: claude-opus-4-6",
+        "---",
+      ].join("\n"),
       "utf-8",
     );
-    assert.ok(
-      !phasesSrc.includes("isAutoMode"),
-      "auto/phases.ts should use default isAutoMode=true (not pass it explicitly)",
-    );
-  });
-});
-
-describe("model downgrade notifications always visible (#3962)", () => {
-  test("downgrade notification is not gated by verbose flag", () => {
-    // The downgrade notification block should NOT be wrapped in `if (verbose)`
-    // Find the downgrade block and verify it's not behind a verbose check
-    const downgradeBlock = "if (routingResult.wasDowngraded)";
-    const downgradeIdx = modelSelectionSrc.indexOf(downgradeBlock);
-    assert.ok(downgradeIdx > 0, "downgrade block should exist");
-
-    // Extract the code between wasDowngraded check and the next routing label assignment
-    const afterDowngrade = modelSelectionSrc.slice(
-      downgradeIdx,
-      modelSelectionSrc.indexOf("routingTierLabel =", downgradeIdx),
-    );
-
-    // The notification calls should NOT be wrapped in `if (verbose)`
-    assert.ok(
-      !afterDowngrade.includes("if (verbose)"),
-      "downgrade notifications should not be gated by verbose flag",
-    );
-
-    // But the notification calls should exist
-    assert.ok(
-      afterDowngrade.includes('ctx.ui.notify('),
-      "downgrade notifications should still fire",
-    );
-  });
-
-  test("tier escalation notification is not gated by verbose flag", () => {
-    // Extract the escalation block: from "if (escalated)" to its closing
-    // and verify the notification is present but `if (verbose)` is not.
-    const escalatedIdx = modelSelectionSrc.indexOf("if (escalated)");
-    assert.ok(escalatedIdx > 0, "escalation block should exist");
-
-    // Get the block from "if (escalated)" to the next distinctive marker
-    // (the capability-override loading that immediately follows).
-    const block = extractSourceRegion(
-      modelSelectionSrc,
-      "if (escalated)",
-      "// Load user capability overrides",
-    );
-    assert.ok(
-      block.includes("Tier escalation:"),
-      "escalation block should contain the notification",
-    );
-    assert.ok(
-      !block.includes("if (verbose)"),
-      "escalation block should not gate notification behind verbose flag",
-    );
-  });
-});
-
-describe("auto-mode start routing banner (#3962)", () => {
-  test("auto-start shows dynamic routing status on startup", () => {
-    assert.ok(
-      autoStartSrc.includes("Dynamic routing:"),
-      "auto-start should display routing status banner",
-    );
-    assert.ok(
-      autoStartSrc.includes("resolveDynamicRoutingConfig"),
-      "auto-start should import resolveDynamicRoutingConfig",
-    );
-  });
-
-  test("banner shows different messages for enabled vs disabled routing", () => {
-    assert.ok(
-      autoStartSrc.includes("Dynamic routing: enabled"),
-      "should show message when routing is enabled",
-    );
-    assert.ok(
-      autoStartSrc.includes("Dynamic routing: disabled"),
-      "should show message when routing is disabled",
-    );
-  });
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+    return fn();
+  } 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("banner shows the ceiling model", () => {
-    assert.ok(
-      autoStartSrc.includes("startModelLabel"),
-      "banner should reference the start/ceiling model",
-    );
-  });
-
-  test("banner accounts for flat-rate provider suppression", () => {
-    // The banner should check isFlatRateProvider to accurately reflect
-    // whether routing will actually be active at dispatch time (#3962 codex review)
-    assert.ok(
-      autoStartSrc.includes("isFlatRateProvider"),
-      "banner should check flat-rate provider status",
-    );
-    assert.ok(
-      autoStartSrc.includes("effectivelyEnabled"),
-      "banner should compute effective routing state, not just raw config",
-    );
+describe("interactive routing bypass (#3962)", () => {
+  test("interactive dispatch does not synthesize dynamic routing config", () => {
+    withRoutingPrefs(() => {
+      const result = resolvePreferredModelConfig(
+        "execute-task",
+        { provider: "anthropic", id: "claude-sonnet-4-6" },
+        false,
+      );
+
+      assert.equal(result, undefined);
+    });
   });
 
-  test("banner uses effective ceiling from tier_models.heavy when configured", () => {
-    // The actual ceiling may come from tier_models.heavy, not the start model
-    assert.ok(
-      autoStartSrc.includes("tier_models?.heavy"),
-      "banner should check tier_models.heavy for the effective ceiling",
-    );
-    assert.ok(
-      autoStartSrc.includes("effectiveCeiling"),
-      "banner should compute the effective ceiling model",
-    );
+  test("auto-mode dispatch still synthesizes dynamic routing config", () => {
+    withRoutingPrefs(() => {
+      const result = resolvePreferredModelConfig(
+        "execute-task",
+        { provider: "anthropic", id: "claude-sonnet-4-6" },
+        true,
+      );
+
+      assert.ok(result);
+      assert.equal(result!.primary, "claude-opus-4-6");
+      assert.equal(result!.source, "synthesized");
+    });
   });
 });

package/src/resources/extensions/gsd/tests/isolation-none-branch-guard.test.ts

@@ -1,62 +1,19 @@
-/**
- * Regression test for #3675 — isolation:none stale branch guard
- *
- * When switching from isolation:branch/worktree to isolation:none, HEAD
- * could remain on a milestone/<MID> branch. The fix in auto-start.ts
- * detects this and auto-checks out to the integration branch.
- *
- * This structural test verifies the milestone/ branch check exists
- * in auto-start.ts.
- */
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
 
-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 { resolveIsolationNoneBranchCheckout } from "../auto-start.ts";
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const source = readFileSync(join(__dirname, '..', 'auto-start.ts'), 'utf-8');
-
-describe('isolation:none stale branch guard (#3675)', () => {
-  test('checks for milestone/ branch prefix', () => {
-    assert.match(source, /startsWith\(["']milestone\//,
-      'auto-start should check for milestone/ branch prefix');
-  });
-
-  test('imports nativeGetCurrentBranch', () => {
-    assert.match(source, /nativeGetCurrentBranch/,
-      'auto-start should import nativeGetCurrentBranch');
-  });
-
-  test('imports nativeDetectMainBranch', () => {
-    assert.match(source, /nativeDetectMainBranch/,
-      'auto-start should import nativeDetectMainBranch');
-  });
-
-  test('imports nativeCheckoutBranch', () => {
-    assert.match(source, /nativeCheckoutBranch/,
-      'auto-start should import nativeCheckoutBranch');
-  });
-
-  test('guard is conditional on isolation mode "none"', () => {
-    assert.match(source, /getIsolationMode\([^)]*\)\s*===\s*["']none["']/,
-      'guard should only activate when isolation mode is "none"');
-  });
-
-  test('calls nativeCheckoutBranch to return to integration branch', () => {
-    assert.match(source, /nativeCheckoutBranch\(base,\s*integrationBranch\)/,
-      'should checkout to the integration branch');
+describe("isolation:none stale branch guard (#3675)", () => {
+  test("returns integration branch for stale milestone branch in isolation:none", () => {
+    assert.equal(
+      resolveIsolationNoneBranchCheckout("milestone/M001", "main", "none", true),
+      "main",
+    );
   });
 
-  test('guard is wrapped in try-catch (non-fatal)', () => {
-    // Find the milestone/ check and verify it is inside a try block
-    const milestoneIdx = source.indexOf('startsWith("milestone/")');
-    assert.ok(milestoneIdx > 0, 'milestone/ check should exist');
-    const before = source.slice(Math.max(0, milestoneIdx - 500), milestoneIdx);
-    assert.match(before, /try\s*\{/,
-      'milestone branch guard should be inside a try block');
+  test("does nothing outside milestone branches, repos, or isolation:none", () => {
+    assert.equal(resolveIsolationNoneBranchCheckout("feature", "main", "none", true), null);
+    assert.equal(resolveIsolationNoneBranchCheckout("milestone/M001", "main", "worktree", true), null);
+    assert.equal(resolveIsolationNoneBranchCheckout("milestone/M001", "main", "none", false), null);
   });
 });

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -85,7 +85,11 @@ function makeMockDeps(
     resolveMilestoneFile: () => null,
     reconcileMergeState: () => "clean",
     preflightCleanRoot: () => ({ stashPushed: false, summary: "" }),
-    postflightPopStash: () => {},
+    postflightPopStash: () => ({
+      restored: true,
+      needsManualRecovery: false,
+      message: "restored",
+    }),
     getLedger: () => ({ units: [] }),
     getProjectTotals: () => ({ cost: 0 }),
     formatCost: (c: number) => `$${c.toFixed(2)}`,

package/src/resources/extensions/gsd/tests/journal-query-tool.test.ts

@@ -52,6 +52,16 @@ async function executeToolInDir(tool: any, params: Record<string, unknown>, dir:
   }
 }
 
+async function executeToolWithContextRoot(tool: any, params: Record<string, unknown>, processDir: string, contextRoot: string) {
+  const originalCwd = process.cwd();
+  try {
+    process.chdir(processDir);
+    return await tool.execute("test-call-id", params, undefined, undefined, { cwd: contextRoot });
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
 // ─── Registration ─────────────────────────────────────────────────────────────
 
 test("registerJournalTools registers gsd_journal_query tool", () => {
@@ -126,6 +136,28 @@ test("gsd_journal_query respects limit parameter", async () => {
   }
 });
 
+test("gsd_journal_query uses context cwd instead of process cwd", async () => {
+  const processBase = makeTmpBase();
+  const contextBase = makeTmpBase();
+  try {
+    emitJournalEvent(processBase, makeEntry({ seq: 0, flowId: "process-flow" }));
+    emitJournalEvent(contextBase, makeEntry({ seq: 0, flowId: "context-flow" }));
+
+    const pi = makeMockPi();
+    registerJournalTools(pi);
+    const tool = pi.tools[0];
+
+    const result = await executeToolWithContextRoot(tool, { limit: 5 }, processBase, contextBase);
+    const entries = JSON.parse(result.content[0].text) as JournalEntry[];
+
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0].flowId, "context-flow");
+  } finally {
+    cleanup(processBase);
+    cleanup(contextBase);
+  }
+});
+
 // ─── Error Handling ───────────────────────────────────────────────────────────
 
 test("gsd_journal_query handles errors gracefully", async () => {

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

@@ -249,6 +249,28 @@ test('loadKnowledgeBlock: reports globalSizeKb above 4KB threshold', () => {
   rmSync(tmp, { recursive: true, force: true });
 });
 
+test('loadKnowledgeBlock: caps repeated system prompt knowledge by default with source path', () => {
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-kb-')));
+  const gsdHome = join(tmp, 'home');
+  const cwd = join(tmp, 'project');
+  mkdirSync(join(cwd, '.gsd'), { recursive: true });
+  mkdirSync(join(gsdHome, 'agent'), { recursive: true });
+  writeFileSync(join(cwd, '.gsd', 'KNOWLEDGE.md'), `K001: ${'large project knowledge '.repeat(1200)}`);
+
+  const original = process.env.PI_GSD_KNOWLEDGE_MAX_CHARS;
+  delete process.env.PI_GSD_KNOWLEDGE_MAX_CHARS;
+  try {
+    const result = loadKnowledgeBlock(gsdHome, cwd);
+    assert.ok(result.block.includes('Source: `'));
+    assert.ok(result.block.length <= 12_500, `knowledge block ${result.block.length} should stay near default cap`);
+    assert.ok(result.block.includes('[Knowledge Truncated]'));
+  } finally {
+    if (original === undefined) delete process.env.PI_GSD_KNOWLEDGE_MAX_CHARS;
+    else process.env.PI_GSD_KNOWLEDGE_MAX_CHARS = original;
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
 // ─── inlineKnowledgeBudgeted — issue #4719 ─────────────────────────────────
 // Milestone-phase prompts must not inject the full KNOWLEDGE.md. The budgeted
 // helper scopes by milestone-level keywords and caps the injected size.
@@ -315,6 +337,31 @@ test('inlineKnowledgeBudgeted: caps payload below budget for large files', async
   rmSync(tmp, { recursive: true, force: true });
 });
 
+test('inlineKnowledgeBudgeted: default budget keeps auto prompt knowledge compact', async () => {
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-knowledge-')));
+  const gsdDir = join(tmp, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+
+  const entries = Array.from({ length: 300 }, (_, i) =>
+    `### Entry ${i}: shared topic\n${'default budget filler '.repeat(25)}\n`,
+  ).join('\n');
+  writeFileSync(join(gsdDir, 'KNOWLEDGE.md'), `# Project Knowledge\n\n## Patterns\n\n${entries}`);
+
+  const result = await inlineKnowledgeBudgeted(tmp, ['shared']);
+  assert.ok(result !== null, 'should return content');
+  assert.ok(
+    result!.length <= 12_500,
+    `default payload ${result!.length} chars should stay near the 12k budget`,
+  );
+  assert.match(
+    result!,
+    /\[\.\.\.truncated \d+ chars; rerun with narrower scope if needed\]/,
+    'should include truncation note when default budget is exceeded',
+  );
+
+  rmSync(tmp, { recursive: true, force: true });
+});
+
 test('inlineKnowledgeBudgeted: returns null when no KNOWLEDGE.md exists', async () => {
   const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-knowledge-')));
   const gsdDir = join(tmp, '.gsd');