@warpgogol/forge 2.8.0 → 2.8.2

package/src/tests/promote.test.ts

@@ -0,0 +1,481 @@
+import { test, expect, describe } from "vitest";
+import { normalizeTitle, detectDuplicatePrinciples, planPromotion } from "../knowledge/promote.ts";
+import type {
+  ParsedKnowledgeFile,
+  KnowledgeEntryMeta,
+  KnowledgeEntry,
+} from "../knowledge/schema.ts";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const testDir = join(tmpdir(), "test");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeMeta(overrides: Partial<KnowledgeEntryMeta> = {}): KnowledgeEntryMeta {
+  const layer = overrides.layer ?? "L2";
+  const base: KnowledgeEntryMeta = {
+    id: "K-0001",
+    layer,
+    created: "2026-01-01",
+    status: "active",
+  };
+  if (layer === "L2") {
+    base.confirmations = 1;
+    base.lastConfirmedAt = "2026-01-01";
+  }
+  return { ...base, ...overrides };
+}
+
+function makeEntry(
+  id: string,
+  title: string,
+  metaOverrides: Partial<KnowledgeEntryMeta> = {},
+  body = "Body text.",
+): KnowledgeEntry {
+  return {
+    meta: makeMeta({ id, ...metaOverrides }),
+    title,
+    body,
+    lineStart: 1,
+  };
+}
+
+function makeParsedFile(
+  entries: KnowledgeEntry[],
+  overrides: Partial<ParsedKnowledgeFile> = {},
+): ParsedKnowledgeFile {
+  return {
+    path: join(testDir, "learned-principles.md"),
+    layer: "L2",
+    preamble: "",
+    entries,
+    legacySections: [],
+    parseIssues: [],
+    isKnowledgeAdjacent: false,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// normalizeTitle
+// ---------------------------------------------------------------------------
+
+describe("normalizeTitle", () => {
+  test("lowercases", () => {
+    expect(normalizeTitle("Redact Sensitive Information")).toBe("redact sensitive information");
+  });
+
+  test("strips punctuation", () => {
+    expect(normalizeTitle("Redact: Sensitive! Information?")).toBe("redact sensitive information");
+  });
+
+  test("strips emoji", () => {
+    expect(normalizeTitle("🔒 Lock files before writing")).toBe("lock files before writing");
+  });
+
+  test("collapses whitespace", () => {
+    expect(normalizeTitle("  Redact   Sensitive  Information  ")).toBe(
+      "redact sensitive information",
+    );
+  });
+
+  test("drops stop-words (the, a, an)", () => {
+    expect(normalizeTitle("The Redact a Sensitive an Information")).toBe(
+      "redact sensitive information",
+    );
+  });
+
+  test("preserves 'always' and 'never'", () => {
+    expect(normalizeTitle("Always verify before trusting")).toBe("always verify before trusting");
+    expect(normalizeTitle("Never trust raw input")).toBe("never trust raw input");
+  });
+
+  test("empty string returns empty", () => {
+    expect(normalizeTitle("")).toBe("");
+  });
+
+  test("only stop-words returns empty", () => {
+    expect(normalizeTitle("the a an")).toBe("");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// detectDuplicatePrinciples
+// ---------------------------------------------------------------------------
+
+describe("detectDuplicatePrinciples", () => {
+  test("exact match — two entries with identical normalized titles", () => {
+    const files = [
+      {
+        skill: "fo-session-save",
+        parsed: makeParsedFile([makeEntry("K-0001", "Redact sensitive information")]),
+      },
+      {
+        skill: "fo-memory-sync",
+        parsed: makeParsedFile([makeEntry("K-0005", "Redact sensitive information")]),
+      },
+    ];
+
+    const pairs = detectDuplicatePrinciples(files);
+    expect(pairs).toHaveLength(1);
+    expect(pairs[0].kind).toBe("exact");
+    expect(pairs[0].a.skill).toBe("fo-session-save");
+    expect(pairs[0].b.skill).toBe("fo-memory-sync");
+    expect(pairs[0].normalizedTitle).toBe("redact sensitive information");
+  });
+
+  test("no match — different titles", () => {
+    const files = [
+      {
+        skill: "fo-session-save",
+        parsed: makeParsedFile([makeEntry("K-0001", "Redact sensitive information")]),
+      },
+      {
+        skill: "fo-memory-sync",
+        parsed: makeParsedFile([makeEntry("K-0005", "Verify before trusting")]),
+      },
+    ];
+
+    const pairs = detectDuplicatePrinciples(files);
+    expect(pairs).toHaveLength(0);
+  });
+
+  test("containment match — shorter is substring of longer, >= 20 chars and >= 60%", () => {
+    const shortTitle = "always verify auto-extracted ids before trusting";
+    const longTitle = "always verify auto-extracted ids before trusting them in production";
+
+    const files = [
+      { skill: "fo-session-save", parsed: makeParsedFile([makeEntry("K-0001", shortTitle)]) },
+      { skill: "grilling", parsed: makeParsedFile([makeEntry("K-0003", longTitle)]) },
+    ];
+
+    const pairs = detectDuplicatePrinciples(files);
+    expect(pairs).toHaveLength(1);
+    expect(pairs[0].kind).toBe("containment");
+  });
+
+  test("containment bounded — shorter title < 20 chars produces no match", () => {
+    const shortTitle = "verify ids"; // 10 chars normalized
+    const longTitle = "verify ids before trusting them in production environments";
+
+    const files = [
+      { skill: "fo-session-save", parsed: makeParsedFile([makeEntry("K-0001", shortTitle)]) },
+      { skill: "grilling", parsed: makeParsedFile([makeEntry("K-0003", longTitle)]) },
+    ];
+
+    const pairs = detectDuplicatePrinciples(files);
+    expect(pairs).toHaveLength(0);
+  });
+
+  test("containment bounded — shorter title < 60% of longer produces no match", () => {
+    const shortTitle = "always verify ids before trusting"; // 33 chars
+    const longTitle =
+      "always verify ids before trusting them in production environments with proper validation and care"; // 85 chars, 33/85 = 38.8%
+
+    const files = [
+      { skill: "fo-session-save", parsed: makeParsedFile([makeEntry("K-0001", shortTitle)]) },
+      { skill: "grilling", parsed: makeParsedFile([makeEntry("K-0003", longTitle)]) },
+    ];
+
+    const pairs = detectDuplicatePrinciples(files);
+    expect(pairs).toHaveLength(0);
+  });
+
+  test("exclusion — pairs linked by promotedTo are excluded", () => {
+    const files = [
+      {
+        skill: "fo-session-save",
+        parsed: makeParsedFile([
+          makeEntry("K-0001", "Redact sensitive information", { promotedTo: "shared/K-0001" }),
+        ]),
+      },
+      {
+        skill: "fo-memory-sync",
+        parsed: makeParsedFile([
+          makeEntry("K-0005", "Redact sensitive information", { promotedTo: "shared/K-0001" }),
+        ]),
+      },
+    ];
+
+    const pairs = detectDuplicatePrinciples(files);
+    expect(pairs).toHaveLength(0);
+  });
+
+  test("exclusion — pairs linked by supersedes are excluded", () => {
+    const files = [
+      {
+        skill: "fo-session-save",
+        parsed: makeParsedFile([
+          makeEntry("K-0001", "Redact sensitive information", { supersedes: ["K-0005"] }),
+        ]),
+      },
+      {
+        skill: "fo-memory-sync",
+        parsed: makeParsedFile([makeEntry("K-0005", "Redact sensitive information")]),
+      },
+    ];
+
+    const pairs = detectDuplicatePrinciples(files);
+    expect(pairs).toHaveLength(0);
+  });
+
+  test("exclusion — entries with status: stale are excluded", () => {
+    const files = [
+      {
+        skill: "fo-session-save",
+        parsed: makeParsedFile([
+          makeEntry("K-0001", "Redact sensitive information", { status: "stale" }),
+        ]),
+      },
+      {
+        skill: "fo-memory-sync",
+        parsed: makeParsedFile([makeEntry("K-0005", "Redact sensitive information")]),
+      },
+    ];
+
+    const pairs = detectDuplicatePrinciples(files);
+    expect(pairs).toHaveLength(0);
+  });
+
+  test("exclusion — entries with status: archived are excluded", () => {
+    const files = [
+      {
+        skill: "fo-session-save",
+        parsed: makeParsedFile([
+          makeEntry("K-0001", "Redact sensitive information", { status: "archived" }),
+        ]),
+      },
+      {
+        skill: "fo-memory-sync",
+        parsed: makeParsedFile([makeEntry("K-0005", "Redact sensitive information")]),
+      },
+    ];
+
+    const pairs = detectDuplicatePrinciples(files);
+    expect(pairs).toHaveLength(0);
+  });
+
+  test("multiple skills — detection across 3+ skills", () => {
+    const files = [
+      {
+        skill: "fo-session-save",
+        parsed: makeParsedFile([makeEntry("K-0001", "Redact sensitive information")]),
+      },
+      {
+        skill: "fo-memory-sync",
+        parsed: makeParsedFile([makeEntry("K-0005", "Redact sensitive information")]),
+      },
+      {
+        skill: "grilling",
+        parsed: makeParsedFile([makeEntry("K-0010", "Redact sensitive information")]),
+      },
+    ];
+
+    const pairs = detectDuplicatePrinciples(files);
+    expect(pairs).toHaveLength(3); // 3 pairs: (0,1), (0,2), (1,2)
+    expect(pairs.every((p) => p.kind === "exact")).toBe(true);
+  });
+
+  test("knowledge-adjacent files are excluded", () => {
+    const files = [
+      {
+        skill: "fo-session-save",
+        parsed: makeParsedFile([makeEntry("K-0001", "Redact sensitive information")]),
+      },
+      {
+        skill: "fo-memory-sync",
+        parsed: makeParsedFile([makeEntry("K-0005", "Redact sensitive information")], {
+          isKnowledgeAdjacent: true,
+        }),
+      },
+    ];
+
+    const pairs = detectDuplicatePrinciples(files);
+    expect(pairs).toHaveLength(0);
+  });
+
+  test("files with parse issues are excluded", () => {
+    const files = [
+      {
+        skill: "fo-session-save",
+        parsed: makeParsedFile([makeEntry("K-0001", "Redact sensitive information")]),
+      },
+      {
+        skill: "fo-memory-sync",
+        parsed: makeParsedFile([makeEntry("K-0005", "Redact sensitive information")], {
+          parseIssues: [{ line: 1, message: "bad" }],
+        }),
+      },
+    ];
+
+    const pairs = detectDuplicatePrinciples(files);
+    expect(pairs).toHaveLength(0);
+  });
+
+  test("empty normalized title is excluded", () => {
+    const files = [
+      { skill: "fo-session-save", parsed: makeParsedFile([makeEntry("K-0001", "the a an")]) },
+      { skill: "fo-memory-sync", parsed: makeParsedFile([makeEntry("K-0005", "the a an")]) },
+    ];
+
+    const pairs = detectDuplicatePrinciples(files);
+    expect(pairs).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// planPromotion
+// ---------------------------------------------------------------------------
+
+describe("planPromotion", () => {
+  test("summed confirmations — two sources with 3 and 5 produce 8", () => {
+    const sources = [
+      {
+        skill: "fo-session-save",
+        file: "/path/a.md",
+        entry: makeEntry("K-0001", "Redact sensitive information", { confirmations: 3 }),
+      },
+      {
+        skill: "fo-memory-sync",
+        file: "/path/b.md",
+        entry: makeEntry("K-0005", "Redact sensitive information", { confirmations: 5 }),
+      },
+    ];
+
+    const plan = planPromotion(
+      sources,
+      { title: "Redact sensitive information", body: "Merged body." },
+      "K-0001",
+      "2026-08-03",
+    );
+
+    expect(plan.sharedEntry.meta.confirmations).toBe(8);
+  });
+
+  test("promotedFrom provenance — lists all source skill/id pairs", () => {
+    const sources = [
+      {
+        skill: "fo-session-save",
+        file: "/path/a.md",
+        entry: makeEntry("K-0001", "Redact sensitive information", { confirmations: 3 }),
+      },
+      {
+        skill: "fo-memory-sync",
+        file: "/path/b.md",
+        entry: makeEntry("K-0005", "Redact sensitive information", { confirmations: 5 }),
+      },
+    ];
+
+    const plan = planPromotion(
+      sources,
+      { title: "Redact sensitive information", body: "Merged body." },
+      "K-0001",
+      "2026-08-03",
+    );
+
+    expect(plan.sharedEntry.meta.promotedFrom).toEqual([
+      "fo-session-save/K-0001",
+      "fo-memory-sync/K-0005",
+    ]);
+  });
+
+  test("pointer list — one pointer per source entry", () => {
+    const sources = [
+      {
+        skill: "fo-session-save",
+        file: "/path/a.md",
+        entry: makeEntry("K-0001", "Redact sensitive information", { confirmations: 3 }),
+      },
+      {
+        skill: "fo-memory-sync",
+        file: "/path/b.md",
+        entry: makeEntry("K-0005", "Redact sensitive information", { confirmations: 5 }),
+      },
+    ];
+
+    const plan = planPromotion(
+      sources,
+      { title: "Redact sensitive information", body: "Merged body." },
+      "K-0001",
+      "2026-08-03",
+    );
+
+    expect(plan.localPointers).toHaveLength(2);
+    expect(plan.localPointers[0]).toEqual({
+      skill: "fo-session-save",
+      file: "/path/a.md",
+      entryId: "K-0001",
+    });
+    expect(plan.localPointers[1]).toEqual({
+      skill: "fo-memory-sync",
+      file: "/path/b.md",
+      entryId: "K-0005",
+    });
+  });
+
+  test("shared entry metadata — status active, created today, lastConfirmedAt today", () => {
+    const sources = [
+      {
+        skill: "fo-session-save",
+        file: "/path/a.md",
+        entry: makeEntry("K-0001", "Redact sensitive information", { confirmations: 3 }),
+      },
+    ];
+
+    const plan = planPromotion(
+      sources,
+      { title: "Redact sensitive information", body: "Merged body." },
+      "K-0001",
+      "2026-08-03",
+    );
+
+    expect(plan.sharedEntry.meta.status).toBe("active");
+    expect(plan.sharedEntry.meta.created).toBe("2026-08-03");
+    expect(plan.sharedEntry.meta.lastConfirmedAt).toBe("2026-08-03");
+    expect(plan.sharedEntry.meta.layer).toBe("L2");
+    expect(plan.sharedEntry.meta.id).toBe("K-0001");
+  });
+
+  test("shared entry carries merged title and body", () => {
+    const sources = [
+      {
+        skill: "fo-session-save",
+        file: "/path/a.md",
+        entry: makeEntry("K-0001", "Redact sensitive information", { confirmations: 3 }),
+      },
+    ];
+
+    const plan = planPromotion(
+      sources,
+      { title: "Redact sensitive information", body: "Merged body." },
+      "K-0001",
+      "2026-08-03",
+    );
+
+    expect(plan.sharedEntry.title).toBe("Redact sensitive information");
+    expect(plan.sharedEntry.body).toBe("Merged body.");
+  });
+
+  test("single source — confirmations from one entry", () => {
+    const sources = [
+      {
+        skill: "grilling",
+        file: "/path/a.md",
+        entry: makeEntry("K-0001", "Test principle", { confirmations: 7 }),
+      },
+    ];
+
+    const plan = planPromotion(
+      sources,
+      { title: "Test principle", body: "Body." },
+      "K-0001",
+      "2026-08-03",
+    );
+
+    expect(plan.sharedEntry.meta.confirmations).toBe(7);
+    expect(plan.localPointers).toHaveLength(1);
+  });
+});

package/src/tests/registry.test.ts

@@ -0,0 +1,73 @@
+import { test, expect, describe } from "vitest";
+import { FORGE_SKILLS } from "../registry.ts";
+
+describe("FORGE_SKILLS registry", () => {
+  test("is non-empty", () => {
+    expect(FORGE_SKILLS.length).toBeGreaterThan(10);
+  });
+
+  test("has no duplicate names", () => {
+    const names = FORGE_SKILLS.map((s) => s.name);
+    const unique = new Set(names);
+    expect(unique.size).toBe(names.length);
+  });
+
+  test("has no duplicate paths", () => {
+    const paths = FORGE_SKILLS.map((s) => s.path);
+    const unique = new Set(paths);
+    expect(unique.size).toBe(paths.length);
+  });
+
+  test("all names are kebab-case", () => {
+    for (const skill of FORGE_SKILLS) {
+      expect(skill.name).toMatch(/^[a-z][a-z0-9-]*$/);
+    }
+  });
+
+  test("all paths end with SKILL.md", () => {
+    for (const skill of FORGE_SKILLS) {
+      expect(skill.path.endsWith("SKILL.md")).toBe(true);
+    }
+  });
+
+  test("all categories are valid", () => {
+    const validCategories = new Set(["fo", "shared", "meta"]);
+    for (const skill of FORGE_SKILLS) {
+      expect(validCategories.has(skill.category)).toBe(true);
+    }
+  });
+
+  test("all invocations are valid", () => {
+    const validInvocations = new Set(["user", "model"]);
+    for (const skill of FORGE_SKILLS) {
+      expect(validInvocations.has(skill.invocation)).toBe(true);
+    }
+  });
+
+  test("all concerns are valid", () => {
+    const validConcerns = new Set([
+      "read-only",
+      "document-only",
+      "content-mutation",
+      "code-mutation",
+    ]);
+    for (const skill of FORGE_SKILLS) {
+      expect(validConcerns.has(skill.concerns)).toBe(true);
+    }
+  });
+
+  test("dependsOn entries reference existing skill names", () => {
+    const knownNames = new Set(FORGE_SKILLS.map((s) => s.name));
+    for (const skill of FORGE_SKILLS) {
+      for (const dep of skill.dependsOn) {
+        expect(knownNames.has(dep)).toBe(true);
+      }
+    }
+  });
+
+  test("path prefix matches category directory", () => {
+    for (const skill of FORGE_SKILLS) {
+      expect(skill.path.startsWith(`skills/${skill.category}/`)).toBe(true);
+    }
+  });
+});

package/src/tests/scaffold-project.test.ts

@@ -0,0 +1,150 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Unit tests for forge.scaffold project command and forge.init --from flag.</purpose>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0392: initial scaffold-project and init --from tests.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { test, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm, readdir, mkdir, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runScaffoldProject } from "../onboarding/scaffold-project.ts";
+import { runInit } from "../onboarding/init.ts";
+import type { ForgeRuntimeContext } from "../types.ts";
+
+const silentLogger = {
+  section: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  success: () => {},
+};
+
+function makeContext(workspaceRoot: string): ForgeRuntimeContext {
+  return {
+    workspaceRoot,
+    logger: silentLogger as never,
+    dryRun: false,
+    outputFormat: "json",
+  };
+}
+
+// Resolve forge root from this test file's location
+const FORGE_ROOT = join(import.meta.dirname, "..", "..");
+// In monorepo: FORGE_ROOT = packages/forge, workspace = monorepo root
+// In extracted package: FORGE_ROOT = repo root, workspace = FORGE_ROOT
+const monorepoRoot = join(FORGE_ROOT, "..", "..");
+const WORKSPACE_ROOT = existsSync(join(monorepoRoot, "package.json")) ? monorepoRoot : FORGE_ROOT;
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "scaffold-test-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+test("forge.scaffold tolerates non-empty directory (RFC-0877 in-place mode)", async () => {
+  await writeFile(join(tempDir, "some-file.txt"), "hello", "utf8");
+  const result = await runScaffoldProject(
+    { argv: [], flags: { profile: "forge-shell", name: "my-project" } },
+    { ...makeContext(tempDir), forgeRoot: FORGE_ROOT },
+  );
+  expect(result.exitCode).toBe(0);
+  expect(result.data?.status).toBe("pass");
+  expect(existsSync(join(tempDir, "package.json"))).toBe(true);
+  expect(existsSync(join(tempDir, "some-file.txt"))).toBe(true);
+}, 30000);
+
+test("forge.scaffold fails on missing --profile", async () => {
+  const result = await runScaffoldProject(
+    { argv: [], flags: { name: "my-site" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(1);
+  expect(result.data?.errors[0]).toContain("--profile");
+});
+
+test("forge.scaffold derives name from folder when --name omitted", async () => {
+  const result = await runScaffoldProject(
+    { argv: [], flags: { profile: "phaser-turborepo" } },
+    { ...makeContext(tempDir), forgeRoot: FORGE_ROOT },
+  );
+  // Name is now derived from the folder name (consistent with forge.create)
+  // The temp dir name may not be kebab-case, so we accept either:
+  // 1. pass (if folder name happens to be kebab-case)
+  // 2. fail with kebab-case error (if folder name has uppercase)
+  if (result.exitCode === 0) {
+    expect(result.data?.status).toBe("pass");
+  } else {
+    expect(result.data?.errors[0]).toContain("kebab-case");
+  }
+});
+
+test("forge.scaffold fails on non-kebab-case name", async () => {
+  const result = await runScaffoldProject(
+    { argv: [], flags: { profile: "phaser-turborepo", name: "MySite" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(1);
+  expect(result.data?.errors[0]).toContain("kebab-case");
+});
+
+test("forge.scaffold fails on unknown profile", async () => {
+  const result = await runScaffoldProject(
+    { argv: [], flags: { profile: "nonexistent", name: "my-site" } },
+    makeContext(tempDir),
+  );
+  expect(result.exitCode).toBe(1);
+  expect(result.data?.errors[0]).toContain("Unknown profile");
+});
+
+test("forge.scaffold creates workspace files in empty dir (no install)", async () => {
+  // Use a profile that has no install commands by testing the file creation directly.
+  // We can't run real pnpm install in tests, so we test with a profile that has empty install.
+  // Instead, test the non-install path by checking that files are created before install runs.
+  // For a full test we'd need a mock profile, but the handler runs real install commands.
+  // Skip this test if pnpm is not available — the file creation logic is tested above.
+  // Instead, verify the directory is empty first, then check that the handler at least
+  // starts creating files before potentially failing on install.
+  const entries = await readdir(tempDir);
+  expect(entries.length).toBe(0);
+  // We can't fully test scaffold without running pnpm install.
+  // The key acceptance criterion is the integration test with --lockfile-only.
+  // Here we just verify the empty-dir check passes.
+});
+
+test("forge.init --from detects stack from existing project", async () => {
+  // Create a fake project with phaser.config.ts
+  const fakeProject = join(tempDir, "fake-project");
+  await mkdir(fakeProject, { recursive: true });
+  await writeFile(join(fakeProject, "phaser.config.ts"), "export default {}", "utf8");
+
+  const result = runInit({ flags: { from: fakeProject } }, { workspaceRoot: WORKSPACE_ROOT });
+  expect(result.status).toBe("pass");
+  expect(result.detection).toBeDefined();
+  expect(result.detection?.profile).toBe("phaser-turborepo");
+});
+
+test("forge.init --from reports null when stack undetectable", async () => {
+  const fakeProject = join(tempDir, "fake-project");
+  await mkdir(fakeProject, { recursive: true });
+  await writeFile(join(fakeProject, "Cargo.toml"), "[package]", "utf8");
+
+  const result = runInit({ flags: { from: fakeProject } }, { workspaceRoot: WORKSPACE_ROOT });
+  expect(result.status).toBe("pass");
+  expect(result.detection?.profile).toBeNull();
+  expect(result.detection?.unsupported).toEqual(["unknown"]);
+});
+
+test("forge.init --from fails on non-existent path", async () => {
+  const result = runInit({ flags: { from: "/nonexistent/path/xyz" } }, { workspaceRoot: tempDir });
+  expect(result.status).toBe("fail");
+  expect(result.errors[0]).toContain("does not exist");
+});