maka-agent 0.2.0-dev.26.20260909 → 0.2.0-dev.28.20260911

package/node_modules/@maka/runtime/dist/plugin-llm-service.js

@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+import { pluginInvocationSignal } from './plugin-invocation-signal.js';
+import { MakaPluginRuntimeError, pluginIdentity, registerPluginContribution, } from './plugin-runtime.js';
+import { PluginScopeRegistry } from './plugin-scope-registry.js';
+/** Metered Host model calls plus an ordered plugin adapter seam. */
+export class PluginLlmService extends Service {
+    agents;
+    llmRuntime;
+    adapters = new PluginScopeRegistry();
+    constructor(ctx, agents) {
+        super(ctx, 'llm');
+        this.agents = agents;
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error('Only the Host may bind the LLM Runtime');
+        if (this.llmRuntime)
+            throw new Error('Plugin LLM Runtime is already bound');
+        this.llmRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.llmRuntime === runtime)
+                this.llmRuntime = undefined;
+        }, 'llm.bindRuntime()');
+    }
+    register(adapter) {
+        if (!adapter || !/^[A-Za-z][A-Za-z0-9._:-]{0,127}$/u.test(adapter.id)) {
+            throw new TypeError('LLM adapter id is invalid');
+        }
+        if (typeof adapter.supports !== 'function' || typeof adapter.generate !== 'function') {
+            throw new TypeError(`LLM adapter implementation is invalid: ${adapter.id}`);
+        }
+        const identity = pluginIdentity(this.ctx);
+        return registerPluginContribution(this.ctx, `llm.adapter:${adapter.id}`, () => {
+            const rootId = identity.scopeId;
+            const existing = this.adapters.get(rootId, adapter.id);
+            if (existing && existing.entryId !== identity.entryId) {
+                throw new MakaPluginRuntimeError('activation_failed', `LLM adapter is already registered in this scope: ${adapter.id}`);
+            }
+            const entry = {
+                ...identity,
+                adapter,
+                token: Symbol(adapter.id),
+                retired: false,
+            };
+            return this.adapters.publish(rootId, adapter.id, entry);
+        });
+    }
+    generate(input) {
+        const invocation = this.agents.requireInvocation();
+        const effectiveInput = Object.freeze({
+            ...input,
+            signal: pluginInvocationSignal(invocation.abortSignal, input.signal),
+        });
+        const visibleAdapters = this.adapters.visible(invocation.sessionId);
+        const adapter = input.model
+            ? [...visibleAdapters.values()]
+                .map((entry) => entry.adapter)
+                .filter((candidate) => candidate.supports(input.model))
+                .sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0))[0]
+            : undefined;
+        if (adapter)
+            return adapter.generate(effectiveInput, invocation);
+        if (!this.llmRuntime)
+            throw new Error('Plugin LLM Runtime is unavailable');
+        return this.llmRuntime.generate(effectiveInput, invocation);
+    }
+}

package/node_modules/@maka/runtime/dist/plugin-lsp-service.js

@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+import { PluginScopeRegistry } from './plugin-scope-registry.js';
+import { pluginIdentity, registerPluginContribution, MakaPluginRuntimeError, } from './plugin-runtime.js';
+/** High-level LSP router; providers own processes, callers receive no JSON-RPC escape hatch. */
+export class PluginLspService extends Service {
+    routes = new PluginScopeRegistry();
+    constructor(ctx) {
+        super(ctx, 'lsp');
+    }
+    registerProvider(provider) {
+        validateProvider(provider);
+        const identity = pluginIdentity(this.ctx);
+        if (identity.scopeId === 'desktop-ui')
+            throw new MakaPluginRuntimeError('activation_failed', 'desktop-ui plugins cannot register Host LSP providers');
+        return registerPluginContribution(this.ctx, `lsp.registerProvider(${JSON.stringify(provider.id)})`, () => {
+            const rootId = identity.scopeId;
+            const pending = Object.entries(provider.extensionToLanguage).map(([extension, languageId]) => [normalizeExtension(extension), languageId]);
+            for (const [extension] of pending) {
+                const existing = this.routes.get(rootId, extension);
+                if (existing && existing.entryId !== identity.entryId)
+                    throw new MakaPluginRuntimeError('activation_failed', `LSP extension ${JSON.stringify(extension)} is already registered by ${existing.entryId}`);
+            }
+            const disposers = pending.map(([extension, languageId]) => this.routes.publish(rootId, extension, {
+                ...identity,
+                provider,
+                languageId,
+                token: Symbol(`${provider.id}:${extension}`),
+                retired: false,
+            }));
+            return async () => {
+                await Promise.all(disposers.reverse().map((dispose) => dispose()));
+            };
+        });
+    }
+    async query(request, signal) {
+        validateRequest(request);
+        const route = this.routes.visible(request.sessionId).get(finalExtension(request.filePath));
+        if (!route)
+            throw new Error(`No LSP provider handles ${JSON.stringify(request.filePath)}`);
+        if (signal?.aborted)
+            throw signal.reason ?? new Error('LSP query aborted');
+        return await route.provider.query(Object.freeze({ ...request, languageId: route.languageId }), signal);
+    }
+}
+export function finalExtension(filePath) {
+    const base = filePath.slice(Math.max(filePath.lastIndexOf('/'), filePath.lastIndexOf('\\')) + 1);
+    const dot = base.lastIndexOf('.');
+    return dot <= 0 ? '' : base.slice(dot).toLowerCase();
+}
+function normalizeExtension(value) {
+    const extension = value.toLowerCase();
+    const result = extension.startsWith('.') ? extension : `.${extension}`;
+    if (!/^\.[^./\\]+$/u.test(result))
+        throw new TypeError(`Invalid LSP extension: ${value}`);
+    return result;
+}
+function validateProvider(provider) {
+    if (!provider.id.trim() ||
+        typeof provider.query !== 'function' ||
+        Object.keys(provider.extensionToLanguage).length === 0)
+        throw new TypeError('Invalid LSP provider');
+    for (const [extension, language] of Object.entries(provider.extensionToLanguage)) {
+        normalizeExtension(extension);
+        if (!language.trim())
+            throw new TypeError('LSP language id must not be empty');
+    }
+}
+function validateRequest(request) {
+    if (!request.sessionId ||
+        !request.filePath ||
+        !Number.isSafeInteger(request.position.line) ||
+        request.position.line < 0 ||
+        !Number.isSafeInteger(request.position.character) ||
+        request.position.character < 0)
+        throw new TypeError('Invalid LSP query');
+}

package/node_modules/@maka/runtime/dist/plugin-scope-registry.js

@@ -0,0 +1,91 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Shared Profile/Session membership and replacement semantics for typed Plugin
+ * capabilities. Capability services retain validation and value-specific
+ * behavior; this registry only answers which keyed contribution is visible.
+ */
+export class PluginScopeRegistry {
+    #layers = new Map();
+    get(rootId, key) {
+        return this.#layers.get(rootId)?.get(key);
+    }
+    /** Snapshot Profile membership overlaid by an exact Session layer. */
+    visible(sessionId) {
+        if (!sessionId || /[\r\n\0]/u.test(sessionId)) {
+            throw new Error('Invalid Plugin Session scope');
+        }
+        const visible = new Map(this.#layers.get('profile'));
+        for (const [key, entry] of this.#layers.get(`session:${sessionId}`) ?? []) {
+            visible.set(key, entry);
+        }
+        return visible;
+    }
+    entries(rootId) {
+        return Object.freeze(rootId
+            ? [...(this.#layers.get(rootId)?.values() ?? [])]
+            : [...this.#layers.values()].flatMap((layer) => [...layer.values()]));
+    }
+    /**
+     * Atomically publishes one keyed contribution. A same-key predecessor is
+     * restored only when still live, which supports candidate rollback without
+     * resurrecting a successfully retired generation.
+     */
+    publish(rootId, key, entry, hooks = {}) {
+        let layer = this.#layers.get(rootId);
+        if (!layer) {
+            layer = new Map();
+            this.#layers.set(rootId, layer);
+        }
+        const previous = layer.get(key);
+        layer.set(key, entry);
+        try {
+            hooks.onChanged?.(rootId);
+        }
+        catch (error) {
+            if (previous)
+                layer.set(key, previous);
+            else
+                layer.delete(key);
+            this.#prune(rootId);
+            throw error;
+        }
+        let disposed = false;
+        return async () => {
+            if (disposed)
+                return;
+            disposed = true;
+            entry.retired = true;
+            const currentLayer = this.#layers.get(rootId);
+            if (currentLayer?.get(key)?.token === entry.token) {
+                if (previous && !previous.retired)
+                    currentLayer.set(key, previous);
+                else
+                    currentLayer.delete(key);
+                this.#prune(rootId);
+                hooks.onChanged?.(rootId);
+            }
+            await hooks.onRetired?.(entry);
+        };
+    }
+    #prune(rootId) {
+        if (this.#layers.get(rootId)?.size === 0)
+            this.#layers.delete(rootId);
+    }
+}

package/node_modules/@maka/runtime/dist/plugin-session-query-service.js

@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+/** Read-only, paged Session projection. It never exposes the mutable Session Store. */
+export class PluginSessionQueryService extends Service {
+    agents;
+    queryRuntime;
+    constructor(ctx, agents) {
+        super(ctx, 'sessionQuery');
+        this.agents = agents;
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error('Only the Host may bind the Session Query Runtime');
+        if (this.queryRuntime)
+            throw new Error('Plugin Session Query Runtime is already bound');
+        this.queryRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.queryRuntime === runtime)
+                this.queryRuntime = undefined;
+        }, 'sessionQuery.bindRuntime()');
+    }
+    list() {
+        return this.runtime().list(this.caller());
+    }
+    read(sessionId) {
+        return this.runtime().read(assertSessionId(sessionId), this.caller());
+    }
+    search(request) {
+        if (!request.query.trim())
+            throw new TypeError('Session query must not be empty');
+        if (request.limit !== undefined &&
+            (!Number.isSafeInteger(request.limit) || request.limit < 1 || request.limit > 100)) {
+            throw new TypeError('Session query limit must be an integer from 1 to 100');
+        }
+        return this.runtime().search(Object.freeze({ ...request, query: request.query.trim() }), this.caller());
+    }
+    runtime() {
+        if (!this.queryRuntime)
+            throw new Error('Plugin Session Query Runtime is unavailable');
+        return this.queryRuntime;
+    }
+    caller() {
+        const invocation = this.agents.currentInvocation();
+        if (invocation)
+            return Object.freeze({ invocation });
+        const rootId = this.ctx.maka?.rootId;
+        return Object.freeze(rootId?.startsWith('session:') ? { scopeSessionId: rootId.slice('session:'.length) } : {});
+    }
+}
+function assertSessionId(value) {
+    if (!value || /[\0\r\n]/u.test(value))
+        throw new TypeError('Session id is invalid');
+    return value;
+}

package/node_modules/@maka/runtime/dist/plugin-shell-env-service.js

@@ -0,0 +1,87 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+import { PluginScopeRegistry } from './plugin-scope-registry.js';
+import { pluginIdentity, registerPluginContribution, MakaPluginRuntimeError, } from './plugin-runtime.js';
+/** Deterministic, declared environment overlay rebuilt for each Shell execution. */
+export class PluginShellEnvService extends Service {
+    variables = new PluginScopeRegistry();
+    constructor(ctx) {
+        super(ctx, 'shellEnv');
+    }
+    register(contributor) {
+        validateContributor(contributor);
+        const identity = pluginIdentity(this.ctx);
+        if (identity.scopeId === 'desktop-ui')
+            throw new MakaPluginRuntimeError('activation_failed', 'desktop-ui plugins cannot contribute Shell environment');
+        return registerPluginContribution(this.ctx, `shellEnv.register(${JSON.stringify(contributor.name)})`, () => {
+            const rootId = identity.scopeId;
+            const keys = Object.keys(contributor.variables).sort();
+            for (const key of keys) {
+                const existing = this.variables.get(rootId, key);
+                if (existing && existing.entryId !== identity.entryId)
+                    throw new MakaPluginRuntimeError('activation_failed', `Shell environment key ${JSON.stringify(key)} is already registered by ${existing.entryId}`);
+            }
+            const disposers = keys.map((key) => this.variables.publish(rootId, key, {
+                ...identity,
+                contributor,
+                key,
+                token: Symbol(`${contributor.name}:${key}`),
+                retired: false,
+            }));
+            return async () => {
+                await Promise.all(disposers.reverse().map((dispose) => dispose()));
+            };
+        });
+    }
+    async collect(invocation) {
+        const visible = this.variables.visible(invocation.sessionId);
+        const contributors = [
+            ...new Set([...visible.values()].map(({ contributor }) => contributor)),
+        ].sort((a, b) => a.name.localeCompare(b.name));
+        const output = Object.create(null);
+        for (const contributor of contributors) {
+            const resolved = await contributor.resolve(invocation);
+            for (const [key, value] of Object.entries(resolved)) {
+                if (!Object.hasOwn(contributor.variables, key))
+                    throw new Error(`Shell environment contributor ${JSON.stringify(contributor.name)} returned undeclared key ${JSON.stringify(key)}`);
+                if (value !== undefined && typeof value !== 'string')
+                    throw new TypeError(`Shell environment value ${JSON.stringify(key)} must be a string`);
+                if (value !== undefined)
+                    output[key] = value;
+            }
+        }
+        return Object.freeze(Object.fromEntries(Object.entries(output).sort(([left], [right]) => left.localeCompare(right))));
+    }
+}
+function validateContributor(value) {
+    if (!/^[a-z][a-z0-9-]*$/u.test(value.name) || typeof value.resolve !== 'function')
+        throw new TypeError('Invalid Shell environment contributor');
+    const keys = Object.keys(value.variables);
+    if (keys.length === 0)
+        throw new TypeError('Shell environment contributor must declare at least one variable');
+    for (const key of keys) {
+        if (!/^MAKA_PLUGIN_[A-Z][A-Z0-9_]*$/u.test(key))
+            throw new TypeError(`Plugin Shell environment key is outside the MAKA_PLUGIN_* namespace: ${key}`);
+        if (!value.variables[key].description.trim())
+            throw new TypeError(`Plugin Shell environment key must have a description: ${key}`);
+        if (/^(?:PATH|HOME|SHELL|NODE_OPTIONS|LD_|DYLD_)/u.test(key.slice('MAKA_PLUGIN_'.length)))
+            throw new TypeError(`Plugin Shell environment key is reserved: ${key}`);
+    }
+}

package/node_modules/@maka/runtime/dist/plugin-shell-service.js

@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+/** Streaming, cancellable foreground/background/PTY shell surface. */
+export class PluginShellService extends Service {
+    agents;
+    shellEnv;
+    shellRuntime;
+    constructor(ctx, agents, shellEnv) {
+        super(ctx, 'shell');
+        this.agents = agents;
+        this.shellEnv = shellEnv;
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error('Only the Host may bind the Shell Runtime');
+        if (this.shellRuntime)
+            throw new Error('Plugin Shell Runtime is already bound');
+        this.shellRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.shellRuntime === runtime)
+                this.shellRuntime = undefined;
+        }, 'shell.bindRuntime()');
+    }
+    async run(options) {
+        if (options.environment !== undefined)
+            throw new TypeError('Shell environment is Host-managed');
+        const invocation = this.agents.requireInvocation();
+        const environment = await this.shellEnv?.collect(invocation);
+        return this.runtime().run(environment && Object.keys(environment).length > 0 ? { ...options, environment } : options, invocation);
+    }
+    read(ref) {
+        const invocation = this.agents.requireInvocation();
+        const read = this.runtime().read;
+        if (!read)
+            throw new Error('Shell resource reads are unavailable');
+        return read(ref, invocation);
+    }
+    write(ref, input) {
+        const invocation = this.agents.requireInvocation();
+        const write = this.runtime().write;
+        if (!write)
+            throw new Error('Shell PTY input is unavailable');
+        return write(ref, input, invocation);
+    }
+    stop(ref) {
+        const invocation = this.agents.requireInvocation();
+        const stop = this.runtime().stop;
+        if (!stop)
+            throw new Error('Shell process cancellation is unavailable');
+        return stop(ref, invocation);
+    }
+    runtime() {
+        if (!this.shellRuntime)
+            throw new Error('Plugin Shell Runtime is unavailable');
+        return this.shellRuntime;
+    }
+}

package/node_modules/@maka/runtime/dist/plugin-skill-service.js

@@ -0,0 +1,93 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+import { PluginScopeRegistry } from './plugin-scope-registry.js';
+import { pluginIdentity, registerPluginContribution, MakaPluginRuntimeError, } from './plugin-runtime.js';
+/** Profile/Session-scoped Skill contributions owned by the registering Fiber. */
+export class PluginSkillService extends Service {
+    registry = new PluginScopeRegistry();
+    revision = 0;
+    constructor(ctx) {
+        super(ctx, 'skills');
+    }
+    register(definition) {
+        validateSkill(definition);
+        const identity = pluginIdentity(this.ctx);
+        if (identity.scopeId === 'desktop-ui')
+            throw new MakaPluginRuntimeError('activation_failed', 'desktop-ui plugins cannot register Host skills');
+        return registerPluginContribution(this.ctx, `skills.register(${JSON.stringify(definition.name)})`, () => {
+            const rootId = identity.scopeId;
+            const existing = this.registry.get(rootId, definition.name);
+            if (existing && existing.entryId !== identity.entryId)
+                throw new MakaPluginRuntimeError('activation_failed', `Plugin Skill ${JSON.stringify(definition.name)} is already registered by ${existing.entryId}`);
+            const dispose = this.registry.publish(rootId, definition.name, {
+                ...identity,
+                definition: freezeSkill(definition),
+                token: Symbol(definition.name),
+                retired: false,
+            });
+            this.revision += 1;
+            return async () => {
+                await dispose();
+                this.revision += 1;
+            };
+        });
+    }
+    resolve(sessionId) {
+        return Object.freeze([...this.registry.visible(assertScope(sessionId)).values()]
+            .sort(compareIdentity)
+            .map(({ definition }) => definition));
+    }
+    get(sessionId, name) {
+        return this.registry.visible(assertScope(sessionId)).get(name)?.definition;
+    }
+    snapshot(sessionId) {
+        return Object.freeze({ revision: this.revision, skills: this.resolve(sessionId) });
+    }
+    inspect(rootId) {
+        return Object.freeze([...this.registry.entries(rootId)]
+            .sort(compareIdentity)
+            .map(({ definition, ...identity }) => Object.freeze({ ...identity, name: definition.name })));
+    }
+}
+function validateSkill(value) {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(value.name))
+        throw new TypeError('Plugin Skill name must be lower-kebab-case');
+    if (!value.description.trim() || !value.instructions.trim())
+        throw new TypeError('Plugin Skill description and instructions are required');
+    if (value.instructions.length > 256 * 1024)
+        throw new TypeError('Plugin Skill instructions exceed 256 KiB');
+}
+function freezeSkill(value) {
+    return Object.freeze({
+        ...value,
+        description: value.description.trim(),
+        instructions: value.instructions,
+        declaredTools: Object.freeze([...(value.declaredTools ?? [])]),
+        requiredTools: Object.freeze([...(value.requiredTools ?? [])]),
+    });
+}
+function assertScope(value) {
+    if (!value || /[\0\r\n]/u.test(value))
+        throw new TypeError('Session id is invalid');
+    return value;
+}
+function compareIdentity(left, right) {
+    return left.entryId.localeCompare(right.entryId) || left.generation - right.generation;
+}