gsd-pi 2.74.0 → 2.75.0-dev.fd2382b9f

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/tools/workflow-tool-executors.js

@@ -1,7 +1,7 @@
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
 import { sanitizeCompleteMilestoneParams } from "../bootstrap/sanitize-complete-milestone.js";
 import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
-import { getMilestone, getSliceStatusSummary, getSliceTaskCounts, _getAdapter, saveGateResult, } from "../gsd-db.js";
+import { getMilestone, getSliceStatusSummary, getSliceTaskCounts, readTransaction, saveGateResult, } from "../gsd-db.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
 import { saveArtifactToDb } from "../db-writer.js";
 import { handleCompleteMilestone } from "./complete-milestone.js";
@@ -493,12 +493,9 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
                 isError: true,
             };
         }
-        const adapter = _getAdapter();
-        adapter.exec("BEGIN");
-        try {
+        return readTransaction(() => {
             const milestone = getMilestone(params.milestoneId);
             if (!milestone) {
-                adapter.exec("COMMIT");
                 return {
                     content: [{ type: "text", text: `Milestone ${params.milestoneId} not found in database.` }],
                     details: { operation: "milestone_status", milestoneId: params.milestoneId, found: false },
@@ -510,7 +507,6 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
                 status: s.status,
                 taskCounts: getSliceTaskCounts(params.milestoneId, s.id),
             }));
-            adapter.exec("COMMIT");
             const result = {
                 milestoneId: milestone.id,
                 title: milestone.title,
@@ -524,14 +520,7 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
                 content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
                 details: { operation: "milestone_status", milestoneId: milestone.id, sliceCount: slices.length },
             };
-        }
-        catch (txErr) {
-            try {
-                adapter.exec("ROLLBACK");
-            }
-            catch { /* swallow */ }
-            throw txErr;
-        }
+        });
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);

package/dist/resources/extensions/gsd/triage-resolution.js

@@ -83,12 +83,9 @@ export function executeReplan(basePath, mid, sid, capture) {
         // Also write replan_triggered_at column for DB-backed detection
         try {
             const req = createRequire(import.meta.url);
-            const { isDbAvailable, _getAdapter } = req("./gsd-db.js");
+            const { isDbAvailable, setSliceReplanTriggeredAt } = req("./gsd-db.js");
             if (isDbAvailable()) {
-                const adapter = _getAdapter();
-                if (adapter) {
-                    adapter.prepare("UPDATE slices SET replan_triggered_at = :ts WHERE milestone_id = :mid AND id = :sid").run({ ":ts": ts, ":mid": mid, ":sid": sid });
-                }
+                setSliceReplanTriggeredAt(mid, sid, ts);
             }
         }
         catch {

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 ?? "commit",
+        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);
+}

package/dist/resources/extensions/gsd/uok/gate-runner.js

@@ -0,0 +1,109 @@
+import { insertGateRun } from "../gsd-db.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
+const RETRY_MATRIX = {
+    none: 0,
+    policy: 0,
+    input: 0,
+    execution: 1,
+    artifact: 1,
+    verification: 1,
+    closeout: 1,
+    git: 1,
+    timeout: 2,
+    "manual-attention": 0,
+    unknown: 0,
+};
+export class UokGateRunner {
+    registry = new Map();
+    register(gate) {
+        this.registry.set(gate.id, gate);
+    }
+    list() {
+        return Array.from(this.registry.values());
+    }
+    async run(id, ctx) {
+        const gate = this.registry.get(id);
+        if (!gate) {
+            return {
+                gateId: id,
+                gateType: "unknown",
+                outcome: "manual-attention",
+                failureClass: "unknown",
+                rationale: `Gate ${id} not registered`,
+                attempt: 1,
+                maxAttempts: 1,
+                retryable: false,
+                evaluatedAt: new Date().toISOString(),
+            };
+        }
+        let attempt = 0;
+        let final = null;
+        const maxAttemptsByFailureClass = RETRY_MATRIX;
+        while (attempt < 3) {
+            attempt += 1;
+            const now = new Date().toISOString();
+            const result = await gate.execute(ctx, attempt);
+            const failureClass = result.failureClass ?? (result.outcome === "pass" ? "none" : "unknown");
+            const retryBudget = maxAttemptsByFailureClass[failureClass] ?? 0;
+            const retryable = result.outcome !== "pass" && attempt <= retryBudget;
+            final = {
+                gateId: gate.id,
+                gateType: gate.type,
+                outcome: retryable ? "retry" : result.outcome,
+                failureClass,
+                rationale: result.rationale,
+                findings: result.findings,
+                attempt,
+                maxAttempts: Math.max(1, retryBudget),
+                retryable,
+                evaluatedAt: now,
+            };
+            insertGateRun({
+                traceId: ctx.traceId,
+                turnId: ctx.turnId,
+                gateId: final.gateId,
+                gateType: final.gateType,
+                unitType: ctx.unitType,
+                unitId: ctx.unitId,
+                milestoneId: ctx.milestoneId,
+                sliceId: ctx.sliceId,
+                taskId: ctx.taskId,
+                outcome: final.outcome,
+                failureClass: final.failureClass,
+                rationale: final.rationale,
+                findings: final.findings,
+                attempt: final.attempt,
+                maxAttempts: final.maxAttempts,
+                retryable: final.retryable,
+                evaluatedAt: final.evaluatedAt,
+            });
+            emitUokAuditEvent(ctx.basePath, buildAuditEnvelope({
+                traceId: ctx.traceId,
+                turnId: ctx.turnId,
+                category: "gate",
+                type: "gate-run",
+                payload: {
+                    gateId: final.gateId,
+                    gateType: final.gateType,
+                    outcome: final.outcome,
+                    failureClass: final.failureClass,
+                    attempt: final.attempt,
+                    maxAttempts: final.maxAttempts,
+                    retryable: final.retryable,
+                },
+            }));
+            if (!retryable)
+                break;
+        }
+        return final ?? {
+            gateId: gate.id,
+            gateType: gate.type,
+            outcome: "manual-attention",
+            failureClass: "unknown",
+            attempt: 1,
+            maxAttempts: 1,
+            retryable: false,
+            evaluatedAt: new Date().toISOString(),
+        };
+    }
+}

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

@@ -0,0 +1,53 @@
+import { isDbAvailable, upsertTurnGitTransaction } from "../gsd-db.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
+export function writeTurnGitTransaction(args) {
+    if (!isDbAvailable())
+        return;
+    upsertTurnGitTransaction({
+        traceId: args.traceId,
+        turnId: args.turnId,
+        unitType: args.unitType,
+        unitId: args.unitId,
+        stage: args.stage,
+        action: args.action,
+        push: args.push,
+        status: args.status,
+        error: args.error,
+        metadata: args.metadata,
+        updatedAt: new Date().toISOString(),
+    });
+    emitUokAuditEvent(args.basePath, buildAuditEnvelope({
+        traceId: args.traceId,
+        turnId: args.turnId,
+        category: "gitops",
+        type: `turn-git-${args.stage}`,
+        payload: {
+            unitType: args.unitType,
+            unitId: args.unitId,
+            action: args.action,
+            push: args.push,
+            status: args.status,
+            error: args.error,
+            ...(args.metadata ?? {}),
+        },
+    }));
+}
+export function writeTurnCloseoutGitRecord(basePath, record) {
+    writeTurnGitTransaction({
+        basePath,
+        traceId: record.traceId,
+        turnId: record.turnId,
+        unitType: record.unitType,
+        unitId: record.unitId,
+        stage: "record",
+        action: record.gitAction,
+        push: record.gitPushed,
+        status: record.failureClass === "git" ? "failed" : "ok",
+        error: record.failureClass === "git" ? "git closeout failure" : undefined,
+        metadata: {
+            turnStatus: record.status,
+            finishedAt: record.finishedAt,
+            activityFile: record.activityFile,
+        },
+    });
+}

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

@@ -0,0 +1,85 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { gsdRoot } from "../paths.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
+import { setUnifiedAuditEnabled } from "./audit-toggle.js";
+import { resolveUokFlags } from "./flags.js";
+import { createTurnObserver } from "./loop-adapter.js";
+function parityLogPath(basePath) {
+    return join(gsdRoot(basePath), "runtime", "uok-parity.jsonl");
+}
+function writeParityEvent(basePath, event) {
+    try {
+        mkdirSync(join(gsdRoot(basePath), "runtime"), { recursive: true });
+        appendFileSync(parityLogPath(basePath), `${JSON.stringify(event)}\n`, "utf-8");
+    }
+    catch {
+        // parity telemetry must never block orchestration
+    }
+}
+function resolveKernelPathLabel(flags) {
+    if (flags.legacyFallback)
+        return "legacy-fallback";
+    return flags.enabled ? "uok-kernel" : "legacy-wrapper";
+}
+export async function runAutoLoopWithUok(args) {
+    const { ctx, pi, s, deps, runKernelLoop, runLegacyLoop } = args;
+    const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
+    const flags = resolveUokFlags(prefs);
+    setUnifiedAuditEnabled(flags.auditUnified);
+    writeParityEvent(s.basePath, {
+        ts: new Date().toISOString(),
+        path: resolveKernelPathLabel(flags),
+        flags,
+        phase: "enter",
+    });
+    if (flags.auditUnified) {
+        emitUokAuditEvent(s.basePath, buildAuditEnvelope({
+            traceId: `session:${String(s.autoStartTime || Date.now())}`,
+            category: "orchestration",
+            type: "uok-kernel-enter",
+            payload: {
+                flags,
+                sessionId: ctx.sessionManager?.getSessionId?.(),
+            },
+        }));
+    }
+    const decoratedDeps = flags.enabled
+        ? {
+            ...deps,
+            uokObserver: createTurnObserver({
+                basePath: s.basePath,
+                gitAction: flags.gitopsTurnAction,
+                gitPush: flags.gitopsTurnPush,
+                enableAudit: flags.auditUnified,
+                enableGitops: flags.gitops,
+            }),
+        }
+        : deps;
+    try {
+        if (flags.enabled) {
+            await runKernelLoop(ctx, pi, s, decoratedDeps);
+        }
+        else {
+            await runLegacyLoop(ctx, pi, s, deps);
+        }
+        writeParityEvent(s.basePath, {
+            ts: new Date().toISOString(),
+            path: resolveKernelPathLabel(flags),
+            flags,
+            phase: "exit",
+            status: "ok",
+        });
+    }
+    catch (err) {
+        writeParityEvent(s.basePath, {
+            ts: new Date().toISOString(),
+            path: resolveKernelPathLabel(flags),
+            flags,
+            phase: "exit",
+            status: "error",
+            error: err instanceof Error ? err.message : String(err),
+        });
+        throw err;
+    }
+}