gsd-pi 2.78.1-dev.82bcf6b71 → 2.78.1-dev.84c045fd2

package/src/resources/GSD-WORKFLOW.md

@@ -542,74 +542,61 @@ If files disagree, **pause and surface to the user**:
 
 ---
 
-## Git Strategy: Branch-Per-Slice with Squash Merge
+## Git Strategy: Sequential Commits with Optional Milestone Isolation
 
-**Principle:** Main is always clean and working. Each slice gets an isolated branch. The user never runs a git command — the agent handles everything.
+**Principle:** GSD keeps work atomic and recoverable. By default, work happens on the current branch. If `git.isolation` is set to `worktree` or `branch`, a milestone branch is used and merged back to the recorded integration branch when the milestone completes. The user never runs a git command — the agent handles everything.
 
-### Branch Lifecycle
+### Isolation Modes
 
-1. **Slice starts** → create branch `gsd/M001/S01` from main
-2. **Per-task commits** on the branch — atomic, descriptive, bisectable
-3. **Slice completes** → squash merge to main as one clean commit
-4. **Branch deleted** — squash commit on main is the permanent record
+| Mode | Where work happens | Branch behavior |
+|------|--------------------|-----------------|
+| `none` (default) | Project root | Current branch, no isolation branch |
+| `worktree` | `.gsd/worktrees/<MID>/` | `milestone/<MID>` branch in a git worktree |
+| `branch` | Project root | `milestone/<MID>` branch checked out in place |
 
-### What Main Looks Like
+In all modes, slices and tasks commit sequentially on the active branch; there are no per-slice branches. The integration branch is captured when the milestone starts, so stale `git.main_branch` preferences do not redirect merge-back.
 
-```
-feat(M001/S03): milestone and slice discuss commands
-feat(M001/S02): extension scaffold and command routing
-feat(M001/S01): file I/O foundation
-```
+### Milestone Lifecycle
 
-One commit per slice. Individually revertable. Reads like a changelog.
+1. **Milestone starts** → capture the current integration branch.
+2. **Optional isolation** → create `milestone/M001` only when `git.isolation` is `worktree` or `branch`.
+3. **Per-task commits** — atomic, descriptive, bisectable.
+4. **Slice completes** → write slice summary, UAT script, roadmap checkbox, and milestone summary.
+5. **Milestone completes** → if isolated, squash-merge the milestone branch back to the captured integration branch and clean up the worktree/branch.
 
-### What the Branch Looks Like
+### What History Looks Like
 
 ```
-gsd/M001/S01:
-  test(S01/T03): round-trip tests passing
-  feat(S01/T03): file writer with round-trip fidelity
-  feat(S01/T02): markdown parser for plan files
-  feat(S01/T01): core types and interfaces
-  docs(S01): add slice plan
+feat: core type definitions
+feat: markdown parser for plan files
+fix: handle empty state rebuild
 ```
 
+In `none` mode these commits land directly on the current branch. In isolated modes they land on `milestone/<MID>` and are squashed back at milestone completion.
+
 ### Commit Conventions
 
 | When | Format | Example |
 |------|--------|---------|
-| Task completed | `{type}(S01/T02): <one-liner from summary>` | Type inferred from title (`feat`, `fix`, `test`, etc.) |
-| Plan/docs committed | `docs(S01): add slice plan` | Planning artifacts |
-| Slice squash to main | `type(M001/S01): <slice title>` | Type inferred from title |
-| State rebuild | `chore(S01/T02): auto-commit after state-rebuild` | Bookkeeping only |
+| Task completed | `{type}: <one-liner from summary>` | Type inferred from title (`feat`, `fix`, `test`, etc.) |
+| State rebuild | `chore: auto-commit after state-rebuild` | Bookkeeping only |
+| Milestone squash | `{type}: <milestone title>` | Type inferred from title |
 
 The system reads the task summary after execution and builds a meaningful commit message:
-- **Subject**: `{type}({sliceId}/{taskId}): {one-liner}` — the one-liner from the summary frontmatter
+- **Subject**: `{type}: {one-liner}` — the one-liner from the summary frontmatter, sanitized to one line
 - **Type**: Inferred from the task title and one-liner (`feat`, `fix`, `test`, `refactor`, `docs`, `perf`, `chore`)
 - **Body**: Key files from the summary frontmatter (up to 8 files listed)
+- **Trailers**: `GSD-Task: S##/T##`; if GitHub sync linked an issue, `Resolves #N`
 
 Commit types: `feat`, `fix`, `test`, `refactor`, `docs`, `perf`, `chore`
 
-### Squash Merge Message
-
-```
-feat(M001/S01): file I/O foundation
-
-Agent can parse, format, load, and save all GSD file types with round-trip fidelity.
-
-Tasks completed:
-- T01: core types and interfaces
-- T02: markdown parser for plan files
-- T03: file writer with round-trip fidelity
-```
-
 ### Rollback
 
 | Problem | Fix |
 |---------|-----|
-| Bad task | `git reset --hard HEAD~1` to previous commit on the branch |
-| Bad slice | `git revert <squash commit>` on main |
-| UAT failure after merge | Fix tasks on `gsd/M001/S01-fix` branch, squash as `fix(M001/S01): <fix>` |
+| Bad task | Revert the task commit on the active branch |
+| Bad milestone squash | Revert the squash commit on the integration branch |
+| UAT failure after merge | Create follow-up fix tasks in the current or next milestone |
 
 ---
 

package/src/resources/extensions/async-jobs/job-manager.ts

@@ -216,6 +216,9 @@ export class AsyncJobManager {
 			this.evictionTimers.delete(id);
 			this.jobs.delete(id);
 		}, this.evictionMs);
+		// Eviction is housekeeping; it should not keep short-lived test/CLI
+		// processes alive after the real work has finished.
+		if (typeof timer === "object" && "unref" in timer) timer.unref();
 
 		this.evictionTimers.set(id, timer);
 	}

package/src/resources/extensions/bg-shell/bg-shell-lifecycle.ts

@@ -27,6 +27,7 @@ import { formatUptime, getBgShellLiveCwd, resolveBgShellPersistenceCwd } from ".
 import { formatTokenCount } from "../shared/format-utils.js";
 
 import type { BgShellSharedState } from "./index.js";
+import { homedir } from "node:os";
 
 export function registerBgShellLifecycle(pi: ExtensionAPI, state: BgShellSharedState): void {
 
@@ -226,8 +227,8 @@ export function registerBgShellLifecycle(pi: ExtensionAPI, state: BgShellSharedS
 				render(width: number): string[] {
 					// ── Line 1: pwd (branch) [session]  ...  bg status ──
 					let pwd = getBgShellLiveCwd(state.latestCtx?.cwd);
-					const home = process.env.HOME || process.env.USERPROFILE;
-					if (home && pwd.startsWith(home)) {
+					const home = homedir();
+					if (pwd.startsWith(home)) {
 						pwd = `~${pwd.slice(home.length)}`;
 					}
 					const branch = footerData.getGitBranch();

package/src/resources/extensions/bg-shell/utilities.ts

@@ -35,6 +35,7 @@ export function restoreWindowsVTInput(): void {
 // ── Time Formatting ────────────────────────────────────────────────────────
 
 import { formatDuration } from "../shared/mod.js";
+import { homedir } from "node:os";
 
 export const formatUptime = formatDuration;
 
@@ -58,7 +59,7 @@ export function getBgShellLiveCwd(
 		return getCwd();
 	} catch {
 		const projectRoot = deriveProjectRootFromAutoWorktree(cachedCwd);
-		const home = process.env.HOME || process.env.USERPROFILE;
+		const home = homedir();
 		const fallbacks = [projectRoot, cachedCwd, home, "/"].filter(
 			(candidate): candidate is string => Boolean(candidate),
 		);

package/src/resources/extensions/browser-tools/tools/intent.ts

@@ -1,6 +1,5 @@
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
-import { StringEnum } from "@gsd/pi-ai";
+import { type TUnsafe, Type } from "@sinclair/typebox";
 import { diffCompactStates } from "../core.js";
 import type { ToolDeps, CompactPageState } from "../state.js";
 import {
@@ -25,6 +24,18 @@ const INTENTS = [
 
 type Intent = (typeof INTENTS)[number];
 
+function StringEnum<T extends readonly string[]>(
+	values: T,
+	options?: { description?: string; default?: T[number] },
+): TUnsafe<T[number]> {
+	return Type.Unsafe<T[number]>({
+		type: "string",
+		enum: values as any,
+		...(options?.description && { description: options.description }),
+		...(options?.default && { default: options.default }),
+	});
+}
+
 // ---------------------------------------------------------------------------
 // Scoring evaluate script — runs entirely in-browser via page.evaluate()
 // ---------------------------------------------------------------------------

package/src/resources/extensions/claude-code-cli/stream-adapter.ts

@@ -1091,6 +1091,20 @@ export function createClaudeCodeCanUseToolHandler(
 							destination: "localSettings",
 						}];
 					}
+				} else if (!perms || (Array.isArray(perms) && perms.length === 0)) {
+					// Non-Bash tool with no SDK-supplied suggestions. Without a
+					// fallback rule the SDK would return `behavior: "allow"`
+					// with no `updatedPermissions`, so "Always Allow" silently
+					// fails to persist for tools whose input varies per call
+					// (e.g. AskUserQuestion with different `questions` payloads).
+					// A bare `{ toolName }` rule matches any input.
+					perms = [{
+						type: "addRules",
+						rules: [{ toolName }],
+						behavior: "allow",
+						destination: "localSettings",
+					}];
+					notifyLabel = toolName;
 				}
 				// Notify with the resolved pattern (label already previewed it)
 				if (notifyLabel) {
@@ -1275,13 +1289,13 @@ export function buildSdkOptions(
 	const { reasoning, ...sdkExtraOptions } = extraOptions;
 	const mcpServers = buildWorkflowMcpServers();
 	const permissionMode = overrides?.permissionMode ?? "bypassPermissions";
-	// Globally unblock all tools. Users reported that the `acceptEdits` default
-	// plus a narrow allowlist silently declined most Bash/Agent/WebFetch calls
-	// when `extensionUIContext` wasn't threaded through. Default to
-	// bypassPermissions and an empty disallow list so every tool — including
-	// `AskUserQuestion` and every `mcp__*` workflow tool — is auto-approved.
+	// Globally unblock the tools GSD expects Claude Code to run. When the
+	// workflow MCP server is available, prefer its `ask_user_questions` tool over
+	// Claude Code's native `AskUserQuestion`; the MCP path carries stable IDs and
+	// routes responses through the GSD elicitation bridge.
 	// Opt back into gated mode with GSD_CLAUDE_CODE_PERMISSION_MODE=acceptEdits.
-	const disallowedTools: string[] = [];
+	const workflowMcpTools = mcpServers ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`) : [];
+	const disallowedTools: string[] = workflowMcpTools.length > 0 ? ["AskUserQuestion"] : [];
 	const allowedTools = [
 		"Read",
 		"Write",
@@ -1292,8 +1306,7 @@ export function buildSdkOptions(
 		"Agent",
 		"WebFetch",
 		"WebSearch",
-		"AskUserQuestion",
-		...(mcpServers ? Object.keys(mcpServers).map((serverName) => `mcp__${serverName}__*`) : []),
+		...(workflowMcpTools.length > 0 ? workflowMcpTools : ["AskUserQuestion"]),
 	];
 	const supportsAdaptive = modelSupportsAdaptiveThinking(modelId);
 	const effort =

package/src/resources/extensions/claude-code-cli/tests/stream-adapter.test.ts

@@ -787,7 +787,7 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		assert.equal("thinking" in options, false, "non-adaptive models must not receive a thinking field");
 	});
 
-	test("buildSdkOptions includes workflow MCP server config when env is set", () => {
+	test("buildSdkOptions prefers workflow MCP question tools over native AskUserQuestion", () => {
 		const restore = setWorkflowMcpEnv({
 			GSD_WORKFLOW_MCP_COMMAND: "node",
 			GSD_WORKFLOW_MCP_NAME: "gsd-workflow",
@@ -807,7 +807,7 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			assert.equal(srv.env.GSD_CLI_PATH, "/tmp/gsd");
 			assert.equal(srv.env.GSD_PERSIST_WRITE_GATE_STATE, "1");
 			assert.equal(srv.env.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
-			assert.deepEqual(options.disallowedTools, []);
+			assert.deepEqual(options.disallowedTools, ["AskUserQuestion"]);
 			assert.deepEqual(options.allowedTools, [
 				"Read",
 				"Write",
@@ -818,7 +818,6 @@ describe("stream-adapter — session persistence (#2859)", () => {
 				"Agent",
 				"WebFetch",
 				"WebSearch",
-				"AskUserQuestion",
 				"mcp__gsd-workflow__*",
 			]);
 		} finally {
@@ -826,7 +825,7 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		}
 	});
 
-	test("buildSdkOptions auto-approves every tool for custom workflow MCP server names", () => {
+	test("buildSdkOptions prefers custom workflow MCP question tools over native AskUserQuestion", () => {
 		const restore = setWorkflowMcpEnv({
 			GSD_WORKFLOW_MCP_COMMAND: "node",
 			GSD_WORKFLOW_MCP_NAME: "custom-workflow",
@@ -839,7 +838,7 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			const options = buildSdkOptions("claude-sonnet-4-20250514", "test");
 			const mcpServers = options.mcpServers as Record<string, any>;
 			assert.ok(mcpServers?.["custom-workflow"], "expected custom workflow server config");
-			assert.deepEqual(options.disallowedTools, []);
+			assert.deepEqual(options.disallowedTools, ["AskUserQuestion"]);
 			assert.deepEqual(options.allowedTools, [
 				"Read",
 				"Write",
@@ -850,7 +849,6 @@ describe("stream-adapter — session persistence (#2859)", () => {
 				"Agent",
 				"WebFetch",
 				"WebSearch",
-				"AskUserQuestion",
 				"mcp__custom-workflow__*",
 			]);
 		} finally {
@@ -882,7 +880,7 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			const mcpServers = (options as any).mcpServers;
 			if (mcpServers) {
 				assert.ok(mcpServers["gsd-workflow"], "if present, must be gsd-workflow");
-				assert.deepEqual((options as any).disallowedTools, []);
+				assert.deepEqual((options as any).disallowedTools, ["AskUserQuestion"]);
 			} else {
 				assert.deepEqual((options as any).disallowedTools, []);
 			}
@@ -923,7 +921,7 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			assert.equal(srv.env.GSD_CLI_PATH, "/tmp/gsd");
 			assert.equal(srv.env.GSD_PERSIST_WRITE_GATE_STATE, "1");
 			assert.equal(srv.env.GSD_WORKFLOW_PROJECT_ROOT, resolvedRepoDir);
-			assert.deepEqual(options.disallowedTools, []);
+			assert.deepEqual(options.disallowedTools, ["AskUserQuestion"]);
 		} finally {
 			process.chdir(originalCwd);
 			rmSync(repoDir, { recursive: true, force: true });
@@ -1609,17 +1607,40 @@ describe("stream-adapter — canUseTool handler", () => {
 		assert.equal(notified.length, 0);
 	});
 
-	test("Always Allow for non-Bash without suggestions omits updatedPermissions", async () => {
+	test("Always Allow for non-Bash without suggestions builds tool-name-only fallback rule", async () => {
 		const notified: string[] = [];
 		const ui = { select: async (_p: string, opts: string[]) => opts.find((o) => o.startsWith("Always Allow"))!, notify: (msg: string) => notified.push(msg) };
 
 		const handler = createClaudeCodeCanUseToolHandler(ui as any);
-		const result = await handler!("Write", { file_path: "/tmp/test.txt" }, makeOptions());
+		const result = await handler!("AskUserQuestion", { questions: [{ question: "?", header: "h", multiSelect: false, options: [] }] }, makeOptions());
 
 		assert.equal(result.behavior, "allow");
-		assert.equal((result as any).updatedPermissions, undefined);
-		// No suggestions → no notification
-		assert.equal(notified.length, 0);
+		assert.deepEqual((result as any).updatedPermissions, [{
+			type: "addRules",
+			rules: [{ toolName: "AskUserQuestion" }],
+			behavior: "allow",
+			destination: "localSettings",
+		}]);
+		assert.equal(notified.length, 1);
+		assert.match(notified[0], /AskUserQuestion/);
+	});
+
+	test("Always Allow for non-Bash with empty suggestions array builds tool-name-only fallback rule", async () => {
+		const notified: string[] = [];
+		const ui = { select: async (_p: string, opts: string[]) => opts.find((o) => o.startsWith("Always Allow"))!, notify: (msg: string) => notified.push(msg) };
+
+		const handler = createClaudeCodeCanUseToolHandler(ui as any);
+		const result = await handler!("AskUserQuestion", { questions: [{ question: "?", header: "h", multiSelect: false, options: [] }] }, makeOptions({ suggestions: [] }));
+
+		assert.equal(result.behavior, "allow");
+		assert.deepEqual((result as any).updatedPermissions, [{
+			type: "addRules",
+			rules: [{ toolName: "AskUserQuestion" }],
+			behavior: "allow",
+			destination: "localSettings",
+		}]);
+		assert.equal(notified.length, 1);
+		assert.match(notified[0], /AskUserQuestion/);
 	});
 
 	test("prompt includes command text for Bash tools", async () => {

package/src/resources/extensions/github-sync/cli.ts

@@ -6,6 +6,7 @@
  */
 
 import { execFileSync } from "node:child_process";
+import { GIT_NO_PROMPT_ENV } from "../gsd/git-constants.js";
 
 // ─── Result Type ────────────────────────────────────────────────────────────
 
@@ -342,6 +343,7 @@ export function ghPushBranch(cwd: string, branch: string, setUpstream = true): G
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 30_000,
+      env: GIT_NO_PROMPT_ENV,
     });
     return ok(undefined);
   } catch (err) {
@@ -356,6 +358,7 @@ export function ghCreateBranch(cwd: string, branch: string, from: string): GhRes
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 10_000,
+      env: GIT_NO_PROMPT_ENV,
     });
     return ok(undefined);
   } catch (err) {

package/src/resources/extensions/github-sync/sync.ts

@@ -206,8 +206,8 @@ async function syncSlicePlan(
   mid: string,
   sid: string,
 ): Promise<void> {
-  // Skip if already synced
-  if (getSliceRecord(mapping, mid, sid)) return;
+  const existingSlice = getSliceRecord(mapping, mid, sid);
+  if (existingSlice) return;
 
   // Ensure milestone is synced first
   if (!getMilestoneRecord(mapping, mid)) {
@@ -223,7 +223,6 @@ async function syncSlicePlan(
 
   const plan = parsePlan(content);
   const sliceBranch = `milestone/${mid}/${sid}`;
-  const milestoneBranch = `milestone/${mid}`;
 
   // Create task sub-issues first (so we can link them in the PR body)
   const taskIssueNumbers: Array<{ id: string; title: string; issueNumber?: number }> = [];
@@ -271,70 +270,84 @@ async function syncSlicePlan(
     }
   }
 
-  if (config.slice_prs === false) {
-    // Slice PRs disabled — just record without PR
-    setSliceRecord(mapping, mid, sid, {
-      issueNumber: 0,
-      prNumber: 0,
-      branch: sliceBranch,
-      lastSyncedAt: new Date().toISOString(),
-      state: "open",
-    });
-    return;
-  }
+  setSliceRecord(mapping, mid, sid, {
+    issueNumber: 0,
+    prNumber: 0,
+    branch: sliceBranch,
+    lastSyncedAt: new Date().toISOString(),
+    state: "open",
+  });
+
+  debugLog("github-sync", {
+    phase: "slice-synced",
+    mid,
+    sid,
+    pr: 0,
+    taskIssues: taskIssueNumbers.filter(t => t.issueNumber).length,
+  });
+}
+
+async function ensureSlicePullRequest(
+  basePath: string,
+  mapping: SyncMapping,
+  mid: string,
+  sid: string,
+): Promise<number | null> {
+  const sliceRecord = getSliceRecord(mapping, mid, sid);
+  if (!sliceRecord) return null;
+  if (sliceRecord.prNumber) return sliceRecord.prNumber;
+
+  const planPath = resolveSliceFile(basePath, mid, sid, "PLAN");
+  if (!planPath) return null;
+  const content = await loadFile(planPath);
+  if (!content) return null;
+  const plan = parsePlan(content);
+
+  const sliceBranch = sliceRecord.branch || `milestone/${mid}/${sid}`;
+  const milestoneBranch = `milestone/${mid}`;
 
-  // Create slice branch from milestone branch
   const branchResult = ghCreateBranch(basePath, sliceBranch, milestoneBranch);
   if (!branchResult.ok) {
     debugLog("github-sync", { phase: "create-slice-branch", error: branchResult.error });
-    // Branch might already exist — continue anyway
   }
 
-  // Push the slice branch
   const pushResult = ghPushBranch(basePath, sliceBranch);
   if (!pushResult.ok) {
     debugLog("github-sync", { phase: "push-slice-branch", error: pushResult.error });
+    return null;
   }
 
-  // Create draft PR
-  const prBody = formatSlicePRBody({
-    id: sid,
-    title: plan.title || sid,
-    goal: plan.goal,
-    mustHaves: plan.mustHaves,
-    demoCriterion: plan.demo,
-    tasks: taskIssueNumbers,
-  });
+  const tasks = (plan.tasks ?? []).map((task) => ({
+    id: task.id,
+    title: task.title,
+    issueNumber: getTaskRecord(mapping, mid, sid, task.id)?.issueNumber,
+  }));
 
   const prResult = ghCreatePR(basePath, {
     repo: mapping.repo,
     base: milestoneBranch,
     head: sliceBranch,
     title: `${sid}: ${plan.title || sid}`,
-    body: prBody,
+    body: formatSlicePRBody({
+      id: sid,
+      title: plan.title || sid,
+      goal: plan.goal,
+      mustHaves: plan.mustHaves,
+      demoCriterion: plan.demo,
+      tasks,
+    }),
     draft: true,
   });
 
-  const prNumber = prResult.ok ? prResult.data! : 0;
   if (!prResult.ok) {
     debugLog("github-sync", { phase: "create-slice-pr", error: prResult.error });
+    return null;
   }
 
-  setSliceRecord(mapping, mid, sid, {
-    issueNumber: 0, // Slice doesn't get its own issue — tracked via PR
-    prNumber,
-    branch: sliceBranch,
-    lastSyncedAt: new Date().toISOString(),
-    state: "open",
-  });
-
-  debugLog("github-sync", {
-    phase: "slice-synced",
-    mid,
-    sid,
-    pr: prNumber,
-    taskIssues: taskIssueNumbers.filter(t => t.issueNumber).length,
-  });
+  sliceRecord.prNumber = prResult.data!;
+  sliceRecord.lastSyncedAt = new Date().toISOString();
+  setSliceRecord(mapping, mid, sid, sliceRecord);
+  return sliceRecord.prNumber;
 }
 
 async function syncTaskComplete(
@@ -349,6 +362,7 @@ async function syncTaskComplete(
   if (!taskRecord || taskRecord.state === "closed") return;
 
   // Load task summary
+  let commentOk = true;
   const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
   if (summaryPath) {
     const content = await loadFile(summaryPath);
@@ -359,18 +373,24 @@ async function syncTaskComplete(
         body: summary.whatHappened,
         frontmatter: summary.frontmatter as unknown as Record<string, unknown>,
       });
-      ghAddComment(basePath, mapping.repo, taskRecord.issueNumber, comment);
+      const commentResult = ghAddComment(basePath, mapping.repo, taskRecord.issueNumber, comment);
+      commentOk = commentResult.ok;
+      if (!commentResult.ok) {
+        debugLog("github-sync", { phase: "task-comment-failed", mid, sid, tid, error: commentResult.error });
+      }
     }
   }
 
-  // Close the task issue
-  ghCloseIssue(basePath, mapping.repo, taskRecord.issueNumber);
+  if (!commentOk) return;
 
-  taskRecord.state = "closed";
+  // Do not close the GitHub issue here. The task commit may still be local-only;
+  // closing before the commit/PR reaches GitHub breaks the remote audit trail.
+  // Commit trailers / PR merge should close linked issues once code is delivered.
+  taskRecord.state = "open";
   taskRecord.lastSyncedAt = new Date().toISOString();
   setTaskRecord(mapping, mid, sid, tid, taskRecord);
 
-  debugLog("github-sync", { phase: "task-closed", mid, sid, tid, issue: taskRecord.issueNumber });
+  debugLog("github-sync", { phase: "task-complete-commented", mid, sid, tid, issue: taskRecord.issueNumber });
 }
 
 async function syncSliceComplete(
@@ -380,8 +400,17 @@ async function syncSliceComplete(
   mid: string,
   sid: string,
 ): Promise<void> {
-  const sliceRecord = getSliceRecord(mapping, mid, sid);
+  let sliceRecord = getSliceRecord(mapping, mid, sid);
+  if (!sliceRecord) {
+    await syncSlicePlan(basePath, mapping, config, mid, sid);
+    sliceRecord = getSliceRecord(mapping, mid, sid);
+  }
   if (!sliceRecord || sliceRecord.state === "closed") return;
+  if (!sliceRecord.prNumber && config.slice_prs !== false) {
+    await ensureSlicePullRequest(basePath, mapping, mid, sid);
+    sliceRecord = getSliceRecord(mapping, mid, sid);
+    if (!sliceRecord || !sliceRecord.prNumber) return;
+  }
 
   // Post slice summary as PR comment
   const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
@@ -500,28 +529,29 @@ export async function bootstrapSync(basePath: string): Promise<{
 
 // ─── Config Loading ─────────────────────────────────────────────────────────
 
-let _cachedConfig: GitHubSyncConfig | null | undefined;
+const _cachedConfigByBasePath = new Map<string, GitHubSyncConfig | null>();
 
-function loadGitHubSyncConfig(_basePath: string): GitHubSyncConfig | null {
-  if (_cachedConfig !== undefined) return _cachedConfig;
+function loadGitHubSyncConfig(basePath: string): GitHubSyncConfig | null {
+  if (_cachedConfigByBasePath.has(basePath)) return _cachedConfigByBasePath.get(basePath)!;
   try {
-    const prefs = loadEffectiveGSDPreferences();
+    const prefs = loadEffectiveGSDPreferences(basePath);
     const github = (prefs?.preferences as Record<string, unknown>)?.github;
     if (!github || typeof github !== "object") {
-      _cachedConfig = null;
+      _cachedConfigByBasePath.set(basePath, null);
       return null;
     }
-    _cachedConfig = github as GitHubSyncConfig;
-    return _cachedConfig;
+    const config = github as GitHubSyncConfig;
+    _cachedConfigByBasePath.set(basePath, config);
+    return config;
   } catch {
-    _cachedConfig = null;
+    _cachedConfigByBasePath.set(basePath, null);
     return null;
   }
 }
 
 /** Reset config cache (for testing). */
 export function _resetConfigCache(): void {
-  _cachedConfig = undefined;
+  _cachedConfigByBasePath.clear();
 }
 
 function resolveRepo(basePath: string): string | null {

package/src/resources/extensions/github-sync/tests/sync-source.test.ts

@@ -0,0 +1,26 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const source = readFileSync(join(import.meta.dirname, "..", "sync.ts"), "utf8");
+
+test("slice plan sync records issues without creating a draft PR", () => {
+	const planStart = source.indexOf("async function syncSlicePlan");
+	const prHelperStart = source.indexOf("async function ensureSlicePullRequest");
+	assert.ok(planStart >= 0 && prHelperStart > planStart, "slice plan and PR helper functions are present");
+
+	const planBody = source.slice(planStart, prHelperStart);
+	assert.match(planBody, /prNumber:\s*0/);
+	assert.doesNotMatch(planBody, /ghCreatePR\(/);
+	assert.doesNotMatch(planBody, /ghPushBranch\(/);
+});
+
+test("slice completion creates the PR only after slice work is complete", () => {
+	const completeStart = source.indexOf("async function syncSliceComplete");
+	const milestoneStart = source.indexOf("async function syncMilestoneComplete");
+	assert.ok(completeStart >= 0 && milestoneStart > completeStart, "slice complete function is present");
+
+	const completeBody = source.slice(completeStart, milestoneStart);
+	assert.match(completeBody, /ensureSlicePullRequest\(basePath, mapping, mid, sid\)/);
+});

package/src/resources/extensions/gsd/auto/loop-deps.ts

@@ -113,7 +113,7 @@ export interface LoopDeps {
     basePath: string,
     mid: string,
   ) => void;
-  getIsolationMode: () => string;
+  getIsolationMode: (basePath?: string) => string;
   getCurrentBranch: (basePath: string) => string;
   autoWorktreeBranch: (milestoneId: string) => string;
   resolveMilestoneFile: (