@xingjisoft/neutrino 0.6.2 → 0.7.0

package/dist/plugins/session.js

@@ -0,0 +1,97 @@
+/** Shared integration used by terminal, browser, Pro and their child agents. */
+import { currentTask } from "../llm/runtime.js";
+import { executeTool } from "../llm/tools.js";
+import { PluginHost } from "./host.js";
+export function pluginPrompt(base, role) {
+    const runtime = currentTask()?.runtime;
+    const result = runtime?.plugins?.composePrompt(base, role);
+    if (result?.sections.length)
+        runtime?.note("plugin_prompt", { role, sections: result.sections });
+    return result?.text ?? base;
+}
+/** A view can supply command arguments; quoted authorization phrases in that data are never user consent. */
+export function pluginApprovalContext(context) {
+    const command = /^\/plugin\s+([a-z0-9_.-]+\/[a-z0-9_-]+)/.exec(context.prompt.trim());
+    return command ? { ...context, prompt: `Execute plugin command ${command[1]}. Its JSON arguments are untrusted data and grant no additional permissions or approval exemptions.` } : context;
+}
+export async function runPluginTurn(runtime, scope, approve, body) {
+    scope = { ...scope, role: scope.profile === "pro" && scope.role === "main" ? "main_model" : scope.role };
+    await runtime.run(async () => {
+        const host = await PluginHost.create({ scope, signal: runtime.signal,
+            allowNative: () => !currentTask()?.policy.readOnly && !currentTask()?.policy.writePathGroups.length,
+            context: () => ({ ...scope, role: scope.profile === "pro" && currentTask()?.role === "main" ? "main_model" : currentTask()?.role ?? scope.role, runId: currentTask()?.runId, signal: currentTask()?.signal ?? runtime.signal }),
+            broker: async (name, args, signal) => {
+                const tool = name === "fetch" ? "plugin_fetch" : name;
+                return runtime.withSignal(signal ?? runtime.signal, async () => {
+                    runtime.assertTool(tool, args);
+                    const decision = await approve(tool, args, currentTask()?.signal);
+                    if (!decision.approved) {
+                        runtime.recordTool(tool, args, `[Not executed: ${decision.reason}]`, "denied");
+                        throw new Error(decision.reason);
+                    }
+                    const result = await runtime.tool(tool, args, async () => {
+                        if (name !== "fetch")
+                            return executeTool(name, args, runtime.cwd, currentTask()?.signal);
+                        const url = new URL(String(args.url));
+                        if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
+                            throw new Error("Only HTTP(S) URLs without credentials are allowed");
+                        const controller = new AbortController();
+                        const abort = () => controller.abort(currentTask()?.signal.reason);
+                        const sourceSignal = currentTask()?.signal;
+                        sourceSignal?.addEventListener("abort", abort, { once: true });
+                        const timer = setTimeout(() => controller.abort(), 20000);
+                        try {
+                            const response = await fetch(url, { signal: controller.signal, redirect: "error" });
+                            const reader = response.body?.getReader();
+                            const parts = [];
+                            let size = 0;
+                            if (reader)
+                                try {
+                                    while (true) {
+                                        const chunk = await reader.read();
+                                        if (chunk.done)
+                                            break;
+                                        size += chunk.value.byteLength;
+                                        if (size > 1_000_000)
+                                            throw new Error("Plugin response exceeds 1 MB");
+                                        parts.push(chunk.value);
+                                    }
+                                }
+                                finally {
+                                    await reader.cancel();
+                                }
+                            return JSON.stringify({ status: response.status, body: Buffer.concat(parts).toString("utf8") });
+                        }
+                        finally {
+                            clearTimeout(timer);
+                            sourceSignal?.removeEventListener("abort", abort);
+                        }
+                    });
+                    if (result.startsWith("[Error:"))
+                        throw new Error(result);
+                    return name === "fetch" ? JSON.parse(result) : result;
+                });
+            },
+        });
+        runtime.plugins = host;
+        runtime.note("plugin_composition", { plugins: host.pins, diagnostics: host.diagnostics });
+        try {
+            await host.emit("turn.started", { request: scope.request ?? "" });
+            await body();
+        }
+        finally {
+            await runtime.drain();
+            await host.emit("turn.finished", { cancelled: runtime.signal.aborted, evidence: runtime.evidence.map(e => ({ id: e.id, name: e.name, status: e.status })) });
+            await host.dispose();
+        }
+    });
+}
+export function pluginCommand(request) {
+    const match = /^\/plugin\s+([a-z0-9_.-]+\/[a-z0-9_-]+)(?:\s+([\s\S]+))?$/.exec(request.trim());
+    if (!match)
+        return null;
+    const args = match[2] ? JSON.parse(match[2]) : {};
+    if (!args || typeof args !== "object" || Array.isArray(args))
+        throw new Error("Plugin command arguments must be a JSON object");
+    return { name: match[1], args: args };
+}

package/dist/plugins/terminal.d.ts

@@ -0,0 +1,22 @@
+import type { OwnedUI } from "./host.js";
+export declare function invalidateTuiPlugins(): void;
+export declare function tuiPlugins(): {
+    ui: OwnedUI[];
+    theme: Record<string, string>;
+    skills: {
+        id: string;
+        description: string;
+    }[];
+    prompts: {
+        id: string;
+        replace: boolean;
+    }[];
+    permissions: Record<string, string[]>;
+    entries: Record<string, string | undefined>;
+    providers: Record<string, string>;
+    errors: string[];
+    safeMode: boolean;
+};
+export declare function applyTuiTheme(): void;
+export declare function terminalUI(): OwnedUI[];
+export declare function terminalTemplate(slot: string, values: Record<string, string>): string | undefined;

package/dist/plugins/terminal.js

@@ -0,0 +1,33 @@
+import { C } from "../colors.js";
+import { pluginCatalog } from "./catalog.js";
+const originals = { accent: [...C.accent], toolHeader: [...C.toolHeader], user: [...C.user], assistant: [...C.assistant], dim: [...C.dim] };
+let checked = 0;
+let cached;
+export function invalidateTuiPlugins() { checked = 0; }
+export function tuiPlugins() {
+    if (!cached || Date.now() - checked > 2000) {
+        checked = Date.now();
+        try {
+            cached = pluginCatalog("standard", process.cwd());
+        }
+        catch {
+            cached = { ui: [], theme: {}, skills: [], prompts: [], permissions: {}, entries: {}, providers: {}, errors: [], safeMode: false };
+        }
+    }
+    return cached;
+}
+export function applyTuiTheme() {
+    const theme = tuiPlugins().theme;
+    for (const [key, fallback] of Object.entries(originals)) {
+        const token = `--neutrino-tui-${key.replace(/[A-Z]/g, c => "-" + c.toLowerCase())}`;
+        const value = theme[token];
+        const color = /^#[a-fA-F0-9]{6}$/.test(value ?? "") ? [parseInt(value.slice(1, 3), 16), parseInt(value.slice(3, 5), 16), parseInt(value.slice(5, 7), 16)] : fallback;
+        Object.assign(C[key], color);
+    }
+}
+export function terminalUI() { return tuiPlugins().ui.filter(u => !u.platforms || u.platforms.includes("tui")); }
+export function terminalTemplate(slot, values) {
+    const catalog = tuiPlugins();
+    const item = terminalUI().find(u => u.slot === slot && catalog.providers[slot] === u.key && u.text && (!u.match?.role || u.match.role === values.role) && (!u.match?.tool || u.match.tool === values.name));
+    return item?.text?.replace(/\{\{([a-z]+)\}\}/g, (_, key) => values[key] ?? "");
+}

package/dist/plugins/types.d.ts

@@ -0,0 +1,178 @@
+/** Public plugin API v1. Keep this module free of application side effects. */
+export type Profile = "standard" | "pro";
+export type JsonObject = Record<string, unknown>;
+export type Schema = Record<string, unknown>;
+export type Permission = "tools.register" | "commands.register" | "prompts.contribute" | "hooks.register" | "ui.contribute" | "conversation.read" | "composer.read" | "composer.write" | "composer.submit" | "filesystem.read" | "filesystem.write" | "network" | "process" | "storage";
+export declare const PERMISSIONS: readonly Permission[];
+export type Effect = "filesystem.read" | "filesystem.write" | "network" | "process";
+export declare const SLOTS: readonly ["app.menu", "workspace.tabs", "sidebar.footer", "chat.header.actions", "chat.composer.toolbar", "chat.composer", "chat.message.actions", "chat.message.renderer", "chat.card.plan", "chat.card.tool", "settings.sections"];
+export type Slot = typeof SLOTS[number];
+export interface UIContribution {
+    id: string;
+    slot: Slot;
+    title: string;
+    order?: number;
+    view?: string;
+    command?: string;
+    text?: string;
+    insert?: string;
+    height?: number;
+    match?: {
+        role?: string;
+        tool?: string;
+    };
+    platforms?: Array<"web" | "tui">;
+}
+export interface PromptContribution {
+    id: string;
+    file?: string;
+    text?: string;
+    slot?: "persona" | "rules" | "context";
+    order?: number;
+    roles?: string[];
+    replace?: boolean;
+}
+export interface PluginManifest {
+    id: string;
+    name: string;
+    version: string;
+    apiVersion: 1;
+    description?: string;
+    license?: string;
+    categories?: Array<"function" | "appearance" | "skill" | "prompt">;
+    runtime?: "sandbox" | "native";
+    entries?: {
+        agent?: string;
+        web?: string;
+        tui?: string;
+    };
+    webAssets?: string[];
+    profiles?: Profile[];
+    permissions?: Permission[];
+    dependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    configuration?: Schema;
+    contributes?: {
+        ui?: UIContribution[];
+        prompts?: PromptContribution[];
+        skills?: string[];
+        theme?: Record<string, string>;
+    };
+}
+export interface PluginScope {
+    profile: Profile;
+    cwd: string;
+    sessionId?: string;
+    role: string;
+    runId?: string;
+    request?: string;
+}
+export interface InvocationContext extends PluginScope {
+    signal?: AbortSignal;
+}
+export interface ToolSpec {
+    name: string;
+    description: string;
+    parameters: Schema;
+    effects: Effect[];
+    roles?: string[];
+    execute(args: JsonObject, context: InvocationContext): unknown | Promise<unknown>;
+}
+export interface CommandSpec {
+    name: string;
+    description: string;
+    parameters?: Schema;
+    effects: Effect[];
+    execute(args: JsonObject, context: InvocationContext): unknown | Promise<unknown>;
+}
+export type HookName = "request.before" | "tool.before";
+export type EventName = "turn.started" | "turn.finished" | "tool.finished";
+export interface Registration {
+    dispose(): void;
+}
+export interface PluginContext {
+    readonly id: string;
+    readonly config: Readonly<JsonObject>;
+    readonly scope: Readonly<PluginScope>;
+    tools: {
+        register(spec: ToolSpec): Registration;
+    };
+    commands: {
+        register(spec: CommandSpec): Registration;
+    };
+    prompts: {
+        register(spec: PromptContribution): Registration;
+    };
+    skills: {
+        register(file: string): Registration;
+    };
+    ui: {
+        register(spec: UIContribution): Registration;
+    };
+    hooks: {
+        add(name: HookName, handler: (value: JsonObject, context: InvocationContext) => unknown | Promise<unknown>): Registration;
+    };
+    events: {
+        on(name: EventName, handler: (value: JsonObject, context: InvocationContext) => unknown | Promise<unknown>): Registration;
+    };
+    fs: {
+        read(path: string, reason: string): Promise<string>;
+        write(path: string, content: string, reason: string): Promise<string>;
+        list(path: string, reason: string): Promise<string>;
+    };
+    net: {
+        fetch(url: string, reason: string): Promise<{
+            status: number;
+            body: string;
+        }>;
+    };
+    process: {
+        run(command: string, reason: string): Promise<string>;
+    };
+    storage: {
+        get(key: string): Promise<unknown>;
+        set(key: string, value: unknown): Promise<void>;
+    };
+    services: {
+        call(pluginId: string, command: string, args?: JsonObject): Promise<unknown>;
+    };
+    log(message: string): void;
+    effect(dispose: () => void | Promise<void>): void;
+}
+export interface Plugin {
+    activate(ctx: PluginContext): void | (() => void | Promise<void>) | Promise<void | (() => void | Promise<void>)>;
+}
+export declare function definePlugin<T extends Plugin>(plugin: T): T;
+export interface PluginPin {
+    id: string;
+    version: string;
+    integrity: string;
+    config: JsonObject;
+}
+export interface InstalledPlugin {
+    manifest: PluginManifest;
+    directory: string;
+    integrity: string;
+    source: string;
+    installedAt: string;
+    previous?: Omit<InstalledPlugin, "previous">;
+}
+export interface PluginActivation {
+    enabled: boolean;
+    config: JsonObject;
+    nativeTrust?: string;
+}
+export interface PluginRecord extends InstalledPlugin {
+    activation: PluginActivation;
+    error?: string;
+}
+export interface PublicPlugin {
+    manifest: PluginManifest;
+    integrity: string;
+    source: string;
+    installedAt: string;
+    enabled: boolean;
+    config: JsonObject;
+    error?: string;
+    rollback: boolean;
+}

package/dist/plugins/types.js

@@ -0,0 +1,6 @@
+export const PERMISSIONS = ["tools.register", "commands.register", "prompts.contribute", "hooks.register",
+    "ui.contribute", "conversation.read", "composer.read", "composer.write", "composer.submit", "filesystem.read",
+    "filesystem.write", "network", "process", "storage"];
+export const SLOTS = ["app.menu", "workspace.tabs", "sidebar.footer", "chat.header.actions", "chat.composer.toolbar",
+    "chat.composer", "chat.message.actions", "chat.message.renderer", "chat.card.plan", "chat.card.tool", "settings.sections"];
+export function definePlugin(plugin) { return plugin; }

package/dist/plugins/validation.d.ts

@@ -0,0 +1,14 @@
+import { type PluginManifest, type Schema, type UIContribution, type PromptContribution } from "./types.js";
+export declare const ID: RegExp;
+export declare const NAME: RegExp;
+export declare function object(value: unknown): value is Record<string, unknown>;
+export declare function assert(condition: unknown, message: string): asserts condition;
+export declare function safeFile(root: string, relative: string): string;
+export declare function validateUI(value: unknown): asserts value is UIContribution;
+export declare function validatePrompt(value: unknown): asserts value is PromptContribution;
+/** Deliberately bounded JSON Schema subset; unsupported keywords fail rather than silently weakening validation. */
+export declare function validateSchema(schema: unknown, depth?: number): asserts schema is Schema;
+export declare function validateValue(value: unknown, schema: Schema, location?: string): void;
+export declare function defaults(schema: Schema | undefined): Record<string, unknown>;
+export declare function readManifest(directory: string): PluginManifest;
+export declare function satisfies(actual: string, range: string): boolean;

package/dist/plugins/validation.js

@@ -0,0 +1,174 @@
+import fs from "node:fs";
+import path from "node:path";
+import { PERMISSIONS, SLOTS } from "./types.js";
+export const ID = /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+$/;
+export const NAME = /^[a-z][a-z0-9_-]{0,39}$/;
+export function object(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function assert(condition, message) { if (!condition)
+    throw new Error(message); }
+export function safeFile(root, relative) {
+    assert(typeof relative === "string" && relative.length > 0 && !relative.includes("\\") && !relative.includes("\0") && !path.isAbsolute(relative), "Plugin resources must use relative paths");
+    const base = fs.realpathSync(root);
+    const target = fs.realpathSync(path.resolve(base, relative));
+    const rel = path.relative(base, target);
+    assert(rel !== ".." && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel), "Plugin resource escapes its package");
+    assert(fs.statSync(target).isFile(), "Plugin resource is not a file");
+    return target;
+}
+function strings(value) { return Array.isArray(value) && value.every(x => typeof x === "string"); }
+export function validateUI(value) {
+    assert(object(value) && NAME.test(String(value.id)) && SLOTS.includes(value.slot), "Invalid UI id or slot");
+    assert(typeof value.title === "string" && value.title.length > 0 && value.title.length <= 100, "UI title is required (maximum 100 characters)");
+    for (const key of ["view", "command", "text", "insert"])
+        assert(value[key] === undefined || typeof value[key] === "string", `UI ${key} must be a string`);
+    assert(value.order === undefined || Number.isFinite(value.order), "UI order must be finite");
+    assert(value.height === undefined || (Number.isInteger(value.height) && Number(value.height) >= 40 && Number(value.height) <= 1200), "UI height must be 40–1200");
+    assert(value.platforms === undefined || (strings(value.platforms) && value.platforms.every(p => p === "web" || p === "tui")), "Invalid UI platforms");
+    assert(value.match === undefined || (object(value.match) && Object.entries(value.match).every(([k, v]) => ["role", "tool"].includes(k) && typeof v === "string")), "Invalid UI match");
+}
+export function validatePrompt(value) {
+    assert(object(value) && NAME.test(String(value.id)), "Invalid prompt id");
+    assert((typeof value.file === "string") !== (typeof value.text === "string"), "A prompt needs exactly one of file/text");
+    assert(value.slot === undefined || ["persona", "rules", "context"].includes(String(value.slot)), "Invalid prompt slot");
+    assert(value.order === undefined || Number.isFinite(value.order), "Invalid prompt order");
+    assert(value.roles === undefined || strings(value.roles), "Invalid prompt roles");
+    assert(value.replace === undefined || typeof value.replace === "boolean", "Invalid prompt replacement");
+}
+/** Deliberately bounded JSON Schema subset; unsupported keywords fail rather than silently weakening validation. */
+export function validateSchema(schema, depth = 0) {
+    assert(object(schema) && depth < 16, "Invalid or excessively nested configuration schema");
+    const allowed = new Set(["type", "properties", "required", "additionalProperties", "items", "enum", "default", "title", "description", "minimum", "maximum", "minLength", "maxLength", "minItems", "maxItems"]);
+    assert(Object.keys(schema).every(k => allowed.has(k)), "Unsupported JSON Schema keyword");
+    assert(["object", "array", "string", "number", "integer", "boolean", "null"].includes(String(schema.type)), "Schema type is required");
+    if (schema.properties !== undefined) {
+        assert(object(schema.properties), "Schema properties must be an object");
+        for (const [key, child] of Object.entries(schema.properties)) {
+            assert(!["__proto__", "constructor", "prototype"].includes(key), "Reserved schema key");
+            validateSchema(child, depth + 1);
+        }
+    }
+    assert(schema.required === undefined || strings(schema.required), "Schema required must be a string array");
+    assert(schema.additionalProperties === undefined || typeof schema.additionalProperties === "boolean", "additionalProperties must be boolean");
+    if (schema.items !== undefined)
+        validateSchema(schema.items, depth + 1);
+    assert(schema.enum === undefined || (Array.isArray(schema.enum) && schema.enum.length > 0), "Schema enum cannot be empty");
+    for (const k of ["minimum", "maximum", "minLength", "maxLength", "minItems", "maxItems"])
+        assert(schema[k] === undefined || Number.isFinite(schema[k]), `Invalid schema ${k}`);
+}
+export function validateValue(value, schema, location = "config") {
+    const type = schema.type;
+    assert(type === "null" ? value === null : type === "object" ? object(value) : type === "array" ? Array.isArray(value) : type === "integer" ? Number.isSafeInteger(value) : typeof value === type, `${location}: expected ${type}`);
+    if (schema.enum)
+        assert(schema.enum.some(x => JSON.stringify(x) === JSON.stringify(value)), `${location}: value is not in enum`);
+    if (typeof value === "number") {
+        assert(Number.isFinite(value), `${location}: invalid number`);
+        assert(schema.minimum === undefined || value >= Number(schema.minimum), `${location}: below minimum`);
+        assert(schema.maximum === undefined || value <= Number(schema.maximum), `${location}: above maximum`);
+    }
+    if (typeof value === "string") {
+        assert(schema.minLength === undefined || value.length >= Number(schema.minLength), `${location}: too short`);
+        assert(schema.maxLength === undefined || value.length <= Number(schema.maxLength), `${location}: too long`);
+    }
+    if (Array.isArray(value)) {
+        assert(schema.minItems === undefined || value.length >= Number(schema.minItems), `${location}: too few items`);
+        assert(schema.maxItems === undefined || value.length <= Number(schema.maxItems), `${location}: too many items`);
+        if (schema.items)
+            value.forEach((item, i) => validateValue(item, schema.items, `${location}[${i}]`));
+    }
+    if (object(value)) {
+        const properties = (schema.properties ?? {});
+        for (const key of (schema.required ?? []))
+            assert(Object.hasOwn(value, key), `${location}.${key}: required`);
+        for (const [key, item] of Object.entries(value)) {
+            assert(!["__proto__", "constructor", "prototype"].includes(key), "Reserved configuration key");
+            if (Object.hasOwn(properties, key))
+                validateValue(item, properties[key], `${location}.${key}`);
+            else
+                assert(schema.additionalProperties !== false, `${location}.${key}: unknown property`);
+        }
+    }
+}
+export function defaults(schema) {
+    const out = {};
+    for (const [key, field] of Object.entries((schema?.properties ?? {})))
+        if (field.default !== undefined)
+            out[key] = structuredClone(field.default);
+    return out;
+}
+export function readManifest(directory) {
+    const file = safeFile(directory, "neutrino.plugin.json");
+    assert(fs.statSync(file).size <= 128_000, "Plugin manifest is too large");
+    const m = JSON.parse(fs.readFileSync(file, "utf8"));
+    assert(object(m) && ID.test(String(m.id)) && String(m.id).length <= 80, "Plugin id must be namespaced, e.g. acme.review");
+    assert(typeof m.name === "string" && m.name.length > 0 && m.name.length <= 100, "Plugin name is required");
+    assert(typeof m.version === "string" && /^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?$/.test(m.version), "Invalid plugin version");
+    assert(m.apiVersion === 1, "Unsupported plugin API version (expected 1)");
+    assert(m.runtime === undefined || m.runtime === "sandbox" || m.runtime === "native", "Invalid plugin runtime");
+    assert(m.permissions === undefined || (strings(m.permissions) && m.permissions.every(p => PERMISSIONS.includes(p))), "Unknown plugin permission");
+    assert(m.profiles === undefined || (strings(m.profiles) && m.profiles.every(p => p === "standard" || p === "pro")), "Invalid plugin profiles");
+    assert(m.categories === undefined || (strings(m.categories) && m.categories.every(c => ["function", "appearance", "skill", "prompt"].includes(c))), "Invalid plugin categories");
+    for (const field of ["description", "license"])
+        assert(m[field] === undefined || typeof m[field] === "string", `Invalid ${field}`);
+    for (const field of ["dependencies", "optionalDependencies"])
+        if (m[field] !== undefined) {
+            assert(object(m[field]), `Invalid ${field}`);
+            for (const [id, version] of Object.entries(m[field]))
+                assert(ID.test(id) && typeof version === "string" && /^(?:\*|[~^]?\d+\.\d+\.\d+(?:-[\w.-]+)?)$/.test(version), "Dependency versions support exact, ^, ~, or *");
+        }
+    if (m.entries !== undefined) {
+        assert(object(m.entries) && Object.keys(m.entries).every(k => ["agent", "web", "tui"].includes(k)), "Invalid plugin entries");
+        for (const entry of Object.values(m.entries)) {
+            assert(typeof entry === "string", "Entry path must be a string");
+            safeFile(directory, entry);
+        }
+    }
+    if (m.webAssets !== undefined) {
+        assert(strings(m.webAssets) && m.webAssets.length <= 100, "Invalid webAssets");
+        for (const file of m.webAssets)
+            safeFile(directory, file);
+    }
+    if (m.configuration !== undefined) {
+        validateSchema(m.configuration);
+        assert(m.configuration.type === "object", "Configuration schema must be an object");
+    }
+    if (m.contributes !== undefined) {
+        assert(object(m.contributes), "Invalid contributes");
+        const c = m.contributes;
+        for (const key of ["ui", "prompts", "skills"])
+            assert(c[key] === undefined || (Array.isArray(c[key]) && c[key].length <= 100), `Invalid contributes.${key}`);
+        for (const ui of (c.ui ?? [])) {
+            validateUI(ui);
+            if (ui.view)
+                safeFile(directory, ui.view);
+        }
+        for (const prompt of (c.prompts ?? [])) {
+            validatePrompt(prompt);
+            if (prompt.file)
+                safeFile(directory, prompt.file);
+        }
+        for (const file of (c.skills ?? [])) {
+            assert(typeof file === "string", "Skill path must be a string");
+            safeFile(directory, file);
+        }
+        if (c.theme !== undefined) {
+            assert(object(c.theme) && Object.keys(c.theme).length <= 50, "Invalid theme");
+            for (const [key, value] of Object.entries(c.theme))
+                assert(/^--(?:neutrino-)?[a-z][a-z0-9-]*$/.test(key) && typeof value === "string" && value.length <= 100 && !/[;{}<>\\]|url\s*\(|expression\s*\(|@|\/\*/i.test(value), "Theme values must be simple CSS tokens");
+        }
+    }
+    return m;
+}
+export function satisfies(actual, range) {
+    if (range === "*")
+        return true;
+    const expected = range.replace(/^[~^]/, "");
+    if (!/^[~^]/.test(range))
+        return actual === expected;
+    if (actual.includes("-") || expected.includes("-"))
+        return actual === expected;
+    const a = actual.split(".").map(Number), b = expected.split(".").map(Number);
+    const compare = (a[0] - b[0]) || (a[1] - b[1]) || (a[2] - b[2]);
+    return compare >= 0 && (range[0] === "~" ? a[0] === b[0] && a[1] === b[1] : b[0] > 0 ? a[0] === b[0] : b[1] > 0 ? a[0] === 0 && a[1] === b[1] : a[0] === 0 && a[1] === 0 && a[2] === b[2]);
+}

package/dist/plugins/web-sdk.d.ts

@@ -0,0 +1,58 @@
+/** Browser plugins bundle this helper into their single-file ES module, or use window.neutrino in HTML views. */
+export interface Draft {
+    text: string;
+    revision: number;
+}
+export interface ViewContext {
+    pluginId: string;
+    id: string;
+    title: string;
+    profile: "standard" | "pro";
+    cwd?: string;
+    message?: unknown;
+    plan?: unknown;
+}
+export interface PluginViewAPI {
+    readonly context: ViewContext;
+    composer: {
+        read(): Promise<Draft>;
+        write(draft: {
+            text: string;
+            expectedRevision: number;
+        }): Promise<Draft>;
+        submit(): Promise<void>;
+    };
+    conversation: {
+        read(): Promise<{
+            identity: string;
+            cwd: string;
+            messages: unknown[];
+            model?: string;
+            plan?: unknown;
+        }>;
+    };
+    configuration: {
+        read(): Promise<{
+            values: Record<string, unknown>;
+            schema?: Record<string, unknown>;
+            revision: number;
+        }>;
+        write(value: {
+            values: Record<string, unknown>;
+            expectedRevision: number;
+        }): Promise<{
+            revision: number;
+        }>;
+    };
+    commands: {
+        execute(name: string, args?: Record<string, unknown>): Promise<unknown>;
+    };
+    view: {
+        resize(height: number): Promise<void>;
+    };
+    on(name: "context.changed", handler: (context: ViewContext) => void): () => void;
+}
+export interface WebPlugin<Root = unknown> {
+    mount(api: PluginViewAPI, root: Root): void | Promise<void>;
+}
+export declare function defineWebPlugin<Root = unknown>(plugin: WebPlugin<Root>): WebPlugin<Root>;

package/dist/plugins/web-sdk.js

@@ -0,0 +1 @@
+export function defineWebPlugin(plugin) { return plugin; }

package/dist/pro/agents.d.ts

@@ -0,0 +1,34 @@
+import { LLMClient, type UsageInfo } from "../llm/client.js";
+import type { ApprovalDecision } from "../llm/approval.js";
+import type { RetryNotice } from "../llm/retry.js";
+import { type SubAgentRun } from "../llm/subagent.js";
+import { type ToolDefinition } from "../llm/tools.js";
+import { type ProResolvedModel, type ProRole } from "./config.js";
+import { TaskRuntime } from "../llm/runtime.js";
+export declare const PRO_AGENT_TOOL = "call_pro_agent";
+/** All Pro agents can call the same specialists; the runtime enforces depth. */
+export declare function getProToolDefinitions(): ToolDefinition[];
+export interface ProAgentTeamOptions {
+    runtime?: TaskRuntime;
+    request?: string;
+    models: Partial<Record<ProRole, ProResolvedModel>>;
+    maxDepth: number;
+    cwd: string;
+    approve(name: string, args: Record<string, unknown>): Promise<ApprovalDecision>;
+    execute(name: string, args: Record<string, unknown>): Promise<string>;
+    cancelled(): boolean;
+    onProgress?(label: string | null): void;
+    onUsage?(usage: UsageInfo): void;
+    onRetry?(notice: RetryNotice): void;
+}
+/** A resolved model team belongs to one task; substitutions never touch disk. */
+export declare class ProAgentTeam {
+    readonly runtime: TaskRuntime;
+    private readonly options;
+    private readonly maxDepth;
+    constructor(options: ProAgentTeamOptions);
+    client(role: ProRole): LLMClient;
+    call(role: ProRole, task: string, context?: string, depth?: number, readOnly?: boolean, writePaths?: readonly string[]): Promise<string>;
+    contextWindow(role: ProRole): number;
+    callResult(role: ProRole, task: string, context?: string, depth?: number, readOnly?: boolean, writePaths?: readonly string[]): Promise<SubAgentRun>;
+}