vouchington-tooling 0.1.8 → 0.2.0

package/dist/skill-discovery/index.mjs

@@ -0,0 +1,64 @@
+import { lstat, realpath } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { linkDirectoryEntry, resolveTargetDirectory, } from './target-directory.mjs';
+import { assertContained, isContained, isSafeSkillName, readSkillManifest, } from './manifest.mjs';
+export { readSkillManifest } from './manifest.mjs';
+export async function linkSkill(options) {
+    if (!isSafeSkillName(options.name))
+        throw new Error(`Invalid skill name: ${options.name}`);
+    const sourceRoot = resolve(options.sourceRoot);
+    const canonicalSourceRoot = await realpath(sourceRoot);
+    const manifest = await readSkillManifest(sourceRoot);
+    const entry = manifest.skills.find((candidate) => candidate.name === options.name);
+    if (entry === undefined)
+        throw new Error(`Unknown skill: ${options.name}`);
+    const targetRoot = await resolveTargetDirectory(options.targetRoot);
+    const linked = new Set();
+    const linking = new Set();
+    return linkManifestSkill(sourceRoot, canonicalSourceRoot, targetRoot, manifest, entry, linked, linking);
+}
+async function linkManifestSkill(sourceRoot, canonicalSourceRoot, targetRoot, manifest, entry, linked, linking) {
+    if (linked.has(entry.name))
+        return linkResult(targetRoot, entry.name, sourceRoot, canonicalSourceRoot, entry.path);
+    if (linking.has(entry.name))
+        throw new Error(`Circular skill prerequisite: ${entry.name}`);
+    linking.add(entry.name);
+    try {
+        for (const prerequisite of prerequisitesFor(manifest, entry)) {
+            await linkManifestSkill(sourceRoot, canonicalSourceRoot, targetRoot, manifest, prerequisite, linked, linking);
+        }
+        const result = await linkResult(targetRoot, entry.name, sourceRoot, canonicalSourceRoot, entry.path);
+        linked.add(entry.name);
+        return result;
+    }
+    finally {
+        linking.delete(entry.name);
+    }
+}
+async function linkResult(targetRoot, name, sourceRoot, canonicalSourceRoot, skillPath) {
+    const source = await resolveSkillSource(sourceRoot, canonicalSourceRoot, skillPath);
+    const path = assertContained(targetRoot.path, name);
+    return { created: await linkDirectoryEntry(source, targetRoot, name), path, source };
+}
+function prerequisitesFor(manifest, entry) {
+    const entriesByName = new Map(manifest.skills.map((candidate) => [candidate.name, candidate]));
+    return (entry.prerequisites ?? []).map((name) => entriesByName.get(name));
+}
+async function resolveSkillSource(sourceRoot, canonicalSourceRoot, skillPath) {
+    const candidate = assertContained(sourceRoot, skillPath);
+    let skill;
+    try {
+        skill = await realpath(candidate);
+    }
+    catch {
+        /* v8 ignore next 2 -- only an attacker replacing a validated source can reach this. */
+        throw new Error(`Invalid skill source: ${skillPath}`);
+    }
+    /* v8 ignore next 2 -- only an attacker replacing a validated source can reach this. */
+    if (!isContained(canonicalSourceRoot, skill) || !(await lstat(skill)).isFile())
+        throw new Error(`Skill source escapes root: ${skillPath}`);
+    // Validate through the canonical path, but retain the caller's logical root in
+    // the link target. Package managers replace their physical store paths during
+    // upgrades while the logical installed path remains stable.
+    return dirname(candidate);
+}

package/dist/skill-discovery/manifest.d.mts

@@ -0,0 +1,15 @@
+export type SkillManifestEntry = {
+    name: string;
+    plugin: string;
+    pluginVersion: string;
+    path: string;
+    prerequisites?: string[];
+};
+export type SkillManifest = {
+    version: 1;
+    skills: SkillManifestEntry[];
+};
+export declare function readSkillManifest(sourceRoot: string): Promise<SkillManifest>;
+export declare function assertContained(root: string, child: string): string;
+export declare function isSafeSkillName(name: string): boolean;
+export declare function isContained(root: string, path: string): boolean;

package/dist/skill-discovery/manifest.mjs

@@ -0,0 +1,85 @@
+import { lstat, readFile, realpath } from 'node:fs/promises';
+import { basename, isAbsolute, relative, resolve, join } from 'node:path';
+export async function readSkillManifest(sourceRoot) {
+    const root = await realpath(resolve(sourceRoot));
+    const parsed = JSON.parse(await readFile(join(root, 'manifest.json'), 'utf8'));
+    if (!isManifest(parsed))
+        throw new Error('Invalid skills manifest');
+    await validateManifestEntries(root, parsed.skills);
+    return parsed;
+}
+export function assertContained(root, child) {
+    if (isAbsolute(child))
+        throw new Error(`Skill path escapes root: ${child}`);
+    const path = resolve(root, child);
+    if (!isContained(root, path))
+        throw new Error(`Skill path escapes root: ${child}`);
+    return path;
+}
+export function isSafeSkillName(name) {
+    return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name);
+}
+export function isContained(root, path) {
+    const pathRelative = relative(root, path);
+    return !pathRelative.startsWith('..') && !isAbsolute(pathRelative);
+}
+async function validateManifestEntries(root, entries) {
+    const names = new Set();
+    const lexicalPaths = new Set();
+    const canonicalPaths = new Set();
+    for (const entry of entries) {
+        if (!isSafeSkillName(entry.name))
+            throw new Error(`Invalid skill name: ${entry.name}`);
+        if (names.has(entry.name))
+            throw new Error(`Duplicate skill name: ${entry.name}`);
+        names.add(entry.name);
+        const prerequisites = entry.prerequisites ?? [];
+        if (new Set(prerequisites).size !== prerequisites.length)
+            throw new Error(`Duplicate skill prerequisite: ${entry.name}`);
+        for (const prerequisite of prerequisites) {
+            if (!isSafeSkillName(prerequisite))
+                throw new Error(`Invalid skill prerequisite: ${prerequisite}`);
+        }
+        if (basename(entry.path) !== 'SKILL.md')
+            throw new Error(`Invalid skill source: ${entry.path}`);
+        const path = assertContained(root, entry.path);
+        if (lexicalPaths.has(path))
+            throw new Error(`Duplicate skill path: ${entry.path}`);
+        lexicalPaths.add(path);
+        let canonicalPath;
+        try {
+            canonicalPath = await realpath(path);
+        }
+        catch {
+            throw new Error(`Invalid skill source: ${entry.path}`);
+        }
+        if (!isContained(root, canonicalPath))
+            throw new Error(`Skill source escapes root: ${entry.path}`);
+        if (!(await lstat(canonicalPath)).isFile())
+            throw new Error(`Invalid skill source: ${entry.path}`);
+        if (canonicalPaths.has(canonicalPath))
+            throw new Error(`Duplicate skill path: ${entry.path}`);
+        canonicalPaths.add(canonicalPath);
+    }
+    for (const entry of entries) {
+        for (const prerequisite of entry.prerequisites ?? []) {
+            if (!names.has(prerequisite))
+                throw new Error(`Missing prerequisite skill: ${prerequisite}`);
+        }
+    }
+}
+function isManifest(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const manifest = value;
+    return manifest.version === 1 && Array.isArray(manifest.skills) && manifest.skills.every(isEntry);
+}
+function isEntry(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const entry = value;
+    return ([entry.name, entry.plugin, entry.pluginVersion, entry.path].every((field) => typeof field === 'string' && field.length > 0) &&
+        (entry.prerequisites === undefined ||
+            (Array.isArray(entry.prerequisites) &&
+                entry.prerequisites.every((name) => typeof name === 'string'))));
+}

package/dist/skill-discovery/target-directory.d.mts

@@ -0,0 +1,10 @@
+export type TargetDirectory = {
+    path: string;
+    dev: bigint;
+    ino: bigint;
+};
+export declare function resolveTargetDirectory(targetRoot: string, beforeRevalidate?: () => Promise<void>): Promise<TargetDirectory>;
+export declare function linkDirectoryEntry(source: string, target: TargetDirectory, name: string, beforeWorker?: () => Promise<void>, worker?: DirectoryLinkWorker, afterWorker?: () => Promise<void>): Promise<boolean>;
+type DirectoryLinkWorker = (source: string, target: TargetDirectory, name: string) => Promise<string>;
+export declare function snapshotTargetDirectory(path: string): Promise<TargetDirectory>;
+export {};

package/dist/skill-discovery/target-directory.mjs

@@ -0,0 +1,126 @@
+import { execFile } from 'node:child_process';
+import { lstat } from 'node:fs/promises';
+import { parse, relative, resolve, sep, join } from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+export async function resolveTargetDirectory(targetRoot, beforeRevalidate) {
+    const path = resolve(targetRoot);
+    const ancestors = await snapshotTargetAncestors(path);
+    await beforeRevalidate?.();
+    await assertTargetAncestorsUnchanged(ancestors);
+    return ancestors.at(-1);
+}
+export async function linkDirectoryEntry(source, target, name, beforeWorker, worker = runDirectoryLinkWorker, afterWorker) {
+    await beforeWorker?.();
+    const stdout = await worker(source, target, name);
+    await afterWorker?.();
+    await assertTargetUnchanged(target);
+    if (stdout === 'created')
+        return true;
+    if (stdout === 'existing')
+        return false;
+    throw new Error('Skill link worker returned an invalid result');
+}
+async function runDirectoryLinkWorker(source, target, name) {
+    try {
+        const { stdout } = await execFileAsync(process.execPath, [
+            '--input-type=module',
+            '--eval',
+            LINK_WORKER,
+            source,
+            name,
+            String(target.dev),
+            String(target.ino),
+        ], { cwd: target.path, windowsHide: true });
+        return stdout;
+    }
+    catch (error) {
+        if (error.stderr?.includes('Target root changed during skill linking'))
+            throw new Error('Target root changed during skill linking');
+        throw error;
+    }
+}
+export async function snapshotTargetDirectory(path) {
+    const stat = await lstat(path, { bigint: true });
+    if (stat.isSymbolicLink())
+        throw new Error(`Target root contains symlink: ${path}`);
+    if (!stat.isDirectory())
+        throw new Error(`Invalid target root: ${path}`);
+    return { path, dev: stat.dev, ino: stat.ino };
+}
+async function assertTargetUnchanged(target) {
+    try {
+        const current = await snapshotTargetDirectory(target.path);
+        if (current.dev === target.dev && current.ino === target.ino)
+            return;
+    }
+    catch { }
+    throw new Error('Target root changed during skill linking');
+}
+async function snapshotTargetAncestors(path) {
+    const parsed = parse(path);
+    let ancestor = parsed.root;
+    const ancestors = [];
+    for (const component of relative(parsed.root, path).split(sep)) {
+        ancestor = join(ancestor, component);
+        try {
+            ancestors.push(await snapshotTargetDirectory(ancestor));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                throw new Error(`Target root must exist: ${path}`);
+            throw error;
+        }
+    }
+    return ancestors;
+}
+async function assertTargetAncestorsUnchanged(ancestors) {
+    try {
+        for (const target of ancestors) {
+            const current = await snapshotTargetDirectory(target.path);
+            if (current.dev !== target.dev || current.ino !== target.ino)
+                throw new Error('Target root changed while resolving');
+        }
+    }
+    catch {
+        throw new Error('Target root changed while resolving');
+    }
+}
+const LINK_WORKER = String.raw `
+import { lstat, readlink, symlink } from 'node:fs/promises'
+
+const [source, name, dev, ino] = process.argv.slice(1)
+const directory = await lstat('.', { bigint: true })
+if (!directory.isDirectory() || directory.isSymbolicLink() || directory.dev !== BigInt(dev) || directory.ino !== BigInt(ino))
+  throw new Error('Target root changed during skill linking')
+async function assertExistingMatchesSource() {
+  const destination = await lstat(name)
+  if (!destination.isSymbolicLink() || (await readlink(name)) !== source)
+    throw new Error('Destination already exists: ' + name)
+}
+
+let created = false
+try {
+  await assertExistingMatchesSource()
+} catch (error) {
+  if (error?.code !== 'ENOENT') throw error
+  try {
+    await symlink(source, name, 'dir')
+    created = true
+  } catch (error) {
+    if (error?.code === 'EEXIST') {
+      await assertExistingMatchesSource()
+    } else {
+      if (process.platform !== 'win32' || !['EACCES', 'EPERM'].includes(error?.code)) throw error
+      try {
+        await symlink(source, name, 'junction')
+        created = true
+      } catch (error) {
+        if (error?.code !== 'EEXIST') throw error
+        await assertExistingMatchesSource()
+      }
+    }
+  }
+}
+process.stdout.write(created ? 'created' : 'existing')
+`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vouchington-tooling",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "Vouchington CLI and extractable tooling libraries.",
   "homepage": "https://github.com/vouchington/vouchington-tooling/tree/main/packages/vouchington-tooling#readme",
   "bugs": {
@@ -31,6 +31,11 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
+    "./skill-discovery": {
+      "types": "./dist/skill-discovery/index.d.mts",
+      "import": "./dist/skill-discovery/index.mjs",
+      "default": "./dist/skill-discovery/index.mjs"
+    },
     "./runner-port-policy": {
       "types": "./dist/runner-port-policy/index.d.mts",
       "import": "./dist/runner-port-policy/index.mjs",

package/scripts/build.mjs

@@ -1,7 +1,10 @@
 import { execFileSync } from 'node:child_process'
 import { chmod, copyFile, cp, mkdir, rm } from 'node:fs/promises'
+import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
+import skillManifest from '../skill-manifest.json' with { type: 'json' }
+
 const packageRoot = new URL('..', import.meta.url)
 const dist = new URL('../dist', import.meta.url)
 
@@ -16,9 +19,18 @@ await copyFile(
   new URL('../src/runner-port-policy/runner-port-policy.json', import.meta.url),
   new URL('../dist/runner-port-policy/runner-port-policy.json', import.meta.url),
 )
-await cp(
-  new URL('../../../plugins/vouchington-workflow/skills', import.meta.url),
-  new URL('../skills', import.meta.url),
-  { recursive: true },
+const pluginRoot = fileURLToPath(new URL('../../../plugins', import.meta.url))
+const skillsRoot = fileURLToPath(new URL('../skills/', import.meta.url))
+const seenSkills = new Set()
+for (const skill of skillManifest.skills) {
+  if (seenSkills.has(skill.name)) throw new Error(`Duplicate skill: ${skill.name}`)
+  seenSkills.add(skill.name)
+  await cp(join(pluginRoot, skill.plugin, 'skills', skill.name), join(skillsRoot, skill.name), {
+    recursive: true,
+  })
+}
+await copyFile(
+  new URL('../skill-manifest.json', import.meta.url),
+  new URL('../skills/manifest.json', import.meta.url),
 )
 await chmod(new URL('../dist/cli/index.mjs', import.meta.url), 0o755)

package/skills/agent-workflow/SKILL.md

@@ -23,5 +23,10 @@ branching, review, and release policy.
 6. Review the diff for accidental files, secrets, generated output, broken documentation links,
    and assumptions that belong in local instructions instead.
 
+For portable implementation and review checks, read [implementation](references/implementation.md),
+[review](references/review.md), and [evidence sweep](references/evidence-sweep.md). The older
+[implementation and review](references/implementation-and-review.md) remains a compact overview.
+Local instructions remain authoritative for commands, commits, review systems, and release policy.
+
 Do not invent a default branch, runner class, documentation root, review system, merge policy, or
 command catalog. A consumer wrapper or local instruction file owns those choices.

package/skills/agent-workflow/references/evidence-sweep.md

@@ -0,0 +1,8 @@
+# Evidence sweep
+
+Map every acceptance criterion to a focused test, inspection, or manual verification with a concrete
+result. Run the required broader checks after focused validation. Treat skipped validation as a
+finding: state the blocker, affected surface, and remaining risk.
+
+Before handoff, compare the final diff to the accepted decision ledger and verify documentation,
+generated output, and public contracts agree with the implementation.

package/skills/agent-workflow/references/implementation-and-review.md

@@ -0,0 +1,9 @@
+# Implementation and review
+
+Before editing, map callers, tests, configuration, and documentation that own the behavior. Keep the
+change within the accepted boundary; record a new dependency or product decision before widening it.
+
+After focused validation, inspect the complete diff for accidental generated files, secret exposure,
+dead paths, and documentation drift. Validate the public interface and failure paths, not only the
+happy path. Before a reviewable commit, run the repository-required checks and state any skipped
+checks with their concrete blocker.

package/skills/agent-workflow/references/implementation.md

@@ -0,0 +1,8 @@
+# Implementation
+
+Keep an accepted-decision ledger for interfaces, data boundaries, validation, and ownership choices
+that could otherwise be lost during coding. Start from a failing behavioral test when practical and
+complete the real path rather than adding placeholders or compatibility shims without a requirement.
+
+When behavior changes, update the public contract, documentation, fixtures, and generated artifacts
+that describe it. Keep local commands, branch policy, and release mechanics in the consumer wrapper.

package/skills/agent-workflow/references/review.md

@@ -0,0 +1,7 @@
+# Review
+
+Review the complete diff, not only changed implementation lines. Check premise and scope, public
+contract compatibility, failure paths, authorization, untrusted input, secrets, and security
+boundaries. Remove dead paths and stale documentation rather than labeling them as legacy.
+
+Record unresolved risk as an explicit accepted decision or follow-up, never as an unnoticed gap.

package/skills/backend-vitest-test-authoring/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: backend-vitest-test-authoring
+description: Apply backend Vitest patterns for service, provider, persistence, and queue boundaries.
+---
+
+# Backend Vitest test authoring
+
+Apply [vitest-test-authoring](../vitest-test-authoring/SKILL.md) first. Exercise real integration
+boundaries only when their lifecycle is controlled by the test environment; otherwise mock the
+network or provider edge. Randomize fixture identities where shared stores can collide, assert
+authorization and retry behavior at boundaries, and clean up resources deterministically.
+
+Consumer wrappers own database setup, queue providers, test projects, and rate-limit policy.
+
+Read [integration boundaries](references/integration-boundaries.md) for fixture and collision safety.

package/skills/backend-vitest-test-authoring/references/integration-boundaries.md

@@ -0,0 +1,10 @@
+# Integration boundaries
+
+Use real persistence, queue, and internal-service boundaries when the test environment controls
+their lifecycle. Mock only external provider edges. Create collision-safe fixture identities and
+register event listeners before the mutation that produces them. Cleanup must be ownership-scoped;
+never broadly reset shared state used by concurrent tests.
+
+Assert persisted state, emitted work, or externally visible results at the boundary. A mock-only
+test is insufficient when import wiring, serialization, transaction behavior, or retries are part
+of the contract.

package/skills/dotnet-test-authoring/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: dotnet-test-authoring
+description: Add maintainable .NET tests with appropriate unit, app, and integration boundaries.
+---
+
+# .NET test authoring
+
+Place tests at the narrowest layer that proves the behavior. Batch native or external selection
+where the project requires it, isolate process and filesystem state, and assert serialized contracts
+instead of private implementation details. Keep test helpers typed and reusable only when they remove
+repeated setup without hiding important expectations.
+
+Consumer wrappers own solution layout, test frameworks, native dependencies, and coverage policy.
+
+Keep portable library tests separate from rendered application tests; batch compatible native targets
+in one selection pass so a shared build validates the same source set.

package/skills/manifest.json

@@ -0,0 +1,158 @@
+{
+  "version": 1,
+  "skills": [
+    {
+      "name": "agent-workflow",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "agent-workflow/SKILL.md"
+    },
+    {
+      "name": "backend-vitest-test-authoring",
+      "plugin": "vouchington-testing",
+      "pluginVersion": "0.1.0",
+      "path": "backend-vitest-test-authoring/SKILL.md",
+      "prerequisites": ["vitest-test-authoring"]
+    },
+    {
+      "name": "blackboard",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "blackboard/SKILL.md"
+    },
+    {
+      "name": "dotnet-test-authoring",
+      "plugin": "vouchington-testing",
+      "pluginVersion": "0.1.0",
+      "path": "dotnet-test-authoring/SKILL.md"
+    },
+    {
+      "name": "git-commit-checklist",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "git-commit-checklist/SKILL.md"
+    },
+    {
+      "name": "github-actions-checklist",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "github-actions-checklist/SKILL.md"
+    },
+    {
+      "name": "github-issue",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "github-issue/SKILL.md"
+    },
+    {
+      "name": "nextjs-vitest-test-authoring",
+      "plugin": "vouchington-testing",
+      "pluginVersion": "0.1.0",
+      "path": "nextjs-vitest-test-authoring/SKILL.md",
+      "prerequisites": ["vitest-test-authoring"]
+    },
+    {
+      "name": "organize-github-issues",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "organize-github-issues/SKILL.md"
+    },
+    {
+      "name": "package-json-checklist",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "package-json-checklist/SKILL.md"
+    },
+    {
+      "name": "planning",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "planning/SKILL.md"
+    },
+    {
+      "name": "playwright-authoring",
+      "plugin": "vouchington-testing",
+      "pluginVersion": "0.1.0",
+      "path": "playwright-authoring/SKILL.md"
+    },
+    {
+      "name": "postgres-node-performance-tuning",
+      "plugin": "vouchington-database",
+      "pluginVersion": "0.1.0",
+      "path": "postgres-node-performance-tuning/SKILL.md"
+    },
+    {
+      "name": "postgres-partitioning-uuid-v7",
+      "plugin": "vouchington-database",
+      "pluginVersion": "0.1.0",
+      "path": "postgres-partitioning-uuid-v7/SKILL.md"
+    },
+    {
+      "name": "pr-description",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "pr-description/SKILL.md"
+    },
+    {
+      "name": "retrospective",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "retrospective/SKILL.md"
+    },
+    {
+      "name": "retrospective-distill",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "retrospective-distill/SKILL.md"
+    },
+    {
+      "name": "review-ci-logs",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "review-ci-logs/SKILL.md"
+    },
+    {
+      "name": "review-github-issue-taxonomy",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "review-github-issue-taxonomy/SKILL.md"
+    },
+    {
+      "name": "revisit-followups",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "revisit-followups/SKILL.md"
+    },
+    {
+      "name": "static-analysis-checklist",
+      "plugin": "vouchington-workflow",
+      "pluginVersion": "0.3.0",
+      "path": "static-analysis-checklist/SKILL.md"
+    },
+    {
+      "name": "storybook-authoring",
+      "plugin": "vouchington-testing",
+      "pluginVersion": "0.1.0",
+      "path": "storybook-authoring/SKILL.md"
+    },
+    {
+      "name": "swift-test-authoring",
+      "plugin": "vouchington-testing",
+      "pluginVersion": "0.1.0",
+      "path": "swift-test-authoring/SKILL.md"
+    },
+    {
+      "name": "test-authoring",
+      "plugin": "vouchington-testing",
+      "pluginVersion": "0.1.0",
+      "path": "test-authoring/SKILL.md"
+    },
+    {
+      "name": "vitest-test-authoring",
+      "plugin": "vouchington-testing",
+      "pluginVersion": "0.1.0",
+      "path": "vitest-test-authoring/SKILL.md",
+      "prerequisites": ["test-authoring"]
+    }
+  ]
+}

package/skills/nextjs-vitest-test-authoring/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: nextjs-vitest-test-authoring
+description: Apply Vitest patterns for Next.js components, routes, and server-side modules.
+---
+
+# Next.js Vitest test authoring
+
+Apply [vitest-test-authoring](../vitest-test-authoring/SKILL.md) first. Mock framework navigation,
+headers, and server-only boundaries at the framework edge, then test component behavior through
+rendered output and user-visible state. Keep API-response fixtures representative and avoid testing
+framework internals. Use browser tests for behavior that cannot be represented in the test runtime.
+
+Consumer wrappers own framework mock helpers, render libraries, and route fixture conventions.
+
+Read [framework boundaries](references/framework-boundaries.md) for module shape and server-only cases.

package/skills/nextjs-vitest-test-authoring/references/framework-boundaries.md

@@ -0,0 +1,9 @@
+# Framework boundaries
+
+Mock framework navigation, headers, cookies, and server-only APIs at the framework edge, not inside
+the component or route under test. Preserve typed module shape and use the consumer's shared mocks
+when they exist. Build API responses with typed factories rather than inline partial objects.
+
+Use direct rendering for component behavior. If request scope, hydration, browser APIs, or server
+module resolution cannot be represented faithfully, move the assertion to an integration or browser
+test instead of widening a unit-test mock.

package/skills/planning/SKILL.md

@@ -19,5 +19,8 @@ Use before implementation work that needs a durable plan. Repository-local `AGEN
 5. Validate and save the plan using the repository's required issue or document workflow before
    implementation when local policy requires one.
 
+For cross-cutting changes, read [impact discovery](references/impact-discovery.md) before selecting
+tests or concluding that a surface has no dependents.
+
 Do not invent a plan template, default repository, issue taxonomy, dependency graph tool, or
 approval workflow. A consumer wrapper owns those choices.

package/skills/planning/references/impact-discovery.md

@@ -0,0 +1,9 @@
+# Impact discovery
+
+Start from the changed surface and trace imports, callers, configuration, generated artifacts, and
+tests. Use the repository's graph or search tools where available; otherwise record the evidence
+used and the uncertainty that remains. Select focused tests from real dependents, then include
+broader validation when a shared contract, package boundary, or generated artifact changes.
+
+Do not treat a tool's incomplete graph as proof that no dependent exists. Escalate uncertain
+high-risk boundaries for independent review or a broader test selection.