gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0

package/src/resources/extensions/gsd/tests/uok-execution-graph.test.ts

@@ -5,6 +5,7 @@ import {
   selectConflictFreeBatch,
   selectReactiveDispatchBatch,
   buildSidecarQueueNodes,
+  buildExecutionGraphSnapshot,
   scheduleSidecarQueue,
 } from "../uok/execution-graph.ts";
 
@@ -67,3 +68,18 @@ test("uok execution graph sidecar scheduler preserves deterministic queue order"
     queue.map((item) => item.unitId),
   );
 });
+
+test("uok execution graph snapshot captures deterministic order and conflicts", () => {
+  const snapshot = buildExecutionGraphSnapshot(
+    [
+      { id: "b", kind: "unit", dependsOn: ["a"], writes: ["src/shared.ts"] },
+      { id: "a", kind: "unit", dependsOn: [], writes: ["src/a.ts"] },
+      { id: "c", kind: "verification", dependsOn: [], writes: ["src/shared.ts"] },
+    ],
+    "before-unit",
+  );
+
+  assert.equal(snapshot.phase, "before-unit");
+  assert.deepEqual(snapshot.order, ["a", "b", "c"]);
+  assert.ok(snapshot.conflicts.some((c) => c.file === "src/shared.ts"));
+});

package/src/resources/extensions/gsd/tests/uok-gate-runner.test.ts

@@ -68,3 +68,78 @@ test("uok gate runner returns manual-attention for unknown gate id", async () =>
   assert.equal(result.outcome, "manual-attention");
   assert.equal(result.failureClass, "unknown");
 });
+
+// Regression tests for #4950
+
+test("uok gate runner: gate.execute throws — outcome is fail, audit emitted, DB row written, no exception escapes", async () => {
+  const runner = new UokGateRunner();
+
+  runner.register({
+    id: "throwing-gate",
+    type: "verification",
+    execute: async () => {
+      throw new Error("unexpected runtime failure");
+    },
+  });
+
+  let threw = false;
+  let result;
+  try {
+    result = await runner.run("throwing-gate", {
+      basePath: process.cwd(),
+      traceId: "trace-throw",
+      turnId: "turn-throw",
+    });
+  } catch {
+    threw = true;
+  }
+
+  assert.equal(threw, false, "run() must not throw when gate.execute throws");
+  assert.equal(result?.outcome, "fail");
+  assert.equal(result?.failureClass, "unknown");
+  assert.equal(result?.rationale, "unexpected runtime failure");
+
+  const adapter = _getAdapter();
+  const rows = adapter?.prepare("SELECT gate_id, outcome, failure_class FROM gate_runs WHERE gate_id = 'throwing-gate'").all() ?? [];
+  assert.ok(rows.length >= 1, "at least one DB row must be written for a thrown gate");
+  assert.equal(rows[0]?.["outcome"], "fail");
+});
+
+test("uok gate runner: unknown gate id emits audit + DB row with manual-attention", async () => {
+  const runner = new UokGateRunner();
+
+  await runner.run("ghost-gate", {
+    basePath: process.cwd(),
+    traceId: "trace-ghost",
+    turnId: "turn-ghost",
+  });
+
+  const adapter = _getAdapter();
+  const rows = adapter?.prepare("SELECT gate_id, outcome, failure_class FROM gate_runs WHERE gate_id = 'ghost-gate'").all() ?? [];
+  assert.equal(rows.length, 1, "unknown gate must write exactly one DB row");
+  assert.equal(rows[0]?.["outcome"], "manual-attention");
+});
+
+test("uok gate runner: maxAttempts reported equals retryBudget + 1", async () => {
+  const runner = new UokGateRunner();
+
+  // timeout has retryBudget=2, so maxAttempts should be 3
+  runner.register({
+    id: "budget-gate",
+    type: "verification",
+    execute: async () => ({
+      outcome: "fail",
+      failureClass: "timeout",
+      rationale: "always fails",
+    }),
+  });
+
+  const result = await runner.run("budget-gate", {
+    basePath: process.cwd(),
+    traceId: "trace-budget",
+    turnId: "turn-budget",
+  });
+
+  // retryBudget for "timeout" is 2, so maxAttempts must be 3
+  assert.equal(result.maxAttempts, 3, "maxAttempts must equal retryBudget + 1");
+});

package/src/resources/extensions/gsd/tests/uok-gitops-wiring.test.ts

@@ -1,35 +1,58 @@
+/**
+ * UOK gitops wiring — post-unit pre-verification policy.
+ *
+ * Tests the pure policy bit that selects the turn-level git action from
+ * resolved UOK flags. The integration wiring (postUnitPreVerification
+ * calling runTurnGitAction, writeTurnGitTransaction, the UokGateRunner
+ * closeout pathway, and buildSnapshotOpts' trace/turn ID plumbing) is
+ * exercised end-to-end by the auto-loop and UOK kernel integration tests;
+ * the earlier source-grep assertions duplicated that coverage without
+ * actually exercising the code, and have been removed.
+ */
+
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const gsdDir = join(__dirname, "..");
+import { resolveUokFlags } from "../uok/flags.ts";
+
+test("turn action defaults to commit when uok.gitops is enabled with no override", () => {
+  const flags = resolveUokFlags({ uok: { gitops: { enabled: true } } } as any);
+  assert.equal(flags.gitops, true);
+  assert.equal(flags.gitopsTurnAction, "commit");
+});
+
+test("turn action reflects uok.gitops.turn_action when set to snapshot", () => {
+  const flags = resolveUokFlags({
+    uok: { gitops: { enabled: true, turn_action: "snapshot" } },
+  } as any);
+  assert.equal(flags.gitops, true);
+  assert.equal(flags.gitopsTurnAction, "snapshot");
+});
 
-test("post-unit pre-verification selects turn git action from UOK gitops flags", () => {
-  const source = readFileSync(join(gsdDir, "auto-post-unit.ts"), "utf-8");
-  assert.ok(
-    source.includes("const turnAction: TurnGitActionMode = uokFlags.gitops ? uokFlags.gitopsTurnAction : \"commit\""),
-    "postUnitPreVerification should derive turn action from uok.gitops.turn_action when enabled",
-  );
+test("turn action reflects uok.gitops.turn_action when set to status-only", () => {
+  const flags = resolveUokFlags({
+    uok: { gitops: { enabled: true, turn_action: "status-only" } },
+  } as any);
+  assert.equal(flags.gitops, true);
+  assert.equal(flags.gitopsTurnAction, "status-only");
 });
 
-test("post-unit pre-verification routes git failures through closeout gate", () => {
-  const source = readFileSync(join(gsdDir, "auto-post-unit.ts"), "utf-8");
-  assert.ok(
-    source.includes('id: "closeout-git-action"') &&
-    source.includes('type: "closeout"') &&
-    source.includes('failureClass: "git"'),
-    "git failures should be persisted via a closeout gate with failureClass=git",
-  );
+test("turn_push flag round-trips through resolveUokFlags", () => {
+  const on = resolveUokFlags({
+    uok: { gitops: { enabled: true, turn_push: true } },
+  } as any);
+  const off = resolveUokFlags({
+    uok: { gitops: { enabled: true, turn_push: false } },
+  } as any);
+  assert.equal(on.gitopsTurnPush, true);
+  assert.equal(off.gitopsTurnPush, false);
 });
 
-test("auto snapshot opts carry trace/turn IDs for turn closeout records", () => {
-  const source = readFileSync(join(gsdDir, "auto.ts"), "utf-8");
-  assert.ok(
-    source.includes("traceId: s.currentTraceId ?? undefined") &&
-    source.includes("turnId: s.currentTurnId ?? undefined"),
-    "buildSnapshotOpts should pass trace/turn IDs into closeout options",
-  );
+test("gitops disabled when uok.gitops.enabled is explicitly false", () => {
+  const flags = resolveUokFlags({
+    uok: { gitops: { enabled: false, turn_action: "snapshot" } },
+  } as any);
+  assert.equal(flags.gitops, false);
+  // Turn_action is still surfaced so callers can read their policy cleanly.
+  assert.equal(flags.gitopsTurnAction, "snapshot");
 });

package/src/resources/extensions/gsd/tests/uok-loop-adapter-writer.test.ts

@@ -0,0 +1,65 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { createTurnObserver } from "../uok/loop-adapter.ts";
+import { hasActiveWriterToken, resetWriterTokensForTests } from "../uok/writer.ts";
+
+function readAuditPayloads(basePath: string): Array<Record<string, unknown>> {
+  const path = join(basePath, ".gsd", "audit", "events.jsonl");
+  if (!existsSync(path)) return [];
+  return readFileSync(path, "utf-8")
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line) as { payload?: Record<string, unknown> })
+    .map((event) => event.payload ?? {});
+}
+
+test("uok turn observer adds writer sequence metadata to audit events", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-uok-loop-writer-"));
+  resetWriterTokensForTests();
+  t.after(() => {
+    resetWriterTokensForTests();
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const observer = createTurnObserver({
+    basePath,
+    gitAction: "status-only",
+    gitPush: false,
+    enableAudit: true,
+    enableGitops: false,
+  });
+
+  observer.onTurnStart({
+    basePath,
+    traceId: "trace-1",
+    turnId: "turn-1",
+    iteration: 1,
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    startedAt: new Date().toISOString(),
+  });
+  assert.equal(hasActiveWriterToken(basePath, "turn-1"), true);
+
+  observer.onTurnResult({
+    traceId: "trace-1",
+    turnId: "turn-1",
+    iteration: 1,
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    status: "completed",
+    failureClass: "none",
+    phaseResults: [],
+    startedAt: new Date().toISOString(),
+    finishedAt: new Date().toISOString(),
+  });
+
+  assert.equal(hasActiveWriterToken(basePath, "turn-1"), false);
+  const payloads = readAuditPayloads(basePath);
+  assert.equal(payloads[0]?.writeSequence, 1);
+  assert.equal(payloads[1]?.writeSequence, 2);
+  assert.equal(typeof payloads[0]?.writerTokenId, "string");
+});

package/src/resources/extensions/gsd/tests/uok-parity-report.test.ts

@@ -0,0 +1,42 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, appendFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { buildParityReport, parseParityEvents, writeParityReport } from "../uok/parity-report.ts";
+
+test("uok parity report summarizes paths, statuses, and fallback use", () => {
+  const events = parseParityEvents([
+    JSON.stringify({ path: "uok-kernel", phase: "enter" }),
+    JSON.stringify({ path: "uok-kernel", phase: "exit", status: "ok" }),
+    JSON.stringify({ path: "legacy-fallback", phase: "enter" }),
+    JSON.stringify({ path: "legacy-fallback", phase: "exit", status: "error", error: "boom" }),
+  ].join("\n"));
+
+  const report = buildParityReport(events, "/tmp/uok-parity.jsonl");
+  assert.equal(report.totalEvents, 4);
+  assert.equal(report.paths["uok-kernel"], 2);
+  assert.equal(report.fallbackInvocations, 2);
+  assert.deepEqual(report.criticalMismatches, ["boom"]);
+});
+
+test("uok parity report writes runtime report artifact", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-uok-parity-"));
+  t.after(() => {
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const runtime = join(basePath, ".gsd", "runtime");
+  mkdirSync(runtime, { recursive: true });
+  appendFileSync(
+    join(runtime, "uok-parity.jsonl"),
+    `${JSON.stringify({ path: "uok-kernel", phase: "exit", status: "ok" })}\n`,
+    "utf-8",
+  );
+
+  const report = writeParityReport(basePath);
+  assert.equal(report.totalEvents, 1);
+  const saved = JSON.parse(readFileSync(join(runtime, "uok-parity-report.json"), "utf-8"));
+  assert.equal(saved.statuses.ok, 1);
+});

package/src/resources/extensions/gsd/tests/uok-plan-v2-wiring.test.ts

@@ -13,7 +13,11 @@ import {
   openDatabase,
 } from "../gsd-db.ts";
 import type { GSDState, Phase } from "../types.ts";
-import { ensurePlanV2Graph } from "../uok/plan-v2.ts";
+import {
+  ensurePlanV2Graph,
+  hasFinalizedMilestoneContext,
+  isMissingFinalizedContextResult,
+} from "../uok/plan-v2.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const gsdDir = join(__dirname, "..");
@@ -88,7 +92,7 @@ test.afterEach(() => {
   tempDirs.clear();
 });
 
-test("guided flow enforces plan-v2 gate before execution-oriented dispatch", () => {
+test("guided flow keeps plan-v2 fail-closed handling for non-recoverable failures", () => {
   const source = readFileSync(join(gsdDir, "guided-flow.ts"), "utf-8");
   assert.ok(
     source.includes("needsPlanV2Gate") &&
@@ -98,6 +102,17 @@ test("guided flow enforces plan-v2 gate before execution-oriented dispatch", ()
   );
 });
 
+test("guided flow routes recoverable missing finalized context to discuss-milestone", () => {
+  const source = readFileSync(join(gsdDir, "guided-flow.ts"), "utf-8");
+  assert.ok(
+    source.includes('PlanV2GateDecision = "pass" | "recover-missing-context" | "block"') &&
+    source.includes("isMissingFinalizedContextResult(compiled)") &&
+    source.includes('planV2GateDecision === "recover-missing-context"') &&
+    source.includes("buildDiscussMilestonePrompt"),
+    "guided flow should redispatch missing finalized context to discuss-milestone instead of fail-closing",
+  );
+});
+
 test("plan-v2 gate fails closed for execution phase when finalized context is missing", () => {
   const basePath = createBasePath();
   seedGraphRows();
@@ -107,6 +122,7 @@ test("plan-v2 gate fails closed for execution phase when finalized context is mi
   const compiled = ensurePlanV2Graph(basePath, buildState("executing"));
   assert.equal(compiled.ok, false);
   assert.match(compiled.reason ?? "", /CONTEXT\.md/i);
+  assert.equal(isMissingFinalizedContextResult(compiled), true);
 });
 
 test("plan-v2 gate accepts finalized context from project-root fallback", () => {
@@ -123,6 +139,7 @@ test("plan-v2 gate accepts finalized context from project-root fallback", () =>
     const compiled = ensurePlanV2Graph(worktreeBase, buildState("executing"));
     assert.equal(compiled.ok, true);
     assert.equal(compiled.finalizedContextIncluded, true);
+    assert.equal(hasFinalizedMilestoneContext(worktreeBase, MILESTONE_ID), true);
   } finally {
     if (prevProjectRoot === undefined) {
       delete process.env.GSD_PROJECT_ROOT;

package/src/resources/extensions/gsd/tests/uok-writer.test.ts

@@ -0,0 +1,75 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  acquireWriterToken,
+  hasActiveWriterToken,
+  nextWriteRecord,
+  releaseWriterToken,
+  resetWriterTokensForTests,
+} from "../uok/writer.ts";
+
+test("uok writer enforces one active token per turn", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-uok-writer-"));
+  resetWriterTokensForTests();
+  t.after(() => {
+    resetWriterTokensForTests();
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const token = acquireWriterToken({
+    basePath,
+    traceId: "trace-1",
+    turnId: "turn-1",
+  });
+  assert.equal(hasActiveWriterToken(basePath, "turn-1"), true);
+  assert.throws(
+    () => acquireWriterToken({ basePath, traceId: "trace-1", turnId: "turn-1" }),
+    /already active/,
+  );
+
+  releaseWriterToken(basePath, token);
+  assert.equal(hasActiveWriterToken(basePath, "turn-1"), false);
+});
+
+test("uok writer produces monotonic sequence records across turns", (t) => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-uok-writer-seq-"));
+  resetWriterTokensForTests();
+  t.after(() => {
+    resetWriterTokensForTests();
+    rmSync(basePath, { recursive: true, force: true });
+  });
+
+  const token1 = acquireWriterToken({
+    basePath,
+    traceId: "trace-1",
+    turnId: "turn-1",
+  });
+  const first = nextWriteRecord({
+    basePath,
+    token: token1,
+    category: "audit",
+    operation: "append",
+    path: ".gsd/audit/events.jsonl",
+  });
+  releaseWriterToken(basePath, token1);
+
+  const token2 = acquireWriterToken({
+    basePath,
+    traceId: "trace-2",
+    turnId: "turn-2",
+  });
+  const second = nextWriteRecord({
+    basePath,
+    token: token2,
+    category: "gitops",
+    operation: "insert",
+  });
+
+  assert.equal(first.sequence.sequence, 1);
+  assert.equal(second.sequence.sequence, 2);
+  assert.equal(second.sequence.turnId, "turn-2");
+});

package/src/resources/extensions/gsd/tests/validate-milestone.test.ts

@@ -41,6 +41,12 @@ function writeRoadmap(base: string, mid: string, content: string): void {
   writeFileSync(join(dir, `${mid}-ROADMAP.md`), content);
 }
 
+function writeContext(base: string, mid: string, content = "# M001 Context\n\nValidated context."): void {
+  const dir = join(base, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-CONTEXT.md`), content);
+}
+
 function writeMilestoneSummary(base: string, mid: string, content: string): void {
   const dir = join(base, ".gsd", "milestones", mid);
   mkdirSync(dir, { recursive: true });
@@ -265,6 +271,7 @@ Test
     assert.match(prompt, /S01 Summary/i, "prompt should inline non-skipped slice summaries");
     assert.doesNotMatch(prompt, /### S02 Summary/i, "prompt should not inline skipped slice summaries");
     assert.doesNotMatch(prompt, /not found — file does not exist yet/i, "prompt should not emit skipped-slice missing-file placeholders");
+    assert.doesNotMatch(prompt, /S02-SUMMARY\.md/, "skipped slice must not appear in on-demand path list (#4780)");
   } finally {
     cleanup(base);
   }
@@ -328,6 +335,7 @@ test("dispatch rule matches validating-milestone phase", async () => {
   const base = makeTmpBase();
   try {
     // Set up minimal milestone structure for the prompt builder
+    writeContext(base, "M001");
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
     writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDone."); // Guard requires slice summaries (#1368)
 
@@ -364,6 +372,7 @@ test("dispatch rule skips when skip_milestone_validation preference is set", asy
 
   const base = makeTmpBase();
   try {
+    writeContext(base, "M001");
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
     writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDone."); // Guard requires slice summaries (#1368)
 
@@ -402,6 +411,7 @@ test("dispatch rule fails closed for failure-path SUMMARY when DB milestone is n
   try {
     openTestDb(base);
     insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeContext(base, "M001");
     writeMilestoneSummary(base, "M001", "# Milestone Summary\nverification FAILED — not complete.");
 
     const ctx: DispatchContext = {
@@ -439,6 +449,7 @@ test("dispatch rule reconciles DB for successful stale SUMMARY (#4658)", async (
   try {
     openTestDb(base);
     insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeContext(base, "M001");
     writeMilestoneSummary(
       base,
       "M001",
@@ -487,6 +498,7 @@ test("dispatch rule fails closed for ambiguous stale SUMMARY (#4658)", async ()
   try {
     openTestDb(base);
     insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeContext(base, "M001");
     writeMilestoneSummary(base, "M001", "# M001 Summary\nSome notes without completion metadata.");
 
     const ctx: DispatchContext = {