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

package/src/resources/extensions/gsd/tests/cold-resume-db-reopen.test.ts

@@ -25,8 +25,12 @@ console.log("\n=== resume path refreshes resources and opens DB before rebuildSt
 const resumeSectionStart = autoSrc.indexOf("if (s.paused) {", autoSrc.indexOf("// If resuming from paused state"));
 assertTrue(resumeSectionStart > 0, "auto.ts has the paused-session resume block");
 
-const resumeSectionEnd = autoSrc.indexOf("await autoLoop(", resumeSectionStart);
-assertTrue(resumeSectionEnd > resumeSectionStart, "resume block reaches autoLoop");
+const resumeSectionEndCandidates = [
+  autoSrc.indexOf("await runAutoLoopWithUok(", resumeSectionStart),
+  autoSrc.indexOf("await autoLoop(", resumeSectionStart),
+].filter((idx) => idx > resumeSectionStart);
+const resumeSectionEnd = resumeSectionEndCandidates.length > 0 ? Math.min(...resumeSectionEndCandidates) : -1;
+assertTrue(resumeSectionEnd > resumeSectionStart, "resume block reaches the dispatch loop");
 
 const resumeSection = autoSrc.slice(resumeSectionStart, resumeSectionEnd);
 

package/src/resources/extensions/gsd/tests/commands-extract-learnings.test.ts

@@ -0,0 +1,340 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import {
+  parseExtractLearningsArgs,
+  buildLearningsOutputPath,
+  resolvePhaseArtifacts,
+  buildExtractLearningsPrompt,
+  buildFrontmatter,
+  extractProjectName,
+} from "../commands-extract-learnings.js";
+
+// ─── parseExtractLearningsArgs ────────────────────────────────────────────────
+
+describe("parseExtractLearningsArgs", () => {
+  it("parses a milestone ID", () => {
+    const result = parseExtractLearningsArgs("M001");
+    assert.deepEqual(result, { milestoneId: "M001" });
+  });
+
+  it("returns null milestoneId for empty string", () => {
+    const result = parseExtractLearningsArgs("");
+    assert.deepEqual(result, { milestoneId: null });
+  });
+
+  it("returns null milestoneId for whitespace-only string", () => {
+    const result = parseExtractLearningsArgs("  ");
+    assert.deepEqual(result, { milestoneId: null });
+  });
+
+  it("trims whitespace from milestone ID", () => {
+    const result = parseExtractLearningsArgs("  M002  ");
+    assert.deepEqual(result, { milestoneId: "M002" });
+  });
+});
+
+// ─── buildLearningsOutputPath ─────────────────────────────────────────────────
+
+describe("buildLearningsOutputPath", () => {
+  it("builds the correct output path", () => {
+    const result = buildLearningsOutputPath("/base/.gsd/milestones/M001", "M001");
+    assert.equal(result, "/base/.gsd/milestones/M001/M001-LEARNINGS.md");
+  });
+
+  it("builds path for different milestone ID", () => {
+    const result = buildLearningsOutputPath("/project/.gsd/milestones/M005", "M005");
+    assert.equal(result, "/project/.gsd/milestones/M005/M005-LEARNINGS.md");
+  });
+});
+
+// ─── resolvePhaseArtifacts ────────────────────────────────────────────────────
+
+describe("resolvePhaseArtifacts", () => {
+  let tmpBase: string;
+
+  beforeEach(() => {
+    tmpBase = join(tmpdir(), `gsd-learnings-test-${randomUUID()}`);
+    mkdirSync(tmpBase, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tmpBase, { recursive: true, force: true });
+  });
+
+  it("finds required PLAN and SUMMARY when both present", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# M001 Plan content", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# M001 Summary content", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.plan, join(tmpBase, "M001-PLAN.md"));
+    assert.equal(result.summary, join(tmpBase, "M001-SUMMARY.md"));
+    assert.deepEqual(result.missingRequired, []);
+  });
+
+  it("reports missing PLAN as missingRequired", () => {
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.ok(result.missingRequired.includes("M001-PLAN.md"));
+    assert.equal(result.plan, null);
+  });
+
+  it("reports missing SUMMARY as missingRequired", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.ok(result.missingRequired.includes("M001-SUMMARY.md"));
+    assert.equal(result.summary, null);
+  });
+
+  it("reports both required files missing when neither present", () => {
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.missingRequired.length, 2);
+    assert.ok(result.missingRequired.includes("M001-PLAN.md"));
+    assert.ok(result.missingRequired.includes("M001-SUMMARY.md"));
+  });
+
+  it("finds optional VERIFICATION when present", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+    writeFileSync(join(tmpBase, "M001-VERIFICATION.md"), "# Verification", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.verification, join(tmpBase, "M001-VERIFICATION.md"));
+  });
+
+  it("returns null for optional VERIFICATION when absent", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.verification, null);
+  });
+
+  it("finds optional UAT when present", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+    writeFileSync(join(tmpBase, "M001-UAT.md"), "# UAT", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.uat, join(tmpBase, "M001-UAT.md"));
+  });
+
+  it("returns null for optional UAT when absent, no error", () => {
+    writeFileSync(join(tmpBase, "M001-PLAN.md"), "# Plan", "utf-8");
+    writeFileSync(join(tmpBase, "M001-SUMMARY.md"), "# Summary", "utf-8");
+
+    const result = resolvePhaseArtifacts(tmpBase, "M001");
+    assert.equal(result.uat, null);
+    assert.deepEqual(result.missingRequired, []);
+  });
+});
+
+// ─── buildExtractLearningsPrompt ──────────────────────────────────────────────
+
+describe("buildExtractLearningsPrompt", () => {
+  it("includes milestoneId and outputPath", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/project/.gsd/milestones/M001/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "# Plan content",
+      summaryContent: "# Summary content",
+      verificationContent: null,
+      uatContent: null,
+      missingArtifacts: [],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("M001"));
+    assert.ok(result.includes("/project/.gsd/milestones/M001/M001-LEARNINGS.md"));
+  });
+
+  it("includes all 4 learning categories", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/out/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "# Plan",
+      summaryContent: "# Summary",
+      verificationContent: null,
+      uatContent: null,
+      missingArtifacts: [],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("Decisions"));
+    assert.ok(result.includes("Lessons"));
+    assert.ok(result.includes("Patterns"));
+    assert.ok(result.includes("Surprises"));
+  });
+
+  it("includes plan and summary content", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/out/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "PLAN_CONTENT_UNIQUE_123",
+      summaryContent: "SUMMARY_CONTENT_UNIQUE_456",
+      verificationContent: null,
+      uatContent: null,
+      missingArtifacts: [],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("PLAN_CONTENT_UNIQUE_123"));
+    assert.ok(result.includes("SUMMARY_CONTENT_UNIQUE_456"));
+  });
+
+  it("includes optional artifacts when present", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/out/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "# Plan",
+      summaryContent: "# Summary",
+      verificationContent: "VERIFICATION_UNIQUE_789",
+      uatContent: "UAT_UNIQUE_012",
+      missingArtifacts: [],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("VERIFICATION_UNIQUE_789"));
+    assert.ok(result.includes("UAT_UNIQUE_012"));
+  });
+
+  it("lists missing artifacts when present", () => {
+    const result = buildExtractLearningsPrompt({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      outputPath: "/out/M001-LEARNINGS.md",
+      relativeOutputPath: ".gsd/milestones/M001/M001-LEARNINGS.md",
+      planContent: "# Plan",
+      summaryContent: "# Summary",
+      verificationContent: null,
+      uatContent: null,
+      missingArtifacts: ["M001-VERIFICATION.md"],
+      projectName: "MyProject",
+    });
+
+    assert.ok(result.includes("M001-VERIFICATION.md"));
+  });
+});
+
+// ─── buildFrontmatter ─────────────────────────────────────────────────────────
+
+describe("buildFrontmatter", () => {
+  it("starts with --- and ends with ---", () => {
+    const result = buildFrontmatter({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      projectName: "MyProject",
+      generatedAt: "2026-04-15T10:00:00Z",
+      counts: { decisions: 0, lessons: 0, patterns: 0, surprises: 0 },
+      missingArtifacts: [],
+    });
+
+    assert.ok(result.startsWith("---\n"));
+    assert.ok(result.endsWith("---"));
+  });
+
+  it("includes required fields", () => {
+    const result = buildFrontmatter({
+      milestoneId: "M001",
+      milestoneName: "Test Milestone",
+      projectName: "MyProject",
+      generatedAt: "2026-04-15T10:00:00Z",
+      counts: { decisions: 3, lessons: 2, patterns: 1, surprises: 0 },
+      missingArtifacts: [],
+    });
+
+    assert.ok(result.includes("phase:"));
+    assert.ok(result.includes("phase_name:"));
+    assert.ok(result.includes("project:"));
+    assert.ok(result.includes("generated:"));
+    assert.ok(result.includes("counts:"));
+    assert.ok(result.includes("missing_artifacts:"));
+  });
+
+  it("includes milestoneId as phase value", () => {
+    const result = buildFrontmatter({
+      milestoneId: "M001",
+      milestoneName: "Auth System",
+      projectName: "MyApp",
+      generatedAt: "2026-04-15T10:00:00Z",
+      counts: { decisions: 0, lessons: 0, patterns: 0, surprises: 0 },
+      missingArtifacts: [],
+    });
+
+    assert.ok(result.includes("M001"));
+    assert.ok(result.includes("Auth System"));
+    assert.ok(result.includes("MyApp"));
+    assert.ok(result.includes("2026-04-15T10:00:00Z"));
+  });
+
+  it("includes missing artifacts list", () => {
+    const result = buildFrontmatter({
+      milestoneId: "M001",
+      milestoneName: "Test",
+      projectName: "Proj",
+      generatedAt: "2026-04-15T10:00:00Z",
+      counts: { decisions: 0, lessons: 0, patterns: 0, surprises: 0 },
+      missingArtifacts: ["M001-VERIFICATION.md", "M001-UAT.md"],
+    });
+
+    assert.ok(result.includes("M001-VERIFICATION.md"));
+    assert.ok(result.includes("M001-UAT.md"));
+  });
+});
+
+// ─── extractProjectName ───────────────────────────────────────────────────────
+
+describe("extractProjectName", () => {
+  let tmpBase: string;
+
+  beforeEach(() => {
+    tmpBase = join(tmpdir(), `gsd-projname-test-${randomUUID()}`);
+    mkdirSync(join(tmpBase, ".gsd"), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tmpBase, { recursive: true, force: true });
+  });
+
+  it("reads name from PROJECT.md frontmatter", () => {
+    writeFileSync(
+      join(tmpBase, ".gsd", "PROJECT.md"),
+      "---\nname: My Cool Project\nversion: 1\n---\n# Project\n",
+      "utf-8",
+    );
+
+    const result = extractProjectName(tmpBase);
+    assert.equal(result, "My Cool Project");
+  });
+
+  it("falls back to directory name when PROJECT.md absent", () => {
+    const result = extractProjectName(tmpBase);
+    // Should return the last path segment of tmpBase
+    assert.equal(result, tmpBase.split("/").at(-1));
+  });
+
+  it("falls back to directory name when PROJECT.md has no name field", () => {
+    writeFileSync(
+      join(tmpBase, ".gsd", "PROJECT.md"),
+      "---\nversion: 1\n---\n# Project\n",
+      "utf-8",
+    );
+
+    const result = extractProjectName(tmpBase);
+    assert.equal(result, tmpBase.split("/").at(-1));
+  });
+});

package/src/resources/extensions/gsd/tests/complete-slice.test.ts

@@ -125,9 +125,9 @@ console.log('\n=== complete-slice: schema v6 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v14 after indexes + slice_dependencies)
+  // Verify schema version is current (v15 with UOK projection tables)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 14, 'schema version should be 14');
+  assertEq(versionRow?.['v'], 15, 'schema version should be 15');
 
   // Verify slices table has full_summary_md and full_uat_md columns
   const cols = adapter.prepare("PRAGMA table_info(slices)").all();

package/src/resources/extensions/gsd/tests/complete-task.test.ts

@@ -109,9 +109,9 @@ console.log('\n=== complete-task: schema v5 migration ===');
 
   const adapter = _getAdapter()!;
 
-  // Verify schema version is current (v14 after indexes + slice_dependencies)
+  // Verify schema version is current (v15 with UOK projection tables)
   const versionRow = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(versionRow?.['v'], 14, 'schema version should be 14');
+  assertEq(versionRow?.['v'], 15, 'schema version should be 15');
 
   // Verify all 4 new tables exist
   const tables = adapter.prepare(

package/src/resources/extensions/gsd/tests/finalize-timeout-guard.test.ts

@@ -26,6 +26,14 @@ import { MAX_FINALIZE_TIMEOUTS } from "../auto/types.ts";
 
 const { assertTrue, assertEq, report } = createTestContext();
 
+function getRunFinalizeBody(phasesSource: string): string {
+  const fnIdx = phasesSource.indexOf("export async function runFinalize(");
+  assertTrue(fnIdx > 0, "runFinalize function should exist in phases.ts");
+
+  const nextExportIdx = phasesSource.indexOf("\nexport ", fnIdx + 1);
+  return phasesSource.slice(fnIdx, nextExportIdx > fnIdx ? nextExportIdx : undefined);
+}
+
 // ═══ Test: withTimeout resolves when inner promise resolves promptly ══════════
 
 {
@@ -145,11 +153,7 @@ const { assertTrue, assertEq, report } = createTestContext();
     "utf-8",
   );
 
-  // Find the runFinalize function body
-  const fnIdx = phasesSource.indexOf("export async function runFinalize(");
-  assertTrue(fnIdx > 0, "runFinalize function should exist in phases.ts");
-
-  const fnBody = phasesSource.slice(fnIdx, fnIdx + 8000);
+  const fnBody = getRunFinalizeBody(phasesSource);
 
   // postUnitPreVerification must be wrapped in withTimeout
   const preTimeoutIdx = fnBody.indexOf("withTimeout(");
@@ -207,8 +211,7 @@ const { assertTrue, assertEq, report } = createTestContext();
     "utf-8",
   );
 
-  const fnIdx = phasesSource.indexOf("export async function runFinalize(");
-  const fnBody = phasesSource.slice(fnIdx, fnIdx + 8000);
+  const fnBody = getRunFinalizeBody(phasesSource);
 
   // Both timeout handlers should increment consecutiveFinalizeTimeouts
   const incrementCount = (fnBody.match(/consecutiveFinalizeTimeouts\+\+/g) || []).length;

package/src/resources/extensions/gsd/tests/gsd-db.test.ts

@@ -80,7 +80,7 @@ describe('gsd-db', () => {
     // Check schema_version table
     const adapter = _getAdapter()!;
     const version = adapter.prepare('SELECT MAX(version) as version FROM schema_version').get();
-    assert.deepStrictEqual(version?.['version'], 14, 'schema version should be 14');
+    assert.deepStrictEqual(version?.['version'], 15, 'schema version should be 15');
 
     // Check tables exist by querying them
     const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -198,7 +198,7 @@ test("session_start bootstraps the health widget alongside notifications", async
     },
   } as any;
 
-  registerHooks(pi);
+  registerHooks(pi, []);
   const sessionStart = handlers.get("session_start");
   assert.ok(sessionStart, "session_start handler is registered");
 

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -595,13 +595,13 @@ test("unit-end event contains errorContext when unit is cancelled with structure
   const unitPromise = runUnitPhase(ic, iterData, loopState);
   await new Promise(r => setTimeout(r, 50));
 
-  // Resolve with errorContext (simulates a timeout cancel)
+  // Resolve with errorContext (simulates a unit hard timeout — not session creation)
   resolveAgentEndCancelled({ message: "Hard timeout error: exceeded limit", category: "timeout", isTransient: true });
 
   const result = await unitPromise;
-  // Transient timeout cancellations pause (recoverable) instead of hard-stopping
+  // Unit hard timeouts pause (recoverable) without auto-resume
   assert.equal(result.action, "break");
-  assert.equal((result as any).reason, "session-timeout");
+  assert.equal((result as any).reason, "unit-hard-timeout");
   assert.equal(pauseCalls, 1, "timeout cancellations should pause auto-mode exactly once");
   assert.equal(commitCalls, 1, "timeout cancellations should flush a unit auto-commit once");
 

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -363,7 +363,7 @@ test('md-importer: schema v1→v2 migration', () => {
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.v, 14, 'new DB should be at schema version 14');
+  assert.deepStrictEqual(version?.v, 15, 'new DB should be at schema version 15');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();
@@ -413,4 +413,3 @@ test('md-importer: round-trip fidelity', () => {
 });
 
 // ═══════════════════════════════════════════════════════════════════════════
-

package/src/resources/extensions/gsd/tests/memory-store.test.ts

@@ -323,10 +323,9 @@ test('memory-store: schema includes memories table', () => {
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assert.deepStrictEqual(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 14 (after indexes + slice_dependencies)
+  // Verify schema version is 15 (UOK gate/git/audit projection tables included)
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.['v'], 14, 'schema version should be 14');
+  assert.deepStrictEqual(version?.['v'], 15, 'schema version should be 15');
 
   closeDatabase();
 });
-

package/src/resources/extensions/gsd/tests/post-exec-retry-bypass.test.ts

@@ -14,7 +14,7 @@ import { join } from "node:path";
 
 import { runPostUnitVerification, type VerificationContext } from "../auto-verification.ts";
 import { AutoSession } from "../auto/session.ts";
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, _getAdapter } from "../gsd-db.ts";
 import { invalidateAllCaches } from "../cache.ts";
 import { _clearGsdRootCache } from "../paths.ts";
 
@@ -140,6 +140,43 @@ function createBasicTask(): void {
   });
 }
 
+function createPostExecFailureTask(): void {
+  insertMilestone({ id: "M001" });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Test Slice",
+    risk: "low",
+  });
+
+  const srcDir = join(tempDir, "src");
+  mkdirSync(srcDir, { recursive: true });
+  writeFileSync(
+    join(srcDir, "broken.ts"),
+    "import { missing } from './does-not-exist.js';\nexport const ok = 1;\n",
+    "utf-8",
+  );
+
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task with broken import",
+    status: "pending",
+    keyFiles: ["src/broken.ts"],
+    planning: {
+      description: "Task that introduces an unresolved import in key files",
+      estimate: "1h",
+      files: ["src/broken.ts"],
+      verify: "echo pass",
+      inputs: [],
+      expectedOutput: [],
+      observabilityImpact: "",
+    },
+    sequence: 0,
+  });
+}
+
 // ─── Tests ───────────────────────────────────────────────────────────────────
 
 describe("Post-execution blocking failure retry bypass", () => {
@@ -249,6 +286,47 @@ describe("Post-execution blocking failure retry bypass", () => {
     // This test mainly confirms the wiring is correct
     assert.equal(result, "continue");
   });
+
+  test("uok gate runner persists post-execution gate failures when enabled", async () => {
+    createPostExecFailureTask();
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_post: true,
+      verification_auto_fix: true,
+      verification_max_retries: 2,
+      uok: {
+        enabled: true,
+        gates: { enabled: true },
+      },
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+    const vctx: VerificationContext = { s, ctx, pi };
+
+    const result = await runPostUnitVerification(vctx, pauseAutoMock);
+
+    assert.equal(result, "pause");
+    assert.equal(pauseAutoMock.mock.callCount(), 1);
+
+    const adapter = _getAdapter();
+    const row = adapter
+      ?.prepare(
+        `SELECT gate_id, outcome, failure_class
+         FROM gate_runs
+         WHERE gate_id = 'post-execution-checks'
+         ORDER BY id DESC
+         LIMIT 1`,
+      )
+      .get() as { gate_id: string; outcome: string; failure_class: string } | undefined;
+
+    assert.ok(row, "post-execution gate run should be persisted when uok.gates is enabled");
+    assert.equal(row?.gate_id, "post-execution-checks");
+    assert.equal(row?.outcome, "fail");
+    assert.equal(row?.failure_class, "artifact");
+  });
 });
 
 describe("Post-execution retry behavior", () => {

package/src/resources/extensions/gsd/tests/post-unit-state-rebuild.test.ts

@@ -21,7 +21,8 @@ test("postUnitPreVerification rebuilds STATE.md before worktree sync", () => {
   const fnStart = source.indexOf("export async function postUnitPreVerification");
   assert.ok(fnStart > 0, "postUnitPreVerification should exist");
 
-  const section = source.slice(fnStart, fnStart + 8000);
+  const fnEnd = source.indexOf("export async function postUnitPostVerification", fnStart);
+  const section = source.slice(fnStart, fnEnd > fnStart ? fnEnd : undefined);
   const rebuildIdx = section.indexOf('await runSafely("postUnit", "state-rebuild"');
   const syncIdx = section.indexOf('await runSafely("postUnit", "worktree-sync"');
 

package/src/resources/extensions/gsd/tests/pre-execution-pause-wiring.test.ts

@@ -17,7 +17,7 @@ import { join } from "node:path";
 
 import { postUnitPostVerification, type PostUnitContext } from "../auto-post-unit.ts";
 import { AutoSession } from "../auto/session.ts";
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, _getAdapter } from "../gsd-db.ts";
 import { invalidateAllCaches } from "../cache.ts";
 import { _clearGsdRootCache } from "../paths.ts";
 
@@ -454,4 +454,43 @@ describe("Pre-execution checks → pauseAuto wiring", () => {
       "postUnitPostVerification should return 'continue' when pre-execution checks are disabled"
     );
   });
+
+  test("uok gate runner persists pre-execution gate outcomes when enabled", async () => {
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_pre: true,
+      enhanced_verification_strict: true,
+      uok: {
+        enabled: true,
+        gates: { enabled: true },
+      },
+    });
+
+    createFailingTasks();
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "plan-slice", id: "M001/S01" });
+    const pctx = makePostUnitContext(s, ctx, pi, pauseAutoMock);
+
+    const result = await postUnitPostVerification(pctx);
+    assert.equal(result, "stopped");
+
+    const adapter = _getAdapter();
+    const row = adapter
+      ?.prepare(
+        `SELECT gate_id, outcome, failure_class
+         FROM gate_runs
+         WHERE gate_id = 'pre-execution-checks'
+         ORDER BY id DESC
+         LIMIT 1`,
+      )
+      .get() as { gate_id: string; outcome: string; failure_class: string } | undefined;
+
+    assert.ok(row, "pre-execution gate run should be persisted when uok.gates is enabled");
+    assert.equal(row?.gate_id, "pre-execution-checks");
+    assert.equal(row?.outcome, "fail");
+    assert.equal(row?.failure_class, "input");
+  });
 });