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

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",
@@ -84,6 +85,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "discuss_web_research",
     "discuss_depth",
     "flat_rate_providers",
+    "language",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [

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 ─────────────────────────────────────────────
@@ -1038,5 +1144,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

@@ -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/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:
@@ -71,6 +89,7 @@ remote_questions:
 uat_dispatch:
 post_unit_hooks: []
 pre_dispatch_hooks: []
+# language:
 # experimental:
 #   rtk: false
 ---

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 {};