@vibesdotdev/tools 0.0.0-stage → 1.0.0-rc.3

package/dist/kinds/tool.d.ts

@@ -0,0 +1,239 @@
+/**
+ * Tool Kind Definition
+ *
+ * Defines the tool asset type for runtime registration.
+ * Tools are executable actions invoked via MCP, CLI, or workers.
+ *
+ * Tools receive the runtime directly and query for what they need:
+ *   const api = await runtime.query('api/client').resolve();
+ *   const pm = await runtime.context('pm');
+ */
+import type { KindContext } from '@vibesdotdev/kernel/schemas/kind';
+import type { RuntimeScope } from '@vibesdotdev/kernel/schemas/scope';
+import type { VibesRuntime } from '@vibesdotdev/kernel/api/runtime';
+import type { RuntimeDescriptor } from '@vibesdotdev/kernel/schemas/descriptor';
+import type { ToolCallContext } from '@vibesdotdev/kernel/schemas/tool-call';
+import { type ToolAssetDescriptor } from '../schemas/runtime/descriptors.ts';
+import { type ToolImplementationBinding } from './schemas/tool.ts';
+import type { ToolImplementation, ToolExecutionInput, ToolExecutionResult } from './schemas/tool.ts';
+export type { ToolImplementation, ToolExecuteFunction, ToolExecutionInput, ToolExecutionResult } from './schemas/tool.ts';
+export { ToolExecutionInputSchema, ToolJsonValueSchema } from './schemas/tool.ts';
+/**
+ * Default tool implementation - used when no specific implementation is registered.
+ * Throws on execute to ensure proper implementations are provided.
+ */
+declare class DefaultToolImplementation implements ToolImplementation {
+    readonly id: string;
+    readonly descriptor: ToolAssetDescriptor;
+    constructor(descriptor: RuntimeDescriptor, _context: KindContext);
+    execute(_input: ToolExecutionInput, _runtime: VibesRuntime, _ctx: ToolCallContext): Promise<ToolExecutionResult>;
+}
+/**
+ * A purpose list does not hide a tool. `restrictPurpose` is the lock.
+ * When locked, `projection` and `mcp` satisfy each other.
+ */
+export declare function toolPurposeAllows(descriptor: {
+    purpose?: readonly string[];
+    restrictPurpose?: boolean;
+}, requested: string | undefined): boolean;
+/**
+ * Tool kind resolution logic.
+ * Selects the best tool from candidates based on hardware and purpose.
+ */
+declare function isToolEligible(descriptor: RuntimeDescriptor, requestedScope: {
+    purpose?: string;
+}, executionScope: {
+    hardware?: RuntimeScope['hardware'];
+}): boolean;
+/**
+ * The kind's eligibility rule for a purpose a caller requests for one call
+ * (`vibes tools list|run --purpose`), on a host with `hardware`. The host's
+ * declared purpose is neither consulted nor patched (rc02-rc03 §2.3): the
+ * request is an argument, the declaration stays the host's.
+ */
+export declare function toolEligibleForPurpose(descriptor: RuntimeDescriptor, purpose: string, hardware: RuntimeScope['hardware']): boolean;
+/** Eligibility is applied by Runtime before ranking, including mounted candidates. */
+declare function resolveTool(candidates: RuntimeDescriptor[]): RuntimeDescriptor | undefined;
+/**
+ * Project-local tools: `.vibes/tools/*.descriptor.ts` in the bound
+ * workspace's declared packages, found by the kernel's one discovery pass
+ * (rc02-rc03 §2.5). Each file default-exports its descriptor and exports
+ * `execute` beside it.
+ */
+export declare const LOCAL_TOOL_DISCOVERY_PATTERNS: readonly [".vibes/tools/*.descriptor.ts"];
+export interface LocalToolModule {
+    readonly execute?: ToolImplementation['execute'];
+    readonly default?: {
+        readonly execute?: ToolImplementation['execute'];
+    };
+}
+/**
+ * The implementation a local tool module carries inline: its `execute`
+ * export (or its default export's). A module with none still registers its
+ * descriptor, and running it fails naming the file and the export it lacks.
+ * One rule for discovery and for `vibes tools scan --load`.
+ */
+export declare function localToolImplementation(module: LocalToolModule, descriptor: RuntimeDescriptor, file: string): ToolImplementation;
+/**
+ * Tool kind definition for runtime registration.
+ *
+ * Tools no longer declare context dependencies - they query the runtime
+ * directly for what they need at execution time.
+ */
+export declare const toolKind: {
+    id: string;
+    descriptorSchema: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        hardware: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        priority: import("zod").ZodOptional<import("zod").ZodNumber>;
+        capabilityId: import("zod").ZodOptional<import("zod").ZodString>;
+        requiredContext: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        optionalContext: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        config: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        retention: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+            maxAgeDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+            maxEntries: import("zod").ZodOptional<import("zod").ZodNumber>;
+            maxBytes: import("zod").ZodOptional<import("zod").ZodNumber>;
+            cascadeFrom: import("zod").ZodOptional<import("zod").ZodString>;
+            ageField: import("zod").ZodOptional<import("zod").ZodString>;
+            reason: import("zod").ZodString;
+            enforcedBy: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>]>>;
+        purpose: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+            agent: "agent";
+            worker: "worker";
+            mcp: "mcp";
+            direct: "direct";
+            projection: "projection";
+        }>>>;
+        restrictPurpose: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        category: import("zod").ZodOptional<import("zod").ZodString>;
+        subcategory: import("zod").ZodOptional<import("zod").ZodString>;
+        aliases: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        permissions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        requiresApproval: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        approval: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodPipe<import("zod").ZodObject<{
+            channel: import("zod").ZodString;
+            correlation: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodString>>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodTransform<{
+            channel: string;
+            correlation?: Record<string, string> | undefined;
+        }, {
+            channel: string;
+            correlation?: Record<string, string | undefined> | undefined;
+        }>>, import("zod").ZodObject<{
+            config: import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                field: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>]>>;
+        capability: import("zod").ZodOptional<import("zod").ZodObject<{
+            scopes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            samplingIntent: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            tier: import("zod").ZodEnum<{
+                0: "0";
+                1: "1";
+                3: "3";
+                "2a": "2a";
+                "2b": "2b";
+            }>;
+            egress: import("zod").ZodOptional<import("zod").ZodObject<{
+                anyHost: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                hosts: import("zod").ZodArray<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>>;
+        safety: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"read">, import("zod").ZodLiteral<"write">, import("zod").ZodLiteral<"execute">, import("zod").ZodObject<{
+            category: import("zod").ZodEnum<{
+                read: "read";
+                write: "write";
+                execute: "execute";
+            }>;
+            idempotent: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            destructive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            openWorld: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>]>>;
+        reads: import("zod").ZodOptional<import("zod").ZodEnum<{
+            index: "index";
+            "working-tree": "working-tree";
+        }>>;
+        mcpDescription: import("zod").ZodOptional<import("zod").ZodString>;
+        mcp: import("zod").ZodOptional<import("zod").ZodObject<{
+            resource: import("zod").ZodOptional<import("zod").ZodObject<{
+                uri: import("zod").ZodString;
+                name: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                cacheable: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                subscriptions: import("zod").ZodOptional<import("zod").ZodObject<{
+                    supported: import("zod").ZodBoolean;
+                    events: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>;
+            resources: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                uri: import("zod").ZodString;
+                name: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                cacheable: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                subscriptions: import("zod").ZodOptional<import("zod").ZodObject<{
+                    supported: import("zod").ZodBoolean;
+                    events: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>>;
+            resourceTemplates: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                uriTemplate: import("zod").ZodString;
+                name: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                cacheable: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                subscriptions: import("zod").ZodOptional<import("zod").ZodObject<{
+                    supported: import("zod").ZodBoolean;
+                    events: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>>>;
+            promptIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strip>>;
+        examples: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            input: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            output: import("zod").ZodOptional<import("zod").ZodUnknown>;
+            notes: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>>;
+        usageGuidance: import("zod").ZodOptional<import("zod").ZodObject<{
+            when: import("zod").ZodOptional<import("zod").ZodString>;
+            whenNot: import("zod").ZodOptional<import("zod").ZodString>;
+            alternatives: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                tool: import("zod").ZodString;
+                scenario: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>>;
+            commonPatterns: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strip>>;
+        kind: import("zod").ZodLiteral<"tools/tool">;
+        schemas: import("zod").ZodObject<{
+            events: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodInstanceOf<import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>>>>;
+            defaultAction: import("zod").ZodOptional<import("zod").ZodString>;
+            actionSafety: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodEnum<{
+                read: "read";
+                write: "write";
+                execute: "execute";
+            }>>>;
+            input: import("zod").ZodUnion<readonly [import("zod").ZodInstanceOf<import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>>, import("zod").ZodPipe<import("zod").ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, import("zod/v4/core").$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>, import("zod").ZodTransform<import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>, import("@vibesdotdev/kernel/schemas/json").JsonObject>>]>;
+            output: import("zod").ZodUnion<readonly [import("zod").ZodInstanceOf<import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>>, import("zod").ZodPipe<import("zod").ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, import("zod/v4/core").$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>, import("zod").ZodTransform<import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>, import("@vibesdotdev/kernel/schemas/json").JsonObject>>]>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    defaultImplementation: typeof DefaultToolImplementation;
+    validateImplementation: (impl: ToolImplementationBinding) => boolean;
+    resolve: typeof resolveTool;
+    isEligible: typeof isToolEligible;
+    contexts: never[];
+    discoveryPatterns: readonly [".vibes/tools/*.descriptor.ts"];
+    discoveredImplementation: typeof localToolImplementation;
+};
+export type { ToolDescriptor } from './schemas/tool.ts';
+export type { VibesRuntime } from '@vibesdotdev/kernel/api/runtime';
+export type { ToolCallContext, ToolProgress } from '@vibesdotdev/kernel/schemas/tool-call';
+//# sourceMappingURL=tool.d.ts.map

package/dist/kinds/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/kinds/tool.ts"],"names":[],"mappings":"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"}

package/dist/kinds/tool.js

@@ -0,0 +1,127 @@
+/**
+ * Tool Kind Definition
+ *
+ * Defines the tool asset type for runtime registration.
+ * Tools are executable actions invoked via MCP, CLI, or workers.
+ *
+ * Tools receive the runtime directly and query for what they need:
+ *   const api = await runtime.query('api/client').resolve();
+ *   const pm = await runtime.context('pm');
+ */
+import { CapabilityError } from '@vibesdotdev/kernel';
+import { PROJECT_TOOLS_DIR } from '@vibesdotdev/paths';
+import { ToolDescriptorSchema } from "../schemas/runtime/descriptors.js";
+import { ToolImplementationBindingSchema } from "./schemas/tool.js";
+export { ToolExecutionInputSchema, ToolJsonValueSchema } from "./schemas/tool.js";
+function isToolAssetDescriptor(descriptor) {
+    return (descriptor.kind === 'tools/tool' && 'schemas' in descriptor && descriptor.id != null);
+}
+/**
+ * Default tool implementation - used when no specific implementation is registered.
+ * Throws on execute to ensure proper implementations are provided.
+ */
+class DefaultToolImplementation {
+    id;
+    descriptor;
+    constructor(descriptor, _context) {
+        if (!isToolAssetDescriptor(descriptor)) {
+            throw new Error(`Invalid tools/tool descriptor '${descriptor.id ?? 'unknown'}'`);
+        }
+        this.descriptor = descriptor;
+        this.id = this.descriptor.id;
+    }
+    execute(_input, _runtime, _ctx) {
+        throw new Error(`No implementation registered for tool '${this.id}'. ` +
+            `Register an implementation via runtime.registerLoader('tools/tool', '${this.id}', loader).`);
+    }
+}
+/** `projection` is the foreign-host catalog. MCP is that same surface. */
+const PROJECTION_PURPOSES = new Set(['projection', 'mcp']);
+/**
+ * A purpose list does not hide a tool. `restrictPurpose` is the lock.
+ * When locked, `projection` and `mcp` satisfy each other.
+ */
+export function toolPurposeAllows(descriptor, requested) {
+    if (!requested || !descriptor.restrictPurpose)
+        return true;
+    const declared = descriptor.purpose;
+    if (!declared?.length)
+        return true;
+    if (declared.includes(requested))
+        return true;
+    return (PROJECTION_PURPOSES.has(requested) &&
+        declared.some((purpose) => PROJECTION_PURPOSES.has(purpose)));
+}
+/**
+ * Tool kind resolution logic.
+ * Selects the best tool from candidates based on hardware and purpose.
+ */
+function isToolEligible(descriptor, requestedScope, executionScope) {
+    if (!isToolAssetDescriptor(descriptor))
+        return false;
+    return ((!descriptor.hardware?.length || (executionScope.hardware !== undefined && descriptor.hardware.includes(executionScope.hardware))) &&
+        toolPurposeAllows(descriptor, requestedScope.purpose));
+}
+/**
+ * The kind's eligibility rule for a purpose a caller requests for one call
+ * (`vibes tools list|run --purpose`), on a host with `hardware`. The host's
+ * declared purpose is neither consulted nor patched (rc02-rc03 §2.3): the
+ * request is an argument, the declaration stays the host's.
+ */
+export function toolEligibleForPurpose(descriptor, purpose, hardware) {
+    return isToolEligible(descriptor, { purpose }, { hardware });
+}
+/** Eligibility is applied by Runtime before ranking, including mounted candidates. */
+function resolveTool(candidates) {
+    const tools = candidates.filter(isToolAssetDescriptor);
+    return tools.find((descriptor) => descriptor.hardware?.length) ?? tools[0];
+}
+/**
+ * Project-local tools: `.vibes/tools/*.descriptor.ts` in the bound
+ * workspace's declared packages, found by the kernel's one discovery pass
+ * (rc02-rc03 §2.5). Each file default-exports its descriptor and exports
+ * `execute` beside it.
+ */
+export const LOCAL_TOOL_DISCOVERY_PATTERNS = [`${PROJECT_TOOLS_DIR}/*.descriptor.ts`];
+/**
+ * The implementation a local tool module carries inline: its `execute`
+ * export (or its default export's). A module with none still registers its
+ * descriptor, and running it fails naming the file and the export it lacks.
+ * One rule for discovery and for `vibes tools scan --load`.
+ */
+export function localToolImplementation(module, descriptor, file) {
+    const execute = module.execute ?? module.default?.execute;
+    if (execute != null) {
+        return { execute };
+    }
+    return {
+        async execute() {
+            throw new CapabilityError(`Local tool "${descriptor.id}" is registered but ${file} exports no execute().`, 'UNAVAILABLE', {
+                reason: 'tool-execute-absent',
+                recoveryHint: 'Export async function execute(input, runtime, ctx) from the descriptor module.',
+                details: { toolId: descriptor.id, file }
+            });
+        }
+    };
+}
+/**
+ * Tool kind definition for runtime registration.
+ *
+ * Tools no longer declare context dependencies - they query the runtime
+ * directly for what they need at execution time.
+ */
+export const toolKind = {
+    id: 'tools/tool',
+    descriptorSchema: ToolDescriptorSchema,
+    defaultImplementation: DefaultToolImplementation,
+    // Two implementation shapes are valid (see execution/invoke.ts): the
+    // canonical `{ execute }` object and a bare callable execute function,
+    // which is how most first-party tool modules default-export themselves.
+    validateImplementation: (impl) => ToolImplementationBindingSchema.safeParse(impl).success,
+    resolve: resolveTool,
+    isEligible: isToolEligible,
+    contexts: [], // Tools query runtime directly, no pre-resolved contexts
+    discoveryPatterns: LOCAL_TOOL_DISCOVERY_PATTERNS,
+    discoveredImplementation: localToolImplementation
+};
+//# sourceMappingURL=tool.js.map

package/dist/kinds/tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.js","sourceRoot":"","sources":["../../src/kinds/tool.ts"],"names":[],"mappings":"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"}

package/dist/local/ensure-local-tools.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Project-local tools (`.vibes/tools/*.descriptor.ts`).
+ *
+ * The kernel's one discovery pass loads them (rc02-rc03 §2.5): the
+ * `tools/tool` kind declares the `.vibes/tools` pattern and binds each file's
+ * inline `execute`, in the bound workspace's declared packages, at boot and
+ * again on every reload generation. Nothing here scans, walks or reads the
+ * cwd: this module reports what that pass registered, from the runtime's own
+ * discovery record, so list/run/inspect and MCP can tag and explain local
+ * tools. `vibes tools scan --load` remains the explicit re-scan through the
+ * filesystem tool provider.
+ */
+import { type RuntimeRef, type VibesRuntime } from '@vibesdotdev/kernel';
+import type { ToolProviderInterface } from '../interfaces/schemas/provider.ts';
+import type { ToolAssetDescriptor as ToolDescriptor } from '../schemas/runtime/descriptors.ts';
+/**
+ * - `loaded`: discovery registered at least one tool from `.vibes/tools`;
+ * - `none`: it registered none (no `.vibes/tools` files in the bound
+ *   workspace, or a host that discovers nothing: a literal composition, or
+ *   one bound to no workspace).
+ */
+export type LocalToolsStatus = 'loaded' | 'none';
+export interface LocalToolsReport {
+    status: LocalToolsStatus;
+    /** Tool ids discovery registered from `.vibes/tools`. */
+    toolIds: string[];
+    /** The `.vibes/tools` directories those tools came from. */
+    scannedPaths: string[];
+    /** Human lines for stderr (empty when there is nothing to say). */
+    notices: string[];
+}
+/**
+ * The project-local tools this host's discovery pass registered. A host that
+ * discovered none reports `none`; it is not an error, and nothing falls back
+ * to a scan.
+ */
+export declare function localToolsOf(runtime: Pick<VibesRuntime, 'discovered'>): LocalToolsReport;
+export declare function emitLocalToolsNotices(report: Pick<LocalToolsReport, 'notices'>, target?: RuntimeRef | {
+    warn: (line: string) => void;
+} | {
+    log: (line: string) => void;
+}): void;
+/** Expand bare ↔ `local:` aliases for membership tests. */
+export declare function localToolIdSet(toolIds: readonly string[]): Set<string>;
+/** True when `toolId` (or its `local:` alias) is one of the project-local `toolIds`. */
+export declare function isLocalToolId(toolId: string, toolIds: readonly string[]): boolean;
+/**
+ * Register descriptors and lazy source loaders from a resolved tool provider
+ * into `tools/tool`: `vibes tools scan --load`'s explicit re-scan. Each loader
+ * binds the module's inline implementation by the kind's own rule
+ * (`localToolImplementation`), the one discovery uses.
+ */
+export declare function registerLocalToolsIntoRuntime(runtime: Pick<VibesRuntime, 'hasKind' | 'registerDescriptor' | 'registerLoader'>, tools: ToolDescriptor[], provider: ToolProviderInterface): Promise<{
+    loaders: number;
+}>;
+//# sourceMappingURL=ensure-local-tools.d.ts.map

package/dist/local/ensure-local-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure-local-tools.d.ts","sourceRoot":"","sources":["../../src/local/ensure-local-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAmB,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAE1F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAE/E,OAAO,KAAK,EAAE,mBAAmB,IAAI,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAE/F;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEjD,MAAM,WAAW,gBAAgB;IAChC,MAAM,EAAE,gBAAgB,CAAC;IACzB,yDAAyD;IACzD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,4DAA4D;IAC5D,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,mEAAmE;IACnE,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAQD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,YAAY,CAAC,GAAG,gBAAgB,CAcxF;AAED,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,CAAC,EACzC,MAAM,CAAC,EAAE,UAAU,GAAG;IAAE,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GAAG;IAAE,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GACtF,IAAI,CAmBN;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAatE;AAED,wFAAwF;AACxF,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAGjF;AAED;;;;;GAKG;AACH,wBAAsB,6BAA6B,CAClD,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,oBAAoB,GAAG,gBAAgB,CAAC,EAChF,KAAK,EAAE,cAAc,EAAE,EACvB,QAAQ,EAAE,qBAAqB,GAC7B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAyB9B"}

package/dist/local/ensure-local-tools.js

@@ -0,0 +1,124 @@
+/**
+ * Project-local tools (`.vibes/tools/*.descriptor.ts`).
+ *
+ * The kernel's one discovery pass loads them (rc02-rc03 §2.5): the
+ * `tools/tool` kind declares the `.vibes/tools` pattern and binds each file's
+ * inline `execute`, in the bound workspace's declared packages, at boot and
+ * again on every reload generation. Nothing here scans, walks or reads the
+ * cwd: this module reports what that pass registered, from the runtime's own
+ * discovery record, so list/run/inspect and MCP can tag and explain local
+ * tools. `vibes tools scan --load` remains the explicit re-scan through the
+ * filesystem tool provider.
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { getRuntimeStdio } from '@vibesdotdev/kernel';
+import { PROJECT_TOOLS_DIR } from '@vibesdotdev/paths';
+import { localToolImplementation } from "../kinds/tool.js";
+const LOCAL_TOOLS_SEGMENT = `/${PROJECT_TOOLS_DIR}/`;
+function directoryOf(file) {
+    return file.slice(0, file.lastIndexOf('/'));
+}
+/**
+ * The project-local tools this host's discovery pass registered. A host that
+ * discovered none reports `none`; it is not an error, and nothing falls back
+ * to a scan.
+ */
+export function localToolsOf(runtime) {
+    const local = runtime
+        .discovered('tools/tool')
+        .filter((entry) => entry.file.replace(/\\/g, '/').includes(LOCAL_TOOLS_SEGMENT));
+    if (local.length === 0)
+        return { status: 'none', toolIds: [], scannedPaths: [], notices: [] };
+    const toolIds = local.map((entry) => entry.id).sort();
+    const scannedPaths = [...new Set(local.map((entry) => directoryOf(entry.file)))].sort();
+    const from = scannedPaths.length === 1 ? scannedPaths[0] : `${scannedPaths.length} paths`;
+    return {
+        status: 'loaded',
+        toolIds,
+        scannedPaths,
+        notices: [`Loaded ${toolIds.length} local tool(s) from ${from}.`]
+    };
+}
+export function emitLocalToolsNotices(report, target) {
+    if (report.notices.length === 0 || !target)
+        return;
+    if ('warn' in target) {
+        for (const line of report.notices) {
+            target.warn(line);
+        }
+        return;
+    }
+    if ('log' in target) {
+        for (const line of report.notices) {
+            target.log(line);
+        }
+        return;
+    }
+    void getRuntimeStdio(target).then((stdio) => {
+        for (const line of report.notices) {
+            stdio.write('stderr', `${line}\n`);
+        }
+    });
+}
+/** Expand bare ↔ `local:` aliases for membership tests. */
+export function localToolIdSet(toolIds) {
+    const set = new Set();
+    for (const id of toolIds) {
+        if (!id)
+            continue;
+        set.add(id);
+        if (id.startsWith('local:')) {
+            const bare = id.slice('local:'.length);
+            if (bare)
+                set.add(bare);
+        }
+        else {
+            set.add(`local:${id}`);
+        }
+    }
+    return set;
+}
+/** True when `toolId` (or its `local:` alias) is one of the project-local `toolIds`. */
+export function isLocalToolId(toolId, toolIds) {
+    if (toolIds.length === 0)
+        return false;
+    return localToolIdSet(toolIds).has(toolId);
+}
+/**
+ * Register descriptors and lazy source loaders from a resolved tool provider
+ * into `tools/tool`: `vibes tools scan --load`'s explicit re-scan. Each loader
+ * binds the module's inline implementation by the kind's own rule
+ * (`localToolImplementation`), the one discovery uses.
+ */
+export async function registerLocalToolsIntoRuntime(runtime, tools, provider) {
+    if (!runtime.hasKind('tools/tool')) {
+        throw new Error('Cannot load local tools: tools/tool kind is not registered. ' +
+            'Register the tools plugin before scan --load.');
+    }
+    let loaders = 0;
+    for (const tool of tools) {
+        if (!tool?.id)
+            continue;
+        runtime.registerDescriptor('tools/tool', tool);
+        const sourcePath = provider.getToolSourcePath?.(tool.id);
+        if (sourcePath) {
+            runtime.registerLoader('tools/tool', tool.id, async () => {
+                // SAFETY: Discovered local tool module is dynamically imported and conforms to LocalToolModule shape.
+                const mod = (await import(__rewriteRelativeImportExtension(sourcePath)));
+                return {
+                    impl: localToolImplementation(mod, tool, sourcePath)
+                };
+            });
+            loaders += 1;
+        }
+    }
+    return { loaders };
+}
+//# sourceMappingURL=ensure-local-tools.js.map

package/dist/local/ensure-local-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure-local-tools.js","sourceRoot":"","sources":["../../src/local/ensure-local-tools.ts"],"names":[],"mappings":"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"}

package/dist/local/extract-ex-example.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Parse tools.authoring `Ex:` payloads from mcpDescription.
+ *
+ * Convention (docs + init scaffold): a single-line mcpDescription ends with
+ * `Ex: {action:"echo",message:"hello"}.` so CLI preflight and agents can
+ * recover a workable --input without inventing schema fields.
+ *
+ * Pure — no runtime, no FS. Shared by tools/cli run preflight and init tests.
+ */
+/**
+ * Pull a JSON-stringified example object from an mcpDescription Ex: clause.
+ * Returns undefined when no parseable object is present.
+ */
+export declare function extractExExampleFromMcpDescription(mcpDescription: string | undefined): string | undefined;
+//# sourceMappingURL=extract-ex-example.d.ts.map

package/dist/local/extract-ex-example.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-ex-example.d.ts","sourceRoot":"","sources":["../../src/local/extract-ex-example.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAmBH;;;GAGG;AACH,wBAAgB,kCAAkC,CACjD,cAAc,EAAE,MAAM,GAAG,SAAS,GAChC,MAAM,GAAG,SAAS,CAiBpB"}

package/dist/local/extract-ex-example.js

@@ -0,0 +1,43 @@
+/**
+ * Parse tools.authoring `Ex:` payloads from mcpDescription.
+ *
+ * Convention (docs + init scaffold): a single-line mcpDescription ends with
+ * `Ex: {action:"echo",message:"hello"}.` so CLI preflight and agents can
+ * recover a workable --input without inventing schema fields.
+ *
+ * Pure — no runtime, no FS. Shared by tools/cli run preflight and init tests.
+ */
+import { CaughtFailureSchema, valueFreeFailure } from '@vibesdotdev/kernel';
+function safeNormalizeJson(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return { ok: true, data: JSON.stringify(parsed) };
+    }
+    catch (error) {
+        return { ok: false, failure: valueFreeFailure(CaughtFailureSchema.parse(error)) };
+    }
+}
+/**
+ * Pull a JSON-stringified example object from an mcpDescription Ex: clause.
+ * Returns undefined when no parseable object is present.
+ */
+export function extractExExampleFromMcpDescription(mcpDescription) {
+    if (!mcpDescription)
+        return undefined;
+    // Prefer JSON-like object after Ex:
+    const objectMatch = mcpDescription.match(/Ex:\s*(\{[\s\S]*?\})(?:\s*\.|$)/i);
+    if (objectMatch?.[1]) {
+        const raw = objectMatch[1]
+            // Authors often use unquoted keys / single-quoted values in prose.
+            .replace(/([{,]\s*)([a-zA-Z_][\w]*)\s*:/g, '$1"$2":')
+            .replace(/:\s*'([^']*)'/g, ':"$1"')
+            .replace(/:\s*"([^"]*)"/g, ':"$1"');
+        const normalized = safeNormalizeJson(raw.replace(/'/g, '"'));
+        if (normalized.ok && normalized.data) {
+            return normalized.data;
+        }
+        return objectMatch[1].trim();
+    }
+    return undefined;
+}
+//# sourceMappingURL=extract-ex-example.js.map