@opengsd/gsd-pi 1.4.0-dev.c18009cd → 1.5.0-dev.553dc518

package/src/resources/extensions/gsd/flat-phase-migration.ts

@@ -6,7 +6,7 @@ import { cpSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSyn
 import { join } from "node:path";
 
 import { renderAllFromDb, renderRoadmapFromDb } from "./markdown-renderer.js";
-import { getAllMilestones, getMilestoneSlices } from "./gsd-db.js";
+import { deleteArtifactsByPathPrefix, getAllMilestones, getMilestoneSlices } from "./gsd-db.js";
 import { migrateFromMarkdown } from "./md-importer.js";
 import { countDbHierarchy } from "./migration-auto-check.js";
 import { logWarning } from "./workflow-logger.js";
@@ -195,7 +195,8 @@ export function pruneStaleFlatPhaseBackups(basePath: string): number {
  * 2. Rename .gsd/milestones/ aside so path resolvers target phases/
  * 3. Render flat-phase from the DB (which already has the data)
  * 4. Verify counts match
- * 5. Remove the renamed legacy tree
+ * 5. Prune legacy milestones/ artifact rows
+ * 6. Remove the renamed legacy tree
  *
  * Idempotent: if .gsd/milestones/ doesn't exist, returns immediately.
  */
@@ -313,7 +314,17 @@ export async function migrateToFlatPhase(basePath: string): Promise<void> {
     throw new Error("flat-phase migration verification failed: no artifacts rendered");
   }
 
-  // 6. Verified — remove the renamed legacy tree (backup already on disk).
+  // 6. Verified — prune legacy artifact rows now that renderAllFromDb has
+  // re-inserted flat-phase rows for artifacts that still have files.
+  try {
+    deleteArtifactsByPathPrefix("milestones/");
+  } catch (err) {
+    logWarning("migration", `flat-phase migration could not prune legacy artifact rows: ${(err as Error).message}`);
+    rollbackPartialMigration(basePath, backupDir, migratingPath);
+    throw err;
+  }
+
+  // 7. Remove the renamed legacy tree (backup already on disk).
   try {
     removePathWithRetries(migratingPath);
   } catch (err) {

package/src/resources/extensions/gsd/forensics.ts

@@ -30,7 +30,7 @@ import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
 import { isDbAvailable, getHierarchyCompletionCounts } from "./gsd-db.js";
 import { formatDuration } from "../shared/format-utils.js";
-import { getAutoWorktreePath } from "./auto-worktree.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { clearGSDPreferencesCache, loadEffectiveGSDPreferences, loadGlobalGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
 import { showNextAction } from "../shared/tui.js";
 import {

package/src/resources/extensions/gsd/git-conflict-resolve.ts

@@ -7,9 +7,9 @@ import {
   nativeCheckoutTheirs,
   nativeRmForce,
 } from "./native-git-bridge.js";
-import { isSafeToAutoResolve } from "./auto-worktree.js";
+import { isSafeToAutoResolve } from "./auto-worktree-conflict-auto-resolve.js";
 
-export { isSafeToAutoResolve } from "./auto-worktree.js";
+export { isSafeToAutoResolve } from "./auto-worktree-conflict-auto-resolve.js";
 
 export interface AutoResolveSafePathsResult {
   resolved: string[];

package/src/resources/extensions/gsd/git-service.ts

@@ -704,6 +704,59 @@ export function runGit(basePath: string, args: string[], options: { allowFailure
   }
 }
 
+/**
+ * Arguments for creating a task/workflow branch.
+ *
+ * When the current branch is a leftover GSD task branch (workflow template,
+ * quick task, or slice), the new branch starts from `baseBranch` — the
+ * caller's resolved integration branch, normally `GitServiceImpl.getMainBranch()`
+ * so `main_branch` preference, milestone integration branch, and worktree base
+ * all take priority over repo-default detection. Branching from HEAD there
+ * silently stacks consecutive workflow branches on top of each other, so every
+ * new gsd/* branch (and its eventual PR) drags along the previous workflow's
+ * commits.
+ *
+ * On any other branch (a user's feature branch, a worktree base, the main
+ * branch itself) the legacy branch-from-HEAD behavior is kept: basing new work
+ * on the branch the user chose to stand on is intentional there.
+ *
+ * Falls back to branch-from-HEAD, with a logged warning, when the base branch
+ * has no local ref or the working tree is still dirty (a start point that
+ * changes the tree would abort the checkout or strand in-flight changes).
+ * The base is the local ref — deliberately no fetch, so branch creation stays
+ * offline-safe even if the local base is behind its remote.
+ */
+export function taskBranchArgs(basePath: string, branchName: string, currentBranch: string, baseBranch: string): string[] {
+  const args = ["checkout", "-b", branchName];
+  const onTaskBranch =
+    WORKFLOW_BRANCH_RE.test(currentBranch) ||
+    QUICK_BRANCH_RE.test(currentBranch) ||
+    SLICE_BRANCH_RE.test(currentBranch);
+  if (!onTaskBranch || !baseBranch || baseBranch === currentBranch) return args;
+  try {
+    if (!nativeBranchExists(basePath, baseBranch)) {
+      logWarning(
+        "engine",
+        `taskBranchArgs: base branch "${baseBranch}" has no local ref — branching ${branchName} from HEAD (${currentBranch})`,
+        { file: "git-service.ts" },
+      );
+      return args;
+    }
+    if (nativeHasChanges(basePath)) {
+      logWarning(
+        "engine",
+        `taskBranchArgs: working tree still dirty after auto-commit — branching ${branchName} from HEAD (${currentBranch}) to preserve in-flight changes`,
+        { file: "git-service.ts" },
+      );
+      return args;
+    }
+  } catch {
+    return args;
+  }
+  args.push(baseBranch);
+  return args;
+}
+
 // ─── Commit Type Inference ─────────────────────────────────────────────────
 
 /**

package/src/resources/extensions/gsd/gsd-db.ts

@@ -1397,6 +1397,19 @@ export function deleteArtifactByPath(path: string): void {
   getDbOrNull()!.prepare("DELETE FROM artifacts WHERE path = :path").run({ ":path": path });
 }
 
+/** Delete artifact rows whose paths share a DB-relative prefix. */
+export function deleteArtifactsByPathPrefix(prefix: string): number {
+  if (!getDbOrNull()!) throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+  return transaction(() => {
+    const likePrefix = `${prefix}%`;
+    const countRow = getDbOrNull()!.prepare(
+      "SELECT COUNT(*) AS count FROM artifacts WHERE path LIKE :prefix",
+    ).get({ ":prefix": likePrefix });
+    getDbOrNull()!.prepare("DELETE FROM artifacts WHERE path LIKE :prefix").run({ ":prefix": likePrefix });
+    return Number(countRow?.["count"] ?? 0);
+  });
+}
+
 /**
  * Drop hierarchy rows in dependency order inside a transaction. Used by
  * `gsd recover --confirm` to rebuild engine state from markdown.

package/src/resources/extensions/gsd/guided-flow.ts

@@ -51,7 +51,7 @@ import { nativeAddAll, nativeCommit, nativeHasCommittedHead, nativeIsRepo, nativ
 import { isInheritedRepo } from "./repo-identity.js";
 import { ensureGitignore, ensurePreferences, untrackRuntimeFiles } from "./gitignore.js";
 import { getIsolationMode, loadEffectiveGSDPreferences } from "./preferences.js";
-import { getAutoWorktreePath } from "./auto-worktree.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { ensurePlanV2Graph, isMissingFinalizedContextResult } from "./uok/plan-v2.js";
 import { detectProjectState, hasGsdBootstrapArtifacts } from "./detection.js";
@@ -94,7 +94,7 @@ import {
 import { probeCoversRequiredWorkflowTools } from "./tool-surface-readiness.js";
 import { getRequiredWorkflowToolsForUnit } from "./unit-tool-contracts.js";
 import { isWorkflowToolSurfaceName } from "./workflow-tool-surface.js";
-import { getUnitWorkflowDispatchReadinessError } from "./tool-contract.js";
+import { getUnitWorkflowDispatchReadinessErrorForModel } from "./tool-contract.js";
 import {
   runPreparation,
   formatCodebaseBrief,
@@ -613,7 +613,7 @@ interface DispatchWorkflowOptions {
   deps?: {
     loadPreferences?: typeof loadEffectiveGSDPreferences;
     selectModel?: typeof selectAndApplyModel;
-    getDispatchReadinessError?: typeof getUnitWorkflowDispatchReadinessError;
+    getDispatchReadinessError?: typeof getUnitWorkflowDispatchReadinessErrorForModel;
   };
 }
 
@@ -730,7 +730,7 @@ async function dispatchWorkflow(
   const loadPreferences = resolvedOptions.deps?.loadPreferences ?? loadEffectiveGSDPreferences;
   const selectModel = resolvedOptions.deps?.selectModel ?? selectAndApplyModel;
   const getDispatchReadinessError = resolvedOptions.deps?.getDispatchReadinessError
-    ?? getUnitWorkflowDispatchReadinessError;
+    ?? getUnitWorkflowDispatchReadinessErrorForModel;
 
   // Route through the dynamic routing pipeline (complexity classification,
   // tier downgrade, fallback chains) — same path as auto-mode dispatches (#2958).
@@ -750,16 +750,12 @@ async function dispatchWorkflow(
     }
 
     const compatibilityError = getDispatchReadinessError({
-      provider: result.appliedModel?.provider ?? ctx.model?.provider,
+      model: result.appliedModel,
+      fallbackModel: ctx.model,
+      getProviderAuthMode: (provider) => ctx.modelRegistry.getProviderAuthMode(provider),
       projectRoot,
       surface: "guided flow",
       unitType,
-      authMode: result.appliedModel?.provider
-        ? ctx.modelRegistry.getProviderAuthMode(result.appliedModel.provider)
-        : ctx.model?.provider
-          ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
-          : undefined,
-      baseUrl: result.appliedModel?.baseUrl ?? ctx.model?.baseUrl,
       // Guided flow starts the MCP workflow server as part of dispatch, so the
       // parent session's activeTools doesn't include MCP tools yet. The MCP
       // launch config check (detectWorkflowMcpLaunchConfig) is the right gate

package/src/resources/extensions/gsd/markdown-renderer.ts

@@ -1299,9 +1299,21 @@ export async function renderAssessmentFromDb(
   sliceId: string,
   assessmentData: AssessmentData,
 ): Promise<{ assessmentPath: string; content: string }> {
-  // Flat-phase: assessment file lives in the phase dir
-  const slicePath = resolveSlicePath(basePath, milestoneId, sliceId)
-    ?? join(milestonesDir(basePath), canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
+  // Flat-phase: the assessment file lives in the phase dir, NOT in a slices/SID/
+  // subdir. resolveSlicePath() detects a slices/SID/ dir unconditionally, so a
+  // stray slices/SID/ created by an earlier planning step would send this write
+  // to a hybrid path (wrong dir, flat filename) that verification cannot find.
+  // Guard with the same legacy-base check relSlicePath() uses so flat-phase
+  // milestones always target the phase dir.
+  const mDir = resolveMilestonePath(basePath, milestoneId);
+  const legacyBase = legacyMilestonesDir(basePath);
+  const isLegacyLayout = mDir
+    ? mDir.startsWith(legacyBase + "/") || mDir.startsWith(legacyBase + "\\")
+    : false;
+  const fallbackDir = join(milestonesDir(basePath), canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
+  const slicePath = isLegacyLayout
+    ? (resolveSlicePath(basePath, milestoneId, sliceId) ?? fallbackDir)
+    : (mDir ?? fallbackDir);
   const phaseNum = milestoneIdToPhaseNum(milestoneId);
   const planNum = sliceIdToPlanNum(sliceId);
   const absPath = join(slicePath, planFileName(phaseNum, planNum, "ASSESSMENT"));

package/src/resources/extensions/gsd/milestone-merge-transaction.ts

@@ -1,6 +1,8 @@
 // Project/App: gsd-pi
 // File Purpose: Process-level transaction wrapper for milestone merge closeout.
 
+import { mergeMilestoneToMain } from "./auto-worktree-merge.js";
+
 export interface MilestoneMergeTransactionResult {
   pushed: boolean;
   codeFilesChanged: boolean;
@@ -45,3 +47,16 @@ export function createMilestoneMergeTransaction(
     );
   };
 }
+
+/**
+ * Production merge transaction adapter.
+ *
+ * This is the only production construction point that knows the legacy
+ * `auto-worktree.ts` merge primitive. Lifecycle callers depend on the
+ * transaction runner interface, not the legacy implementation module.
+ */
+export function createDefaultMilestoneMergeTransaction(
+  mergeMilestone: MilestoneMergeTransactionRunner = mergeMilestoneToMain,
+): MilestoneMergeTransactionRunner {
+  return createMilestoneMergeTransaction(mergeMilestone);
+}

package/src/resources/extensions/gsd/milestone-settlement.ts

@@ -1,7 +1,7 @@
 // Project/App: gsd-pi
 // File Purpose: Milestone closeout settlement state across DB proof, artifacts, merge, and cleanup.
 
-import { isInAutoWorktree } from "./auto-worktree.js";
+import { isInAutoWorktree } from "./auto-worktree-entry.js";
 import {
   formatCloseoutProofBlock,
   proveMilestoneCloseout,

package/src/resources/extensions/gsd/parallel-merge.ts

@@ -10,7 +10,7 @@ import { join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { resolveGsdPathContract } from "./paths.js";
 import { worktreePathFor, worktreesDirs } from "./worktree-placement.js";
-import { getAutoWorktreePath } from "./auto-worktree.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { buildWorktreeLifecycleDeps } from "./auto.js";
 import {
   mergeMilestoneStandalone,

package/src/resources/extensions/gsd/parallel-orchestrator.ts

@@ -21,7 +21,9 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath } from "./worktree-manager.js";
-import { autoWorktreeBranch, fastForwardReusedMilestoneBranchIfSafe, runWorktreePostCreateHook, syncGsdStateToWorktreeByScope } from "./auto-worktree.js";
+import { autoWorktreeBranch, fastForwardReusedMilestoneBranchIfSafe } from "./auto-worktree-branch-lifecycle.js";
+import { syncGsdStateToWorktreeByScope } from "./auto-worktree-sync.js";
+import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 import { nativeBranchExists } from "./native-git-bridge.js";
 import { readIntegrationBranch } from "./git-service.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";

package/src/resources/extensions/gsd/preferences-types.ts

@@ -29,6 +29,33 @@ export interface ContextManagementConfig {
   tool_result_max_chars?: number;         // default: 800, range: 200-10000
 }
 
+/**
+ * User-tunable thresholds for the tool-call loop guard (#1198). Keeps the two
+ * guards separately configurable: the identical-args guard (catches real
+ * infinite loops) and the repeated-tool-name cap (catches improvisation loops,
+ * more likely to false-positive on legitimate automation). All fields are
+ * optional; omitted fields fall back to the built-in defaults so existing
+ * installs keep their current behavior. Also overridable via GSD_TOOL_LOOP_*
+ * environment variables.
+ */
+export interface ToolCallLoopGuardConfig {
+  /** Master switch for both guards. Default: true. */
+  enabled?: boolean;
+  /** Identical-args sliding-window guard. */
+  identical_args?: {
+    enabled?: boolean;                    // default: true
+    max_consecutive_calls?: number;       // default: 4, min: 1
+  };
+  /** Per-tool-name cap, independent of args. */
+  repeated_tool?: {
+    enabled?: boolean;                    // default: true
+    default_cap?: number;                 // default: 6, min: 1
+    repeatable_cap?: number;              // default: 15, min: 1
+    /** Additional tool names exempt from the per-tool cap (merged with built-in defaults). */
+    exempt_tools?: string[];
+  };
+}
+
 /**
  * Opt-in tool-output sandboxing for sub-sessions. When enabled, the gsd_exec
  * MCP tool runs scripts in an isolated subprocess and returns only a short
@@ -139,6 +166,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "min_request_interval_ms",
   "stale_commit_threshold_minutes",
   "context_management",
+  "tool_call_loop_guard",
   "experimental",
   "codebase",
   "slice_parallel",
@@ -440,6 +468,8 @@ export interface GSDPreferences {
    */
   context_window_override?: number;
   context_management?: ContextManagementConfig;
+  /** User-tunable tool-call loop guard thresholds (#1198). */
+  tool_call_loop_guard?: ToolCallLoopGuardConfig;
   /**
    * Tool-output sandboxing via gsd_exec. Keeps sub-session context windows
    * clean by running scripts in a subprocess and only surfacing a short

package/src/resources/extensions/gsd/preferences-validation.ts

@@ -794,6 +794,75 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── Tool-call loop guard (#1198) ────────────────────────────────────────
+  if (preferences.tool_call_loop_guard !== undefined) {
+    if (typeof preferences.tool_call_loop_guard === "object" && preferences.tool_call_loop_guard !== null) {
+      const g = preferences.tool_call_loop_guard as unknown as Record<string, unknown>;
+      const validGuard: Record<string, unknown> = {};
+
+      if (g.enabled !== undefined) {
+        if (typeof g.enabled === "boolean") validGuard.enabled = g.enabled;
+        else errors.push("tool_call_loop_guard.enabled must be a boolean");
+      }
+
+      if (g.identical_args !== undefined) {
+        if (typeof g.identical_args === "object" && g.identical_args !== null) {
+          const ia = g.identical_args as Record<string, unknown>;
+          const validIa: Record<string, unknown> = {};
+          if (ia.enabled !== undefined) {
+            if (typeof ia.enabled === "boolean") validIa.enabled = ia.enabled;
+            else errors.push("tool_call_loop_guard.identical_args.enabled must be a boolean");
+          }
+          if (ia.max_consecutive_calls !== undefined) {
+            const n = ia.max_consecutive_calls;
+            if (typeof n === "number" && Number.isInteger(n) && n >= 1) validIa.max_consecutive_calls = n;
+            else errors.push("tool_call_loop_guard.identical_args.max_consecutive_calls must be an integer >= 1");
+          }
+          if (Object.keys(validIa).length > 0) validGuard.identical_args = validIa;
+        } else {
+          errors.push("tool_call_loop_guard.identical_args must be an object");
+        }
+      }
+
+      if (g.repeated_tool !== undefined) {
+        if (typeof g.repeated_tool === "object" && g.repeated_tool !== null) {
+          const rt = g.repeated_tool as Record<string, unknown>;
+          const validRt: Record<string, unknown> = {};
+          if (rt.enabled !== undefined) {
+            if (typeof rt.enabled === "boolean") validRt.enabled = rt.enabled;
+            else errors.push("tool_call_loop_guard.repeated_tool.enabled must be a boolean");
+          }
+          if (rt.default_cap !== undefined) {
+            const n = rt.default_cap;
+            if (typeof n === "number" && Number.isInteger(n) && n >= 1) validRt.default_cap = n;
+            else errors.push("tool_call_loop_guard.repeated_tool.default_cap must be an integer >= 1");
+          }
+          if (rt.repeatable_cap !== undefined) {
+            const n = rt.repeatable_cap;
+            if (typeof n === "number" && Number.isInteger(n) && n >= 1) validRt.repeatable_cap = n;
+            else errors.push("tool_call_loop_guard.repeated_tool.repeatable_cap must be an integer >= 1");
+          }
+          if (rt.exempt_tools !== undefined) {
+            if (Array.isArray(rt.exempt_tools) && rt.exempt_tools.every((t) => typeof t === "string")) {
+              validRt.exempt_tools = rt.exempt_tools;
+            } else {
+              errors.push("tool_call_loop_guard.repeated_tool.exempt_tools must be an array of strings");
+            }
+          }
+          if (Object.keys(validRt).length > 0) validGuard.repeated_tool = validRt;
+        } else {
+          errors.push("tool_call_loop_guard.repeated_tool must be an object");
+        }
+      }
+
+      if (Object.keys(validGuard).length > 0) {
+        validated.tool_call_loop_guard = validGuard as any;
+      }
+    } else {
+      errors.push("tool_call_loop_guard must be an object");
+    }
+  }
+
   // ─── Context Mode (gsd_exec sandbox) ────────────────────────────────────
   if (preferences.context_mode !== undefined) {
     if (typeof preferences.context_mode === "object" && preferences.context_mode !== null) {

package/src/resources/extensions/gsd/prompts/system.md

@@ -38,7 +38,7 @@ If a `GSD Skill Preferences` block appears below, treat it as durable guidance f
 
 ### Naming Convention
 
-Directories use bare IDs. Files use ID-SUFFIX format. Milestones: `M001/` or `M{seq}-{rand6}/` when `unique_milestone_ids: true`; files like `M001-CONTEXT.md`, `M001-ROADMAP.md`, `M001-RESEARCH.md`. Slices: `S01/` with `S01-PLAN.md`, `S01-RESEARCH.md`, `S01-SUMMARY.md`, `S01-UAT.md`. Tasks: `T01-PLAN.md`, `T01-SUMMARY.md`. Titles live inside content, not names.
+GSD projects use a flat-phase layout. Phase directories are `{MM}-{slug}` where `{MM}` is the zero-padded phase number and `{slug}` is derived from the phase title (e.g. `47-real-time-runtime-hardening`). Phase-level files are `{MM}-SUFFIX.md` (e.g. `47-CONTEXT.md`, `47-RESEARCH.md`, `47-ROADMAP.md`, `47-VALIDATION.md`, `47-SUMMARY.md`). Slice/plan files live directly in the phase directory as `{MM}-{SS}-SUFFIX.md` (e.g. `47-01-PLAN.md`, `47-01-SUMMARY.md`, `47-01-UAT.md`). Task plan content lives inside the slice plan file (`{MM}-{SS}-PLAN.md`) as checkboxes; there is no `tasks/` subdirectory and no `tasks/T##-PLAN.md`. Titles live inside content, not names. Prefer GSD-provided layout-aware paths/resolvers over hardcoding artifact paths, since phase slugs are title-derived.
 
 ### Directory Structure
 
@@ -46,13 +46,13 @@ Directories use bare IDs. Files use ID-SUFFIX format. Milestones: `M001/` or `M{
 .gsd/
   PROJECT.md, REQUIREMENTS.md, DECISIONS.md, KNOWLEDGE.md, CODEBASE.md, OVERRIDES.md, QUEUE.md, STATE.md
   runtime/, activity/, worktrees/
-  milestones/M001/
-    M001-CONTEXT.md, M001-RESEARCH.md, M001-ROADMAP.md, M001-SUMMARY.md
-    slices/S01/
-      S01-CONTEXT.md, S01-RESEARCH.md, S01-PLAN.md, S01-SUMMARY.md, S01-UAT.md
-      tasks/T01-PLAN.md, tasks/T01-SUMMARY.md
+  phases/{MM}-{slug}/
+    {MM}-CONTEXT.md, {MM}-RESEARCH.md, {MM}-ROADMAP.md, {MM}-VALIDATION.md, {MM}-SUMMARY.md
+    {MM}-{SS}-PLAN.md, {MM}-{SS}-SUMMARY.md, {MM}-{SS}-UAT.md
 ```
 
+Task plan content is embedded in `{MM}-{SS}-PLAN.md`; do not expect `tasks/T##-PLAN.md`.
+
 `runtime/`, `activity/`, `worktrees/`, and `STATE.md` are system-managed. `PROJECT.md` is current state; `REQUIREMENTS.md` is the active capability contract; `DECISIONS.md` and `KNOWLEDGE.md` are append-only; `CODEBASE.md` is an auto-refreshed codebase map.
 
 ### Isolation Model

package/src/resources/extensions/gsd/quick.ts

@@ -15,7 +15,7 @@ import { isAbsolute, join, relative, resolve } from "node:path";
 import { QUICK_BRANCH_RE } from "./branch-patterns.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
-import { GitServiceImpl, runGit } from "./git-service.js";
+import { GitServiceImpl, runGit, taskBranchArgs } from "./git-service.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { nativeBranchExists, nativeDetectMainBranch, nativeDiffNumstat } from "./native-git-bridge.js";
 import { nativeHasStagedChanges } from "./native-git-bridge.js";
@@ -365,6 +365,7 @@ export async function handleQuick(
   const git = new GitServiceImpl(basePath, gitPrefs);
   const branchName = `gsd/quick/${taskNum}-${slug}`;
   let originalBranch = git.getCurrentBranch();
+  let returnBranch = originalBranch;
 
   const { getIsolationMode } = await import("./preferences.js");
   const usesBranch = getIsolationMode() !== "none" && isGitOpsEnabled();
@@ -381,7 +382,14 @@ export async function handleQuick(
           }
         } catch { /* nothing to commit — fine */ }
 
-        runGit(basePath, ["checkout", "-b", branchName]);
+        const branchArgs = taskBranchArgs(basePath, branchName, current, git.getMainBranch());
+        const startPoint = branchArgs[3];
+        // When the quick branch is redirected off a stale task branch, the
+        // squash-merge on closeout must return to the same base — merging a
+        // base-branch-rooted quick branch back into the stale task branch
+        // would drag the base's newer history into it.
+        if (startPoint) returnBranch = startPoint;
+        runGit(basePath, branchArgs);
         branchCreated = true;
       }
     } catch (err) {
@@ -395,7 +403,7 @@ export async function handleQuick(
   if (actualBranch === branchName && originalBranch !== branchName) {
     persistPendingReturn({
       basePath,
-      originalBranch,
+      originalBranch: returnBranch,
       quickBranch: branchName,
       taskNum,
       slug,

package/src/resources/extensions/gsd/slice-parallel-orchestrator.ts

@@ -30,7 +30,9 @@ import { isAbsolute, join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath, removeWorktree } from "./worktree-manager.js";
-import { autoWorktreeBranch, runWorktreePostCreateHook, syncGsdStateToWorktreeByScope } from "./auto-worktree.js";
+import { autoWorktreeBranch } from "./auto-worktree-branch-lifecycle.js";
+import { syncGsdStateToWorktreeByScope } from "./auto-worktree-sync.js";
+import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
 import {
   writeSessionStatus,