@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.eed73bea

package/src/resources/extensions/gsd/tests/forensics-error-filter.test.ts

@@ -119,3 +119,91 @@ describe("extractTrace error filtering (#2539)", () => {
     assert.equal(trace.errors.length, 1, "lint error with output should be counted");
   });
 });
+
+describe("extractTrace pending tool calls (#945)", () => {
+  test("tool call without a toolResult is counted as an error", () => {
+    const entries = [
+      {
+        type: "message",
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "toolCall",
+              id: "toolu_missing",
+              name: "gsd_summary_save",
+              arguments: { content: "unfinished summary" },
+            },
+          ],
+        },
+      },
+    ];
+
+    const trace = extractTrace(entries);
+
+    assert.equal(trace.toolCalls.length, 1);
+    assert.equal(trace.toolCalls[0]?.name, "gsd_summary_save");
+    assert.equal(trace.toolCalls[0]?.isError, true);
+    assert.equal(trace.toolCalls[0]?.result, "missing tool result (stream/tool-call abort before execution)");
+    assert.equal(trace.errors.length, 1);
+    assert.equal(trace.errors[0], "Tool call gsd_summary_save started but no toolResult was recorded");
+  });
+
+  test("pending bash call with no toolResult marks commandsRun entry as failed", () => {
+    // A bash tool call that was initiated but never got a toolResult (stream abort).
+    const entries = [
+      {
+        type: "message",
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "toolCall",
+              id: "toolu_bash_missing",
+              name: "bash",
+              arguments: { command: "npm run build" },
+            },
+          ],
+        },
+      },
+    ];
+
+    const trace = extractTrace(entries);
+
+    // The tool call should be recorded as an error.
+    assert.equal(trace.toolCalls.length, 1);
+    assert.equal(trace.toolCalls[0]?.name, "bash");
+    assert.equal(trace.toolCalls[0]?.isError, true);
+
+    // The commandsRun entry must be consistent: failed: true, not failed: false.
+    assert.equal(trace.commandsRun.length, 1);
+    assert.equal(trace.commandsRun[0]?.command, "npm run build");
+    assert.equal(trace.commandsRun[0]?.failed, true,
+      "commandsRun entry should be failed when its bash call never returned a result");
+  });
+
+  test("pending bg_shell call with no toolResult marks commandsRun entry as failed", () => {
+    const entries = [
+      {
+        type: "message",
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "toolCall",
+              id: "toolu_bg_missing",
+              name: "bg_shell",
+              arguments: { command: "sleep 30" },
+            },
+          ],
+        },
+      },
+    ];
+
+    const trace = extractTrace(entries);
+
+    assert.equal(trace.commandsRun.length, 1);
+    assert.equal(trace.commandsRun[0]?.failed, true,
+      "bg_shell commandsRun entry should be failed when no toolResult was recorded");
+  });
+});

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

@@ -86,3 +86,45 @@ test("guided milestone prompt builder preloads milestone planning context", asyn
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("guided milestone prompt builder caps prior draft seed before interpolation", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-guided-milestone-draft-cap-"));
+  const previousGsdHome = process.env.GSD_HOME;
+  process.env.GSD_HOME = join(base, ".gsd-home");
+
+  try {
+    const currentDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(currentDir, { recursive: true });
+
+    const draftPath = join(currentDir, "M001-CONTEXT-DRAFT.md");
+    writeFileSync(draftPath, "# Draft\n\nSMALL-DRAFT-SIGNAL", "utf-8");
+    const smallPrompt = await buildDiscussMilestonePrompt("M001", "Draft Resume", base, "true", {
+      includeContextMode: false,
+    });
+
+    writeFileSync(
+      draftPath,
+      ["# Draft", "", "SMALL-DRAFT-SIGNAL", "", "A".repeat(200_000), "", "OVERSIZED-DRAFT-TAIL-SIGNAL"].join("\n"),
+      "utf-8",
+    );
+    const largePrompt = await buildDiscussMilestonePrompt("M001", "Draft Resume", base, "true", {
+      includeContextMode: false,
+    });
+
+    const addedChars = largePrompt.length - smallPrompt.length;
+
+    assert.match(largePrompt, /## Prior Discussion \(Draft Seed\)/);
+    assert.match(largePrompt, /### Prior Discussion Draft/);
+    assert.match(largePrompt, /SMALL-DRAFT-SIGNAL/);
+    assert.doesNotMatch(largePrompt, /OVERSIZED-DRAFT-TAIL-SIGNAL/);
+    assert.match(
+      largePrompt,
+      /Draft seed truncated; read the full draft at `\.gsd\/milestones\/M001\/M001-CONTEXT-DRAFT\.md` if needed\./,
+    );
+    assert.ok(addedChars < 25_000, `large draft should add bounded seed chars, added ${addedChars}`);
+  } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -3,8 +3,10 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { chmodSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { performance } from "node:perf_hooks";
+import { delimiter, join } from "node:path";
 import { tmpdir } from "node:os";
 import {
   buildHealthLines,
@@ -12,8 +14,9 @@ import {
   formatRelativeTime,
   type HealthWidgetData,
 } from "../health-widget-core.ts";
-import { HEALTH_WIDGET_ACTIVE_HINTS } from "../health-widget.ts";
+import { HEALTH_WIDGET_ACTIVE_HINTS, getCachedProjectState, initHealthWidget } from "../health-widget.ts";
 import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { GIT_NO_PROMPT_ENV } from "../git-constants.ts";
 
 function makeTempDir(prefix: string): string {
   const dir = join(
@@ -32,6 +35,58 @@ function cleanup(dir: string): void {
   }
 }
 
+function runGit(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+  }).trim();
+}
+
+function makeTempRepo(prefix: string): string {
+  const dir = makeTempDir(prefix);
+  runGit(dir, "init");
+  runGit(dir, "config", "user.email", "test@test.com");
+  runGit(dir, "config", "user.name", "Test");
+  writeFileSync(join(dir, "README.md"), "# test\n", "utf-8");
+  runGit(dir, "add", "README.md");
+  runGit(dir, "commit", "-m", "initial commit");
+  return dir;
+}
+
+function installSlowGitLogShim(binDir: string): void {
+  writeFileSync(
+    join(binDir, "git"),
+    [
+      "#!/bin/sh",
+      'if [ "$1" = "log" ]; then sleep 1; fi',
+      'PATH="$GSD_REAL_PATH"',
+      "export PATH",
+      'exec git "$@"',
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+  chmodSync(join(binDir, "git"), 0o755);
+
+  writeFileSync(
+    join(binDir, "git.cmd"),
+    [
+      "@echo off",
+      'if "%1"=="log" powershell -NoProfile -Command "Start-Sleep -Seconds 1"',
+      'set "PATH=%GSD_REAL_PATH%"',
+      "git %*",
+      "",
+    ].join("\r\n"),
+    "utf-8",
+  );
+}
+
+type HealthWidgetFactory = (
+  tui: { requestRender(): void },
+  theme: { fg(style: string, text: string): string },
+) => { dispose(): void };
+
 function activeData(overrides: Partial<HealthWidgetData> = {}): HealthWidgetData {
   return {
     projectState: "active",
@@ -70,6 +125,86 @@ test("detectHealthWidgetProjectState: milestone without metrics returns active",
   assert.equal(detectHealthWidgetProjectState(dir), "active");
 });
 
+test("getCachedProjectState: reuses project state until the refresh TTL expires", (t) => {
+  const dir = makeTempDir("cached-state");
+  t.after(() => { cleanup(dir); });
+
+  let now = 1_000_000;
+  const dateNow = t.mock.method(Date, "now", () => now);
+  t.after(() => { dateNow.mock.restore(); });
+
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  assert.equal(getCachedProjectState(dir), "initialized");
+
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  assert.equal(getCachedProjectState(dir), "initialized");
+
+  now += 60_000;
+  assert.equal(getCachedProjectState(dir), "initialized");
+
+  now += 1;
+  assert.equal(getCachedProjectState(dir), "active");
+});
+
+test("getCachedProjectState: force=true bypasses TTL and returns fresh state within TTL window", (t) => {
+  const dir = makeTempDir("forced-state");
+  t.after(() => { cleanup(dir); });
+
+  let now = 2_000_000;
+  const dateNow = t.mock.method(Date, "now", () => now);
+  t.after(() => { dateNow.mock.restore(); });
+
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  // Prime the cache with "initialized".
+  assert.equal(getCachedProjectState(dir), "initialized");
+
+  // Disk changes within the TTL window.
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  now += 1_000; // well within 60s TTL
+
+  // Normal call still returns stale cached value.
+  assert.equal(getCachedProjectState(dir), "initialized");
+
+  // force=true bypasses TTL and returns the fresh disk state.
+  assert.equal(getCachedProjectState(dir, true), "active");
+
+  // Subsequent non-forced call also reflects the freshened cache.
+  assert.equal(getCachedProjectState(dir), "active");
+});
+
+test("initHealthWidget: re-init paints fresh project state within cache TTL", (t) => {
+  const dir = makeTempDir("reinit-state");
+  t.after(() => { cleanup(dir); });
+
+  let now = 3_000_000;
+  const dateNow = t.mock.method(Date, "now", () => now);
+  t.after(() => { dateNow.mock.restore(); });
+
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  t.after(() => { process.chdir(originalCwd); });
+
+  const initialLineSets: string[][] = [];
+  const ctx = {
+    hasUI: true,
+    ui: {
+      setWidget: (_key: string, value: unknown) => {
+        if (Array.isArray(value)) initialLineSets.push(value as string[]);
+      },
+    },
+  } as any;
+
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  initHealthWidget(ctx);
+  assert.equal(initialLineSets.at(-1)?.[0], "  GSD  Project Initialized");
+
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  now += 1_000;
+
+  initHealthWidget(ctx);
+  assert.match(initialLineSets.at(-1)?.[0] ?? "", /System OK/);
+});
+
 test("buildHealthLines: none state shows single onboarding line pointing at /gsd", (t) => {
   const lines = buildHealthLines(activeData({ projectState: "none" }));
   assert.equal(lines.length, 1, "renders exactly one line");
@@ -101,6 +236,136 @@ test("health widget active hints include visualization and notifications", () =>
   assert.match(HEALTH_WIDGET_ACTIVE_HINTS, /\/gsd help/);
 });
 
+test("health widget async refresh does not block timers while git log is slow", async (t) => {
+  const dir = makeTempRepo("slow-git-log");
+  const binDir = makeTempDir("slow-git-log-bin");
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  installSlowGitLogShim(binDir);
+
+  const originalCwd = process.cwd();
+  const originalProcessPath = process.env.PATH;
+  const originalEnvPath = GIT_NO_PROMPT_ENV.PATH;
+  const originalEnvRealPath = GIT_NO_PROMPT_ENV.GSD_REAL_PATH;
+  const shimmedPath = `${binDir}${delimiter}${originalProcessPath ?? ""}`;
+
+  process.chdir(dir);
+  process.env.PATH = shimmedPath;
+  GIT_NO_PROMPT_ENV.PATH = shimmedPath;
+  GIT_NO_PROMPT_ENV.GSD_REAL_PATH = originalProcessPath ?? "";
+
+  let factory: HealthWidgetFactory | null = null;
+  let resolveRefresh: (() => void) | undefined;
+  const refreshed = new Promise<void>((resolve) => { resolveRefresh = resolve; });
+  const gaps: number[] = [];
+  let lastTick = performance.now();
+  let heartbeat: NodeJS.Timeout | undefined;
+  let refreshTimeout: NodeJS.Timeout | undefined;
+  let widget: { dispose(): void } | undefined;
+
+  t.after(() => {
+    if (widget) widget.dispose();
+    if (heartbeat) clearInterval(heartbeat);
+    if (refreshTimeout) clearTimeout(refreshTimeout);
+    process.chdir(originalCwd);
+    if (originalProcessPath === undefined) delete process.env.PATH;
+    else process.env.PATH = originalProcessPath;
+    if (originalEnvPath === undefined) delete GIT_NO_PROMPT_ENV.PATH;
+    else GIT_NO_PROMPT_ENV.PATH = originalEnvPath;
+    if (originalEnvRealPath === undefined) delete GIT_NO_PROMPT_ENV.GSD_REAL_PATH;
+    else GIT_NO_PROMPT_ENV.GSD_REAL_PATH = originalEnvRealPath;
+    cleanup(binDir);
+    cleanup(dir);
+  });
+
+  initHealthWidget({
+    hasUI: true,
+    ui: {
+      setWidget: (_key: string, value: unknown) => {
+        if (typeof value === "function") factory = value as HealthWidgetFactory;
+      },
+    },
+  } as any);
+
+  assert.ok(factory, "health widget factory is registered");
+
+  heartbeat = setInterval(() => {
+    const now = performance.now();
+    gaps.push(now - lastTick);
+    lastTick = now;
+  }, 25);
+
+  // assert.ok above guards at runtime; double-cast is needed because TypeScript
+  // cannot track the factory assignment through the `as any` closure call.
+  widget = (factory as unknown as HealthWidgetFactory)(
+    { requestRender: () => { resolveRefresh?.(); } },
+    { fg: (_style: string, text: string) => text },
+  );
+
+  await Promise.race([
+    refreshed,
+    new Promise<never>((_, reject) => {
+      refreshTimeout = setTimeout(() => reject(new Error("health widget refresh did not complete")), 4_000);
+    }),
+  ]);
+  if (refreshTimeout) clearTimeout(refreshTimeout);
+
+  assert.ok(gaps.length > 0, "heartbeat ran while refresh was in flight");
+  const maxGap = Math.max(...gaps);
+  assert.ok(maxGap < 750, `slow git log must not starve timers; max gap was ${Math.round(maxGap)}ms`);
+});
+
+test("initHealthWidget: synchronous first-paint render never contains last-commit info (regression #964)", (t) => {
+  // Before the fix, loadHealthWidgetData with includeChecks:true called
+  // loadLastCommitInfo — synchronous native-git-bridge ops (nativeIsRepo,
+  // nativeGetCurrentBranch, nativeLastCommitEpoch, nativeCommitSubject) — which
+  // froze the TUI on slow repos. The fix removes that synchronous git path
+  // entirely: lastCommitEpoch/lastCommitMessage are now always null from the
+  // synchronous loader; only the async refresh (loadLastCommitInfoAsync) fills
+  // them in. This test guards that contract by verifying that the initial
+  // string-array setWidget call never contains "Last commit:" even on a real
+  // git repo where native git queries would succeed.
+  const dir = makeTempRepo("sync-last-commit-regression");
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+
+  let widget: { dispose(): void } | undefined;
+  t.after(() => {
+    if (widget) widget.dispose();
+    process.chdir(originalCwd);
+    cleanup(dir);
+  });
+
+  const initialRenders: string[][] = [];
+
+  initHealthWidget({
+    hasUI: true,
+    ui: {
+      setWidget: (_key: string, value: unknown) => {
+        if (Array.isArray(value)) {
+          initialRenders.push(value as string[]);
+        } else if (typeof value === "function") {
+          // Instantiate the factory to satisfy dispose(), but do not await the
+          // async refresh — we are only inspecting the synchronous first-paint.
+          widget = (value as unknown as HealthWidgetFactory)(
+            { requestRender: () => {} },
+            { fg: (_style: string, text: string) => text },
+          );
+        }
+      },
+    },
+  } as any);
+
+  assert.ok(initialRenders.length > 0, "at least one synchronous setWidget call");
+
+  const combined = initialRenders.flat().join("\n");
+  assert.ok(
+    !combined.includes("Last commit:"),
+    "synchronous first-paint render must not contain 'Last commit:' — sync git path removed (regression #964)",
+  );
+});
+
 test("buildHealthLines: active state with budget ceiling shows percent summary", (t) => {
   const lines = buildHealthLines(activeData({ budgetSpent: 2.5, budgetCeiling: 10 }));
   assert.equal(lines.length, 1);

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

@@ -3,7 +3,7 @@
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, symlinkSync, readFileSync, chmodSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join, dirname, delimiter } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync, execSync } from "node:child_process";
 
@@ -23,6 +23,7 @@ import {
   type PreMergeCheckResult,
   type TaskCommitContext,
 } from "../../git-service.ts";
+import { GIT_NO_PROMPT_ENV } from "../../git-constants.ts";
 import { nativeAddAllWithExclusions, nativeHasChanges, _resetHasChangesCache } from "../../native-git-bridge.ts";
 function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
@@ -405,6 +406,49 @@ describe('git-service', async () => {
     }).trim();
   }
 
+  function findGitExecutable(): string {
+    const command = process.platform === "win32" ? "where git" : "command -v git";
+    const output = execSync(command, { encoding: "utf-8" });
+    const found = output.split(/\r?\n/).map(line => line.trim()).find(Boolean);
+    assert.ok(found, "git executable is available");
+    return found;
+  }
+
+  function installGitRmCachedCounterShim(shimDir: string): void {
+    const shimScript = join(shimDir, "git-shim.cjs");
+    writeFileSync(shimScript, `
+const { appendFileSync } = require("node:fs");
+const { spawnSync } = require("node:child_process");
+
+const args = process.argv.slice(2);
+if (args[0] === "rm" && args[1] === "--cached") {
+  appendFileSync(process.env.GSD_GIT_SHIM_LOG, args.join("\\0") + "\\n");
+}
+
+const result = spawnSync(process.env.GSD_REAL_GIT || "git", args, {
+  stdio: "inherit",
+  env: process.env,
+});
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+process.exit(result.status ?? 0);
+`.trimStart(), "utf-8");
+
+    const posixShim = join(shimDir, "git");
+    const quotedScript = `'${shimScript.replace(/'/g, "'\\''")}'`;
+    writeFileSync(posixShim, `#!/bin/sh\nexec node ${quotedScript} "$@"\n`, "utf-8");
+    chmodSync(posixShim, 0o755);
+
+    writeFileSync(join(shimDir, "git.cmd"), "@echo off\r\nnode \"%~dp0git-shim.cjs\" %*\r\n", "utf-8");
+  }
+
+  function countRmCachedInvocations(logFile: string): number {
+    if (!existsSync(logFile)) return 0;
+    return readFileSync(logFile, "utf-8").split(/\r?\n/).filter(Boolean).length;
+  }
+
   // ─── GitServiceImpl: smart staging ─────────────────────────────────────
 
   test('GitServiceImpl: smart staging', () => {
@@ -447,6 +491,80 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('GitServiceImpl: runtime cleanup runs once per repo across service instances', () => {
+    const repo = initTempRepo();
+    const shimDir = mkdtempSync(join(tmpdir(), "gsd-git-rm-shim-"));
+    const logFile = join(shimDir, "git-rm-cached.log");
+    const originalPath = process.env.PATH;
+    const originalRealGit = process.env.GSD_REAL_GIT;
+    const originalShimLog = process.env.GSD_GIT_SHIM_LOG;
+    const originalSafePath = GIT_NO_PROMPT_ENV.PATH;
+    const originalSafeRealGit = GIT_NO_PROMPT_ENV.GSD_REAL_GIT;
+    const originalSafeShimLog = GIT_NO_PROMPT_ENV.GSD_GIT_SHIM_LOG;
+
+    try {
+      installGitRmCachedCounterShim(shimDir);
+      const realGit = findGitExecutable();
+      process.env.GSD_REAL_GIT = realGit;
+      process.env.GSD_GIT_SHIM_LOG = logFile;
+      process.env.PATH = `${shimDir}${delimiter}${originalPath ?? ""}`;
+      GIT_NO_PROMPT_ENV.GSD_REAL_GIT = realGit;
+      GIT_NO_PROMPT_ENV.GSD_GIT_SHIM_LOG = logFile;
+      GIT_NO_PROMPT_ENV.PATH = process.env.PATH;
+
+      createFile(repo, "src/first.ts", "first");
+      const first = new GitServiceImpl(repo).commit({ message: "test: first cleanup pass" });
+      assert.deepStrictEqual(first, "test: first cleanup pass", "first commit succeeds");
+      assert.deepStrictEqual(
+        countRmCachedInvocations(logFile),
+        RUNTIME_EXCLUSION_PATHS.length,
+        "first service instance checks each runtime exclusion once",
+      );
+
+      createFile(repo, "src/second.ts", "second");
+      const second = new GitServiceImpl(repo).commit({ message: "test: second cleanup pass" });
+      assert.deepStrictEqual(second, "test: second cleanup pass", "second commit succeeds");
+      assert.deepStrictEqual(
+        countRmCachedInvocations(logFile),
+        RUNTIME_EXCLUSION_PATHS.length,
+        "fresh service instance for the same repo does not rerun runtime cleanup",
+      );
+    } finally {
+      if (originalPath === undefined) {
+        delete process.env.PATH;
+      } else {
+        process.env.PATH = originalPath;
+      }
+      if (originalRealGit === undefined) {
+        delete process.env.GSD_REAL_GIT;
+      } else {
+        process.env.GSD_REAL_GIT = originalRealGit;
+      }
+      if (originalShimLog === undefined) {
+        delete process.env.GSD_GIT_SHIM_LOG;
+      } else {
+        process.env.GSD_GIT_SHIM_LOG = originalShimLog;
+      }
+      if (originalSafePath === undefined) {
+        delete GIT_NO_PROMPT_ENV.PATH;
+      } else {
+        GIT_NO_PROMPT_ENV.PATH = originalSafePath;
+      }
+      if (originalSafeRealGit === undefined) {
+        delete GIT_NO_PROMPT_ENV.GSD_REAL_GIT;
+      } else {
+        GIT_NO_PROMPT_ENV.GSD_REAL_GIT = originalSafeRealGit;
+      }
+      if (originalSafeShimLog === undefined) {
+        delete GIT_NO_PROMPT_ENV.GSD_GIT_SHIM_LOG;
+      } else {
+        GIT_NO_PROMPT_ENV.GSD_GIT_SHIM_LOG = originalSafeShimLog;
+      }
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(shimDir, { recursive: true, force: true });
+    }
+  });
+
   test('GitServiceImpl: task autoCommit skips keyFiles inside submodules', () => {
     const repo = initTempRepo();
     const subSrc = mkdtempSync(join(tmpdir(), "gsd-git-submodule-src-"));

package/src/resources/extensions/gsd/tests/integration/queue-active-milestone-context-budget.test.ts

@@ -0,0 +1,93 @@
+import { describe, test } 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 { buildExistingMilestonesContext } from "../../guided-flow-queue.ts";
+import type { GSDState, MilestoneRegistryEntry } from "../../types.ts";
+
+const LARGE_BODY = "A".repeat(150_000);
+const LARGE_DRAFT = "D".repeat(150_000);
+const LARGE_ROADMAP = "R".repeat(150_000);
+
+function makeState(registry: MilestoneRegistryEntry[]): GSDState {
+  return {
+    activeMilestone: registry.find(m => m.status === "active") ?? null,
+    activeSlice: null,
+    activeTask: null,
+    phase: "executing",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry,
+  };
+}
+
+function writeMilestoneArtifact(base: string, mid: string, suffix: string, content: string): void {
+  mkdirSync(join(base, ".gsd", "milestones", mid), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", mid, `${mid}-${suffix}.md`), content);
+}
+
+describe("queue active/pending milestone context budget", () => {
+  test("summarizes active and pending artifacts with source paths and bounded excerpts", async () => {
+    const tmpBase = mkdtempSync(join(tmpdir(), "gsd-queue-active-budget-"));
+    try {
+      writeMilestoneArtifact(tmpBase, "M001", "CONTEXT", `# Active context\n\n${LARGE_BODY}\nEND_ACTIVE_CONTEXT`);
+      writeMilestoneArtifact(tmpBase, "M001", "ROADMAP", `# Active roadmap\n\n${LARGE_ROADMAP}\nEND_ACTIVE_ROADMAP`);
+      writeMilestoneArtifact(tmpBase, "M002", "CONTEXT-DRAFT", `# Pending draft\n\n${LARGE_DRAFT}\nEND_PENDING_DRAFT`);
+      writeMilestoneArtifact(tmpBase, "M002", "ROADMAP", `# Pending roadmap\n\n${LARGE_ROADMAP}\nEND_PENDING_ROADMAP`);
+
+      const registry: MilestoneRegistryEntry[] = [
+        { id: "M001", title: "Active milestone", status: "active" },
+        { id: "M002", title: "Pending milestone", status: "pending" },
+      ];
+
+      const context = await buildExistingMilestonesContext(tmpBase, ["M001", "M002"], makeState(registry));
+
+      assert.match(context, /Source: `.gsd\/milestones\/M001\/M001-CONTEXT.md`/);
+      assert.match(context, /Source: `.gsd\/milestones\/M001\/M001-ROADMAP.md`/);
+      assert.match(context, /Source: `.gsd\/milestones\/M002\/M002-CONTEXT-DRAFT.md`/);
+      assert.match(context, /Source: `.gsd\/milestones\/M002\/M002-ROADMAP.md`/);
+      assert.match(context, /Read `.gsd\/milestones\/M001\/M001-CONTEXT.md` for full content/);
+      assert.equal(context.includes("END_ACTIVE_CONTEXT"), false);
+      assert.equal(context.includes("END_ACTIVE_ROADMAP"), false);
+      assert.equal(context.includes("END_PENDING_DRAFT"), false);
+      assert.equal(context.includes("END_PENDING_ROADMAP"), false);
+    } finally {
+      rmSync(tmpBase, { recursive: true, force: true });
+    }
+  });
+
+  test("caps the total existing milestones context", async () => {
+    const tmpBase = mkdtempSync(join(tmpdir(), "gsd-queue-total-budget-"));
+    try {
+      const registry: MilestoneRegistryEntry[] = [];
+      const milestoneIds: string[] = [];
+      for (let i = 1; i <= 5; i++) {
+        const mid = `M${String(i).padStart(3, "0")}`;
+        milestoneIds.push(mid);
+        registry.push({ id: mid, title: `Pending milestone ${i}`, status: "pending" });
+        writeMilestoneArtifact(tmpBase, mid, "CONTEXT", `# ${mid} context\n\n${LARGE_BODY}\nEND_${mid}_CONTEXT`);
+        writeMilestoneArtifact(tmpBase, mid, "ROADMAP", `# ${mid} roadmap\n\n${LARGE_ROADMAP}\nEND_${mid}_ROADMAP`);
+      }
+
+      const context = await buildExistingMilestonesContext(tmpBase, milestoneIds, makeState(registry));
+
+      assert.ok(
+        context.length <= 120_000,
+        `expected total context to stay within budget, got ${context.length} chars`,
+      );
+      assert.match(context, /Existing milestones context truncated/);
+      for (let i = 1; i <= 5; i++) {
+        const mid = `M${String(i).padStart(3, "0")}`;
+        assert.match(context, new RegExp(`### ${mid}: Pending milestone ${i}`));
+        assert.match(context, new RegExp(`Source: \`.gsd/milestones/${mid}/${mid}-CONTEXT.md\``));
+        assert.match(context, new RegExp(`Source: \`.gsd/milestones/${mid}/${mid}-ROADMAP.md\``));
+      }
+      assert.equal(context.includes("END_M005_ROADMAP"), false);
+    } finally {
+      rmSync(tmpBase, { recursive: true, force: true });
+    }
+  });
+});