gsd-pi 2.74.0 → 2.75.0-dev.2203010a0

package/dist/resources/extensions/gsd/slice-parallel-orchestrator.js

@@ -21,6 +21,7 @@ import { createWorktree, worktreePath, removeWorktree } from "./worktree-manager
 import { writeSessionStatus, } from "./session-status-io.js";
 import { hasFileConflict } from "./slice-parallel-conflict.js";
 import { getErrorMessage } from "./error-utils.js";
+import { selectConflictFreeBatch } from "./uok/execution-graph.js";
 // ─── Module State ──────────────────────────────────────────────────────────
 let sliceState = null;
 // ─── Public API ────────────────────────────────────────────────────────────
@@ -62,7 +63,7 @@ export async function startSliceParallel(basePath, milestoneId, eligibleSlices,
     const started = [];
     const errors = [];
     // Filter out conflicting slices (conservative: check all pairs)
-    const safeSlices = filterConflictingSlices(basePath, milestoneId, eligibleSlices);
+    const safeSlices = filterConflictingSlices(basePath, milestoneId, eligibleSlices, opts.useExecutionGraph === true);
     // Limit to maxWorkers
     const toSpawn = safeSlices.slice(0, maxWorkers);
     for (const slice of toSpawn) {
@@ -176,7 +177,16 @@ export function resetSliceOrchestrator() {
  * Greedy: add slices to the safe set in order; skip any that conflict
  * with an already-included slice.
  */
-function filterConflictingSlices(basePath, milestoneId, slices) {
+function filterConflictingSlices(basePath, milestoneId, slices, useExecutionGraph) {
+    if (useExecutionGraph) {
+        const selectedIds = selectConflictFreeBatch({
+            orderedIds: slices.map((slice) => slice.id),
+            maxParallel: slices.length,
+            hasConflict: (candidate, existing) => hasFileConflict(basePath, milestoneId, candidate, existing),
+        });
+        const selected = new Set(selectedIds);
+        return slices.filter((slice) => selected.has(slice.id));
+    }
     const safe = [];
     for (const candidate of slices) {
         let conflictsWithSafe = false;

package/dist/resources/extensions/gsd/state.js

@@ -13,7 +13,9 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
 import { logWarning, logError } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
-import { isDbAvailable, wasDbOpenAttempted, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, insertTask, updateSliceStatus, updateTaskStatus, getPendingGateCountForTurn, } from './gsd-db.js';
+import { loadEffectiveGSDPreferences } from './preferences.js';
+import { detectPendingEscalation } from './escalation.js';
+import { isDbAvailable, wasDbOpenAttempted, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, insertTask, updateSliceStatus, updateTaskStatus, getPendingGateCountForTurn, autoHealSketchFlags, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
  * files like CONTEXT, CONTEXT-DRAFT, ROADMAP, or SUMMARY).  These appear when
@@ -271,7 +273,11 @@ function reconcileDiskToDb(basePath) {
         try {
             roadmapContent = readFileSync(roadmapPath, "utf-8");
         }
-        catch {
+        catch (err) {
+            logWarning("state", "reconcileDiskToDb: roadmap read failed, skipping milestone", {
+                mid,
+                error: err.message,
+            });
             continue;
         }
         const parsed = parseRoadmap(roadmapContent);
@@ -706,7 +712,13 @@ export async function deriveStateFromDb(basePath) {
     if (allSlicesDone) {
         return handleAllSlicesDone(basePath, activeMilestone, registry, requirements, milestoneProgress, sliceProgress);
     }
-    const activeSliceContext = resolveSliceDependencies(activeMilestoneSlices);
+    // ADR-011 auto-heal: if a slice has a PLAN on disk but is still flagged is_sketch=1
+    // (e.g. a crash between plan-slice write and the sketch flip), reconcile before
+    // running phase derivation so the flag doesn't misroute state.
+    autoHealSketchFlags(activeMilestone.id, (sid) => !!resolveSliceFile(basePath, activeMilestone.id, sid, "PLAN"));
+    // Re-read slices after auto-heal so downstream reads see fresh is_sketch values.
+    const healedSlices = getMilestoneSlices(activeMilestone.id);
+    const activeSliceContext = resolveSliceDependencies(healedSlices);
     if (!activeSliceContext.activeSlice) {
         // If locked slice wasn't found, it returns null but logs warning, we need to return 'blocked'
         if (process.env.GSD_SLICE_LOCK) {
@@ -726,9 +738,23 @@ export async function deriveStateFromDb(basePath) {
             progress: { milestones: milestoneProgress, slices: sliceProgress },
         };
     }
-    const { activeSlice } = activeSliceContext;
+    const { activeSlice, activeSliceRow } = activeSliceContext;
     const planFile = resolveSliceFile(basePath, activeMilestone.id, activeSlice.id, "PLAN");
     if (!planFile) {
+        // ADR-011: sketch slices with progressive_planning enabled enter the
+        // `refining` phase — a refine-slice unit expands the sketch into a full plan
+        // before execution. When the flag is off, sketches are indistinguishable
+        // from a missing plan and fall through to the normal `planning` phase.
+        const progressive = loadEffectiveGSDPreferences()?.preferences?.phases?.progressive_planning === true;
+        if (progressive && activeSliceRow?.is_sketch === 1) {
+            return {
+                activeMilestone, activeSlice, activeTask: null,
+                phase: 'refining', recentDecisions: [], blockers: [],
+                nextAction: `Refine sketch slice ${activeSlice.id} (${activeSlice.title}) using prior slice context.`,
+                registry, requirements,
+                progress: { milestones: milestoneProgress, slices: sliceProgress },
+            };
+        }
         return {
             activeMilestone, activeSlice, activeTask: null,
             phase: 'planning', recentDecisions: [], blockers: [],
@@ -807,6 +833,28 @@ export async function deriveStateFromDb(basePath) {
             };
         }
     }
+    // ADR-011 Phase 2: pause-on-escalation takes precedence over dispatching the
+    // next task. `awaiting_review` tasks (continueWithDefault=true) are NOT
+    // surfaced here — they let the loop continue.
+    //
+    // We do NOT gate this on `phases.mid_execution_escalation` — creation of
+    // new escalations is gated at the write site (tools/complete-task.ts:315),
+    // but any escalation_pending row already persisted in the DB must be
+    // honored even if the user later toggles the flag off. Otherwise those
+    // rows would silently orphan, the loop would advance past the paused task,
+    // and the user's prior resolution never lands.
+    const escalatingTaskId = detectPendingEscalation(tasks, basePath);
+    if (escalatingTaskId) {
+        return {
+            activeMilestone, activeSlice, activeTask,
+            phase: 'escalating-task', recentDecisions: [],
+            blockers: [`Task ${escalatingTaskId} requires a user decision before the loop can proceed`],
+            nextAction: `Run /gsd escalate show ${escalatingTaskId} to review, then /gsd escalate resolve ${escalatingTaskId} <choice> to proceed.`,
+            activeWorkspace: undefined,
+            registry, requirements,
+            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
+        };
+    }
     if (!blockerTaskId) {
         const isTriggered = checkReplanTrigger(basePath, activeMilestone.id, activeSlice.id);
         if (isTriggered) {

package/dist/resources/extensions/gsd/templates/PREFERENCES.md

@@ -39,6 +39,24 @@ dynamic_routing:
   budget_pressure:
   cross_provider:
   hooks:
+uok:
+  enabled: true
+  legacy_fallback:
+    enabled: false
+  gates:
+    enabled: true
+  model_policy:
+    enabled: true
+  execution_graph:
+    enabled: true
+  gitops:
+    enabled: true
+    turn_action: commit
+    turn_push: false
+  audit_unified:
+    enabled: true
+  plan_v2:
+    enabled: true
 auto_visualize:
 auto_report:
 parallel:
@@ -71,6 +89,7 @@ remote_questions:
 uat_dispatch:
 post_unit_hooks: []
 pre_dispatch_hooks: []
+# language:
 # experimental:
 #   rtk: false
 ---

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -354,6 +354,26 @@ export async function handleCompleteSlice(params, basePath) {
     catch (eventErr) {
         logError("tool", `complete-slice event log FAILED — completion invisible to reconciliation`, { error: eventErr.message });
     }
+    // Fire-and-forget graph rebuild — must NOT await, must NOT crash slice completion.
+    // Dynamic import of the package name (not a relative path) so it resolves
+    // correctly via package.json#exports in both development and production.
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    (async () => {
+        try {
+            const graphMod = await import("@gsd-build/mcp-server");
+            if (typeof graphMod.buildGraph !== "function"
+                || typeof graphMod.writeGraph !== "function"
+                || typeof graphMod.resolveGsdRoot !== "function") {
+                throw new Error("graph helpers unavailable from @gsd-build/mcp-server");
+            }
+            const g = await graphMod.buildGraph(basePath);
+            await graphMod.writeGraph(graphMod.resolveGsdRoot(basePath), g);
+        }
+        catch (graphErr) {
+            // Graph rebuild is best-effort — log at warning level but never propagate
+            logWarning("tool", `complete-slice graph rebuild failed (non-fatal): ${graphErr.message ?? String(graphErr)}`);
+        }
+    })();
     return {
         sliceId: params.sliceId,
         milestoneId: params.milestoneId,

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -20,6 +20,8 @@ import { renderAllProjections, renderSummaryContent } from "../workflow-projecti
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+import { buildEscalationArtifact, writeEscalationArtifact } from "../escalation.js";
 /**
  * Map an execute-task-owned gate id to the CompleteTaskParams field whose
  * presence drives `pass` vs. `omitted`. Keep in lockstep with the gates
@@ -80,6 +82,11 @@ function paramsToTaskRow(params, completedAt) {
         observability_impact: "",
         full_plan_md: "",
         sequence: 0,
+        blocker_source: "",
+        escalation_pending: 0,
+        escalation_awaiting_review: 0,
+        escalation_artifact_path: null,
+        escalation_override_applied_at: null,
     };
 }
 /**
@@ -111,6 +118,39 @@ export async function handleCompleteTask(params, basePath) {
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     const completedAt = new Date().toISOString();
     let guardError = null;
+    // ── ADR-011 Phase 2: validate escalation payload BEFORE any side effects ─
+    // Building the artifact runs the full shape validation (2-4 options, unique
+    // ids, recommendation references a real id). If the payload is malformed
+    // we must reject the call before marking the task complete, writing
+    // SUMMARY.md, flipping the plan checkbox, or closing execute-task gates —
+    // otherwise a rejected payload would leave the task marked complete with
+    // no escalation recorded, and the loop would silently advance past it.
+    // The filesystem write happens later (after side effects) because that's
+    // the cheapest ordering and validation is where 99% of failures live.
+    let validatedEscalationArtifact = null;
+    let escalationWriteEnabled = false;
+    if (params.escalation) {
+        escalationWriteEnabled = loadEffectiveGSDPreferences()?.preferences?.phases?.mid_execution_escalation === true;
+        if (escalationWriteEnabled) {
+            try {
+                validatedEscalationArtifact = buildEscalationArtifact({
+                    taskId: params.taskId,
+                    sliceId: params.sliceId,
+                    milestoneId: params.milestoneId,
+                    question: params.escalation.question,
+                    options: params.escalation.options,
+                    recommendation: params.escalation.recommendation,
+                    recommendationRationale: params.escalation.recommendationRationale,
+                    continueWithDefault: params.escalation.continueWithDefault,
+                });
+            }
+            catch (validationErr) {
+                return {
+                    error: `complete-task escalation payload invalid for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${validationErr.message}`,
+                };
+            }
+        }
+    }
     transaction(() => {
         // State machine preconditions (inside txn for atomicity).
         // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
@@ -239,6 +279,46 @@ export async function handleCompleteTask(params, basePath) {
     catch (gateErr) {
         logWarning("tool", `complete-task gate close warning for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${gateErr.message}`);
     }
+    // ── ADR-011 Phase 2: write escalation artifact (opt-in) ────────────────
+    // Validation already happened BEFORE side effects — this block only
+    // performs the disk write for a pre-validated artifact. For
+    // continueWithDefault=false, a write failure here would otherwise leave
+    // the task marked complete with SUMMARY.md + closed gates but no
+    // escalation, which silently advances the loop past a pause the user
+    // asked for. We compensate by reverting the DB-level completion: set
+    // status back to 'pending' and delete the verification_evidence rows
+    // (same shape as the disk-render-failure rollback above). SUMMARY.md
+    // on disk is left in place because the next complete-task retry will
+    // overwrite it; gate rows are UPSERT-keyed per task and will also be
+    // overwritten. This restores the invariant that deriveState() sees a
+    // consistent "task not done" view so the loop re-dispatches the task.
+    if (validatedEscalationArtifact) {
+        try {
+            writeEscalationArtifact(basePath, validatedEscalationArtifact);
+        }
+        catch (escalationErr) {
+            const msg = `complete-task escalation write failed for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${escalationErr.message}`;
+            logWarning("tool", msg);
+            if (validatedEscalationArtifact.continueWithDefault === false) {
+                // Compensating rollback: revert DB completion so the loop pauses on
+                // re-dispatch instead of silently advancing. Mirror the existing
+                // renderErr rollback (line ~261).
+                try {
+                    deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
+                    updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, 'pending');
+                    invalidateStateCache();
+                    logWarning("tool", `complete-task rolled back DB completion for ${params.milestoneId}/${params.sliceId}/${params.taskId} after escalation write failure; SUMMARY.md left on disk for retry.`);
+                }
+                catch (rollbackErr) {
+                    logWarning("tool", `complete-task rollback failed after escalation write failure for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${rollbackErr.message}`);
+                }
+                return { error: msg };
+            }
+        }
+    }
+    else if (params.escalation && !escalationWriteEnabled) {
+        logWarning("tool", `complete-task received escalation payload but phases.mid_execution_escalation is not enabled; ignoring (${params.milestoneId}/${params.sliceId}/${params.taskId})`);
+    }
     // Invalidate all caches
     invalidateStateCache();
     clearPathCache();

package/dist/resources/extensions/gsd/tools/plan-milestone.js

@@ -61,6 +61,15 @@ function validateSlices(value) {
         const proofLevel = obj.proofLevel;
         const integrationClosure = obj.integrationClosure;
         const observabilityImpact = obj.observabilityImpact;
+        const isSketchRaw = obj.isSketch;
+        const sketchScopeRaw = obj.sketchScope;
+        // ADR-011: preserve the 3-valued semantics of isSketch (true / false / absent).
+        // Callers that omit isSketch must receive `undefined` here so `insertSlice`'s
+        // ON CONFLICT clause preserves any existing is_sketch on the row rather than
+        // silently overwriting a legitimate sketch to non-sketch.
+        const isSketch = isSketchRaw === true ? true
+            : isSketchRaw === false ? false
+                : undefined;
         if (!isNonEmptyString(sliceId))
             throw new Error(`slices[${index}].sliceId must be a non-empty string`);
         if (seen.has(sliceId))
@@ -77,14 +86,22 @@ function validateSlices(value) {
             throw new Error(`slices[${index}].demo must be a non-empty string`);
         if (!isNonEmptyString(goal))
             throw new Error(`slices[${index}].goal must be a non-empty string`);
-        if (!isNonEmptyString(successCriteria))
-            throw new Error(`slices[${index}].successCriteria must be a non-empty string`);
-        if (!isNonEmptyString(proofLevel))
-            throw new Error(`slices[${index}].proofLevel must be a non-empty string`);
-        if (!isNonEmptyString(integrationClosure))
-            throw new Error(`slices[${index}].integrationClosure must be a non-empty string`);
-        if (!isNonEmptyString(observabilityImpact))
-            throw new Error(`slices[${index}].observabilityImpact must be a non-empty string`);
+        // ADR-011: sketch slices may defer the heavyweight planning fields to refine-slice.
+        if (isSketch === true) {
+            if (!isNonEmptyString(sketchScopeRaw)) {
+                throw new Error(`slices[${index}].sketchScope must be a non-empty string when isSketch is true`);
+            }
+        }
+        else {
+            if (!isNonEmptyString(successCriteria))
+                throw new Error(`slices[${index}].successCriteria must be a non-empty string`);
+            if (!isNonEmptyString(proofLevel))
+                throw new Error(`slices[${index}].proofLevel must be a non-empty string`);
+            if (!isNonEmptyString(integrationClosure))
+                throw new Error(`slices[${index}].integrationClosure must be a non-empty string`);
+            if (!isNonEmptyString(observabilityImpact))
+                throw new Error(`slices[${index}].observabilityImpact must be a non-empty string`);
+        }
         return {
             sliceId,
             title,
@@ -92,10 +109,14 @@ function validateSlices(value) {
             depends,
             demo,
             goal,
-            successCriteria,
-            proofLevel,
-            integrationClosure,
-            observabilityImpact,
+            successCriteria: isNonEmptyString(successCriteria) ? successCriteria : "",
+            proofLevel: isNonEmptyString(proofLevel) ? proofLevel : "",
+            integrationClosure: isNonEmptyString(integrationClosure) ? integrationClosure : "",
+            observabilityImpact: isNonEmptyString(observabilityImpact) ? observabilityImpact : "",
+            isSketch,
+            // Only carry the sketch scope through if the caller explicitly provided it
+            // — preserves ON CONFLICT semantics for re-plans that omit the field.
+            sketchScope: sketchScopeRaw === undefined ? undefined : (isNonEmptyString(sketchScopeRaw) ? sketchScopeRaw : ""),
         };
     });
 }
@@ -209,6 +230,10 @@ export async function handlePlanMilestone(rawParams, basePath) {
                     depends: slice.depends,
                     demo: slice.demo,
                     sequence: i + 1, // Preserve agent-ordered sequence (#3356)
+                    // ADR-011: pass undefined through so ON CONFLICT preserves existing values
+                    // when the caller omitted the fields on a re-plan.
+                    isSketch: slice.isSketch,
+                    sketchScope: slice.sketchScope,
                 });
                 upsertSlicePlanning(params.milestoneId, slice.sliceId, {
                     goal: slice.goal,

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -1,7 +1,7 @@
 import { clearParseCache } from "../files.js";
-import { isClosedStatus } from "../status-guards.js";
+import { isClosedStatus, isDeferredStatus } from "../status-guards.js";
 import { isNonEmptyString } from "../validation.js";
-import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, } from "../gsd-db.js";
+import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -114,6 +114,9 @@ export async function handlePlanSlice(rawParams, basePath) {
                 guardError = `cannot re-plan slice ${params.sliceId}: it is already complete — use gsd_slice_reopen first`;
                 return;
             }
+            if (isDeferredStatus(parentSlice.status)) {
+                updateSliceStatus(params.milestoneId, params.sliceId, "pending");
+            }
             upsertSlicePlanning(params.milestoneId, params.sliceId, {
                 goal: params.goal,
                 successCriteria: params.successCriteria,

package/dist/resources/extensions/gsd/tools/validate-milestone.js

@@ -16,6 +16,9 @@ import { invalidateStateCache } from "../state.js";
 import { VALIDATION_VERDICTS, isValidMilestoneVerdict } from "../verdict-parser.js";
 import { insertMilestoneValidationGates } from "../milestone-validation-gates.js";
 import { logWarning } from "../workflow-logger.js";
+import { UokGateRunner } from "../uok/gate-runner.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+import { resolveUokFlags } from "../uok/flags.js";
 function renderValidationMarkdown(params) {
     let md = `---
 verdict: ${params.verdict}
@@ -48,7 +51,7 @@ ${params.verdictRationale}
     }
     return md;
 }
-export async function handleValidateMilestone(params, basePath) {
+export async function handleValidateMilestone(params, basePath, opts) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
@@ -73,6 +76,8 @@ export async function handleValidateMilestone(params, basePath) {
     // rendering can regenerate. The inverse (file exists, no DB row) is
     // harder to detect and recover from (#2725).
     const validatedAt = new Date().toISOString();
+    const slices = getMilestoneSlices(params.milestoneId);
+    const gateSliceId = slices.length > 0 ? slices[0].id : "_milestone";
     transaction(() => {
         insertAssessment({
             path: validationPath,
@@ -86,9 +91,7 @@ export async function handleValidateMilestone(params, basePath) {
         // #2945 Bug 4: persist quality_gates records alongside the assessment.
         // Previously only the assessment was written, leaving M002+ milestones
         // with zero quality_gate records despite passing validation.
-        const slices = getMilestoneSlices(params.milestoneId);
-        const sliceId = slices.length > 0 ? slices[0].id : "_milestone";
-        insertMilestoneValidationGates(params.milestoneId, sliceId, params.verdict, validatedAt);
+        insertMilestoneValidationGates(params.milestoneId, gateSliceId, params.verdict, validatedAt);
     });
     // ── Filesystem render (outside transaction) ────────────────────────────
     // If disk render fails, roll back the DB row so state stays consistent.
@@ -103,6 +106,38 @@ export async function handleValidateMilestone(params, basePath) {
     invalidateStateCache();
     clearPathCache();
     clearParseCache();
+    const prefs = loadEffectiveGSDPreferences()?.preferences;
+    const gatesEnabled = opts?.uokGatesEnabled ?? resolveUokFlags(prefs).gates;
+    if (gatesEnabled) {
+        try {
+            const gateRunner = new UokGateRunner();
+            const nonPassVerdict = params.verdict !== "pass";
+            gateRunner.register({
+                id: "milestone-validation-gates",
+                type: "verification",
+                execute: async () => ({
+                    outcome: nonPassVerdict ? "manual-attention" : "pass",
+                    failureClass: nonPassVerdict ? "manual-attention" : "none",
+                    rationale: `milestone validation verdict: ${params.verdict}`,
+                    findings: nonPassVerdict
+                        ? [params.verdictRationale, params.remediationPlan ?? ""].filter(Boolean).join("\n")
+                        : "",
+                }),
+            });
+            await gateRunner.run("milestone-validation-gates", {
+                basePath,
+                traceId: opts?.traceId ?? `validate-milestone:${params.milestoneId}`,
+                turnId: opts?.turnId ?? `${params.milestoneId}:validate`,
+                milestoneId: params.milestoneId,
+                sliceId: gateSliceId,
+                unitType: "validate-milestone",
+                unitId: params.milestoneId,
+            });
+        }
+        catch (err) {
+            logWarning("tool", `validate_milestone — failed to persist UOK gate result: ${err.message}`);
+        }
+    }
     return {
         milestoneId: params.milestoneId,
         verdict: params.verdict,

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

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

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

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

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

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

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

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

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

@@ -0,0 +1,40 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { gsdRoot } from "../paths.js";
+import { isDbAvailable, insertAuditEvent } from "../gsd-db.js";
+function auditLogPath(basePath) {
+    return join(gsdRoot(basePath), "audit", "events.jsonl");
+}
+function ensureAuditDir(basePath) {
+    mkdirSync(join(gsdRoot(basePath), "audit"), { recursive: true });
+}
+export function buildAuditEnvelope(args) {
+    return {
+        eventId: randomUUID(),
+        traceId: args.traceId,
+        turnId: args.turnId,
+        causedBy: args.causedBy,
+        category: args.category,
+        type: args.type,
+        ts: new Date().toISOString(),
+        payload: args.payload ?? {},
+    };
+}
+export function emitUokAuditEvent(basePath, event) {
+    try {
+        ensureAuditDir(basePath);
+        appendFileSync(auditLogPath(basePath), `${JSON.stringify(event)}\n`, "utf-8");
+    }
+    catch {
+        // Best-effort: audit writes must never break orchestration.
+    }
+    if (!isDbAvailable())
+        return;
+    try {
+        insertAuditEvent(event);
+    }
+    catch {
+        // Projection failures are non-fatal while legacy readers are still active.
+    }
+}

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

@@ -0,0 +1 @@
+export {};