@aqian0/dsh-unity 0.0.0-stage → 0.1.0

package/lib/frontmatter.js

@@ -0,0 +1,392 @@
+/**
+ * YAML frontmatter reader for SKILL.md files.
+ *
+ * The skill documents use a small, well-understood subset of YAML, so the plugin
+ * carries its own reader instead of a parser dependency: the package must install
+ * with no build-time or run-time third-party code. Supported syntax:
+ *
+ * - top-level `key: value` mappings, including nested block mappings
+ *   (`required_packages`, `metadata`);
+ * - block sequences (`allowed-tools` followed by `- item` lines);
+ * - flow sequences (`modes: [agent, ask]`);
+ * - plain, single-quoted, and double-quoted scalars;
+ * - literal (`|`, `|-`, `|+`) and folded (`>`, `>-`, `>+`) block scalars;
+ * - full-line comments and inline ` #` comments on plain scalars.
+ *
+ * Scalars resolve through the YAML 1.2 core schema, matching what a full parser
+ * would produce for these documents. The invocation policy uses the registry's
+ * strict boolean grammar. A value this reader cannot represent is reported as a
+ * syntax error so the caller can skip the skill instead of advertising a wrong
+ * description.
+ *
+ * @module dsh-unity/lib/frontmatter
+ */
+/** Kebab-case grammar shared by the harness skill registry. */
+export const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const FENCE = '---';
+const BLOCK_HEADER = /^([|>])([+-]?)(\d?)$/;
+/**
+ * Split a Markdown document into its YAML frontmatter block and body.
+ *
+ * @param raw - complete file text.
+ * @returns the frontmatter source and body, or `undefined` without a fence.
+ */
+export function splitFrontmatter(raw) {
+    const text = raw.replace(/^\uFEFF/, '').replace(/\r\n?/g, '\n');
+    const lines = text.split('\n');
+    if (lines[0]?.trimEnd() !== FENCE)
+        return undefined;
+    for (let index = 1; index < lines.length; index += 1) {
+        if (lines[index]?.trimEnd() === FENCE) {
+            return { yaml: lines.slice(1, index).join('\n'), body: lines.slice(index + 1).join('\n') };
+        }
+    }
+    return undefined;
+}
+/**
+ * Parse a SKILL.md document into frontmatter fields and body.
+ *
+ * @param raw - complete file text.
+ * @returns parsed frontmatter and the trimmed body, or `undefined` without a fence.
+ * @throws {SyntaxError} when the frontmatter is not the supported YAML subset.
+ */
+export function parseSkillMarkdown(raw) {
+    const split = splitFrontmatter(raw);
+    if (split === undefined)
+        return undefined;
+    const data = parseYamlSubset(split.yaml);
+    if (data === null || typeof data !== 'object' || Array.isArray(data)) {
+        throw new SyntaxError('frontmatter is not a mapping');
+    }
+    return { data: data, body: split.body.trim() };
+}
+/**
+ * Parse the supported YAML subset into a plain value.
+ *
+ * @param source - YAML text without the surrounding fences.
+ * @returns a mapping, sequence, scalar, or `null` for a `key:` without a value.
+ * @throws {SyntaxError} on indentation this subset cannot represent.
+ */
+export function parseYamlSubset(source) {
+    const lines = source.replace(/\r\n?/g, '\n').split('\n');
+    const cursor = { index: 0 };
+    skipInert(lines, cursor);
+    if (cursor.index >= lines.length)
+        return {};
+    const value = parseBlock(lines, cursor, indentationOf(lines[cursor.index] ?? ''));
+    skipInert(lines, cursor);
+    if (cursor.index < lines.length) {
+        throw new SyntaxError(`unexpected content on line ${cursor.index + 1}`);
+    }
+    return value;
+}
+/**
+ * Read a frontmatter boolean with the registry's strict grammar.
+ *
+ * @param data - parsed frontmatter.
+ * @param key - exact frontmatter key.
+ * @returns the value, or `undefined` when the key is absent.
+ * @throws {TypeError} when the key is present but is not a boolean spelling.
+ */
+export function frontmatterBoolean(data, key) {
+    if (!Object.hasOwn(data, key))
+        return undefined;
+    const value = data[key];
+    if (typeof value === 'boolean')
+        return value;
+    if (value === 1 || value === '1')
+        return true;
+    if (value === 0 || value === '0')
+        return false;
+    if (typeof value === 'string') {
+        switch (value.toLowerCase()) {
+            case 'true':
+            case 'yes':
+            case 'on':
+                return true;
+            case 'false':
+            case 'no':
+            case 'off':
+                return false;
+            default:
+                break;
+        }
+    }
+    throw new TypeError(`frontmatter field "${key}" must be a boolean`);
+}
+/**
+ * Resolve the invocation policy from frontmatter.
+ *
+ * @param data - parsed frontmatter.
+ * @returns the policy; absent keys keep both surfaces permitted.
+ * @throws {Error} when a legacy camelCase key is present.
+ */
+export function parseInvocation(data) {
+    const legacy = [
+        ['disableModelInvocation', 'disable-model-invocation'],
+        ['modelInvocable', 'disable-model-invocation'],
+        ['userInvocable', 'user-invocable'],
+    ];
+    for (const [alias, canonical] of legacy) {
+        if (Object.hasOwn(data, alias)) {
+            throw new Error(`frontmatter field "${alias}" is unsupported; use "${canonical}"`);
+        }
+    }
+    return {
+        modelInvocable: frontmatterBoolean(data, 'disable-model-invocation') !== true,
+        userInvocable: frontmatterBoolean(data, 'user-invocable') !== false,
+    };
+}
+/** Advance the cursor past blank lines and full-line comments. */
+function skipInert(lines, cursor) {
+    while (cursor.index < lines.length) {
+        const line = lines[cursor.index] ?? '';
+        if (line.trim() === '' || line.trimStart().startsWith('#')) {
+            cursor.index += 1;
+            continue;
+        }
+        return;
+    }
+}
+/** Count leading spaces of a line. */
+function indentationOf(line) {
+    const match = /^ */.exec(line);
+    return match === null ? 0 : match[0].length;
+}
+/** Parse one block (mapping or sequence) whose lines start at `indent`. */
+function parseBlock(lines, cursor, indent) {
+    const first = lines[cursor.index] ?? '';
+    if (/^\s*-(?:\s|$)/.test(first))
+        return parseSequence(lines, cursor, indent);
+    return parseMapping(lines, cursor, indent);
+}
+/** Parse consecutive `key: value` lines at one indentation. */
+function parseMapping(lines, cursor, indent) {
+    const result = {};
+    while (true) {
+        skipInert(lines, cursor);
+        if (cursor.index >= lines.length)
+            break;
+        const line = lines[cursor.index] ?? '';
+        const current = indentationOf(line);
+        if (current < indent)
+            break;
+        if (current > indent)
+            throw new SyntaxError(`unexpected indentation on line ${cursor.index + 1}`);
+        const entry = /^([^:#][^:]*?):(?:[ \t]+(.*)|[ \t]*)$/.exec(line.slice(indent));
+        if (entry === null)
+            throw new SyntaxError(`expected "key: value" on line ${cursor.index + 1}`);
+        const key = entry[1]?.trim() ?? '';
+        const rest = (entry[2] ?? '').trimEnd();
+        cursor.index += 1;
+        result[key] = parseValue(lines, cursor, indent, rest);
+    }
+    return result;
+}
+/** Parse consecutive `- item` lines at one indentation. */
+function parseSequence(lines, cursor, indent) {
+    const result = [];
+    while (true) {
+        skipInert(lines, cursor);
+        if (cursor.index >= lines.length)
+            break;
+        const line = lines[cursor.index] ?? '';
+        const current = indentationOf(line);
+        if (current < indent)
+            break;
+        if (current > indent)
+            throw new SyntaxError(`unexpected indentation on line ${cursor.index + 1}`);
+        const item = /^-(?:\s+(.*)|\s*)$/.exec(line.slice(indent).trimEnd());
+        if (item === null)
+            break;
+        const rest = (item[1] ?? '').trim();
+        cursor.index += 1;
+        if (rest === '') {
+            skipInert(lines, cursor);
+            const nested = lines[cursor.index];
+            const nestedIndent = nested === undefined ? indent : indentationOf(nested);
+            result.push(nestedIndent > indent ? parseBlock(lines, cursor, nestedIndent) : null);
+            continue;
+        }
+        result.push(parseValue(lines, cursor, indent, rest));
+    }
+    return result;
+}
+/** Resolve the value that follows `key:` or `- `. */
+function parseValue(lines, cursor, indent, rest) {
+    if (rest.startsWith('#'))
+        return parseNestedOrNull(lines, cursor, indent);
+    const block = BLOCK_HEADER.exec(rest);
+    if (block !== null)
+        return parseBlockScalar(lines, cursor, indent, block[1], block[2]);
+    if (rest !== '') {
+        const plain = stripComment(rest);
+        return plain === '' ? parseNestedOrNull(lines, cursor, indent) : parseScalar(plain);
+    }
+    return parseNestedOrNull(lines, cursor, indent);
+}
+/** Read a nested block after `key:` when no inline value was present. */
+function parseNestedOrNull(lines, cursor, indent) {
+    skipInert(lines, cursor);
+    const next = lines[cursor.index];
+    if (next === undefined)
+        return null;
+    const nestedIndent = indentationOf(next);
+    if (nestedIndent <= indent)
+        return null;
+    return parseBlock(lines, cursor, nestedIndent);
+}
+/** Collect an indented block scalar and apply its folding and chomping. */
+function parseBlockScalar(lines, cursor, indent, style, chomping) {
+    const collected = [];
+    let blockIndent;
+    while (cursor.index < lines.length) {
+        const line = lines[cursor.index] ?? '';
+        if (line.trim() === '') {
+            collected.push('');
+            cursor.index += 1;
+            continue;
+        }
+        const current = indentationOf(line);
+        if (current <= indent)
+            break;
+        if (blockIndent === undefined)
+            blockIndent = current;
+        collected.push(line.slice(Math.min(blockIndent, current)));
+        cursor.index += 1;
+    }
+    while (collected.length > 0 && collected[collected.length - 1] === '') {
+        collected.pop();
+    }
+    const text = style === '|' ? collected.join('\n') : foldLines(collected);
+    if (chomping === '-')
+        return text;
+    return collected.length === 0 ? '' : `${text}\n`;
+}
+/** Fold block-scalar lines: single breaks become spaces, blank lines newlines. */
+function foldLines(lines) {
+    let out = '';
+    let pendingBreaks = 0;
+    for (const line of lines) {
+        if (line === '') {
+            pendingBreaks += 1;
+            continue;
+        }
+        if (out === '') {
+            out = line;
+            pendingBreaks = 0;
+            continue;
+        }
+        out += pendingBreaks > 0 ? '\n'.repeat(pendingBreaks) : ' ';
+        out += line;
+        pendingBreaks = 0;
+    }
+    return out;
+}
+/** Strip a ` #` inline comment from a plain scalar. */
+function stripComment(text) {
+    const index = text.search(/\s#/);
+    return index < 0 ? text.trim() : text.slice(0, index).trim();
+}
+/** Parse a single inline scalar: flow sequence, quoted string, or plain text. */
+function parseScalar(text) {
+    if (text.startsWith('[') && text.endsWith(']')) {
+        const inner = text.slice(1, -1).trim();
+        if (inner === '')
+            return [];
+        return splitFlow(inner).map((item) => parseScalar(item.trim()));
+    }
+    if (text.startsWith('"') && text.endsWith('"') && text.length >= 2) {
+        return unescapeDouble(text.slice(1, -1));
+    }
+    if (text.startsWith("'") && text.endsWith("'") && text.length >= 2) {
+        return text.slice(1, -1).replaceAll("''", "'");
+    }
+    return resolvePlain(text);
+}
+/** Resolve a plain scalar through the YAML 1.2 core schema. */
+function resolvePlain(text) {
+    switch (text) {
+        case 'null':
+        case 'Null':
+        case 'NULL':
+        case '~':
+            return null;
+        case 'true':
+        case 'True':
+        case 'TRUE':
+            return true;
+        case 'false':
+        case 'False':
+        case 'FALSE':
+            return false;
+        default:
+            break;
+    }
+    if (/^[-+]?\d+$/.test(text))
+        return Number(text);
+    if (/^[-+]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][-+]?\d+)?$/.test(text))
+        return Number(text);
+    return text;
+}
+/** Split flow-sequence contents on commas that are not inside quotes. */
+function splitFlow(text) {
+    const parts = [];
+    let current = '';
+    let quote;
+    for (const char of text) {
+        if (quote !== undefined) {
+            current += char;
+            if (char === quote)
+                quote = undefined;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            current += char;
+            continue;
+        }
+        if (char === ',') {
+            parts.push(current);
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    parts.push(current);
+    return parts;
+}
+/** Decode the double-quoted escapes present in these documents. */
+function unescapeDouble(text) {
+    let out = '';
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (char !== '\\') {
+            out += char;
+            continue;
+        }
+        const next = text[index + 1];
+        index += 1;
+        switch (next) {
+            case 'n':
+                out += '\n';
+                break;
+            case 't':
+                out += '\t';
+                break;
+            case 'r':
+                out += '\r';
+                break;
+            case '"':
+                out += '"';
+                break;
+            case '\\':
+                out += '\\';
+                break;
+            default:
+                out += next ?? '';
+                break;
+        }
+    }
+    return out;
+}

package/lib/gating.js

@@ -0,0 +1,105 @@
+/**
+ * Visibility decisions for one agent's skill catalog.
+ *
+ * The harness separates two questions about a skill: whether the model may see
+ * and load it (`modelInvocable`) and whether a person may invoke it by name
+ * (`userInvocable`). That split is exactly what project-aware gating needs: a
+ * skill that does not apply to the current project should leave the model's
+ * catalog to save context and avoid wrong suggestions, while staying reachable
+ * through an explicit `/skill-name` request.
+ *
+ * The rules here are intentionally conservative:
+ *
+ * - outside a Unity project only the configured workspace skills stay visible;
+ * - an unmet editor or package requirement hides the skill;
+ * - an *unknown* fact never hides a skill, so a broken manifest cannot silently
+ *   empty the catalog;
+ * - a skill the project provides itself is not offered by this plugin at all,
+ *   which is what keeps a project's own customization authoritative.
+ *
+ * @module dsh-unity/lib/gating
+ */
+import { evaluateRequirements } from './requirements.js';
+/**
+ * Decide the model-visibility of one skill candidate.
+ *
+ * @param candidate - candidate carrying its `requirements`.
+ * @param facts - project facts from `detectProject`.
+ * @param settings - resolved plugin settings.
+ * @returns the decision and, when hidden, a short human-readable reason.
+ */
+export function decideVisibility(candidate, facts, settings) {
+    if (!settings.enforceRequirements)
+        return { modelInvocable: true, reason: undefined };
+    const verdict = evaluateRequirements(candidate.requirements ?? { packages: [] }, facts);
+    if (!verdict.applicable)
+        return { modelInvocable: false, reason: verdict.reasons.join('; ') };
+    return { modelInvocable: true, reason: undefined };
+}
+/**
+ * Build the catalog this plugin serves for one agent.
+ *
+ * Every candidate stays in the list so a person can still invoke a hidden skill
+ * by name; only its `modelInvocable` flag changes. Candidates the project
+ * overrides are dropped instead, so the project's own copy wins the name.
+ *
+ * @param candidates - candidates from the skill reader.
+ * @param facts - project facts, or `undefined` outside a project.
+ * @param settings - resolved plugin settings.
+ * @param projectSkills - skill names the project supplies itself.
+ * @returns gated candidates and the reasons for every hidden skill.
+ */
+export function gateCatalog(candidates, facts, settings, projectSkills = new Set()) {
+    const gated = [];
+    const hidden = [];
+    const projectOverridden = [];
+    const workspaceOnly = facts === undefined && settings.gateByProject;
+    for (const candidate of candidates) {
+        if (projectSkills.has(candidate.name)) {
+            projectOverridden.push(candidate.name);
+            continue;
+        }
+        let reason;
+        if (workspaceOnly && !settings.workspaceSkills.has(candidate.name)) {
+            reason = 'no Unity project in this session';
+        }
+        else {
+            const decision = decideVisibility(candidate, facts, settings);
+            if (!decision.modelInvocable)
+                reason = decision.reason ?? 'requirements not met';
+            else if (candidate.invocation.modelInvocable !== true)
+                reason = 'the skill disables model invocation';
+        }
+        if (reason === undefined) {
+            gated.push(candidate);
+            continue;
+        }
+        hidden.push({ name: candidate.name, reason });
+        gated.push({ ...candidate, invocation: { ...candidate.invocation, modelInvocable: false } });
+    }
+    return { candidates: gated, hidden, projectOverridden };
+}
+/**
+ * Render the runtime-context line contributed for one agent.
+ *
+ * Kept to one short paragraph: it is re-read on every prompt assembly, so it must
+ * describe facts the model cannot infer and nothing else.
+ *
+ * @param facts - project facts.
+ * @param hidden - gated-away skills.
+ * @returns the context text, or `undefined` when there is nothing to say.
+ */
+export function renderContext(facts, hidden) {
+    if (facts === undefined)
+        return undefined;
+    const pipeline = facts.renderPipeline === undefined ? '' : `, ${facts.renderPipeline.toUpperCase()}`;
+    const parts = [
+        `Unity project: ${facts.root} (Editor ${facts.editorVersion ?? 'unknown'}${pipeline}, Editor ${facts.editorOpen ? 'open' : 'closed'}, unity CLI ${facts.cliAvailable ? 'available' : 'not found'})`,
+    ];
+    if (hidden.length > 0) {
+        const listed = hidden.slice(0, 6).map((entry) => `${entry.name} (${entry.reason})`);
+        const rest = hidden.length - listed.length;
+        parts.push(`skills hidden for this project: ${listed.join(', ')}${rest > 0 ? `, and ${rest} more` : ''}`);
+    }
+    return `${parts.join('. ')}.`;
+}

package/lib/harness.js

@@ -0,0 +1,16 @@
+/**
+ * Structural declarations for the harness surfaces this plugin uses.
+ *
+ * The package is a plugin bundle, not a harness package: it never imports
+ * `@deepseek-ai/*` at runtime, and it deliberately keeps no build-time dependency
+ * on them so a local checkout type-checks without a network install. The
+ * interfaces below transcribe the parts of the harness contracts that matter
+ * here — the skill registry provider contract, the prompt-context contribution,
+ * the agent-scope boundary, and the optional services reached through `ctx.get`.
+ *
+ * Each type names the harness contract it mirrors. When the harness changes one
+ * of them, this file is the single place to update.
+ *
+ * @module dsh-unity/lib/harness
+ */
+export {};

package/lib/index.js

@@ -0,0 +1,171 @@
+/**
+ * Unity's curated skills as a DeepSeek Harness plugin.
+ *
+ * The package carries 34 skills under `skills/` and serves them through the
+ * harness skill registry. What distinguishes this from a directory of Markdown
+ * files is *where* and *how* they are served:
+ *
+ * - registration happens per agent, through that agent's own context, so this
+ *   provider lives in the agent's scope layer and its catalog can depend on the
+ *   project the agent is working in;
+ * - a Unity project is detected from the session's working directory, and skills
+ *   whose `required_editor_version` / `required_packages` cannot be met leave the
+ *   model's catalog while staying reachable by explicit name;
+ * - the detected project facts are contributed to the agent's runtime context, so
+ *   the model states the editor version and package situation instead of guessing;
+ * - the skill directory is watched, and a frontmatter membership change
+ *   invalidates the cached catalog instead of requiring a restart.
+ *
+ * @module @aqian0/dsh-unity
+ */
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createAgentRegistry, createGlobalProvider, serviceOf } from './registry.js';
+import { createParseCache } from './skills.js';
+import { startSkillsWatcher } from './watch.js';
+/** Loader row name. */
+export const name = 'unity-skills';
+/** The skill registry this provider attaches to. */
+export const inject = ['skills'];
+/** Provider name the registry lists the catalog under. */
+export const DEFAULT_PROVIDER_NAME = 'unity';
+/**
+ * Default rank inside one scope layer. The catalog normally lands in the agent's
+ * own layer, where the nearest layer already wins duplicates; the rank only
+ * orders this provider against runtime (`ctx.skills.register()`) registrations,
+ * which use 250.
+ */
+export const DEFAULT_RANK = 240;
+/**
+ * Skills worth showing outside a Unity project: creating a project, driving the
+ * editor from the CLI, and managing packages are all meaningful before a project
+ * exists.
+ */
+export const DEFAULT_WORKSPACE_SKILLS = [
+    'new-unity-project',
+    'unity-cli',
+    'unity-package-management',
+];
+/** Provider name reserved by the registry for per-agent runtime registrations. */
+const RESERVED_PROVIDER = 'runtime';
+/** Directory of this package, used to locate the packaged skills. */
+const PACKAGE_DIR = fileURLToPath(new URL('../', import.meta.url));
+/**
+ * Register the Unity skill provider on `ctx.skills`.
+ *
+ * @param ctx - Cordis plugin context; `skills` is injected.
+ * @param config - row config from the loader patch.
+ */
+export function apply(ctx, config = {}) {
+    const settings = resolveSettings(config);
+    settings.parseCache = createParseCache();
+    const registry = createAgentRegistry({ ctx, settings });
+    const disposers = [];
+    let fallbackRegistered = false;
+    /** Serve one global provider when this context cannot register per agent. */
+    const ensureFallback = () => {
+        if (fallbackRegistered)
+            return;
+        fallbackRegistered = true;
+        ctx.skills.registerProvider(() => createGlobalProvider({ settings, registry }));
+        ctx.logger.warn('unity skills: per-agent registration is unavailable in this profile, so one global provider serves every session. Project gating still follows the session directory, but agent-preset skills win duplicate names.');
+    };
+    const onCreated = async (payload) => {
+        const agent = payload?.agent;
+        try {
+            const result = await registry.add(agent);
+            if (result === 'unavailable')
+                ensureFallback();
+        }
+        catch (error) {
+            ctx.logger.warn(`unity skills: agent registration failed: ${String(error)}`);
+        }
+    };
+    const agents = serviceOf(ctx, 'agents');
+    if (agents === undefined) {
+        ensureFallback();
+    }
+    else {
+        disposers.push(ctx.on('agent/created', (payload) => onCreated(payload)), ctx.on('agent/disposed', (payload) => registry.remove(payload?.agent)));
+        for (const agent of agents.list())
+            void onCreated({ agent });
+    }
+    if (settings.watchSkills) {
+        disposers.push(startSkillsWatcher({
+            dir: settings.skillDir,
+            logger: ctx.logger,
+            onChange: () => {
+                settings.parseCache?.clear();
+                registry.invalidateAll();
+            },
+        }));
+    }
+    ctx.effect(() => () => {
+        for (const dispose of disposers.splice(0)) {
+            try {
+                dispose();
+            }
+            catch {
+                // Disposal is best-effort; the fiber is going away either way.
+            }
+        }
+        registry.disposeAll();
+    }, 'unity-skills lifecycle');
+}
+/**
+ * Validate row config into normalized settings.
+ *
+ * @param config - row config from the loader patch.
+ * @returns normalized settings.
+ * @throws {TypeError} when a field is present but unusable.
+ */
+export function resolveSettings(config) {
+    const providerName = config.providerName ?? DEFAULT_PROVIDER_NAME;
+    if (typeof providerName !== 'string' || providerName.trim() === '') {
+        throw new TypeError('unity-skills: providerName must be a non-empty string');
+    }
+    if (providerName === RESERVED_PROVIDER) {
+        throw new TypeError(`unity-skills: providerName "${RESERVED_PROVIDER}" is reserved for runtime skill registrations`);
+    }
+    const rank = config.rank ?? DEFAULT_RANK;
+    if (typeof rank !== 'number' || !Number.isFinite(rank)) {
+        throw new TypeError('unity-skills: rank must be a finite number');
+    }
+    const skillDirConfig = config.skillDir ?? join(PACKAGE_DIR, 'skills');
+    if (typeof skillDirConfig !== 'string' || skillDirConfig.trim() === '') {
+        throw new TypeError('unity-skills: skillDir must be a non-empty string');
+    }
+    const exclude = readStringArray(config.exclude, 'exclude');
+    const workspaceSkills = readStringArray(config.workspaceSkills, 'workspaceSkills') ?? DEFAULT_WORKSPACE_SKILLS;
+    return {
+        providerName,
+        rank,
+        source: 'unity',
+        skillDir: resolve(skillDirConfig),
+        exclude: new Set(exclude ?? []),
+        workspaceSkills: new Set(workspaceSkills),
+        gateByProject: readBoolean(config.gateByProject, 'gateByProject', true),
+        enforceRequirements: readBoolean(config.enforceRequirements, 'enforceRequirements', true),
+        injectContext: readBoolean(config.injectContext, 'injectContext', true),
+        watchSkills: readBoolean(config.watchSkills, 'watchSkills', true),
+        respectProjectRoots: readBoolean(config.respectProjectRoots, 'respectProjectRoots', true),
+        parseCache: undefined,
+    };
+}
+/** Read an optional string-array field. */
+function readStringArray(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string' || entry.trim() === '')) {
+        throw new TypeError(`unity-skills: ${field} must be an array of non-empty strings`);
+    }
+    return value;
+}
+/** Read an optional boolean field. */
+function readBoolean(value, field, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== 'boolean')
+        throw new TypeError(`unity-skills: ${field} must be a boolean`);
+    return value;
+}