gsd-pi 2.74.0-dev.2b524c3 → 2.74.0-dev.703eabc

package/dist/resources/extensions/gsd/guided-flow.js

@@ -26,6 +26,8 @@ import { nativeIsRepo, nativeInit } from "./native-git-bridge.js";
 import { isInheritedRepo } from "./repo-identity.js";
 import { ensureGitignore, ensurePreferences, untrackRuntimeFiles } from "./gitignore.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { resolveUokFlags } from "./uok/flags.js";
+import { ensurePlanV2Graph } from "./uok/plan-v2.js";
 import { detectProjectState } from "./detection.js";
 import { showProjectInit, offerMigration } from "./init-wizard.js";
 import { validateDirectory } from "./validate-directory.js";
@@ -53,6 +55,25 @@ function nextMilestoneIdReserved(existingIds, uniqueEnabled) {
     reserveMilestoneId(id);
     return id;
 }
+function needsPlanV2Gate(state) {
+    return state.phase === "executing"
+        || state.phase === "summarizing"
+        || state.phase === "validating-milestone"
+        || state.phase === "completing-milestone";
+}
+function runPlanV2Gate(ctx, basePath, state) {
+    const prefs = loadEffectiveGSDPreferences()?.preferences;
+    const uokFlags = resolveUokFlags(prefs);
+    if (!uokFlags.planV2 || !needsPlanV2Gate(state))
+        return true;
+    const compiled = ensurePlanV2Graph(basePath, state);
+    if (!compiled.ok) {
+        const reason = compiled.reason ?? "plan-v2 compilation failed";
+        ctx.ui.notify(`Plan gate failed-closed: ${reason}. Complete plan/discuss artifacts before execution.`, "error");
+        return false;
+    }
+    return true;
+}
 // ─── Commit Instruction Helpers ──────────────────────────────────────────────
 /** Build commit instruction for planning prompts. .gsd/ is managed externally and always gitignored. */
 function buildDocsCommitInstruction(_message) {
@@ -1110,6 +1131,8 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     catch (err) {
         logWarning("guided", `STATE.md rebuild failed: ${err.message}`);
     }
+    if (!runPlanV2Gate(ctx, basePath, state))
+        return;
     if (!state.activeMilestone?.id) {
         // Guard: if a discuss session is already in flight, don't re-inject the prompt.
         // Both /gsd and /gsd auto reach this branch when no milestone exists yet.

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

@@ -1,5 +1,18 @@
 export { isDepthConfirmationAnswer, isDepthVerified, isGateQuestionId, isQueuePhaseActive, setQueuePhaseActive, shouldBlockContextWrite, shouldBlockPendingGate, shouldBlockPendingGateBash, shouldBlockQueueExecution, setPendingGate, clearPendingGate, getPendingGate, } from "./bootstrap/write-gate.js";
 export default async function registerExtension(pi) {
-    const { registerGsdExtension } = await import("./bootstrap/register-extension.js");
-    registerGsdExtension(pi);
+    // Always register the core /gsd command first, in isolation.
+    // This ensures /gsd is available even if the full bootstrap (shortcuts,
+    // tools, hooks) fails — e.g. due to a Windows-specific import error.
+    const { registerGSDCommand } = await import("./commands/index.js");
+    registerGSDCommand(pi);
+    // Full setup (shortcuts, tools, hooks) in a separate try/catch so that
+    // any platform-specific load failure doesn't take out the core command.
+    try {
+        const { registerGsdExtension } = await import("./bootstrap/register-extension.js");
+        registerGsdExtension(pi);
+    }
+    catch (err) {
+        const { logWarning } = await import("./workflow-logger.js");
+        logWarning("bootstrap", `Extension setup partially failed — /gsd commands are available but shortcuts/tools may be missing: ${err instanceof Error ? err.message : String(err)}`);
+    }
 }

package/dist/resources/extensions/gsd/init-wizard.js

@@ -336,6 +336,7 @@ async function customizeAdvancedPrefs(ctx, prefs) {
             { id: "balanced", label: "Balanced", description: "Good trade-off (default)", recommended: true },
             { id: "budget", label: "Budget", description: "Minimize token usage" },
             { id: "quality", label: "Quality", description: "Maximize thoroughness" },
+            { id: "burn-max", label: "Burn Max", description: "Maximum depth, no phase skips" },
         ],
     });
     if (profileChoice !== "not_yet") {

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

@@ -14,6 +14,8 @@
 import { appendFileSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
+import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
 // ─── Emit ─────────────────────────────────────────────────────────────────────
 /**
  * Append a journal event to the daily JSONL file.
@@ -34,6 +36,31 @@ export function emitJournalEvent(basePath, entry) {
     catch {
         // Silent failure — journal must never break auto-mode
     }
+    if (!isUnifiedAuditEnabled())
+        return;
+    try {
+        const causedBy = entry.causedBy
+            ? `${entry.causedBy.flowId}:${entry.causedBy.seq}`
+            : undefined;
+        const turnId = typeof entry.data?.turnId === "string"
+            ? entry.data.turnId
+            : undefined;
+        emitUokAuditEvent(basePath, buildAuditEnvelope({
+            traceId: entry.flowId,
+            turnId,
+            causedBy,
+            category: "orchestration",
+            type: `journal-${entry.eventType}`,
+            payload: {
+                seq: entry.seq,
+                rule: entry.rule,
+                data: entry.data ?? {},
+            },
+        }));
+    }
+    catch {
+        // Best-effort: audit projection must never block journal writes.
+    }
 }
 // ─── Query ────────────────────────────────────────────────────────────────────
 /**

package/dist/resources/extensions/gsd/md-importer.js

@@ -5,7 +5,7 @@
 // Exports: parseDecisionsTable, parseRequirementsSections, migrateFromMarkdown
 import { readFileSync, readdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { upsertDecision, upsertRequirement, insertArtifact, insertMilestone, insertSlice, insertTask, openDatabase, transaction, _getAdapter, } from './gsd-db.js';
+import { upsertDecision, upsertRequirement, insertArtifact, insertMilestone, insertSlice, insertTask, openDatabase, transaction, updateSliceStatus, _getAdapter, } from './gsd-db.js';
 import { resolveGsdRootFile, resolveMilestoneFile, resolveSliceFile, resolveTasksDir, milestonesDir, gsdRoot, resolveTaskFiles, } from './paths.js';
 import { findMilestoneIds } from './guided-flow.js';
 import { parseRoadmap, parsePlan } from './parsers-legacy.js';
@@ -571,9 +571,8 @@ export function migrateHierarchyToDb(basePath) {
                     return t.done && existsSync(summaryFile);
                 });
                 if (allTasksDone && hasSliceSummary) {
-                    const adapter = _getAdapter();
-                    if (adapter) {
-                        adapter.prepare(`UPDATE slices SET status = 'complete' WHERE id = :sid AND milestone_id = :mid`).run({ ':sid': sliceEntry.id, ':mid': milestoneId });
+                    if (_getAdapter()) {
+                        updateSliceStatus(milestoneId, sliceEntry.id, 'complete');
                         process.stderr.write(`gsd-migrate: ${milestoneId}/${sliceEntry.id} all tasks + slice summary complete — upgrading slice to complete\n`);
                     }
                 }

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

@@ -2,7 +2,7 @@
 //
 // Storage layer for auto-learned project memories. Follows context-store.ts patterns.
 // All functions degrade gracefully: return empty results when DB unavailable, never throw.
-import { isDbAvailable, _getAdapter, transaction } from './gsd-db.js';
+import { isDbAvailable, _getAdapter, transaction, insertMemoryRow, rewriteMemoryId, updateMemoryContentRow, incrementMemoryHitCount, supersedeMemoryRow, markMemoryUnitProcessed, decayMemoriesBefore, supersedeLowestRankedMemories, } from './gsd-db.js';
 // ─── Category Display Order ─────────────────────────────────────────────────
 const CATEGORY_PRIORITY = {
     gotcha: 0,
@@ -112,27 +112,23 @@ export function createMemory(fields) {
         const now = new Date().toISOString();
         // Insert with a temporary placeholder ID — seq is auto-assigned
         const placeholder = `_TMP_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        adapter.prepare(`INSERT INTO memories (id, category, content, confidence, source_unit_type, source_unit_id, created_at, updated_at)
-       VALUES (:id, :category, :content, :confidence, :source_unit_type, :source_unit_id, :created_at, :updated_at)`).run({
-            ':id': placeholder,
-            ':category': fields.category,
-            ':content': fields.content,
-            ':confidence': fields.confidence ?? 0.8,
-            ':source_unit_type': fields.source_unit_type ?? null,
-            ':source_unit_id': fields.source_unit_id ?? null,
-            ':created_at': now,
-            ':updated_at': now,
+        insertMemoryRow({
+            id: placeholder,
+            category: fields.category,
+            content: fields.content,
+            confidence: fields.confidence ?? 0.8,
+            sourceUnitType: fields.source_unit_type ?? null,
+            sourceUnitId: fields.source_unit_id ?? null,
+            createdAt: now,
+            updatedAt: now,
         });
-        // Derive the real ID from the assigned seq
+        // Derive the real ID from the assigned seq (SELECT is still fine via adapter)
         const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
         if (!row)
             return placeholder; // fallback — should not happen
         const seq = row['seq'];
         const realId = `MEM${String(seq).padStart(3, '0')}`;
-        adapter.prepare('UPDATE memories SET id = :real_id WHERE id = :placeholder').run({
-            ':real_id': realId,
-            ':placeholder': placeholder,
-        });
+        rewriteMemoryId(placeholder, realId);
         return realId;
     }
     catch {
@@ -145,17 +141,8 @@ export function createMemory(fields) {
 export function updateMemoryContent(id, content, confidence) {
     if (!isDbAvailable())
         return false;
-    const adapter = _getAdapter();
-    if (!adapter)
-        return false;
     try {
-        const now = new Date().toISOString();
-        if (confidence != null) {
-            adapter.prepare('UPDATE memories SET content = :content, confidence = :confidence, updated_at = :updated_at WHERE id = :id').run({ ':content': content, ':confidence': confidence, ':updated_at': now, ':id': id });
-        }
-        else {
-            adapter.prepare('UPDATE memories SET content = :content, updated_at = :updated_at WHERE id = :id').run({ ':content': content, ':updated_at': now, ':id': id });
-        }
+        updateMemoryContentRow(id, content, confidence, new Date().toISOString());
         return true;
     }
     catch {
@@ -168,11 +155,8 @@ export function updateMemoryContent(id, content, confidence) {
 export function reinforceMemory(id) {
     if (!isDbAvailable())
         return false;
-    const adapter = _getAdapter();
-    if (!adapter)
-        return false;
     try {
-        adapter.prepare('UPDATE memories SET hit_count = hit_count + 1, updated_at = :updated_at WHERE id = :id').run({ ':updated_at': new Date().toISOString(), ':id': id });
+        incrementMemoryHitCount(id, new Date().toISOString());
         return true;
     }
     catch {
@@ -185,11 +169,8 @@ export function reinforceMemory(id) {
 export function supersedeMemory(oldId, newId) {
     if (!isDbAvailable())
         return false;
-    const adapter = _getAdapter();
-    if (!adapter)
-        return false;
     try {
-        adapter.prepare('UPDATE memories SET superseded_by = :new_id, updated_at = :updated_at WHERE id = :old_id').run({ ':new_id': newId, ':updated_at': new Date().toISOString(), ':old_id': oldId });
+        supersedeMemoryRow(oldId, newId, new Date().toISOString());
         return true;
     }
     catch {
@@ -220,12 +201,8 @@ export function isUnitProcessed(unitKey) {
 export function markUnitProcessed(unitKey, activityFile) {
     if (!isDbAvailable())
         return false;
-    const adapter = _getAdapter();
-    if (!adapter)
-        return false;
     try {
-        adapter.prepare(`INSERT OR IGNORE INTO memory_processed_units (unit_key, activity_file, processed_at)
-       VALUES (:key, :file, :at)`).run({ ':key': unitKey, ':file': activityFile, ':at': new Date().toISOString() });
+        markMemoryUnitProcessed(unitKey, activityFile, new Date().toISOString());
         return true;
     }
     catch {
@@ -244,16 +221,14 @@ export function decayStaleMemories(thresholdUnits = 20) {
     if (!adapter)
         return;
     try {
-        // Find the timestamp of the Nth most recent processed unit
+        // Find the timestamp of the Nth most recent processed unit (read-only SELECT)
         const row = adapter.prepare(`SELECT processed_at FROM memory_processed_units
        ORDER BY processed_at DESC
        LIMIT 1 OFFSET :offset`).get({ ':offset': thresholdUnits - 1 });
         if (!row)
             return; // not enough processed units yet
         const cutoff = row['processed_at'];
-        adapter.prepare(`UPDATE memories
-       SET confidence = MAX(0.1, confidence - 0.1), updated_at = :now
-       WHERE superseded_by IS NULL AND updated_at < :cutoff AND confidence > 0.1`).run({ ':now': new Date().toISOString(), ':cutoff': cutoff });
+        decayMemoriesBefore(cutoff, new Date().toISOString());
     }
     catch {
         // non-fatal
@@ -274,14 +249,7 @@ export function enforceMemoryCap(max = 50) {
         if (count <= max)
             return;
         const excess = count - max;
-        // Batch update: supersede lowest-ranked active memories in a single statement
-        adapter.prepare(`UPDATE memories SET superseded_by = 'CAP_EXCEEDED', updated_at = :now
-       WHERE id IN (
-         SELECT id FROM memories
-         WHERE superseded_by IS NULL
-         ORDER BY (confidence * (1.0 + hit_count * 0.1)) ASC
-         LIMIT :limit
-       )`).run({ ':now': new Date().toISOString(), ':limit': excess });
+        supersedeLowestRankedMemories(excess, new Date().toISOString());
     }
     catch {
         // non-fatal

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

@@ -17,6 +17,8 @@ import { gsdRoot } from "./paths.js";
 import { getAndClearSkills } from "./skill-telemetry.js";
 import { loadJsonFile, loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
 import { parseUnitId } from "./unit-id.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
+import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
 // Re-export from shared — import directly from format-utils to avoid pulling
 // in the full barrel (mod.js → ui.js → @gsd/pi-tui) which breaks when loaded
 // outside jiti's alias resolution (e.g. dynamic import in auto-loop reports).
@@ -152,6 +154,23 @@ export function snapshotUnitMetrics(ctx, unitType, unitId, startedAt, model, opt
         ledger.units.push(unit);
     }
     saveLedger(basePath, ledger);
+    if (isUnifiedAuditEnabled()) {
+        emitUokAuditEvent(basePath, buildAuditEnvelope({
+            traceId: opts?.traceId ?? `metrics:${unitType}:${unitId}`,
+            turnId: opts?.turnId,
+            causedBy: opts?.causedBy,
+            category: "metrics",
+            type: "unit-metrics-snapshot",
+            payload: {
+                unitType,
+                unitId,
+                model,
+                tokens: unit.tokens,
+                cost: unit.cost,
+                toolCalls: unit.toolCalls,
+            },
+        }));
+    }
     return unit;
 }
 /**

package/dist/resources/extensions/gsd/milestone-validation-gates.js

@@ -10,7 +10,7 @@
  * gate registry so the definitions stay in lockstep with prompt builders,
  * dispatch rules, and state derivation. See gate-registry.ts.
  */
-import { _getAdapter } from "./gsd-db.js";
+import { isDbAvailable, upsertQualityGate } from "./gsd-db.js";
 import { getGatesForTurn } from "./gate-registry.js";
 /**
  * Insert milestone-level quality_gates records for a validation run.
@@ -24,21 +24,22 @@ import { getGatesForTurn } from "./gate-registry.js";
  * in gate-registry.ts automatically flows through here.
  */
 export function insertMilestoneValidationGates(milestoneId, sliceId, verdict, evaluatedAt) {
-    const db = _getAdapter();
-    if (!db)
+    if (!isDbAvailable())
         return;
     const gateVerdict = verdict === "pass" ? "pass" : "flag";
     const milestoneGates = getGatesForTurn("validate-milestone");
     for (const def of milestoneGates) {
-        db.prepare(`INSERT OR REPLACE INTO quality_gates
-       (milestone_id, slice_id, gate_id, scope, task_id, status, verdict, rationale, findings, evaluated_at)
-       VALUES (:mid, :sid, :gid, 'milestone', '', 'complete', :verdict, :rationale, '', :evaluated_at)`).run({
-            ":mid": milestoneId,
-            ":sid": sliceId,
-            ":gid": def.id,
-            ":verdict": gateVerdict,
-            ":rationale": `${def.promptSection} — milestone validation verdict: ${verdict}`,
-            ":evaluated_at": evaluatedAt,
+        upsertQualityGate({
+            milestoneId,
+            sliceId,
+            gateId: def.id,
+            scope: "milestone",
+            taskId: "",
+            status: "complete",
+            verdict: gateVerdict,
+            rationale: `${def.promptSection} — milestone validation verdict: ${verdict}`,
+            findings: "",
+            evaluatedAt,
         });
     }
 }

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -4,7 +4,7 @@
 //
 // Both READ and WRITE operations are native — push operations remain as
 // execSync calls because git2 credential handling is too complex.
-import { execSync, execFileSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { GSDError, GSD_GIT_ERROR } from "./errors.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { getErrorMessage } from "./error-utils.js";
@@ -206,7 +206,7 @@ export function nativeIsRepo(basePath) {
         return native.gitIsRepo(basePath);
     }
     try {
-        execSync("git rev-parse --git-dir", { cwd: basePath, stdio: "pipe" });
+        execFileSync("git", ["rev-parse", "--git-dir"], { cwd: basePath, stdio: "pipe" });
         return true;
     }
     catch {
@@ -629,7 +629,10 @@ export function nativeCommit(basePath, message, options) {
     }
     // Fallback: use git commit with stdin pipe for safe multi-line messages
     try {
-        const result = execSync(`git commit --no-verify -F -${options?.allowEmpty ? " --allow-empty" : ""}`, {
+        const args = ["commit", "--no-verify", "-F", "-"];
+        if (options?.allowEmpty)
+            args.push("--allow-empty");
+        const result = execFileSync("git", args, {
             cwd: basePath,
             stdio: ["pipe", "pipe", "pipe"],
             encoding: "utf-8",
@@ -767,7 +770,7 @@ export function nativeResetHard(basePath) {
         native.gitResetHard(basePath);
         return;
     }
-    execSync("git reset --hard HEAD", { cwd: basePath, stdio: "pipe" });
+    execFileSync("git", ["reset", "--hard", "HEAD"], { cwd: basePath, stdio: "pipe" });
 }
 /**
  * Soft reset to a target ref (git reset --soft <ref>).

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

@@ -20,8 +20,13 @@ import { writeSessionStatus, readAllSessionStatuses, readSessionStatus, removeSe
 import { analyzeParallelEligibility, } 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";
 // ─── Module State ──────────────────────────────────────────────────────────
 let state = null;
+function overlapKey(a, b) {
+    return a < b ? `${a}::${b}` : `${b}::${a}`;
+}
 // ─── Persistence ──────────────────────────────────────────────────────────
 const ORCHESTRATOR_STATE_FILE = "orchestrator.json";
 const TMP_SUFFIX = ".tmp";
@@ -277,6 +282,7 @@ export async function startParallel(basePath, milestoneIds, prefs) {
         return { started: [], errors: [{ mid: "all", error: "Cannot start parallel from within a parallel worker" }] };
     }
     const config = resolveParallelConfig(prefs);
+    const uokFlags = resolveUokFlags(prefs);
     // Release any leftover state from a previous session before reassigning
     if (state) {
         for (const w of state.workers.values()) {
@@ -324,8 +330,34 @@ export async function startParallel(basePath, milestoneIds, prefs) {
     };
     const started = [];
     const errors = [];
+    let filteredMilestoneIds = milestoneIds;
+    if (uokFlags.executionGraph && milestoneIds.length > 1) {
+        try {
+            const requestedIds = new Set(milestoneIds);
+            const candidates = await analyzeParallelEligibility(basePath);
+            const overlapPairs = new Set();
+            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.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
         if (isBudgetExceeded()) {

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

@@ -321,7 +321,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 +365,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 +396,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 +404,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",

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 ─────────────────────────────────────────────