gsd-pi 2.73.1-dev.d987996 → 2.74.0-dev.14c45ac

package/src/resources/extensions/gsd/tools/validate-milestone.ts

@@ -23,6 +23,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";
 
 export interface ValidateMilestoneParams {
   milestoneId: string;
@@ -43,6 +46,12 @@ export interface ValidateMilestoneResult {
   validationPath: string;
 }
 
+export interface ValidateMilestoneOptions {
+  uokGatesEnabled?: boolean;
+  traceId?: string;
+  turnId?: string;
+}
+
 function renderValidationMarkdown(params: ValidateMilestoneParams): string {
   let md = `---
 verdict: ${params.verdict}
@@ -81,6 +90,7 @@ ${params.verdictRationale}
 export async function handleValidateMilestone(
   params: ValidateMilestoneParams,
   basePath: string,
+  opts?: ValidateMilestoneOptions,
 ): Promise<ValidateMilestoneResult | { error: string }> {
   if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
     return { error: "milestoneId is required and must be a non-empty string" };
@@ -108,6 +118,8 @@ export async function handleValidateMilestone(
   // 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({
@@ -123,11 +135,9 @@ export async function handleValidateMilestone(
     // #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,
+      gateSliceId,
       params.verdict,
       validatedAt,
     );
@@ -147,6 +157,41 @@ export async function handleValidateMilestone(
   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 as Error).message}`,
+      );
+    }
+  }
+
   return {
     milestoneId: params.milestoneId,
     verdict: params.verdict,

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -5,7 +5,7 @@ import {
   getMilestone,
   getSliceStatusSummary,
   getSliceTaskCounts,
-  _getAdapter,
+  readTransaction,
   saveGateResult,
 } from "../gsd-db.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
@@ -616,12 +616,9 @@ export async function executeMilestoneStatus(
       };
     }
 
-    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 },
@@ -635,8 +632,6 @@ export async function executeMilestoneStatus(
         taskCounts: getSliceTaskCounts(params.milestoneId, s.id),
       }));
 
-      adapter.exec("COMMIT");
-
       const result = {
         milestoneId: milestone.id,
         title: milestone.title,
@@ -651,10 +646,7 @@ export async function executeMilestoneStatus(
         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);
     logWarning("tool", `gsd_milestone_status tool failed: ${msg}`);

package/src/resources/extensions/gsd/triage-resolution.ts

@@ -111,14 +111,9 @@ export function executeReplan(
     // 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 {
       // DB write is best-effort — disk file is the primary trigger for fallback path

package/src/resources/extensions/gsd/types.ts

@@ -306,7 +306,7 @@ export interface HookDispatchResult {
 
 export type BudgetEnforcementMode = "warn" | "pause" | "halt";
 
-export type TokenProfile = "budget" | "balanced" | "quality";
+export type TokenProfile = "budget" | "balanced" | "quality" | "burn-max";
 
 export type InlineLevel = "full" | "standard" | "minimal";
 

package/src/resources/extensions/gsd/unit-ownership.ts

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

package/src/resources/extensions/gsd/uok/audit-toggle.ts

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

package/src/resources/extensions/gsd/uok/audit.ts

@@ -0,0 +1,51 @@
+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";
+import type { AuditEventEnvelope } from "./contracts.js";
+
+function auditLogPath(basePath: string): string {
+  return join(gsdRoot(basePath), "audit", "events.jsonl");
+}
+
+function ensureAuditDir(basePath: string): void {
+  mkdirSync(join(gsdRoot(basePath), "audit"), { recursive: true });
+}
+
+export function buildAuditEnvelope(args: {
+  traceId: string;
+  turnId?: string;
+  causedBy?: string;
+  category: AuditEventEnvelope["category"];
+  type: string;
+  payload?: Record<string, unknown>;
+}): AuditEventEnvelope {
+  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: string, event: AuditEventEnvelope): void {
+  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/src/resources/extensions/gsd/uok/contracts.ts

@@ -0,0 +1,135 @@
+export type FailureClass =
+  | "none"
+  | "policy"
+  | "input"
+  | "execution"
+  | "artifact"
+  | "verification"
+  | "closeout"
+  | "git"
+  | "timeout"
+  | "manual-attention"
+  | "unknown";
+
+export type GateOutcome = "pass" | "fail" | "retry" | "manual-attention";
+
+export interface GateResult {
+  gateId: string;
+  gateType: string;
+  outcome: GateOutcome;
+  failureClass: FailureClass;
+  rationale?: string;
+  findings?: string;
+  attempt: number;
+  maxAttempts: number;
+  retryable: boolean;
+  evaluatedAt: string;
+}
+
+export type TurnPhase =
+  | "pre-dispatch"
+  | "dispatch"
+  | "unit"
+  | "finalize"
+  | "guard"
+  | "custom-engine";
+
+export type TurnStatus =
+  | "completed"
+  | "failed"
+  | "paused"
+  | "stopped"
+  | "skipped"
+  | "retry";
+
+export interface TurnContract {
+  traceId: string;
+  turnId: string;
+  iteration: number;
+  basePath: string;
+  unitType?: string;
+  unitId?: string;
+  sidecarKind?: string;
+  startedAt: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface TurnCloseoutRecord {
+  traceId: string;
+  turnId: string;
+  unitType?: string;
+  unitId?: string;
+  status: TurnStatus;
+  failureClass: FailureClass;
+  gitAction: "commit" | "snapshot" | "status-only";
+  gitPushed: boolean;
+  activityFile?: string;
+  finishedAt: string;
+}
+
+export interface TurnResult {
+  traceId: string;
+  turnId: string;
+  iteration: number;
+  unitType?: string;
+  unitId?: string;
+  status: TurnStatus;
+  failureClass: FailureClass;
+  phaseResults: Array<{
+    phase: TurnPhase;
+    action: string;
+    ts: string;
+    data?: Record<string, unknown>;
+  }>;
+  gateResults?: GateResult[];
+  closeout?: TurnCloseoutRecord;
+  error?: string;
+  startedAt: string;
+  finishedAt: string;
+}
+
+export interface AuditEventEnvelope {
+  eventId: string;
+  traceId: string;
+  turnId?: string;
+  causedBy?: string;
+  category:
+    | "orchestration"
+    | "gate"
+    | "model-policy"
+    | "gitops"
+    | "verification"
+    | "metrics"
+    | "plan"
+    | "execution";
+  type: string;
+  ts: string;
+  payload: Record<string, unknown>;
+}
+
+export type UokNodeKind =
+  | "unit"
+  | "hook"
+  | "subagent"
+  | "team-worker"
+  | "verification"
+  | "reprocess";
+
+export interface UokGraphNode {
+  id: string;
+  kind: UokNodeKind;
+  dependsOn: string[];
+  writes?: string[];
+  reads?: string[];
+  metadata?: Record<string, unknown>;
+}
+
+export interface UokTurnObserver {
+  onTurnStart(contract: TurnContract): void;
+  onPhaseResult(
+    phase: TurnPhase,
+    action: string,
+    data?: Record<string, unknown>,
+  ): void;
+  onTurnResult(result: TurnResult): void;
+}

package/src/resources/extensions/gsd/uok/execution-graph.ts

@@ -0,0 +1,241 @@
+import type { UokGraphNode } from "./contracts.js";
+import type { DerivedTaskNode } from "../types.js";
+import type { SidecarItem } from "../auto/session.js";
+
+export interface ExecutionGraphRunOptions {
+  parallel?: boolean;
+  maxWorkers?: number;
+}
+
+export interface ExecutionGraphResult {
+  order: string[];
+  conflicts: Array<{ nodeA: string; nodeB: string; file: string }>;
+}
+
+export type ExecutionNodeHandler = (node: UokGraphNode) => Promise<void>;
+
+export interface ConflictFreeBatchInput {
+  orderedIds: string[];
+  maxParallel: number;
+  hasConflict: (leftId: string, rightId: string) => boolean;
+}
+
+export interface ReactiveDispatchSelectionInput {
+  graph: Array<Pick<DerivedTaskNode, "id" | "dependsOn" | "outputFiles">>;
+  readyIds: string[];
+  maxParallel: number;
+  inFlightOutputs?: Set<string>;
+}
+
+export interface ReactiveDispatchSelectionResult {
+  selected: string[];
+  conflicts: Array<{ nodeA: string; nodeB: string; file: string }>;
+}
+
+export function selectConflictFreeBatch({
+  orderedIds,
+  maxParallel,
+  hasConflict,
+}: ConflictFreeBatchInput): string[] {
+  if (maxParallel <= 0 || orderedIds.length === 0) return [];
+  const selected: string[] = [];
+  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: Array<Pick<DerivedTaskNode, "id" | "dependsOn" | "outputFiles">>,
+): UokGraphNode[] {
+  return graph.map((node) => ({
+    id: node.id,
+    kind: "unit",
+    dependsOn: [...node.dependsOn],
+    writes: [...node.outputFiles],
+  }));
+}
+
+export function selectReactiveDispatchBatch(
+  input: ReactiveDispatchSelectionInput,
+): ReactiveDispatchSelectionResult {
+  const nodeMap = new Map(buildReactiveNodes(input.graph).map((n) => [n.id, n]));
+  const readyNodes = input.readyIds
+    .map((id) => nodeMap.get(id))
+    .filter((node): node is UokGraphNode => !!node);
+  const conflicts = detectFileConflicts(readyNodes);
+  if (readyNodes.length === 0 || input.maxParallel <= 0) {
+    return { selected: [], conflicts };
+  }
+
+  const claimed = new Set(input.inFlightOutputs ?? []);
+  const selected: string[] = [];
+  const selectedSet = new Set<string>();
+  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: SidecarItem["kind"]): UokGraphNode["kind"] {
+  if (kind === "hook") return "hook";
+  if (kind === "triage") return "verification";
+  return "team-worker";
+}
+
+export function buildSidecarQueueNodes(queue: SidecarItem[]): UokGraphNode[] {
+  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: SidecarItem[]): Promise<SidecarItem[]> {
+  if (queue.length <= 1) return [...queue];
+  const nodes = buildSidecarQueueNodes(queue);
+  const scheduler = new ExecutionGraphScheduler();
+  const orderedIndexes: number[] = [];
+  const seenKinds = new Set<UokGraphNode["kind"]>(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 is SidecarItem => !!item);
+}
+
+export class ExecutionGraphScheduler {
+  private readonly handlers = new Map<string, ExecutionNodeHandler>();
+
+  registerHandler(kind: UokGraphNode["kind"], handler: ExecutionNodeHandler): void {
+    this.handlers.set(kind, handler);
+  }
+
+  async run(nodes: UokGraphNode[], options?: ExecutionGraphRunOptions): Promise<ExecutionGraphResult> {
+    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<string>();
+    const order: string[] = [];
+
+    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: UokGraphNode[]): UokGraphNode[] {
+  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: UokGraphNode[] = [];
+
+  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: UokGraphNode[]): Array<{ nodeA: string; nodeB: string; file: string }> {
+  const conflicts: Array<{ nodeA: string; nodeB: string; file: string }> = [];
+  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/src/resources/extensions/gsd/uok/flags.ts

@@ -0,0 +1,45 @@
+import type { GSDPreferences } from "../preferences.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+
+export interface UokFlags {
+  enabled: boolean;
+  legacyFallback: boolean;
+  gates: boolean;
+  modelPolicy: boolean;
+  executionGraph: boolean;
+  gitops: boolean;
+  gitopsTurnAction: "commit" | "snapshot" | "status-only";
+  gitopsTurnPush: boolean;
+  auditUnified: boolean;
+  planV2: boolean;
+}
+
+function envForcesLegacyFallback(): boolean {
+  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: GSDPreferences | undefined): UokFlags {
+  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(): UokFlags {
+  const prefs = loadEffectiveGSDPreferences()?.preferences;
+  return resolveUokFlags(prefs);
+}