gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.96d4bb599

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

@@ -31,18 +31,30 @@ describe("slice CONTEXT.md injection into prompt builders (#3452)", () => {
       const fnStart = source.indexOf(`export async function ${builder}`);
       assert.ok(fnStart !== -1, `${builder} should exist in auto-prompts.ts`);
 
-      // Get a reasonable chunk after the function start (enough to cover the inlining section)
+      // Get a reasonable chunk after the function start
       const chunk = source.slice(fnStart, fnStart + 3000);
 
+      // ADR-011: buildPlanSlicePrompt / buildRefineSlicePrompt now delegate to
+      // a shared helper (renderSlicePrompt) that performs the slice CONTEXT
+      // resolve. When a builder delegates, scan the helper's body instead.
+      const delegatesToHelper = chunk.includes("renderSlicePrompt(");
+      const bodyToCheck = delegatesToHelper
+        ? (() => {
+            const helperStart = source.indexOf("async function renderSlicePrompt");
+            assert.ok(helperStart !== -1, "renderSlicePrompt helper must exist");
+            return source.slice(helperStart, helperStart + 3000);
+          })()
+        : chunk;
+
       // Must resolve the slice CONTEXT path
       assert.ok(
-        chunk.includes('resolveSliceFile(base, mid,') && chunk.includes('"CONTEXT"'),
-        `${builder} should call resolveSliceFile with "CONTEXT"`,
+        bodyToCheck.includes('resolveSliceFile(base, mid,') && bodyToCheck.includes('"CONTEXT"'),
+        `${builder} should call resolveSliceFile with "CONTEXT" (directly or via renderSlicePrompt)`,
       );
 
       // Must inline it with inlineFileOptional
       assert.ok(
-        chunk.includes('Slice Context'),
+        bodyToCheck.includes("Slice Context"),
         `${builder} should inline slice CONTEXT with a "Slice Context" label`,
       );
     });

package/src/resources/extensions/gsd/tests/state-corruption-2945.test.ts

@@ -93,6 +93,8 @@ function makeSliceRow(id: string, overrides: Partial<SliceRow> = {}): SliceRow {
     integration_closure: "",
     observability_impact: "",
     replan_triggered_at: null,
+    is_sketch: 0,
+    sketch_scope: "",
     ...overrides,
   };
 }
@@ -295,6 +297,7 @@ describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merg
       loadEffectiveGSDPreferences: () => undefined,
       invalidateAllCaches: () => {},
       captureIntegrationBranch: () => {},
+      enterBranchModeForMilestone: () => {},
     };
 
     // Import and create resolver

package/src/resources/extensions/gsd/tests/stuck-detection-coverage.test.ts

@@ -79,6 +79,21 @@ test("Rule 2: interrupted sequence does not trigger", () => {
   );
 });
 
+test("Rule 2b: same unit repeated 3 times in the window triggers stuck even with an intervening unit", () => {
+  const result = detectStuck([
+    { key: "execute-task/M002/S03/T01" },
+    { key: "execute-task/M002/S03/T01" },
+    { key: "reassess-roadmap/M002/S02" },
+    { key: "execute-task/M002/S03/T01" },
+  ]);
+  assert.notEqual(result, null);
+  assert.equal(result!.stuck, true);
+  assert.ok(
+    result!.reason.includes("3 times in last 4 attempts"),
+    `reason was: ${result!.reason}`,
+  );
+});
+
 // ─── Rule 3: Oscillation A→B→A→B ─────────────────────────────────────────────
 
 test("Rule 3: A-B-A-B oscillation triggers stuck", () => {

package/src/resources/extensions/gsd/tests/summary-render-parity.test.ts

@@ -50,6 +50,11 @@ const taskRow: TaskRow = {
   observability_impact: "",
   full_plan_md: "",
   sequence: 1,
+  blocker_source: "",
+  escalation_pending: 0,
+  escalation_awaiting_review: 0,
+  escalation_artifact_path: null,
+  escalation_override_applied_at: null,
 };
 
 const verificationEvidence = [

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

@@ -64,8 +64,9 @@ test("uok contracts include required DAG node kinds", () => {
     "team-worker",
     "verification",
     "reprocess",
+    "refine",
   ];
-  assert.deepEqual(required.length, 6);
+  assert.deepEqual(required.length, 7);
 });
 
 test("uok audit envelope includes trace/turn/causality fields", () => {

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

@@ -7,6 +7,37 @@ test("uok flags default to enabled when preference is unset", () => {
   const flags = resolveUokFlags(undefined);
   assert.equal(flags.enabled, true);
   assert.equal(flags.legacyFallback, false);
+  assert.equal(flags.gates, true);
+  assert.equal(flags.modelPolicy, true);
+  assert.equal(flags.executionGraph, true);
+  assert.equal(flags.gitops, true);
+  assert.equal(flags.auditUnified, true);
+  assert.equal(flags.planV2, true);
+  assert.equal(flags.gitopsTurnAction, "commit");
+  assert.equal(flags.gitopsTurnPush, false);
+});
+
+test("uok nested flags support explicit opt-out", () => {
+  const flags = resolveUokFlags({
+    uok: {
+      enabled: true,
+      gates: { enabled: false },
+      model_policy: { enabled: false },
+      execution_graph: { enabled: false },
+      gitops: { enabled: false, turn_action: "commit", turn_push: true },
+      audit_unified: { enabled: false },
+      plan_v2: { enabled: false },
+    },
+  });
+  assert.equal(flags.enabled, true);
+  assert.equal(flags.gates, false);
+  assert.equal(flags.modelPolicy, false);
+  assert.equal(flags.executionGraph, false);
+  assert.equal(flags.gitops, false);
+  assert.equal(flags.auditUnified, false);
+  assert.equal(flags.planV2, false);
+  assert.equal(flags.gitopsTurnAction, "commit");
+  assert.equal(flags.gitopsTurnPush, true);
 });
 
 test("uok legacy fallback preference forces legacy path", () => {
@@ -36,4 +67,3 @@ test("uok legacy fallback env var forces legacy path", () => {
     else process.env.GSD_UOK_FORCE_LEGACY = previous;
   }
 });
-

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

@@ -0,0 +1,166 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
+
+import { runAutoLoopWithUok } from "../uok/kernel.ts";
+import type { AutoSession } from "../auto/session.ts";
+import type { LoopDeps } from "../auto/loop-deps.ts";
+import { gsdRoot } from "../paths.ts";
+import type { GSDPreferences } from "../preferences.ts";
+
+function makeBasePath(): string {
+  return mkdtempSync(join(tmpdir(), "gsd-uok-kernel-"));
+}
+
+function makeArgs(
+  basePath: string,
+  preferences: GSDPreferences | undefined,
+): {
+  ctx: ExtensionContext;
+  pi: ExtensionAPI;
+  s: AutoSession;
+  deps: LoopDeps;
+  runKernelLoop: (
+    ctx: ExtensionContext,
+    pi: ExtensionAPI,
+    s: AutoSession,
+    deps: LoopDeps,
+  ) => Promise<void>;
+  runLegacyLoop: (
+    ctx: ExtensionContext,
+    pi: ExtensionAPI,
+    s: AutoSession,
+    deps: LoopDeps,
+  ) => Promise<void>;
+  calls: {
+    kernel: number;
+    legacy: number;
+    kernelDeps: LoopDeps | null;
+    legacyDeps: LoopDeps | null;
+  };
+} {
+  const calls = {
+    kernel: 0,
+    legacy: 0,
+    kernelDeps: null as LoopDeps | null,
+    legacyDeps: null as LoopDeps | null,
+  };
+
+  return {
+    ctx: {
+      sessionManager: {
+        getSessionId: (): string => "session-test",
+      },
+    } as unknown as ExtensionContext,
+    pi: {} as unknown as ExtensionAPI,
+    s: {
+      basePath,
+      autoStartTime: 1,
+    } as unknown as AutoSession,
+    deps: {
+      loadEffectiveGSDPreferences: () => ({ preferences }),
+    } as unknown as LoopDeps,
+    runKernelLoop: async (_ctx, _pi, _s, loopDeps): Promise<void> => {
+      calls.kernel += 1;
+      calls.kernelDeps = loopDeps;
+    },
+    runLegacyLoop: async (_ctx, _pi, _s, loopDeps): Promise<void> => {
+      calls.legacy += 1;
+      calls.legacyDeps = loopDeps;
+    },
+    calls,
+  };
+}
+
+function readParityEvents(basePath: string): Array<Record<string, unknown>> {
+  const file = join(gsdRoot(basePath), "runtime", "uok-parity.jsonl");
+  const raw = readFileSync(file, "utf-8").trim();
+  if (raw.length === 0) return [];
+  return raw.split("\n").map(line => JSON.parse(line) as Record<string, unknown>);
+}
+
+test("runAutoLoopWithUok uses kernel path by default and records uok-kernel parity", async () => {
+  const basePath = makeBasePath();
+  try {
+    const args = makeArgs(basePath, {
+      uok: {
+        enabled: true,
+        audit_unified: { enabled: false },
+        gitops: { enabled: false },
+      },
+    });
+    await runAutoLoopWithUok(args);
+
+    assert.equal(args.calls.kernel, 1);
+    assert.equal(args.calls.legacy, 0);
+    assert.ok(args.calls.kernelDeps);
+    assert.notEqual(args.calls.kernelDeps, args.deps);
+    assert.ok(args.calls.kernelDeps?.uokObserver);
+    assert.equal(process.env.GSD_UOK_AUDIT_UNIFIED, "0");
+
+    const events = readParityEvents(basePath);
+    assert.equal(events.length, 2);
+    assert.equal(events[0]?.path, "uok-kernel");
+    assert.equal(events[0]?.phase, "enter");
+    assert.equal(events[1]?.path, "uok-kernel");
+    assert.equal(events[1]?.phase, "exit");
+    assert.equal(events[1]?.status, "ok");
+  } finally {
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("runAutoLoopWithUok uses legacy path when explicit legacy fallback is enabled", async () => {
+  const basePath = makeBasePath();
+  try {
+    const args = makeArgs(basePath, {
+      uok: {
+        enabled: true,
+        legacy_fallback: { enabled: true },
+      },
+    });
+    await runAutoLoopWithUok(args);
+
+    assert.equal(args.calls.kernel, 0);
+    assert.equal(args.calls.legacy, 1);
+    assert.equal(args.calls.legacyDeps, args.deps);
+
+    const events = readParityEvents(basePath);
+    assert.equal(events.length, 2);
+    assert.equal(events[0]?.path, "legacy-fallback");
+    assert.equal(events[1]?.path, "legacy-fallback");
+    assert.equal(events[1]?.status, "ok");
+  } finally {
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("runAutoLoopWithUok respects GSD_UOK_FORCE_LEGACY emergency switch", async () => {
+  const basePath = makeBasePath();
+  const previous = process.env.GSD_UOK_FORCE_LEGACY;
+  process.env.GSD_UOK_FORCE_LEGACY = "1";
+  try {
+    const args = makeArgs(basePath, {
+      uok: {
+        enabled: true,
+      },
+    });
+    await runAutoLoopWithUok(args);
+
+    assert.equal(args.calls.kernel, 0);
+    assert.equal(args.calls.legacy, 1);
+
+    const events = readParityEvents(basePath);
+    assert.equal(events.length, 2);
+    assert.equal(events[0]?.path, "legacy-fallback");
+    assert.equal(events[1]?.path, "legacy-fallback");
+  } finally {
+    if (previous === undefined) delete process.env.GSD_UOK_FORCE_LEGACY;
+    else process.env.GSD_UOK_FORCE_LEGACY = previous;
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});

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

@@ -997,3 +997,38 @@ test("dependency-audit: subdirectory package.json does not trigger audit", () =>
   assert.equal(npmAuditCalled, false, "subdirectory dependency files should not trigger audit");
   assert.deepStrictEqual(result, []);
 });
+
+// ─── Python normalization (regression: #4416) ────────────────────────────────
+// Verification commands using python3/python must succeed even when only the
+// alternate interpreter name is available. The gate rewrites the command via
+// normalizePythonCommand before spawning — tested here end-to-end on this host.
+
+describe("verification-gate: python normalization (#4416)", () => {
+  let tmp: string;
+  beforeEach(() => { tmp = makeTempDir("vg-python"); });
+  afterEach(() => { rmSync(tmp, { recursive: true, force: true }); });
+
+  test("python3 --version command succeeds on this host (gate uses normalized invocation)", () => {
+    // This test verifies that runVerificationGate can execute a python command
+    // without hard-failing due to interpreter name mismatch. On hosts where
+    // python3 is available it runs directly; on hosts where only python or py
+    // exists, normalizePythonCommand rewrites the token before spawnSync.
+    const result = runVerificationGate({
+      cwd: tmp,
+      preferenceCommands: ["python3 --version"],
+    });
+    assert.equal(typeof result.passed, "boolean");
+    assert.equal(result.checks.length, 1);
+    assert.ok(result.checks[0].durationMs >= 0);
+  });
+
+  test("python --version command produces a VerificationResult (not a crash)", () => {
+    const result = runVerificationGate({
+      cwd: tmp,
+      preferenceCommands: ["python --version"],
+    });
+    assert.equal(typeof result.passed, "boolean");
+    assert.equal(result.checks.length, 1);
+    assert.ok(result.checks[0].durationMs >= 0);
+  });
+});

package/src/resources/extensions/gsd/tests/workflow-install.test.ts

@@ -0,0 +1,113 @@
+// gsd-2 — Regression tests for workflow-install path containment and ext fallback.
+
+import { describe, it, afterEach, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync } from "node:fs";
+import { join, sep as pathSep } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  installPlugin,
+  uninstallPlugin,
+  projectInstallDir,
+  type FetchedContent,
+  type InstallTarget,
+} from "../workflow-install.ts";
+import { parseWorkflowOverridesOnly } from "../commands/handlers/workflow.ts";
+
+const tmpDirs: string[] = [];
+let savedGsdHome: string | undefined;
+
+function makeTmpBase(): string {
+  const dir = mkdtempSync(join(tmpdir(), "wf-install-test-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+beforeEach(() => {
+  savedGsdHome = process.env.GSD_HOME;
+  process.env.GSD_HOME = makeTmpBase();
+});
+
+afterEach(() => {
+  if (savedGsdHome === undefined) delete process.env.GSD_HOME;
+  else process.env.GSD_HOME = savedGsdHome;
+  for (const d of tmpDirs) {
+    try { rmSync(d, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 }); } catch { /* ignore */ }
+  }
+  tmpDirs.length = 0;
+});
+
+function fakeFetched(content: string, ext: ".yaml" | ".md" = ".yaml"): FetchedContent {
+  return {
+    url: `https://example.test/raw/foo${ext}`,
+    filename: `foo${ext}`,
+    ext,
+    content,
+    sha256: "deadbeef",
+  };
+}
+
+describe("workflow-install path containment", () => {
+  it("installPlugin rejects names with path separators", () => {
+    const base = makeTmpBase();
+    const target: InstallTarget = { dir: projectInstallDir(base), scope: "project" };
+    const fetched = fakeFetched("name: ok\nsteps: []\n");
+    assert.throws(() => installPlugin(target, fetched, "../evil"), /Invalid plugin name/);
+    assert.throws(() => installPlugin(target, fetched, "evil/nested"), /Invalid plugin name/);
+    assert.throws(() => installPlugin(target, fetched, ".."), /Invalid plugin name/);
+  });
+
+  it("uninstallPlugin rejects names with path separators", () => {
+    const base = makeTmpBase();
+    assert.throws(() => uninstallPlugin(base, "../evil"), /Invalid plugin name/);
+    assert.throws(() => uninstallPlugin(base, "evil/nested"), /Invalid plugin name/);
+  });
+
+  it("installPlugin writes a safe name into the target dir", () => {
+    const base = makeTmpBase();
+    const target: InstallTarget = { dir: projectInstallDir(base), scope: "project" };
+    const fetched = fakeFetched("name: ok\nsteps: []\n");
+    const result = installPlugin(target, fetched, "safe-name");
+    assert.ok(result.path.startsWith(target.dir + pathSep) || result.path === join(target.dir, "safe-name.yaml"));
+    assert.ok(existsSync(result.path));
+  });
+
+  it("uninstallPlugin ignores provenance entries whose filename escapes the dir", () => {
+    const base = makeTmpBase();
+    const target: InstallTarget = { dir: projectInstallDir(base), scope: "project" };
+    mkdirSync(target.dir, { recursive: true });
+    // Seed a malicious provenance record.
+    const bogus = {
+      "hijack": {
+        source: "https://example.test/x",
+        installedAt: new Date().toISOString(),
+        sha256: "0",
+        filename: "../../etc/passwd",
+      },
+    };
+    writeFileSync(join(target.dir, ".installed.json"), JSON.stringify(bogus), "utf-8");
+    assert.throws(() => uninstallPlugin(base, "hijack"), /Invalid plugin name|Refusing to operate outside/);
+  });
+});
+
+describe("parseWorkflowOverridesOnly", () => {
+  it("keeps all k=v pairs when no name prefix is present", () => {
+    const ov = parseWorkflowOverridesOnly("target=src/foo.ts newName=bar");
+    assert.equal(ov.target, "src/foo.ts");
+    assert.equal(ov.newName, "bar");
+  });
+
+  it("does not drop the first argument", () => {
+    const ov = parseWorkflowOverridesOnly("a=1 b=2");
+    assert.equal(ov.a, "1");
+    assert.equal(ov.b, "2");
+  });
+
+  it("ignores tokens without `=`", () => {
+    const ov = parseWorkflowOverridesOnly("a=1 bareword b=2");
+    assert.equal(ov.a, "1");
+    assert.equal(ov.b, "2");
+    assert.equal(Object.keys(ov).length, 2);
+  });
+});

package/src/resources/extensions/gsd/tests/workflow-logger-wiring.test.ts

@@ -88,15 +88,24 @@ test("runFinalize drains and surfaces logger buffer via ctx.ui.notify", () => {
 });
 
 test("runFinalize timeout branches drain the buffer to prevent bleed", () => {
-  // Both timeout branches null out s.currentUnit — they should also drain
-  // so accumulated logs for the timed-out unit don't leak into the next.
+  // Both timeout branches route through failClosedOnFinalizeTimeout; that
+  // helper must drain the buffer so timed-out unit logs do not bleed into
+  // the next unit.
   const runFinalizeIdx = phasesSrc.indexOf("export async function runFinalize");
   const finalizeBody = phasesSrc.slice(runFinalizeIdx);
-  const drainCallCount =
-    (finalizeBody.match(/drainLogs\(\)/g) ?? []).length;
+  const timeoutHelperCalls =
+    (finalizeBody.match(/failClosedOnFinalizeTimeout\(/g) ?? []).length;
   assert.ok(
-    drainCallCount >= 2,
-    `runFinalize timeout branches should each call drainLogs() (found ${drainCallCount}, expected >= 2)`,
+    timeoutHelperCalls >= 2,
+    `runFinalize timeout branches should each route through failClosedOnFinalizeTimeout() (found ${timeoutHelperCalls}, expected >= 2)`,
+  );
+
+  const helperMatch = phasesSrc.match(
+    /async function failClosedOnFinalizeTimeout[\s\S]*?drainLogs\(\)/,
+  );
+  assert.ok(
+    helperMatch,
+    "failClosedOnFinalizeTimeout should drain the logger buffer before returning",
   );
 });
 

package/src/resources/extensions/gsd/tests/workflow-mcp.test.ts

@@ -441,13 +441,13 @@ test("usesWorkflowMcpTransport matches local externalCli providers", () => {
   assert.equal(usesWorkflowMcpTransport("oauth", "local://custom"), false);
 });
 
-test("supportsStructuredQuestions disables structured ask flow on workflow MCP transports", () => {
+test("supportsStructuredQuestions stays enabled on workflow MCP transports when ask_user_questions is available", () => {
   assert.equal(
     supportsStructuredQuestions(["ask_user_questions"], {
       authMode: "externalCli",
       baseUrl: "local://claude-code",
     }),
-    false,
+    true,
   );
   assert.equal(
     supportsStructuredQuestions(["ask_user_questions"], {