@kuralle-agents/core 0.12.0 → 0.14.0

package/dist/session/testing.js

@@ -21,6 +21,7 @@
  * `bun:test` into runtime bundles.
  */
 import { describe, test, expect, beforeEach } from 'bun:test';
+import { StaleWriteError } from './SessionStore.js';
 const buildSession = (overrides = {}) => {
     const now = new Date();
     return {
@@ -120,3 +121,36 @@ export function runSessionStoreContract(factory) {
         });
     });
 }
+/**
+ * Registers optimistic-concurrency (CAS) contract tests for SessionStore adapters.
+ * Two concurrent saves with the same expected version: exactly one succeeds.
+ */
+export function runSessionStoreCasContract(factory) {
+    describe('SessionStore CAS contract', () => {
+        let store;
+        beforeEach(async () => {
+            store = await factory();
+        });
+        test('concurrent save with same expected version rejects one writer with StaleWriteError', async () => {
+            const session = buildSession({ id: 'cas-sess' });
+            await store.save(session);
+            const firstRead = (await store.get('cas-sess'));
+            const secondRead = (await store.get('cas-sess'));
+            expect(firstRead.version).toBe(1);
+            expect(secondRead.version).toBe(1);
+            firstRead.workingMemory = { writer: 'a' };
+            secondRead.workingMemory = { writer: 'b' };
+            const results = await Promise.allSettled([
+                store.save(firstRead),
+                store.save(secondRead),
+            ]);
+            const fulfilled = results.filter((r) => r.status === 'fulfilled');
+            const rejected = results.filter((r) => r.status === 'rejected');
+            expect(fulfilled).toHaveLength(1);
+            expect(rejected).toHaveLength(1);
+            expect(rejected[0].reason).toBeInstanceOf(StaleWriteError);
+            const final = await store.get('cas-sess');
+            expect(final?.version).toBe(2);
+        });
+    });
+}

package/dist/session/utils.d.ts

@@ -1,4 +1,5 @@
 import type { Session } from '../types/index.js';
+import { type SessionStore } from './SessionStore.js';
 /**
  * Restores a Session from its serialized form.
  *
@@ -17,3 +18,5 @@ import type { Session } from '../types/index.js';
  * untouched in the key fields — callers are expected to have validated shape.
  */
 export declare function reviveSession(raw: unknown): Session;
+/** Apply a session mutation to the latest snapshot and retry it after CAS conflicts. */
+export declare function mutateSessionWithRetry(store: SessionStore, sessionId: string, mutator: (session: Session) => void | Promise<void>): Promise<Session>;

package/dist/session/utils.js

@@ -1,3 +1,5 @@
+import { StaleWriteError } from './SessionStore.js';
+const CAS_RETRIES = 8;
 /**
  * Restores a Session from its serialized form.
  *
@@ -45,3 +47,24 @@ export function reviveSession(raw) {
     ]));
     return session;
 }
+/** Apply a session mutation to the latest snapshot and retry it after CAS conflicts. */
+export async function mutateSessionWithRetry(store, sessionId, mutator) {
+    for (let attempt = 0; attempt < CAS_RETRIES; attempt++) {
+        const session = await store.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        await mutator(session);
+        try {
+            await store.save(session);
+            return (await store.get(sessionId)) ?? session;
+        }
+        catch (error) {
+            if (error instanceof StaleWriteError && attempt < CAS_RETRIES - 1) {
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error(`CAS retry limit exceeded for session: ${sessionId}`);
+}

package/dist/skills/collectSkills.d.ts

@@ -1,5 +1,6 @@
 import type { AnyTool } from '../types/effectTool.js';
-import type { SkillLike, SkillSource, SkillStoreLike } from '../types/skills.js';
+import type { FileSystem } from '../types/filesystem.js';
+import type { SkillEntry, SkillLike, SkillSource, SkillStoreLike } from '../types/skills.js';
 export interface SkillWireAgent {
     skills?: SkillSource;
     tools?: Record<string, AnyTool>;
@@ -8,10 +9,17 @@ export interface SkillWireAgent {
         name: string;
     }>;
 }
-export declare function isSkillStore(value: SkillSource): value is SkillStoreLike;
+export declare function isSkillStore(value: SkillEntry | SkillSource): value is SkillStoreLike;
 export declare function collectRegisteredNames(agent: SkillWireAgent): Set<string>;
 export declare function validateSkillAllowedTools(skills: SkillLike[], registered: Set<string>): void;
-export declare function prepareSkillStore(source: SkillSource): Promise<{
+/**
+ * Turns whatever the author wrote in `AgentConfig.skills` into one store.
+ *
+ * `fs` is the agent's workspace filesystem, needed only to resolve `string` entries. A path
+ * without a workspace is an authoring mistake, so it throws rather than silently yielding no
+ * skills — a missing skill is invisible at runtime and looks like the model ignoring it.
+ */
+export declare function prepareSkillStore(source: SkillSource, fs?: FileSystem): Promise<{
     store: SkillStoreLike;
     skills: SkillLike[];
 }>;

package/dist/skills/collectSkills.js

@@ -1,4 +1,6 @@
 import { InlineSkillStore } from './inlineSkillStore.js';
+import { CompositeSkillStore } from './compositeSkillStore.js';
+import { fsSkillStore } from './fsSkillStore.js';
 export function isSkillStore(value) {
     return (typeof value === 'object' &&
         value !== null &&
@@ -7,9 +9,6 @@ export function isSkillStore(value) {
         typeof value.list === 'function');
 }
 async function collectSkillsFromSource(source) {
-    if (!isSkillStore(source)) {
-        return Array.isArray(source) ? source : [source];
-    }
     if (typeof source.getAllSkills === 'function') {
         const all = source.getAllSkills();
         return Array.isArray(all) ? all : await all;
@@ -47,10 +46,54 @@ export function validateSkillAllowedTools(skills, registered) {
         }
     }
 }
-export async function prepareSkillStore(source) {
-    if (isSkillStore(source)) {
-        return { store: source, skills: await collectSkillsFromSource(source) };
+/**
+ * Turns whatever the author wrote in `AgentConfig.skills` into one store.
+ *
+ * `fs` is the agent's workspace filesystem, needed only to resolve `string` entries. A path
+ * without a workspace is an authoring mistake, so it throws rather than silently yielding no
+ * skills — a missing skill is invisible at runtime and looks like the model ignoring it.
+ */
+export async function prepareSkillStore(source, fs) {
+    const entries = Array.isArray(source)
+        ? [...source]
+        : [source];
+    // A lone store stays itself: wrapping one store in a composite would add a layer with
+    // nothing to compose, and lose any extra capability the store exposes.
+    if (entries.length === 1 && isSkillStore(entries[0])) {
+        const only = entries[0];
+        return { store: only, skills: await collectSkillsFromSource(only) };
+    }
+    const stores = [];
+    let inline = [];
+    const flushInline = () => {
+        if (inline.length > 0) {
+            stores.push(new InlineSkillStore(inline));
+            inline = [];
+        }
+    };
+    for (const entry of entries) {
+        if (typeof entry === 'string') {
+            if (!fs) {
+                throw new Error(`[skills] "${entry}" is a workspace path, but this agent has no \`workspace\` filesystem. ` +
+                    'Set `workspace` on the agent, or pass skills inline with defineSkill().');
+            }
+            flushInline();
+            stores.push(fsSkillStore(fs, [entry]));
+            continue;
+        }
+        if (isSkillStore(entry)) {
+            flushInline();
+            stores.push(entry);
+            continue;
+        }
+        // Consecutive inline skills share one store so ordering within a run is preserved.
+        inline.push(entry);
+    }
+    flushInline();
+    if (stores.length === 1) {
+        const only = stores[0];
+        return { store: only, skills: await collectSkillsFromSource(only) };
     }
-    const skills = Array.isArray(source) ? source : [source];
-    return { store: new InlineSkillStore(skills), skills };
+    const store = new CompositeSkillStore(stores);
+    return { store, skills: await collectSkillsFromSource(store) };
 }

package/dist/skills/compositeSkillStore.d.ts

@@ -0,0 +1,26 @@
+import type { SkillMeta, SkillStoreLike } from '../types/skills.js';
+/**
+ * Presents several skill stores as one, with **later stores winning** a name collision.
+ *
+ * Delegates rather than flattening on purpose: flattening would force every body and
+ * resource to load up front, which is exactly what progressive disclosure exists to avoid.
+ * Only `list()` (Level 1 — names and descriptions) is eager; bodies and resources stay
+ * behind their own calls.
+ */
+export declare class CompositeSkillStore implements SkillStoreLike {
+    private readonly stores;
+    /** Name → the store that owns it. Built on first `list()`, reused after. */
+    private owners?;
+    /** @param stores In precedence order, lowest first. */
+    constructor(stores: readonly SkillStoreLike[]);
+    list(): Promise<SkillMeta[]>;
+    loadBody(name: string): Promise<string>;
+    loadResource(name: string, path: string): Promise<string | Uint8Array>;
+    loadAllSkills(): Promise<{
+        name: string;
+        description: string;
+        body: string;
+    }[]>;
+    private ownerOf;
+    private resolveOwners;
+}

package/dist/skills/compositeSkillStore.js

@@ -0,0 +1,54 @@
+/**
+ * Presents several skill stores as one, with **later stores winning** a name collision.
+ *
+ * Delegates rather than flattening on purpose: flattening would force every body and
+ * resource to load up front, which is exactly what progressive disclosure exists to avoid.
+ * Only `list()` (Level 1 — names and descriptions) is eager; bodies and resources stay
+ * behind their own calls.
+ */
+export class CompositeSkillStore {
+    stores;
+    /** Name → the store that owns it. Built on first `list()`, reused after. */
+    owners;
+    /** @param stores In precedence order, lowest first. */
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async list() {
+        const merged = new Map();
+        const owners = new Map();
+        for (const store of this.stores) {
+            for (const meta of await store.list()) {
+                merged.set(meta.name, meta);
+                owners.set(meta.name, store);
+            }
+        }
+        this.owners = owners;
+        return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async loadBody(name) {
+        return (await this.ownerOf(name)).loadBody(name);
+    }
+    async loadResource(name, path) {
+        return (await this.ownerOf(name)).loadResource(name, path);
+    }
+    async loadAllSkills() {
+        const owners = await this.resolveOwners();
+        const out = [];
+        for (const [name, store] of owners) {
+            out.push({ name, description: '', body: await store.loadBody(name) });
+        }
+        return out;
+    }
+    async ownerOf(name) {
+        const owner = (await this.resolveOwners()).get(name);
+        if (!owner)
+            throw new Error(`[skills] Skill "${name}" not found.`);
+        return owner;
+    }
+    async resolveOwners() {
+        if (!this.owners)
+            await this.list();
+        return this.owners;
+    }
+}

package/dist/skills/defineSkill.d.ts

@@ -0,0 +1,21 @@
+import type { SkillLike } from '../types/skills.js';
+export interface DefineSkillConfig {
+    /** Lowercase, hyphen-separated, ≤64 chars — the Agent Skills naming rule. */
+    name: string;
+    /** When the model should reach for this skill. Disclosed up front, so keep it specific. ≤1024 chars. */
+    description: string;
+    /** The skill body — Level 2, loaded only when the model calls `load_skill`. */
+    instructions: string;
+    /** Level 3: fetched individually via `read_skill_resource`, never loaded up front. */
+    resources?: Record<string, string | Uint8Array>;
+    /** Restricts this skill to a subset of the agent's tools. Unknown names fail at wiring time. */
+    allowedTools?: string[];
+}
+/**
+ * Authors a skill inline, with no filesystem involved.
+ *
+ * Validated against the same rules as a `SKILL.md` on disk — an inline skill that would be
+ * rejected as a file is rejected here too, so moving one to `agents/<id>/skills/` later
+ * cannot start failing.
+ */
+export declare function defineSkill(config: DefineSkillConfig): SkillLike;

package/dist/skills/defineSkill.js

@@ -0,0 +1,26 @@
+import { validateSkillDescription, validateSkillName } from './parseSkillFrontmatter.js';
+/**
+ * Authors a skill inline, with no filesystem involved.
+ *
+ * Validated against the same rules as a `SKILL.md` on disk — an inline skill that would be
+ * rejected as a file is rejected here too, so moving one to `agents/<id>/skills/` later
+ * cannot start failing.
+ */
+export function defineSkill(config) {
+    const name = config.name?.trim();
+    const description = config.description?.trim();
+    if (!name)
+        throw new Error('[skills] defineSkill requires a non-empty name.');
+    if (!description) {
+        throw new Error(`[skills] Skill "${name}" requires a non-empty description.`);
+    }
+    validateSkillName(name, name);
+    validateSkillDescription(description, name);
+    return {
+        name,
+        description,
+        body: config.instructions,
+        resources: config.resources,
+        allowedTools: config.allowedTools,
+    };
+}

package/dist/skills/fsSkillStore.d.ts

@@ -0,0 +1,3 @@
+import type { FileSystem } from '../types/filesystem.js';
+import type { SkillStoreLike } from '../types/skills.js';
+export declare function fsSkillStore(fs: FileSystem, orderedRoots?: readonly string[]): SkillStoreLike;

package/dist/skills/fsSkillStore.js

@@ -0,0 +1,79 @@
+import { parseSkillFrontmatter } from './parseSkillFrontmatter.js';
+const DEFAULT_ROOT = '/skills';
+export function fsSkillStore(fs, orderedRoots = [DEFAULT_ROOT]) {
+    const roots = [...orderedRoots];
+    return {
+        async list() {
+            const skills = await discoverSkills(fs, roots, true);
+            return [...skills.values()]
+                .map((skill) => skill.meta)
+                .sort((a, b) => a.name.localeCompare(b.name));
+        },
+        async loadBody(name) {
+            const skill = (await discoverSkills(fs, roots, false)).get(name);
+            if (!skill) {
+                throw new Error(`[skills] Skill "${name}" not found.`);
+            }
+            return skill.body;
+        },
+        async loadResource(name, path) {
+            const skill = (await discoverSkills(fs, roots, false)).get(name);
+            if (!skill) {
+                throw new Error(`[skills] Skill "${name}" not found.`);
+            }
+            const normalized = path.trim().replace(/^\.?\//, '');
+            if (normalized.includes('..') || normalized.startsWith('/')) {
+                throw new Error(`[skills] Invalid resource path "${path}".`);
+            }
+            const resourcePath = fs.resolvePath(skill.root, `${skill.folder}/${normalized}`);
+            if (!(await fs.exists(resourcePath))) {
+                const err = new Error(`ENOENT: [skills] Resource "${normalized}" not found for skill "${name}".`);
+                throw err;
+            }
+            return fs.readFile(resourcePath);
+        },
+    };
+}
+async function discoverSkills(fs, roots, warnInvalid) {
+    const skills = new Map();
+    for (const root of roots) {
+        let entries;
+        try {
+            entries = await fs.readdir(root);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries.sort()) {
+            const entryPath = fs.resolvePath(root, entry);
+            let stat;
+            try {
+                stat = await fs.stat(entryPath);
+            }
+            catch {
+                continue;
+            }
+            if (stat.type !== 'directory')
+                continue;
+            const skillPath = fs.resolvePath(root, `${entry}/SKILL.md`);
+            if (!(await fs.exists(skillPath)))
+                continue;
+            try {
+                const content = await fs.readFile(skillPath);
+                const parsed = parseSkillFrontmatter(content, { path: skillPath });
+                skills.set(parsed.name, {
+                    root,
+                    folder: entry,
+                    meta: { name: parsed.name, description: parsed.description },
+                    body: parsed.body,
+                });
+            }
+            catch (err) {
+                if (warnInvalid) {
+                    console.warn(`[skills] Skipping ${skillPath}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+    }
+    return skills;
+}

package/dist/skills/index.d.ts

@@ -3,3 +3,7 @@ export { wireAgentSkills } from './wireAgentSkills.js';
 export type { WiredAgentSkills } from './wireAgentSkills.js';
 export { collectRegisteredNames, validateSkillAllowedTools, prepareSkillStore, isSkillStore, type SkillWireAgent, } from './collectSkills.js';
 export { InlineSkillStore } from './inlineSkillStore.js';
+export { CompositeSkillStore } from './compositeSkillStore.js';
+export { fsSkillStore } from './fsSkillStore.js';
+export { defineSkill, type DefineSkillConfig } from './defineSkill.js';
+export { parseSkillFrontmatter, validateSkillName, validateSkillDescription, type ParsedSkill, } from './parseSkillFrontmatter.js';

package/dist/skills/index.js

@@ -2,3 +2,7 @@ export { SkillsCapability } from './SkillsCapability.js';
 export { wireAgentSkills } from './wireAgentSkills.js';
 export { collectRegisteredNames, validateSkillAllowedTools, prepareSkillStore, isSkillStore, } from './collectSkills.js';
 export { InlineSkillStore } from './inlineSkillStore.js';
+export { CompositeSkillStore } from './compositeSkillStore.js';
+export { fsSkillStore } from './fsSkillStore.js';
+export { defineSkill } from './defineSkill.js';
+export { parseSkillFrontmatter, validateSkillName, validateSkillDescription, } from './parseSkillFrontmatter.js';

package/dist/skills/parseSkillFrontmatter.d.ts

@@ -0,0 +1,14 @@
+export interface ParsedSkill {
+    name: string;
+    description: string;
+    body: string;
+    license?: string;
+    compatibility?: string;
+    allowedTools?: string[];
+    metadata?: Record<string, string>;
+}
+export declare function parseSkillFrontmatter(content: string, ctx: {
+    path: string;
+}): ParsedSkill;
+export declare function validateSkillName(name: string, path: string): void;
+export declare function validateSkillDescription(description: string, path: string): void;

package/dist/skills/parseSkillFrontmatter.js

@@ -0,0 +1,183 @@
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)([\s\S]*)$/;
+const NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export function parseSkillFrontmatter(content, ctx) {
+    const stripped = content.replace(/^\uFEFF/, '');
+    const match = stripped.match(FRONTMATTER_RE);
+    if (!match) {
+        throw new Error(`[skills] Skill ${ctx.path} is missing YAML frontmatter. Start SKILL.md with "---", ` +
+            'include "name" and "description", then close the block with "---".');
+    }
+    const raw = parseFlatYaml(match[1] ?? '', ctx.path);
+    const name = requireField(raw, 'name', ctx.path);
+    const description = requireField(raw, 'description', ctx.path);
+    validateSkillName(name, ctx.path);
+    validateSkillDescription(description, ctx.path);
+    const compatibility = optionalString(raw.compatibility);
+    if (compatibility !== undefined && codePointLength(compatibility) > 500) {
+        throw new Error(`[skills] Skill ${ctx.path} field "compatibility" exceeds 500 characters.`);
+    }
+    let body = match[2] ?? '';
+    if (body.startsWith('\n')) {
+        body = body.slice(1);
+    }
+    const result = { name, description, body };
+    const license = optionalString(raw.license);
+    if (license !== undefined)
+        result.license = license;
+    if (compatibility !== undefined)
+        result.compatibility = compatibility;
+    const allowedTools = parseAllowedTools(raw['allowed-tools']);
+    if (allowedTools !== undefined)
+        result.allowedTools = allowedTools;
+    const metadata = parseMetadata(raw.metadata);
+    if (metadata !== undefined)
+        result.metadata = metadata;
+    return result;
+}
+function parseFlatYaml(yaml, path) {
+    const result = {};
+    const lines = yaml.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.trim() === '') {
+            i += 1;
+            continue;
+        }
+        const keyMatch = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (!keyMatch) {
+            throw new Error(`[skills] Skill ${path} has invalid YAML frontmatter near line: ${line}`);
+        }
+        const key = keyMatch[1];
+        const rest = (keyMatch[2] ?? '').trim();
+        if (rest === '') {
+            i += 1;
+            if (i >= lines.length)
+                break;
+            const next = lines[i];
+            if (next.match(/^\s+-\s+/)) {
+                const items = [];
+                while (i < lines.length) {
+                    const listLine = lines[i];
+                    const itemMatch = listLine.match(/^\s+-\s+(.*)$/);
+                    if (!itemMatch)
+                        break;
+                    items.push(parseScalar(itemMatch[1] ?? ''));
+                    i += 1;
+                }
+                result[key] = items;
+                continue;
+            }
+            if (key === 'metadata') {
+                const meta = {};
+                while (i < lines.length) {
+                    const metaLine = lines[i];
+                    const metaMatch = metaLine.match(/^\s{2}([A-Za-z0-9_-]+):\s*(.*)$/);
+                    if (!metaMatch)
+                        break;
+                    meta[metaMatch[1]] = parseScalar((metaMatch[2] ?? '').trim());
+                    i += 1;
+                }
+                result[key] = meta;
+                continue;
+            }
+            result[key] = '';
+            continue;
+        }
+        if (rest.startsWith('[') && rest.endsWith(']')) {
+            const inner = rest.slice(1, -1).trim();
+            result[key] =
+                inner === ''
+                    ? []
+                    : inner.split(',').map((s) => parseScalar(s.trim()));
+            i += 1;
+            continue;
+        }
+        result[key] = parseScalar(rest);
+        i += 1;
+    }
+    return result;
+}
+function parseScalar(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function requireField(raw, field, path) {
+    const value = raw[field];
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`[skills] Skill ${path} must define frontmatter ${field} as a non-empty string.`);
+    }
+    return value.trim();
+}
+function optionalString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+/** Agent Skills forbids reserved vendor words in a skill name. */
+const RESERVED_NAME_WORDS = ['anthropic', 'claude'];
+/** Frontmatter is injected into the system prompt, so markup in it is a prompt-injection seam. */
+const XML_TAG_PATTERN = /<\/?[a-zA-Z][^>]*>/;
+export function validateSkillName(name, path) {
+    if (name.length > 64) {
+        throw new Error(`[skills] Skill ${path} field "name" must be at most 64 characters.`);
+    }
+    if (XML_TAG_PATTERN.test(name)) {
+        throw new Error(`[skills] Skill ${path} field "name" must not contain XML tags.`);
+    }
+    if (!NAME_PATTERN.test(name)) {
+        throw new Error(`[skills] Skill ${path} field "name" "${name}" must match /^[a-z0-9]+(?:-[a-z0-9]+)*$/.`);
+    }
+    const reserved = RESERVED_NAME_WORDS.find((word) => name.includes(word));
+    if (reserved) {
+        throw new Error(`[skills] Skill ${path} field "name" must not contain the reserved word "${reserved}".`);
+    }
+}
+export function validateSkillDescription(description, path) {
+    if (codePointLength(description) > 1024) {
+        throw new Error(`[skills] Skill ${path} field "description" exceeds 1024 characters.`);
+    }
+    if (XML_TAG_PATTERN.test(description)) {
+        throw new Error(`[skills] Skill ${path} field "description" must not contain XML tags.`);
+    }
+}
+function codePointLength(value) {
+    return [...value].length;
+}
+function parseAllowedTools(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (Array.isArray(value)) {
+        const tools = value.map((v) => String(v).trim()).filter(Boolean);
+        return tools.length > 0 ? tools : undefined;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return undefined;
+        const tools = trimmed.includes(',')
+            ? trimmed.split(',').map((s) => s.trim()).filter(Boolean)
+            : trimmed.split(/\s+/).filter(Boolean);
+        return tools.length > 0 ? tools : undefined;
+    }
+    return undefined;
+}
+function parseMetadata(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+        return undefined;
+    const meta = {};
+    for (const [k, v] of entries) {
+        meta[k] = String(v);
+    }
+    return meta;
+}

package/dist/skills/wireAgentSkills.d.ts

@@ -1,3 +1,4 @@
+import type { FileSystem } from '../types/filesystem.js';
 import { type AnyTool } from '../types/effectTool.js';
 import type { PromptSection } from '../capabilities/index.js';
 import { type SkillWireAgent } from './collectSkills.js';
@@ -7,4 +8,4 @@ export interface WiredAgentSkills {
     tools: Record<string, AnyTool>;
     promptSections: PromptSection[];
 }
-export declare function wireAgentSkills(agent: SkillWireAgent): Promise<WiredAgentSkills | undefined>;
+export declare function wireAgentSkills(agent: SkillWireAgent, fs?: FileSystem): Promise<WiredAgentSkills | undefined>;

package/dist/skills/wireAgentSkills.js

@@ -1,10 +1,10 @@
 import { defineTool } from '../types/effectTool.js';
 import { collectRegisteredNames, prepareSkillStore, validateSkillAllowedTools, } from './collectSkills.js';
 import { SkillsCapability } from './SkillsCapability.js';
-export async function wireAgentSkills(agent) {
+export async function wireAgentSkills(agent, fs) {
     if (!agent.skills)
         return undefined;
-    const { store, skills } = await prepareSkillStore(agent.skills);
+    const { store, skills } = await prepareSkillStore(agent.skills, fs);
     validateSkillAllowedTools(skills, collectRegisteredNames(agent));
     const metas = await store.list();
     const capability = new SkillsCapability(store, metas);

package/dist/testing/mocks.d.ts

@@ -1,4 +1,4 @@
-import type { HarnessStreamPart, TurnHandle } from '../types/stream.js';
+import type { StreamPart, TurnHandle } from '../types/stream.js';
 import type { TurnResult } from '../types/channel.js';
 import type { Session } from '../types/session.js';
 import type { UserInputContent } from '../runtime/userInput.js';
@@ -13,8 +13,8 @@ export interface CreateMockRuntimeOptions {
     sessions?: Map<string, Session>;
     onRun?: (call: MockRuntimeRunCall) => void;
 }
-export declare function createMockTurnHandle(events: AsyncIterable<HarnessStreamPart>, settled?: TurnResult): TurnHandle;
+export declare function createMockTurnHandle(events: AsyncIterable<StreamPart>, settled?: TurnResult): TurnHandle;
 export declare function createMockSession(partial?: Partial<Session>): Session;
-type MockRuntimeEvents = HarnessStreamPart[] | AsyncIterable<HarnessStreamPart> | (() => never);
+type MockRuntimeEvents = StreamPart[] | AsyncIterable<StreamPart> | (() => never);
 export declare function createMockRuntime(parts: MockRuntimeEvents, options?: CreateMockRuntimeOptions): RuntimeLike;
 export {};