@opengsd/gsd-pi 1.5.0 → 1.6.0

package/dist/resources/extensions/gsd/uat-dispatch.js

@@ -0,0 +1,94 @@
+// Project/App: gsd-pi
+// File Purpose: Resolve whether a completed slice needs run-uat dispatch.
+import { loadFile } from "./files.js";
+import { resolveSliceFile } from "./paths.js";
+import { classifyUatContentForRun, shouldDispatchUatForContent, } from "./uat-policy.js";
+import { hasVerdict } from "./verdict-parser.js";
+import { logWarning } from "./workflow-logger.js";
+async function loadSliceFileContent(base, milestoneId, sliceId, kind) {
+    const filePath = resolveSliceFile(base, milestoneId, sliceId, kind);
+    return filePath ? ((await loadFile(filePath)) ?? "") : "";
+}
+async function resolveRunUatEffectiveType(base, milestoneId, sliceId, uatContent) {
+    let summaryContent = "";
+    try {
+        summaryContent = await loadSliceFileContent(base, milestoneId, sliceId, "SUMMARY");
+    }
+    catch (err) {
+        logWarning("prompt", `resolveRunUatEffectiveType SUMMARY load failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return classifyUatContentForRun(uatContent, summaryContent).effectiveType;
+}
+async function resolveCandidateRunUatDispatch(base, milestoneId, candidate, prefs) {
+    const uatContent = await loadSliceFileContent(base, milestoneId, candidate.sliceId, "UAT");
+    if (!uatContent)
+        return null;
+    if (hasVerdict(uatContent))
+        return null;
+    const assessmentContent = await loadSliceFileContent(base, milestoneId, candidate.sliceId, "ASSESSMENT");
+    if (assessmentContent && hasVerdict(assessmentContent))
+        return null;
+    if (!shouldDispatchUatForContent(uatContent, prefs))
+        return null;
+    return {
+        sliceId: candidate.sliceId,
+        uatType: await resolveRunUatEffectiveType(base, milestoneId, candidate.sliceId, uatContent),
+    };
+}
+async function getDbCompletedSliceCandidates(milestoneId) {
+    const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
+    if (!isDbAvailable())
+        return null;
+    const slices = getMilestoneSlices(milestoneId);
+    // No DB slice rows for this milestone: the DB has no authoritative view, so
+    // return null to let the caller defer to the roadmap fallback.
+    if (slices.length === 0)
+        return null;
+    // The DB has slice rows and is therefore authoritative for this milestone.
+    // Return a (possibly empty) array rather than null: an empty result must NOT
+    // fall through to the roadmap fallback, because the DB, not stale roadmap
+    // checkboxes, is the source of truth for which slices are complete.
+    return slices
+        .filter((slice) => slice.status === "complete")
+        .map((slice) => ({ sliceId: slice.id }))
+        .reverse();
+}
+export async function findRunUatDispatchFromCandidates(base, milestoneId, candidates, prefs) {
+    for (const candidate of candidates) {
+        const dispatch = await resolveCandidateRunUatDispatch(base, milestoneId, candidate, prefs);
+        if (dispatch)
+            return dispatch;
+    }
+    return null;
+}
+/**
+ * Check if the most recently completed slice needs a UAT run.
+ * Returns { sliceId, uatType } if UAT should be dispatched, null otherwise.
+ *
+ * When the DB has slice rows for the milestone it is authoritative: only its
+ * completed slices are considered and the `fallbackCandidates` (roadmap-derived)
+ * are ignored, even when no DB slice is complete. The fallback candidates are
+ * only consulted when the DB has no slice rows for the milestone, is
+ * unavailable, or errors.
+ *
+ * Skips when:
+ * - No completed slices exist in DB or the caller-provided fallback candidates
+ * - uat_dispatch is not enabled and the UAT spec does not require runtime/browser evidence
+ * - No UAT file exists for the slice
+ * - UAT result already exists in the UAT or ASSESSMENT file
+ */
+export async function checkNeedsRunUat(base, milestoneId, prefs, fallbackCandidates = []) {
+    try {
+        const dbCandidates = await getDbCompletedSliceCandidates(milestoneId);
+        // A non-null result (including an empty array) means the DB is authoritative
+        // for this milestone; only fall through to the roadmap fallback when the DB
+        // has no slice rows at all (null).
+        if (dbCandidates !== null) {
+            return findRunUatDispatchFromCandidates(base, milestoneId, dbCandidates, prefs);
+        }
+    }
+    catch (err) {
+        logWarning("prompt", `checkNeedsRunUat DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return findRunUatDispatchFromCandidates(base, milestoneId, fallbackCandidates, prefs);
+}

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

@@ -21,8 +21,8 @@
 // Not yet declared here (remaining ADR-033 steps): the manifest data
 // (`UNIT_MANIFESTS` stays in unit-context-manifest.ts, already type-enforced
 // against the registry's `UnitType`). Prompt-template association is declared
-// for direct one-template units; conditional/composite prompt selection stays
-// with the prompt builders until it has a richer registry shape.
+// for direct one-template units and verified conditional template sets;
+// composition logic stays with prompt builders.
 import { BROWSER_CONTRACT_TOOL_NAMES } from "../shared/browser-contract.js";
 // ─── Shared tool-name constants (used by registry rows) ──────────────────
 export const RUN_UAT_WORKFLOW_TOOL_NAMES = [
@@ -84,6 +84,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["discuss", "planning"],
+        promptTemplates: ["discuss", "discuss-headless", "guided-discuss-milestone"],
         toolContract: {
             allowedGsdTools: [
                 "gsd_summary_save",
@@ -444,3 +445,12 @@ export function getUnitPhaseChain(unitType) {
 export function getUnitPromptTemplate(unitType) {
     return getUnitDescriptor(unitType)?.promptTemplate;
 }
+/** Prompt template ids for any verified direct or conditional prompt builder. */
+export function getUnitPromptTemplates(unitType) {
+    const descriptor = getUnitDescriptor(unitType);
+    if (!descriptor)
+        return [];
+    if (descriptor.promptTemplates)
+        return descriptor.promptTemplates;
+    return descriptor.promptTemplate ? [descriptor.promptTemplate] : [];
+}

package/dist/resources/extensions/gsd/unmerged-milestone-guard.js

@@ -2,7 +2,7 @@
 // File Purpose: Block new workflow entry when completed milestone branches are still unmerged.
 import { execFileSync } from "node:child_process";
 import { nativeBranchExists, nativeDetectMainBranch, nativeDiffNumstat, nativeIsAncestor, } from "./native-git-bridge.js";
-import { autoWorktreeBranch } from "./auto-worktree.js";
+import { autoWorktreeBranch } from "./auto-worktree-branch-lifecycle.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { getAllMilestones } from "./gsd-db.js";
 import { resolveMilestoneIntegrationBranch } from "./git-service.js";

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

@@ -1,7 +1,36 @@
 const AUDIT_ENV_KEY = "GSD_UOK_AUDIT_UNIFIED";
+const suppressedBasePaths = new Set();
 export function setUnifiedAuditEnabled(enabled) {
     process.env[AUDIT_ENV_KEY] = enabled ? "1" : "0";
 }
-export function isUnifiedAuditEnabled() {
-    return process.env[AUDIT_ENV_KEY] === "1";
+export function setUnifiedAuditSuppressedForBasePath(basePath, suppressed) {
+    if (suppressed) {
+        suppressedBasePaths.add(basePath);
+        return;
+    }
+    suppressedBasePaths.delete(basePath);
+}
+export function isUnifiedAuditEnabled(basePath) {
+    if (basePath && suppressedBasePaths.has(basePath))
+        return false;
+    return process.env[AUDIT_ENV_KEY] !== "0";
+}
+export function getUnifiedAuditOverride() {
+    const raw = process.env[AUDIT_ENV_KEY];
+    if (raw === "0")
+        return false;
+    if (raw === "1")
+        return true;
+    return undefined;
+}
+export function restoreUnifiedAuditOverride(override) {
+    if (override === undefined) {
+        delete process.env[AUDIT_ENV_KEY];
+        return;
+    }
+    setUnifiedAuditEnabled(override);
+}
+export function clearUnifiedAuditOverrideForTests() {
+    delete process.env[AUDIT_ENV_KEY];
+    suppressedBasePaths.clear();
 }

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

@@ -7,6 +7,7 @@ import { withFileLockSync } from "../file-lock.js";
 import { gsdRoot } from "../paths.js";
 import { isDbAvailable, insertAuditEvent } from "../gsd-db.js";
 import { CURRENT_UOK_CONTRACT_VERSION, validateAuditEvent } from "./contracts.js";
+import { isUnifiedAuditEnabled } from "./audit-toggle.js";
 function auditLogPath(basePath) {
     return join(gsdRoot(basePath), "audit", "events.jsonl");
 }
@@ -30,6 +31,8 @@ export function emitUokAuditEvent(basePath, event) {
     // Drop writes from a turn superseded by timeout recovery / cancellation.
     if (isStaleWrite("uok-audit"))
         return;
+    if (!isUnifiedAuditEnabled(basePath))
+        return;
     const validation = validateAuditEvent(event);
     if (!validation.ok) {
         throw new Error(`Invalid UOK audit event: ${validation.issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`);

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

@@ -1,5 +1,6 @@
 import { insertGateRun } from "../gsd-db.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
+import { isUnifiedAuditEnabled } from "./audit-toggle.js";
 const RETRY_MATRIX = {
     none: 0,
     policy: 0,
@@ -13,6 +14,25 @@ const RETRY_MATRIX = {
     "manual-attention": 0,
     unknown: 0,
 };
+function emitGateAuditIfEnabled(ctx, result) {
+    if (!isUnifiedAuditEnabled(ctx.basePath))
+        return;
+    emitUokAuditEvent(ctx.basePath, buildAuditEnvelope({
+        traceId: ctx.traceId,
+        turnId: ctx.turnId,
+        category: "gate",
+        type: "gate-run",
+        payload: {
+            gateId: result.gateId,
+            gateType: result.gateType,
+            outcome: result.outcome,
+            failureClass: result.failureClass,
+            attempt: result.attempt,
+            maxAttempts: result.maxAttempts,
+            retryable: result.retryable,
+        },
+    }));
+}
 export class UokGateRunner {
     registry = new Map();
     register(gate) {
@@ -55,21 +75,7 @@ export class UokGateRunner {
                 retryable: unknownResult.retryable,
                 evaluatedAt: unknownResult.evaluatedAt,
             });
-            emitUokAuditEvent(ctx.basePath, buildAuditEnvelope({
-                traceId: ctx.traceId,
-                turnId: ctx.turnId,
-                category: "gate",
-                type: "gate-run",
-                payload: {
-                    gateId: unknownResult.gateId,
-                    gateType: unknownResult.gateType,
-                    outcome: unknownResult.outcome,
-                    failureClass: unknownResult.failureClass,
-                    attempt: unknownResult.attempt,
-                    maxAttempts: unknownResult.maxAttempts,
-                    retryable: unknownResult.retryable,
-                },
-            }));
+            emitGateAuditIfEnabled(ctx, unknownResult);
             return unknownResult;
         }
         let attempt = 0;
@@ -125,21 +131,7 @@ export class UokGateRunner {
                 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,
-                },
-            }));
+            emitGateAuditIfEnabled(ctx, final);
             if (!retryable)
                 break;
         }

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

@@ -1,5 +1,6 @@
 import { isDbAvailable, upsertTurnGitTransaction } from "../gsd-db.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
+import { isUnifiedAuditEnabled } from "./audit-toggle.js";
 export function writeTurnGitTransaction(args) {
     if (!isDbAvailable())
         return;
@@ -16,21 +17,23 @@ export function writeTurnGitTransaction(args) {
         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 ?? {}),
-        },
-    }));
+    if (isUnifiedAuditEnabled(args.basePath)) {
+        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, metadata) {
     writeTurnGitTransaction({

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

@@ -2,10 +2,11 @@ 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 { getUnifiedAuditOverride, restoreUnifiedAuditOverride, setUnifiedAuditEnabled, setUnifiedAuditSuppressedForBasePath, } from "./audit-toggle.js";
 import { resolveUokFlags } from "./flags.js";
 import { createTurnObserver } from "./loop-adapter.js";
 import { incrementLegacyTelemetry } from "../legacy-telemetry.js";
+import { logWarning } from "../workflow-logger.js";
 function parityLogPath(basePath) {
     return join(gsdRoot(basePath), "runtime", "uok-parity.jsonl");
 }
@@ -23,68 +24,141 @@ function resolveKernelPathLabel(flags) {
         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);
+function createUokKernelRunPlan(input) {
+    const flags = resolveUokFlags(input.preferences?.preferences);
     const pathLabel = resolveKernelPathLabel(flags);
-    if (pathLabel !== "uok-kernel") {
-        incrementLegacyTelemetry("legacy.uokFallbackUsed");
-    }
-    writeParityEvent(s.basePath, {
-        ts: new Date().toISOString(),
-        path: pathLabel,
+    return {
         flags,
-        phase: "enter",
-    });
-    if (flags.auditUnified) {
-        emitUokAuditEvent(s.basePath, buildAuditEnvelope({
-            traceId: `session:${String(s.autoStartTime || Date.now())}`,
+        pathLabel,
+        traceId: `session:${String(input.autoStartTime || Date.now())}`,
+        useKernel: flags.enabled,
+    };
+}
+function createKernelAuditStateController(basePath) {
+    const previousAuditOverride = getUnifiedAuditOverride();
+    return {
+        apply(enabled) {
+            setUnifiedAuditSuppressedForBasePath(basePath, !enabled);
+            setUnifiedAuditEnabled(enabled);
+        },
+        restore() {
+            restoreUnifiedAuditOverride(previousAuditOverride);
+        },
+    };
+}
+function emitKernelEnterAudit(input) {
+    if (!input.plan.flags.auditUnified)
+        return true;
+    try {
+        emitUokAuditEvent(input.basePath, buildAuditEnvelope({
+            traceId: input.plan.traceId,
             category: "orchestration",
             type: "uok-kernel-enter",
             payload: {
-                flags,
-                sessionId: ctx.sessionManager?.getSessionId?.(),
+                flags: input.plan.flags,
+                sessionId: input.sessionId,
             },
         }));
+        return true;
     }
-    const decoratedDeps = flags.enabled
-        ? {
-            ...deps,
-            uokObserver: createTurnObserver({
-                basePath: s.basePath,
-                gitAction: flags.gitopsTurnAction,
-                gitPush: flags.gitopsTurnPush,
-                enableAudit: flags.auditUnified,
-                enableGitops: flags.gitops,
-            }),
-        }
-        : deps;
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        writeParityEvent(input.basePath, {
+            ts: new Date().toISOString(),
+            path: input.plan.pathLabel,
+            flags: input.plan.flags,
+            phase: "telemetry-error",
+            telemetry: "uok-kernel-enter",
+            error: errorMessage,
+        });
+        logWarning("db", `uok-kernel-enter audit emit failed (non-fatal): ${errorMessage}`);
+        return false;
+    }
+}
+function decorateLoopDepsForKernel(input) {
+    if (!input.plan.useKernel)
+        return input.deps;
+    return {
+        ...input.deps,
+        uokObserver: createTurnObserver({
+            basePath: input.basePath,
+            gitAction: input.plan.flags.gitopsTurnAction,
+            gitPush: input.plan.flags.gitopsTurnPush,
+            enableAudit: input.plan.flags.auditUnified && input.auditHealthy,
+            enableGitops: input.plan.flags.gitops,
+        }),
+    };
+}
+async function executeKernelRunPlan(input) {
+    if (input.plan.useKernel) {
+        await input.runKernelLoop(input.ctx, input.pi, input.s, input.kernelDeps);
+        return;
+    }
+    await input.runLegacyLoop(input.ctx, input.pi, input.s, input.deps);
+}
+export async function runAutoLoopWithUok(args) {
+    const { ctx, pi, s, deps, runKernelLoop, runLegacyLoop } = args;
+    const auditState = createKernelAuditStateController(s.basePath);
+    let plan = null;
     try {
-        if (flags.enabled) {
-            await runKernelLoop(ctx, pi, s, decoratedDeps);
-        }
-        else {
-            await runLegacyLoop(ctx, pi, s, deps);
+        plan = createUokKernelRunPlan({
+            preferences: deps.loadEffectiveGSDPreferences(),
+            autoStartTime: s.autoStartTime,
+        });
+        auditState.apply(plan.flags.auditUnified);
+        if (plan.pathLabel !== "uok-kernel") {
+            incrementLegacyTelemetry("legacy.uokFallbackUsed");
         }
         writeParityEvent(s.basePath, {
             ts: new Date().toISOString(),
-            path: pathLabel,
-            flags,
-            phase: "exit",
-            status: "ok",
+            path: plan.pathLabel,
+            flags: plan.flags,
+            phase: "enter",
+        });
+        const auditHealthy = emitKernelEnterAudit({
+            basePath: s.basePath,
+            plan,
+            sessionId: ctx.sessionManager?.getSessionId?.(),
+        });
+        auditState.apply(plan.flags.auditUnified && auditHealthy);
+        const kernelDeps = decorateLoopDepsForKernel({
+            deps,
+            basePath: s.basePath,
+            plan,
+            auditHealthy,
+        });
+        await executeKernelRunPlan({
+            plan,
+            ctx,
+            pi,
+            s,
+            deps,
+            kernelDeps,
+            runKernelLoop,
+            runLegacyLoop,
         });
-    }
-    catch (err) {
         writeParityEvent(s.basePath, {
             ts: new Date().toISOString(),
-            path: pathLabel,
-            flags,
+            path: plan.pathLabel,
+            flags: plan.flags,
             phase: "exit",
-            status: "error",
-            error: err instanceof Error ? err.message : String(err),
+            status: "ok",
         });
+    }
+    catch (err) {
+        if (plan) {
+            writeParityEvent(s.basePath, {
+                ts: new Date().toISOString(),
+                path: plan.pathLabel,
+                flags: plan.flags,
+                phase: "exit",
+                status: "error",
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
         throw err;
     }
+    finally {
+        auditState.restore();
+    }
 }

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

@@ -1,5 +1,6 @@
 import { computeTaskRequirements, filterToolsForProvider } from "../model-router.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
+import { isUnifiedAuditEnabled } from "./audit-toggle.js";
 export function buildRequirementVector(unitType, taskMetadata) {
     if (!unitType)
         return {};
@@ -41,20 +42,22 @@ export function applyModelPolicyFilter(candidates, options) {
             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 (isUnifiedAuditEnabled(options.basePath)) {
+            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);
     }

package/dist/resources/extensions/gsd/validation-block-guard.js

@@ -1,7 +1,8 @@
 // Project/App: gsd-pi
 // File Purpose: Shared command gate for validation-blocked milestones.
 import { existsSync } from "node:fs";
-import { getAutoWorktreePath, isInAutoWorktree } from "./auto-worktree.js";
+import { isInAutoWorktree } from "./auto-worktree-entry.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { getIsolationMode } from "./preferences.js";

package/dist/resources/extensions/gsd/workflow-event-ledger.js

@@ -66,7 +66,7 @@ export function writeWorktreeEventLog(worktreeBasePath, events) {
     atomicWriteSync(logPath, content);
 }
 function emitWorkflowEventAudit(basePath, event) {
-    if (!isUnifiedAuditEnabled())
+    if (!isUnifiedAuditEnabled(basePath))
         return;
     try {
         const normalized = normalizeWorkflowEventCommand(event.cmd) ?? "unknown";

package/dist/resources/extensions/gsd/workflow-logger.js

@@ -209,7 +209,7 @@ function _push(severity, component, message, context) {
     if (_buffer.length > MAX_BUFFER) {
         _buffer.shift();
     }
-    if (_auditBasePath && isUnifiedAuditEnabled()) {
+    if (_auditBasePath && isUnifiedAuditEnabled(_auditBasePath)) {
         try {
             emitUokAuditEvent(_auditBasePath, buildAuditEnvelope({
                 traceId: `workflow-log:${component}`,