mu-harness 0.16.3

package/script/harness/npm/src/session/catalog.d.ts

@@ -0,0 +1,24 @@
+export interface SessionRecord {
+    id: string;
+    title?: string;
+    cwd?: string;
+    parentId?: string;
+    createdAt: number;
+}
+export interface SessionCatalog {
+    record(id: string, info: {
+        cwd?: string;
+        parentId?: string;
+    }): void;
+    setTitle(id: string, title: string): void;
+    get(id: string): SessionRecord | undefined;
+    list(filter?: {
+        cwd?: string;
+        parentId?: string;
+    }): SessionRecord[];
+    delete(id: string): void;
+    close(): void;
+}
+export declare const createSessionCatalog: ({ file }: {
+    file: string;
+}) => SessionCatalog;

package/script/harness/npm/src/session/catalog.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionCatalog = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_sqlite_1 = require("node:sqlite");
+const toRecord = (row) => ({
+    id: row.id,
+    title: row.title ?? undefined,
+    cwd: row.cwd ?? undefined,
+    parentId: row.parent_id ?? undefined,
+    createdAt: row.created_at,
+});
+const createSessionCatalog = ({ file }) => {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(file), { recursive: true });
+    const db = new node_sqlite_1.DatabaseSync(file);
+    db.exec('CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, title TEXT, cwd TEXT, parent_id TEXT, created_at INTEGER NOT NULL)');
+    try {
+        db.exec('ALTER TABLE sessions ADD COLUMN parent_id TEXT');
+    }
+    catch {
+        void 0;
+    }
+    return {
+        record: (id, info) => {
+            db.prepare('INSERT OR IGNORE INTO sessions (id, cwd, parent_id, created_at) VALUES (?, ?, ?, ?)').run(id, info.cwd ?? null, info.parentId ?? null, Date.now());
+        },
+        setTitle: (id, title) => {
+            db.prepare('UPDATE sessions SET title = ? WHERE id = ?').run(title, id);
+        },
+        get: (id) => {
+            const row = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id);
+            return row ? toRecord(row) : undefined;
+        },
+        list: (filter) => {
+            let sql = 'SELECT * FROM sessions';
+            const params = [];
+            if (filter?.parentId !== undefined) {
+                sql += ' WHERE parent_id = ?';
+                params.push(filter.parentId);
+            }
+            else {
+                sql += ' WHERE parent_id IS NULL';
+                if (filter?.cwd !== undefined) {
+                    sql += ' AND cwd = ?';
+                    params.push(filter.cwd);
+                }
+            }
+            sql += ' ORDER BY created_at DESC';
+            const rows = db.prepare(sql).all(...params);
+            return rows.map(toRecord);
+        },
+        delete: (id) => {
+            db.prepare('DELETE FROM sessions WHERE id = ?').run(id);
+        },
+        close: () => db.close(),
+    };
+};
+exports.createSessionCatalog = createSessionCatalog;

package/script/harness/npm/src/session/index.d.ts

@@ -0,0 +1,7 @@
+export type { AgentSession, AgentSessionEvent } from './types.js';
+export { type AgentSessionConfig, createAgentSession } from './agent-session.js';
+export { createSessionStore, type SessionStore, type StoredSession } from './store.js';
+export { createSessionCatalog, type SessionCatalog, type SessionRecord } from './catalog.js';
+export { persistTo } from './persist.js';
+export { createSessionManager, type ReviveInput, type SessionManager, type SessionManagerOptions } from './manager.js';
+export { cleanTitle, runTitler, type RunTitlerOptions, titleFallback } from './title.js';

package/script/harness/npm/src/session/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.titleFallback = exports.runTitler = exports.cleanTitle = exports.createSessionManager = exports.persistTo = exports.createSessionCatalog = exports.createSessionStore = exports.createAgentSession = void 0;
+var agent_session_js_1 = require("./agent-session.js");
+Object.defineProperty(exports, "createAgentSession", { enumerable: true, get: function () { return agent_session_js_1.createAgentSession; } });
+var store_js_1 = require("./store.js");
+Object.defineProperty(exports, "createSessionStore", { enumerable: true, get: function () { return store_js_1.createSessionStore; } });
+var catalog_js_1 = require("./catalog.js");
+Object.defineProperty(exports, "createSessionCatalog", { enumerable: true, get: function () { return catalog_js_1.createSessionCatalog; } });
+var persist_js_1 = require("./persist.js");
+Object.defineProperty(exports, "persistTo", { enumerable: true, get: function () { return persist_js_1.persistTo; } });
+var manager_js_1 = require("./manager.js");
+Object.defineProperty(exports, "createSessionManager", { enumerable: true, get: function () { return manager_js_1.createSessionManager; } });
+var title_js_1 = require("./title.js");
+Object.defineProperty(exports, "cleanTitle", { enumerable: true, get: function () { return title_js_1.cleanTitle; } });
+Object.defineProperty(exports, "runTitler", { enumerable: true, get: function () { return title_js_1.runTitler; } });
+Object.defineProperty(exports, "titleFallback", { enumerable: true, get: function () { return title_js_1.titleFallback; } });

package/script/harness/npm/src/session/manager.d.ts

@@ -0,0 +1,39 @@
+import type { Message } from 'mu-core';
+import type { SessionCatalog, SessionRecord } from './catalog.js';
+import type { SessionStore, StoredSession } from './store.js';
+import type { AgentSession } from './types.js';
+export interface ReviveInput {
+    id: string;
+    model?: string;
+    messages?: Message[];
+}
+export interface SessionManagerOptions {
+    store: SessionStore;
+    catalog: SessionCatalog;
+    revive(input: ReviveInput): AgentSession;
+    newId(): string;
+    cwd?: string;
+    title?(input: {
+        id: string;
+        text: string;
+    }): void;
+}
+export interface SessionManager {
+    create(options?: {
+        id?: string;
+        model?: string;
+        cwd?: string;
+    }): AgentSession;
+    open(id: string): Promise<AgentSession>;
+    fork(id: string, upToIndex: number): Promise<AgentSession>;
+    list(filter?: {
+        cwd?: string;
+        parentId?: string;
+    }): Promise<SessionRecord[]>;
+    get(id: string): Promise<SessionRecord | undefined>;
+    /** Read a session's stored messages by id without instantiating a live session. */
+    read(id: string): Promise<StoredSession | undefined>;
+    rename(id: string, title: string): void;
+    delete(id: string): Promise<void>;
+}
+export declare const createSessionManager: ({ store, catalog, revive, newId, cwd, title }: SessionManagerOptions) => SessionManager;

package/script/harness/npm/src/session/manager.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionManager = void 0;
+const persist_js_1 = require("./persist.js");
+const inputText = (input) => typeof input === 'string' ? input : input.map((part) => (part.type === 'text' ? part.text : '')).join('');
+const onFirstMessage = (session, fire) => {
+    let pending = !session.messages.some((message) => message.role === 'user');
+    return {
+        get id() {
+            return session.id;
+        },
+        get messages() {
+            return session.messages;
+        },
+        send: async (input) => {
+            if (pending) {
+                pending = false;
+                fire({ id: session.id, text: inputText(input) });
+            }
+            await session.send(input);
+        },
+        abort: session.abort,
+        subscribe: session.subscribe,
+    };
+};
+const createSessionManager = ({ store, catalog, revive, newId, cwd, title }) => ({
+    create: (options) => {
+        const id = options?.id ?? newId();
+        catalog.record(id, { cwd: options?.cwd ?? cwd });
+        const session = (0, persist_js_1.persistTo)(store, revive({ id, model: options?.model }));
+        return title ? onFirstMessage(session, title) : session;
+    },
+    open: async (id) => {
+        const stored = await store.load(id);
+        return (0, persist_js_1.persistTo)(store, revive({ id: stored.id, messages: stored.messages }), stored.messages.length);
+    },
+    fork: async (id, upToIndex) => {
+        const stored = await store.load(id);
+        const messages = stored.messages.slice(0, upToIndex + 1);
+        const forkId = newId();
+        catalog.record(forkId, { cwd: catalog.get(id)?.cwd ?? cwd });
+        const session = revive({ id: forkId, messages });
+        await store.append(forkId, messages);
+        return (0, persist_js_1.persistTo)(store, session, messages.length);
+    },
+    list: async (filter) => catalog.list(filter),
+    get: async (id) => catalog.get(id),
+    read: async (id) => {
+        try {
+            return await store.load(id);
+        }
+        catch {
+            return undefined;
+        }
+    },
+    rename: (id, title) => catalog.setTitle(id, title),
+    delete: async (id) => {
+        for (const child of catalog.list({ parentId: id })) {
+            await store.delete(child.id);
+            catalog.delete(child.id);
+        }
+        await store.delete(id);
+        catalog.delete(id);
+    },
+});
+exports.createSessionManager = createSessionManager;

package/script/harness/npm/src/session/persist.d.ts

@@ -0,0 +1,3 @@
+import type { SessionStore } from './store.js';
+import type { AgentSession } from './types.js';
+export declare const persistTo: (store: SessionStore, session: AgentSession, persisted?: number) => AgentSession;

package/script/harness/npm/src/session/persist.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.persistTo = void 0;
+const persistTo = (store, session, persisted = 0) => {
+    let count = persisted;
+    return {
+        get id() {
+            return session.id;
+        },
+        get messages() {
+            return session.messages;
+        },
+        send: async (input) => {
+            await session.send(input);
+            const all = session.messages;
+            if (all.length > count) {
+                await store.append(session.id, all.slice(count));
+                count = all.length;
+            }
+        },
+        abort: session.abort,
+        subscribe: session.subscribe,
+    };
+};
+exports.persistTo = persistTo;

package/script/harness/npm/src/session/store.d.ts

@@ -0,0 +1,13 @@
+import type { Message } from 'mu-core';
+export interface StoredSession {
+    id: string;
+    messages: Message[];
+}
+export interface SessionStore {
+    load(id: string): Promise<StoredSession>;
+    append(id: string, messages: Message[]): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export declare const createSessionStore: ({ dir }: {
+    dir: string;
+}) => SessionStore;

package/script/harness/npm/src/session/store.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionStore = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const EXT = '.jsonl';
+const fileFor = (dir, id) => {
+    if (!/^[\w-]+$/.test(id))
+        throw new Error(`SessionStore: invalid session id "${id}"`);
+    return (0, node_path_1.join)(dir, `${id}${EXT}`);
+};
+const createSessionStore = ({ dir }) => ({
+    load: async (id) => {
+        const raw = await (0, promises_1.readFile)(fileFor(dir, id), 'utf-8');
+        const messages = raw.split('\n').filter(Boolean).map((line) => JSON.parse(line));
+        return { id, messages };
+    },
+    append: async (id, messages) => {
+        if (messages.length === 0)
+            return;
+        await (0, promises_1.mkdir)(dir, { recursive: true });
+        await (0, promises_1.appendFile)(fileFor(dir, id), messages.map((message) => `${JSON.stringify(message)}\n`).join(''));
+    },
+    delete: async (id) => {
+        await (0, promises_1.rm)(fileFor(dir, id), { force: true });
+    },
+});
+exports.createSessionStore = createSessionStore;

package/script/harness/npm/src/session/title.d.ts

@@ -0,0 +1,9 @@
+export declare const titleFallback: (text: string, max?: number) => string;
+export declare const cleanTitle: (raw: string, max?: number) => string;
+export interface RunTitlerOptions {
+    id: string;
+    text: string;
+    setTitle(id: string, title: string): void | Promise<void>;
+    generate(text: string): Promise<string>;
+}
+export declare const runTitler: (options: RunTitlerOptions) => Promise<void>;

package/script/harness/npm/src/session/title.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTitler = exports.cleanTitle = exports.titleFallback = void 0;
+const titleFallback = (text, max = 50) => {
+    const clean = text.replace(/\s+/g, ' ').trim();
+    return clean.length > max ? `${clean.slice(0, max - 1)}…` : clean;
+};
+exports.titleFallback = titleFallback;
+const cleanTitle = (raw, max = 60) => {
+    const line = raw
+        .replace(/<think>[\s\S]*?<\/think>/g, '')
+        .split('\n')
+        .map((entry) => entry.trim())
+        .find((entry) => entry.length > 0) ?? '';
+    const unquoted = line.replace(/^["'`]+|["'`]+$/g, '').trim();
+    return unquoted.length > max ? `${unquoted.slice(0, max - 1)}…` : unquoted;
+};
+exports.cleanTitle = cleanTitle;
+const runTitler = async (options) => {
+    await options.setTitle(options.id, (0, exports.titleFallback)(options.text));
+    try {
+        const title = (0, exports.cleanTitle)(await options.generate(options.text));
+        if (title)
+            await options.setTitle(options.id, title);
+    }
+    catch {
+        // keep the fallback
+    }
+};
+exports.runTitler = runTitler;

package/script/harness/npm/src/session/types.d.ts

@@ -0,0 +1,17 @@
+import type { ContentPart, LoopEvent, Message } from 'mu-core';
+export type AgentSessionEvent = {
+    type: 'turn_start';
+    input: Message;
+} | LoopEvent | {
+    type: 'turn_end';
+} | {
+    type: 'error';
+    error: unknown;
+};
+export interface AgentSession {
+    readonly id: string;
+    readonly messages: readonly Message[];
+    send(input: string | ContentPart[]): Promise<void>;
+    abort(): void;
+    subscribe(listener: (event: AgentSessionEvent) => void): () => void;
+}

package/script/harness/npm/src/session/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/harness/npm/src/skills/index.d.ts

@@ -0,0 +1,7 @@
+export type { Skill } from './types.js';
+export { createSkillRegistry, type SkillRegistry } from './registry.js';
+export { parseSkill } from './parser.js';
+export { loadSkills } from './loader.js';
+export { createSkillTool } from './tool.js';
+export { createSkillWriterTool } from './writer.js';
+export { createRunSkillTool, runSkill, type RunSkillDeps } from './run.js';

package/script/harness/npm/src/skills/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSkill = exports.createRunSkillTool = exports.createSkillWriterTool = exports.createSkillTool = exports.loadSkills = exports.parseSkill = exports.createSkillRegistry = void 0;
+var registry_js_1 = require("./registry.js");
+Object.defineProperty(exports, "createSkillRegistry", { enumerable: true, get: function () { return registry_js_1.createSkillRegistry; } });
+var parser_js_1 = require("./parser.js");
+Object.defineProperty(exports, "parseSkill", { enumerable: true, get: function () { return parser_js_1.parseSkill; } });
+var loader_js_1 = require("./loader.js");
+Object.defineProperty(exports, "loadSkills", { enumerable: true, get: function () { return loader_js_1.loadSkills; } });
+var tool_js_1 = require("./tool.js");
+Object.defineProperty(exports, "createSkillTool", { enumerable: true, get: function () { return tool_js_1.createSkillTool; } });
+var writer_js_1 = require("./writer.js");
+Object.defineProperty(exports, "createSkillWriterTool", { enumerable: true, get: function () { return writer_js_1.createSkillWriterTool; } });
+var run_js_1 = require("./run.js");
+Object.defineProperty(exports, "createRunSkillTool", { enumerable: true, get: function () { return run_js_1.createRunSkillTool; } });
+Object.defineProperty(exports, "runSkill", { enumerable: true, get: function () { return run_js_1.runSkill; } });

package/script/harness/npm/src/skills/loader.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from './types.js';
+export declare const loadSkills: (dir: string) => Promise<Skill[]>;

package/script/harness/npm/src/skills/loader.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSkills = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const parser_js_1 = require("./parser.js");
+const loadSkills = async (dir) => {
+    let entries;
+    try {
+        entries = await (0, promises_1.readdir)(dir);
+    }
+    catch {
+        return [];
+    }
+    const skills = [];
+    for (const entry of entries.sort()) {
+        const skillDir = (0, node_path_1.join)(dir, entry);
+        try {
+            if (!(await (0, promises_1.stat)(skillDir)).isDirectory())
+                continue;
+            const source = await (0, promises_1.readFile)((0, node_path_1.join)(skillDir, 'SKILL.md'), 'utf-8');
+            skills.push((0, parser_js_1.parseSkill)(source, entry, skillDir));
+        }
+        catch {
+            continue;
+        }
+    }
+    return skills;
+};
+exports.loadSkills = loadSkills;

package/script/harness/npm/src/skills/parser.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from './types.js';
+export declare const parseSkill: (source: string, fallbackName: string, dir?: string) => Skill;

package/script/harness/npm/src/skills/parser.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSkill = void 0;
+const index_js_1 = require("../common/index.js");
+const parseSkill = (source, fallbackName, dir) => {
+    const { fields, body } = (0, index_js_1.parseFrontmatter)(source);
+    return {
+        name: (0, index_js_1.str)(fields.name) ?? fallbackName,
+        description: (0, index_js_1.str)(fields.description) ?? '',
+        prompt: body,
+        dir,
+    };
+};
+exports.parseSkill = parseSkill;

package/script/harness/npm/src/skills/registry.d.ts

@@ -0,0 +1,8 @@
+import type { Skill } from './types.js';
+export interface SkillRegistry {
+    list(): Skill[];
+    get(name: string): Skill | undefined;
+    add(skill: Skill): void;
+    select(names: string[]): SkillRegistry;
+}
+export declare const createSkillRegistry: (skills?: Skill[]) => SkillRegistry;

package/script/harness/npm/src/skills/registry.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSkillRegistry = void 0;
+const createSkillRegistry = (skills = []) => {
+    const byName = new Map();
+    for (const skill of skills)
+        if (!byName.has(skill.name))
+            byName.set(skill.name, skill);
+    const view = (allow) => ({
+        list: () => [...byName.values()].filter((skill) => !allow || allow.has(skill.name)),
+        get: (name) => (!allow || allow.has(name) ? byName.get(name) : undefined),
+        add: (skill) => {
+            byName.set(skill.name, skill);
+            allow?.add(skill.name);
+        },
+        select: (names) => view(new Set(allow ? names.filter((name) => allow.has(name)) : names)),
+    });
+    return view();
+};
+exports.createSkillRegistry = createSkillRegistry;

package/script/harness/npm/src/skills/run.d.ts

@@ -0,0 +1,14 @@
+import type { Tool } from 'mu-core';
+import type { AgentRegistry } from '../agents/index.js';
+import { type RunSubAgentDeps } from '../subAgents/index.js';
+import type { SkillRegistry } from './registry.js';
+export interface RunSkillDeps extends RunSubAgentDeps {
+    skills: SkillRegistry;
+    agents?: AgentRegistry;
+}
+export declare const runSkill: (deps: RunSkillDeps, args: {
+    skill: string;
+    task: string;
+    agent: string;
+}) => Promise<string>;
+export declare const createRunSkillTool: (deps: RunSkillDeps) => Tool;

package/script/harness/npm/src/skills/run.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRunSkillTool = exports.runSkill = void 0;
+const index_js_1 = require("../subAgents/index.js");
+const runSkill = async (deps, args) => {
+    const skill = deps.skills.get(args.skill);
+    if (!skill)
+        throw new Error(`unknown skill "${args.skill}"`);
+    const base = deps.agents?.get(args.agent);
+    if (!base)
+        throw new Error(`unknown agent "${args.agent}"`);
+    const agent = {
+        name: base.name,
+        description: skill.description,
+        prompt: [base.prompt, skill.prompt].filter(Boolean).join('\n\n'),
+        tools: base.tools,
+        model: base.model,
+    };
+    const result = await (0, index_js_1.runSubAgent)(agent, args.task, deps);
+    return result.text;
+};
+exports.runSkill = runSkill;
+const createRunSkillTool = (deps) => ({
+    name: 'run_skill',
+    description: 'Invoke a sub-agent equipped with a named skill to carry out a specific task. Returns its final answer.',
+    prompt: 'To carry out a self-contained task under a skill, call `run_skill` with the skill name, the task, and the agent persona to run it as.',
+    parameters: {
+        type: 'object',
+        properties: {
+            skill: { type: 'string', description: 'Skill name to equip the agent with.' },
+            task: { type: 'string', description: 'The precise task to carry out.' },
+            agent: { type: 'string', description: 'Agent persona to run the skill as (defines its tools).' },
+        },
+        required: ['skill', 'task', 'agent'],
+        additionalProperties: false,
+    },
+    run: async (input) => {
+        const { skill, task, agent } = (input ?? {});
+        if (!skill || !task || !agent) {
+            return [{ type: 'text', text: 'Error: run_skill requires `skill`, `task`, and `agent`.' }];
+        }
+        try {
+            return [{ type: 'text', text: await (0, exports.runSkill)(deps, { skill, task, agent }) }];
+        }
+        catch (error) {
+            return [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }];
+        }
+    },
+});
+exports.createRunSkillTool = createRunSkillTool;

package/script/harness/npm/src/skills/tool.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from 'mu-core';
+import type { SkillRegistry } from './registry.js';
+export declare const createSkillTool: (registry: SkillRegistry) => Tool;

package/script/harness/npm/src/skills/tool.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSkillTool = void 0;
+const createSkillTool = (registry) => ({
+    name: 'skill',
+    description: "Load a named skill's instructions into the conversation, then follow them.",
+    get prompt() {
+        const list = registry.list();
+        if (!list.length)
+            return undefined;
+        const catalog = list.map((skill) => `- ${skill.name}${skill.description ? `: ${skill.description}` : ''}`).join('\n');
+        return `When a request matches one of these skills, call \`skill\` with its name BEFORE acting, then follow the returned instructions:\n${catalog}`;
+    },
+    parameters: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Skill name.' },
+        },
+        required: ['name'],
+        additionalProperties: false,
+    },
+    run: async (input) => {
+        const { name } = (input ?? {});
+        if (!name)
+            return [{ type: 'text', text: 'Error: skill requires `name`.' }];
+        const skill = registry.get(name);
+        if (!skill)
+            return [{ type: 'text', text: `Error: unknown skill "${name}".` }];
+        const header = skill.dir
+            ? `Skill "${skill.name}" (bundled files live under ${skill.dir}):\n\n`
+            : `Skill "${skill.name}":\n\n`;
+        return [{ type: 'text', text: header + skill.prompt }];
+    },
+});
+exports.createSkillTool = createSkillTool;

package/script/harness/npm/src/skills/types.d.ts

@@ -0,0 +1,6 @@
+export interface Skill {
+    name: string;
+    description: string;
+    prompt: string;
+    dir?: string;
+}

package/script/harness/npm/src/skills/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/harness/npm/src/skills/writer.d.ts

@@ -0,0 +1,7 @@
+import type { Tool } from 'mu-core';
+import type { SkillRegistry } from './registry.js';
+export type SkillScope = 'local' | 'config';
+export declare const createSkillWriterTool: (deps: {
+    dirs: Record<SkillScope, string>;
+    registry: SkillRegistry;
+}) => Tool;

package/script/harness/npm/src/skills/writer.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSkillWriterTool = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const parser_js_1 = require("./parser.js");
+const slug = (name) => name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+const createSkillWriterTool = (deps) => ({
+    name: 'create_skill',
+    description: 'Create a reusable skill: a named set of instructions the agent can load on demand later.',
+    prompt: 'When you discover a reusable workflow worth keeping, capture it with `create_skill` (name, description, instructions). Use `scope: "local"` for a skill specific to this project, or `scope: "config"` to make it available across all projects. It can then be loaded via `skill`.',
+    parameters: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Short skill name (kebab-case).' },
+            description: { type: 'string', description: 'One line describing when this skill should be used.' },
+            instructions: { type: 'string', description: 'The skill body: the instructions to follow when it is invoked.' },
+            scope: {
+                type: 'string',
+                enum: ['local', 'config'],
+                description: 'Where to save it: "local" = this project (<cwd>/skills), "config" = global config dir. Defaults to "local".',
+            },
+        },
+        required: ['name', 'description', 'instructions'],
+        additionalProperties: false,
+    },
+    run: async (input) => {
+        const { name, description, instructions, scope } = (input ?? {});
+        if (!name || !description || !instructions) {
+            return [{ type: 'text', text: 'Error: create_skill requires `name`, `description`, and `instructions`.' }];
+        }
+        const base = deps.dirs[scope ?? 'local'];
+        if (!base)
+            return [{ type: 'text', text: `Error: unknown scope "${scope}".` }];
+        const id = slug(name);
+        if (!id)
+            return [{ type: 'text', text: `Error: invalid skill name "${name}".` }];
+        const skillDir = (0, node_path_1.join)(base, id);
+        const file = (0, node_path_1.join)(skillDir, 'SKILL.md');
+        const source = `---\nname: ${id}\ndescription: ${JSON.stringify(description)}\n---\n\n${instructions.trim()}\n`;
+        await (0, promises_1.mkdir)(skillDir, { recursive: true });
+        await (0, promises_1.writeFile)(file, source, 'utf-8');
+        deps.registry.add((0, parser_js_1.parseSkill)(source, id, skillDir));
+        return [{ type: 'text', text: `Created skill "${id}" at ${file}. It is now available via the \`skill\` tool.` }];
+    },
+});
+exports.createSkillWriterTool = createSkillWriterTool;