gsd-pi 2.75.0 → 2.76.0-dev.4100bd590

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/validate-milestone.test.ts

@@ -177,16 +177,22 @@ test("deriveState returns completing-milestone when VALIDATION exists with termi
   }
 });
 
-test("deriveState treats needs-remediation as non-terminal — re-enters validating-milestone (#832)", async () => {
+test("deriveState returns blocked when needs-remediation has no incomplete slices (#4506)", async () => {
   const base = makeTmpBase();
   try {
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
     writeValidation(base, "M001", "---\nverdict: needs-remediation\nremediation_round: 0\n---\n\n# Validation\nNeeds fixes.");
 
     const state = await deriveState(base);
-    // needs-remediation routes back to validating-milestone for re-validation
-    assert.equal(state.phase, "validating-milestone");
+    // All slices done + needs-remediation → blocked (prevents infinite
+    // validate-milestone dispatch loop). Previously returned
+    // validating-milestone, which caused #4506.
+    assert.equal(state.phase, "blocked");
     assert.equal(state.activeMilestone?.id, "M001");
+    assert.ok(
+      state.blockers.some(b => b.includes("needs-remediation") && b.includes("M001")),
+      "blocker message should mention milestone and verdict",
+    );
   } finally {
     cleanup(base);
   }

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"], {