gsd-pi 2.74.0-dev.b741afb → 2.74.0-dev.ffbcc03

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

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

@@ -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 ?? {}) }

package/dist/resources/extensions/gsd/safety/evidence-collector.js

@@ -32,11 +32,11 @@ export function getFilePaths() {
  * Record a tool call at dispatch time (before execution).
  * Exit codes and output are filled in by recordToolResult after execution.
  */
-export function recordToolCall(toolName, input) {
+export function recordToolCall(toolCallId, toolName, input) {
     if (toolName === "bash" || toolName === "Bash") {
         unitEvidence.push({
             kind: "bash",
-            toolCallId: "",
+            toolCallId,
             command: String(input.command ?? ""),
             exitCode: -1,
             outputSnippet: "",
@@ -46,7 +46,7 @@ export function recordToolCall(toolName, input) {
     else if (toolName === "write" || toolName === "Write") {
         unitEvidence.push({
             kind: "write",
-            toolCallId: "",
+            toolCallId,
             path: String(input.file_path ?? input.path ?? ""),
             timestamp: Date.now(),
         });
@@ -54,44 +54,29 @@ export function recordToolCall(toolName, input) {
     else if (toolName === "edit" || toolName === "Edit") {
         unitEvidence.push({
             kind: "edit",
-            toolCallId: "",
+            toolCallId,
             path: String(input.file_path ?? input.path ?? ""),
             timestamp: Date.now(),
         });
     }
 }
 /**
- * Record a tool execution result. Matches the most recent unresolved entry
- * of the same kind and fills in the toolCallId, exit code, and output.
+ * Record a tool execution result. Matches the entry by toolCallId (assigned
+ * at dispatch time) and fills in exit code + output. Prior versions matched
+ * by `kind + empty-string` which corrupted parallel tool calls.
  */
 export function recordToolResult(toolCallId, toolName, result, isError) {
-    const normalizedName = toolName.toLowerCase();
-    if (normalizedName === "bash") {
-        const entry = findLastUnresolved("bash");
-        if (entry) {
-            entry.toolCallId = toolCallId;
-            const text = extractResultText(result);
-            entry.outputSnippet = text.slice(0, 500);
-            const exitMatch = text.match(/Command exited with code (\d+)/);
-            entry.exitCode = exitMatch ? Number(exitMatch[1]) : (isError ? 1 : 0);
-        }
-    }
-    else if (normalizedName === "write" || normalizedName === "edit") {
-        const entry = findLastUnresolved(normalizedName);
-        if (entry) {
-            entry.toolCallId = toolCallId;
-        }
+    const entry = unitEvidence.find(e => e.toolCallId === toolCallId);
+    if (!entry)
+        return;
+    if (entry.kind === "bash") {
+        const text = extractResultText(result);
+        entry.outputSnippet = text.slice(0, 500);
+        const exitMatch = text.match(/Command exited with code (\d+)/);
+        entry.exitCode = exitMatch ? Number(exitMatch[1]) : (isError ? 1 : 0);
     }
 }
 // ─── Internals ──────────────────────────────────────────────────────────────
-function findLastUnresolved(kind) {
-    for (let i = unitEvidence.length - 1; i >= 0; i--) {
-        if (unitEvidence[i].kind === kind && unitEvidence[i].toolCallId === "") {
-            return unitEvidence[i];
-        }
-    }
-    return undefined;
-}
 function extractResultText(result) {
     if (typeof result === "string")
         return result;

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

@@ -21,6 +21,7 @@ import { createWorktree, worktreePath, removeWorktree } from "./worktree-manager
 import { writeSessionStatus, } from "./session-status-io.js";
 import { hasFileConflict } from "./slice-parallel-conflict.js";
 import { getErrorMessage } from "./error-utils.js";
+import { selectConflictFreeBatch } from "./uok/execution-graph.js";
 // ─── Module State ──────────────────────────────────────────────────────────
 let sliceState = null;
 // ─── Public API ────────────────────────────────────────────────────────────
@@ -62,7 +63,7 @@ export async function startSliceParallel(basePath, milestoneId, eligibleSlices,
     const started = [];
     const errors = [];
     // Filter out conflicting slices (conservative: check all pairs)
-    const safeSlices = filterConflictingSlices(basePath, milestoneId, eligibleSlices);
+    const safeSlices = filterConflictingSlices(basePath, milestoneId, eligibleSlices, opts.useExecutionGraph === true);
     // Limit to maxWorkers
     const toSpawn = safeSlices.slice(0, maxWorkers);
     for (const slice of toSpawn) {
@@ -176,7 +177,16 @@ export function resetSliceOrchestrator() {
  * Greedy: add slices to the safe set in order; skip any that conflict
  * with an already-included slice.
  */
-function filterConflictingSlices(basePath, milestoneId, slices) {
+function filterConflictingSlices(basePath, milestoneId, slices, useExecutionGraph) {
+    if (useExecutionGraph) {
+        const selectedIds = selectConflictFreeBatch({
+            orderedIds: slices.map((slice) => slice.id),
+            maxParallel: slices.length,
+            hasConflict: (candidate, existing) => hasFileConflict(basePath, milestoneId, candidate, existing),
+        });
+        const selected = new Set(selectedIds);
+        return slices.filter((slice) => selected.has(slice.id));
+    }
     const safe = [];
     for (const candidate of slices) {
         let conflictsWithSafe = false;

package/dist/resources/extensions/gsd/templates/PREFERENCES.md

@@ -39,6 +39,24 @@ dynamic_routing:
   budget_pressure:
   cross_provider:
   hooks:
+uok:
+  enabled: true
+  legacy_fallback:
+    enabled: false
+  gates:
+    enabled: false
+  model_policy:
+    enabled: false
+  execution_graph:
+    enabled: false
+  gitops:
+    enabled: false
+    turn_action: status-only
+    turn_push: false
+  audit_unified:
+    enabled: false
+  plan_v2:
+    enabled: false
 auto_visualize:
 auto_report:
 parallel:

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -361,6 +361,11 @@ export async function handleCompleteSlice(params, basePath) {
     (async () => {
         try {
             const graphMod = await import("@gsd-build/mcp-server");
+            if (typeof graphMod.buildGraph !== "function"
+                || typeof graphMod.writeGraph !== "function"
+                || typeof graphMod.resolveGsdRoot !== "function") {
+                throw new Error("graph helpers unavailable from @gsd-build/mcp-server");
+            }
             const g = await graphMod.buildGraph(basePath);
             await graphMod.writeGraph(graphMod.resolveGsdRoot(basePath), g);
         }

package/dist/resources/extensions/gsd/tools/validate-milestone.js

@@ -16,6 +16,9 @@ import { invalidateStateCache } from "../state.js";
 import { VALIDATION_VERDICTS, isValidMilestoneVerdict } from "../verdict-parser.js";
 import { insertMilestoneValidationGates } from "../milestone-validation-gates.js";
 import { logWarning } from "../workflow-logger.js";
+import { UokGateRunner } from "../uok/gate-runner.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+import { resolveUokFlags } from "../uok/flags.js";
 function renderValidationMarkdown(params) {
     let md = `---
 verdict: ${params.verdict}
@@ -48,7 +51,7 @@ ${params.verdictRationale}
     }
     return md;
 }
-export async function handleValidateMilestone(params, basePath) {
+export async function handleValidateMilestone(params, basePath, opts) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
@@ -73,6 +76,8 @@ export async function handleValidateMilestone(params, basePath) {
     // rendering can regenerate. The inverse (file exists, no DB row) is
     // harder to detect and recover from (#2725).
     const validatedAt = new Date().toISOString();
+    const slices = getMilestoneSlices(params.milestoneId);
+    const gateSliceId = slices.length > 0 ? slices[0].id : "_milestone";
     transaction(() => {
         insertAssessment({
             path: validationPath,
@@ -86,9 +91,7 @@ export async function handleValidateMilestone(params, basePath) {
         // #2945 Bug 4: persist quality_gates records alongside the assessment.
         // Previously only the assessment was written, leaving M002+ milestones
         // with zero quality_gate records despite passing validation.
-        const slices = getMilestoneSlices(params.milestoneId);
-        const sliceId = slices.length > 0 ? slices[0].id : "_milestone";
-        insertMilestoneValidationGates(params.milestoneId, sliceId, params.verdict, validatedAt);
+        insertMilestoneValidationGates(params.milestoneId, gateSliceId, params.verdict, validatedAt);
     });
     // ── Filesystem render (outside transaction) ────────────────────────────
     // If disk render fails, roll back the DB row so state stays consistent.
@@ -103,6 +106,38 @@ export async function handleValidateMilestone(params, basePath) {
     invalidateStateCache();
     clearPathCache();
     clearParseCache();
+    const prefs = loadEffectiveGSDPreferences()?.preferences;
+    const gatesEnabled = opts?.uokGatesEnabled ?? resolveUokFlags(prefs).gates;
+    if (gatesEnabled) {
+        try {
+            const gateRunner = new UokGateRunner();
+            const nonPassVerdict = params.verdict !== "pass";
+            gateRunner.register({
+                id: "milestone-validation-gates",
+                type: "verification",
+                execute: async () => ({
+                    outcome: nonPassVerdict ? "manual-attention" : "pass",
+                    failureClass: nonPassVerdict ? "manual-attention" : "none",
+                    rationale: `milestone validation verdict: ${params.verdict}`,
+                    findings: nonPassVerdict
+                        ? [params.verdictRationale, params.remediationPlan ?? ""].filter(Boolean).join("\n")
+                        : "",
+                }),
+            });
+            await gateRunner.run("milestone-validation-gates", {
+                basePath,
+                traceId: opts?.traceId ?? `validate-milestone:${params.milestoneId}`,
+                turnId: opts?.turnId ?? `${params.milestoneId}:validate`,
+                milestoneId: params.milestoneId,
+                sliceId: gateSliceId,
+                unitType: "validate-milestone",
+                unitId: params.milestoneId,
+            });
+        }
+        catch (err) {
+            logWarning("tool", `validate_milestone — failed to persist UOK gate result: ${err.message}`);
+        }
+    }
     return {
         milestoneId: params.milestoneId,
         verdict: params.verdict,

package/dist/resources/extensions/gsd/unit-ownership.js

@@ -20,7 +20,7 @@ let providerModule = null;
 let loadAttempted = false;
 function suppressSqliteWarning() {
     const origEmit = process.emit;
-    // @ts-expect-error overriding process.emit for warning filter
+    // Override via loose cast: Node's overloaded emit signature is not directly assignable.
     process.emit = function (event, ...args) {
         if (event === "warning" &&
             args[0] &&

package/dist/resources/extensions/gsd/uok/audit-toggle.js

@@ -0,0 +1,7 @@
+const AUDIT_ENV_KEY = "GSD_UOK_AUDIT_UNIFIED";
+export function setUnifiedAuditEnabled(enabled) {
+    process.env[AUDIT_ENV_KEY] = enabled ? "1" : "0";
+}
+export function isUnifiedAuditEnabled() {
+    return process.env[AUDIT_ENV_KEY] === "1";
+}

package/dist/resources/extensions/gsd/uok/audit.js

@@ -0,0 +1,40 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { gsdRoot } from "../paths.js";
+import { isDbAvailable, insertAuditEvent } from "../gsd-db.js";
+function auditLogPath(basePath) {
+    return join(gsdRoot(basePath), "audit", "events.jsonl");
+}
+function ensureAuditDir(basePath) {
+    mkdirSync(join(gsdRoot(basePath), "audit"), { recursive: true });
+}
+export function buildAuditEnvelope(args) {
+    return {
+        eventId: randomUUID(),
+        traceId: args.traceId,
+        turnId: args.turnId,
+        causedBy: args.causedBy,
+        category: args.category,
+        type: args.type,
+        ts: new Date().toISOString(),
+        payload: args.payload ?? {},
+    };
+}
+export function emitUokAuditEvent(basePath, event) {
+    try {
+        ensureAuditDir(basePath);
+        appendFileSync(auditLogPath(basePath), `${JSON.stringify(event)}\n`, "utf-8");
+    }
+    catch {
+        // Best-effort: audit writes must never break orchestration.
+    }
+    if (!isDbAvailable())
+        return;
+    try {
+        insertAuditEvent(event);
+    }
+    catch {
+        // Projection failures are non-fatal while legacy readers are still active.
+    }
+}

package/dist/resources/extensions/gsd/uok/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/resources/extensions/gsd/uok/execution-graph.js

@@ -0,0 +1,179 @@
+export function selectConflictFreeBatch({ orderedIds, maxParallel, hasConflict, }) {
+    if (maxParallel <= 0 || orderedIds.length === 0)
+        return [];
+    const selected = [];
+    for (const candidate of orderedIds) {
+        if (selected.length >= maxParallel)
+            break;
+        const conflictsExisting = selected.some((existing) => hasConflict(candidate, existing));
+        if (conflictsExisting)
+            continue;
+        selected.push(candidate);
+    }
+    return selected;
+}
+function buildReactiveNodes(graph) {
+    return graph.map((node) => ({
+        id: node.id,
+        kind: "unit",
+        dependsOn: [...node.dependsOn],
+        writes: [...node.outputFiles],
+    }));
+}
+export function selectReactiveDispatchBatch(input) {
+    const nodeMap = new Map(buildReactiveNodes(input.graph).map((n) => [n.id, n]));
+    const readyNodes = input.readyIds
+        .map((id) => nodeMap.get(id))
+        .filter((node) => !!node);
+    const conflicts = detectFileConflicts(readyNodes);
+    if (readyNodes.length === 0 || input.maxParallel <= 0) {
+        return { selected: [], conflicts };
+    }
+    const claimed = new Set(input.inFlightOutputs ?? []);
+    const selected = [];
+    const selectedSet = new Set();
+    const readySet = new Set(input.readyIds);
+    for (const id of input.readyIds) {
+        if (selected.length >= input.maxParallel)
+            break;
+        const node = nodeMap.get(id);
+        if (!node)
+            continue;
+        const hasUnmetReadyDependency = node.dependsOn.some((dep) => readySet.has(dep) && !selectedSet.has(dep));
+        if (hasUnmetReadyDependency)
+            continue;
+        const writes = node.writes ?? [];
+        const conflictsWithClaimed = writes.some((file) => claimed.has(file));
+        if (conflictsWithClaimed)
+            continue;
+        selected.push(node.id);
+        selectedSet.add(node.id);
+        for (const file of writes)
+            claimed.add(file);
+    }
+    return { selected, conflicts };
+}
+function sidecarToNodeKind(kind) {
+    if (kind === "hook")
+        return "hook";
+    if (kind === "triage")
+        return "verification";
+    return "team-worker";
+}
+export function buildSidecarQueueNodes(queue) {
+    return queue.map((item, index) => ({
+        id: `sidecar-${String(index).padStart(4, "0")}:${item.kind}:${item.unitType}:${item.unitId}`,
+        kind: sidecarToNodeKind(item.kind),
+        dependsOn: index > 0 ? [`sidecar-${String(index - 1).padStart(4, "0")}:${queue[index - 1].kind}:${queue[index - 1].unitType}:${queue[index - 1].unitId}`] : [],
+        metadata: { index },
+    }));
+}
+export async function scheduleSidecarQueue(queue) {
+    if (queue.length <= 1)
+        return [...queue];
+    const nodes = buildSidecarQueueNodes(queue);
+    const scheduler = new ExecutionGraphScheduler();
+    const orderedIndexes = [];
+    const seenKinds = new Set(nodes.map((n) => n.kind));
+    for (const kind of seenKinds) {
+        scheduler.registerHandler(kind, async (node) => {
+            const idx = Number(node.metadata?.index);
+            if (Number.isInteger(idx) && idx >= 0)
+                orderedIndexes.push(idx);
+        });
+    }
+    await scheduler.run(nodes, { parallel: false });
+    return orderedIndexes.map((idx) => queue[idx]).filter((item) => !!item);
+}
+export class ExecutionGraphScheduler {
+    handlers = new Map();
+    registerHandler(kind, handler) {
+        this.handlers.set(kind, handler);
+    }
+    async run(nodes, options) {
+        const sorted = topologicalSort(nodes);
+        const conflicts = detectFileConflicts(nodes);
+        // Default deterministic serial execution remains the reference path.
+        if (!options?.parallel) {
+            for (const node of sorted) {
+                const handler = this.handlers.get(node.kind);
+                if (handler)
+                    await handler(node);
+            }
+            return { order: sorted.map((n) => n.id), conflicts };
+        }
+        // Parallel mode only for nodes whose dependencies are already satisfied.
+        const maxWorkers = Math.max(1, Math.min(8, options.maxWorkers ?? 2));
+        const remaining = new Map(nodes.map((n) => [n.id, n]));
+        const done = new Set();
+        const order = [];
+        while (remaining.size > 0) {
+            const ready = Array.from(remaining.values()).filter((node) => node.dependsOn.every((dep) => done.has(dep)));
+            ready.sort((a, b) => a.id.localeCompare(b.id));
+            if (ready.length === 0) {
+                throw new Error("Execution graph deadlock detected: no ready nodes and graph not complete");
+            }
+            const batch = ready.slice(0, maxWorkers);
+            await Promise.all(batch.map(async (node) => {
+                const handler = this.handlers.get(node.kind);
+                if (handler)
+                    await handler(node);
+                done.add(node.id);
+                order.push(node.id);
+                remaining.delete(node.id);
+            }));
+        }
+        return { order, conflicts };
+    }
+}
+function topologicalSort(nodes) {
+    const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+    const inDegree = new Map(nodes.map((n) => [n.id, 0]));
+    for (const node of nodes) {
+        for (const dep of node.dependsOn) {
+            if (nodeMap.has(dep)) {
+                inDegree.set(node.id, (inDegree.get(node.id) ?? 0) + 1);
+            }
+        }
+    }
+    const queue = nodes
+        .filter((n) => (inDegree.get(n.id) ?? 0) === 0)
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const ordered = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        ordered.push(current);
+        for (const next of nodes) {
+            if (!next.dependsOn.includes(current.id))
+                continue;
+            const deg = (inDegree.get(next.id) ?? 0) - 1;
+            inDegree.set(next.id, deg);
+            if (deg === 0) {
+                queue.push(next);
+                queue.sort((a, b) => a.id.localeCompare(b.id));
+            }
+        }
+    }
+    if (ordered.length !== nodes.length) {
+        throw new Error("Execution graph has cyclic dependencies");
+    }
+    return ordered;
+}
+function detectFileConflicts(nodes) {
+    const conflicts = [];
+    for (let i = 0; i < nodes.length; i++) {
+        const a = nodes[i];
+        const writesA = new Set(a.writes ?? []);
+        if (writesA.size === 0)
+            continue;
+        for (let j = i + 1; j < nodes.length; j++) {
+            const b = nodes[j];
+            for (const file of b.writes ?? []) {
+                if (writesA.has(file)) {
+                    conflicts.push({ nodeA: a.id, nodeB: b.id, file });
+                }
+            }
+        }
+    }
+    return conflicts;
+}

package/dist/resources/extensions/gsd/uok/flags.js

@@ -0,0 +1,29 @@
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+function envForcesLegacyFallback() {
+    const raw = process.env.GSD_UOK_FORCE_LEGACY ?? process.env.GSD_UOK_LEGACY_FALLBACK;
+    if (!raw)
+        return false;
+    const normalized = raw.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+export function resolveUokFlags(prefs) {
+    const uok = prefs?.uok;
+    const legacyFallback = uok?.legacy_fallback?.enabled === true || envForcesLegacyFallback();
+    const enabledByPreference = uok?.enabled ?? true;
+    return {
+        enabled: enabledByPreference && !legacyFallback,
+        legacyFallback,
+        gates: uok?.gates?.enabled === true,
+        modelPolicy: uok?.model_policy?.enabled === true,
+        executionGraph: uok?.execution_graph?.enabled === true,
+        gitops: uok?.gitops?.enabled === true,
+        gitopsTurnAction: uok?.gitops?.turn_action ?? "status-only",
+        gitopsTurnPush: uok?.gitops?.turn_push === true,
+        auditUnified: uok?.audit_unified?.enabled === true,
+        planV2: uok?.plan_v2?.enabled === true,
+    };
+}
+export function loadUokFlags() {
+    const prefs = loadEffectiveGSDPreferences()?.preferences;
+    return resolveUokFlags(prefs);
+}