gsd-pi 2.74.0-dev.b741afb → 2.74.0-dev.b7c5f96

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -29,9 +29,10 @@ import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit, type CloseoutOptions } from "./auto-unit-closeout.js";
 import {
-  autoCommitCurrentBranch,
+  runTurnGitAction,
   type TaskCommitContext,
-} from "./worktree.js";
+  type TurnGitActionMode,
+} from "./git-service.js";
 import {
   verifyExpectedArtifact,
   resolveExpectedArtifactPath,
@@ -66,6 +67,9 @@ import { getSliceTasks } from "./gsd-db.js";
 import { runPreExecutionChecks, type PreExecutionResult } from "./pre-execution-checks.js";
 import { writePreExecutionEvidence } from "./verification-evidence.js";
 import { ensureCodebaseMapFresh } from "./codebase-generator.js";
+import { resolveUokFlags } from "./uok/flags.js";
+import { UokGateRunner } from "./uok/gate-runner.js";
+import { writeTurnGitTransaction } from "./uok/gitops.js";
 
 /** Maximum verification retry attempts before escalating to blocker placeholder (#2653). */
 const MAX_VERIFICATION_RETRIES = 3;
@@ -109,6 +113,7 @@ import {
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { _resetHasChangesCache } from "./native-git-bridge.js";
+import { autoCommitCurrentBranch } from "./worktree.js";
 
 // ─── Rogue File Detection ──────────────────────────────────────────────────
 
@@ -357,10 +362,161 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
     await new Promise(r => setTimeout(r, 100));
   }
 
-  // Auto-commit
+  const prefs = loadEffectiveGSDPreferences()?.preferences;
+  const uokFlags = resolveUokFlags(prefs);
+
+  // Turn-level git action (commit | snapshot | status-only)
   if (s.currentUnit) {
     const unit = s.currentUnit;
-    await autoCommitUnit(s.basePath, unit.type, unit.id, ctx);
+    const turnAction: TurnGitActionMode = uokFlags.gitops ? uokFlags.gitopsTurnAction : "commit";
+    const traceId = s.currentTraceId ?? `turn:${unit.startedAt}`;
+    const turnId = s.currentTurnId ?? `${unit.type}/${unit.id}/${unit.startedAt}`;
+    s.lastGitActionFailure = null;
+    s.lastGitActionStatus = null;
+    try {
+      let taskContext: TaskCommitContext | undefined;
+
+      if (turnAction === "commit" && s.currentUnit.type === "execute-task") {
+        const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
+        if (mid && sid && tid) {
+          const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
+          if (summaryPath) {
+            try {
+              const summaryContent = await loadFile(summaryPath);
+              if (summaryContent) {
+                const summary = parseSummary(summaryContent);
+                // Look up GitHub issue number for commit linking
+                let ghIssueNumber: number | undefined;
+                try {
+                  const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
+                  ghIssueNumber = getTaskIssueNumberForCommit(s.basePath, mid, sid, tid) ?? undefined;
+                } catch (err) {
+                  // GitHub sync not available — skip
+                  logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+
+                taskContext = {
+                  taskId: `${sid}/${tid}`,
+                  taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
+                  oneLiner: summary.oneLiner || undefined,
+                  keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
+                  issueNumber: ghIssueNumber,
+                };
+              }
+            } catch (e) {
+              debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
+            }
+          }
+        }
+      }
+
+      // Invalidate the nativeHasChanges cache before auto-commit (#1853).
+      // The cache has a 10-second TTL and is keyed by basePath.  A stale
+      // `false` result causes autoCommit to skip staging entirely, leaving
+      // code files only in the working tree where they are destroyed by
+      // `git worktree remove --force` during teardown.
+      _resetHasChangesCache();
+
+      const skipLifecycleCommit =
+        turnAction === "commit" && LIFECYCLE_ONLY_UNITS.has(s.currentUnit.type);
+
+      if (skipLifecycleCommit) {
+        debugLog("postUnit", {
+          phase: "git-action-skipped",
+          reason: "lifecycle-only-unit",
+          unitType: s.currentUnit.type,
+          unitId: s.currentUnit.id,
+        });
+      } else {
+        const gitResult = runTurnGitAction({
+          basePath: s.basePath,
+          action: turnAction,
+          unitType: s.currentUnit.type,
+          unitId: s.currentUnit.id,
+          taskContext,
+        });
+
+        if (uokFlags.gitops) {
+          writeTurnGitTransaction({
+            basePath: s.basePath,
+            traceId,
+            turnId,
+            unitType: unit.type,
+            unitId: unit.id,
+            stage: "publish",
+            action: turnAction,
+            push: uokFlags.gitopsTurnPush,
+            status: gitResult.status,
+            error: gitResult.error,
+            metadata: {
+              dirty: gitResult.dirty,
+              commitMessage: gitResult.commitMessage,
+              snapshotLabel: gitResult.snapshotLabel,
+            },
+          });
+        }
+
+        if (gitResult.status === "failed") {
+          s.lastGitActionFailure = gitResult.error ?? `git ${turnAction} failed`;
+          s.lastGitActionStatus = "failed";
+          if (uokFlags.gitops && uokFlags.gates) {
+            const parsed = parseUnitId(unit.id);
+            const gateRunner = new UokGateRunner();
+            gateRunner.register({
+              id: "closeout-git-action",
+              type: "closeout",
+              execute: async () => ({
+                outcome: "fail",
+                failureClass: "git",
+                rationale: `turn git action "${turnAction}" failed`,
+                findings: gitResult.error ?? "unknown git failure",
+              }),
+            });
+            await gateRunner.run("closeout-git-action", {
+              basePath: s.basePath,
+              traceId,
+              turnId,
+              milestoneId: parsed.milestone ?? undefined,
+              sliceId: parsed.slice ?? undefined,
+              taskId: parsed.task ?? undefined,
+              unitType: unit.type,
+              unitId: unit.id,
+            });
+          }
+
+          const failureMsg = `Git ${turnAction} failed: ${(gitResult.error ?? "unknown error").split("\n")[0]}`;
+          if (uokFlags.gitops) {
+            ctx.ui.notify(failureMsg, "error");
+            await pauseAuto(ctx, pi);
+            return "dispatched";
+          }
+          ctx.ui.notify(failureMsg, "warning");
+          debugLog("postUnit", {
+            phase: "git-action-failed-nonblocking",
+            action: turnAction,
+            error: gitResult.error ?? "unknown error",
+          });
+        }
+
+        s.lastGitActionStatus = "ok";
+
+        if (turnAction === "commit" && gitResult.commitMessage) {
+          ctx.ui.notify(`Committed: ${gitResult.commitMessage.split("\n")[0]}`, "info");
+        } else if (turnAction === "snapshot" && gitResult.snapshotLabel) {
+          ctx.ui.notify(`Snapshot recorded: ${gitResult.snapshotLabel}`, "info");
+        }
+      }
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      s.lastGitActionFailure = message;
+      s.lastGitActionStatus = "failed";
+      debugLog("postUnit", { phase: "git-action", error: message, action: turnAction });
+      ctx.ui.notify(`Git ${turnAction} failed: ${message.split("\n")[0]}`, uokFlags.gitops ? "error" : "warning");
+      if (uokFlags.gitops) {
+        await pauseAuto(ctx, pi);
+        return "dispatched";
+      }
+    }
 
     // GitHub sync (non-blocking, opt-in)
     await runSafely("postUnit", "github-sync", async () => {
@@ -869,11 +1025,13 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
     s.currentUnit &&
     s.currentUnit.type === "plan-slice"
   ) {
+    const currentUnit = s.currentUnit;
     let preExecPauseNeeded = false;
     await runSafely("postUnitPostVerification", "pre-execution-checks", async () => {
+      const prefs = loadEffectiveGSDPreferences()?.preferences;
+      const uokFlags = resolveUokFlags(prefs);
       try {
         // Check preferences — respect enhanced_verification and enhanced_verification_pre
-        const prefs = loadEffectiveGSDPreferences()?.preferences;
         const enhancedEnabled = prefs?.enhanced_verification !== false; // default true
         const preEnabled = prefs?.enhanced_verification_pre !== false;  // default true
 
@@ -887,7 +1045,7 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
         }
 
         // Parse the unit ID to get milestone/slice IDs
-        const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit!.id);
+        const { milestone: mid, slice: sid } = parseUnitId(currentUnit.id);
         if (!mid || !sid) {
           debugLog("postUnitPostVerification", {
             phase: "pre-execution-checks",
@@ -908,6 +1066,8 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
           return;
         }
 
+        const strictMode = prefs?.enhanced_verification_strict === true;
+
         // Run pre-execution checks
         const result: PreExecutionResult = await runPreExecutionChecks(tasks, s.basePath);
 
@@ -931,11 +1091,45 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
           writePreExecutionEvidence(result, slicePath, mid, sid);
         }
 
-        // Notify UI
+        if (uokFlags.gates) {
+          const failedChecks = result.checks
+            .filter((check) => !check.passed)
+            .map((check) => `[${check.category}] ${check.target}: ${check.message}`);
+          const warnEscalated = result.status === "warn" && strictMode;
+          const blockingFailure = result.status === "fail" || warnEscalated;
+          const gateRunner = new UokGateRunner();
+          gateRunner.register({
+            id: "pre-execution-checks",
+            type: "input",
+            execute: async () => ({
+              outcome: blockingFailure ? "fail" : "pass",
+              failureClass: result.status === "fail" ? "input" : warnEscalated ? "policy" : "none",
+              rationale: blockingFailure
+                ? `pre-execution checks ${result.status}${warnEscalated ? " (strict)" : ""}`
+                : "pre-execution checks passed",
+              findings: failedChecks.join("\n"),
+            }),
+          });
+          await gateRunner.run("pre-execution-checks", {
+            basePath: s.basePath,
+            traceId: `pre-execution:${currentUnit.id}`,
+            turnId: currentUnit.id,
+            milestoneId: mid,
+            sliceId: sid,
+            unitType: currentUnit.type,
+            unitId: currentUnit.id,
+          });
+        }
+
+        // Notify UI — surface actionable details (#4259)
         if (result.status === "fail") {
-          const blockingCount = result.checks.filter(c => !c.passed && c.blocking).length;
+          const blockingChecks = result.checks.filter(c => !c.passed && c.blocking);
+          const blockingCount = blockingChecks.length;
+          const details = blockingChecks.slice(0, 3).map(c => `  \u2022 ${c.message}`).join("\n");
+          const suffix = blockingChecks.length > 3 ? `\n  \u2022 ...and ${blockingChecks.length - 3} more` : "";
+          const evidenceNote = `\nSee ${sid}-PRE-EXEC-VERIFY.json for full details.`;
           ctx.ui.notify(
-            `Pre-execution checks failed: ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} found`,
+            `Pre-execution checks failed: ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} found\n${details}${suffix}${evidenceNote}`,
             "error",
           );
           preExecPauseNeeded = true;
@@ -969,6 +1163,29 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
           `Pre-execution checks error: ${errorMessage} — pausing for human review`,
           "error",
         );
+        if (uokFlags.gates && s.currentUnit) {
+          const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
+          const gateRunner = new UokGateRunner();
+          gateRunner.register({
+            id: "pre-execution-checks",
+            type: "input",
+            execute: async () => ({
+              outcome: "manual-attention",
+              failureClass: "manual-attention",
+              rationale: "pre-execution checks threw before completion",
+              findings: errorMessage,
+            }),
+          });
+          await gateRunner.run("pre-execution-checks", {
+            basePath: s.basePath,
+            traceId: `pre-execution:${s.currentUnit.id}`,
+            turnId: s.currentUnit.id,
+            milestoneId: mid ?? undefined,
+            sliceId: sid ?? undefined,
+            unitType: s.currentUnit.type,
+            unitId: s.currentUnit.id,
+          });
+        }
         preExecPauseNeeded = true;
       }
     });

package/src/resources/extensions/gsd/auto-recovery.ts

@@ -264,18 +264,30 @@ export function verifyExpectedArtifact(
   const absPath = resolveExpectedArtifactPath(unitType, unitId, base);
   // For unit types with no verifiable artifact (null path), the parent directory
   // is missing on disk — treat as stale completion state so the key gets evicted (#313).
-  if (!absPath) return false;
-  if (!existsSync(absPath)) return false;
+  if (!absPath) {
+    logWarning("recovery", `verify-fail ${unitType} ${unitId}: resolveExpectedArtifactPath returned null (parent dir missing)`);
+    return false;
+  }
+  if (!existsSync(absPath)) {
+    logWarning("recovery", `verify-fail ${unitType} ${unitId}: existsSync false for ${absPath}`);
+    return false;
+  }
 
   if (unitType === "validate-milestone") {
     const validationContent = readFileSync(absPath, "utf-8");
-    if (!isValidationTerminal(validationContent)) return false;
+    if (!isValidationTerminal(validationContent)) {
+      logWarning("recovery", `verify-fail ${unitType} ${unitId}: validation not terminal (len=${validationContent.length}) at ${absPath}`);
+      return false;
+    }
   }
 
   if (unitType === "plan-milestone") {
     try {
       const roadmap = parseLegacyRoadmap(readFileSync(absPath, "utf-8"));
-      if (roadmap.slices.length === 0) return false;
+      if (roadmap.slices.length === 0) {
+        logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap has zero slices at ${absPath}`);
+        return false;
+      }
     } catch (err) {
       logWarning("recovery", `plan-milestone roadmap verification failed: ${err instanceof Error ? err.message : String(err)}`);
       return false;
@@ -292,7 +304,10 @@ export function verifyExpectedArtifact(
     // Accept checkbox-style (- [x] **T01: ...) or heading-style (### T01 -- / ### T01: / ### T01 —)
     const hasCheckboxTask = /^- \[[xX ]\] \*\*T\d+:/m.test(planContent);
     const hasHeadingTask = /^#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
-    if (!hasCheckboxTask && !hasHeadingTask) return false;
+    if (!hasCheckboxTask && !hasHeadingTask) {
+      logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
+      return false;
+    }
   }
 
   // execute-task: DB status is authoritative. Fall back to checked-checkbox
@@ -349,10 +364,15 @@ export function verifyExpectedArtifact(
 
         if (taskIds && taskIds.length > 0) {
           const tasksDir = resolveTasksDir(base, mid, sid);
-          if (tasksDir) {
-            for (const tid of taskIds) {
-              const taskPlanFile = join(tasksDir, `${tid}-PLAN.md`);
-              if (!existsSync(taskPlanFile)) return false;
+          if (!tasksDir) {
+            logWarning("recovery", `verify-fail ${unitType} ${unitId}: resolveTasksDir returned null for ${mid}/${sid}`);
+            return false;
+          }
+          for (const tid of taskIds) {
+            const taskPlanFile = join(tasksDir, `${tid}-PLAN.md`);
+            if (!existsSync(taskPlanFile)) {
+              logWarning("recovery", `verify-fail ${unitType} ${unitId}: task plan missing ${taskPlanFile}`);
+              return false;
             }
           }
         }

package/src/resources/extensions/gsd/auto-unit-closeout.ts

@@ -8,6 +8,7 @@ import type { ExtensionContext } from "@gsd/pi-coding-agent";
 import { snapshotUnitMetrics } from "./metrics.js";
 import { saveActivityLog } from "./activity-log.js";
 import { logWarning } from "./workflow-logger.js";
+import { writeTurnGitTransaction } from "./uok/gitops.js";
 
 export interface CloseoutOptions {
   promptCharCount?: number;
@@ -15,6 +16,12 @@ export interface CloseoutOptions {
   tier?: string;
   modelDowngraded?: boolean;
   continueHereFired?: boolean;
+  traceId?: string;
+  turnId?: string;
+  gitAction?: "commit" | "snapshot" | "status-only";
+  gitPush?: boolean;
+  gitStatus?: "ok" | "failed";
+  gitError?: string;
 }
 
 /**
@@ -47,6 +54,23 @@ export async function closeoutUnit(
     }
   }
 
+  if (opts?.traceId && opts.turnId && opts.gitAction && opts.gitStatus) {
+    writeTurnGitTransaction({
+      basePath,
+      traceId: opts.traceId,
+      turnId: opts.turnId,
+      unitType,
+      unitId,
+      stage: "record",
+      action: opts.gitAction,
+      push: opts.gitPush === true,
+      status: opts.gitStatus,
+      error: opts.gitError,
+      metadata: {
+        activityFile,
+      },
+    });
+  }
+
   return activityFile ?? undefined;
 }
-

package/src/resources/extensions/gsd/auto-verification.ts

@@ -33,6 +33,8 @@ import { runPostExecutionChecks, type PostExecutionResult } from "./post-executi
 import type { AutoSession } from "./auto/session.js";
 import type { VerificationResult as VerificationGateResult } from "./types.js";
 import { join } from "node:path";
+import { resolveUokFlags } from "./uok/flags.js";
+import { UokGateRunner } from "./uok/gate-runner.js";
 
 export interface VerificationContext {
   s: AutoSession;
@@ -67,6 +69,37 @@ async function runValidateMilestonePostCheck(
   pauseAuto: (ctx?: ExtensionContext, pi?: ExtensionAPI) => Promise<void>,
 ): Promise<VerificationResult> {
   const { s, ctx, pi } = vctx;
+  const prefs = loadEffectiveGSDPreferences()?.preferences;
+  const uokFlags = resolveUokFlags(prefs);
+  const persistMilestoneValidationGate = async (
+    outcome: "pass" | "fail" | "retry" | "manual-attention",
+    failureClass: "none" | "verification" | "manual-attention",
+    rationale: string,
+    findings = "",
+    milestoneId?: string,
+  ): Promise<void> => {
+    if (!uokFlags.gates || !s.currentUnit) return;
+    const gateRunner = new UokGateRunner();
+    gateRunner.register({
+      id: "milestone-validation-post-check",
+      type: "verification",
+      execute: async () => ({
+        outcome,
+        failureClass,
+        rationale,
+        findings,
+      }),
+    });
+    await gateRunner.run("milestone-validation-post-check", {
+      basePath: s.basePath,
+      traceId: `validation-post-check:${s.currentUnit.id}`,
+      turnId: s.currentUnit.id,
+      milestoneId,
+      unitType: s.currentUnit.type,
+      unitId: s.currentUnit.id,
+    });
+  };
+
   if (!s.currentUnit) return "continue";
 
   const { milestone: mid } = parseUnitId(s.currentUnit.id);
@@ -79,14 +112,32 @@ async function runValidateMilestonePostCheck(
   if (!validationContent) return "continue";
 
   const verdict = extractVerdict(validationContent);
-  if (verdict !== "needs-remediation") return "continue";
+  if (verdict !== "needs-remediation") {
+    await persistMilestoneValidationGate(
+      "pass",
+      "none",
+      `milestone validation verdict is ${verdict}; no remediation loop risk`,
+      "",
+      mid,
+    );
+    return "continue";
+  }
 
   const incompleteSliceCount = await countIncompleteSlices(s.basePath, mid);
 
   // If any non-closed slices exist, the agent successfully queued remediation
   // work — proceed normally. The state machine will execute those slices and
   // re-validate per the #3596/#3670 fix.
-  if (incompleteSliceCount > 0) return "continue";
+  if (incompleteSliceCount > 0) {
+    await persistMilestoneValidationGate(
+      "pass",
+      "none",
+      `remediation slices present (${incompleteSliceCount}); validation can continue`,
+      "",
+      mid,
+    );
+    return "continue";
+  }
 
   ctx.ui.notify(
     `Milestone ${mid} validation returned verdict=needs-remediation but no remediation slices were added. Pausing for human review.`,
@@ -96,6 +147,13 @@ async function runValidateMilestonePostCheck(
     `validate-milestone: pausing — verdict=needs-remediation with no incomplete slices for ${mid}. ` +
       `The agent must call gsd_reassess_roadmap to add remediation slices before re-validation.\n`,
   );
+  await persistMilestoneValidationGate(
+    "manual-attention",
+    "manual-attention",
+    "needs-remediation verdict without queued remediation slices",
+    `No incomplete slices found for ${mid} while verdict=needs-remediation`,
+    mid,
+  );
   await pauseAuto(ctx, pi);
   return "pause";
 }
@@ -158,6 +216,7 @@ export async function runPostUnitVerification(
   try {
     const effectivePrefs = loadEffectiveGSDPreferences();
     const prefs = effectivePrefs?.preferences;
+    const uokFlags = resolveUokFlags(prefs);
 
     // Read task plan verify field
     const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
@@ -196,6 +255,37 @@ export async function runPostUnitVerification(
       }
     }
 
+    if (uokFlags.gates) {
+      const gateRunner = new UokGateRunner();
+      gateRunner.register({
+        id: "verification-gate",
+        type: "verification",
+        execute: async () => ({
+          outcome: result.passed ? "pass" : "fail",
+          failureClass: result.runtimeErrors?.some((e) => e.blocking)
+            ? "execution"
+            : "verification",
+          rationale: result.passed
+            ? "verification checks passed"
+            : "verification checks failed",
+          findings: result.passed
+            ? ""
+            : formatFailureContext(result),
+        }),
+      });
+
+      await gateRunner.run("verification-gate", {
+        basePath: s.basePath,
+        traceId: `verification:${s.currentUnit.id}`,
+        turnId: s.currentUnit.id,
+        milestoneId: mid ?? undefined,
+        sliceId: sid ?? undefined,
+        taskId: tid ?? undefined,
+        unitType: s.currentUnit.type,
+        unitId: s.currentUnit.id,
+      });
+    }
+
     // Auto-fix retry preferences
     const autoFixEnabled = prefs?.verification_auto_fix !== false;
     const maxRetries =
@@ -338,6 +428,43 @@ export async function runPostUnitVerification(
               );
             }
 
+            if (uokFlags.gates) {
+              const strictMode = prefs?.enhanced_verification_strict === true;
+              const warnEscalated = postExecResult.status === "warn" && strictMode;
+              const blockingFailure = postExecResult.status === "fail" || warnEscalated;
+              const findings = postExecResult.checks
+                .filter((check) => !check.passed)
+                .map((check) => `[${check.category}] ${check.target}: ${check.message}`)
+                .join("\n");
+              const gateRunner = new UokGateRunner();
+              gateRunner.register({
+                id: "post-execution-checks",
+                type: "artifact",
+                execute: async () => ({
+                  outcome: blockingFailure ? "fail" : "pass",
+                  failureClass: postExecResult.status === "fail"
+                    ? "artifact"
+                    : warnEscalated
+                      ? "policy"
+                      : "none",
+                  rationale: blockingFailure
+                    ? `post-execution checks ${postExecResult.status}${warnEscalated ? " (strict)" : ""}`
+                    : "post-execution checks passed",
+                  findings,
+                }),
+              });
+              await gateRunner.run("post-execution-checks", {
+                basePath: s.basePath,
+                traceId: `verification:${s.currentUnit.id}`,
+                turnId: s.currentUnit.id,
+                milestoneId: mid,
+                sliceId: sid,
+                taskId: tid,
+                unitType: s.currentUnit.type,
+                unitId: s.currentUnit.id,
+              });
+            }
+
             // Check for blocking failures
             if (postExecResult.status === "fail") {
               postExecBlockingFailure = true;

package/src/resources/extensions/gsd/auto-worktree.ts

@@ -102,6 +102,7 @@ function isSamePath(a: string, b: string): boolean {
   try {
     return realpathSync(a) === realpathSync(b);
   } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === "ENOENT") return false;
     logWarning("worktree", `isSamePath failed: ${(e as Error).message}`);
     return false;
   }

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

@@ -202,6 +202,8 @@ import {
 import { bootstrapAutoSession, openProjectDbIfPresent, type BootstrapDeps } from "./auto-start.js";
 import { initHealthWidget } from "./health-widget.js";
 import { autoLoop, resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight, type LoopDeps, type ErrorContext } from "./auto-loop.js";
+import { runAutoLoopWithUok } from "./uok/kernel.js";
+import { resolveUokFlags } from "./uok/flags.js";
 // Slice-level parallelism (#2340)
 import { getEligibleSlices } from "./slice-parallel-eligibility.js";
 import { startSliceParallel } from "./slice-parallel-orchestrator.js";
@@ -605,11 +607,29 @@ function buildSnapshotOpts(
   continueHereFired?: boolean;
   promptCharCount?: number;
   baselineCharCount?: number;
+  traceId?: string;
+  turnId?: string;
+  gitAction?: "commit" | "snapshot" | "status-only";
+  gitPush?: boolean;
+  gitStatus?: "ok" | "failed";
+  gitError?: string;
 } & Record<string, unknown> {
+  const prefs = loadEffectiveGSDPreferences()?.preferences;
+  const uokFlags = resolveUokFlags(prefs);
   return {
     ...(s.autoStartTime > 0 ? { autoSessionKey: String(s.autoStartTime) } : {}),
     promptCharCount: s.lastPromptCharCount,
     baselineCharCount: s.lastBaselineCharCount,
+    traceId: s.currentTraceId ?? undefined,
+    turnId: s.currentTurnId ?? undefined,
+    ...(uokFlags.gitops
+      ? {
+          gitAction: uokFlags.gitopsTurnAction,
+          gitPush: uokFlags.gitopsTurnPush,
+          gitStatus: s.lastGitActionStatus ?? undefined,
+          gitError: s.lastGitActionFailure ?? undefined,
+        }
+      : {}),
     ...(s.currentUnitRouting ?? {}),
   };
 }
@@ -1513,7 +1533,13 @@ export async function startAuto(
     logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "progress");
 
     captureProjectRootEnv(s.originalBasePath || s.basePath);
-    await autoLoop(ctx, pi, s, buildLoopDeps());
+    await runAutoLoopWithUok({
+      ctx,
+      pi,
+      s,
+      deps: buildLoopDeps(),
+      runLegacyLoop: autoLoop,
+    });
     cleanupAfterLoopExit(ctx);
     return;
   }
@@ -1548,7 +1574,13 @@ export async function startAuto(
   logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, requestedStepMode ? "Step-mode started." : "Auto-mode started.", "progress");
 
   // Dispatch the first unit
-  await autoLoop(ctx, pi, s, buildLoopDeps());
+  await runAutoLoopWithUok({
+    ctx,
+    pi,
+    s,
+    deps: buildLoopDeps(),
+    runLegacyLoop: autoLoop,
+  });
   cleanupAfterLoopExit(ctx);
 }