gsd-pi 2.20.0 → 2.22.0

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

@@ -74,6 +74,19 @@ test("compression: buildExecuteTaskPrompt minimal truncates prior summaries", ()
   );
 });
 
+test("compression: buildExecuteTaskPrompt passes verificationBudget to loadPrompt (#707)", () => {
+  // The execute-task template declares {{verificationBudget}} — the builder must supply it
+  assert.ok(
+    promptsSrc.includes("verificationBudget"),
+    "buildExecuteTaskPrompt should pass verificationBudget in the loadPrompt vars object",
+  );
+  // Verify it computes the budget from computeBudgets
+  assert.ok(
+    promptsSrc.includes("computeBudgets(contextWindow)"),
+    "buildExecuteTaskPrompt should compute budgets from the executor context window",
+  );
+});
+
 test("compression: buildPlanMilestonePrompt minimal drops project/requirements/decisions files", () => {
   // The plan-milestone builder should gate root file inlining on inlineLevel
   assert.ok(

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

@@ -0,0 +1,136 @@
+/**
+ * Unit tests for diff-context.ts — diff-aware context module.
+ * Tests git-based file discovery and relevance ranking.
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { tmpdir } from "node:os";
+import { mkdtempSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  getRecentlyChangedFiles,
+  getChangedFilesWithContext,
+  rankFilesByRelevance,
+} from "../diff-context.js";
+
+// ─── getRecentlyChangedFiles ────────────────────────────────────────────────
+
+describe("diff-context: getRecentlyChangedFiles", () => {
+  it("returns an array of file paths in the current git repo", async () => {
+    // Use the project root — guaranteed to be a git repo
+    const cwd = process.cwd();
+    const files = await getRecentlyChangedFiles(cwd);
+
+    assert.ok(Array.isArray(files), "should return an array");
+    // The result may be empty if the repo is totally clean with no recent
+    // commits, but the function should not throw.
+  });
+
+  it("respects maxFiles option", async () => {
+    const cwd = process.cwd();
+    const files = await getRecentlyChangedFiles(cwd, { maxFiles: 3 });
+
+    assert.ok(files.length <= 3, "should not exceed maxFiles");
+  });
+
+  it("returns empty array for non-git directory", async () => {
+    const tmp = mkdtempSync(join(tmpdir(), "diff-ctx-test-"));
+    const files = await getRecentlyChangedFiles(tmp);
+
+    assert.deepStrictEqual(files, [], "should return empty array for non-git dir");
+  });
+
+  it("returns deduplicated paths", async () => {
+    const cwd = process.cwd();
+    const files = await getRecentlyChangedFiles(cwd, { maxFiles: 100 });
+    const unique = new Set(files);
+
+    assert.equal(files.length, unique.size, "should have no duplicates");
+  });
+});
+
+// ─── getChangedFilesWithContext ─────────────────────────────────────────────
+
+describe("diff-context: getChangedFilesWithContext", () => {
+  it("returns array of ChangedFileInfo objects", async () => {
+    const cwd = process.cwd();
+    const infos = await getChangedFilesWithContext(cwd);
+
+    assert.ok(Array.isArray(infos), "should return an array");
+
+    for (const info of infos) {
+      assert.ok(typeof info.path === "string", "path should be a string");
+      assert.ok(
+        ["modified", "added", "deleted", "staged"].includes(info.changeType),
+        `changeType should be valid, got: ${info.changeType}`,
+      );
+      if (info.linesChanged !== undefined) {
+        assert.ok(typeof info.linesChanged === "number", "linesChanged should be a number");
+      }
+    }
+  });
+
+  it("returns empty array for non-git directory", async () => {
+    const tmp = mkdtempSync(join(tmpdir(), "diff-ctx-test2-"));
+    const infos = await getChangedFilesWithContext(tmp);
+
+    assert.deepStrictEqual(infos, [], "should return empty array for non-git dir");
+  });
+});
+
+// ─── rankFilesByRelevance ───────────────────────────────────────────────────
+
+describe("diff-context: rankFilesByRelevance", () => {
+  it("places changed files before unchanged files", () => {
+    const allFiles = ["a.ts", "b.ts", "c.ts", "d.ts"];
+    const changed = ["c.ts", "a.ts"];
+
+    const ranked = rankFilesByRelevance(allFiles, changed);
+
+    // Changed files come first, sorted by changedFiles priority (c before a)
+    assert.equal(ranked[0], "c.ts");
+    assert.equal(ranked[1], "a.ts");
+    // Unchanged files follow in original order
+    assert.equal(ranked[2], "b.ts");
+    assert.equal(ranked[3], "d.ts");
+  });
+
+  it("preserves order of changed files based on changedFiles priority", () => {
+    const allFiles = ["x.ts", "y.ts", "z.ts", "w.ts"];
+    const changed = ["z.ts", "x.ts"]; // z has higher priority (index 0)
+
+    const ranked = rankFilesByRelevance(allFiles, changed);
+
+    assert.equal(ranked[0], "z.ts", "z.ts should be first (higher priority in changedFiles)");
+    assert.equal(ranked[1], "x.ts", "x.ts should be second");
+  });
+
+  it("returns unchanged files in original order when no changed files match", () => {
+    const allFiles = ["a.ts", "b.ts", "c.ts"];
+    const changed = ["x.ts", "y.ts"]; // none match
+
+    const ranked = rankFilesByRelevance(allFiles, changed);
+
+    assert.deepStrictEqual(ranked, ["a.ts", "b.ts", "c.ts"]);
+  });
+
+  it("handles empty inputs gracefully", () => {
+    assert.deepStrictEqual(rankFilesByRelevance([], []), []);
+    assert.deepStrictEqual(rankFilesByRelevance(["a.ts"], []), ["a.ts"]);
+    assert.deepStrictEqual(rankFilesByRelevance([], ["a.ts"]), []);
+  });
+
+  it("handles all files being changed", () => {
+    const allFiles = ["a.ts", "b.ts"];
+    const changed = ["b.ts", "a.ts"];
+
+    const ranked = rankFilesByRelevance(allFiles, changed);
+
+    // Both are changed, so sorted by changedFiles order: b first, then a
+    assert.equal(ranked[0], "b.ts");
+    assert.equal(ranked[1], "a.ts");
+    assert.equal(ranked.length, 2);
+  });
+});

package/src/resources/extensions/gsd/tests/doctor-git.test.ts

@@ -65,6 +65,27 @@ _None_
   return dir;
 }
 
+/** Write a .gsd/preferences.md with the given git isolation mode. */
+function writePreferencesFile(dir: string, isolation: "none" | "worktree" | "branch"): void {
+  const gsdDir = join(dir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+  writeFileSync(join(gsdDir, "preferences.md"), `---\ngit:\n  isolation: "${isolation}"\n---\n`);
+}
+
+/**
+ * Write preferences to the test runner's cwd .gsd/preferences.md.
+ * loadEffectiveGSDPreferences() resolves PROJECT_PREFERENCES_PATH at module
+ * load time from process.cwd(), so we must write there — not to the temp dir.
+ */
+const RUNNER_PREFS_PATH = join(process.cwd(), ".gsd", "preferences.md");
+function writeRunnerPreferences(isolation: "none" | "worktree" | "branch"): void {
+  mkdirSync(join(process.cwd(), ".gsd"), { recursive: true });
+  writeFileSync(RUNNER_PREFS_PATH, `---\ngit:\n  isolation: "${isolation}"\n---\n`);
+}
+function removeRunnerPreferences(): void {
+  try { rmSync(RUNNER_PREFS_PATH); } catch { /* ignore if already gone */ }
+}
+
 /** Create a repo with an in-progress milestone. */
 function createRepoWithActiveMilestone(): string {
   const dir = realpathSync(mkdtempSync(join(tmpdir(), "doc-git-test-")));
@@ -252,6 +273,103 @@ async function main(): Promise<void> {
       console.log("\n=== active worktree safety (skipped on Windows) ===");
     }
 
+    // ─── Test 7: none-mode skips orphaned worktree check ───────────────
+    // NOTE: loadEffectiveGSDPreferences() resolves PROJECT_PREFERENCES_PATH
+    // at module load time from process.cwd(). We write the prefs file to
+    // the test runner's cwd .gsd/preferences.md and clean up afterwards.
+    if (process.platform !== "win32") {
+    console.log("\n=== none-mode skips orphaned worktree ===");
+    {
+      const dir = createRepoWithCompletedMilestone();
+      cleanups.push(dir);
+
+      // Create worktree with milestone/M001 branch under .gsd/worktrees/
+      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b milestone/M001 .gsd/worktrees/M001", dir);
+
+      // Write preferences to runner's cwd (where the module resolves project prefs)
+      writeRunnerPreferences("none");
+      try {
+        const result = await runGSDDoctor(dir);
+        const orphanIssues = result.issues.filter(i => i.code === "orphaned_auto_worktree");
+        assertEq(orphanIssues.length, 0, "none-mode: orphaned worktree NOT detected");
+      } finally {
+        removeRunnerPreferences();
+      }
+    }
+    } else {
+      console.log("\n=== none-mode skips orphaned worktree (skipped on Windows) ===");
+    }
+
+    // ─── Test 8: none-mode skips stale branch check ────────────────────
+    if (process.platform !== "win32") {
+    console.log("\n=== none-mode skips stale branch ===");
+    {
+      const dir = createRepoWithCompletedMilestone();
+      cleanups.push(dir);
+
+      // Create a milestone/M001 branch (no worktree)
+      run("git branch milestone/M001", dir);
+
+      // Write preferences to runner's cwd
+      writeRunnerPreferences("none");
+      try {
+        const result = await runGSDDoctor(dir);
+        const staleIssues = result.issues.filter(i => i.code === "stale_milestone_branch");
+        assertEq(staleIssues.length, 0, "none-mode: stale branch NOT detected");
+      } finally {
+        removeRunnerPreferences();
+      }
+    }
+    } else {
+      console.log("\n=== none-mode skips stale branch (skipped on Windows) ===");
+    }
+
+    // ─── Test 9: none-mode still detects corrupt merge state ───────────
+    console.log("\n=== none-mode keeps corrupt merge state ===");
+    {
+      const dir = createRepoWithCompletedMilestone();
+      cleanups.push(dir);
+
+      // Inject MERGE_HEAD into .git
+      const headHash = run("git rev-parse HEAD", dir);
+      writeFileSync(join(dir, ".git", "MERGE_HEAD"), headHash + "\n");
+
+      // Write preferences to runner's cwd
+      writeRunnerPreferences("none");
+      try {
+        const result = await runGSDDoctor(dir);
+        const mergeIssues = result.issues.filter(i => i.code === "corrupt_merge_state");
+        assertTrue(mergeIssues.length > 0, "none-mode: corrupt merge state IS detected");
+      } finally {
+        removeRunnerPreferences();
+      }
+    }
+
+    // ─── Test 10: none-mode still detects tracked runtime files ────────
+    console.log("\n=== none-mode keeps tracked runtime files ===");
+    {
+      const dir = createRepoWithCompletedMilestone();
+      cleanups.push(dir);
+
+      // Force-add a runtime file
+      const activityDir = join(dir, ".gsd", "activity");
+      mkdirSync(activityDir, { recursive: true });
+      writeFileSync(join(activityDir, "test.log"), "log data\n");
+      run("git add -f .gsd/activity/test.log", dir);
+      run("git commit -m \"track runtime file\"", dir);
+
+      // Write preferences to runner's cwd
+      writeRunnerPreferences("none");
+      try {
+        const result = await runGSDDoctor(dir);
+        const trackedIssues = result.issues.filter(i => i.code === "tracked_runtime_files");
+        assertTrue(trackedIssues.length > 0, "none-mode: tracked runtime files IS detected");
+      } finally {
+        removeRunnerPreferences();
+      }
+    }
+
   } finally {
     for (const dir of cleanups) {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }

package/src/resources/extensions/gsd/tests/marketplace-discovery.test.ts

@@ -0,0 +1,202 @@
+/**
+ * Marketplace Discovery Tests
+ * 
+ * Tests for the marketplace discovery module that reads marketplace.json
+ * from real Claude marketplace repos, resolves plugin roots, parses plugin.json
+ * manifests, and inventories components.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import {
+  parseMarketplaceJson,
+  inspectPlugin,
+  discoverMarketplace,
+  resolvePluginRoot
+} from '../marketplace-discovery.js';
+import { getMarketplaceFixtures } from './marketplace-test-fixtures.js';
+
+const fixtureSetup = getMarketplaceFixtures(import.meta.dirname);
+const fixtures = fixtureSetup.fixtures;
+const CLAUDE_SKILLS_PATH = fixtures?.claudeSkillsPath;
+const CLAUDE_PLUGINS_OFFICIAL_PATH = fixtures?.claudePluginsOfficialPath;
+
+const skipReason = !fixtureSetup.available
+  ? fixtureSetup.skipReason ?? 'Marketplace repos not found'
+  : undefined;
+
+describe('parseMarketplaceJson', { skip: skipReason }, () => {
+  it('should parse jamie-style marketplace.json', () => {
+    const result = parseMarketplaceJson(CLAUDE_SKILLS_PATH!);
+    assert.strictEqual(result.success, true);
+    if (result.success) {
+      assert.strictEqual(result.manifest.name, 'jamie-bitflight-skills');
+      assert.strictEqual(result.manifest.plugins.length, 26);
+    }
+  });
+
+  it('should parse official-style marketplace.json', () => {
+    const result = parseMarketplaceJson(CLAUDE_PLUGINS_OFFICIAL_PATH!);
+    assert.strictEqual(result.success, true);
+    if (result.success) {
+      assert.strictEqual(result.manifest.name, 'claude-plugins-official');
+      assert.ok(result.manifest.plugins.length > 50);
+    }
+  });
+
+  it('should return error for missing marketplace.json', () => {
+    const result = parseMarketplaceJson('/tmp/nonexistent');
+    assert.strictEqual(result.success, false);
+    if (!result.success) {
+      assert.ok(result.error.includes('not found'));
+    }
+  });
+
+  it('should return error for malformed JSON', () => {
+    const tmpDir = '/tmp/test-marketplace-json-' + Date.now();
+    fs.mkdirSync(tmpDir + '/.claude-plugin', { recursive: true });
+    fs.writeFileSync(tmpDir + '/.claude-plugin/marketplace.json', '{ invalid json');
+    
+    const result = parseMarketplaceJson(tmpDir);
+    assert.strictEqual(result.success, false);
+    if (!result.success) {
+      assert.ok(result.error.includes('Failed to parse'));
+    }
+    
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+});
+
+describe('resolvePluginRoot', { skip: skipReason }, () => {
+  it('should resolve relative paths correctly', () => {
+    const result = resolvePluginRoot(CLAUDE_SKILLS_PATH!, './plugins/python3-development');
+    assert.strictEqual(result, path.join(CLAUDE_SKILLS_PATH!, 'plugins/python3-development'));
+  });
+
+  it('should handle paths without ./ prefix', () => {
+    const result = resolvePluginRoot(CLAUDE_SKILLS_PATH!, 'plugins/python3-development');
+    assert.strictEqual(result, path.join(CLAUDE_SKILLS_PATH!, 'plugins/python3-development'));
+  });
+
+  it('should return null for external sources', () => {
+    const result = resolvePluginRoot(CLAUDE_SKILLS_PATH!, 'https://github.com/example/plugin');
+    assert.strictEqual(result, null);
+  });
+
+  it('should return null for git sources', () => {
+    const result = resolvePluginRoot(CLAUDE_SKILLS_PATH!, { source: 'github', repo: 'example/plugin' });
+    assert.strictEqual(result, null);
+  });
+});
+
+describe('inspectPlugin', { skip: skipReason }, () => {
+  it('should inspect a plugin with plugin.json', () => {
+    const pluginDir = path.join(CLAUDE_SKILLS_PATH!, 'plugins/python3-development');
+    const result = inspectPlugin(pluginDir);
+    
+    assert.strictEqual(result.status, 'ok');
+    assert.strictEqual(result.manifestSource, 'plugin.json');
+    assert.strictEqual(result.name, 'python3-development');
+    assert.ok(result.description !== undefined);
+    assert.ok(result.version !== undefined);
+    assert.ok(result.inventory.skills.length > 0);
+    assert.ok(result.inventory.agents.length > 0);
+    assert.ok(result.inventory.commands.length > 0);
+    assert.ok(Object.keys(result.inventory.mcpServers).length > 0);
+  });
+
+  it('should return error for non-existent plugin directory', () => {
+    const result = inspectPlugin('/tmp/nonexistent-plugin');
+    assert.strictEqual(result.status, 'error');
+    assert.ok(result.error !== undefined, 'error should be defined');
+    assert.ok(result.error.includes('not found'));
+  });
+});
+
+describe('discoverMarketplace', { skip: skipReason }, () => {
+  it('should discover all plugins in jamie-style marketplace', () => {
+    const result = discoverMarketplace(CLAUDE_SKILLS_PATH!);
+    
+    assert.strictEqual(result.status, 'ok');
+    assert.strictEqual(result.pluginFormat, 'jamie-style');
+    assert.ok(result.plugins.length > 0);
+    assert.ok(result.plugins.every((p: { status: string }) => p.status === 'ok'));
+    
+    assert.strictEqual(result.summary.total, result.plugins.length);
+    assert.strictEqual(result.summary.ok, result.plugins.length);
+    assert.strictEqual(result.summary.error, 0);
+  });
+
+  it('should discover all plugins in official-style marketplace', () => {
+    const result = discoverMarketplace(CLAUDE_PLUGINS_OFFICIAL_PATH!);
+    
+    assert.strictEqual(result.status, 'ok');
+    assert.strictEqual(result.pluginFormat, 'official-style');
+    assert.ok(result.plugins.length > 50);
+  });
+
+  it('should return structured error for missing marketplace', () => {
+    const result = discoverMarketplace('/tmp/nonexistent');
+    
+    assert.strictEqual(result.status, 'error');
+    assert.ok(result.error !== undefined);
+    assert.ok(result.error.includes('not found'));
+    assert.deepStrictEqual(result.plugins, []);
+    assert.strictEqual(result.summary.total, 0);
+  });
+
+  it('should inventory skills, agents, commands correctly', () => {
+    const result = discoverMarketplace(CLAUDE_SKILLS_PATH!);
+    const pythonPlugin = result.plugins.find((p: { name: string }) => p.name === 'python3-development');
+    
+    assert.ok(pythonPlugin !== undefined);
+    if (pythonPlugin) {
+      assert.ok(pythonPlugin.inventory.skills.length > 30);
+      assert.ok(pythonPlugin.inventory.agents.length > 10);
+      assert.ok(pythonPlugin.inventory.commands.length > 0);
+    }
+  });
+
+  it('should discover MCP servers from plugin.json', () => {
+    const result = discoverMarketplace(CLAUDE_SKILLS_PATH!);
+    const pythonPlugin = result.plugins.find(p => p.name === 'python3-development');
+    
+    assert.ok(pythonPlugin !== undefined);
+    if (pythonPlugin) {
+      assert.ok(Object.keys(pythonPlugin.inventory.mcpServers).includes('cocoindex-code'));
+    }
+  });
+
+  it('should discover LSP servers from marketplace.json', () => {
+    const result = discoverMarketplace(CLAUDE_PLUGINS_OFFICIAL_PATH!);
+    const tsPlugin = result.plugins.find(p => p.name === 'typescript-lsp');
+    
+    assert.ok(tsPlugin !== undefined);
+    if (tsPlugin) {
+      assert.ok(Object.keys(tsPlugin.inventory.lspServers).includes('typescript'));
+    }
+  });
+
+  it('should detect external plugins correctly', () => {
+    const result = discoverMarketplace(CLAUDE_PLUGINS_OFFICIAL_PATH!);
+    const externalPlugin = result.plugins.find(p => p.name === 'atlassian');
+    
+    assert.ok(externalPlugin !== undefined);
+    if (externalPlugin) {
+      assert.strictEqual(externalPlugin.resolvedPath, null);
+      assert.strictEqual(externalPlugin.status, 'ok');
+    }
+  });
+});
+
+describe('smoke test', { skip: skipReason }, () => {
+  it('should be able to run discovery from both marketplace repos', () => {
+    const jamieResult = discoverMarketplace(CLAUDE_SKILLS_PATH!);
+    const officialResult = discoverMarketplace(CLAUDE_PLUGINS_OFFICIAL_PATH!);
+    
+    assert.strictEqual(jamieResult.status, 'ok');
+    assert.strictEqual(officialResult.status, 'ok');
+  });
+});

package/src/resources/extensions/gsd/tests/marketplace-test-fixtures.ts

@@ -0,0 +1,91 @@
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+export interface MarketplaceFixtureSet {
+  claudeSkillsPath: string;
+  claudePluginsOfficialPath: string;
+  source: 'local' | 'cloned';
+  cleanup: () => void;
+}
+
+const CLAUDE_SKILLS_REPO = 'https://github.com/Jamie-BitFlight/claude_skills.git';
+const CLAUDE_PLUGINS_OFFICIAL_REPO = 'https://github.com/Jamie-BitFlight/claude-plugins-official.git';
+const CLONE_FIXTURES_ENABLED = process.env.GSD_TEST_CLONE_MARKETPLACES === '1';
+
+function canRunGit(): boolean {
+  const result = spawnSync('git', ['--version'], { stdio: 'ignore' });
+  return result.status === 0;
+}
+
+function cloneRepo(repo: string, dest: string): void {
+  const result = spawnSync('git', ['clone', '--depth', '1', repo, dest], {
+    stdio: 'pipe',
+    encoding: 'utf8',
+    timeout: 120000,
+  });
+
+  if (result.status !== 0) {
+    const stderr = (result.stderr || result.stdout || '').trim();
+    throw new Error(`git clone failed for ${repo}: ${stderr}`);
+  }
+}
+
+export function getMarketplaceFixtures(testFileDir: string): { available: boolean; skipReason?: string; fixtures?: MarketplaceFixtureSet } {
+  const gsd2Root = resolve(testFileDir, '../../../../..');
+  const localClaudeSkillsPath = resolve(gsd2Root, '../claude_skills');
+  const localClaudePluginsOfficialPath = resolve(gsd2Root, '../claude-plugins-official');
+
+  if (existsSync(localClaudeSkillsPath) && existsSync(localClaudePluginsOfficialPath)) {
+    return {
+      available: true,
+      fixtures: {
+        claudeSkillsPath: localClaudeSkillsPath,
+        claudePluginsOfficialPath: localClaudePluginsOfficialPath,
+        source: 'local',
+        cleanup: () => {},
+      },
+    };
+  }
+
+  if (!CLONE_FIXTURES_ENABLED) {
+    return {
+      available: false,
+      skipReason: 'Marketplace repos absent and clone-based fixtures are disabled (set GSD_TEST_CLONE_MARKETPLACES=1 to enable)',
+    };
+  }
+
+  if (!canRunGit()) {
+    return {
+      available: false,
+      skipReason: 'Marketplace repos absent and git is unavailable for cloning test fixtures',
+    };
+  }
+
+  try {
+    const fixtureRoot = mkdtempSync(join(tmpdir(), 'gsd-marketplace-fixtures-'));
+    const clonedClaudeSkillsPath = join(fixtureRoot, 'claude_skills');
+    const clonedClaudePluginsOfficialPath = join(fixtureRoot, 'claude-plugins-official');
+
+    cloneRepo(CLAUDE_SKILLS_REPO, clonedClaudeSkillsPath);
+    cloneRepo(CLAUDE_PLUGINS_OFFICIAL_REPO, clonedClaudePluginsOfficialPath);
+
+    return {
+      available: true,
+      fixtures: {
+        claudeSkillsPath: clonedClaudeSkillsPath,
+        claudePluginsOfficialPath: clonedClaudePluginsOfficialPath,
+        source: 'cloned',
+        cleanup: () => {
+          rmSync(fixtureRoot, { recursive: true, force: true });
+        },
+      },
+    };
+  } catch (error) {
+    return {
+      available: false,
+      skipReason: error instanceof Error ? error.message : String(error),
+    };
+  }
+}