gsd-pi 2.80.0-dev.cf9433f56 → 2.80.0-dev.d4fc28e6b

package/src/resources/extensions/gsd/tests/clean-root-preflight.test.ts

@@ -131,9 +131,11 @@ test("postflightPopStash — restores stashed changes and emits info notificatio
     run('git commit -m "simulate merge"', repo);
 
     const postNotifications: Array<{ msg: string; level: string }> = [];
-    postflightPopStash(repo, "M004", preflight.stashMarker, (msg, level) => {
+    const postflight = postflightPopStash(repo, "M004", preflight.stashMarker, (msg, level) => {
       postNotifications.push({ msg, level });
     });
+    assert.equal(postflight.restored, true, "postflight must report successful restore");
+    assert.equal(postflight.needsManualRecovery, false, "successful restore must not need manual recovery");
 
     // The stashed README.md change must be restored
     const content = readFileSync(join(repo, "README.md"), "utf-8");
@@ -171,7 +173,8 @@ test("preflight + merge + postflight round-trip preserves uncommitted changes",
     run('git commit -m "feat: add feature"', repo);
 
     // Postflight: pop stash
-    postflightPopStash(repo, "M005", preflight.stashMarker, () => {});
+    const postflight = postflightPopStash(repo, "M005", preflight.stashMarker, () => {});
+    assert.equal(postflight.needsManualRecovery, false, "clean restore must not stop auto-mode");
 
     // README.md must still have our local content
     const restored = readFileSync(join(repo, "README.md"), "utf-8");
@@ -197,9 +200,12 @@ test("postflightPopStash conflict warning names the exact stash ref", () => {
     run('git commit -m "simulate conflicting merge"', repo);
 
     const notifications: Array<{ msg: string; level: string }> = [];
-    postflightPopStash(repo, "M005C", preflight.stashMarker, (msg, level) => {
+    const postflight = postflightPopStash(repo, "M005C", preflight.stashMarker, (msg, level) => {
       notifications.push({ msg, level });
     });
+    assert.equal(postflight.restored, false, "conflicted restore must report restored=false");
+    assert.equal(postflight.needsManualRecovery, true, "conflicted restore must require manual recovery");
+    assert.match(postflight.message, /failed after merge of milestone M005C/);
 
     const warning = notifications.find((n) => n.level === "warning")?.msg ?? "";
     assert.match(warning, /git stash pop stash@\{\d+\}/);
@@ -219,7 +225,8 @@ test("postflightPopStash restores the matching GSD stash, not stash@{0}", () =>
     writeFileSync(join(repo, "other.txt"), "other stash\n");
     run('git stash push --include-untracked -m "unrelated newer stash"', repo);
 
-    postflightPopStash(repo, "M006", preflight.stashMarker, () => {});
+    const postflight = postflightPopStash(repo, "M006", preflight.stashMarker, () => {});
+    assert.equal(postflight.needsManualRecovery, false, "targeted restore must not need manual recovery");
 
     const content = readFileSync(join(repo, "README.md"), "utf-8");
     assert.equal(content.replace(/\r\n/g, "\n"), "# target stash\n");
@@ -242,7 +249,8 @@ test("postflightPopStash restores the exact preflight marker when another same-m
     writeFileSync(join(repo, "same-milestone.txt"), "newer same milestone stash\n");
     run('git stash push --include-untracked -m "gsd-preflight-stash [gsd-preflight-stash:M007:other]"', repo);
 
-    postflightPopStash(repo, "M007", preflight.stashMarker, () => {});
+    const postflight = postflightPopStash(repo, "M007", preflight.stashMarker, () => {});
+    assert.equal(postflight.needsManualRecovery, false, "exact marker restore must not need manual recovery");
 
     const content = readFileSync(join(repo, "README.md"), "utf-8");
     assert.equal(content.replace(/\r\n/g, "\n"), "# target stash\n");
@@ -260,7 +268,8 @@ test("postflightPopStash falls back to milestone marker prefix when exact marker
     writeFileSync(join(repo, "README.md"), "# fallback stash\n");
     run('git stash push --include-untracked -m "gsd-preflight-stash [gsd-preflight-stash:M008:fallback]"', repo);
 
-    postflightPopStash(repo, "M008", undefined, () => {});
+    const postflight = postflightPopStash(repo, "M008", undefined, () => {});
+    assert.equal(postflight.needsManualRecovery, false, "fallback marker restore must not need manual recovery");
 
     const content = readFileSync(join(repo, "README.md"), "utf-8");
     assert.equal(content.replace(/\r\n/g, "\n"), "# fallback stash\n");

package/src/resources/extensions/gsd/tests/complete-milestone-excerpt.test.ts

@@ -261,3 +261,34 @@ test("#4780 closer prompt: uses excerpts + lists on-demand slice SUMMARY paths",
     `closer prompt length ${prompt.length} should be < raw summary size ${rawSize} + 20KB headroom`,
   );
 });
+
+test("complete-milestone prompt caps repeated inlined context around 20k chars", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  writeRoadmap(base, makeRoadmap());
+  writeSummary(base, "S01", makeFatSummary("S01"));
+  writeSummary(base, "S02", makeFatSummary("S02"));
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001 Context\n\n" + "Large milestone context body. ".repeat(1200),
+  );
+  writeFileSync(
+    join(base, ".gsd", "KNOWLEDGE.md"),
+    "# Project Knowledge\n\n## Patterns\n\n### Test Milestone shared\n" + "Large scoped knowledge body. ".repeat(1200),
+  );
+
+  const prompt = await buildCompleteMilestonePrompt("M001", "Test Milestone", base);
+  const contextStart = prompt.indexOf("## Inlined Context (preloaded");
+  const contextEnd = prompt.indexOf("## Steps", contextStart);
+  assert.ok(contextStart >= 0, "prompt should include inlined context");
+  assert.ok(contextEnd > contextStart, "prompt should include steps after inlined context");
+
+  const inlinedContext = prompt.slice(contextStart, contextEnd);
+  assert.ok(
+    inlinedContext.length <= 21_000,
+    `inlined context ${inlinedContext.length} chars should stay near the 20k cap`,
+  );
+  assert.match(inlinedContext, /\[\.\.\.truncated \d+ sections\]/);
+});

package/src/resources/extensions/gsd/tests/complete-slice-composer.test.ts

@@ -113,8 +113,9 @@ test("#4782 phase 3: buildCompleteSlicePrompt composes roadmap → plan → task
     "task summaries precede slice-summary template",
   );
 
-  // Task body inlined
-  assert.match(prompt, /Task one did the thing/);
+  // Task summary excerpt is inlined; full narrative remains on-demand.
+  assert.match(prompt, /### Task Summary: T01 \(excerpt\)/);
+  assert.doesNotMatch(prompt, /Task one did the thing/);
 });
 
 test("#4782 phase 3: buildCompleteSlicePrompt handles missing task summaries gracefully", async (t) => {

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

@@ -1,3 +1,5 @@
+// GSD-2 + context-store.test.ts — Regression coverage for DB-backed context query helpers.
+
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import {
@@ -362,7 +364,11 @@ describe("context-store: sub-5ms query timing", () => {
 
     assert.strictEqual(decisions.length, 50, `got ${decisions.length} decisions (expected 50)`);
     assert.strictEqual(requirements.length, 50, `got ${requirements.length} requirements (expected 50)`);
-    assert.ok(elapsed < 5, `query latency ${elapsed.toFixed(2)}ms should be < 5ms`);
+    const maxLatencyMs = process.env.NODE_V8_COVERAGE ? 15 : 5;
+    assert.ok(
+      elapsed < maxLatencyMs,
+      `query latency ${elapsed.toFixed(2)}ms should be < ${maxLatencyMs}ms`,
+    );
   });
 });
 

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -192,7 +192,11 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     resolveMilestoneFile: () => null,
     reconcileMergeState: () => "clean",
     preflightCleanRoot: () => ({ stashPushed: false, summary: "" }),
-    postflightPopStash: () => {},
+    postflightPopStash: () => ({
+      restored: true,
+      needsManualRecovery: false,
+      message: "restored",
+    }),
     getLedger: () => null,
     getProjectTotals: () => ({ cost: 0 }),
     formatCost: (c: number) => `$${c.toFixed(2)}`,

package/src/resources/extensions/gsd/tests/execute-task-rendering.test.ts

@@ -39,6 +39,7 @@ test("execute-task prompt renders compact execution and completion gates", async
     taskPlanPath: ".gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md",
     priorTaskLines: "- None",
     skillActivation: "Load relevant skills.",
+    inlinedTemplates: "### Output Template: Task Summary\nSource: `templates/task-summary.md`",
     templatesDir: join(fixtureRoot, "templates"),
     taskSummaryTemplatePath: "C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\task-summary.md",
     verificationBudget: "~10K chars",
@@ -46,12 +47,14 @@ test("execute-task prompt renders compact execution and completion gates", async
   });
 
   assert.match(prompt, /You execute\./);
-  assert.match(prompt, /Call `memory_query`/);
+  assert.match(prompt, /Call `memory_query`.*only when no injected memory block exists/s);
   assert.match(prompt, /Before any `Write` that creates an artifact or output file/);
   assert.match(prompt, /Build real behavior/);
   assert.match(prompt, /Background process rule/);
   assert.match(prompt, /blocker_discovered: true/);
-  assert.match(prompt, /C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\task-summary\.md/);
+  assert.match(prompt, /Use the inlined Task Summary template below/);
+  assert.match(prompt, /Read `C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\task-summary\.md` only if the inlined template is absent or visibly truncated/);
+  assert.match(prompt, /### Output Template: Task Summary/);
   assert.doesNotMatch(prompt, /\{\{templatesDir\}\}\/task-summary\.md/);
   assert.match(prompt, /Call `gsd_task_complete`/);
   assert.match(prompt, /Do not run git commands/);

package/src/resources/extensions/gsd/tests/fast-forward-reused-milestone-branch.test.ts

@@ -0,0 +1,219 @@
+// GSD-2 + src/resources/extensions/gsd/tests/fast-forward-reused-milestone-branch.test.ts
+// Regression: when createAutoWorktree reuses an existing milestone branch,
+// it must be fast-forwarded onto integration so the next milestone forks
+// from up-to-date code (#5538-followup).
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+
+import {
+  fastForwardReusedMilestoneBranchIfSafe,
+  _isBranchCheckedOutElsewhere,
+} from "../auto-worktree.js";
+
+const NO_PROMPT_ENV = {
+  ...process.env,
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_AUTHOR_NAME: "test",
+  GIT_AUTHOR_EMAIL: "test@example.com",
+  GIT_COMMITTER_NAME: "test",
+  GIT_COMMITTER_EMAIL: "test@example.com",
+};
+
+function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: NO_PROMPT_ENV,
+  });
+}
+
+function rev(cwd: string, ref: string): string {
+  return git(cwd, "rev-parse", ref).trim();
+}
+
+describe("fastForwardReusedMilestoneBranchIfSafe", () => {
+  let repo: string;
+
+  beforeEach(() => {
+    repo = mkdtempSync(join(tmpdir(), "ff-reused-branch-"));
+    git(repo, "init", "-q", "-b", "main");
+    git(repo, "config", "user.email", "test@example.com");
+    git(repo, "config", "user.name", "test");
+    writeFileSync(join(repo, "seed.txt"), "seed\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "initial");
+  });
+
+  afterEach(() => {
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test("fast-forwards a milestone branch that is strictly behind integration (regression: stale base)", () => {
+    // Create milestone/M001 from main's initial commit, then advance main.
+    git(repo, "branch", "milestone/M001");
+    const m001Initial = rev(repo, "milestone/M001");
+
+    writeFileSync(join(repo, "seed.txt"), "advanced\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "main moved forward");
+    const mainTip = rev(repo, "main");
+
+    assert.notEqual(m001Initial, mainTip, "main must be ahead before the test");
+
+    fastForwardReusedMilestoneBranchIfSafe(repo, "M001", "milestone/M001");
+
+    assert.equal(
+      rev(repo, "milestone/M001"),
+      mainTip,
+      "milestone/M001 must be fast-forwarded to main's tip",
+    );
+  });
+
+  test("does not touch a milestone branch that has its own commits ahead", () => {
+    // Branch from main, add a unique commit, then advance main.
+    git(repo, "checkout", "-q", "-b", "milestone/M001");
+    writeFileSync(join(repo, "milestone-only.txt"), "milestone work\n");
+    git(repo, "add", "milestone-only.txt");
+    git(repo, "commit", "-q", "-m", "M001 work");
+    const milestoneTip = rev(repo, "milestone/M001");
+
+    git(repo, "checkout", "-q", "main");
+    writeFileSync(join(repo, "seed.txt"), "advanced\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "main moved forward");
+
+    fastForwardReusedMilestoneBranchIfSafe(repo, "M001", "milestone/M001");
+
+    assert.equal(
+      rev(repo, "milestone/M001"),
+      milestoneTip,
+      "diverged milestone branch must NOT be touched (would lose work)",
+    );
+  });
+
+  test("is a no-op when milestone branch is already up-to-date with main", () => {
+    git(repo, "branch", "milestone/M001");
+    const before = rev(repo, "milestone/M001");
+
+    fastForwardReusedMilestoneBranchIfSafe(repo, "M001", "milestone/M001");
+
+    assert.equal(rev(repo, "milestone/M001"), before, "ref must not move");
+  });
+
+  test("does nothing when the milestone branch does not exist", () => {
+    // Should silently return — no error, no side effects.
+    assert.doesNotThrow(() =>
+      fastForwardReusedMilestoneBranchIfSafe(repo, "M999", "milestone/M999"),
+    );
+  });
+
+  test("does nothing in a non-git directory", () => {
+    const nonRepo = mkdtempSync(join(tmpdir(), "ff-not-a-repo-"));
+    try {
+      assert.doesNotThrow(() =>
+        fastForwardReusedMilestoneBranchIfSafe(nonRepo, "M001", "milestone/M001"),
+      );
+    } finally {
+      rmSync(nonRepo, { recursive: true, force: true });
+    }
+  });
+
+  test("skips fast-forward when branch is checked out in another worktree (peer-review regression)", () => {
+    // Codex peer review caught: `nativeUpdateRef` succeeds even when the
+    // branch is checked out in a linked worktree, leaving that worktree's
+    // HEAD inconsistent with its index/work tree. The fix calls
+    // `nativeWorktreeList` first and skips the FF if any worktree owns the
+    // target branch. This test sets up the exact scenario.
+    git(repo, "branch", "milestone/M001");
+    const m001Initial = rev(repo, "milestone/M001");
+
+    // Add a linked worktree that checks out milestone/M001.
+    const wtPath = join(repo, "..", `${basename(repo)}-wt`);
+    git(repo, "worktree", "add", wtPath, "milestone/M001");
+
+    // Advance main so a fast-forward would otherwise apply.
+    writeFileSync(join(repo, "seed.txt"), "advanced\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "main moved forward");
+
+    try {
+      fastForwardReusedMilestoneBranchIfSafe(repo, "M001", "milestone/M001");
+
+      assert.equal(
+        rev(repo, "milestone/M001"),
+        m001Initial,
+        "milestone/M001 must NOT move while a linked worktree has it checked out",
+      );
+    } finally {
+      git(repo, "worktree", "remove", "--force", wtPath);
+      rmSync(wtPath, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("_isBranchCheckedOutElsewhere", () => {
+  let repo: string;
+
+  beforeEach(() => {
+    repo = mkdtempSync(join(tmpdir(), "is-checked-out-"));
+    git(repo, "init", "-q", "-b", "main");
+    git(repo, "config", "user.email", "test@example.com");
+    git(repo, "config", "user.name", "test");
+    writeFileSync(join(repo, "seed.txt"), "seed\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "initial");
+  });
+
+  afterEach(() => {
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test("returns true when branch is checked out in a linked worktree", () => {
+    git(repo, "branch", "milestone/M001");
+    const wtPath = join(repo, "..", `${basename(repo)}-wt`);
+    git(repo, "worktree", "add", wtPath, "milestone/M001");
+    try {
+      assert.equal(_isBranchCheckedOutElsewhere(repo, "milestone/M001"), true);
+    } finally {
+      git(repo, "worktree", "remove", "--force", wtPath);
+      rmSync(wtPath, { recursive: true, force: true });
+    }
+  });
+
+  test("returns true when branch is checked out in the main worktree itself", () => {
+    // The default checkout. `git worktree list --porcelain` reports the
+    // primary worktree too, so a branch checked out there counts as
+    // "checked out elsewhere" relative to a fresh ref update intent.
+    git(repo, "checkout", "-q", "-b", "milestone/M002");
+    assert.equal(_isBranchCheckedOutElsewhere(repo, "milestone/M002"), true);
+  });
+
+  test("returns false when branch exists but is not checked out anywhere", () => {
+    git(repo, "branch", "milestone/M003");
+    assert.equal(_isBranchCheckedOutElsewhere(repo, "milestone/M003"), false);
+  });
+
+  test("returns false for an unknown branch in a clean repo", () => {
+    assert.equal(_isBranchCheckedOutElsewhere(repo, "milestone/M999"), false);
+  });
+
+  test("returns false on a non-git directory (empty worktree list)", () => {
+    // nativeWorktreeList does not throw on a non-repo — it returns []. The
+    // parent function `fastForwardReusedMilestoneBranchIfSafe` never reaches
+    // this code path on a non-repo because `nativeBranchExists` short-circuits
+    // earlier. Documenting actual behavior so future readers don't expect a
+    // fail-safe `true` here.
+    const nonRepo = mkdtempSync(join(tmpdir(), "is-checked-out-not-repo-"));
+    try {
+      assert.equal(_isBranchCheckedOutElsewhere(nonRepo, "milestone/M001"), false);
+    } finally {
+      rmSync(nonRepo, { recursive: true, force: true });
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/finalize-survivor-branch.test.ts

@@ -0,0 +1,132 @@
+// GSD-2 + src/resources/extensions/gsd/tests/finalize-survivor-branch.test.ts
+// Regression: a thrown error from `_mergeBranchMode` (made fail-loud in
+// commit 68ef58a3c) must be caught at the survivor-finalize call site so
+// bootstrap surfaces an error notify instead of an unhandled exception
+// propagating to the slash-command caller (#5549 post-merge audit, R2).
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { _finalizeSurvivorBranch } from "../auto-start.js";
+import type { WorktreeResolver } from "../worktree-resolver.js";
+
+interface FakeResolverState {
+  mergeCalls: Array<{ milestoneId: string }>;
+  shouldThrow?: unknown;
+}
+
+function fakeResolver(state: FakeResolverState): WorktreeResolver {
+  return {
+    mergeAndExit: (milestoneId: string) => {
+      state.mergeCalls.push({ milestoneId });
+      if (state.shouldThrow) throw state.shouldThrow;
+    },
+  } as unknown as WorktreeResolver;
+}
+
+interface FakeUiState {
+  notifications: Array<{ message: string; level: string }>;
+}
+
+function fakeUi(state: FakeUiState): {
+  notify: (msg: string, level?: "info" | "warning" | "error" | "success") => void;
+} {
+  return {
+    notify: (message: string, level?: "info" | "warning" | "error" | "success") => {
+      state.notifications.push({ message, level: level ?? "info" });
+    },
+  };
+}
+
+test("happy path: survivor merge runs, returns merged:true, info notify announces the merge", () => {
+  const resolverState: FakeResolverState = { mergeCalls: [] };
+  const uiState: FakeUiState = { notifications: [] };
+  const result = _finalizeSurvivorBranch(
+    fakeResolver(resolverState),
+    "M001",
+    fakeUi(uiState),
+  );
+
+  assert.deepEqual(result, { merged: true });
+  assert.deepEqual(resolverState.mergeCalls, [{ milestoneId: "M001" }]);
+  assert.equal(uiState.notifications.length, 1);
+  assert.equal(uiState.notifications[0].level, "info");
+  assert.match(
+    uiState.notifications[0].message,
+    /Milestone M001 is complete but branch\/worktree was not finalized/,
+  );
+});
+
+test("regression: thrown error from mergeAndExit (e.g. wrong-branch) is caught and surfaced as error notify", () => {
+  // Pre-PR-5549 commit 5: `_mergeBranchMode` returned false silently.
+  // Post-commit 5: it throws. Without this fix, the throw at auto-start.ts
+  // line ~810 would bubble through `bootstrapAutoSession` to
+  // `startAutoDetached`'s top-level .catch as an unhandled-exception log
+  // — observable as a stack trace instead of a clean failure notification.
+  const boom = new Error("dirty working tree blocks checkout");
+  const resolverState: FakeResolverState = { mergeCalls: [], shouldThrow: boom };
+  const uiState: FakeUiState = { notifications: [] };
+
+  // Must not throw.
+  const result = _finalizeSurvivorBranch(
+    fakeResolver(resolverState),
+    "M001",
+    fakeUi(uiState),
+  );
+
+  assert.equal(result.merged, false);
+  assert.equal(result.error, boom);
+
+  // Two notifies: info (announce) + error (the failure detail).
+  assert.equal(uiState.notifications.length, 2);
+  assert.equal(uiState.notifications[0].level, "info");
+  assert.equal(uiState.notifications[1].level, "error");
+  assert.match(
+    uiState.notifications[1].message,
+    /Survivor-branch finalization for M001 failed/,
+  );
+  assert.match(uiState.notifications[1].message, /dirty working tree blocks checkout/);
+  assert.match(uiState.notifications[1].message, /Resolve manually/);
+});
+
+test("non-Error thrown values are stringified into the user-facing message", () => {
+  const resolverState: FakeResolverState = {
+    mergeCalls: [],
+    shouldThrow: "git lock contention",
+  };
+  const uiState: FakeUiState = { notifications: [] };
+
+  const result = _finalizeSurvivorBranch(
+    fakeResolver(resolverState),
+    "M001",
+    fakeUi(uiState),
+  );
+
+  assert.equal(result.merged, false);
+  assert.equal(result.error, resolverState.shouldThrow);
+  assert.equal(uiState.notifications[1].level, "error");
+  assert.match(uiState.notifications[1].message, /git lock contention/);
+});
+
+test("inner notifications from mergeAndExit's NotifyCtx reach the same UI", () => {
+  // The resolver's NotifyCtx must be wired to ui.notify so messages emitted
+  // inside mergeAndExit (e.g. "Milestone Mxxx merged. Pushed to remote.")
+  // appear in the same UI stream as the outer notifies.
+  const uiState: FakeUiState = { notifications: [] };
+  const ui = fakeUi(uiState);
+
+  const resolver = {
+    mergeAndExit: (_milestoneId: string, ctx: { notify: (msg: string, level?: "info" | "warning" | "error" | "success") => void }) => {
+      ctx.notify("Milestone M001 merged.", "success");
+    },
+  } as unknown as WorktreeResolver;
+
+  const result = _finalizeSurvivorBranch(resolver, "M001", ui);
+
+  assert.equal(result.merged, true);
+  // 1: outer announce
+  // 2: inner success
+  assert.equal(uiState.notifications.length, 2);
+  assert.equal(uiState.notifications[1].level, "success");
+  assert.equal(uiState.notifications[1].message, "Milestone M001 merged.");
+});

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

@@ -52,9 +52,12 @@ describe('isolation:none stale branch guard (#3675)', () => {
   });
 
   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');
+    // Pin to the specific guard usage (`currentBranch.startsWith(...)`) so
+    // unrelated occurrences of `startsWith("milestone/")` elsewhere in the
+    // file (e.g. branch-name iteration helpers added later) don't shift the
+    // index and break this structural assertion.
+    const milestoneIdx = source.indexOf('currentBranch.startsWith("milestone/")');
+    assert.ok(milestoneIdx > 0, 'isolation:none guard 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');

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');