gsd-pi 2.74.0 → 2.75.0-dev.2203010a0

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

package/dist/resources/extensions/gsd/uok/loop-adapter.js

@@ -0,0 +1,133 @@
+import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
+import { writeTurnCloseoutGitRecord, writeTurnGitTransaction } from "./gitops.js";
+export function createTurnObserver(options) {
+    let current = null;
+    const phaseResults = [];
+    return {
+        onTurnStart(contract) {
+            current = contract;
+            phaseResults.length = 0;
+            if (options.enableGitops) {
+                writeTurnGitTransaction({
+                    basePath: options.basePath,
+                    traceId: contract.traceId,
+                    turnId: contract.turnId,
+                    unitType: contract.unitType,
+                    unitId: contract.unitId,
+                    stage: "turn-start",
+                    action: options.gitAction,
+                    push: options.gitPush,
+                    status: "ok",
+                    metadata: {
+                        iteration: contract.iteration,
+                        sidecarKind: contract.sidecarKind,
+                    },
+                });
+            }
+            if (options.enableAudit) {
+                emitUokAuditEvent(options.basePath, buildAuditEnvelope({
+                    traceId: contract.traceId,
+                    turnId: contract.turnId,
+                    category: "orchestration",
+                    type: "turn-start",
+                    payload: {
+                        iteration: contract.iteration,
+                        unitType: contract.unitType,
+                        unitId: contract.unitId,
+                        sidecarKind: contract.sidecarKind,
+                    },
+                }));
+            }
+        },
+        onPhaseResult(phase, action, data) {
+            phaseResults.push({
+                phase,
+                action,
+                ts: new Date().toISOString(),
+                data,
+            });
+            if (!current || !options.enableGitops)
+                return;
+            if (phase === "dispatch") {
+                writeTurnGitTransaction({
+                    basePath: options.basePath,
+                    traceId: current.traceId,
+                    turnId: current.turnId,
+                    unitType: data?.unitType,
+                    unitId: data?.unitId,
+                    stage: "stage",
+                    action: options.gitAction,
+                    push: options.gitPush,
+                    status: "ok",
+                    metadata: { action },
+                });
+            }
+            if (phase === "unit") {
+                writeTurnGitTransaction({
+                    basePath: options.basePath,
+                    traceId: current.traceId,
+                    turnId: current.turnId,
+                    unitType: data?.unitType,
+                    unitId: data?.unitId,
+                    stage: "checkpoint",
+                    action: options.gitAction,
+                    push: options.gitPush,
+                    status: "ok",
+                    metadata: { action },
+                });
+            }
+            if (phase === "finalize") {
+                writeTurnGitTransaction({
+                    basePath: options.basePath,
+                    traceId: current.traceId,
+                    turnId: current.turnId,
+                    unitType: data?.unitType,
+                    unitId: data?.unitId,
+                    stage: "publish",
+                    action: options.gitAction,
+                    push: options.gitPush,
+                    status: "ok",
+                    metadata: { action },
+                });
+            }
+        },
+        onTurnResult(result) {
+            const merged = {
+                ...result,
+                phaseResults: result.phaseResults.length > 0 ? result.phaseResults : [...phaseResults],
+            };
+            if (options.enableAudit) {
+                emitUokAuditEvent(options.basePath, buildAuditEnvelope({
+                    traceId: merged.traceId,
+                    turnId: merged.turnId,
+                    category: "orchestration",
+                    type: "turn-result",
+                    payload: {
+                        unitType: merged.unitType,
+                        unitId: merged.unitId,
+                        status: merged.status,
+                        failureClass: merged.failureClass,
+                        error: merged.error,
+                        phaseCount: merged.phaseResults.length,
+                    },
+                }));
+            }
+            if (options.enableGitops) {
+                const closeout = merged.closeout ?? {
+                    traceId: merged.traceId,
+                    turnId: merged.turnId,
+                    unitType: merged.unitType,
+                    unitId: merged.unitId,
+                    status: merged.status,
+                    failureClass: merged.failureClass,
+                    gitAction: options.gitAction,
+                    gitPushed: options.gitPush,
+                    finishedAt: merged.finishedAt,
+                };
+                writeTurnCloseoutGitRecord(options.basePath, closeout);
+            }
+            current = null;
+            phaseResults.length = 0;
+        },
+    };
+}

package/dist/resources/extensions/gsd/uok/model-policy.js

@@ -0,0 +1,66 @@
+import { computeTaskRequirements, filterToolsForProvider } from "../model-router.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
+export function buildRequirementVector(unitType, taskMetadata) {
+    if (!unitType)
+        return {};
+    return computeTaskRequirements(unitType, taskMetadata);
+}
+export function applyModelPolicyFilter(candidates, options) {
+    const requiredTools = options.requiredTools ?? [];
+    const deniedProviders = new Set((options.deniedProviders ?? []).map((p) => p.toLowerCase()));
+    const allowedApis = options.allowedApis ? new Set(options.allowedApis) : null;
+    const requirements = buildRequirementVector(options.unitType, options.taskMetadata);
+    const decisions = [];
+    const eligible = [];
+    for (const model of candidates) {
+        let allowed = true;
+        let reason = "allowed";
+        if (options.allowCrossProvider === false && options.currentProvider && model.provider !== options.currentProvider) {
+            allowed = false;
+            reason = `cross-provider routing disabled (${model.provider} != ${options.currentProvider})`;
+        }
+        if (allowed && deniedProviders.has(model.provider.toLowerCase())) {
+            allowed = false;
+            reason = `provider denied by policy: ${model.provider}`;
+        }
+        if (allowed && allowedApis && !allowedApis.has(model.api)) {
+            allowed = false;
+            reason = `transport/api denied by policy: ${model.api}`;
+        }
+        if (allowed && requiredTools.length > 0) {
+            const compatibility = filterToolsForProvider(requiredTools, model.api);
+            if (compatibility.filtered.length > 0) {
+                allowed = false;
+                reason = `tool policy denied (${compatibility.filtered.join(", ")}) for ${model.api}`;
+            }
+        }
+        const decision = {
+            modelId: model.id,
+            provider: model.provider,
+            allowed,
+            reason,
+        };
+        decisions.push(decision);
+        emitUokAuditEvent(options.basePath, buildAuditEnvelope({
+            traceId: options.traceId,
+            turnId: options.turnId,
+            category: "model-policy",
+            type: allowed ? "model-policy-allow" : "model-policy-deny",
+            payload: {
+                modelId: model.id,
+                provider: model.provider,
+                api: model.api,
+                reason,
+                unitType: options.unitType,
+                requirements,
+            },
+        }));
+        if (allowed)
+            eligible.push(model);
+    }
+    return {
+        eligible,
+        decisions,
+        requirements,
+    };
+}