mu-harness 0.16.3

package/esm/harness/npm/src/deps/jsr.io/@std/yaml/1.1.0/stringify.js

@@ -0,0 +1,33 @@
+// Ported from js-yaml v3.13.1:
+// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da
+// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { DumperState } from "./_dumper_state.js";
+import { SCHEMA_MAP } from "./_schema.js";
+/**
+ * Converts a JavaScript object or value to a YAML document string.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringify } from "@std/yaml/stringify";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const data = { id: 1, name: "Alice" };
+ * const yaml = stringify(data);
+ *
+ * assertEquals(yaml, "id: 1\nname: Alice\n");
+ * ```
+ *
+ * @throws {TypeError} If `data` contains invalid types.
+ * @param data The data to serialize.
+ * @param options The options for serialization.
+ * @returns A YAML string.
+ */
+export function stringify(data, options = {}) {
+    const state = new DumperState({
+        ...options,
+        schema: SCHEMA_MAP.get(options.schema),
+    });
+    return state.stringify(data);
+}

package/esm/harness/npm/src/harness/create.d.ts

@@ -0,0 +1,2 @@
+import type { Harness, HarnessOptions } from './types.js';
+export declare const createHarness: (options: HarnessOptions) => Promise<Harness>;

package/esm/harness/npm/src/harness/create.js

@@ -0,0 +1,139 @@
+import { join } from 'node:path';
+import process from 'node:process';
+import { createAgentRegistry, loadAgents } from '../agents/index.js';
+import { createAgentsCommand, createCommandRegistry, createHelpCommand, createSessionsCommand, createSkillsCommand, } from '../commands/index.js';
+import { createHarnessConfig } from '../config/index.js';
+import { mergeHooks } from '../hooks/index.js';
+import { allowList } from '../permissions/index.js';
+import { createPluginStore } from '../plugin/index.js';
+import { createScheduler, createScheduleTaskTool, createTasksCommand, createTaskStore } from '../scheduler/index.js';
+import { createAgentSession, createSessionCatalog, createSessionManager, createSessionStore, persistTo, runTitler, } from '../session/index.js';
+import { createRunSkillTool, createSkillRegistry, createSkillTool, createSkillWriterTool, loadSkills, runSkill, } from '../skills/index.js';
+import { createSubAgentRegistry, createSubAgentTool, runSubAgent } from '../subAgents/index.js';
+import { createModelRegistry } from './models.js';
+const TITLE_AGENT = {
+    name: 'title',
+    description: 'Generates a concise session title from the first user message.',
+    prompt: 'Generate a concise title (3 to 6 words) for the conversation based on the user message. Reply with ONLY the title — no quotes, no trailing punctuation, no explanation.',
+    tools: [],
+};
+export const createHarness = async (options) => {
+    const { hostName, xdg, providers, model, agents: hostAgents = [], skills: hostSkills = [], title, titleModel, scheduler: enableScheduler = false, ...sessionDefaults } = options;
+    const cwd = options.cwd ?? process.cwd();
+    const config = createHarnessConfig({ hostName, xdg });
+    const models = createModelRegistry({ providers, default: model });
+    const plugins = createPluginStore({ dir: join(config.configDir, 'plugins') });
+    const newId = () => crypto.randomUUID();
+    const pluginAgents = (sessionDefaults.plugins ?? []).flatMap((plugin) => plugin.agents ?? []);
+    const diskAgents = await loadAgents(join(config.configDir, 'agents'));
+    const agents = createAgentRegistry([...hostAgents, ...pluginAgents, ...diskAgents]);
+    const skillsDir = join(config.configDir, 'skills');
+    const cwdSkillsDir = join(cwd, 'skills');
+    const pluginSkills = (sessionDefaults.plugins ?? []).flatMap((plugin) => plugin.skills ?? []);
+    const cwdSkills = await loadSkills(cwdSkillsDir);
+    const diskSkills = await loadSkills(skillsDir);
+    const skills = createSkillRegistry([...hostSkills, ...pluginSkills, ...cwdSkills, ...diskSkills]);
+    const skillTools = [
+        createSkillTool(skills),
+        createSkillWriterTool({ dirs: { local: cwdSkillsDir, config: skillsDir }, registry: skills }),
+    ];
+    const tasks = enableScheduler ? createTaskStore({ dir: join(config.configDir, 'tasks') }) : undefined;
+    let schedulerTools = [];
+    const runs = createSubAgentRegistry();
+    const store = createSessionStore({ dir: join(config.dataDir, 'sessions') });
+    const sessionTools = (extra = []) => [...(sessionDefaults.tools ?? []), ...extra, ...skillTools, ...schedulerTools];
+    const persona = (agent, opts) => createAgentSession({
+        tools: opts.tools,
+        plugins: sessionDefaults.plugins,
+        system: agent.prompt,
+        hooks: opts.hooks ?? allowList(agent.tools),
+        ...models.resolve(opts.model ?? agent.model),
+        id: newId(),
+    });
+    const spawn = (agent) => persistTo(store, persona(agent, {
+        tools: sessionTools(),
+        hooks: mergeHooks([sessionDefaults.hooks, allowList(agent.tools)]),
+    }));
+    const scheduler = enableScheduler && tasks
+        ? createScheduler({
+            store: tasks,
+            run: async (task) => {
+                try {
+                    if (!task.agent)
+                        throw new Error('scheduled task is missing an agent');
+                    const output = await runSkill({ skills, agents, spawn, runs, parentId: task.id }, {
+                        skill: task.skill,
+                        task: task.prompt,
+                        agent: task.agent,
+                    });
+                    return { ok: true, output };
+                }
+                catch (error) {
+                    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+                }
+            },
+        })
+        : undefined;
+    if (tasks && scheduler) {
+        schedulerTools = [
+            createRunSkillTool({ skills, agents, spawn, runs }),
+            createScheduleTaskTool({ store: tasks, skills, onChange: () => scheduler.reload() }),
+        ];
+    }
+    const titleSpawn = (agent) => persona(agent, { model: titleModel });
+    const catalog = createSessionCatalog({ file: join(config.dataDir, 'sessions.db') });
+    runs.subscribe((run) => catalog.record(run.runId, { cwd, parentId: run.parentId }));
+    const sessions = createSessionManager({
+        store,
+        catalog,
+        newId,
+        cwd,
+        title: title === false ? undefined : ({ id, text }) => {
+            void runTitler({
+                id,
+                text,
+                setTitle: (sid, value) => catalog.setTitle(sid, value),
+                generate: (input) => runSubAgent(TITLE_AGENT, input, { spawn: titleSpawn }).then((result) => result.text),
+            });
+        },
+        revive: ({ id, model: ref, messages }) => createAgentSession({
+            ...sessionDefaults,
+            tools: sessionTools([createSubAgentTool({ registry: agents, spawn, runs, parentId: id })]),
+            ...models.resolve(ref),
+            id,
+            messages,
+        }),
+    });
+    const commands = createCommandRegistry([
+        createAgentsCommand(agents),
+        createSkillsCommand(skills),
+        createSessionsCommand(sessions),
+        ...(tasks ? [createTasksCommand(tasks)] : []),
+    ]);
+    commands.register(createHelpCommand(() => commands.list()));
+    if (scheduler)
+        await scheduler.start();
+    return {
+        config,
+        models,
+        plugins,
+        sessions,
+        agents,
+        skills,
+        subAgents: runs,
+        dispatchSubAgent: async (agent, task, parentId) => {
+            const def = agents.get(agent);
+            if (!def)
+                throw new Error(`unknown sub-agent "${agent}"`);
+            return await runSubAgent(def, task, { spawn, runs, parentId });
+        },
+        scheduler,
+        tasks,
+        commands,
+        cwd,
+        close: () => {
+            scheduler?.stop();
+            catalog.close();
+        },
+    };
+};

package/esm/harness/npm/src/harness/index.d.ts

@@ -0,0 +1,3 @@
+export type { Harness, HarnessOptions } from './types.js';
+export { createHarness } from './create.js';
+export { createModelRegistry, type ModelRegistry, type ModelRegistryOptions, type ResolvedModel } from './models.js';

package/esm/harness/npm/src/harness/index.js

@@ -0,0 +1,2 @@
+export { createHarness } from './create.js';
+export { createModelRegistry } from './models.js';

package/esm/harness/npm/src/harness/models.d.ts

@@ -0,0 +1,16 @@
+import type { Provider } from 'mu-core';
+export interface ModelRegistryOptions {
+    providers: Record<string, Provider>;
+    default: string;
+}
+export interface ResolvedModel {
+    provider: Provider;
+    model: string;
+}
+export interface ModelRegistry {
+    readonly selected: string;
+    readonly providers: string[];
+    select(ref: string): void;
+    resolve(ref?: string): ResolvedModel;
+}
+export declare const createModelRegistry: (options: ModelRegistryOptions) => ModelRegistry;

package/esm/harness/npm/src/harness/models.js

@@ -0,0 +1,30 @@
+export const createModelRegistry = (options) => {
+    const { providers } = options;
+    let selected = options.default;
+    const resolve = (ref) => {
+        const value = ref ?? selected;
+        const slash = value.indexOf('/');
+        if (slash <= 0 || slash === value.length - 1) {
+            throw new Error(`ModelRegistry: model must be "provider/model", got "${value}"`);
+        }
+        const name = value.slice(0, slash);
+        const provider = providers[name];
+        if (!provider)
+            throw new Error(`ModelRegistry: unknown provider "${name}"`);
+        return { provider, model: value.slice(slash + 1) };
+    };
+    resolve(selected);
+    return {
+        get selected() {
+            return selected;
+        },
+        get providers() {
+            return Object.keys(providers);
+        },
+        select: (ref) => {
+            resolve(ref);
+            selected = ref;
+        },
+        resolve,
+    };
+};

package/esm/harness/npm/src/harness/types.d.ts

@@ -0,0 +1,35 @@
+import type { Provider } from 'mu-core';
+import type { Agent, AgentRegistry } from '../agents/index.js';
+import type { CommandRegistry } from '../commands/index.js';
+import type { HarnessConfig, HarnessConfigOptions } from '../config/index.js';
+import type { PluginStore } from '../plugin/index.js';
+import type { Scheduler, TaskStore } from '../scheduler/index.js';
+import type { AgentSessionConfig, SessionManager } from '../session/index.js';
+import type { Skill, SkillRegistry } from '../skills/index.js';
+import type { SubAgentRegistry, SubAgentResult } from '../subAgents/index.js';
+import type { ModelRegistry } from './models.js';
+export type HarnessOptions = HarnessConfigOptions & Omit<AgentSessionConfig, 'provider' | 'model' | 'id' | 'messages'> & {
+    providers: Record<string, Provider>;
+    model: string;
+    agents?: Agent[];
+    skills?: Skill[];
+    title?: boolean;
+    titleModel?: string;
+    cwd?: string;
+    scheduler?: boolean;
+};
+export interface Harness {
+    readonly config: HarnessConfig;
+    readonly models: ModelRegistry;
+    readonly plugins: PluginStore;
+    readonly sessions: SessionManager;
+    readonly agents: AgentRegistry;
+    readonly skills: SkillRegistry;
+    readonly subAgents: SubAgentRegistry;
+    dispatchSubAgent(agent: string, task: string, parentId: string): Promise<SubAgentResult>;
+    readonly commands: CommandRegistry;
+    readonly scheduler?: Scheduler;
+    readonly tasks?: TaskStore;
+    readonly cwd: string;
+    close(): void;
+}

package/esm/harness/npm/src/harness/types.js

@@ -0,0 +1 @@
+export {};

package/esm/harness/npm/src/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export type { AgentSessionHooks, PreparedRequest } from './types.js';
+export { withHooks } from './with-hooks.js';
+export { mergeHooks } from './merge-hooks.js';

package/esm/harness/npm/src/hooks/index.js

@@ -0,0 +1,2 @@
+export { withHooks } from './with-hooks.js';
+export { mergeHooks } from './merge-hooks.js';

package/esm/harness/npm/src/hooks/merge-hooks.d.ts

@@ -0,0 +1,2 @@
+import type { AgentSessionHooks } from './types.js';
+export declare const mergeHooks: (list: (AgentSessionHooks | undefined)[]) => AgentSessionHooks;

package/esm/harness/npm/src/hooks/merge-hooks.js

@@ -0,0 +1,42 @@
+export const mergeHooks = (list) => {
+    const hooks = list.filter((h) => h !== undefined);
+    const merged = {};
+    if (hooks.some((h) => h.sessionStart)) {
+        merged.sessionStart = async () => {
+            for (const h of hooks)
+                await h.sessionStart?.();
+        };
+    }
+    if (hooks.some((h) => h.prepareRequest)) {
+        merged.prepareRequest = async (req) => {
+            let current = req;
+            for (const h of hooks) {
+                const next = await h.prepareRequest?.(current);
+                if (next)
+                    current = { system: next.system ?? current.system, tools: next.tools ?? current.tools };
+            }
+            return current;
+        };
+    }
+    if (hooks.some((h) => h.beforeToolCall)) {
+        merged.beforeToolCall = async (call) => {
+            for (const h of hooks) {
+                const blocked = await h.beforeToolCall?.(call);
+                if (blocked)
+                    return blocked;
+            }
+        };
+    }
+    if (hooks.some((h) => h.afterToolCall)) {
+        merged.afterToolCall = async (call) => {
+            let result = call.result;
+            for (const h of hooks) {
+                const next = await h.afterToolCall?.({ name: call.name, result });
+                if (next)
+                    result = next;
+            }
+            return result;
+        };
+    }
+    return merged;
+};

package/esm/harness/npm/src/hooks/types.d.ts

@@ -0,0 +1,20 @@
+import type { ContentPart, Tool } from 'mu-core';
+export interface PreparedRequest {
+    system?: string;
+    tools?: Tool[];
+}
+export interface AgentSessionHooks {
+    sessionStart?(): void | Promise<void>;
+    prepareRequest?(req: {
+        system: string;
+        tools: Tool[];
+    }): PreparedRequest | void | Promise<PreparedRequest | void>;
+    beforeToolCall?(call: {
+        name: string;
+        input: unknown;
+    }): void | ContentPart[] | Promise<void | ContentPart[]>;
+    afterToolCall?(call: {
+        name: string;
+        result: ContentPart[];
+    }): void | ContentPart[] | Promise<void | ContentPart[]>;
+}

package/esm/harness/npm/src/hooks/types.js

@@ -0,0 +1 @@
+export {};

package/esm/harness/npm/src/hooks/with-hooks.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from 'mu-core';
+import type { AgentSessionHooks } from './types.js';
+export declare const withHooks: (tool: Tool, hooks: AgentSessionHooks) => Tool;

package/esm/harness/npm/src/hooks/with-hooks.js

@@ -0,0 +1,12 @@
+export const withHooks = (tool, hooks) => {
+    if (!hooks.beforeToolCall && !hooks.afterToolCall)
+        return tool;
+    const run = async (input, ctx) => {
+        const blocked = await hooks.beforeToolCall?.({ name: tool.name, input });
+        if (blocked)
+            return blocked;
+        const result = await tool.run(input, ctx);
+        return (await hooks.afterToolCall?.({ name: tool.name, result })) ?? result;
+    };
+    return Object.assign(Object.create(tool), { run });
+};

package/esm/harness/npm/src/index.d.ts

@@ -0,0 +1,15 @@
+import "./_dnt.polyfills.js";
+export * from './agents/index.js';
+export * from './channels/index.js';
+export * from './commands/index.js';
+export * from './common/index.js';
+export * from './config/index.js';
+export * from './harness/index.js';
+export * from './hooks/index.js';
+export * from './permissions/index.js';
+export * from './plugin/index.js';
+export * from './scheduler/index.js';
+export * from './session/index.js';
+export * from './skills/index.js';
+export * from './subAgents/index.js';
+export * from './tui/index.js';

package/esm/harness/npm/src/index.js

@@ -0,0 +1,15 @@
+import "./_dnt.polyfills.js";
+export * from './agents/index.js';
+export * from './channels/index.js';
+export * from './commands/index.js';
+export * from './common/index.js';
+export * from './config/index.js';
+export * from './harness/index.js';
+export * from './hooks/index.js';
+export * from './permissions/index.js';
+export * from './plugin/index.js';
+export * from './scheduler/index.js';
+export * from './session/index.js';
+export * from './skills/index.js';
+export * from './subAgents/index.js';
+export * from './tui/index.js';

package/esm/harness/npm/src/permissions/allow-list.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from 'mu-core';
+import type { AgentSessionHooks } from '../hooks/index.js';
+export declare const filterTools: (pool: Tool[], allow: string[] | undefined) => Tool[];
+export declare const allowList: (names: string[] | undefined) => AgentSessionHooks;

package/esm/harness/npm/src/permissions/allow-list.js

@@ -0,0 +1,8 @@
+import { matchesAnyGlob } from './glob.js';
+export const filterTools = (pool, allow) => {
+    const patterns = allow ?? [];
+    return pool.filter((tool) => matchesAnyGlob(tool.name, patterns));
+};
+export const allowList = (names) => ({
+    prepareRequest: ({ tools }) => ({ tools: filterTools(tools, names) }),
+});

package/esm/harness/npm/src/permissions/approval.d.ts

@@ -0,0 +1,17 @@
+import type { ContentPart } from 'mu-core';
+import type { AgentSessionHooks } from '../hooks/index.js';
+export interface ApprovalCall {
+    id: string;
+    name: string;
+    input: unknown;
+}
+export interface RequireApprovalOptions {
+    needsApproval(call: {
+        name: string;
+        input: unknown;
+    }): boolean;
+    prompt(call: ApprovalCall): boolean | Promise<boolean>;
+    onDeny?(call: ApprovalCall): ContentPart[];
+    newId?(): string;
+}
+export declare const requireApproval: (options: RequireApprovalOptions) => AgentSessionHooks;

package/esm/harness/npm/src/permissions/approval.js

@@ -0,0 +1,13 @@
+export const requireApproval = (options) => {
+    const newId = options.newId ?? (() => crypto.randomUUID());
+    return {
+        beforeToolCall: async ({ name, input }) => {
+            if (!options.needsApproval({ name, input }))
+                return;
+            const call = { id: newId(), name, input };
+            if (await options.prompt(call))
+                return;
+            return options.onDeny?.(call) ?? [{ type: 'text', text: `Denied: ${call.name}` }];
+        },
+    };
+};

package/esm/harness/npm/src/permissions/glob.d.ts

@@ -0,0 +1 @@
+export declare const matchesAnyGlob: (value: string, patterns: string[]) => boolean;

package/esm/harness/npm/src/permissions/glob.js

@@ -0,0 +1,2 @@
+import { matchesGlob } from 'node:path';
+export const matchesAnyGlob = (value, patterns) => patterns.some((pattern) => matchesGlob(value, pattern));

package/esm/harness/npm/src/permissions/index.d.ts

@@ -0,0 +1,3 @@
+export { allowList, filterTools } from './allow-list.js';
+export { type ApprovalCall, requireApproval, type RequireApprovalOptions } from './approval.js';
+export { matchesAnyGlob } from './glob.js';

package/esm/harness/npm/src/permissions/index.js

@@ -0,0 +1,3 @@
+export { allowList, filterTools } from './allow-list.js';
+export { requireApproval } from './approval.js';
+export { matchesAnyGlob } from './glob.js';

package/esm/harness/npm/src/plugin/define.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from './types.js';
+export declare const definePlugin: (plugin: Plugin) => Plugin;

package/esm/harness/npm/src/plugin/define.js

@@ -0,0 +1 @@
+export const definePlugin = (plugin) => plugin;

package/esm/harness/npm/src/plugin/import-ts.d.ts

@@ -0,0 +1 @@
+export declare const importModule: (spec: string) => Promise<Record<string, unknown>>;

package/esm/harness/npm/src/plugin/import-ts.js

@@ -0,0 +1,85 @@
+import { transformSync } from '@swc/wasm-typescript';
+import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const TS_EXT = /\.(?:[cm]?ts|tsx)$/;
+const REMOTE = /^(?:npm|jsr|node|bun|http|https|data|file):/;
+const SPECIFIER = /(?:\bfrom|\bimport|\bexport\s*\*\s*from|\bimport)\s*\(?\s*(['"])(\.{1,2}\/[^'"]+)\1/g;
+const isLocalTs = (spec) => TS_EXT.test(spec) && !REMOTE.test(spec);
+const toAbs = (spec) => {
+    if (spec.startsWith('file://'))
+        return resolve(decodeURIComponent(new URL(spec).pathname));
+    return isAbsolute(spec) ? spec : resolve(spec);
+};
+const resolveRelative = async (from, spec) => {
+    const base = resolve(dirname(from), spec);
+    const candidates = TS_EXT.test(base) ? [base] : [
+        base,
+        `${base}.ts`,
+        `${base}.tsx`,
+        `${base}.mts`,
+        `${base}.cts`,
+        join(base, 'index.ts'),
+        join(base, 'index.tsx'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            await readFile(candidate);
+            return candidate;
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error(`cannot resolve "${spec}" from ${from}`);
+};
+const collect = async (entry) => {
+    const sources = new Map();
+    const pending = [entry];
+    while (pending.length > 0) {
+        const file = pending.pop();
+        if (sources.has(file))
+            continue;
+        const source = await readFile(file, 'utf-8');
+        sources.set(file, source);
+        for (const match of source.matchAll(SPECIFIER)) {
+            pending.push(await resolveRelative(file, match[2]));
+        }
+    }
+    return sources;
+};
+const commonBase = (files) => {
+    if (files.length === 1)
+        return dirname(files[0]);
+    const split = files.map((f) => dirname(f).split(sep));
+    const first = split[0];
+    let i = 0;
+    while (i < first.length && split.every((parts) => parts[i] === first[i]))
+        i++;
+    return first.slice(0, i).join(sep) || sep;
+};
+const outName = (path) => path.replace(TS_EXT, '.mjs');
+const rewriteSpecifiers = (code) => code.replace(SPECIFIER, (whole, quote, spec) => whole.replace(`${quote}${spec}${quote}`, `${quote}${outName(spec)}${quote}`));
+const transpileTree = async (entry) => {
+    const sources = await collect(entry);
+    if (sources.size === 1) {
+        const { code } = transformSync(sources.get(entry), { mode: 'transform', module: true });
+        return `data:text/javascript;base64,${btoa(unescape(encodeURIComponent(code)))}`;
+    }
+    const base = commonBase([...sources.keys()]);
+    const outDir = await mkdtemp(join(tmpdir(), 'mu-plugin-'));
+    for (const [file, source] of sources) {
+        const { code } = transformSync(source, { mode: 'transform', module: true });
+        const out = join(outDir, outName(relative(base, file)));
+        await mkdir(dirname(out), { recursive: true });
+        await writeFile(out, rewriteSpecifiers(code), 'utf-8');
+    }
+    return pathToFileURL(join(outDir, outName(relative(base, entry)))).href;
+};
+export const importModule = async (spec) => {
+    if (!isLocalTs(spec))
+        return (await import(spec));
+    const url = await transpileTree(toAbs(spec));
+    return (await import(url));
+};

package/esm/harness/npm/src/plugin/index.d.ts

@@ -0,0 +1,5 @@
+export type { Plugin } from './types.js';
+export { definePlugin } from './define.js';
+export { resolve, type Resolved, type ResolveInput } from './resolve.js';
+export { createPluginStore, type PluginStore } from './store.js';
+export { importModule } from './import-ts.js';

package/esm/harness/npm/src/plugin/index.js

@@ -0,0 +1,4 @@
+export { definePlugin } from './define.js';
+export { resolve } from './resolve.js';
+export { createPluginStore } from './store.js';
+export { importModule } from './import-ts.js';

package/esm/harness/npm/src/plugin/resolve.d.ts

@@ -0,0 +1,13 @@
+import type { Tool } from 'mu-core';
+import { type AgentSessionHooks } from '../hooks/index.js';
+import type { Plugin } from './types.js';
+export interface Resolved {
+    tools: Tool[];
+    hooks: AgentSessionHooks;
+}
+export interface ResolveInput {
+    tools?: Tool[];
+    hooks?: AgentSessionHooks;
+    plugins?: Plugin[];
+}
+export declare const resolve: (config: ResolveInput) => Resolved;

package/esm/harness/npm/src/plugin/resolve.js

@@ -0,0 +1,17 @@
+import { mergeHooks } from '../hooks/index.js';
+export const resolve = (config) => {
+    const plugins = config.plugins ?? [];
+    return {
+        tools: dedupeTools([...plugins.flatMap((p) => p.tools ?? []), ...(config.tools ?? [])]),
+        hooks: mergeHooks([...plugins.map((p) => p.hooks), config.hooks]),
+    };
+};
+const dedupeTools = (tools) => {
+    const seen = new Set();
+    for (const tool of tools) {
+        if (seen.has(tool.name))
+            throw new Error(`AgentSession: duplicate tool name "${tool.name}"`);
+        seen.add(tool.name);
+    }
+    return tools;
+};

package/esm/harness/npm/src/plugin/store.d.ts

@@ -0,0 +1,8 @@
+export interface PluginStore {
+    write(name: string, content: string): Promise<string>;
+    list(): Promise<string[]>;
+    remove(name: string): Promise<void>;
+}
+export declare const createPluginStore: ({ dir }: {
+    dir: string;
+}) => PluginStore;

package/esm/harness/npm/src/plugin/store.js

@@ -0,0 +1,26 @@
+import { mkdir, readdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const fileFor = (dir, name) => {
+    if (name.includes('/') || name.includes('..') || name === '')
+        throw new Error(`PluginStore: invalid name "${name}"`);
+    return join(dir, name);
+};
+export const createPluginStore = ({ dir }) => ({
+    write: async (name, content) => {
+        const path = fileFor(dir, name);
+        await mkdir(dir, { recursive: true });
+        await writeFile(path, content, 'utf-8');
+        return path;
+    },
+    list: async () => {
+        try {
+            return await readdir(dir);
+        }
+        catch {
+            return [];
+        }
+    },
+    remove: async (name) => {
+        await rm(fileFor(dir, name), { force: true });
+    },
+});