gsd-pi 2.74.0 → 2.75.0-dev.2203010a0

package/dist/resources/extensions/gsd/post-execution-checks.js

@@ -75,12 +75,36 @@ export function extractRelativeImports(source) {
 }
 /**
  * Check if a relative import resolves to an existing file.
- * Handles .ts, .tsx, .js, .jsx extensions and index files.
- * Also handles TypeScript ESM convention where imports use .js but resolve to .ts.
+ * Resolution order:
+ *   1. Imports carrying an explicit extension are checked as-is (handles assets
+ *      like .css/.scss/images/fonts and .json, not just code extensions).
+ *   2. TypeScript ESM convention where .js imports resolve to .ts files.
+ *   3. Extensionless imports resolved against .ts/.tsx/.js/.jsx/.mjs/.cjs.
+ *   4. Directory imports resolved against index.{ts,tsx,js,jsx,mjs,cjs}.
  */
 export function resolveImportPath(importPath, sourceFile, basePath) {
     const sourceDir = dirname(resolve(basePath, sourceFile));
     const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+    // If the import already has an explicit extension, check it as-is first.
+    // This correctly resolves asset imports like .css, .scss, images, fonts
+    // without requiring each extension to be enumerated (issue #4411). We only
+    // do this when the import carries an extension so that extensionless module
+    // imports still flow through the TS ESM convention and index-file resolvers.
+    const explicitExt = extname(importPath);
+    if (explicitExt !== "") {
+        const directPath = resolve(sourceDir, importPath);
+        if (existsSync(directPath)) {
+            return { exists: true, resolvedPath: directPath };
+        }
+        // Only .js/.jsx/.mjs/.cjs imports legitimately fall through for the TS
+        // ESM convention (.js → .ts). Any other explicit extension (.css, .json,
+        // .svg, images, fonts, .ts, .tsx, …) must stay unresolved when the direct
+        // path is missing — otherwise a stray `./missing.css.ts` could shadow a
+        // genuinely missing `./missing.css` import.
+        if (![".js", ".jsx", ".mjs", ".cjs"].includes(explicitExt)) {
+            return { exists: false, resolvedPath: null };
+        }
+    }
     // Handle TypeScript ESM convention: .js imports resolve to .ts files
     // e.g., import './types.js' -> ./types.ts
     let normalizedPath = importPath;
@@ -96,7 +120,7 @@ export function resolveImportPath(importPath, sourceFile, basePath) {
     else if (importPath.endsWith(".cjs")) {
         normalizedPath = importPath.slice(0, -4);
     }
-    // Try the normalized path with common extensions first
+    // Try the normalized path with common extensions
     for (const ext of extensions) {
         const fullPath = resolve(sourceDir, normalizedPath + ext);
         if (existsSync(fullPath)) {
@@ -110,14 +134,6 @@ export function resolveImportPath(importPath, sourceFile, basePath) {
             return { exists: true, resolvedPath: indexPath };
         }
     }
-    // Check if path already has extension (for .json, etc.)
-    const hasExt = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"].some((ext) => importPath.endsWith(ext));
-    if (hasExt) {
-        const fullPath = resolve(sourceDir, importPath);
-        if (existsSync(fullPath)) {
-            return { exists: true, resolvedPath: fullPath };
-        }
-    }
     return { exists: false, resolvedPath: null };
 }
 /**

package/dist/resources/extensions/gsd/pre-execution-checks.js

@@ -15,6 +15,7 @@
  */
 import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
+import { homedir } from "node:os";
 import { resolve } from "node:path";
 const NPM_COMMAND = process.platform === "win32" ? "npm.cmd" : "npm";
 // ─── Package Existence Check ─────────────────────────────────────────────────
@@ -202,6 +203,16 @@ export function normalizeFilePath(filePath) {
     let normalized = extractPathFromAnnotation(filePath);
     // Normalize path separators to forward slashes
     normalized = normalized.replace(/\\/g, "/");
+    // Expand a leading ~ or ~/ so downstream resolve()/set lookups hit the real
+    // home directory instead of treating the tilde as a literal path segment.
+    if (normalized === "~") {
+        normalized = homedir();
+    }
+    else if (normalized.startsWith("~/")) {
+        normalized = resolve(homedir(), normalized.slice(2));
+    }
+    // homedir()/resolve() can emit platform separators (e.g. "\" on Windows).
+    normalized = normalized.replace(/\\/g, "/");
     // Remove leading ./
     while (normalized.startsWith("./")) {
         normalized = normalized.slice(2);
@@ -214,6 +225,49 @@ export function normalizeFilePath(filePath) {
     }
     return normalized;
 }
+/**
+ * Planning units sometimes pass a directory reference as task.inputs
+ * (e.g. `artifacts/M009-S03/`). The trailing slash is meaningful — the task
+ * reads whatever lands inside — but normalizeFilePath strips it, so call this
+ * helper against the raw input before normalization.
+ */
+function isDirectoryReference(raw) {
+    const candidate = extractPathFromAnnotation(raw.trim());
+    if (!candidate)
+        return false;
+    if (containsGlobPattern(candidate))
+        return false;
+    return candidate.endsWith("/");
+}
+/**
+ * True when any of `knownOutputs` lives under `normalizedDir` (i.e. the task
+ * directory input is the parent of something a prior/same task produces).
+ */
+function anyOutputUnderDirectory(normalizedDir, knownOutputs) {
+    const prefix = normalizedDir + "/";
+    for (const output of knownOutputs) {
+        if (output === normalizedDir)
+            return true;
+        if (output.startsWith(prefix))
+            return true;
+    }
+    return false;
+}
+const URL_SCHEME_PATTERN = /^(https?|ftp|file|ssh|git):\/\//i;
+const SCP_PATTERN = /^[\w.-]+@[\w.-]+:[^/]/;
+function looksLikePathOrUrl(token) {
+    if (URL_SCHEME_PATTERN.test(token))
+        return true;
+    if (SCP_PATTERN.test(token))
+        return true;
+    if (/^[./~]/.test(token))
+        return true;
+    if (/[\\/]/.test(token))
+        return true;
+    if (/\.[A-Za-z0-9]{1,8}$/.test(token))
+        return true;
+    return false;
+}
 function extractPathFromAnnotation(raw) {
     const trimmed = raw.trim();
     if (!trimmed)
@@ -226,6 +280,19 @@ function extractPathFromAnnotation(raw) {
     if (annotatedMatch) {
         return annotatedMatch[1].trim();
     }
+    // Fallback: scan all backticked tokens and return the first one that looks
+    // like a path or URL. Handles prose-annotated bullets such as:
+    //   `path/` directory listing (...)
+    //   Prefix prose `https://...` suffix prose
+    //   Citing `.gsd/REQUIREMENTS.md` mid-sentence
+    // Skips non-path backticked tokens like `note` or `npm test`.
+    const backtickTokens = trimmed.matchAll(/`([^`]+)`/g);
+    for (const match of backtickTokens) {
+        const token = match[1].trim();
+        if (looksLikePathOrUrl(token)) {
+            return token;
+        }
+    }
     // Fall back to the original behavior for already-plain paths.
     return trimmed.replace(/`/g, "");
 }
@@ -240,12 +307,17 @@ function shouldValidateInputAsPath(raw) {
     const trimmed = raw.trim();
     if (!trimmed)
         return false;
-    if (/^`+[^`]+`+/.test(trimmed)) {
-        return true;
-    }
     const candidate = extractPathFromAnnotation(trimmed);
     if (!candidate)
         return false;
+    // URLs and remote repo refs are not filesystem paths.
+    if (URL_SCHEME_PATTERN.test(candidate))
+        return false;
+    if (SCP_PATTERN.test(candidate))
+        return false;
+    if (/^`+[^`]+`+/.test(trimmed)) {
+        return true;
+    }
     if (!/\s/.test(candidate)) {
         return true;
     }
@@ -256,6 +328,9 @@ function shouldValidateInputAsPath(raw) {
         /[\\/]/.test(candidate) ||
         /[*?[\]{}]/.test(candidate));
 }
+function containsGlobPattern(candidate) {
+    return ["*", "?", "[", "]", "{", "}"].some((char) => candidate.includes(char));
+}
 /**
  * Build a set of files that will be created by tasks up to (but not including) taskIndex.
  * All paths are normalized for consistent comparison.
@@ -293,12 +368,23 @@ export function checkFilePathConsistency(tasks, basePath) {
                 continue;
             // Normalize path for consistent comparison
             const normalizedFile = normalizeFilePath(file);
+            if (containsGlobPattern(normalizedFile))
+                continue;
             // Check if file exists on disk
             const absolutePath = resolve(basePath, normalizedFile);
             const existsOnDisk = existsSync(absolutePath);
             // Check if file is in prior expected outputs (priorOutputs already normalized)
             const inPriorOutputs = priorOutputs.has(normalizedFile);
-            if (!existsOnDisk && !inPriorOutputs) {
+            // Directory inputs are satisfied when something produces a file beneath
+            // them — either a prior task or the current task itself.
+            let directorySatisfied = false;
+            if (!existsOnDisk && !inPriorOutputs && isDirectoryReference(file)) {
+                const sameTaskOutputs = task.expected_output.map(normalizeFilePath);
+                directorySatisfied =
+                    anyOutputUnderDirectory(normalizedFile, priorOutputs) ||
+                        anyOutputUnderDirectory(normalizedFile, sameTaskOutputs);
+            }
+            if (!existsOnDisk && !inPriorOutputs && !directorySatisfied) {
                 results.push({
                     category: "file",
                     target: file,
@@ -341,6 +427,13 @@ export function checkTaskOrdering(tasks, basePath) {
             if (!shouldValidateInputAsPath(file))
                 continue;
             const normalizedFile = normalizeFilePath(file);
+            if (containsGlobPattern(normalizedFile))
+                continue;
+            // A directory reference like `artifacts/M009-S03/` is never a concrete
+            // read-before-create dependency: the fileCreators map is keyed by leaf
+            // files, and a same-task output under the directory satisfies it.
+            if (isDirectoryReference(file))
+                continue;
             const creator = fileCreators.get(normalizedFile);
             const absolutePath = resolve(basePath, normalizedFile);
             const existsOnDisk = existsSync(absolutePath);

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

@@ -39,6 +39,7 @@ export function resolveModelWithFallbacksForUnit(unitType) {
             break;
         case "plan-milestone":
         case "plan-slice":
+        case "refine-slice":
         case "replan-slice":
             phaseConfig = m.planning;
             break;
@@ -321,7 +322,7 @@ export function resolveAutoSupervisorConfig() {
     };
 }
 // ─── Token Profile Resolution ─────────────────────────────────────────────
-const VALID_TOKEN_PROFILES = new Set(["budget", "balanced", "quality"]);
+const VALID_TOKEN_PROFILES = new Set(["budget", "balanced", "quality", "burn-max"]);
 /**
  * Resolve profile defaults for a given token profile tier.
  * Returns a partial GSDPreferences that is used as the base layer --
@@ -365,6 +366,22 @@ export function resolveProfileDefaults(profile) {
                     skip_reassess: true,
                 },
             };
+        case "burn-max":
+            return {
+                // Quality-first profile: keep user-selected models, disable downgrade routing.
+                // Policy constraints still apply at dispatch time.
+                dynamic_routing: {
+                    enabled: false,
+                },
+                context_selection: "full",
+                phases: {
+                    skip_research: false,
+                    skip_slice_research: false,
+                    skip_reassess: false,
+                    skip_milestone_validation: false,
+                    reassess_after_slice: true,
+                },
+            };
     }
 }
 /**
@@ -380,7 +397,7 @@ export function resolveEffectiveProfile() {
 }
 /**
  * Resolve the inline level from the active token profile.
- * budget -> minimal, balanced -> standard, quality -> full.
+ * budget -> minimal, balanced -> standard, quality/burn-max -> full.
  */
 export function resolveInlineLevel() {
     const profile = resolveEffectiveProfile();
@@ -388,11 +405,12 @@ export function resolveInlineLevel() {
         case "budget": return "minimal";
         case "balanced": return "standard";
         case "quality": return "full";
+        case "burn-max": return "full";
     }
 }
 /**
  * Resolve the context selection mode from the active token profile.
- * budget -> "smart", balanced/quality -> "full".
+ * budget -> "smart", balanced/quality/burn-max -> "full".
  * Explicit preference always wins.
  */
 export function resolveContextSelection() {

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

@@ -53,6 +53,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "post_unit_hooks",
     "pre_dispatch_hooks",
     "dynamic_routing",
+    "uok",
     "token_profile",
     "phases",
     "auto_visualize",
@@ -84,10 +85,12 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "discuss_web_research",
     "discuss_depth",
     "flat_rate_providers",
+    "language",
+    "context_window_override",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [
-    "research-milestone", "plan-milestone", "research-slice", "plan-slice",
+    "research-milestone", "plan-milestone", "research-slice", "plan-slice", "refine-slice",
     "execute-task", "reactive-execute", "gate-evaluate", "complete-slice", "replan-slice", "reassess-roadmap",
     "run-uat", "complete-milestone", "validate-milestone", "rewrite-docs",
     "discuss-milestone", "discuss-slice", "worktree-merge",

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

@@ -8,7 +8,12 @@
 import { VALID_BRANCH_NAME } from "./git-service.js";
 import { normalizeStringArray } from "../shared/format-utils.js";
 import { KNOWN_PREFERENCE_KEYS, KNOWN_UNIT_TYPES, SKILL_ACTIONS, } from "./preferences-types.js";
-const VALID_TOKEN_PROFILES = new Set(["budget", "balanced", "quality"]);
+const VALID_TOKEN_PROFILES = new Set(["budget", "balanced", "quality", "burn-max"]);
+const VALID_UOK_TURN_ACTIONS = new Set([
+    "commit",
+    "snapshot",
+    "status-only",
+]);
 export function validatePreferences(preferences) {
     const errors = [];
     const warnings = [];
@@ -136,13 +141,114 @@ export function validatePreferences(preferences) {
             errors.push(`budget_enforcement must be one of: warn, pause, halt`);
         }
     }
+    // ─── UOK Flags ──────────────────────────────────────────────────────
+    if (preferences.uok !== undefined) {
+        if (typeof preferences.uok === "object" && preferences.uok !== null) {
+            const raw = preferences.uok;
+            const valid = {};
+            if (raw.enabled !== undefined) {
+                if (typeof raw.enabled === "boolean")
+                    valid.enabled = raw.enabled;
+                else
+                    errors.push("uok.enabled must be a boolean");
+            }
+            const parseEnabledBlock = (key) => {
+                const value = raw[key];
+                if (value === undefined)
+                    return;
+                if (typeof value !== "object" || value === null) {
+                    errors.push(`uok.${key} must be an object`);
+                    return;
+                }
+                const block = value;
+                const parsed = {};
+                if (block.enabled !== undefined) {
+                    if (typeof block.enabled === "boolean")
+                        parsed.enabled = block.enabled;
+                    else
+                        errors.push(`uok.${key}.enabled must be a boolean`);
+                }
+                const unknown = Object.keys(block).filter((k) => k !== "enabled");
+                for (const unk of unknown) {
+                    warnings.push(`unknown uok.${key} key "${unk}" — ignored`);
+                }
+                if (Object.keys(parsed).length > 0) {
+                    valid[key] = parsed;
+                }
+            };
+            parseEnabledBlock("legacy_fallback");
+            parseEnabledBlock("gates");
+            parseEnabledBlock("model_policy");
+            parseEnabledBlock("execution_graph");
+            parseEnabledBlock("audit_unified");
+            parseEnabledBlock("plan_v2");
+            if (raw.gitops !== undefined) {
+                if (typeof raw.gitops !== "object" || raw.gitops === null) {
+                    errors.push("uok.gitops must be an object");
+                }
+                else {
+                    const gitops = raw.gitops;
+                    const parsed = {};
+                    if (gitops.enabled !== undefined) {
+                        if (typeof gitops.enabled === "boolean")
+                            parsed.enabled = gitops.enabled;
+                        else
+                            errors.push("uok.gitops.enabled must be a boolean");
+                    }
+                    if (gitops.turn_action !== undefined) {
+                        if (typeof gitops.turn_action === "string" &&
+                            VALID_UOK_TURN_ACTIONS.has(gitops.turn_action)) {
+                            parsed.turn_action = gitops.turn_action;
+                        }
+                        else {
+                            errors.push("uok.gitops.turn_action must be one of: commit, snapshot, status-only");
+                        }
+                    }
+                    if (gitops.turn_push !== undefined) {
+                        if (typeof gitops.turn_push === "boolean")
+                            parsed.turn_push = gitops.turn_push;
+                        else
+                            errors.push("uok.gitops.turn_push must be a boolean");
+                    }
+                    const unknown = Object.keys(gitops).filter((k) => !["enabled", "turn_action", "turn_push"].includes(k));
+                    for (const unk of unknown) {
+                        warnings.push(`unknown uok.gitops key "${unk}" — ignored`);
+                    }
+                    if (Object.keys(parsed).length > 0) {
+                        valid.gitops = parsed;
+                    }
+                }
+            }
+            const knownUokKeys = new Set([
+                "enabled",
+                "legacy_fallback",
+                "gates",
+                "model_policy",
+                "execution_graph",
+                "gitops",
+                "audit_unified",
+                "plan_v2",
+            ]);
+            for (const key of Object.keys(raw)) {
+                if (!knownUokKeys.has(key)) {
+                    warnings.push(`unknown uok key "${key}" — ignored`);
+                }
+            }
+            if (Object.keys(valid).length > 0) {
+                validated.uok = valid;
+            }
+        }
+        else {
+            errors.push("uok must be an object");
+        }
+    }
     // ─── Token Profile ─────────────────────────────────────────────────
     if (preferences.token_profile !== undefined) {
         if (typeof preferences.token_profile === "string" && VALID_TOKEN_PROFILES.has(preferences.token_profile)) {
             validated.token_profile = preferences.token_profile;
         }
         else {
-            errors.push(`token_profile must be one of: budget, balanced, quality`);
+            errors.push(`token_profile must be one of: budget, balanced, quality, burn-max`);
         }
     }
     // ─── Search Provider ─────────────────────────────────────────────
@@ -182,20 +288,48 @@ export function validatePreferences(preferences) {
         if (typeof preferences.phases === "object" && preferences.phases !== null) {
             const validatedPhases = {};
             const p = preferences.phases;
+            // Strict boolean parsing — YAML usually delivers real booleans, but
+            // hand-edits like `progressive_planning: "false"` otherwise coerce to
+            // truthy via `!!`. Accept only real booleans or the literal strings
+            // "true"/"false"; anything else becomes a warning + ignored.
+            const parseStrictBoolean = (key, raw) => {
+                if (typeof raw === "boolean")
+                    return raw;
+                if (typeof raw === "string") {
+                    if (raw === "true")
+                        return true;
+                    if (raw === "false")
+                        return false;
+                }
+                warnings.push(`phases.${key} must be a boolean (got ${typeof raw}: ${JSON.stringify(raw)}) — ignored`);
+                return undefined;
+            };
+            const assignBool = (key, raw) => {
+                const v = parseStrictBoolean(String(key), raw);
+                if (v !== undefined)
+                    validatedPhases[key] = v;
+            };
             if (p.skip_research !== undefined)
-                validatedPhases.skip_research = !!p.skip_research;
+                assignBool("skip_research", p.skip_research);
             if (p.skip_reassess !== undefined)
-                validatedPhases.skip_reassess = !!p.skip_reassess;
+                assignBool("skip_reassess", p.skip_reassess);
             if (p.skip_slice_research !== undefined)
-                validatedPhases.skip_slice_research = !!p.skip_slice_research;
+                assignBool("skip_slice_research", p.skip_slice_research);
             if (p.skip_milestone_validation !== undefined)
-                validatedPhases.skip_milestone_validation = !!p.skip_milestone_validation;
+                assignBool("skip_milestone_validation", p.skip_milestone_validation);
             if (p.reassess_after_slice !== undefined)
-                validatedPhases.reassess_after_slice = !!p.reassess_after_slice;
-            if (p.require_slice_discussion !== undefined)
-                validatedPhases.require_slice_discussion = !!p.require_slice_discussion;
+                assignBool("reassess_after_slice", p.reassess_after_slice);
+            if (p.require_slice_discussion !== undefined) {
+                const v = parseStrictBoolean("require_slice_discussion", p.require_slice_discussion);
+                if (v !== undefined)
+                    validatedPhases.require_slice_discussion = v;
+            }
+            if (p.mid_execution_escalation !== undefined)
+                assignBool("mid_execution_escalation", p.mid_execution_escalation);
+            if (p.progressive_planning !== undefined)
+                assignBool("progressive_planning", p.progressive_planning);
             // Warn on unknown phase keys
-            const knownPhaseKeys = new Set(["skip_research", "skip_reassess", "skip_slice_research", "skip_milestone_validation", "reassess_after_slice", "require_slice_discussion"]);
+            const knownPhaseKeys = new Set(["skip_research", "skip_reassess", "skip_slice_research", "skip_milestone_validation", "reassess_after_slice", "require_slice_discussion", "mid_execution_escalation", "progressive_planning"]);
             for (const key of Object.keys(p)) {
                 if (!knownPhaseKeys.has(key)) {
                     warnings.push(`unknown phases key "${key}" — ignored`);
@@ -453,6 +587,12 @@ export function validatePreferences(preferences) {
                 else
                     errors.push("dynamic_routing.capability_routing must be a boolean");
             }
+            if (dr.allow_flat_rate_providers !== undefined) {
+                if (typeof dr.allow_flat_rate_providers === "boolean")
+                    validDr.allow_flat_rate_providers = dr.allow_flat_rate_providers;
+                else
+                    errors.push("dynamic_routing.allow_flat_rate_providers must be a boolean");
+            }
             if (dr.tier_models !== undefined) {
                 if (typeof dr.tier_models === "object" && dr.tier_models !== null) {
                     const tm = dr.tier_models;
@@ -1038,5 +1178,15 @@ export function validatePreferences(preferences) {
             errors.push(`discuss_depth must be one of: quick, standard, thorough`);
         }
     }
+    // ─── Language ────────────────────────────────────────────────────────
+    if (preferences.language !== undefined) {
+        const trimmed = typeof preferences.language === "string" ? preferences.language.trim() : undefined;
+        if (trimmed && trimmed.length <= 50 && !/[\r\n]/.test(trimmed)) {
+            validated.language = trimmed;
+        }
+        else {
+            errors.push(`language must be a non-empty string up to 50 characters with no newlines (e.g. "Chinese", "de", "日本語")`);
+        }
+    }
     return { preferences: validated, errors, warnings };
 }

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

@@ -41,21 +41,21 @@ function gsdHome() {
     return process.env.GSD_HOME || join(homedir(), ".gsd");
 }
 function globalPreferencesPath() {
-    return join(gsdHome(), "preferences.md");
+    return join(gsdHome(), "PREFERENCES.md");
 }
 function legacyGlobalPreferencesPath() {
     return join(homedir(), ".pi", "agent", "gsd-preferences.md");
 }
 function projectPreferencesPath() {
-    return join(gsdRoot(process.cwd()), "preferences.md");
+    return join(gsdRoot(process.cwd()), "PREFERENCES.md");
 }
-// Bootstrap in gitignore.ts historically created PREFERENCES.md (uppercase) by mistake.
-// Check uppercase as a fallback so those files aren't silently ignored.
-function globalPreferencesPathUppercase() {
-    return join(gsdHome(), "PREFERENCES.md");
+// Legacy lowercase files can still exist in older projects. Keep them as a
+// compatibility-only fallback, but route new reads/writes through PREFERENCES.md.
+function legacyGlobalPreferencesPathLowercase() {
+    return join(gsdHome(), "preferences.md");
 }
-function projectPreferencesPathUppercase() {
-    return join(gsdRoot(process.cwd()), "PREFERENCES.md");
+function legacyProjectPreferencesPathLowercase() {
+    return join(gsdRoot(process.cwd()), "preferences.md");
 }
 export function getGlobalGSDPreferencesPath() {
     return globalPreferencesPath();
@@ -69,12 +69,12 @@ export function getProjectGSDPreferencesPath() {
 // ─── Loading ────────────────────────────────────────────────────────────────
 export function loadGlobalGSDPreferences() {
     return loadPreferencesFile(globalPreferencesPath(), "global")
-        ?? loadPreferencesFile(globalPreferencesPathUppercase(), "global")
+        ?? loadPreferencesFile(legacyGlobalPreferencesPathLowercase(), "global")
         ?? loadPreferencesFile(legacyGlobalPreferencesPath(), "global");
 }
 export function loadProjectGSDPreferences() {
     return loadPreferencesFile(projectPreferencesPath(), "project")
-        ?? loadPreferencesFile(projectPreferencesPathUppercase(), "project");
+        ?? loadPreferencesFile(legacyProjectPreferencesPathLowercase(), "project");
 }
 export function loadEffectiveGSDPreferences() {
     const globalPreferences = loadGlobalGSDPreferences();
@@ -293,6 +293,32 @@ function mergePreferences(base, override) {
         dynamic_routing: (base.dynamic_routing || override.dynamic_routing)
             ? { ...(base.dynamic_routing ?? {}), ...(override.dynamic_routing ?? {}) }
             : undefined,
+        uok: (base.uok || override.uok)
+            ? {
+                enabled: override.uok?.enabled ?? base.uok?.enabled,
+                legacy_fallback: (base.uok?.legacy_fallback || override.uok?.legacy_fallback)
+                    ? { ...(base.uok?.legacy_fallback ?? {}), ...(override.uok?.legacy_fallback ?? {}) }
+                    : undefined,
+                gates: (base.uok?.gates || override.uok?.gates)
+                    ? { ...(base.uok?.gates ?? {}), ...(override.uok?.gates ?? {}) }
+                    : undefined,
+                model_policy: (base.uok?.model_policy || override.uok?.model_policy)
+                    ? { ...(base.uok?.model_policy ?? {}), ...(override.uok?.model_policy ?? {}) }
+                    : undefined,
+                execution_graph: (base.uok?.execution_graph || override.uok?.execution_graph)
+                    ? { ...(base.uok?.execution_graph ?? {}), ...(override.uok?.execution_graph ?? {}) }
+                    : undefined,
+                gitops: (base.uok?.gitops || override.uok?.gitops)
+                    ? { ...(base.uok?.gitops ?? {}), ...(override.uok?.gitops ?? {}) }
+                    : undefined,
+                audit_unified: (base.uok?.audit_unified || override.uok?.audit_unified)
+                    ? { ...(base.uok?.audit_unified ?? {}), ...(override.uok?.audit_unified ?? {}) }
+                    : undefined,
+                plan_v2: (base.uok?.plan_v2 || override.uok?.plan_v2)
+                    ? { ...(base.uok?.plan_v2 ?? {}), ...(override.uok?.plan_v2 ?? {}) }
+                    : undefined,
+            }
+            : undefined,
         token_profile: override.token_profile ?? base.token_profile,
         phases: (base.phases || override.phases)
             ? { ...(base.phases ?? {}), ...(override.phases ?? {}) }
@@ -334,6 +360,7 @@ function mergePreferences(base, override) {
         slice_parallel: (base.slice_parallel || override.slice_parallel)
             ? { ...(base.slice_parallel ?? {}), ...(override.slice_parallel ?? {}) }
             : undefined,
+        language: override.language ?? base.language,
     };
 }
 function mergeStringLists(base, override) {
@@ -428,6 +455,10 @@ export function renderPreferencesForSystemPrompt(preferences, resolutions) {
             lines.push(`  - ${instruction}`);
         }
     }
+    if (preferences.language) {
+        const safeLang = preferences.language.replace(/[\r\n]/g, " ").slice(0, 50);
+        lines.push(`- Language: Always respond in ${safeLang}.`);
+    }
     return lines.join("\n");
 }
 // ─── Hook Resolution ──────────────────────────────────────────────────────────

package/dist/resources/extensions/gsd/prompts/add-tests.md

@@ -0,0 +1,35 @@
+You are generating tests for recently completed GSD work.
+
+## Slice: {{sliceId}} — {{sliceTitle}}
+
+### Summary
+
+{{sliceSummary}}
+
+### Existing Test Patterns
+
+{{existingTestPatterns}}
+
+## Working Directory
+
+`{{workingDirectory}}`
+
+## Instructions
+
+1. Read the slice summary above to understand what was built
+2. Identify the source files that were created or modified for this slice
+3. Read the implementation code to understand behavior, edge cases, and error paths
+4. Write comprehensive tests following the project's existing test patterns and framework
+5. Run the tests to verify they pass
+6. Fix any failures
+
+### Rules
+
+- Follow the project's existing test patterns (framework, assertions, file structure)
+- Test behavior, not implementation details
+- Cover: happy path, edge cases, error conditions, boundary values
+- Do NOT modify implementation files — only create or update test files
+- Name test files consistently with the project's conventions
+- Keep tests focused and readable
+
+{{skillActivation}}