gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.fd2382b9f

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

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

@@ -0,0 +1,310 @@
+/**
+ * workflow-plugins.test.ts — Tests for the unified plugin discovery & resolution.
+ *
+ * Verifies precedence (project > global > bundled), both YAML and markdown
+ * formats, mode defaults, invalid-file handling, and legacy compat with
+ * `.gsd/workflow-defs/`.
+ */
+
+import { describe, it, afterEach, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  rmSync,
+  mkdirSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  discoverPlugins,
+  resolvePlugin,
+  listPluginsFormatted,
+  formatPluginInfo,
+} from "../workflow-plugins.ts";
+
+// ─── Test setup ──────────────────────────────────────────────────────────
+
+const tmpDirs: string[] = [];
+let savedGsdHome: string | undefined;
+
+function makeTmpBase(): string {
+  const dir = mkdtempSync(join(tmpdir(), "wf-plugins-test-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+beforeEach(() => {
+  savedGsdHome = process.env.GSD_HOME;
+  const fakeHome = makeTmpBase();
+  process.env.GSD_HOME = fakeHome;
+});
+
+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: 100 }); } catch { /* non-fatal */ }
+  }
+  tmpDirs.length = 0;
+});
+
+function writeFile(path: string, content: string): void {
+  mkdirSync(join(path, "..").replace(/[^/]+$/, ""), { recursive: true });
+  writeFileSync(path, content, "utf-8");
+}
+
+function writeProjectPlugin(basePath: string, filename: string, content: string): void {
+  const dir = join(basePath, ".gsd", "workflows");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, filename), content, "utf-8");
+}
+
+function writeGlobalPlugin(filename: string, content: string): void {
+  const dir = join(process.env.GSD_HOME!, "workflows");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, filename), content, "utf-8");
+}
+
+function writeLegacyDef(basePath: string, filename: string, content: string): void {
+  const dir = join(basePath, ".gsd", "workflow-defs");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, filename), content, "utf-8");
+}
+
+const SIMPLE_YAML = `
+version: 1
+name: sample
+description: A sample YAML plugin
+steps:
+  - id: s1
+    name: Step 1
+    prompt: Do the thing
+`;
+
+const SIMPLE_ONESHOT_YAML = `
+version: 1
+name: oneshot-sample
+mode: oneshot
+description: A oneshot yaml plugin
+steps:
+  - id: only
+    name: Only
+    prompt: Just do it
+`;
+
+const SIMPLE_MD = `# Sample MD Plugin
+
+<template_meta>
+name: sample-md
+version: 1
+mode: markdown-phase
+artifact_dir: .gsd/workflows/samples/
+</template_meta>
+
+<phases>
+1. one
+2. two
+</phases>
+`;
+
+const ONESHOT_MD = `# Oneshot MD Plugin
+
+<template_meta>
+name: oneshot-md
+version: 1
+mode: oneshot
+</template_meta>
+`;
+
+// ─── Bundled discovery ───────────────────────────────────────────────────
+
+describe("discoverPlugins: bundled tier", () => {
+  it("discovers the 8+ bundled templates", () => {
+    const base = makeTmpBase();
+    const plugins = discoverPlugins(base);
+    for (const id of ["bugfix", "hotfix", "spike", "full-project"]) {
+      assert.ok(plugins.has(id), `bundled plugin "${id}" should be discovered`);
+    }
+    assert.equal(plugins.get("bugfix")!.source, "bundled");
+    assert.equal(plugins.get("bugfix")!.format, "md");
+  });
+
+  it("bundled templates have valid mode values", () => {
+    const base = makeTmpBase();
+    const plugins = discoverPlugins(base);
+    const bugfix = plugins.get("bugfix")!;
+    assert.equal(bugfix.meta.mode, "markdown-phase");
+    const fullProject = plugins.get("full-project")!;
+    assert.equal(fullProject.meta.mode, "auto-milestone");
+  });
+});
+
+// ─── Project / Global / Bundled precedence ───────────────────────────────
+
+describe("discoverPlugins: precedence", () => {
+  it("project overrides bundled", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "bugfix.md", `# Overridden\n\n<template_meta>\nname: bugfix-override\nmode: markdown-phase\n</template_meta>`);
+    const plugins = discoverPlugins(base);
+    const bugfix = plugins.get("bugfix")!;
+    assert.equal(bugfix.source, "project");
+    assert.ok(bugfix.path.includes(".gsd/workflows/bugfix.md"));
+  });
+
+  it("global overrides bundled when project is absent", () => {
+    const base = makeTmpBase();
+    writeGlobalPlugin("bugfix.md", `# Global\n\n<template_meta>\nname: bugfix-global\nmode: markdown-phase\n</template_meta>`);
+    const plugins = discoverPlugins(base);
+    const bugfix = plugins.get("bugfix")!;
+    assert.equal(bugfix.source, "global");
+  });
+
+  it("project overrides global", () => {
+    const base = makeTmpBase();
+    writeGlobalPlugin("foo.yaml", SIMPLE_YAML);
+    writeProjectPlugin(base, "foo.yaml", SIMPLE_YAML.replace("sample", "foo"));
+    const plugins = discoverPlugins(base);
+    assert.equal(plugins.get("foo")!.source, "project");
+  });
+});
+
+// ─── YAML + MD format handling ───────────────────────────────────────────
+
+describe("discoverPlugins: formats", () => {
+  it("loads a project YAML plugin with default mode yaml-step", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "sample.yaml", SIMPLE_YAML);
+    const plugins = discoverPlugins(base);
+    const p = plugins.get("sample")!;
+    assert.equal(p.format, "yaml");
+    assert.equal(p.meta.mode, "yaml-step");
+    assert.equal(p.meta.displayName, "sample");
+  });
+
+  it("respects mode: oneshot in YAML", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "oneshot-sample.yaml", SIMPLE_ONESHOT_YAML);
+    const plugins = discoverPlugins(base);
+    assert.equal(plugins.get("oneshot-sample")!.meta.mode, "oneshot");
+  });
+
+  it("loads a project MD plugin with default mode markdown-phase", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "simple-md.md", `# Plain\n\n<template_meta>\nname: plain\n</template_meta>`);
+    const plugins = discoverPlugins(base);
+    assert.equal(plugins.get("simple-md")!.meta.mode, "markdown-phase");
+  });
+
+  it("respects mode: oneshot in MD", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "oneshot-md.md", ONESHOT_MD);
+    const plugins = discoverPlugins(base);
+    assert.equal(plugins.get("oneshot-md")!.meta.mode, "oneshot");
+  });
+
+  it("parses phases from MD <phases> block", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "sample-md.md", SIMPLE_MD);
+    const plugins = discoverPlugins(base);
+    const p = plugins.get("sample-md")!;
+    assert.deepEqual(p.meta.phases, ["one", "two"]);
+  });
+});
+
+// ─── Error handling ──────────────────────────────────────────────────────
+
+describe("discoverPlugins: error handling", () => {
+  it("invalid YAML surfaces as an entry with an error, doesn't crash", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "broken.yaml", "this: is: not: valid: yaml:\n  - x\n    - y");
+    const plugins = discoverPlugins(base);
+    const p = plugins.get("broken");
+    assert.ok(p, "broken plugin should still appear");
+    if (p!.error) {
+      assert.match(p!.error, /parse|object/i);
+    }
+  });
+
+  it("ignores subdirectories under .gsd/workflows/ (artifact dirs)", () => {
+    const base = makeTmpBase();
+    // Create a subdir — simulates `/gsd start bugfix` artifact dir
+    mkdirSync(join(base, ".gsd", "workflows", "bugfixes", "250101-1-slug"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "workflows", "bugfixes", "250101-1-slug", "STATE.json"), "{}", "utf-8");
+    const plugins = discoverPlugins(base);
+    assert.ok(!plugins.has("bugfixes"), "should not pick up subdir as a plugin");
+  });
+});
+
+// ─── resolvePlugin ───────────────────────────────────────────────────────
+
+describe("resolvePlugin", () => {
+  it("returns the plugin by name", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "foo.yaml", SIMPLE_YAML);
+    const p = resolvePlugin(base, "foo");
+    assert.ok(p);
+    assert.equal(p!.name, "foo");
+  });
+
+  it("returns null for unknown names", () => {
+    const base = makeTmpBase();
+    assert.equal(resolvePlugin(base, "nonexistent-plugin-xyz"), null);
+  });
+
+  it("resolves bundled templates", () => {
+    const base = makeTmpBase();
+    const p = resolvePlugin(base, "bugfix");
+    assert.ok(p);
+    assert.equal(p!.source, "bundled");
+  });
+});
+
+// ─── Legacy fallback ─────────────────────────────────────────────────────
+
+describe("discoverPlugins: legacy .gsd/workflow-defs/", () => {
+  it("still discovers legacy YAML definitions", () => {
+    const base = makeTmpBase();
+    writeLegacyDef(base, "legacy.yaml", SIMPLE_YAML);
+    const plugins = discoverPlugins(base);
+    assert.ok(plugins.has("legacy"), "legacy definition should be discovered");
+    assert.equal(plugins.get("legacy")!.format, "yaml");
+  });
+
+  it("new .gsd/workflows/ overrides legacy .gsd/workflow-defs/", () => {
+    const base = makeTmpBase();
+    writeLegacyDef(base, "dup.yaml", SIMPLE_YAML);
+    writeProjectPlugin(base, "dup.yaml", SIMPLE_YAML);
+    const plugins = discoverPlugins(base);
+    const p = plugins.get("dup")!;
+    assert.ok(p.path.includes(".gsd/workflows/dup.yaml"));
+  });
+});
+
+// ─── Display ─────────────────────────────────────────────────────────────
+
+describe("listPluginsFormatted", () => {
+  it("produces output grouped by mode with bundled templates", () => {
+    const base = makeTmpBase();
+    const out = listPluginsFormatted(base);
+    assert.match(out, /Workflow Plugins/);
+    assert.match(out, /\[markdown-phase\]/);
+    assert.match(out, /bugfix/);
+  });
+});
+
+describe("formatPluginInfo", () => {
+  it("formats YAML plugin info", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "foo.yaml", SIMPLE_YAML);
+    const p = resolvePlugin(base, "foo")!;
+    const info = formatPluginInfo(p);
+    assert.match(info, /Plugin:/);
+    assert.match(info, /Mode:\s+yaml-step/);
+    assert.match(info, /Source:\s+project/);
+  });
+});

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

@@ -28,6 +28,8 @@ function makeSlice(overrides: Partial<SliceRow> = {}): SliceRow {
     completed_at: null,
     sequence: 1,
     replan_triggered_at: null,
+    is_sketch: 0,
+    sketch_scope: '',
     ...overrides,
   };
 }
@@ -59,6 +61,11 @@ function makeTask(overrides: Partial<TaskRow> = {}): TaskRow {
     expected_output: [],
     observability_impact: '',
     sequence: 1,
+    blocker_source: '',
+    escalation_pending: 0,
+    escalation_awaiting_review: 0,
+    escalation_artifact_path: null,
+    escalation_override_applied_at: null,
     ...overrides,
   };
 }

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

@@ -36,8 +36,14 @@ console.log('\n── Registry Loading ──');
   for (const [id, entry] of Object.entries(registry.templates)) {
     assert.ok(typeof entry.name === 'string' && entry.name.length > 0, `${id}: name should be non-empty string`);
     assert.ok(typeof entry.description === 'string' && entry.description.length > 0, `${id}: description should be non-empty`);
-    assert.ok(typeof entry.file === 'string' && entry.file.endsWith('.md'), `${id}: file should be a .md path`);
-    assert.ok(Array.isArray(entry.phases) && entry.phases.length > 0, `${id}: phases should be non-empty array`);
+    assert.ok(typeof entry.file === 'string' && (entry.file.endsWith('.md') || entry.file.endsWith('.yaml') || entry.file.endsWith('.yml')), `${id}: file should be a .md or .yaml path`);
+    // Phases are only required for phased modes (markdown-phase, auto-milestone).
+    const isPhased = !entry.mode || entry.mode === 'markdown-phase' || entry.mode === 'auto-milestone';
+    if (isPhased) {
+      assert.ok(Array.isArray(entry.phases) && entry.phases.length > 0, `${id}: phases should be non-empty array for phased mode`);
+    } else {
+      assert.ok(Array.isArray(entry.phases), `${id}: phases should be an array (may be empty for ${entry.mode})`);
+    }
     assert.ok(Array.isArray(entry.triggers) && entry.triggers.length > 0, `${id}: triggers should be non-empty array`);
   }
 }