gsd-pi 2.80.0-dev.96f4d89d5 → 2.80.0-dev.b0acf17e9

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: WorktreeResolver unit and regression tests.
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdtempSync, rmSync, mkdirSync, realpathSync } from "node:fs";
@@ -9,6 +11,17 @@ import {
   type NotifyCtx,
 } from "../worktree-resolver.js";
 import { AutoSession } from "../auto/session.js";
+import {
+  closeDatabase,
+  insertMilestone,
+  openDatabase,
+} from "../gsd-db.js";
+import { registerAutoWorker } from "../db/auto-workers.js";
+import {
+  claimMilestoneLease,
+  getMilestoneLease,
+  releaseMilestoneLease,
+} from "../db/milestone-leases.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -19,11 +32,12 @@ interface CallLog {
 }
 
 function makeSession(
-  overrides?: Partial<{ basePath: string; originalBasePath: string }>,
+  overrides?: Partial<AutoSession>,
 ): AutoSession {
   const s = new AutoSession();
   s.basePath = overrides?.basePath ?? "/project";
   s.originalBasePath = overrides?.originalBasePath ?? "/project";
+  Object.assign(s, overrides);
   return s;
 }
 
@@ -104,6 +118,9 @@ function makeDeps(
       calls.push({ fn: "getCurrentBranch", args: [basePath] });
       return "main";
     },
+    checkoutBranch: (basePath: string, branch: string) => {
+      calls.push({ fn: "checkoutBranch", args: [basePath, branch] });
+    },
     autoWorktreeBranch: (milestoneId: string) => {
       calls.push({ fn: "autoWorktreeBranch", args: [milestoneId] });
       return `milestone/${milestoneId}`;
@@ -182,6 +199,17 @@ function findCalls(calls: CallLog[], fn: string): CallLog[] {
   return calls.filter((c) => c.fn === fn);
 }
 
+function makeDbBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-worktree-resolver-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanupDbBase(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
 // ─── Getter Tests ────────────────────────────────────────────────────────────
 
 test("workPath returns s.basePath", () => {
@@ -371,6 +399,43 @@ test("enterMilestone does not create double-nested worktree when originalBasePat
   );
 });
 
+test("enterMilestone reacquires a released same-milestone lease before worktree entry", (t) => {
+  const base = makeDbBase();
+  t.after(() => cleanupDbBase(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test milestone", status: "active" });
+
+  const workerId = registerAutoWorker({ projectRootRealpath: base });
+  const originalClaim = claimMilestoneLease(workerId, "M001");
+  assert.equal(originalClaim.ok, true);
+  if (!originalClaim.ok) throw new Error("expected test lease claim");
+  assert.equal(releaseMilestoneLease(workerId, "M001", originalClaim.token), true);
+
+  const s = makeSession({
+    basePath: base,
+    originalBasePath: base,
+    workerId,
+    currentMilestoneId: "M001",
+    milestoneLeaseToken: originalClaim.token,
+  });
+  const deps = makeDeps({
+    createAutoWorktree: (basePath: string, milestoneId: string) => join(basePath, ".gsd", "worktrees", milestoneId),
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  resolver.enterMilestone("M001", ctx);
+
+  const row = getMilestoneLease("M001");
+  assert.ok(row);
+  assert.equal(row.worker_id, workerId);
+  assert.equal(row.status, "held");
+  assert.equal(row.fencing_token, originalClaim.token + 1);
+  assert.equal(s.milestoneLeaseToken, originalClaim.token + 1);
+  assert.equal(s.basePath, join(base, ".gsd", "worktrees", "M001"));
+  assert.equal(ctx.messages.some((m) => m.level === "error"), false);
+});
+
 // ─── enterMilestone Tests (branch mode) ──────────────────────────────────────
 
 test("enterMilestone in branch mode calls enterBranchModeForMilestone and rebuilds GitService", () => {
@@ -464,6 +529,42 @@ test("exitMilestone commits, tears down, and resets basePath", () => {
   assert.equal(findCalls(deps.calls, "invalidateAllCaches").length, 1);
 });
 
+test("exitMilestone moves cwd to project root before teardown", (t) => {
+  const originalCwd = process.cwd();
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-exit-cwd-")));
+  const wtPath = join(base, ".gsd", "worktrees", "M001");
+  mkdirSync(wtPath, { recursive: true });
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  process.chdir(wtPath);
+  const s = makeSession({
+    basePath: wtPath,
+    originalBasePath: base,
+  });
+  const deps = makeDeps({
+    isInAutoWorktree: () => true,
+  });
+  deps.teardownAutoWorktree = (
+    teardownBasePath: string,
+    milestoneId: string,
+    opts?: { preserveBranch?: boolean },
+  ) => {
+    deps.calls.push({ fn: "teardownAutoWorktree", args: [teardownBasePath, milestoneId, opts] });
+    assert.equal(process.cwd(), base);
+    rmSync(wtPath, { recursive: true, force: true });
+  };
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  resolver.exitMilestone("M001", ctx);
+
+  assert.equal(process.cwd(), base);
+  assert.equal(s.basePath, base);
+});
+
 test("exitMilestone is no-op when not in worktree", () => {
   const s = makeSession();
   const deps = makeDeps({
@@ -740,21 +841,92 @@ test("mergeAndExit in branch mode merges when on milestone branch", () => {
   assert.ok(ctx.messages.some((m) => m.msg.includes("branch mode")));
 });
 
-test("mergeAndExit in branch mode skips when not on milestone branch", () => {
+test("mergeAndExit in branch mode checks out the milestone branch and merges (#5538-followup)", () => {
+  // Regression: previously this case silently returned without merging,
+  // stranding the milestone's commits on the branch (the test12345 repro).
+  // The fix forces a checkout first; merge proceeds when checkout succeeds.
   const s = makeSession({ basePath: "/project", originalBasePath: "/project" });
+  let currentBranch = "main";
+  const checkoutInvocations: Array<{ basePath: string; branch: string }> = [];
   const deps = makeDeps({
     isInAutoWorktree: () => false,
     getIsolationMode: () => "branch",
-    getCurrentBranch: () => "main",
+    getCurrentBranch: () => currentBranch,
     autoWorktreeBranch: () => "milestone/M001",
+    checkoutBranch: (basePath: string, branch: string) => {
+      checkoutInvocations.push({ basePath, branch });
+      currentBranch = branch;
+    },
   });
   const ctx = makeNotifyCtx();
   const resolver = new WorktreeResolver(s, deps);
 
   resolver.mergeAndExit("M001", ctx);
 
+  assert.equal(checkoutInvocations.length, 1, "must attempt checkout when on wrong branch");
+  assert.deepEqual(checkoutInvocations[0], { basePath: "/project", branch: "milestone/M001" });
+  assert.equal(findCalls(deps.calls, "mergeMilestoneToMain").length, 1);
+});
+
+test("mergeAndExit in branch mode throws when checkout fails", () => {
+  // Regression for the silent-skip bug: if the working tree is on the wrong
+  // branch and checkout fails, we must throw so the caller pauses auto-mode
+  // — never silently advance with the milestone unmerged.
+  const s = makeSession({ basePath: "/project", originalBasePath: "/project" });
+  const deps = makeDeps({
+    isInAutoWorktree: () => false,
+    getIsolationMode: () => "branch",
+    getCurrentBranch: () => "main",
+    autoWorktreeBranch: () => "milestone/M001",
+    checkoutBranch: () => {
+      throw new Error("dirty working tree blocks checkout");
+    },
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  assert.throws(
+    () => resolver.mergeAndExit("M001", ctx),
+    /dirty working tree blocks checkout/,
+  );
+  assert.equal(
+    findCalls(deps.calls, "mergeMilestoneToMain").length,
+    0,
+    "merge must not run when checkout failed",
+  );
+  const errorNotify = ctx.messages.find((m) => m.level === "error");
+  assert.ok(errorNotify, "an error notification must be emitted");
+  assert.match(errorNotify!.msg, /milestone\/M001 failed/);
+  assert.match(errorNotify!.msg, /Resolve manually/);
+  assert.equal(
+    ctx.messages.some((m) => m.level === "warning" && m.msg.includes("Milestone merge failed")),
+    false,
+    "checkout failures with explicit recovery guidance must not emit a duplicate warning",
+  );
+});
+
+test("mergeAndExit in branch mode throws when checkout reports success but HEAD is still wrong", () => {
+  // Defense in depth: even if checkoutBranch returns without throwing, we
+  // re-verify and throw if HEAD didn't actually move. Prevents merging on
+  // top of the wrong branch on platforms where the checkout is a no-op.
+  const s = makeSession({ basePath: "/project", originalBasePath: "/project" });
+  const deps = makeDeps({
+    isInAutoWorktree: () => false,
+    getIsolationMode: () => "branch",
+    getCurrentBranch: () => "main", // never changes — simulates no-op checkout
+    autoWorktreeBranch: () => "milestone/M001",
+    checkoutBranch: () => {
+      // Pretend success — but getCurrentBranch will still return "main".
+    },
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  assert.throws(
+    () => resolver.mergeAndExit("M001", ctx),
+    /reported success but current branch is main/,
+  );
   assert.equal(findCalls(deps.calls, "mergeMilestoneToMain").length, 0);
-  assert.equal(ctx.messages.length, 0);
 });
 
 test("mergeAndExit in branch mode handles merge failure gracefully", () => {
@@ -977,6 +1149,33 @@ test("mergeAndEnterNext enters next milestone even if merge fails", () => {
   );
 });
 
+test("mergeAndEnterNext halts after branch-mode user-notified checkout failure", () => {
+  const s = makeSession({ basePath: "/project", originalBasePath: "/project" });
+  const deps = makeDeps({
+    isInAutoWorktree: () => false,
+    getIsolationMode: () => "branch",
+    getCurrentBranch: () => "main",
+    autoWorktreeBranch: () => "milestone/M001",
+    checkoutBranch: () => {
+      throw new Error("dirty working tree blocks checkout");
+    },
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  assert.throws(
+    () => resolver.mergeAndEnterNext("M001", "M002", ctx),
+    /dirty working tree blocks checkout/,
+  );
+  assert.equal(
+    findCalls(deps.calls, "enterBranchModeForMilestone").length,
+    0,
+    "must not enter the next milestone after a user-notified branch-mode failure",
+  );
+  assert.equal(findCalls(deps.calls, "mergeMilestoneToMain").length, 0);
+  assert.ok(ctx.messages.some((m) => m.level === "error" && m.msg.includes("Resolve manually")));
+});
+
 // ─── GitService Rebuild Atomicity ────────────────────────────────────────────
 
 test("GitService is rebuilt with the NEW basePath after enterMilestone", () => {

package/src/resources/extensions/gsd/tests/worktree-write-gate.test.ts

@@ -0,0 +1,179 @@
+// GSD-2 worktree-isolation write gate (#5199).
+//
+// Regression coverage for shouldBlockWorktreeWrite — the helper that prevents
+// the LLM from authoring code at the project root when `git.isolation: worktree`
+// is configured but auto-mode (and its post-unit commit pipeline) hasn't run.
+// Without this gate, writes silently orphan outside git history.
+//
+// Test setup creates a fresh temp project for each isolation case, writes a
+// `.gsd/PREFERENCES.md` with `isolation: "worktree"`, and exercises the helper
+// against the 9 scenarios listed in the issue. No source-grep tests — every
+// assertion exercises the real predicate.
+
+import { test, describe, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { shouldBlockWorktreeWrite } from "../bootstrap/write-gate.js";
+import { invalidateAllCaches } from "../cache.js";
+
+function makeProject(isolation: "none" | "worktree" | "branch" | null): string {
+  const root = mkdtempSync(join(tmpdir(), "wt-write-gate-"));
+  if (isolation !== null) {
+    mkdirSync(join(root, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(root, ".gsd", "PREFERENCES.md"),
+      `---\ngit:\n  isolation: "${isolation}"\n---\n`,
+    );
+  }
+  invalidateAllCaches();
+  return root;
+}
+
+const PLANNING_WRITE_TOOLS = ["write", "edit", "multi_edit", "notebook_edit"];
+
+describe("shouldBlockWorktreeWrite (#5199)", () => {
+  let projectRoot: string;
+  let prevDisableEnv: string | undefined;
+
+  beforeEach(() => {
+    prevDisableEnv = process.env.GSD_DISABLE_WORKTREE_WRITE_GUARD;
+    delete process.env.GSD_DISABLE_WORKTREE_WRITE_GUARD;
+  });
+
+  afterEach(() => {
+    if (projectRoot) {
+      try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* best-effort */ }
+    }
+    if (prevDisableEnv === undefined) {
+      delete process.env.GSD_DISABLE_WORKTREE_WRITE_GUARD;
+    } else {
+      process.env.GSD_DISABLE_WORKTREE_WRITE_GUARD = prevDisableEnv;
+    }
+    invalidateAllCaches();
+  });
+
+  test("Case 1: every PLANNING_WRITE_TOOLS variant writing to <root>/app.js is blocked", () => {
+    projectRoot = makeProject("worktree");
+    for (const tool of PLANNING_WRITE_TOOLS) {
+      const result = shouldBlockWorktreeWrite(
+        tool,
+        join(projectRoot, "app.js"),
+        projectRoot,
+        /* isAutoLive */ false,
+        /* unitType */ null,
+      );
+      assert.equal(result.block, true, `tool ${tool} should be blocked`);
+      assert.match(result.reason ?? "", /HARD BLOCK/);
+    }
+  });
+
+  test("Case 2: write to <root>/.gsd/PROJECT.md is allowed", () => {
+    projectRoot = makeProject("worktree");
+    const result = shouldBlockWorktreeWrite(
+      "write",
+      join(projectRoot, ".gsd", "PROJECT.md"),
+      projectRoot,
+      false,
+      null,
+    );
+    assert.equal(result.block, false);
+  });
+
+  test("Case 3: write inside <root>/.gsd/worktrees/M001/ is allowed", () => {
+    projectRoot = makeProject("worktree");
+    const target = join(projectRoot, ".gsd", "worktrees", "M001", "src", "app.js");
+    const result = shouldBlockWorktreeWrite("edit", target, projectRoot, false, null);
+    assert.equal(result.block, false);
+  });
+
+  test("Case 4: write to <root>/.gsd/worktrees-extra/M001/app.js (prefix trick) is blocked", () => {
+    projectRoot = makeProject("worktree");
+    const target = join(projectRoot, ".gsd", "worktrees-extra", "M001", "app.js");
+    const result = shouldBlockWorktreeWrite("write", target, projectRoot, false, null);
+    assert.equal(result.block, true);
+    assert.match(result.reason ?? "", /HARD BLOCK/);
+  });
+
+  test("Case 5: isolation=none → allow", () => {
+    projectRoot = makeProject("none");
+    const result = shouldBlockWorktreeWrite(
+      "write",
+      join(projectRoot, "app.js"),
+      projectRoot,
+      false,
+      null,
+    );
+    assert.equal(result.block, false);
+  });
+
+  test("Case 6: isolation=worktree, auto active, effectiveBasePath inside worktree → allow", () => {
+    projectRoot = makeProject("worktree");
+    const inside = join(projectRoot, ".gsd", "worktrees", "M001");
+    mkdirSync(inside, { recursive: true });
+    const result = shouldBlockWorktreeWrite(
+      "write",
+      join(inside, "src", "app.js"),
+      inside,
+      /* isAutoLive */ true,
+      null,
+    );
+    assert.equal(result.block, false);
+  });
+
+  test("Case 7: isolation=worktree, auto active, effectiveBasePath is project root (cwd never flipped) → block", () => {
+    projectRoot = makeProject("worktree");
+    const result = shouldBlockWorktreeWrite(
+      "write",
+      join(projectRoot, "app.js"),
+      projectRoot,
+      /* isAutoLive */ true,
+      null,
+    );
+    assert.equal(result.block, true);
+    assert.match(result.reason ?? "", /HARD BLOCK/);
+  });
+
+  test("Case 8: bootstrap unit type active → allow", () => {
+    projectRoot = makeProject("worktree");
+    for (const unitType of ["discuss-milestone", "plan-milestone", "init"]) {
+      const result = shouldBlockWorktreeWrite(
+        "write",
+        join(projectRoot, "app.js"),
+        projectRoot,
+        false,
+        unitType,
+      );
+      assert.equal(result.block, false, `unit ${unitType} should bypass the guard`);
+    }
+  });
+
+  test("Case 9: GSD_DISABLE_WORKTREE_WRITE_GUARD=1 → allow", () => {
+    projectRoot = makeProject("worktree");
+    process.env.GSD_DISABLE_WORKTREE_WRITE_GUARD = "1";
+    const result = shouldBlockWorktreeWrite(
+      "write",
+      join(projectRoot, "app.js"),
+      projectRoot,
+      false,
+      null,
+    );
+    assert.equal(result.block, false);
+  });
+
+  test("non-planning tools (read/grep/bash) pass through unconditionally", () => {
+    projectRoot = makeProject("worktree");
+    for (const tool of ["read", "grep", "bash", "ls"]) {
+      const result = shouldBlockWorktreeWrite(
+        tool,
+        join(projectRoot, "app.js"),
+        projectRoot,
+        false,
+        null,
+      );
+      assert.equal(result.block, false, `tool ${tool} must not be gated`);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/zero-slice-roadmap-guided.test.ts

@@ -1,19 +1,25 @@
-/**
- * Regression test for #3441: guided flow must treat a roadmap with zero
- * parseable slices the same as no roadmap — offer "Create roadmap" not "Go auto".
- */
+// GSD-2 — Guided roadmap slice detection regression tests.
+
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 
-test("guided-flow checks roadmap slice count before offering auto (#3441)", () => {
-  const src = readFileSync(
-    join(import.meta.dirname, "..", "guided-flow.ts"),
-    "utf-8",
+import { _roadmapHasParseableSlicesForTest } from "../guided-flow.ts";
+
+test("guided flow treats placeholder roadmaps with zero slices as not runnable", () => {
+  assert.equal(
+    _roadmapHasParseableSlicesForTest("# M001 Roadmap\n\nPlanning notes only.\n"),
+    false,
   );
-  assert.ok(
-    src.includes("roadmapHasSlices") || src.includes("parseRoadmapSlices"),
-    "Guided flow must parse roadmap for slices before deciding which options to show",
+});
+
+test("guided flow accepts roadmaps with parseable slices", () => {
+  assert.equal(
+    _roadmapHasParseableSlicesForTest([
+      "# M001 Roadmap",
+      "",
+      "## Slices",
+      "- [ ] **S01: First slice** `risk:low` `depends:[]`",
+    ].join("\n")),
+    true,
   );
 });

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -85,7 +85,7 @@ function taskGateFieldForId(
  * Normalize a list parameter that may arrive as a string (newline-delimited
  * bullet list from the LLM) into a string array (#3361).
  */
-function normalizeListParam(value: unknown): string[] {
+export function normalizeListParam(value: unknown): string[] {
   if (Array.isArray(value)) return value.map(String);
   if (typeof value === "string" && value.trim()) {
     return value.split(/\n/).map(s => s.replace(/^[\s\-*•]+/, "").trim()).filter(Boolean);

package/src/resources/extensions/gsd/tools/context-mode-tool-result.ts

@@ -0,0 +1,25 @@
+// Project/App: GSD-2
+// File Purpose: Shared Context Mode tool result helpers.
+
+export interface ToolExecutionResult {
+  content: Array<{ type: "text"; text: string }>;
+  details: Record<string, unknown>;
+  isError?: boolean;
+}
+
+export type ContextModeToolName = "gsd_exec" | "gsd_exec_search" | "gsd_resume";
+
+export function contextModeDisabledResult(operation: ContextModeToolName): ToolExecutionResult {
+  return {
+    content: [
+      {
+        type: "text",
+        text:
+          `${operation} is disabled by \`context_mode.enabled: false\` in preferences. ` +
+          "Remove that override or set it to true to re-enable Context Mode tools.",
+      },
+    ],
+    details: { operation, error: "context_mode_disabled" },
+    isError: true,
+  };
+}

package/src/resources/extensions/gsd/tools/exec-search-tool.ts

@@ -4,6 +4,8 @@
 // re-discover past runs without re-executing. Read-only; no DB writes.
 
 import { searchExecHistory, type ExecSearchOptions } from "../exec-history.js";
+import { isContextModeEnabled, type ContextModeConfig } from "../preferences-types.js";
+import { contextModeDisabledResult, type ToolExecutionResult } from "./context-mode-tool-result.js";
 
 export interface ExecSearchToolParams {
   query?: string;
@@ -12,16 +14,14 @@ export interface ExecSearchToolParams {
   limit?: number;
 }
 
-export interface ToolExecutionResult {
-  content: Array<{ type: "text"; text: string }>;
-  details: Record<string, unknown>;
-  isError?: boolean;
-}
-
 export function executeExecSearch(
   params: ExecSearchToolParams,
-  opts: { baseDir: string },
+  opts: { baseDir: string; preferences?: { context_mode?: ContextModeConfig } | null },
 ): ToolExecutionResult {
+  if (!isContextModeEnabled(opts.preferences)) {
+    return contextModeDisabledResult("gsd_exec_search");
+  }
+
   const searchOpts: ExecSearchOptions = {
     query: typeof params.query === "string" ? params.query : undefined,
     runtime: params.runtime,

package/src/resources/extensions/gsd/tools/exec-tool.ts

@@ -12,6 +12,7 @@ import {
   type ExecSandboxResult,
 } from "../exec-sandbox.js";
 import { isContextModeEnabled, type ContextModeConfig } from "../preferences-types.js";
+import { contextModeDisabledResult, type ToolExecutionResult } from "./context-mode-tool-result.js";
 
 export interface ExecToolParams {
   runtime: ExecSandboxRequest["runtime"];
@@ -20,17 +21,12 @@ export interface ExecToolParams {
   timeout_ms?: number;
 }
 
-export interface ToolExecutionResult {
-  content: Array<{ type: "text"; text: string }>;
-  details: Record<string, unknown>;
-  isError?: boolean;
-}
-
 export interface ExecToolDeps {
   baseDir: string;
   preferences: { context_mode?: ContextModeConfig } | null;
   /** Optional override for testing. */
   run?: (req: ExecSandboxRequest, opts: ExecSandboxOptions) => Promise<ExecSandboxResult>;
+  env?: NodeJS.ProcessEnv;
   now?: () => Date;
   generateId?: () => string;
 }
@@ -77,21 +73,6 @@ function isEnabled(prefs: ExecToolDeps["preferences"]): boolean {
   return isContextModeEnabled(prefs);
 }
 
-function disabledResult(): ToolExecutionResult {
-  return {
-    content: [
-      {
-        type: "text",
-        text:
-          "gsd_exec is disabled by `context_mode.enabled: false` in preferences. Remove that " +
-          "override (or set it to true) to re-enable sandboxed tool-output execution.",
-      },
-    ],
-    details: { operation: "gsd_exec", error: "context_mode_disabled" },
-    isError: true,
-  };
-}
-
 function paramError(message: string): ToolExecutionResult {
   return {
     content: [{ type: "text", text: `Error: ${message}` }],
@@ -104,7 +85,7 @@ export async function executeGsdExec(
   params: ExecToolParams,
   deps: ExecToolDeps,
 ): Promise<ToolExecutionResult> {
-  if (!isEnabled(deps.preferences)) return disabledResult();
+  if (!isEnabled(deps.preferences)) return contextModeDisabledResult("gsd_exec");
 
   const runtime = params.runtime;
   if (runtime !== "bash" && runtime !== "node" && runtime !== "python") {
@@ -121,7 +102,7 @@ export async function executeGsdExec(
   const opts = buildExecOptions(
     deps.baseDir,
     deps.preferences?.context_mode,
-    { now: deps.now, generateId: deps.generateId },
+    { env: deps.env, now: deps.now, generateId: deps.generateId },
   );
   const run = deps.run ?? runExecSandbox;
 

package/src/resources/extensions/gsd/tools/memory-tools.ts

@@ -308,6 +308,7 @@ function includeSupersededMemories(rankedActive: Memory[]): Memory[] {
         scope: (row["scope"] as string) ?? "project",
         tags,
         structured_fields: structuredFields,
+        last_hit_at: (row["last_hit_at"] as string | null) ?? null,
       };
     });
   } catch {

package/src/resources/extensions/gsd/tools/plan-slice.ts

@@ -18,6 +18,7 @@ import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { validatePlanningPathScope } from "../planning-path-scope.js";
 
 export interface PlanSliceTaskInput {
   taskId: string;
@@ -141,6 +142,18 @@ export async function handlePlanSlice(
     return { error: `validation failed: ${(err as Error).message}` };
   }
 
+  const pathScopeError = validatePlanningPathScope(
+    basePath,
+    params.tasks.flatMap((task, index) => [
+      { field: `tasks[${index}].files`, values: task.files },
+      { field: `tasks[${index}].inputs`, values: task.inputs },
+      { field: `tasks[${index}].expectedOutput`, values: task.expectedOutput },
+    ]),
+  );
+  if (pathScopeError) {
+    return { error: `validation failed: ${pathScopeError}` };
+  }
+
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   // Guards must be inside the transaction so the state they check cannot
   // change between the read and the write (#2723).