zidane 1.8.1 → 2.0.1

package/dist/index.js

@@ -1,34 +1,48 @@
 import {
   defineSkill
-} from "./chunk-CFLC2I7D.js";
+} from "./chunk-LVC7NQUZ.js";
+import {
+  toolResultToText
+} from "./chunk-MYWDHD7C.js";
 import {
   anthropic,
   cerebras,
   openai,
   openrouter
-} from "./chunk-3S377TS4.js";
+} from "./chunk-FRNFVKWW.js";
 import {
   defineHarness,
   noTools
-} from "./chunk-3RJOWJOJ.js";
+} from "./chunk-OVQ4N64O.js";
 import {
   createAgent,
   createInteractionTool,
+  createSkillsReadTool,
+  createSkillsRunScriptTool,
+  createSkillsUseTool,
   createSpawnTool,
   glob,
   spawn
-} from "./chunk-4N5ADW7A.js";
+} from "./chunk-PASFWG7S.js";
 import {
+  IMPLICITLY_ALLOWED_SKILL_TOOLS,
   buildCatalog,
+  createSkillActivationState,
   discoverSkills,
+  installAllowedToolsGate,
   interpolateShellCommands,
+  isToolAllowedByUnion,
+  matchesAllowedTool,
   mergeSkillsConfig,
+  parseAllowedToolPattern,
   parseSkillFile,
   resolveSkills,
+  validateResourcePath,
+  validateSkillForWrite,
   validateSkillName,
   writeSkillToDisk,
   writeSkillsToDisk
-} from "./chunk-4C6Y56CC.js";
+} from "./chunk-BCXXXJ3G.js";
 import {
   createDockerContext,
   createProcessContext,
@@ -36,8 +50,10 @@ import {
 } from "./chunk-SZA4FKW5.js";
 import {
   connectMcpServers,
-  normalizeMcpServers
-} from "./chunk-TBC6MSVK.js";
+  normalizeMcpBlocks,
+  normalizeMcpServers,
+  resultToString
+} from "./chunk-PJUUYBKF.js";
 import {
   createFileMapStore,
   createMemoryStore,
@@ -55,15 +71,16 @@ import {
   openaiCompat,
   toAnthropic,
   toOpenAI
-} from "./chunk-EC7IRWVS.js";
+} from "./chunk-LN4LLLHA.js";
 import {
   AgentAbortedError,
   AgentContextExceededError,
   AgentProviderError,
+  AgentToolNotAllowedError,
   CONTEXT_EXCEEDED_MESSAGE_PATTERNS,
   matchesContextExceeded,
   toTypedError
-} from "./chunk-FFFDQHMA.js";
+} from "./chunk-7JTBBZ2U.js";
 
 // src/tracing.ts
 function createTracingHooks(options) {
@@ -181,7 +198,9 @@ export {
   AgentAbortedError,
   AgentContextExceededError,
   AgentProviderError,
+  AgentToolNotAllowedError,
   CONTEXT_EXCEEDED_MESSAGE_PATTERNS,
+  IMPLICITLY_ALLOWED_SKILL_TOOLS,
   OpenAICompatHttpError,
   anthropic,
   autoDetectAndConvert,
@@ -198,6 +217,10 @@ export {
   createRemoteStore,
   createSandboxContext,
   createSession,
+  createSkillActivationState,
+  createSkillsReadTool,
+  createSkillsRunScriptTool,
+  createSkillsUseTool,
   createSpawnTool,
   createTracingHooks,
   defineHarness,
@@ -206,22 +229,31 @@ export {
   fromAnthropic,
   fromOpenAI,
   glob,
+  installAllowedToolsGate,
   interpolateShellCommands,
+  isToolAllowedByUnion,
   loadSession,
   mapOAIFinishReason,
+  matchesAllowedTool,
   matchesContextExceeded,
   mergeSkillsConfig,
   noTools,
+  normalizeMcpBlocks,
   normalizeMcpServers,
   openai,
   openaiCompat,
   openrouter,
+  parseAllowedToolPattern,
   parseSkillFile,
   resolveSkills,
+  resultToString,
   spawn,
   toAnthropic,
   toOpenAI,
   toTypedError,
+  toolResultToText,
+  validateResourcePath,
+  validateSkillForWrite,
   validateSkillName,
   writeSkillToDisk,
   writeSkillsToDisk,

package/dist/mcp.d.ts

@@ -1,5 +1,4 @@
 import 'hookable';
-export { M as McpConnection, p as McpServerConfig, ad as connectMcpServers, ap as normalizeMcpServers, ay as resultToString } from './agent-8QBOx4_0.js';
+export { M as McpConnection, q as McpServerConfig, at as connectMcpServers, aG as normalizeMcpBlocks, aH as normalizeMcpServers, aL as resultToString } from './agent-D-ZFMbSd.js';
 import '@modelcontextprotocol/sdk/client/index.js';
 import './types-BpvTmawk.js';
-import './types-CDI8Kmve.js';

package/dist/mcp.js

@@ -1,10 +1,12 @@
 import {
   connectMcpServers,
+  normalizeMcpBlocks,
   normalizeMcpServers,
   resultToString
-} from "./chunk-TBC6MSVK.js";
+} from "./chunk-PJUUYBKF.js";
 export {
   connectMcpServers,
+  normalizeMcpBlocks,
   normalizeMcpServers,
   resultToString
 };

package/dist/providers.d.ts

@@ -1,5 +1,4 @@
-export { i as AnthropicParams, j as CerebrasParams, a6 as OpenAICompatAuthHeader, a7 as OpenAICompatHttpError, a8 as OpenAICompatParams, r as OpenAIParams, s as OpenRouterParams, w as Provider, L as StreamCallbacks, Q as StreamOptions, U as ToolCall, _ as ToolResult, $ as ToolSpec, a1 as TurnResult, a9 as anthropic, ab as cerebras, ac as classifyOpenAICompatError, an as mapOAIFinishReason, aq as openai, ar as openaiCompat, as as openrouter } from './agent-8QBOx4_0.js';
+export { j as AnthropicParams, k as CerebrasParams, ai as OpenAICompatAuthHeader, aj as OpenAICompatHttpError, ak as OpenAICompatParams, s as OpenAIParams, t as OpenRouterParams, x as Provider, y as ProviderCapabilities, V as StreamCallbacks, X as StreamOptions, Z as ToolCall, a3 as ToolResult, a7 as ToolSpec, a9 as TurnResult, ap as anthropic, ar as cerebras, as as classifyOpenAICompatError, aE as mapOAIFinishReason, aI as openai, aJ as openaiCompat, aK as openrouter } from './agent-D-ZFMbSd.js';
 import 'hookable';
 import './types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';
-import './types-CDI8Kmve.js';

package/dist/providers.js

@@ -3,14 +3,14 @@ import {
   cerebras,
   openai,
   openrouter
-} from "./chunk-3S377TS4.js";
+} from "./chunk-FRNFVKWW.js";
 import {
   OpenAICompatHttpError,
   classifyOpenAICompatError,
   mapOAIFinishReason,
   openaiCompat
-} from "./chunk-EC7IRWVS.js";
-import "./chunk-FFFDQHMA.js";
+} from "./chunk-LN4LLLHA.js";
+import "./chunk-7JTBBZ2U.js";
 export {
   OpenAICompatHttpError,
   anthropic,

package/dist/session/sqlite.d.ts

@@ -1,8 +1,7 @@
-import { G as SessionStore } from '../agent-8QBOx4_0.js';
+import { K as SessionStore } from '../agent-D-ZFMbSd.js';
 import 'hookable';
 import '../types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';
-import '../types-CDI8Kmve.js';
 
 /**
  * SQLite session store using Bun's built-in bun:sqlite.

package/dist/session.d.ts

@@ -1,5 +1,4 @@
-export { n as CreateSessionOptions, a4 as FileMapAdapter, a5 as FileMapStoreOptions, R as RemoteStoreOptions, S as Session, y as SessionContentBlock, z as SessionData, E as SessionMessage, F as SessionRun, G as SessionStore, J as SessionTurn, aa as autoDetectAndConvert, af as createFileMapStore, ag as createMemoryStore, ah as createRemoteStore, ai as createSession, ak as fromAnthropic, al as fromOpenAI, am as loadSession, at as toAnthropic, au as toOpenAI } from './agent-8QBOx4_0.js';
+export { o as CreateSessionOptions, ag as FileMapAdapter, ah as FileMapStoreOptions, R as RemoteStoreOptions, S as Session, B as SessionContentBlock, D as SessionData, G as SessionMessage, J as SessionRun, K as SessionStore, L as SessionTurn, aq as autoDetectAndConvert, av as createFileMapStore, aw as createMemoryStore, ax as createRemoteStore, ay as createSession, aB as fromAnthropic, aC as fromOpenAI, aD as loadSession, aM as toAnthropic, aN as toOpenAI } from './agent-D-ZFMbSd.js';
 import 'hookable';
 import './types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';
-import './types-CDI8Kmve.js';

package/dist/session.js

@@ -11,8 +11,8 @@ import {
   fromOpenAI,
   toAnthropic,
   toOpenAI
-} from "./chunk-EC7IRWVS.js";
-import "./chunk-FFFDQHMA.js";
+} from "./chunk-LN4LLLHA.js";
+import "./chunk-7JTBBZ2U.js";
 export {
   autoDetectAndConvert,
   createFileMapStore,

package/dist/skills-use-C4KFVla0.d.ts

@@ -0,0 +1,66 @@
+import { $ as ToolDef, N as SkillConfig, al as SkillActivationState, d as AgentHooks } from './agent-D-ZFMbSd.js';
+import { Hookable } from 'hookable';
+
+declare const glob: ToolDef;
+
+/**
+ * `skills_read` tool — reads a bundled resource file from an active skill.
+ *
+ * Requires the skill to be active (model must have called `skills_use` first).
+ * Paths are validated against the skill's `baseDir` to prevent directory
+ * traversal. File I/O goes through `ctx.execution.readFile` so docker/sandbox
+ * execution contexts work identically to in-process.
+ */
+
+interface SkillsReadToolOptions {
+    catalog: readonly SkillConfig[];
+    state: SkillActivationState;
+}
+declare function createSkillsReadTool(options: SkillsReadToolOptions): ToolDef;
+
+/**
+ * `skills_run_script` tool — executes a script from an active skill's
+ * `scripts/` directory via the agent's execution context.
+ *
+ * Path is validated against the skill's `baseDir` and constrained to the
+ * `scripts/` subdirectory. Timeout is configurable via
+ * `SkillsConfig.scriptTimeoutMs` (default 60 s).
+ */
+
+interface SkillsRunScriptToolOptions {
+    catalog: readonly SkillConfig[];
+    state: SkillActivationState;
+    /** Script timeout in milliseconds. Default 60000. */
+    scriptTimeoutMs?: number;
+}
+declare function createSkillsRunScriptTool(options: SkillsRunScriptToolOptions): ToolDef;
+
+/**
+ * `skills_use` tool — activates a skill and returns its full instructions.
+ *
+ * Implements tier 2 of progressive disclosure per the Agent Skills spec.
+ * Body is frontmatter-stripped (the model gets the markdown only, wrapped in
+ * `<skill_content>` tags so the harness can identify it during context
+ * management). Shell-interpolation (`!` `` `cmd` ``) runs per-activation rather
+ * than once per agent, so values like `gh pr diff` reflect the current state.
+ */
+
+interface SkillsUseToolOptions {
+    /** Resolved skills catalog for this run. */
+    catalog: readonly SkillConfig[];
+    /** Per-agent activation state the tool mutates. */
+    state: SkillActivationState;
+    /** Agent hooks — used to fire `skills:activate` on first activation. */
+    hooks: Hookable<AgentHooks>;
+}
+/**
+ * Factory for `skills_use`. Auto-injected into the agent's tool set by the
+ * agent runtime when a non-empty skills catalog is available (unless
+ * `SkillsConfig.tool === false`).
+ *
+ * The tool schema's `name` property is `enum`-constrained to the resolved
+ * catalog so the LLM cannot hallucinate a skill that doesn't exist.
+ */
+declare function createSkillsUseTool(options: SkillsUseToolOptions): ToolDef;
+
+export { type SkillsReadToolOptions as S, type SkillsRunScriptToolOptions as a, type SkillsUseToolOptions as b, createSkillsReadTool as c, createSkillsRunScriptTool as d, createSkillsUseTool as e, glob as g };

package/dist/skills.d.ts

@@ -1,55 +1,231 @@
-import { S as SkillConfig, b as SkillsConfig } from './types-CDI8Kmve.js';
-export { a as SkillResource } from './types-CDI8Kmve.js';
+import { d as AgentHooks, al as SkillActivationState, N as SkillConfig, ao as SkillSource, an as SkillDiagnostic, T as SkillsConfig } from './agent-D-ZFMbSd.js';
+export { ad as ActivationVia, ae as ActiveSkill, af as DeactivationReason, am as SkillActivationStateOptions, Q as SkillResource, az as createSkillActivationState } from './agent-D-ZFMbSd.js';
+import { Hookable } from 'hookable';
 import { b as ExecutionContext, c as ExecutionHandle } from './types-BpvTmawk.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+
+/**
+ * `allowed-tools` enforcement middleware.
+ *
+ * Installed by the agent on `tool:gate` and `mcp:tool:gate`. Computes the
+ * union of `allowedTools` patterns across currently-active skills; blocks any
+ * tool call whose `displayName` is not in that union. The three injected
+ * skills tools (`skills_use` / `skills_read` / `skills_run_script`) are
+ * implicitly allowed so a skill declaring an allow-list cannot lock out the
+ * scaffolding that lets it run at all.
+ *
+ * The match target is `displayName` (wire / LLM-facing name), not the
+ * canonical name, because skill authors write allow-list entries to match
+ * what the model sees.
+ */
+
+/** Tools that are always allowed regardless of the active skills' allow-list. */
+declare const IMPLICITLY_ALLOWED_SKILL_TOOLS: readonly string[];
+/**
+ * Register `tool:gate` / `mcp:tool:gate` handlers that enforce the union of
+ * `allowedTools` across active skills.
+ *
+ * No-op when no active skill declares an allow-list (permissive default —
+ * matches the spec's "experimental" note for `allowed-tools`).
+ *
+ * Returns an `uninstall` fn. The agent calls this at run end to detach the
+ * handlers and prevent cross-run hook leaks.
+ */
+declare function installAllowedToolsGate(hooks: Hookable<AgentHooks>, state: SkillActivationState): () => void;
 
 /**
  * Skill catalog generation.
  *
- * Builds the system prompt section that discloses available skills
- * to the agent, following progressive disclosure (tier 1: name + description only).
+ * Builds the system prompt section that discloses available skills to the
+ * agent — tier 1 of progressive disclosure per the Agent Skills spec.
+ *
+ * The catalog's behavioral prose branches on which activation mechanism is
+ * active for the run:
+ *
+ * - When the `skills_use` tool is auto-injected (the default for a non-empty
+ *   catalog), the prose tells the model to call `skills_use` with the skill's
+ *   name. The agent returns a structured `<skill_content>` block.
+ * - When the skills tool is opted out (`SkillsConfig.tool: false`), the prose
+ *   falls back to the file-read pattern — the model reads `SKILL.md` itself
+ *   via its file-read tool.
  */
 
+interface BuildCatalogOptions {
+    /**
+     * When true (the default), the prose instructs the model to call
+     * `skills_use`. Set to false when `SkillsConfig.tool === false` so the
+     * system prompt matches the active activation mechanism.
+     */
+    skillsToolRegistered?: boolean;
+    /**
+     * Name of the tool the model should use to read `SKILL.md` files when
+     * `skillsToolRegistered` is false. Defaults to `'read_file'`.
+     */
+    readToolName?: string;
+}
 /**
  * Build the skill catalog XML and behavioral instructions for the system prompt.
+ */
+declare function buildCatalog(skills: SkillConfig[], optionsOrReadToolName?: BuildCatalogOptions | string): string;
+
+/**
+ * Strict validators for Agent Skills.
  *
- * @param skills - Resolved skills to include (already filtered for excluded)
- * @param readToolName - Tool name the agent should use to read skill files (default: 'read_file')
+ * Applied on the authoring path (`defineSkill`, `writeSkillToDisk`). Parser-time
+ * validation is intentionally lenient — see `parseSkillFile` for diagnostic collection.
  */
-declare function buildCatalog(skills: SkillConfig[], readToolName?: string): string;
+
+/**
+ * A single issue surfaced by skill-authoring validation.
+ * Distinct from `ValidationResult` in `tools/validation.ts` (tool-input JSON
+ * schema validation) — different domain, different module.
+ */
+interface SkillValidationIssue {
+    /** Stable machine-readable code for consumer matching. */
+    code: string;
+    /** Human-readable description. */
+    message: string;
+    /** Frontmatter field name the issue relates to, when applicable. */
+    field?: string;
+}
+interface SkillValidationResult {
+    valid: boolean;
+    errors: SkillValidationIssue[];
+}
+/**
+ * Validate a skill name per the spec:
+ * - 1–64 characters
+ * - Lowercase alphanumeric + hyphens only
+ * - Must not start or end with a hyphen
+ * - Must not contain consecutive hyphens
+ *
+ * The parent-directory match is validated separately (it requires knowing the
+ * skill's `location`, which this function does not).
+ */
+declare function validateSkillName(name: string): boolean;
+/**
+ * Strict validation for a skill that is about to be authored / written to disk.
+ * Rejects anything that would violate the spec. Use the lenient parser path
+ * (`parseSkillFile`) for loading third-party skills.
+ */
+declare function validateSkillForWrite(skill: SkillConfig): SkillValidationResult;
+/**
+ * Validate that `relPath` stays inside `baseDir` when resolved.
+ *
+ * Rejects:
+ * - Absolute paths (`/etc/passwd`, `C:\…`)
+ * - Parent traversal (`..` segments that escape baseDir)
+ * - Null-byte tricks
+ *
+ * Returns `{ valid: true, absolutePath }` on success or `{ valid: false, error }`
+ * with a human-readable reason.
+ */
+declare function validateResourcePath(relPath: string, baseDir: string): {
+    valid: true;
+    absolutePath: string;
+} | {
+    valid: false;
+    error: string;
+};
+/**
+ * Parse a single `allowed-tools` entry into its tool name + optional argument pattern.
+ *
+ * Examples:
+ * - `Read` → `{ tool: 'Read' }`
+ * - `Bash(git:*)` → `{ tool: 'Bash', argPrefix: 'git' }`
+ */
+declare function parseAllowedToolPattern(entry: string): {
+    tool: string;
+    argPrefix?: string;
+} | null;
+/**
+ * Check whether a tool call (identified by its wire/displayName and argument input)
+ * matches a skill's allow-list entry.
+ *
+ * Matching rules (Zidane's interpretation of the spec's unspecified syntax):
+ * - Exact match: displayName === pattern (no parens).
+ * - Prefix match: for `Tool(arg:*)`, displayName === 'Tool' AND **any** string
+ *   value in the input object starts with `arg`. This is intentionally
+ *   permissive: it doesn't depend on a convention about which property carries
+ *   the "command" (schemas vary across tools), and for the common
+ *   `shell({ command: 'git …' })` shape it behaves identically to a "primary
+ *   string" rule.
+ * - For tools whose inputs carry no string values, the arg-match returns false.
+ */
+declare function matchesAllowedTool(displayName: string, input: Record<string, unknown>, pattern: string): boolean;
+/**
+ * Test whether a tool call is allowed by the union of `allowedTools` across a set
+ * of active skills. Returns `true` when the union is empty (permissive default)
+ * OR when any entry matches.
+ */
+declare function isToolAllowedByUnion(displayName: string, input: Record<string, unknown>, union: readonly string[]): boolean;
 
 /**
  * Skill discovery and parsing.
  *
  * Scans filesystem directories for SKILL.md files following the
  * Agent Skills specification (agentskills.io/specification).
+ *
+ * Parsing is intentionally **lenient** — per the spec's client-implementation
+ * guide: warn, don't block. Diagnostics are attached to the returned
+ * SkillConfig for host UIs to surface; only unrecoverable errors (missing
+ * description, unparseable YAML) skip the skill entirely.
  */
 
-/**
- * Validate a skill name per the Agent Skills spec:
- * 1-64 chars, lowercase alphanumeric + hyphens, no leading/trailing/consecutive hyphens.
- */
-declare function validateSkillName(name: string): boolean;
 interface ParsedSkillFile {
     frontmatter: Record<string, unknown>;
     body: string;
+    diagnostics: SkillDiagnostic[];
 }
 /**
  * Parse a SKILL.md file into frontmatter + body.
- * Uses simple regex-based extraction (no external YAML lib needed for simple cases).
+ *
+ * Uses a simple regex-based YAML extractor that handles:
+ * - Flat key: value pairs
+ * - Quoted values
+ * - One-level nested maps (for `metadata:`)
+ * - Lenient recovery from unquoted-colon values (e.g.
+ *   `description: Use when: the user asks …`) via a quote-wrap retry.
  */
 declare function parseFrontmatter(content: string): ParsedSkillFile;
+interface ParseSkillOptions {
+    /** Source tag to attach to the returned SkillConfig. */
+    source?: SkillSource;
+}
 /**
- * Parse a SKILL.md file into a SkillConfig.
- * Returns null if the file is invalid (missing description).
+ * Parse a SKILL.md file into a SkillConfig (lenient).
+ *
+ * Returns `null` only when the skill is fundamentally unusable:
+ * - The file is missing
+ * - The description is absent (required by spec for disclosure)
+ *
+ * All other issues are surfaced as `SkillConfig.diagnostics` with severity
+ * `warning`. Deprecated top-level fields (`paths`, `model`, `thinking`) are
+ * auto-migrated into `metadata['zidane.*']`.
  */
-declare function parseSkillFile(filePath: string): Promise<SkillConfig | null>;
-declare function getDefaultScanPaths(): string[];
+declare function parseSkillFile(filePath: string, options?: ParseSkillOptions): Promise<SkillConfig | null>;
+/** A scan path paired with the source tag that should be attached to any skills found in it. */
+interface SourcedScanPath {
+    path: string;
+    source: SkillSource;
+}
 /**
- * Discover skills from filesystem paths.
+ * Return the default scan paths tagged by source. Project-scope paths come
+ * first; their skills therefore win on name collisions against user-scope
+ * skills (first-found wins in discovery).
+ */
+declare function getDefaultScanPaths(): SourcedScanPath[];
+/**
+ * Infer a source tag for a user-provided scan path.
+ * Paths under `$HOME` are treated as 'user'; everything else as 'project'.
+ */
+declare function inferSource(path: string): SkillSource;
+/**
+ * Discover skills from sourced filesystem paths.
  * Each path is scanned for subdirectories containing SKILL.md.
- * Later paths have lower priority (earlier skill with same name wins).
+ * Earlier paths have higher priority (first-found wins on name collision).
  */
-declare function discoverSkills(paths: string[]): Promise<SkillConfig[]>;
+declare function discoverSkills(paths: SourcedScanPath[]): Promise<SkillConfig[]>;
 
 /**
  * Shell interpolation for skill instructions.
@@ -84,12 +260,11 @@ declare function interpolateShellCommands(instructions: string, execution: Execu
 
 /**
  * Resolve all skills from a SkillsConfig:
- * 1. Write dynamic skills (config.write) to a temp directory
- * 2. Discover skills from scan paths (defaults + config.scan + written dir)
- * 3. Filter out exclude skills
  *
- * Written skills are materialized as proper SKILL.md files on disk,
- * so they participate in discovery like any other filesystem skill.
+ * 1. Materialize `config.write` entries to a temp directory, tagged as `inline`
+ * 2. Combine with default + user-provided scan paths (project-first, user-next)
+ * 3. Run lenient discovery
+ * 4. Apply filters: `exclude`, `enabled` allowlist, optional project-skill trust gate
  */
 declare function resolveSkills(config: SkillsConfig): Promise<SkillConfig[]>;
 /**
@@ -102,15 +277,21 @@ declare function mergeSkillsConfig(harness?: SkillsConfig, agent?: SkillsConfig)
 /**
  * Skill writer — materializes inline SkillConfig objects to disk as proper
  * SKILL.md files so they participate fully in the filesystem-based skill system.
+ *
+ * Strict-validates each skill before writing (see `validateSkillForWrite`).
  */
 
 /**
- * Write a SkillConfig to disk as a proper skill directory with SKILL.md.
+ * Write a `SkillConfig` to disk as a proper skill directory with SKILL.md.
  * Returns the path to the written SKILL.md file.
+ *
+ * Throws if the skill fails `validateSkillForWrite` — the authoring path is
+ * strict on purpose. For loading third-party skills, use `parseSkillFile`
+ * directly (lenient).
  */
 declare function writeSkillToDisk(skill: SkillConfig, targetDir: string): string;
 /**
- * Write multiple SkillConfig objects to a target directory.
+ * Write multiple `SkillConfig` objects to a target directory.
  * Each skill gets its own subdirectory with a SKILL.md file.
  * Returns the target directory path (for use as a scan path).
  */
@@ -118,8 +299,12 @@ declare function writeSkillsToDisk(skills: SkillConfig[], targetDir: string): st
 
 /**
  * Define an inline skill configuration.
- * Convenience wrapper for type safety — returns the config as-is.
+ *
+ * Strict-validates at author-time — throws if the config would be rejected by
+ * `writeSkillToDisk` or the spec. Source defaults to `'inline'`.
  */
-declare function defineSkill(config: SkillConfig): SkillConfig;
+declare function defineSkill(config: Omit<SkillConfig, 'source'> & {
+    source?: SkillConfig['source'];
+}): SkillConfig;
 
-export { SkillConfig, SkillsConfig, buildCatalog, defineSkill, discoverSkills, getDefaultScanPaths, interpolateShellCommands, mergeSkillsConfig, parseFrontmatter, parseSkillFile, resolveSkills, validateSkillName, writeSkillToDisk, writeSkillsToDisk };
+export { IMPLICITLY_ALLOWED_SKILL_TOOLS, SkillActivationState, SkillConfig, SkillDiagnostic, SkillSource, type SkillValidationIssue, type SkillValidationResult, SkillsConfig, type SourcedScanPath, buildCatalog, defineSkill, discoverSkills, getDefaultScanPaths, inferSource, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, matchesAllowedTool, mergeSkillsConfig, parseAllowedToolPattern, parseFrontmatter, parseSkillFile, resolveSkills, validateResourcePath, validateSkillForWrite, validateSkillName, writeSkillToDisk, writeSkillsToDisk };

package/dist/skills.js

@@ -1,29 +1,48 @@
 import {
   defineSkill
-} from "./chunk-CFLC2I7D.js";
+} from "./chunk-LVC7NQUZ.js";
 import {
+  IMPLICITLY_ALLOWED_SKILL_TOOLS,
   buildCatalog,
+  createSkillActivationState,
   discoverSkills,
   getDefaultScanPaths,
+  inferSource,
+  installAllowedToolsGate,
   interpolateShellCommands,
+  isToolAllowedByUnion,
+  matchesAllowedTool,
   mergeSkillsConfig,
+  parseAllowedToolPattern,
   parseFrontmatter,
   parseSkillFile,
   resolveSkills,
+  validateResourcePath,
+  validateSkillForWrite,
   validateSkillName,
   writeSkillToDisk,
   writeSkillsToDisk
-} from "./chunk-4C6Y56CC.js";
+} from "./chunk-BCXXXJ3G.js";
+import "./chunk-7JTBBZ2U.js";
 export {
+  IMPLICITLY_ALLOWED_SKILL_TOOLS,
   buildCatalog,
+  createSkillActivationState,
   defineSkill,
   discoverSkills,
   getDefaultScanPaths,
+  inferSource,
+  installAllowedToolsGate,
   interpolateShellCommands,
+  isToolAllowedByUnion,
+  matchesAllowedTool,
   mergeSkillsConfig,
+  parseAllowedToolPattern,
   parseFrontmatter,
   parseSkillFile,
   resolveSkills,
+  validateResourcePath,
+  validateSkillForWrite,
   validateSkillName,
   writeSkillToDisk,
   writeSkillsToDisk

package/dist/{spawn-jjxPcNcH.d.ts → spawn-RoqpjYLZ.d.ts}

@@ -1,4 +1,4 @@
-import { V as ToolContext, W as ToolDef, o as HarnessConfig, h as AgentStats } from './agent-8QBOx4_0.js';
+import { _ as ToolContext, $ as ToolDef, p as HarnessConfig, h as AgentStats } from './agent-D-ZFMbSd.js';
 
 /**
  * Interaction tool — lets the agent request structured input from the outside world.

package/dist/tools.d.ts

@@ -1,11 +1,10 @@
-export { g as glob } from './glob-Bo0GAiKk.js';
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-jjxPcNcH.js';
-import { W as ToolDef } from './agent-8QBOx4_0.js';
+export { S as SkillsReadToolOptions, a as SkillsRunScriptToolOptions, b as SkillsUseToolOptions, c as createSkillsReadTool, d as createSkillsRunScriptTool, e as createSkillsUseTool, g as glob } from './skills-use-C4KFVla0.js';
+export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-RoqpjYLZ.js';
+import { $ as ToolDef } from './agent-D-ZFMbSd.js';
 export { V as ValidationResult, v as validateToolArgs } from './validation-DOY_k7lW.js';
 import 'hookable';
 import './types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';
-import './types-CDI8Kmve.js';
 
 declare const listFiles: ToolDef;