gsd-pi 2.74.0 → 2.75.0-dev.2203010a0

package/src/resources/extensions/gsd/onboarding-state.ts

@@ -0,0 +1,146 @@
+// GSD — Onboarding completion record (~/.gsd/agent/onboarding.json)
+//
+// First-class state for the onboarding wizard so re-entry, resume, and the
+// web boot probe all read the same source of truth. Replaces the implicit
+// "settings.defaultProvider exists" heuristic.
+
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
+import { dirname, join } from "node:path"
+import { logWarning } from "./workflow-logger.js"
+
+/**
+ * Bump `FLOW_VERSION` whenever a new required step is added to ONBOARDING_STEPS.
+ * Records with an older flowVersion are treated as "needs partial re-onboarding"
+ * by isOnboardingComplete().
+ */
+export const FLOW_VERSION = 1
+
+const RECORD_VERSION = 1
+// Inline agentDir computation (mirrors src/app-paths.ts) — keep this module
+// rootDir-clean for the resources tsconfig; importing from src/ pulls files
+// outside src/resources and breaks the build.
+const AGENT_DIR =
+  process.env.GSD_CODING_AGENT_DIR ||
+  join(process.env.GSD_HOME || join(homedir(), ".gsd"), "agent")
+const FILE = join(AGENT_DIR, "onboarding.json")
+
+export interface OnboardingRecord {
+  version: number
+  flowVersion: number
+  completedAt: string | null
+  completedSteps: string[]
+  skippedSteps: string[]
+  lastResumePoint: string | null
+}
+
+const DEFAULT: OnboardingRecord = {
+  version: RECORD_VERSION,
+  flowVersion: FLOW_VERSION,
+  completedAt: null,
+  completedSteps: [],
+  skippedSteps: [],
+  lastResumePoint: null,
+}
+
+export function readOnboardingRecord(): OnboardingRecord {
+  if (!existsSync(FILE)) return { ...DEFAULT }
+  try {
+    const raw = JSON.parse(readFileSync(FILE, "utf-8")) as Partial<OnboardingRecord>
+    return {
+      version: typeof raw.version === "number" ? raw.version : RECORD_VERSION,
+      flowVersion: typeof raw.flowVersion === "number" ? raw.flowVersion : 0,
+      completedAt: typeof raw.completedAt === "string" ? raw.completedAt : null,
+      completedSteps: Array.isArray(raw.completedSteps) ? raw.completedSteps.filter(s => typeof s === "string") : [],
+      skippedSteps: Array.isArray(raw.skippedSteps) ? raw.skippedSteps.filter(s => typeof s === "string") : [],
+      lastResumePoint: typeof raw.lastResumePoint === "string" ? raw.lastResumePoint : null,
+    }
+  } catch {
+    // Corrupt/unreadable — fall back to defaults rather than crashing onboarding flow
+    return { ...DEFAULT }
+  }
+}
+
+function atomicWrite(record: OnboardingRecord): void {
+  mkdirSync(dirname(FILE), { recursive: true })
+  const tmp = `${FILE}.tmp.${process.pid}.${Date.now()}`
+  try {
+    writeFileSync(tmp, JSON.stringify(record, null, 2), "utf-8")
+    renameSync(tmp, FILE)
+  } catch (err) {
+    // Best-effort: drop the tmp file if the rename failed (don't leak stale tmps)
+    try { if (existsSync(tmp)) unlinkSync(tmp) } catch { /* swallow secondary error */ }
+    throw err
+  }
+}
+
+export function writeOnboardingRecord(patch: Partial<OnboardingRecord>): OnboardingRecord {
+  const current = readOnboardingRecord()
+  const next: OnboardingRecord = {
+    ...current,
+    ...patch,
+    version: RECORD_VERSION,
+    // flowVersion is sticky on writes unless explicitly patched
+    flowVersion: typeof patch.flowVersion === "number" ? patch.flowVersion : current.flowVersion,
+  }
+  try {
+    atomicWrite(next)
+  } catch (err) {
+    // Non-fatal for the wizard, but make the failure diagnosable. The next boot
+    // will re-prompt for onboarding because the record didn't persist; the
+    // logWarning entry tells the user why.
+    logWarning("state", `Failed to persist onboarding record: ${err instanceof Error ? err.message : String(err)}`, {
+      file: FILE,
+    })
+  }
+  return next
+}
+
+/**
+ * Onboarding is "complete" when there's a completedAt timestamp AND the
+ * flowVersion matches the current FLOW_VERSION. A flowVersion bump means
+ * a new required step exists and the user should re-enter to configure it.
+ */
+export function isOnboardingComplete(): boolean {
+  const r = readOnboardingRecord()
+  return r.completedAt !== null && r.flowVersion === FLOW_VERSION
+}
+
+export function markStepCompleted(stepId: string): void {
+  const r = readOnboardingRecord()
+  if (r.completedSteps.includes(stepId)) {
+    writeOnboardingRecord({ lastResumePoint: stepId })
+    return
+  }
+  writeOnboardingRecord({
+    completedSteps: [...r.completedSteps, stepId],
+    skippedSteps: r.skippedSteps.filter(s => s !== stepId),
+    lastResumePoint: stepId,
+  })
+}
+
+export function markStepSkipped(stepId: string): void {
+  const r = readOnboardingRecord()
+  if (r.skippedSteps.includes(stepId) || r.completedSteps.includes(stepId)) return
+  writeOnboardingRecord({
+    skippedSteps: [...r.skippedSteps, stepId],
+    lastResumePoint: stepId,
+  })
+}
+
+export function markOnboardingComplete(completedSteps: string[]): void {
+  writeOnboardingRecord({
+    completedAt: new Date().toISOString(),
+    flowVersion: FLOW_VERSION,
+    completedSteps,
+  })
+}
+
+export function resetOnboarding(): void {
+  writeOnboardingRecord({
+    completedAt: null,
+    completedSteps: [],
+    skippedSteps: [],
+    lastResumePoint: null,
+  })
+}

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

@@ -42,6 +42,8 @@ import {
 } from "./parallel-eligibility.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning } from "./workflow-logger.js";
+import { resolveUokFlags } from "./uok/flags.js";
+import { selectConflictFreeBatch } from "./uok/execution-graph.js";
 
 // ─── Types ─────────────────────────────────────────────────────────────────
 
@@ -69,6 +71,10 @@ export interface OrchestratorState {
 
 let state: OrchestratorState | null = null;
 
+function overlapKey(a: string, b: string): string {
+  return a < b ? `${a}::${b}` : `${b}::${a}`;
+}
+
 // ─── Persistence ──────────────────────────────────────────────────────────
 
 const ORCHESTRATOR_STATE_FILE = "orchestrator.json";
@@ -365,6 +371,7 @@ export async function startParallel(
   }
 
   const config = resolveParallelConfig(prefs);
+  const uokFlags = resolveUokFlags(prefs);
 
   // Release any leftover state from a previous session before reassigning
   if (state) {
@@ -418,8 +425,40 @@ export async function startParallel(
   const started: string[] = [];
   const errors: Array<{ mid: string; error: string }> = [];
 
+  let filteredMilestoneIds = milestoneIds;
+  if (uokFlags.executionGraph && milestoneIds.length > 1) {
+    try {
+      const requestedIds = new Set(milestoneIds);
+      const candidates = await analyzeParallelEligibility(basePath);
+      const overlapPairs = new Set<string>();
+      for (const overlap of candidates.fileOverlaps) {
+        if (!requestedIds.has(overlap.mid1) || !requestedIds.has(overlap.mid2)) continue;
+        overlapPairs.add(overlapKey(overlap.mid1, overlap.mid2));
+      }
+      filteredMilestoneIds = selectConflictFreeBatch({
+        orderedIds: milestoneIds,
+        maxParallel: milestoneIds.length,
+        hasConflict: (candidate, existing) =>
+          overlapPairs.has(overlapKey(candidate, existing)),
+      });
+      if (filteredMilestoneIds.length < milestoneIds.length) {
+        const skipped = milestoneIds.filter((mid) => !filteredMilestoneIds.includes(mid));
+        logWarning(
+          "parallel",
+          `uok execution graph filtered ${skipped.length} conflicting milestone(s): ${skipped.join(", ")}`,
+        );
+      }
+    } catch (e) {
+      logWarning(
+        "parallel",
+        `uok execution graph overlap analysis failed; using legacy milestone selection: ${(e as Error).message}`,
+      );
+      filteredMilestoneIds = milestoneIds;
+    }
+  }
+
   // Cap to max_workers
-  const toStart = milestoneIds.slice(0, config.max_workers);
+  const toStart = filteredMilestoneIds.slice(0, config.max_workers);
 
   for (const mid of toStart) {
     // Check budget ceiling before each spawn

package/src/resources/extensions/gsd/post-execution-checks.ts

@@ -118,8 +118,12 @@ export function extractRelativeImports(
 
 /**
  * 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: string,
@@ -129,6 +133,27 @@ export function resolveImportPath(
   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;
@@ -142,7 +167,7 @@ export function resolveImportPath(
     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)) {
@@ -158,17 +183,6 @@ export function resolveImportPath(
     }
   }
 
-  // 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 };
 }
 
@@ -227,11 +241,20 @@ export function checkImportResolution(
 
 // ─── Cross-Task Signature Check ──────────────────────────────────────────────
 
+/**
+ * Normalized function signature extracted from a source file.
+ * Used to compare definitions across tasks and detect signature drift.
+ */
 interface FunctionSignature {
+  /** Function or exported const name. */
   name: string;
+  /** Parameter list with defaults and comments stripped. */
   params: string;
+  /** Declared return type, or "void" when none is annotated. */
   returnType: string;
+  /** Source file the signature was extracted from. */
   file: string;
+  /** 1-based line number of the declaration. */
   lineNum: number;
 }
 

package/src/resources/extensions/gsd/pre-execution-checks.ts

@@ -16,6 +16,7 @@
 
 import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
+import { homedir } from "node:os";
 import { resolve } from "node:path";
 import type { TaskRow } from "./gsd-db.ts";
 import type { PreExecutionCheckJSON } from "./verification-evidence.ts";
@@ -245,23 +246,74 @@ export function normalizeFilePath(filePath: string): string {
 
   // 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);
   }
-  
+
   // Remove duplicate slashes
   normalized = normalized.replace(/\/+/g, "/");
-  
+
   // Remove trailing slash unless it's the root
   if (normalized.length > 1 && normalized.endsWith("/")) {
     normalized = normalized.slice(0, -1);
   }
-  
+
   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: string): boolean {
+  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: string,
+  knownOutputs: Iterable<string>,
+): boolean {
+  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: string): boolean {
+  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: string): string {
   const trimmed = raw.trim();
   if (!trimmed) return trimmed;
@@ -276,6 +328,20 @@ function extractPathFromAnnotation(raw: string): string {
     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, "");
 }
@@ -291,13 +357,17 @@ function shouldValidateInputAsPath(raw: string): boolean {
   const trimmed = raw.trim();
   if (!trimmed) return false;
 
+  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;
   }
 
-  const candidate = extractPathFromAnnotation(trimmed);
-  if (!candidate) return false;
-
   if (!/\s/.test(candidate)) {
     return true;
   }
@@ -312,6 +382,10 @@ function shouldValidateInputAsPath(raw: string): boolean {
   );
 }
 
+function containsGlobPattern(candidate: string): boolean {
+  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.
@@ -354,6 +428,7 @@ export function checkFilePathConsistency(
 
       // Normalize path for consistent comparison
       const normalizedFile = normalizeFilePath(file);
+      if (containsGlobPattern(normalizedFile)) continue;
 
       // Check if file exists on disk
       const absolutePath = resolve(basePath, normalizedFile);
@@ -362,7 +437,17 @@ export function checkFilePathConsistency(
       // 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,
@@ -414,6 +499,11 @@ export function checkTaskOrdering(
       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/src/resources/extensions/gsd/preferences-models.ts

@@ -55,6 +55,7 @@ export function resolveModelWithFallbacksForUnit(unitType: string): ResolvedMode
       break;
     case "plan-milestone":
     case "plan-slice":
+    case "refine-slice":
     case "replan-slice":
       phaseConfig = m.planning;
       break;
@@ -355,7 +356,7 @@ export function resolveAutoSupervisorConfig(): AutoSupervisorConfig {
 
 // ─── Token Profile Resolution ─────────────────────────────────────────────
 
-const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality"]);
+const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality", "burn-max"]);
 
 /**
  * Resolve profile defaults for a given token profile tier.
@@ -400,6 +401,22 @@ export function resolveProfileDefaults(profile: TokenProfile): Partial<GSDPrefer
           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,
+        },
+      };
   }
 }
 
@@ -416,7 +433,7 @@ export function resolveEffectiveProfile(): TokenProfile {
 
 /**
  * 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(): InlineLevel {
   const profile = resolveEffectiveProfile();
@@ -424,12 +441,13 @@ export function resolveInlineLevel(): InlineLevel {
     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(): import("./types.js").ContextSelectionMode {

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

@@ -83,6 +83,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "post_unit_hooks",
   "pre_dispatch_hooks",
   "dynamic_routing",
+  "uok",
   "token_profile",
   "phases",
   "auto_visualize",
@@ -114,11 +115,13 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "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",
@@ -208,6 +211,35 @@ export interface CmuxPreferences {
   browser?: boolean;
 }
 
+export type UokTurnActionMode = "commit" | "snapshot" | "status-only";
+
+export interface UokPreferences {
+  enabled?: boolean;
+  legacy_fallback?: {
+    enabled?: boolean;
+  };
+  gates?: {
+    enabled?: boolean;
+  };
+  model_policy?: {
+    enabled?: boolean;
+  };
+  execution_graph?: {
+    enabled?: boolean;
+  };
+  gitops?: {
+    enabled?: boolean;
+    turn_action?: UokTurnActionMode;
+    turn_push?: boolean;
+  };
+  audit_unified?: {
+    enabled?: boolean;
+  };
+  plan_v2?: {
+    enabled?: boolean;
+  };
+}
+
 /**
  * Opt-in experimental features. All features in this block are disabled by
  * default and must be explicitly enabled. They may change or be removed without
@@ -256,8 +288,17 @@ export interface GSDPreferences {
   post_unit_hooks?: PostUnitHookConfig[];
   pre_dispatch_hooks?: PreDispatchHookConfig[];
   dynamic_routing?: DynamicRoutingConfig;
+  /** Unified Orchestration Kernel controls (default-on, with opt-out and emergency legacy fallback). */
+  uok?: UokPreferences;
   /** Per-model capability overrides. Deep-merged with built-in profiles for capability-aware routing (ADR-004). */
   modelOverrides?: Record<string, { capabilities?: Partial<ModelCapabilities> }>;
+  /**
+   * Override executor context window (in tokens) for prompt budget sizing.
+   * Useful when the configured model registry can't resolve the runtime limit
+   * — e.g. local llama.cpp/lemonade servers where the server-side n_ctx is
+   * smaller than the model's advertised window. Issue #4435.
+   */
+  context_window_override?: number;
   context_management?: ContextManagementConfig;
   token_profile?: TokenProfile;
   phases?: PhaseSkipPreferences;
@@ -371,6 +412,11 @@ export interface GSDPreferences {
    * same regardless of model.  Case-insensitive.
    */
   flat_rate_providers?: string[];
+  /**
+   * Language preference for GSD responses. Accepts any language name or code
+   * (e.g. "Chinese", "zh", "German", "de", "日本語"). Persists across /clear.
+   */
+  language?: string;
 }
 
 export interface LoadedGSDPreferences {