gsd-pi 2.79.0 → 2.80.0

package/dist/resources/extensions/gsd/post-execution-checks.js

@@ -96,12 +96,25 @@ export function resolveImportPath(importPath, sourceFile, basePath) {
         if (existsSync(directPath)) {
             return { exists: true, resolvedPath: directPath };
         }
-        // Only .js/.jsx/.mjs/.cjs imports legitimately fall through for the TS
-        // ESM convention (.js → .ts). Any other explicit extension (.css, .json,
-        // .svg, images, fonts, .ts, .tsx, …) must stay unresolved when the direct
-        // path is missing — otherwise a stray `./missing.css.ts` could shadow a
-        // genuinely missing `./missing.css` import.
-        if (![".js", ".jsx", ".mjs", ".cjs"].includes(explicitExt)) {
+        // Known concrete extensions that should NOT fall through to code-shadow
+        // probing when missing. This preserves the "missing.css must stay missing"
+        // guarantee while still allowing dotted module stems like ./route.server
+        // to resolve as ./route.server.ts.
+        const nonFallbackExtensions = new Set([
+            ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+            ".json", ".css", ".scss", ".sass", ".less", ".styl",
+            ".svg", ".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif", ".ico", ".bmp",
+            ".woff", ".woff2", ".ttf", ".otf", ".eot",
+        ]);
+        const runtimeFallbackExtensions = new Set([".js", ".jsx", ".mjs", ".cjs"]);
+        const dottedStemFallbackExtensions = new Set([".server", ".client", ".webhook"]);
+        if (explicitExt !== "" &&
+            !runtimeFallbackExtensions.has(explicitExt) &&
+            !nonFallbackExtensions.has(explicitExt) &&
+            !dottedStemFallbackExtensions.has(explicitExt)) {
+            return { exists: false, resolvedPath: null };
+        }
+        if (nonFallbackExtensions.has(explicitExt) && !runtimeFallbackExtensions.has(explicitExt)) {
             return { exists: false, resolvedPath: null };
         }
     }
@@ -163,6 +176,12 @@ export function checkImportResolution(taskRow, _priorTasks, basePath) {
         }
         const imports = extractRelativeImports(source);
         for (const { importPath, lineNum } of imports) {
+            // React Router generated +types modules may not exist on disk during
+            // post-exec checks (generated during framework build). Don't block task
+            // completion on these imports.
+            if (/^\.{1,2}\/\+types\//.test(importPath)) {
+                continue;
+            }
             const resolution = resolveImportPath(importPath, file, basePath);
             if (!resolution.exists) {
                 results.push({

package/dist/resources/extensions/gsd/preferences-types.js

@@ -100,8 +100,26 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "context_mode",
     "planning_depth",
 ]);
-/** Canonical list of all dispatch unit types. */
-export const KNOWN_UNIT_TYPES = [
+/**
+ * Broad union of every recognized unit-type *label* used across the codebase.
+ *
+ * This intentionally covers more than the manifest-tracked dispatch units in
+ * `unit-context-manifest.ts:KNOWN_UNIT_TYPES`. Examples that live here but not
+ * in the manifest:
+ * - `discuss-slice` — dispatched by `guided-flow.ts` rather than auto-mode;
+ *   composer falls through to default behavior via `resolveManifest()` null path.
+ * - `worktree-merge` — used as a model-routing case, prompt-template name, and
+ *   commit-message label, not as an LLM-dispatched unit.
+ *
+ * Used by `preferences-validation.ts` to validate user-provided unit-type
+ * references in preferences (model overrides, skill rules, etc.) — preferences
+ * may legitimately reference any label, including non-dispatched ones.
+ *
+ * The manifest-strict subset lives in `unit-context-manifest.ts:KNOWN_UNIT_TYPES`
+ * and is enforced 1:1 against `UNIT_MANIFESTS` by the parity test in
+ * `tests/unit-context-manifest.test.ts`.
+ */
+export const KNOWN_UNIT_LABELS = [
     "research-milestone", "plan-milestone", "research-slice", "plan-slice", "refine-slice",
     "execute-task", "reactive-execute", "gate-evaluate", "complete-slice", "replan-slice", "reassess-roadmap",
     "run-uat", "complete-milestone", "validate-milestone", "rewrite-docs",

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -7,7 +7,7 @@
  */
 import { VALID_BRANCH_NAME } from "./git-service.js";
 import { normalizeStringArray } from "../shared/format-utils.js";
-import { KNOWN_PREFERENCE_KEYS, KNOWN_UNIT_TYPES, SKILL_ACTIONS, } from "./preferences-types.js";
+import { KNOWN_PREFERENCE_KEYS, KNOWN_UNIT_LABELS, SKILL_ACTIONS, } from "./preferences-types.js";
 const VALID_TOKEN_PROFILES = new Set(["budget", "balanced", "quality", "burn-max"]);
 const VALID_UOK_TURN_ACTIONS = new Set([
     "commit",
@@ -432,7 +432,7 @@ export function validatePreferences(preferences) {
     if (preferences.post_unit_hooks && Array.isArray(preferences.post_unit_hooks)) {
         const validHooks = [];
         const seenNames = new Set();
-        const knownUnitTypes = new Set(KNOWN_UNIT_TYPES);
+        const knownUnitTypes = new Set(KNOWN_UNIT_LABELS);
         for (const hook of preferences.post_unit_hooks) {
             if (!hook || typeof hook !== "object") {
                 errors.push("post_unit_hooks entry must be an object");
@@ -493,7 +493,7 @@ export function validatePreferences(preferences) {
     if (preferences.pre_dispatch_hooks && Array.isArray(preferences.pre_dispatch_hooks)) {
         const validPreHooks = [];
         const seenPreNames = new Set();
-        const knownUnitTypes = new Set(KNOWN_UNIT_TYPES);
+        const knownUnitTypes = new Set(KNOWN_UNIT_LABELS);
         const validActions = new Set(["modify", "skip", "replace"]);
         for (const hook of preferences.pre_dispatch_hooks) {
             if (!hook || typeof hook !== "object") {

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, shouldBlockRootArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
-import { getActiveRequirements, getMilestone, getSliceStatusSummary, getSliceTaskCounts, readTransaction, saveGateResult, } from "../gsd-db.js";
+import { getActiveRequirements, insertMilestone, getMilestone, getSliceStatusSummary, getSliceTaskCounts, readTransaction, saveGateResult, } from "../gsd-db.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
 import { generateRequirementsMd, saveArtifactToDb } from "../db-writer.js";
 import { resolveMilestoneFile, resolveSliceFile } from "../paths.js";
@@ -17,6 +17,7 @@ import { handleValidateMilestone } from "./validate-milestone.js";
 import { logError, logWarning } from "../workflow-logger.js";
 import { invalidateStateCache } from "../state.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
+import { parseProject } from "../schemas/parsers.js";
 export const SUPPORTED_SUMMARY_ARTIFACT_TYPES = [
     "SUMMARY",
     "RESEARCH",
@@ -37,6 +38,19 @@ function isRootSummaryArtifactType(artifactType) {
         artifactType === "REQUIREMENTS" ||
         artifactType === "REQUIREMENTS-DRAFT";
 }
+function registerProjectMilestoneSequence(content) {
+    const parsed = parseProject(content);
+    const registered = [];
+    for (const milestone of parsed.milestones) {
+        insertMilestone({
+            id: milestone.id,
+            title: milestone.title,
+            status: milestone.done ? "complete" : "queued",
+        });
+        registered.push(milestone.id);
+    }
+    return registered;
+}
 export async function executeSummarySave(params, basePath = process.cwd()) {
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable) {
@@ -126,6 +140,66 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
             slice_id: isRootArtifact ? undefined : params.slice_id,
             task_id: isRootArtifact ? undefined : params.task_id,
         }, basePath);
+        let registeredMilestones = [];
+        if (params.artifact_type === "PROJECT") {
+            try {
+                registeredMilestones = registerProjectMilestoneSequence(contentToSave);
+                if (registeredMilestones.length > 0)
+                    invalidateStateCache();
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logError("tool", `gsd_summary_save: PROJECT artifact persisted but milestone registration threw: ${msg}`, {
+                    tool: "gsd_summary_save",
+                    error: String(err),
+                    stack: err instanceof Error ? err.stack ?? "" : "",
+                });
+                // PROJECT.md was persisted by saveArtifactToDb above; the artifacts row
+                // changed even though no milestones registered. Invalidate so subsequent
+                // /gsd reads see the persisted artifact instead of the pre-save cache.
+                invalidateStateCache();
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: PROJECT.md was saved to ${relativePath} but milestone registration failed: ${msg}. ` +
+                                `The DB has no milestone rows for this project, so /gsd will report "No Active Milestone". ` +
+                                `Re-call gsd_summary_save(PROJECT) once the underlying error is resolved — INSERT OR IGNORE makes registration idempotent.`,
+                        }],
+                    details: {
+                        operation: "save_summary",
+                        path: relativePath,
+                        artifact_type: params.artifact_type,
+                        error: "milestone_registration_threw",
+                        registration_error: msg,
+                    },
+                    isError: true,
+                };
+            }
+            if (registeredMilestones.length === 0) {
+                logError("tool", `gsd_summary_save: PROJECT.md saved to ${relativePath} but parsed zero milestones — registration produced no DB rows`, {
+                    tool: "gsd_summary_save",
+                });
+                // PROJECT.md was persisted; invalidate so subsequent reads see the new
+                // artifacts row even though no milestones registered.
+                invalidateStateCache();
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: PROJECT.md was saved to ${relativePath} but contains zero parseable milestone lines, ` +
+                                `so no milestones were registered in the DB. /gsd will report "No Active Milestone". ` +
+                                `Rewrite PROJECT.md so the "Milestone Sequence" section uses canonical lines: ` +
+                                `\`- [ ] M001: <Title> — <One-liner>\` (em-dash, double-dash \`--\`, or single-dash \`-\` separator), then re-call gsd_summary_save(PROJECT).`,
+                        }],
+                    details: {
+                        operation: "save_summary",
+                        path: relativePath,
+                        artifact_type: params.artifact_type,
+                        error: "milestone_registration_empty_parse",
+                    },
+                    isError: true,
+                };
+            }
+        }
         if (params.artifact_type === "CONTEXT" && !params.task_id) {
             try {
                 const draftFile = params.slice_id
@@ -140,7 +214,13 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
         }
         return {
             content: [{ type: "text", text: `Saved ${params.artifact_type} artifact to ${relativePath}` }],
-            details: { operation: "save_summary", path: relativePath, artifact_type: params.artifact_type, content_source: contentSource },
+            details: {
+                operation: "save_summary",
+                path: relativePath,
+                artifact_type: params.artifact_type,
+                content_source: contentSource,
+                ...(registeredMilestones.length > 0 ? { registeredMilestones } : {}),
+            },
         };
     }
     catch (err) {

package/dist/resources/extensions/gsd/unit-context-composer.js

@@ -71,6 +71,38 @@ export function manifestBudgetChars(unitType) {
     const manifest = resolveManifest(unitType);
     return manifest ? manifest.maxSystemPromptChars : null;
 }
+const CONTEXT_MODE_LANE_LABELS = {
+    interview: "interview",
+    research: "research",
+    planning: "planning",
+    execution: "execution",
+    verification: "verification",
+    orchestration: "orchestration",
+    docs: "documentation",
+};
+const CONTEXT_MODE_GUIDANCE = "Use `gsd_exec` for noisy scans, builds, and tests so full output stays out of prompt context; call `gsd_exec_search` before repeating prior runs; call `gsd_resume` after compaction or resume to recover stored execution context.";
+/**
+ * Render the Context Mode instruction lane for a unit type. Unknown unit
+ * types, disabled config, and explicit `contextMode: "none"` all omit the
+ * block so callers can prefix this safely without extra branching.
+ */
+export function composeContextModeInstructions(unitType, opts) {
+    if (!opts.enabled)
+        return "";
+    const manifest = resolveManifest(unitType);
+    if (!manifest || manifest.contextMode === "none")
+        return "";
+    const lane = CONTEXT_MODE_LANE_LABELS[manifest.contextMode];
+    if (opts.renderMode === "nested") {
+        return `Context Mode (${lane} lane): ${CONTEXT_MODE_GUIDANCE}`;
+    }
+    return [
+        "## Context Mode",
+        "",
+        `Lane: **${lane} lane**.`,
+        CONTEXT_MODE_GUIDANCE,
+    ].join("\n");
+}
 const SECTION_SEPARATOR = "\n\n---\n\n";
 /**
  * Compose all manifest-declared context for a unit type using the v2

package/dist/resources/extensions/gsd/unit-context-manifest.js

@@ -137,6 +137,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "research",
         tools: TOOLS_PLANNING,
         artifacts: {
             // Phase 3 migration (#4782): matches today's actual
@@ -153,6 +154,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "planning",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["project", "requirements", "decisions", "milestone-research", "templates"],
@@ -167,6 +169,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "interview",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["project", "requirements", "decisions", "milestone-context", "templates"],
@@ -181,6 +184,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: false,
         preferences: "active-only",
+        contextMode: "verification",
         // planning-dispatch: validation is a verification-fan-out unit. It reads
         // the milestone surface and dispatches reviewer/security/tester subagents
         // to report findings without touching user source. Mirrors
@@ -199,6 +203,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: false,
         preferences: "active-only",
+        contextMode: "verification",
         // planning-dispatch: completion is a high-leverage place to fan out to
         // reviewer / security / tester subagents. They read the diff and report
         // findings; they do not write user source. Write isolation to .gsd/ is
@@ -221,6 +226,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "research",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["roadmap", "milestone-research", "dependency-summaries", "templates"],
@@ -235,6 +241,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "planning",
         // planning-dispatch: allows subagent dispatch so the planner can fan out
         // to scout for codebase recon and to planner/decompose-style specialists
         // for sub-decomposition. Write-isolation to .gsd/ is preserved.
@@ -252,6 +259,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "planning",
         // See plan-slice — same rationale: dispatch to scout/planner-style
         // specialists during refinement is materially better than re-doing recon
         // inline.
@@ -269,6 +277,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "planning",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["slice-plan", "slice-research", "dependency-summaries", "prior-task-summaries", "templates"],
@@ -283,6 +292,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: false,
         preferences: "active-only",
+        contextMode: "verification",
         // See complete-milestone — same rationale: dispatch to reviewer / security /
         // tester subagents to fan out review work without bloating this unit's
         // context.
@@ -304,6 +314,7 @@ export const UNIT_MANIFESTS = {
         memory: "critical-only",
         codebaseMap: false,
         preferences: "none",
+        contextMode: "planning",
         tools: TOOLS_PLANNING,
         artifacts: {
             // Phase 2 pilot (#4782): manifest now matches today's actual
@@ -322,6 +333,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "execution",
         tools: TOOLS_ALL,
         artifacts: {
             inline: ["task-plan", "slice-plan", "prior-task-summaries", "templates"],
@@ -336,6 +348,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "execution",
         tools: TOOLS_ALL,
         artifacts: {
             inline: ["slice-plan", "prior-task-summaries", "templates"],
@@ -351,6 +364,7 @@ export const UNIT_MANIFESTS = {
         memory: "critical-only",
         codebaseMap: false,
         preferences: "active-only",
+        contextMode: "verification",
         tools: TOOLS_PLANNING,
         artifacts: {
             // Phase 3 migration (#4782): manifest matches today's actual
@@ -369,6 +383,7 @@ export const UNIT_MANIFESTS = {
         memory: "critical-only",
         codebaseMap: false,
         preferences: "active-only",
+        contextMode: "verification",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["slice-plan", "prior-task-summaries"],
@@ -383,6 +398,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "docs",
         tools: TOOLS_DOCS,
         artifacts: {
             inline: ["project", "requirements", "decisions", "templates"],
@@ -401,6 +417,7 @@ export const UNIT_MANIFESTS = {
         memory: "none",
         codebaseMap: false,
         preferences: "none",
+        contextMode: "none",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: [],
@@ -418,6 +435,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "interview",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["templates"],
@@ -434,6 +452,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "interview",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: ["project", "templates"],
@@ -450,6 +469,7 @@ export const UNIT_MANIFESTS = {
         memory: "none",
         codebaseMap: false,
         preferences: "none",
+        contextMode: "none",
         tools: TOOLS_PLANNING,
         artifacts: {
             inline: [],
@@ -468,6 +488,7 @@ export const UNIT_MANIFESTS = {
         memory: "prompt-relevant",
         codebaseMap: true,
         preferences: "active-only",
+        contextMode: "research",
         tools: { mode: "planning-dispatch", allowedSubagents: ["scout"] },
         artifacts: {
             inline: ["project", "requirements", "templates"],

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

@@ -1,3 +1,4 @@
+// GSD2 UOK Audit Events and DB-First Projection Writes
 import { appendFileSync, closeSync, existsSync, mkdirSync, openSync } from "node:fs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -5,6 +6,7 @@ import { isStaleWrite } from "../auto/turn-epoch.js";
 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";
 function auditLogPath(basePath) {
     return join(gsdRoot(basePath), "audit", "events.jsonl");
 }
@@ -13,6 +15,7 @@ function ensureAuditDir(basePath) {
 }
 export function buildAuditEnvelope(args) {
     return {
+        version: CURRENT_UOK_CONTRACT_VERSION,
         eventId: randomUUID(),
         traceId: args.traceId,
         turnId: args.turnId,
@@ -27,6 +30,25 @@ export function emitUokAuditEvent(basePath, event) {
     // Drop writes from a turn superseded by timeout recovery / cancellation.
     if (isStaleWrite("uok-audit"))
         return;
+    const validation = validateAuditEvent(event);
+    if (!validation.ok) {
+        throw new Error(`Invalid UOK audit event: ${validation.issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`);
+    }
+    const canonical = validation.value;
+    if (isDbAvailable()) {
+        try {
+            insertAuditEvent({
+                ...canonical,
+                payload: {
+                    ...canonical.payload,
+                    contractVersion: canonical.version ?? CURRENT_UOK_CONTRACT_VERSION,
+                },
+            });
+        }
+        catch (err) {
+            throw new Error(`DB authoritative audit write failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     try {
         ensureAuditDir(basePath);
         const path = auditLogPath(basePath);
@@ -39,18 +61,10 @@ export function emitUokAuditEvent(basePath, event) {
         // POSIX O_APPEND atomicity still protects small line writes, so skipping
         // the lock rather than stalling orchestration is the correct tradeoff.
         withFileLockSync(path, () => {
-            appendFileSync(path, `${JSON.stringify(event)}\n`, "utf-8");
+            appendFileSync(path, `${JSON.stringify(canonical)}\n`, "utf-8");
         }, { onLocked: "skip" });
     }
     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

@@ -1 +1,69 @@
-export {};
+// GSD2 UOK Contract Types and Versioning
+export const CURRENT_UOK_CONTRACT_VERSION = "1";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeVersion(value) {
+    return value === CURRENT_UOK_CONTRACT_VERSION ? CURRENT_UOK_CONTRACT_VERSION : "0";
+}
+function requireString(value, key, issues) {
+    if (typeof value[key] !== "string" || value[key] === "") {
+        issues.push({ path: key, message: `${key} must be a non-empty string` });
+    }
+}
+function requireRecord(value, key, issues) {
+    if (!isRecord(value[key])) {
+        issues.push({ path: key, message: `${key} must be an object` });
+    }
+}
+export function normalizeTurnResult(value) {
+    return { ...value, version: normalizeVersion(value.version) };
+}
+export function normalizeDispatchEnvelope(value) {
+    return { ...value, version: normalizeVersion(value.version) };
+}
+export function normalizeAuditEvent(value) {
+    return { ...value, version: normalizeVersion(value.version) };
+}
+export function validateTurnResult(value) {
+    const normalized = normalizeTurnResult(value);
+    const record = normalized;
+    const issues = [];
+    requireString(record, "traceId", issues);
+    requireString(record, "turnId", issues);
+    if (!Number.isInteger(record.iteration)) {
+        issues.push({ path: "iteration", message: "iteration must be an integer" });
+    }
+    requireString(record, "status", issues);
+    requireString(record, "failureClass", issues);
+    if (!Array.isArray(record.phaseResults)) {
+        issues.push({ path: "phaseResults", message: "phaseResults must be an array" });
+    }
+    requireString(record, "startedAt", issues);
+    requireString(record, "finishedAt", issues);
+    return { ok: issues.length === 0, value: normalized, issues };
+}
+export function validateDispatchEnvelope(value) {
+    const normalized = normalizeDispatchEnvelope(value);
+    const record = normalized;
+    const issues = [];
+    requireString(record, "action", issues);
+    requireRecord(record, "reason", issues);
+    if (isRecord(record.reason)) {
+        requireString(record.reason, "reasonCode", issues);
+        requireString(record.reason, "summary", issues);
+    }
+    return { ok: issues.length === 0, value: normalized, issues };
+}
+export function validateAuditEvent(value) {
+    const normalized = normalizeAuditEvent(value);
+    const record = normalized;
+    const issues = [];
+    requireString(record, "eventId", issues);
+    requireString(record, "traceId", issues);
+    requireString(record, "category", issues);
+    requireString(record, "type", issues);
+    requireString(record, "ts", issues);
+    requireRecord(record, "payload", issues);
+    return { ok: issues.length === 0, value: normalized, issues };
+}

package/dist/resources/extensions/gsd/uok/dispatch-envelope.js

@@ -1,5 +1,8 @@
+// GSD2 UOK Dispatch Envelope Builder
+import { CURRENT_UOK_CONTRACT_VERSION } from "./contracts.js";
 export function buildDispatchEnvelope(input) {
     return {
+        version: CURRENT_UOK_CONTRACT_VERSION,
         action: input.action,
         nodeKind: input.node?.kind,
         unitType: input.unitType,