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

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -12,7 +12,7 @@ import { readFileSync, existsSync, mkdirSync, statSync, unlinkSync } from "node:
 import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
 import { dirname, join, relative } from "node:path";
-import { getAllMilestones, getMilestone, getMilestoneScopedArtifacts, getSliceScopedArtifacts, getMilestoneSlices, getSliceTasks, getTask, getSlice, insertArtifact, deleteArtifactByPath, getGateResults, isDbAvailable, } from "./gsd-db.js";
+import { getAllMilestones, getMilestone, getMilestoneScopedArtifacts, getSliceScopedArtifacts, getMilestoneSlices, getSliceTasks, getTasksBySliceIds, getTask, getSlice, insertArtifact, deleteArtifactByPath, getGateResults, isDbAvailable, } from "./gsd-db.js";
 import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, gsdProjectionRoot, gsdRoot, buildMilestoneFileName, buildTaskFileName, } from "./paths.js";
 import { saveFile, clearParseCache, registerCacheClearCallback } from "./files.js";
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
@@ -99,6 +99,12 @@ function meaningfulSection(value) {
         return "";
     return trimmed;
 }
+function renderGateFindings(gate) {
+    const findings = gate.findings.trim() || `- **Verdict:** ${gate.verdict}\n- **Rationale:** ${gate.rationale}`;
+    if (gate.verdict !== "flag")
+        return findings;
+    return `> **Warning:** Verdict: flag - concerns recorded below\n\n${findings}`;
+}
 function pushIndented(lines, value, indent = "  ") {
     for (const line of value.split("\n")) {
         lines.push(`${indent}${line}`);
@@ -289,7 +295,7 @@ function renderTaskPlanMarkdown(task, taskGates = []) {
         if (gate && gate.verdict !== "omitted") {
             lines.push(`## ${label}`);
             lines.push("");
-            lines.push(gate.findings.trim() || `- **Verdict:** ${gate.verdict}\n- **Rationale:** ${gate.rationale}`);
+            lines.push(renderGateFindings(gate));
             lines.push("");
         }
     }
@@ -319,14 +325,14 @@ function renderSlicePlanMarkdown(slice, tasks, gates = []) {
     if (q3 && q3.verdict !== "omitted") {
         lines.push("## Threat Surface");
         lines.push("");
-        lines.push(q3.findings.trim() || `- **Verdict:** ${q3.verdict}\n- **Rationale:** ${q3.rationale}`);
+        lines.push(renderGateFindings(q3));
         lines.push("");
     }
     const q4 = gates.find(g => g.gate_id === "Q4" && g.status === "complete");
     if (q4 && q4.verdict !== "omitted") {
         lines.push("## Requirement Impact");
         lines.push("");
-        lines.push(q4.findings.trim() || `- **Verdict:** ${q4.verdict}\n- **Rationale:** ${q4.rationale}`);
+        lines.push(renderGateFindings(q4));
         lines.push("");
     }
     const proofLevel = meaningfulSection(slice.proof_level);
@@ -701,6 +707,17 @@ export async function renderSliceSummary(basePath, milestoneId, sliceId) {
 export async function renderAllFromDb(basePath) {
     const result = { rendered: 0, skipped: 0, errors: [] };
     const milestones = getAllMilestones();
+    // Pre-fetch slices once per milestone and batch-load all tasks in one query
+    // family, avoiding an N+1 (previously one task query per slice).
+    const slicesByMilestone = new Map();
+    const slicePairs = [];
+    for (const milestone of milestones) {
+        const slices = getMilestoneSlices(milestone.id);
+        slicesByMilestone.set(milestone.id, slices);
+        for (const slice of slices)
+            slicePairs.push({ milestoneId: milestone.id, sliceId: slice.id });
+    }
+    const tasksBySlice = getTasksBySliceIds(slicePairs);
     for (const milestone of milestones) {
         // Render roadmap checkboxes
         try {
@@ -723,8 +740,8 @@ export async function renderAllFromDb(basePath) {
         catch (err) {
             result.errors.push(`milestone artifacts ${milestone.id}: ${err.message}`);
         }
-        // Iterate slices
-        const slices = getMilestoneSlices(milestone.id);
+        // Iterate slices (pre-fetched above)
+        const slices = slicesByMilestone.get(milestone.id) ?? [];
         for (const slice of slices) {
             // Preserve slice-scoped artifacts imported from disk, including real PLAN
             // fallback content when task rows cannot regenerate it.
@@ -760,8 +777,8 @@ export async function renderAllFromDb(basePath) {
             catch (err) {
                 result.errors.push(`slice summary ${milestone.id}/${slice.id}: ${err.message}`);
             }
-            // Iterate tasks
-            const tasks = getSliceTasks(milestone.id, slice.id);
+            // Iterate tasks (batched above)
+            const tasks = tasksBySlice.get(`${milestone.id}\0${slice.id}`) ?? [];
             for (const task of tasks) {
                 try {
                     const ok = await renderTaskSummary(basePath, milestone.id, slice.id, task.id);
@@ -1028,9 +1045,21 @@ export async function renderReplanFromDb(basePath, milestoneId, sliceId, replanD
     return { replanPath: absPath, content };
 }
 export async function renderAssessmentFromDb(basePath, milestoneId, sliceId, assessmentData) {
-    // 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/dist/resources/extensions/gsd/migrate-external.js

@@ -8,7 +8,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, renameSync, cpSync, rmSync, statSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
-import { externalGsdRoot, isInsideWorktree } from "./repo-identity.js";
+import { externalGsdRoot, externalStateAlreadyExistsForProject, isInsideWorktree } from "./repo-identity.js";
 import { getErrorMessage } from "./error-utils.js";
 import { hasGitTrackedGsdFiles } from "./gitignore.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
@@ -74,6 +74,15 @@ export function migrateToExternalState(basePath) {
             return { migrated: false };
         }
     }
+    // If external state already contains project data, this is not a legacy
+    // migration source. It is likely an already-migrated project whose symlink
+    // was replaced by a real directory, so copying would risk data loss.
+    if (externalStateAlreadyExistsForProject(basePath)) {
+        return {
+            migrated: false,
+            error: "External state already exists for this project; leaving local .gsd directory untouched to avoid overwriting authoritative state",
+        };
+    }
     const externalPath = externalGsdRoot(basePath);
     const migratingPath = join(basePath, ".gsd.migrating");
     try {
@@ -81,13 +90,13 @@ export function migrateToExternalState(basePath) {
         mkdirSync(externalPath, { recursive: true });
         // Rename .gsd -> .gsd.migrating (atomic lock).
         // On Windows, NTFS may reject rename with EPERM if file descriptors are
-        // open (VS Code watchers, antivirus on-access scan). Fall back to
-        // copy+delete (#1292).
+        // open (VS Code watchers, antivirus on-access scan). WSL/DrvFs can report
+        // the same transient lock as EACCES. Fall back to copy+delete (#1292).
         try {
             renameSync(localGsd, migratingPath);
         }
         catch (renameErr) {
-            if (renameErr?.code === "EPERM" || renameErr?.code === "EBUSY") {
+            if (renameErr?.code === "EPERM" || renameErr?.code === "EBUSY" || renameErr?.code === "EACCES") {
                 try {
                     cpSync(localGsd, migratingPath, { recursive: true, force: true });
                     rmSync(localGsd, { recursive: true, force: true });
@@ -239,7 +248,7 @@ function isLocalGsdExternalStateJunction(basePath, localGsd) {
  * Recover from a failed migration (`.gsd.migrating` exists).
  * Moves `.gsd.migrating` back to `.gsd` if `.gsd` doesn't exist, or removes an
  * orphaned staging directory when `.gsd` is already a verified external state
- * junction with intact current state.
+ * junction, or an intact real directory, with intact current state.
  */
 export function recoverFailedMigration(basePath) {
     const localGsd = join(basePath, ".gsd");
@@ -247,10 +256,18 @@ export function recoverFailedMigration(basePath) {
     if (!existsSync(migratingPath))
         return false;
     if (existsSync(localGsd)) {
-        if (!isLocalGsdExternalStateJunction(basePath, localGsd))
-            return false;
         if (!isCurrentGsdStateIntactForMigratingCleanup(basePath))
             return false;
+        if (!isLocalGsdExternalStateJunction(basePath, localGsd)) {
+            try {
+                const stat = lstatSync(localGsd);
+                if (!stat.isDirectory())
+                    return false;
+            }
+            catch {
+                return false;
+            }
+        }
         try {
             rmSync(migratingPath, { recursive: true, force: true });
             return true;

package/dist/resources/extensions/gsd/milestone-merge-transaction.js

@@ -1,10 +1,21 @@
 // Project/App: gsd-pi
 // File Purpose: Process-level transaction wrapper for milestone merge closeout.
+import { mergeMilestoneToMain } from "./auto-worktree-merge.js";
 export function runMilestoneMergeTransaction(deps, input) {
-    return deps.mergeMilestoneToMain(input.basePath, input.milestoneId, input.roadmapContent);
+    return deps.mergeMilestone(input.basePath, input.milestoneId, input.roadmapContent);
 }
-export function createMilestoneMergeTransaction(mergeMilestoneToMain) {
+export function createMilestoneMergeTransaction(mergeMilestone) {
     return function mergeMilestoneTransaction(basePath, milestoneId, roadmapContent) {
-        return runMilestoneMergeTransaction({ mergeMilestoneToMain }, { basePath, milestoneId, roadmapContent });
+        return runMilestoneMergeTransaction({ mergeMilestone }, { basePath, milestoneId, roadmapContent });
     };
 }
+/**
+ * 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 = mergeMilestoneToMain) {
+    return createMilestoneMergeTransaction(mergeMilestone);
+}

package/dist/resources/extensions/gsd/milestone-settlement.js

@@ -1,6 +1,6 @@
 // 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, } from "./milestone-closeout-proof.js";
 import { resolveCloseoutArtifactProjection } from "./artifact-projection.js";
 function isActiveUnmergedWorktree(input) {

package/dist/resources/extensions/gsd/parallel-merge.js

@@ -8,7 +8,7 @@ import { existsSync, readdirSync } from "node:fs";
 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, } from "./worktree-lifecycle.js";
 import { MergeConflictError } from "./git-service.js";

package/dist/resources/extensions/gsd/parallel-orchestrator.js

@@ -12,7 +12,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/dist/resources/extensions/gsd/preferences-diagnostics.js

@@ -1,4 +1,5 @@
-import { loadGlobalGSDPreferences, loadProjectGSDPreferences, } from "./preferences.js";
+import { loadEffectiveGSDPreferences, loadGlobalGSDPreferences, loadProjectGSDPreferences, } from "./preferences.js";
+import { crossAxisPreferenceWarnings } from "./preferences-validation.js";
 const notifiedPreferenceDiagnostics = new Set();
 export function collectPreferenceDiagnostics(basePath) {
     const diagnostics = [
@@ -14,6 +15,28 @@ export function collectPreferenceDiagnostics(basePath) {
         seen.add(signature);
         unique.push(diagnostic);
     }
+    const effective = loadEffectiveGSDPreferences(basePath);
+    if (effective) {
+        const existingMessages = new Set(unique.map((diagnostic) => diagnostic.message));
+        for (const message of crossAxisPreferenceWarnings(effective.preferences)) {
+            if (existingMessages.has(message))
+                continue;
+            const diagnostic = {
+                path: effective.path,
+                scope: effective.scope,
+                severity: "warning",
+                kind: "validation",
+                message,
+                sanitized: true,
+            };
+            const signature = preferenceDiagnosticSignature(diagnostic);
+            if (seen.has(signature))
+                continue;
+            seen.add(signature);
+            existingMessages.add(message);
+            unique.push(diagnostic);
+        }
+    }
     return unique;
 }
 export function formatPreferenceDiagnostic(diagnostic) {

package/dist/resources/extensions/gsd/preferences-models.js

@@ -74,10 +74,12 @@ function resolveWinningPhase(models, chain) {
  * - Legacy: `planning: claude-opus-4-6`
  * - Extended: `planning: { model: claude-opus-4-6, fallbacks: [glm-5, minimax-m2.5] }`
  */
-export function resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId) {
-    const loadOpts = availableModelIds !== undefined || preferredModelId !== undefined
-        ? { availableModelIds, preferredModelId }
-        : undefined;
+export function resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId, skipProfileDefaults = false) {
+    const loadOpts = {
+        ...(availableModelIds !== undefined ? { availableModelIds } : {}),
+        ...(preferredModelId !== undefined ? { preferredModelId } : {}),
+        ...(skipProfileDefaults ? { skipProfileDefaults: true } : {}),
+    };
     const prefs = loadEffectiveGSDPreferences(basePath, loadOpts);
     const chain = phaseChainForUnit(unitType);
     if (!chain)

package/dist/resources/extensions/gsd/preferences-types.js

@@ -86,6 +86,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "min_request_interval_ms",
     "stale_commit_threshold_minutes",
     "context_management",
+    "tool_call_loop_guard",
     "experimental",
     "codebase",
     "slice_parallel",

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -34,6 +34,15 @@ const VALID_POST_UNIT_HOOK_ON_BLOCK_ACTIONS = new Set([
     "pause",
 ]);
 const VALID_GATE_EVALUATE_SLICE_GATES = new Set(getGateIdsForTurn("gate-evaluate"));
+/** Cross-axis warnings that only apply to the effective (merged) preference shape. */
+export function crossAxisPreferenceWarnings(preferences) {
+    if (preferences.mode === "team" && preferences.workspace?.mode === "parent") {
+        return [
+            "mode:team + workspace.mode:parent: team branch-push/PR resolves at the project root and will not push child repositories — see docs/dev/ADR-044",
+        ];
+    }
+    return [];
+}
 export function validatePreferences(preferences) {
     const errors = [];
     const warnings = [];
@@ -489,8 +498,12 @@ export function validatePreferences(preferences) {
     }
     // ─── Remote Questions ───────────────────────────────────────────────
     if (preferences.remote_questions !== undefined) {
-        if (preferences.remote_questions && typeof preferences.remote_questions === "object") {
-            validated.remote_questions = preferences.remote_questions;
+        const remoteQuestions = preferences.remote_questions;
+        if (typeof remoteQuestions === "object" && remoteQuestions !== null) {
+            validated.remote_questions = remoteQuestions;
+        }
+        else if (remoteQuestions === false) {
+            // Explicit disable for a globally-configured remote questions channel.
         }
         else {
             errors.push("remote_questions must be an object");
@@ -788,6 +801,88 @@ export function validatePreferences(preferences) {
             errors.push("context_management must be an object");
         }
     }
+    // ─── 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;
+            const validGuard = {};
+            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;
+                    const validIa = {};
+                    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;
+                    const validRt = {};
+                    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;
+            }
+        }
+        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) {
@@ -1524,6 +1619,15 @@ export function validatePreferences(preferences) {
         else {
             errors.push("workspace must be an object");
         }
+        // parent mode is behavioral: it must coordinate at least one declared
+        // child repository. Without one it is indistinguishable from project
+        // mode, so reject it explicitly rather than silently degrading.
+        if (validated.workspace?.mode === "parent") {
+            const childRepoCount = validated.workspace.repositories ? Object.keys(validated.workspace.repositories).length : 0;
+            if (childRepoCount === 0) {
+                errors.push('workspace.mode "parent" requires at least one repository under workspace.repositories');
+            }
+        }
     }
     // ─── Enhanced Verification ──────────────────────────────────────────────────
     if (preferences.enhanced_verification !== undefined) {
@@ -1596,5 +1700,6 @@ export function validatePreferences(preferences) {
             errors.push(`language must be a non-empty string up to 50 characters with no newlines (e.g. "Chinese", "de", "日本語")`);
         }
     }
+    warnings.push(...crossAxisPreferenceWarnings(validated));
     return { preferences: validated, errors, warnings };
 }

package/dist/resources/extensions/gsd/preferences.js

@@ -19,7 +19,7 @@ import { logWarning } from "./workflow-logger.js";
 import { DEFAULT_TOKEN_PROFILE, resolveProfileDefaults as _resolveProfileDefaults, VALID_TOKEN_PROFILES, resolveDisabledModelProvidersFromPreferences, } from "./preferences-models.js";
 import { nativeHasCommittedHead, nativeIsRepo } from "./native-git-bridge.js";
 import { KNOWN_PREFERENCE_KEYS, MODE_DEFAULTS, formatSkillRef, } from "./preferences-types.js";
-import { validatePreferences } from "./preferences-validation.js";
+import { crossAxisPreferenceWarnings, validatePreferences } from "./preferences-validation.js";
 import { gsdHome } from "./gsd-home.js";
 // ─── Re-exports: validation ─────────────────────────────────────────────────
 export { validatePreferences } from "./preferences-validation.js";
@@ -203,6 +203,7 @@ function effectivePreferencesCacheKey(basePath, opts) {
         project: projectPreferencesCandidatePaths(basePath).map(preferencesFileSignature),
         availableModelIds: opts?.availableModelIds ?? null,
         preferredModelId: opts?.preferredModelId ?? null,
+        skipProfileDefaults: opts?.skipProfileDefaults === true,
     });
 }
 function cloneLoadedPreferences(loaded) {
@@ -264,7 +265,7 @@ export function loadEffectiveGSDPreferences(basePath, opts) {
     else {
         profileForDefaults = DEFAULT_TOKEN_PROFILE;
     }
-    if (profileForDefaults) {
+    if (profileForDefaults && !opts?.skipProfileDefaults) {
         const profileDefaults = _resolveProfileDefaults(profileForDefaults, opts?.availableModelIds, result.preferences.dynamic_routing, opts?.preferredModelId);
         const defaultsToApply = explicitProfile
             ? profileDefaults
@@ -282,9 +283,35 @@ export function loadEffectiveGSDPreferences(basePath, opts) {
         };
     }
     result = stripInheritedPlanningDepth(result, projectHasPlanningDepth);
+    result = appendCrossAxisPreferenceWarnings(result);
     cacheEffectivePreferences(cacheKey, result);
     return result;
 }
+function appendCrossAxisPreferenceWarnings(loaded) {
+    const crossWarnings = crossAxisPreferenceWarnings(loaded.preferences);
+    const existingMessages = new Set([
+        ...(loaded.warnings ?? []),
+        ...(loaded.diagnostics ?? []).map((diagnostic) => diagnostic.message),
+    ]);
+    const newWarnings = crossWarnings.filter((message) => !existingMessages.has(message));
+    if (newWarnings.length === 0)
+        return loaded;
+    return {
+        ...loaded,
+        warnings: [...(loaded.warnings ?? []), ...newWarnings],
+        diagnostics: [
+            ...(loaded.diagnostics ?? []),
+            ...newWarnings.map((message) => ({
+                path: loaded.path,
+                scope: loaded.scope,
+                severity: "warning",
+                kind: "validation",
+                message,
+                sanitized: true,
+            })),
+        ],
+    };
+}
 function withoutProfilePhaseDefaults(defaults) {
     if (defaults.phases === undefined)
         return defaults;

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -32,6 +32,8 @@ Before planning, validate roadmap assumptions against code and dependency summar
 
 If slice research is inlined, trust its architectural findings, but verify every concrete file path you place in task `inputs` or `expectedOutput` against the current tree or prior/same-task outputs. Explore enough code to confirm paths, boundaries, and verification. Executors later get only task plans, slice excerpt, and prior summaries, so put required paths, steps, inputs, and outputs in task plans.
 
+{{repoRegistry}}
+
 {{executorContextConstraints}}
 
 ## Planning Rules
@@ -45,8 +47,8 @@ If slice research is inlined, trust its architectural findings, but verify every
 6. Include Threat Surface (Q3), Requirement Impact (Q4), proof level, observability, integration closure, Failure Modes (Q5), Load Profile (Q6), and Negative Tests (Q7) only where applicable.
 7. Right-size tasks. Simple slices can be one task; split only when context, ownership, or verification boundaries justify it.
 8. Task `verify` commands must be safe, simple commands. Do not use shell pipes, redirects, semicolons, backticks, command substitution, output trimming, or grep regex alternation with `|`. If multiple checks are needed, create a small test file and run it with `node --test` or a package test script, or use separate simple commands joined only with `&&`. For absence checks, verify a pattern does not exist with `! grep -q 'pattern' file` or `! rg -q 'pattern' file`; do not use `grep -c` or `rg -c` to assert zero matches because count commands exit 1 when they find zero matches, and the verification gate treats that as failure.
-9. Each task persisted with `gsd_plan_task` needs the exact shape: `milestoneId`, `sliceId`, `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. `description` should contain the Why / Do / Done-when narrative. Any npm package name in a task description's install/add instructions (`npm install`, `yarn add`, `pnpm add`) or in `require('...')` or `import ... from '...'` code examples is subject to pre-execution registry validation; reference only packages that exist on the public npm registry, and remove or correct any package name that is not real. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even when there is only one path (for example, `"inputs": ["src/index.ts"]`, never `"inputs": "src/index.ts"`). Use paths relative to `{{workingDirectory}}`; do not put absolute paths to the original checkout or any directory outside `{{workingDirectory}}` in `files`, `inputs`, `expectedOutput`, or verification commands. **`expectedOutput` must only list files the task actually creates or overwrites on disk.** Do NOT include files the task merely reads, verifies, tests, or describes — those belong in `inputs`, `verify`, `description`, or slice success criteria. If a task is a pure verification or test task that produces no new files, `expectedOutput` must be `[]`; if it writes a test-result log or assertion output file, list only that concrete file path. A file that does not yet exist on disk and is needed as an `input` must be produced by an earlier task's `expectedOutput` — if no prior task creates it, add a task before this one that does. Never list GSD planning artifacts — anything under `.gsd/`, `.planning/`, or `.audits/`, or artifact names like `M001-CONTEXT.md` / `S01-PLAN.md` — in `inputs`, `files`, or `expectedOutput`: their content is preloaded as context, and they are written by workflow tools, not by tasks.
-10. Persist incrementally through DB-backed tools. First call `gsd_plan_slice` with `milestoneId`, `sliceId`, `goal`, and optional `successCriteria`/`proofLevel`/`integrationClosure`/`observabilityImpact`; omit `tasks` for this metadata call. Then call `gsd_plan_task` once per task, using the task shape above. Each successful tool call saves progress and re-renders `{{outputPath}}` from DB. The DB-backed tools are the canonical write path. Do **not** rely on direct `PLAN.md` writes as the source of truth.
+9. Each task persisted with `gsd_plan_task` needs the exact shape: `milestoneId`, `sliceId`, `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. In a parent workspace (when a Declared Repositories block is present above), also set `targetRepositories` to the repository id(s) the task touches. `description` should contain the Why / Do / Done-when narrative. Any npm package name in a task description's install/add instructions (`npm install`, `yarn add`, `pnpm add`) or in `require('...')` or `import ... from '...'` code examples is subject to pre-execution registry validation; reference only packages that exist on the public npm registry, and remove or correct any package name that is not real. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even when there is only one path (for example, `"inputs": ["src/index.ts"]`, never `"inputs": "src/index.ts"`). Use paths relative to `{{workingDirectory}}`; do not put absolute paths to the original checkout or any directory outside `{{workingDirectory}}` in `files`, `inputs`, `expectedOutput`, or verification commands. **`expectedOutput` must only list files the task actually creates or overwrites on disk.** Do NOT include files the task merely reads, verifies, tests, or describes — those belong in `inputs`, `verify`, `description`, or slice success criteria. If a task is a pure verification or test task that produces no new files, `expectedOutput` must be `[]`; if it writes a test-result log or assertion output file, list only that concrete file path. A file that does not yet exist on disk and is needed as an `input` must be produced by an earlier task's `expectedOutput` — if no prior task creates it, add a task before this one that does. Never list GSD planning artifacts — anything under `.gsd/`, `.planning/`, or `.audits/`, or artifact names like `M001-CONTEXT.md` / `S01-PLAN.md` — in `inputs`, `files`, or `expectedOutput`: their content is preloaded as context, and they are written by workflow tools, not by tasks.
+10. Persist incrementally through DB-backed tools. First call `gsd_plan_slice` with `milestoneId`, `sliceId`, `goal`, and optional `successCriteria`/`proofLevel`/`integrationClosure`/`observabilityImpact` (and `targetRepositories` in a parent workspace, to set the slice-wide default); omit `tasks` for this metadata call. Then call `gsd_plan_task` once per task, using the task shape above. Each successful tool call saves progress and re-renders `{{outputPath}}` from DB. The DB-backed tools are the canonical write path. Do **not** rely on direct `PLAN.md` writes as the source of truth.
 11. Self-audit before finishing: goal/demo closure, requirement coverage, deliverable coverage audit (cross-check every file listed in CONTEXT.md `## Scope` / `### In Scope` against task `files` or `expectedOutput`), locked decisions, concrete paths, dependency order, wiring, scope size, proof truthfulness, feature completeness, and quality gates. Quality gates: non-trivial slices/tasks include specific Q3-Q7 coverage where applicable.
 12. If planning creates structural decisions, call `gsd_decision_save` for each; the tool persists the decision and regenerates `.gsd/DECISIONS.md`.
 13. {{commitInstruction}}

package/dist/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/dist/resources/extensions/gsd/quick.js

@@ -13,7 +13,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";
@@ -317,6 +317,7 @@ export async function handleQuick(args, ctx, pi) {
     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();
     let branchCreated = false;
@@ -331,7 +332,15 @@ export async function handleQuick(args, ctx, pi) {
                     }
                 }
                 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;
             }
         }
@@ -345,7 +354,7 @@ export async function handleQuick(args, ctx, pi) {
     if (actualBranch === branchName && originalBranch !== branchName) {
         persistPendingReturn({
             basePath,
-            originalBranch,
+            originalBranch: returnBranch,
             quickBranch: branchName,
             taskNum,
             slug,