pi-gsd 2.0.1 → 2.0.3

package/src/wxp/__tests__/integration.test.ts

@@ -1,166 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { Mock } from "vitest";
-import path from "node:path";
-
-vi.mock("node:child_process", () => ({
-  execFileSync: vi.fn().mockReturnValue("shell-output\n"),
-}));
-
-import { processWxp, WxpProcessingError } from "../index.js";
-import type { WxpSecurityConfig } from "../../schemas/wxp.zod.js";
-import { execFileSync } from "node:child_process";
-
-const PROJECT_ROOT = "/project";
-const PKG_ROOT = "/pkg";
-const TRUSTED_DIR = "/project/.pi/gsd/workflows";
-const VIRTUAL_FILE = path.join(TRUSTED_DIR, "test.md");
-
-const cfg: WxpSecurityConfig = {
-  trustedPaths: [{ position: "absolute", path: TRUSTED_DIR }],
-  untrustedPaths: [],
-  shellAllowlist: ["pi-gsd-tools", "git", "node", "cat", "ls", "echo", "find"],
-  shellBanlist: [],
-  shellTimeoutMs: 30_000,
-};
-
-describe("processWxp — integration (TST-02)", () => {
-  beforeEach(() => {
-    (execFileSync as Mock).mockReturnValue("shell-output\n");
-  });
-
-  it("Fixture 1: shell output captured and paste tag replaced", () => {
-    const content = [
-      "<gsd-execute>",
-      "  <shell command=\"pi-gsd-tools\">",
-      "    <args><arg string=\"state\" /><arg string=\"json\" /></args>",
-      "    <outs><out type=\"string\" name=\"state\" /></outs>",
-      "  </shell>",
-      "</gsd-execute>",
-      "State: <gsd-paste name=\"state\" />",
-    ].join("\n");
-
-    const result = processWxp(content, VIRTUAL_FILE, cfg, PROJECT_ROOT, PKG_ROOT);
-    expect(result).toContain("State: shell-output");
-    expect(result).not.toMatch(/<gsd-paste/);
-    expect(result).not.toMatch(/<gsd-execute>/);
-  });
-
-  it("Fixture 2: <gsd-paste> inside code fence is unchanged (WXP-01)", () => {
-    const content = [
-      "Example:",
-      "```",
-      '<gsd-paste name="x" />',
-      "```",
-    ].join("\n");
-    // No variables — would throw WxpProcessingError if paste ran outside fence
-    const result = processWxp(content, VIRTUAL_FILE, cfg, PROJECT_ROOT, PKG_ROOT);
-    expect(result).toContain('<gsd-paste name="x" />');
-  });
-
-  it("Fixture 3: if/starts-with condition branches correctly", () => {
-    const content = [
-      "<gsd-arguments>",
-      '  <arg name="auto-chain-active" type="flag" flag="--auto" optional />',
-      "</gsd-arguments>",
-      "<gsd-execute>",
-      "  <if>",
-      "    <condition><equals>",
-      '      <left name="auto-chain-active" />',
-      '      <right type="boolean" value="false" />',
-      "    </equals></condition>",
-      "    <then>",
-      '      <shell command="pi-gsd-tools">',
-      '        <args><arg string="config-set" /><arg string="workflow._auto_chain_active" /><arg name="auto-chain-active" /></args>',
-      "        <outs><suppress-errors /></outs>",
-      "      </shell>",
-      "    </then>",
-      "  </if>",
-      "</gsd-execute>",
-    ].join("\n");
-
-    (execFileSync as Mock).mockReturnValue("ok\n");
-    // Without --auto flag: auto-chain-active = false → condition true → shell runs
-    const result = processWxp(content, VIRTUAL_FILE, cfg, PROJECT_ROOT, PKG_ROOT, "");
-    expect(execFileSync).toHaveBeenCalled();
-    expect(result.trim()).toBe("");
-  });
-
-  it("Fixture 5: variable collision gets owner-prefixed", async () => {
-    const { createVariableStore } = await import("../variables.js");
-    const store = createVariableStore();
-    store.set("result", "from-a", "file-a");
-    store.set("result", "from-b", "file-b");
-    expect(store.get("result")).toBeUndefined();
-    expect(store.get("file-a:result")).toBe("from-a");
-    expect(store.get("file-b:result")).toBe("from-b");
-  });
-
-  it("Fixture 6a: untrusted path throws WxpProcessingError", () => {
-    expect(() =>
-      processWxp("content", "/untrusted/file.md", cfg, PROJECT_ROOT, PKG_ROOT),
-    ).toThrow(WxpProcessingError);
-  });
-
-  it("Fixture 6b: .planning/ path throws WxpProcessingError", () => {
-    expect(() =>
-      processWxp("content", "/project/.planning/STATE.md", cfg, PROJECT_ROOT, PKG_ROOT),
-    ).toThrow(WxpProcessingError);
-  });
-
-  it("Fixture 6c: undefined paste variable throws WxpProcessingError", () => {
-    const content = '<gsd-paste name="missing" />';
-    expect(() =>
-      processWxp(content, VIRTUAL_FILE, cfg, PROJECT_ROOT, PKG_ROOT),
-    ).toThrow(WxpProcessingError);
-  });
-
-  it("Fixture 6d: non-allowlisted command throws WxpProcessingError", () => {
-    const content = [
-      "<gsd-execute>",
-      '  <shell command="bash">',
-      '    <args><arg string="-c" /><arg string="echo hi" /></args>',
-      "    <outs><out type=\"string\" name=\"out\" /></outs>",
-      "  </shell>",
-      "</gsd-execute>",
-    ].join("\n");
-    expect(() =>
-      processWxp(content, VIRTUAL_FILE, cfg, PROJECT_ROOT, PKG_ROOT),
-    ).toThrow(WxpProcessingError);
-  });
-
-  it("WxpProcessingError contains variable namespace", () => {
-    try {
-      processWxp('<gsd-paste name="gone" />', VIRTUAL_FILE, cfg, PROJECT_ROOT, PKG_ROOT);
-    } catch (err) {
-      expect(err).toBeInstanceOf(WxpProcessingError);
-      expect((err as WxpProcessingError).message).toContain("Variable Namespace");
-    }
-  });
-
-  it("Fixture 7: output contains zero <gsd-* tags outside code fences (TST-03)", () => {
-    const content = [
-      "<gsd-execute>",
-      '  <shell command="echo">',
-      '    <args><arg string="hello" /></args>',
-      '    <outs><out type="string" name="val" /></outs>',
-      "  </shell>",
-      "</gsd-execute>",
-      '<gsd-paste name="val" />',
-      "",
-      "```",
-      '<gsd-paste name="val" />',
-      "```",
-    ].join("\n");
-
-    (execFileSync as Mock).mockReturnValue("hello\n");
-    const result = processWxp(content, VIRTUAL_FILE, cfg, PROJECT_ROOT, PKG_ROOT);
-    const withoutFences = result.replace(/^```[^\n]*\n[\s\S]*?^```/gm, "FENCE");
-    expect(withoutFences.match(/<gsd-(?!-)[^>]*>/g)).toBeNull();
-  });
-
-  it("gsd-version tags are informational and do not cause errors", () => {
-    const content = '<gsd-version v="1.12.4" />\n# Hello';
-    const result = processWxp(content, VIRTUAL_FILE, cfg, PROJECT_ROOT, PKG_ROOT);
-    expect(result).toContain("# Hello");
-  });
-});

package/src/wxp/__tests__/new-features.test.ts

@@ -1,222 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { Mock } from "vitest";
-
-vi.mock("node:child_process", () => ({
-  execFileSync: vi.fn().mockReturnValue("ok\n"),
-}));
-
-import { createVariableStore } from "../variables.js";
-import { executeBlock } from "../executor.js";
-import { evaluateCondExprNode } from "../conditions.js";
-import type { WxpExecContext } from "../../schemas/wxp.zod.js";
-import { execFileSync } from "node:child_process";
-import { x } from "./helpers.js";
-
-const makeCtx = (onDisplay = vi.fn()): WxpExecContext => ({
-  config: {
-    trustedPaths: [],
-    untrustedPaths: [],
-    shellAllowlist: ["pi-gsd-tools", "git", "echo", "cat", "node", "ls", "find"],
-    shellBanlist: [],
-    shellTimeoutMs: 30_000,
-  },
-  projectRoot: "/project",
-  pkgRoot: "/pkg",
-  onDisplay,
-});
-
-function exec(...children: ReturnType<typeof x>[]) {
-  return x("gsd-execute", {}, children);
-}
-
-describe("conditions — new operators", () => {
-  it("not-equals: true when values differ", () => {
-    const vars = createVariableStore();
-    vars.set("status", "complete");
-    expect(evaluateCondExprNode(
-      x("not-equals", {}, [x("left", { name: "status" }), x("right", { value: "pending" })]),
-      vars,
-    )).toBe(true);
-  });
-
-  it("less-than (numeric)", () => {
-    const vars = createVariableStore();
-    vars.set("n", "3");
-    expect(evaluateCondExprNode(
-      x("less-than", {}, [x("left", { name: "n", type: "number" }), x("right", { type: "number", value: "5" })]),
-      vars,
-    )).toBe(true);
-  });
-
-  it("greater-than-or-equal", () => {
-    const vars = createVariableStore();
-    vars.set("n", "5");
-    expect(evaluateCondExprNode(
-      x("greater-than-or-equal", {}, [x("left", { name: "n", type: "number" }), x("right", { type: "number", value: "5" })]),
-      vars,
-    )).toBe(true);
-  });
-
-  it("contains", () => {
-    const vars = createVariableStore();
-    vars.set("init", "@file:/tmp/out.json");
-    expect(evaluateCondExprNode(
-      x("contains", {}, [x("left", { name: "init" }), x("right", { value: "@file:" })]),
-      vars,
-    )).toBe(true);
-  });
-
-  it("<and>: all children must be true", () => {
-    const vars = createVariableStore();
-    vars.set("a", "1"); vars.set("b", "2");
-    expect(evaluateCondExprNode(x("and", {}, [
-      x("equals", {}, [x("left", { name: "a" }), x("right", { value: "1" })]),
-      x("equals", {}, [x("left", { name: "b" }), x("right", { value: "2" })]),
-    ]), vars)).toBe(true);
-    expect(evaluateCondExprNode(x("and", {}, [
-      x("equals", {}, [x("left", { name: "a" }), x("right", { value: "1" })]),
-      x("equals", {}, [x("left", { name: "b" }), x("right", { value: "99" })]),
-    ]), vars)).toBe(false);
-  });
-
-  it("<or>: any child true is sufficient", () => {
-    const vars = createVariableStore();
-    vars.set("x", "hello");
-    expect(evaluateCondExprNode(x("or", {}, [
-      x("equals", {}, [x("left", { name: "x" }), x("right", { value: "nope" })]),
-      x("equals", {}, [x("left", { name: "x" }), x("right", { value: "hello" })]),
-    ]), vars)).toBe(true);
-  });
-
-  it("nested <and> inside <or>", () => {
-    const vars = createVariableStore();
-    vars.set("status", "pending"); vars.set("phase", "3");
-    expect(evaluateCondExprNode(x("or", {}, [
-      x("equals", {}, [x("left", { name: "status" }), x("right", { value: "complete" })]),
-      x("and", {}, [
-        x("equals", {}, [x("left", { name: "status" }), x("right", { value: "pending" })]),
-        x("greater-than-or-equal", {}, [x("left", { name: "phase", type: "number" }), x("right", { type: "number", value: "2" })]),
-      ]),
-    ]), vars)).toBe(true);
-  });
-});
-
-describe("<display>", () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it("emits via onDisplay with {varname} interpolation", () => {
-    const onDisplay = vi.fn();
-    const vars = createVariableStore();
-    vars.set("phase", "3"); vars.set("phase-name", "WXP Foundation");
-    executeBlock(exec(x("display", { msg: "GSD ► PHASE {phase} — {phase-name}", level: "info" })), vars, makeCtx(onDisplay));
-    expect(onDisplay).toHaveBeenCalledWith("GSD ► PHASE 3 — WXP Foundation", "info");
-  });
-
-  it("resolves dot-notation {item.status}", () => {
-    const onDisplay = vi.fn();
-    const vars = createVariableStore();
-    vars.set("phase", JSON.stringify({ status: "complete", name: "Test" }));
-    executeBlock(exec(x("display", { msg: "Status: {phase.status}" })), vars, makeCtx(onDisplay));
-    expect(onDisplay).toHaveBeenCalledWith("Status: complete", "info");
-  });
-});
-
-describe("<json-parse>", () => {
-  it("extracts a top-level key", () => {
-    const vars = createVariableStore();
-    vars.set("data", JSON.stringify({ phase_number: "3" }));
-    executeBlock(exec(x("json-parse", { src: "data", path: "$.phase_number", out: "phase" })), vars, makeCtx());
-    expect(vars.get("phase")).toBe("3");
-  });
-
-  it("extracts an array for <for-each>", () => {
-    const vars = createVariableStore();
-    vars.set("progress", JSON.stringify({ phases: [{ number: "1" }, { number: "2" }] }));
-    executeBlock(exec(x("json-parse", { src: "progress", path: "$.phases", out: "phases" })), vars, makeCtx());
-    const arr = vars.getArray("phases");
-    expect(arr).toHaveLength(2);
-    expect(JSON.parse(arr![0]).number).toBe("1");
-  });
-});
-
-describe("<for-each>", () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it("iterates array and runs body for each item", () => {
-    const onDisplay = vi.fn();
-    const vars = createVariableStore();
-    vars.setArray("items", [JSON.stringify({ name: "Alpha" }), JSON.stringify({ name: "Beta" })]);
-    executeBlock(exec(
-      x("for-each", { var: "items", item: "item" }, [
-        x("display", { msg: "Item: {item.name}", level: "info" }),
-      ]),
-    ), vars, makeCtx(onDisplay));
-    expect(onDisplay).toHaveBeenCalledTimes(2);
-    expect(onDisplay).toHaveBeenNthCalledWith(1, "Item: Alpha", "info");
-    expect(onDisplay).toHaveBeenNthCalledWith(2, "Item: Beta", "info");
-  });
-
-  it("<where> filters items", () => {
-    const onDisplay = vi.fn();
-    const vars = createVariableStore();
-    vars.setArray("phases", [
-      JSON.stringify({ number: "1", status: "complete" }),
-      JSON.stringify({ number: "2", status: "pending" }),
-      JSON.stringify({ number: "3", status: "pending" }),
-    ]);
-    executeBlock(exec(
-      x("for-each", { var: "phases", item: "phase" }, [
-        x("where", {}, [
-          x("not-equals", {}, [x("left", { name: "phase.status" }), x("right", { value: "complete" })]),
-        ]),
-        x("display", { msg: "{phase.number}" }),
-      ]),
-    ), vars, makeCtx(onDisplay));
-    expect(onDisplay).toHaveBeenCalledTimes(2);
-    expect(onDisplay).toHaveBeenNthCalledWith(1, "2", "info");
-  });
-
-  it("<sort-by> sorts numerically", () => {
-    const onDisplay = vi.fn();
-    const vars = createVariableStore();
-    vars.setArray("phases", [
-      JSON.stringify({ number: "3" }), JSON.stringify({ number: "1" }), JSON.stringify({ number: "2" }),
-    ]);
-    executeBlock(exec(
-      x("for-each", { var: "phases", item: "phase" }, [
-        x("sort-by", { key: "number", type: "number", order: "asc" }),
-        x("display", { msg: "{phase.number}" }),
-      ]),
-    ), vars, makeCtx(onDisplay));
-    expect(onDisplay).toHaveBeenNthCalledWith(1, "1", "info");
-    expect(onDisplay).toHaveBeenNthCalledWith(3, "3", "info");
-  });
-
-  it("missing array is silently skipped", () => {
-    const vars = createVariableStore();
-    expect(() => executeBlock(exec(
-      x("for-each", { var: "nonexistent", item: "x" }, []),
-    ), vars, makeCtx())).not.toThrow();
-  });
-});
-
-describe("variables — dot notation and arrays", () => {
-  it("resolve dot-notation accesses JSON property", () => {
-    const vars = createVariableStore();
-    vars.set("item", JSON.stringify({ status: "complete", number: "5" }));
-    expect(vars.resolve("item.status")).toBe("complete");
-    expect(vars.resolve("item.number")).toBe("5");
-  });
-
-  it("setArray/getArray round-trips", () => {
-    const vars = createVariableStore();
-    vars.setArray("arr", ["a", "b", "c"]);
-    expect(vars.getArray("arr")).toEqual(["a", "b", "c"]);
-  });
-
-  it("getArray falls back to parsing JSON scalar", () => {
-    const vars = createVariableStore();
-    vars.set("data", JSON.stringify(["x", "y"]));
-    expect(vars.getArray("data")).toEqual(["x", "y"]);
-  });
-});

package/src/wxp/__tests__/parser.test.ts

@@ -1,159 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { extractWxpTags, extractCodeFenceRegions } from "../parser.js";
-import { executeNode } from "../executor.js";
-import { createVariableStore } from "../variables.js";
-import type { WxpExecContext } from "../../schemas/wxp.zod.js";
-import { x } from "./helpers.js";
-
-const ctx: WxpExecContext = {
-  config: {
-    trustedPaths: [],
-    untrustedPaths: [],
-    shellAllowlist: ["pi-gsd-tools", "git", "cat", "ls", "echo", "node", "find"],
-    shellBanlist: [],
-    shellTimeoutMs: 30_000,
-  },
-  projectRoot: "/project",
-  pkgRoot: "/pkg",
-  onDisplay: () => {},
-};
-
-describe("extractCodeFenceRegions", () => {
-  it("returns empty for content with no fences", () => {
-    expect(extractCodeFenceRegions("hello world")).toEqual([]);
-  });
-
-  it("identifies a fenced region", () => {
-    const content = "before\n```\ncode\n```\nafter";
-    const regions = extractCodeFenceRegions(content);
-    expect(regions).toHaveLength(1);
-    expect(content.slice(regions[0][0], regions[0][1])).toContain("code");
-  });
-});
-
-describe("extractWxpTags — code-fence skip (WXP-01)", () => {
-  it("does NOT parse <gsd-paste> inside a code fence", () => {
-    const content = "before\n```\n<gsd-paste name=\"x\" />\n```\nafter";
-    const pastes = extractWxpTags(content).filter((t) => t.node.tag === "gsd-paste");
-    expect(pastes).toHaveLength(0);
-  });
-
-  it("DOES parse <gsd-paste> outside a code fence", () => {
-    const content = 'text\n<gsd-paste name="x" />\nmore';
-    const pastes = extractWxpTags(content).filter((t) => t.node.tag === "gsd-paste");
-    expect(pastes).toHaveLength(1);
-    expect(pastes[0].node.attrs["name"]).toBe("x");
-  });
-});
-
-describe("extractWxpTags — gsd-execute with shell children", () => {
-  it("parses nested shell/args/outs structure", () => {
-    const content = [
-      "<gsd-execute>",
-      "  <shell command=\"pi-gsd-tools\">",
-      "    <args><arg string=\"init\" /><arg string=\"execute-phase\" /><arg name=\"phase\" wrap='\"' /></args>",
-      "    <outs><out type=\"string\" name=\"init\" /></outs>",
-      "  </shell>",
-      "</gsd-execute>",
-    ].join("\n");
-
-    const tags = extractWxpTags(content);
-    expect(tags).toHaveLength(1);
-    expect(tags[0].node.tag).toBe("gsd-execute");
-
-    const shell = tags[0].node.children.find((c) => c.tag === "shell");
-    expect(shell).toBeDefined();
-    expect(shell?.attrs["command"]).toBe("pi-gsd-tools");
-
-    const args = shell?.children.find((c) => c.tag === "args");
-    expect(args?.children.filter((c) => c.tag === "arg")).toHaveLength(3);
-
-    const outs = shell?.children.find((c) => c.tag === "outs");
-    expect(outs?.children.find((c) => c.tag === "out")?.attrs["name"]).toBe("init");
-  });
-});
-
-describe("extractWxpTags — gsd-arguments", () => {
-  it("parses typed positionals and flag with settings", () => {
-    const content = [
-      "<gsd-arguments>",
-      "  <settings><keep-extra-args /></settings>",
-      "  <arg name=\"phase\" type=\"number\" />",
-      "  <arg name=\"auto\" type=\"flag\" flag=\"--auto\" optional />",
-      "  <arg name=\"user-text\" type=\"string\" optional />",
-      "</gsd-arguments>",
-    ].join("\n");
-
-    const tags = extractWxpTags(content);
-    expect(tags[0].node.tag).toBe("gsd-arguments");
-    const argDefs = tags[0].node.children.filter((c) => c.tag === "arg");
-    expect(argDefs).toHaveLength(3);
-    expect(argDefs.find((a) => a.attrs["type"] === "flag")?.attrs["flag"]).toBe("--auto");
-    expect(tags[0].node.children.find((c) => c.tag === "settings")
-      ?.children.some((c) => c.tag === "keep-extra-args")).toBe(true);
-  });
-});
-
-describe("extractWxpTags — gsd-include", () => {
-  it("parses self-closing include", () => {
-    const content = `<gsd-include path="other.md" />`;
-    const tags = extractWxpTags(content);
-    expect(tags[0].node.attrs["path"]).toBe("other.md");
-  });
-
-  it("parses include-arguments attribute", () => {
-    const content = `<gsd-include path="other.md" include-arguments />`;
-    expect("include-arguments" in extractWxpTags(content)[0].node.attrs).toBe(true);
-  });
-
-  it("parses include with arg mappings (INC-02)", () => {
-    const content = [
-      `<gsd-include path="other.md">`,
-      `  <gsd-arguments>`,
-      `    <arg name="my-phase" as="phase" />`,
-      `  </gsd-arguments>`,
-      `</gsd-include>`,
-    ].join("\n");
-    const tag = extractWxpTags(content)[0];
-    const mappingArg = tag.node.children
-      .find((c) => c.tag === "gsd-arguments")
-      ?.children.find((c) => c.tag === "arg");
-    expect(mappingArg?.attrs["name"]).toBe("my-phase");
-    expect(mappingArg?.attrs["as"]).toBe("phase");
-  });
-});
-
-describe("extractWxpTags — gsd-version", () => {
-  it("parses version tag", () => {
-    const tag = extractWxpTags(`<gsd-version v="1.12.4" />`)[0];
-    expect(tag.node.attrs["v"]).toBe("1.12.4");
-  });
-
-  it("parses do-not-update", () => {
-    const tag = extractWxpTags(`<gsd-version v="1.0.0" do-not-update />`)[0];
-    expect("do-not-update" in tag.node.attrs).toBe(true);
-  });
-});
-
-describe("if node with PRD condition structure — executed directly", () => {
-  it("evaluates equals with left/right operands and runs then-branch", () => {
-    const vars = createVariableStore();
-    vars.set("auto-chain-active", "false");
-    const displayed: string[] = [];
-    const testCtx = { ...ctx, onDisplay: (m: string) => displayed.push(m) };
-
-    executeNode(x("if", {}, [
-      x("condition", {}, [
-        x("equals", {}, [
-          x("left", { name: "auto-chain-active" }),
-          x("right", { type: "boolean", value: "false" }),
-        ]),
-      ]),
-      x("then", {}, [
-        x("display", { msg: "condition was true" }),
-      ]),
-    ]), vars, testCtx);
-
-    expect(displayed).toContain("condition was true");
-  });
-});

package/src/wxp/__tests__/paste.test.ts

@@ -1,66 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { applyPaste, WxpPasteError } from "../paste.js";
-import { createVariableStore } from "../variables.js";
-
-describe("applyPaste (WXP-06)", () => {
-  it("replaces a paste tag with the variable value", () => {
-    const vars = createVariableStore();
-    vars.set("greeting", "Hello World");
-    const result = applyPaste('Say: <gsd-paste name="greeting" />', vars);
-    expect(result).toBe("Say: Hello World");
-  });
-
-  it("replaces multiple paste tags", () => {
-    const vars = createVariableStore();
-    vars.set("a", "foo");
-    vars.set("b", "bar");
-    const result = applyPaste('<gsd-paste name="a" /> and <gsd-paste name="b" />', vars);
-    expect(result).toBe("foo and bar");
-  });
-
-  it("throws WxpPasteError immediately on undefined variable (no partial output)", () => {
-    const vars = createVariableStore();
-    vars.set("defined", "ok");
-    const content = '<gsd-paste name="defined" /> <gsd-paste name="missing" />';
-    expect(() => applyPaste(content, vars)).toThrow(WxpPasteError);
-  });
-
-  it("WxpPasteError contains the variable name and snapshot", () => {
-    const vars = createVariableStore();
-    vars.set("existing", "val");
-    try {
-      applyPaste('<gsd-paste name="nope" />', vars);
-    } catch (err) {
-      expect(err).toBeInstanceOf(WxpPasteError);
-      expect((err as WxpPasteError).variableName).toBe("nope");
-      expect((err as WxpPasteError).variableSnapshot).toMatchObject({ existing: "val" });
-    }
-  });
-
-  it("does NOT replace paste tag inside a code fence (dead-zone skip)", () => {
-    const vars = createVariableStore();
-    vars.set("x", "REPLACED");
-    const content = "```\n<gsd-paste name=\"x\" />\n```\nafter";
-    const result = applyPaste(content, vars);
-    expect(result).toContain('<gsd-paste name="x" />');
-    expect(result).not.toContain("REPLACED");
-  });
-
-  it("replaces paste tag outside fence but not inside fence", () => {
-    const vars = createVariableStore();
-    vars.set("val", "VALUE");
-    const content = "```\n<gsd-paste name=\"val\" />\n```\n<gsd-paste name=\"val\" />";
-    const result = applyPaste(content, vars);
-    // Inside fence: unchanged
-    expect(result).toContain('<gsd-paste name="val" />');
-    // Outside fence: replaced
-    const outsidePart = result.split("```\n").pop() ?? "";
-    expect(outsidePart).toBe("VALUE");
-  });
-
-  it("returns content unchanged when there are no paste tags", () => {
-    const vars = createVariableStore();
-    const content = "No tags here";
-    expect(applyPaste(content, vars)).toBe(content);
-  });
-});