@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

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);
@@ -518,13 +524,8 @@ export async function renderRoadmapFromDb(basePath, milestoneId) {
  * @returns true if the roadmap was written, false on skip/error
  */
 export async function renderRoadmapCheckboxes(basePath, milestoneId) {
-    const slices = getMilestoneSlices(milestoneId);
-    if (slices.length === 0) {
-        process.stderr.write(`markdown-renderer: no slices found for milestone ${milestoneId}\n`);
-        return false;
-    }
-    await renderRoadmapFromDb(basePath, milestoneId);
-    return true;
+    const rendered = await renderRoadmapFromDb(basePath, milestoneId);
+    return !("skipped" in rendered);
 }
 /**
  * Project milestone-level artifacts (CONTEXT, RESEARCH, VALIDATION, etc.) from
@@ -706,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 {
@@ -728,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.
@@ -765,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);

package/dist/resources/extensions/gsd/memory-backfill.js

@@ -33,8 +33,8 @@ import { logWarning } from "./workflow-logger.js";
  *   decision is checked individually; only decisions whose id is already
  *   present in the memory store are skipped. A user-authored memory with
  *   their own `sourceDecisionId` does NOT abort the backfill.
- * - Best-effort: never throws. Logs and returns 0 on failure so a broken
- *   backfill cannot block agent startup.
+ * - Best-effort: never throws. Failed memory inserts are logged and skipped;
+ *   setup/read failures log and return 0 so backfill cannot block startup.
  * - Full migration (ADR-013 Stage 2a): both active and superseded rows are
  *   migrated. `structured_fields.superseded_by` preserves the supersedes
  *   chain so the DECISIONS.md projection regen can source from memories
@@ -117,25 +117,32 @@ export function backfillDecisionsToMemories() {
                 continue;
             }
             const content = synthesizeDecisionMemoryContent(row);
-            const id = createMemory({
-                category: "architecture",
-                content,
-                scope: row.scope || "project",
-                confidence: 0.85,
-                structuredFields: {
-                    sourceDecisionId: row.id,
-                    when_context: row.when_context,
-                    scope: row.scope,
-                    decision: row.decision,
-                    choice: row.choice,
-                    rationale: row.rationale,
-                    made_by: row.made_by,
-                    revisable: row.revisable,
-                    superseded_by: row.superseded_by,
-                },
-            });
-            if (id)
-                written += 1;
+            try {
+                const id = createMemory({
+                    category: "architecture",
+                    content,
+                    scope: row.scope || "project",
+                    confidence: 0.85,
+                    structuredFields: {
+                        sourceDecisionId: row.id,
+                        when_context: row.when_context,
+                        scope: row.scope,
+                        decision: row.decision,
+                        choice: row.choice,
+                        rationale: row.rationale,
+                        made_by: row.made_by,
+                        revisable: row.revisable,
+                        superseded_by: row.superseded_by,
+                    },
+                });
+                if (id)
+                    written += 1;
+            }
+            catch (rowErr) {
+                const message = rowErr instanceof Error ? rowErr.message : String(rowErr);
+                logWarning("memory-backfill", `decisions->memories backfill skipped ${row.id}: ${message}`);
+                continue;
+            }
         }
         if (healed > 0) {
             logWarning("memory-backfill", `decisions->memories drift healed: ${healed} row${healed === 1 ? "" : "s"} updated superseded_by`);

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

@@ -17,7 +17,7 @@ import { join } from "node:path";
 import { openSync, closeSync, unlinkSync, statSync, writeFileSync } from "node:fs";
 import { gsdRoot } from "./paths.js";
 import { getAndClearSkills } from "./skill-telemetry.js";
-import { loadJsonFile, loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
+import { loadJsonFile, loadJsonFileOrNull, saveJsonFileCompact } from "./json-persistence.js";
 import { parseUnitId } from "./unit-id.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
 import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
@@ -636,7 +636,7 @@ export function pruneMetricsLedger(base, keepCount) {
         return 0;
     const removed = disk.units.length - keepCount;
     disk.units = keepNewestUnits(disk.units, keepCount);
-    saveJsonFile(metricsPath(base), disk);
+    saveJsonFileCompact(metricsPath(base), disk);
     // Keep the in-memory ledger in sync if it is loaded for this session.
     if (ledger) {
         ledger.units = keepNewestUnits(ledger.units, keepCount);
@@ -799,7 +799,7 @@ function saveLedger(base, data) {
                 : dataUnits;
             merged.sort(compareUnitsByTime);
             data.units = keepNewestUnits(merged);
-            saveJsonFile(path, data);
+            saveJsonFileCompact(path, data);
         }
         finally {
             releaseLock(lockPath);
@@ -813,6 +813,6 @@ function saveLedger(base, data) {
         // read-merge-write sequence without mutual exclusion.
         logWarning("fs", "saveLedger: lock not acquired — falling back to direct write (no merge)");
         data.units = keepNewestUnits(data.units);
-        saveJsonFile(path, data);
+        saveJsonFileCompact(path, data);
     }
 }

package/dist/resources/extensions/gsd/migrate-external.js

@@ -110,6 +110,7 @@ export function migrateToExternalState(basePath) {
         }
         // Copy contents to external dir, skipping worktrees/
         const entries = readdirSync(migratingPath, { withFileTypes: true });
+        const copyFailures = [];
         for (const entry of entries) {
             if (entry.name === "worktrees")
                 continue; // worktrees stay local
@@ -123,9 +124,17 @@ export function migrateToExternalState(basePath) {
                     cpSync(src, dst, { force: true });
                 }
             }
-            catch {
-                // Non-fatal: continue with other files
+            catch (copyErr) {
+                copyFailures.push(`${entry.name}: ${getErrorMessage(copyErr)}`);
+            }
+        }
+        if (copyFailures.length > 0) {
+            try {
+                rmSync(localGsd, { force: true });
             }
+            catch { /* may not exist */ }
+            renameSync(migratingPath, localGsd);
+            return { migrated: false, error: `Migration copy failed: ${copyFailures.join("; ")}` };
         }
         // Create symlink .gsd -> external path
         symlinkSync(externalPath, localGsd, "junction");
@@ -230,7 +239,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");
@@ -238,10 +247,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/migration-auto-check.js

@@ -45,6 +45,27 @@ function scanHasExtraIdentities(a, b) {
         hasExtra(a.slices, b.slices) ||
         hasExtra(a.tasks, b.tasks));
 }
+function paddedMilestoneId(id) {
+    return /^\d+$/.test(id) ? `M${id.padStart(3, "0")}` : null;
+}
+function replaceSetPrefix(values, from, to) {
+    for (const value of [...values]) {
+        if (value !== from && !value.startsWith(`${from}/`))
+            continue;
+        values.delete(value);
+        values.add(`${to}${value.slice(from.length)}`);
+    }
+}
+function alignNumericMarkdownIdsWithDb(markdownScan, dbScan) {
+    for (const dbId of dbScan.milestones) {
+        const paddedId = paddedMilestoneId(dbId);
+        if (!paddedId || dbScan.milestones.has(paddedId) || !markdownScan.milestones.has(paddedId))
+            continue;
+        replaceSetPrefix(markdownScan.milestones, paddedId, dbId);
+        replaceSetPrefix(markdownScan.slices, paddedId, dbId);
+        replaceSetPrefix(markdownScan.tasks, paddedId, dbId);
+    }
+}
 /**
  * True when the DB holds any milestone/slice/task identity the markdown lacks —
  * i.e. a `/gsd recover --confirm` (markdown → DB) would DELETE authoritative DB
@@ -126,6 +147,7 @@ export async function checkMarkdownHierarchyAgainstDb(basePath) {
     refreshWorkflowDatabaseFromDisk();
     const dbScan = scanDbHierarchy();
     const beforeDb = dbScan.counts;
+    alignNumericMarkdownIdsWithDb(markdownScan, dbScan);
     // Discussion-phase scratch: a milestone dir with no ROADMAP and no DB row is
     // a pre-registration discussion artifact (CONTEXT/CONTEXT-DRAFT only — the
     // queued DB row is inserted only at discussion handoff). Treating it as

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

@@ -123,7 +123,8 @@ export function clearReservedMilestoneIds() {
     reservedMilestoneIds.clear();
 }
 // ─── Discovery ──────────────────────────────────────────────────────────────
-function scanMilestoneIdsFromDir(dir) {
+function scanMilestoneIdsFromDir(basePath, dir) {
+    const legacyNumericIds = idsWithLegacyNumericDirs(basePath);
     return readdirSync(dir, { withFileTypes: true })
         .filter((d) => d.isDirectory())
         .map((d) => {
@@ -131,6 +132,12 @@ function scanMilestoneIdsFromDir(dir) {
         if (MILESTONE_ID_RE.test(d.name)) {
             return d.name;
         }
+        // Legacy recovery/imports may contain bare numeric milestone directories
+        // (for example `milestones/15/15-ROADMAP.md`). The DB can preserve that
+        // id, and rebuild renders it, so drift scans must see it too.
+        if (/^\d+$/.test(d.name)) {
+            return d.name;
+        }
         // Legacy layout: M001-abcdef-slug descriptor directories
         const legacyMatch = d.name.match(/^(M\d{3}(?:-[a-z0-9]{6})?)-/);
         if (legacyMatch) {
@@ -144,12 +151,35 @@ function scanMilestoneIdsFromDir(dir) {
             if (MILESTONE_ID_RE.test(fromSlug)) {
                 return fromSlug;
             }
+            const numericId = String(phaseNum);
+            if (legacyNumericIds.has(numericId)) {
+                return numericId;
+            }
             return `M${String(phaseNum).padStart(3, "0")}`;
         }
         return null;
     })
         .filter((id) => id !== null);
 }
+function idsWithLegacyNumericDirs(basePath) {
+    const legacyDir = join(gsdProjectionRoot(basePath), "milestones");
+    const ids = new Set();
+    try {
+        for (const entry of readdirSync(legacyDir, { withFileTypes: true })) {
+            if (entry.isDirectory() && /^\d+$/.test(entry.name))
+                ids.add(entry.name);
+        }
+    }
+    catch (err) {
+        // A missing legacy directory is the common, benign case (nothing to
+        // consult). Only surface a real failure when the directory exists but
+        // could not be read.
+        if (existsSync(legacyDir)) {
+            logWarning("engine", `idsWithLegacyNumericDirs: ${legacyDir} exists but readdirSync failed — ${getErrorMessage(err)}`);
+        }
+    }
+    return ids;
+}
 /** Scan the milestones directory and return IDs sorted by queue order (or numeric fallback). */
 export function findMilestoneIds(basePath) {
     const root = gsdProjectionRoot(basePath);
@@ -163,7 +193,7 @@ export function findMilestoneIds(basePath) {
     const ids = new Set();
     for (const dir of dirs) {
         try {
-            for (const id of scanMilestoneIdsFromDir(dir))
+            for (const id of scanMilestoneIdsFromDir(basePath, dir))
                 ids.add(id);
         }
         catch (err) {

package/dist/resources/extensions/gsd/orphan-stash-audit.js

@@ -26,16 +26,78 @@ function _isAlreadyRestoredApplyError(err) {
     return /already exists, no checkout/i.test(message);
 }
 export { _isAlreadyRestoredApplyError };
+function gitOutput(basePath, args) {
+    return execFileSync("git", args, {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: GIT_NO_PROMPT_ENV,
+    });
+}
+function listStashUntrackedPaths(basePath, stashRef) {
+    try {
+        return gitOutput(basePath, ["ls-tree", "-r", "-z", "--name-only", `${stashRef}^3`]).split("\0").filter(Boolean);
+    }
+    catch {
+        return null;
+    }
+}
+function listStashTrackedPaths(basePath, stashRef) {
+    try {
+        return gitOutput(basePath, ["diff", "--name-only", "-z", `${stashRef}^1`, stashRef]).split("\0").filter(Boolean);
+    }
+    catch {
+        return null;
+    }
+}
+function readWorkingTreeStatus(basePath) {
+    try {
+        return gitOutput(basePath, ["status", "--porcelain", "-z", "--untracked-files=all"])
+            .split("\0")
+            .filter(Boolean)
+            .map((entry) => ({ code: entry.slice(0, 2), path: entry.slice(3) }));
+    }
+    catch {
+        return null;
+    }
+}
+function isAlreadyRestoredUntrackedStatus(basePath, stashRef, statusEntries) {
+    if (statusEntries.length === 0 || statusEntries.some((entry) => entry.code !== "??"))
+        return false;
+    const stashTrackedPaths = listStashTrackedPaths(basePath, stashRef);
+    if (!stashTrackedPaths || stashTrackedPaths.length > 0)
+        return false;
+    const stashUntrackedPaths = listStashUntrackedPaths(basePath, stashRef);
+    if (!stashUntrackedPaths || stashUntrackedPaths.length === 0)
+        return false;
+    const stashUntrackedPathSet = new Set(stashUntrackedPaths);
+    const workingTreeUntrackedPathSet = new Set(statusEntries.map((entry) => entry.path));
+    // "Already restored" requires the working tree's untracked paths to match the
+    // stash's untracked paths exactly, in BOTH directions:
+    //   1. every current untracked path comes from the stash (no unexplained user
+    //      work that an apply would clobber), AND
+    //   2. every stash untracked path is already present in the working tree.
+    // Without (2), a partial restore (where only some stash files were recovered)
+    // would be misread as fully restored: the audit would no-op without applying
+    // or warning, leaving the remaining pre-merge files missing.
+    return (statusEntries.every((entry) => stashUntrackedPathSet.has(entry.path)) &&
+        stashUntrackedPaths.every((path) => workingTreeUntrackedPathSet.has(path)));
+}
+function manualApplyWarning(stashRef, milestoneId, reason) {
+    return (`Pre-merge stash ${stashRef} for milestone ${milestoneId} not auto-applied: ${reason}; ` +
+        `run \`git stash apply ${stashRef}\` manually to restore your pre-merge changes.`);
+}
 /**
  * Audit `git stash list` for orphaned `gsd-preflight-stash:M00x:*` entries.
  *
  * The matching merge code in `phases.ts` previously skipped the postflight
  * pop whenever `mergeAndExit` threw, leaking the user's pre-merge working
- * tree into the stash list. For every preflight-stash entry whose milestone
- * is now complete (per the supplied callback), `git stash apply` is invoked —
+ * tree into the stash list. Completed-milestone stashes are only auto-applied
+ * when the working tree is clean and the stash does not modify tracked files.
+ * Dirty trees and tracked-file stashes are left untouched with a manual
+ * recovery warning. When auto-apply is safe, `git stash apply` is invoked —
  * NOT `pop`. The stash entry stays in the list so the user retains a backup
- * if the apply produces unexpected merge results. Idempotent across repeated
- * startup runs.
+ * if the apply produces unexpected merge results.
  *
  * Failures are best-effort: a list error (no repo, git unavailable) returns
  * an empty result. An apply error becomes a warning the user sees alongside
@@ -45,12 +107,7 @@ export function auditOrphanedPreflightStashes(basePath, isMilestoneComplete) {
     const result = { applied: [], warnings: [] };
     let listOutput;
     try {
-        listOutput = execFileSync("git", ["stash", "list", "--format=%gd%x00%s"], {
-            cwd: basePath,
-            stdio: ["ignore", "pipe", "pipe"],
-            encoding: "utf-8",
-            env: GIT_NO_PROMPT_ENV,
-        });
+        listOutput = gitOutput(basePath, ["stash", "list", "--format=%gd%x00%s"]);
     }
     catch {
         return result;
@@ -78,13 +135,32 @@ export function auditOrphanedPreflightStashes(basePath, isMilestoneComplete) {
         }
         if (!complete)
             continue;
+        const statusEntries = readWorkingTreeStatus(basePath);
+        if (!statusEntries) {
+            result.warnings.push(manualApplyWarning(ref, milestoneId, "could not verify working tree status"));
+            continue;
+        }
+        if (statusEntries.length > 0) {
+            if (isAlreadyRestoredUntrackedStatus(basePath, ref, statusEntries))
+                continue;
+            result.warnings.push(manualApplyWarning(ref, milestoneId, "working tree not clean"));
+            continue;
+        }
+        const trackedPaths = listStashTrackedPaths(basePath, ref);
+        if (trackedPaths === null) {
+            result.warnings.push(manualApplyWarning(ref, milestoneId, "could not inspect tracked paths in stash"));
+            continue;
+        }
+        if (trackedPaths.length > 0) {
+            // A retained tracked-file stash has no durable marker showing whether a
+            // clean tree needs first recovery or would be re-mutated by an old backup.
+            const preview = trackedPaths.slice(0, 5).join(", ");
+            const suffix = trackedPaths.length > 5 ? `, and ${trackedPaths.length - 5} more` : "";
+            result.warnings.push(manualApplyWarning(ref, milestoneId, `stash modifies tracked files (${preview}${suffix})`));
+            continue;
+        }
         try {
-            execFileSync("git", ["stash", "apply", "--quiet", ref], {
-                cwd: basePath,
-                stdio: ["ignore", "pipe", "pipe"],
-                encoding: "utf-8",
-                env: GIT_NO_PROMPT_ENV,
-            });
+            gitOutput(basePath, ["stash", "apply", "--quiet", ref]);
             result.applied.push({ milestoneId, stashRef: ref });
         }
         catch (err) {

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-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");
@@ -1524,6 +1537,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 +1618,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 };
 }