@veil-runtime/core 0.1.2 → 0.2.0

package/README.md

@@ -1,522 +1,58 @@
-# Veil
-
-Veil is a capability-driven execution platform for AI and software systems.
-
-It separates **reasoning** from **execution**, allowing planners, language models, agents, humans and applications to safely interact with external systems through reusable capabilities while keeping execution governed, observable, auditable and independent of any specific AI provider.
-
-The goal is simple:
-
-> **Allow any planner to decide _what_ should happen, while Veil reliably decides _how_ it happens.**
-
-Or, more simply:
-
-> **Veil treats AI as a planning problem and execution as an engineering problem.**
-
----
-
-# Vision
-
-Modern language models are exceptional at reasoning.
-
-They should not be responsible for safely interacting with production systems.
-
-Veil provides the governed execution layer between reasoning and the outside world.
-
-Instead of allowing planners to directly manipulate browsers, files, databases, infrastructure or external services, Veil executes structured plans through governed capabilities, applying validation, permissions, policies, memory, logging and runtime services before any action is performed.
-
-The result is a reusable execution platform capable of powering automation, operational intelligence, developer tooling and enterprise integrations without coupling execution to any specific reasoning system or AI provider.
-
----
-
-# Architectural Principles
-
-Veil owns **the contract between reasoning and execution**.
-
-It does not prescribe how reasoning is performed or how capabilities are implemented.
-
-Instead, it defines stable interfaces that allow both sides to evolve independently.
-
-```text
-Reasoning
-    │
-Planner Providers
-Planner Strategies
-Planner Routing
-    │
-ExecutionPlan
-══════════════════════
-OperatorRuntime
-══════════════════════
-Capability Registry
-Capability Modules
-Providers
-    │
-Execution
-```
-
-This separation allows new planners, routing strategies, capability modules and providers to be introduced without changing Veil Core.
-
----
-
-# Architecture
-
-```text
-                         Goal
-                          │
-                          ▼
-                    Planner Router
-                          │
-                   selects strategy
-                          │
-                          ▼
-                   Planner Strategy
-                          │
-             ┌────────────┼────────────┐
-             │            │            │
-             ▼            ▼            ▼
-      Planner Registry Runtime State Eligibility
-             │
-             └────────────┬────────────┘
-                          │
-                          ▼
-                  Planner Provider(s)
-                          │
-                          ▼
-                    ExecutionPlan
-
-══════════════════════════════════════════════
-                     VEIL
-══════════════════════════════════════════════
-
-                          │
-                          ▼
-                  OperatorRuntime
-                          │
-          ┌───────────────┼───────────────┐
-          ▼               ▼               ▼
-       Policy        Job Manager      Event Bus
-                                             │
-                                             ▼
-                                     Execution Engine
-                                             │
-                                             ▼
-                                  Capability Registry
-                                             │
-                                             ▼
-                                  Capability Modules
-                                             │
-                                             ▼
-                                         Providers
-                                             │
-           ┌──────────────┬──────────────┬──────────────┬──────────────┐
-           ▼              ▼              ▼              ▼
-        Browser      Filesystem        Shell          HTTP
-```
-
----
-
-# Current Features
-
-## Runtime
-
-- Generic execution engine
-- OperatorRuntime façade
-- Planner router registry
-- Planner registry
-- Strategy registry
-- Capability registry
-- ExecutionPlan contract
-- Execution context
-- Event bus
-- Runtime events
-- Structured execution logging
-- Job lifecycle management
-- Persistent SQLite job store
-- Human-reviewed outcomes
-
----
-
-## Planning
-
-- Planner router
-- Planner registry
-- Planner strategies
-- Deterministic planner
-- OpenAI-compatible planner support
-- Example local and distributed planner configurations
-- Planner health monitoring
-- Planner runtime state
-- Planner eligibility
-- Historical context retrieval
-- ExecutionPlan v1
-
----
-
-## SDK
-
-- Capability SDK
-- Declarative capability authoring
-- Middleware pipeline
-- Lifecycle middleware
-- Timeout middleware
-- Runtime execution options
-- Capability module support
-
----
-
-## Memory
-
-- Persistent job history
-- Planner context retrieval
-- Historical capability recall
-- Outcome recording
-- Human review workflow
-
----
-
-## Capabilities
-
-- LinkedIn authentication
-- LinkedIn profile reader
-- Generic web page reader
-- HTTP request execution
-- Filesystem reader
-- Shell command execution
-
----
-
-## Providers
-
-- Browser provider
-- Browser session manager
-- HTTP provider
-- Filesystem provider
-- Shell provider
-- SQLite provider
-- OpenAI-compatible AI providers
-
----
-
-# Design Principles
-
-- Planner agnostic
-- Strategy agnostic
-- Provider agnostic
-- Capability driven
-- Runtime governed
-- Explicit permissions
-- Structured observability
-- Human review before learning
-- Small composable services
-- Extension through composition
-- Reusable by design
-
----
-
-# What Makes Veil Different
-
-Veil does not attempt to replace language models.
-
-Instead, it provides the governed execution environment around them.
-
-Reasoning remains completely replaceable.
-
-Execution remains governed and deterministic at the capability boundary.
-
-Applications can embed Veil without coupling themselves to specific planners, capability implementations or infrastructure providers.
-
-Because these responsibilities remain independent:
-
-- Routers choose strategies.
-- Strategies orchestrate planners.
-- Planners produce execution plans.
-- OperatorRuntime governs execution.
-- Capabilities perform the work.
-- Providers interact with external systems.
-- Runtime services remain independent of planners and capabilities.
-
-This separation allows Veil to remain reusable across domains while ensuring execution remains governed, observable and consistent.
-
----
-
-# Roadmap
-
-## Runtime
-
-- Dependency graph execution
-- Parallel capability execution
-- Live progress reporting
-- Cancellation
-- Retry policies
-- Secrets service
-- Metrics
-- Audit services
-- Resource management
-
----
-
-## SDK
-
-- Provider SDK
-- Capability testing framework
-- Middleware library
-- Validation helpers
-- Retry middleware
-- Metrics middleware
-- Audit middleware
-- Execution decorators
-
----
-
-## Intelligence
-
-- Planner routing policies
-- Planner evaluation
-- Cost-aware routing
-- Latency-aware routing
-- Capability recommendations
-- Historical plan optimisation
-- Outcome-aware learning
-- Runtime analytics
-- Multi-agent planning pipelines
-
----
-
-## Capabilities
-
-- LinkedIn posting
-- GitHub
-- Docker
-- SSH
-- SQL
-- Jira
-- Confluence
-- Kubernetes
-- Cloud providers
-- Generic REST integrations
-
----
-
-# Long-Term Direction
-
-Veil is evolving into a reusable execution platform capable of powering:
-
-- AI assistants
-- Operational intelligence platforms
-- Enterprise automation
-- Developer tooling
-- Agentic systems
-- Workflow orchestration
-- Multi-agent collaboration
-
-Reasoning remains modular through planners, strategies and routing.
-
-Execution remains governed and deterministic at the capability boundary.
-
-Veil defines the contract between them.
-
----
-
-# Status
-
-Veil has evolved beyond a proof of concept into a reusable execution platform.
-
-The execution runtime, capability system, reasoning architecture, planner routing, planner strategies, provider model, event bus, persistent memory, module architecture and SDK foundation are now in place.
-
-The current focus is strengthening the platform itself—its SDKs, runtime services, provider ecosystem, reasoning architecture and execution model—so that new planners, strategies, capabilities and integrations become progressively simpler to build while preserving governed, observable and reliable execution.
-
-Every architectural improvement compounds across the platform, allowing Veil to grow in capability while keeping complexity contained behind stable contracts.
-
-The guiding principles remain simple:
-
-> **Veil owns the contract between reasoning and execution.**
-
-> **Planners reason. Strategies orchestrate. OperatorRuntime governs execution. Veil owns the contract between them.**
-
-> **Architecture evolves only when existing contracts can no longer express a real-world use case. Otherwise, Veil grows through extensions rather than changes to its core.**
-
----
----
-
-# Getting Started
-
-## Requirements
-
-- Node.js 24+
-- npm
-- Git
-
-Optional:
-
-- Docker Model Runner or another OpenAI-compatible endpoint
-- Playwright (for browser capabilities)
-
----
-
-## Installation
-
-Install the public runtime package in an application:
-
-```bash
-npm install @veil-runtime/core
-```
-
-Create and execute a capability through the public API:
-
-```ts
-import {
-  createCapability,
-  OperatorRuntime,
-  type CapabilityModule,
-  type ExecutionPlan,
-} from '@veil-runtime/core';
-
-const echo = createCapability<{ value: string }, string>({
-  name: 'example.echo',
-  version: '1.0.0',
-  description: 'Return the provided value',
-  risk: 'read',
-  async execute({ input }) {
-    return input.value;
-  },
-});
-
-const module: CapabilityModule = {
-  manifest: {
-    name: 'example',
-    version: '1.0.0',
-    capabilities: [echo.name],
-  },
-  capabilities: [echo],
-};
-
-const plan: ExecutionPlan = {
-  version: '1.0',
-  steps: [{
-    id: 'echo',
-    capability: echo.name,
-    capabilityVersion: echo.version,
-    input: { value: 'Hello from Veil' },
-  }],
-};
-
-const runtime = new OperatorRuntime();
-runtime.use(module);
-
-const job = await runtime.executePlan(plan);
-console.log(job.status, job.result);
-```
-
-This public-package usage is compile- and execution-verified by the release
-consumer fixture. Internal `src`, `dist`, registry, provider, and storage
-subpaths are intentionally unavailable.
-
-### Contextual execution authorization
-
-An application may supply a runtime-scoped authorizer. Veil resolves and
-validates the step input before invoking it, and does not start a denied
-capability:
-
-```ts
-import {
-  OperatorRuntime,
-  type ExecutionAuthorizer,
-} from '@veil-runtime/core';
-
-const authorizer: ExecutionAuthorizer = {
-  async authorize({ capability, input }) {
-    if (
-      capability.name === 'deploy.trigger' &&
-      typeof input === 'object' &&
-      input !== null &&
-      'environment' in input &&
-      input.environment === 'production'
-    ) {
-      return {
-        decision: 'deny',
-        reason: 'Production deployment is not allowed.',
-      };
-    }
-
-    return { decision: 'allow' };
-  },
-};
-
-const runtime = new OperatorRuntime({ authorizer });
-```
-
-## Repository development
-
-Clone the repository:
-
-```bash
-git clone git@github.com:veil-runtime/veil.git
-cd veil
-```
-
-Install dependencies:
-
-```bash
-npm install
-```
-
----
-
-## Running Veil
-
-Start the runtime:
-
-```bash
-JOB_STORE=sqlite npm run dev
-```
-
-The runtime will start on:
-
-```
-http://127.0.0.1:3333
-```
-
-Verify it's running:
-
-```bash
-curl http://127.0.0.1:3333/health
-```
-
-Expected response:
-
-```json
-{
-  "status": "ok",
-  "service": "operator-runtime"
-}
-```
-
----
-
-## Running Your First Job
-
-Submit a goal:
-
-```bash
-curl -X POST http://127.0.0.1:3333/api/jobs/run \
-  -H "Content-Type: application/json" \
-  -d '{
-    "goal": "Read README.md"
-  }'
-```
-
-Veil will:
-
-1. Route the request through a `PlannerRouter`.
-2. Select a `PlannerStrategy`.
-3. Generate an `ExecutionPlan`.
-4. Execute the plan through `OperatorRuntime`.
-5. Return the completed job.
-
----
-
-# License and branding
-
-Veil Core is licensed under Apache-2.0. Copyright 2026 Mustapha Keraan.
-Veil names, logos, and branding are governed separately; see
-[TRADEMARKS.md](TRADEMARKS.md) for the brand policy.
+# Veil
+
+Veil is a governed, capability-driven execution runtime for AI and software systems.
+
+**Developer documentation:** [GitHub Pages portal](https://veil-runtime.github.io/veil/developer.html) | [repository docs](docs/developer.md)
+
+## The idea
+
+Veil separates reasoning from execution. A human, application, deterministic planner, or AI system produces an ExecutionPlan; OperatorRuntime validates and executes it through registered capabilities.
+
+    Reasoning / application -> ExecutionPlan -> OperatorRuntime
+      -> validation -> reference resolution -> authorization
+      -> capability -> provider -> external system
+      -> job history and events
+
+Planners reason. Strategies orchestrate. Routers select strategies. Capabilities define work. Providers interact with external systems.
+
+## Install
+
+Requires Node.js 24+.
+
+    npm install @veil-runtime/core
+
+This installs the published package. To verify v0.2.0 before publication, see [candidate installation](docs/getting-started/installation.md).
+
+## Smallest working example
+
+    import { createCapability, OperatorRuntime } from '@veil-runtime/core';
+
+    const echo = createCapability<{ value: string }, string>({
+      name: 'example.echo', version: '1.0.0', description: 'Return a value', risk: 'read',
+      inputSchema: { value: { type: 'string', required: true, description: 'Text' } },
+      async execute({ input }) { return input.value; },
+    });
+    const module = {
+      manifest: { name: 'example', version: '1.0.0', capabilities: [echo.name] },
+      capabilities: [echo],
+    };
+    const runtime = new OperatorRuntime();
+    runtime.use(module);
+    const job = await runtime.executePlan({ version: '1.0', steps: [{
+      id: 'echo', capability: echo.name, capabilityVersion: echo.version,
+      input: { value: 'Hello from Veil' },
+    }] });
+
+The default authorizer permits reads and denies write/destructive capabilities. Supply a runtime-scoped authorizer to allow selected writes. See [authorization](docs/concepts/authorization.md).
+
+## Status and roadmap
+
+Release candidate: **v0.2.0**. See [release notes](docs/getting-started/v0.2.0.md). The latest published package remains **v0.1.3** until publication. ExecutionPlan v1 is linear. DAGs, parallel execution, conditionals, cancellation, and retry policies are roadmap work, not current behavior.
+
+## Contributing
+
+See [development setup](docs/contributing/development-setup.md), [testing](docs/contributing/testing.md), and the [architecture rules](docs/contributing/architecture-rules.md).
+
+## License and branding
+
+Veil Core is licensed under Apache-2.0. See [LICENSE](LICENSE), [NOTICE](NOTICE), and [TRADEMARKS.md](TRADEMARKS.md).

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export type { OperatorRuntimeOptions } from './runtime/operator-runtime.js';
 export type { CapabilityAuthorizationContext, CapabilityAuthorizationDecision, ExecutionAuthorizer, } from './runtime/permissions/execution-authorizer.js';
 export type { ExecutionPlan, ExecutionStep, Planner, PlannerContext, ResultReference, } from './runtime/planner/planner.js';
 export type { ExecutionCaller, ExecutionContext } from './runtime/execution/execution-context.js';
-export type { Capability, CapabilityInputField, CapabilityRisk, } from './runtime/registry/capability.js';
+export type { Capability, CapabilityDescriptor, CapabilityInputField, CapabilityRisk, } from './runtime/registry/capability.js';
 export type { CapabilityModule } from './runtime/modules/capability-module.js';
 export type { CapabilityModuleManifest } from './runtime/modules/capability-module-manifest.js';
 export type { Job, JobOutcome } from './runtime/jobs/job.js';

package/dist/runtime/events/memory-event-bus.js

@@ -24,7 +24,14 @@ class MemoryEventBus {
             ...specific,
             ...wildcard,
         ];
-        await Promise.all(handlers.map((handler) => Promise.resolve(handler(event))));
+        await Promise.all(handlers.map(async (handler) => {
+            try {
+                await handler(event);
+            }
+            catch {
+                // Subscriber failures are contained observer failures.
+            }
+        }));
     }
 }
 exports.MemoryEventBus = MemoryEventBus;

package/dist/runtime/execution/plan-validator.js

@@ -79,6 +79,13 @@ function validatePlan(steps) {
     const errors = [];
     const seenStepIds = new Set();
     for (const step of steps) {
+        if (seenStepIds.has(step.id)) {
+            errors.push({
+                stepId: step.id,
+                capability: step.capability,
+                message: `Duplicate step ID: ${step.id}`,
+            });
+        }
         const capability = registry_js_1.capabilityRegistry.get(step.capability);
         if (!capability) {
             errors.push({
@@ -89,7 +96,7 @@ function validatePlan(steps) {
             seenStepIds.add(step.id);
             continue;
         }
-        if (step.capabilityVersion && step.capabilityVersion !== capability.version) {
+        if (step.capabilityVersion !== undefined && step.capabilityVersion !== capability.version) {
             errors.push({
                 stepId: step.id,
                 capability: step.capability,

package/dist/runtime/execution/result-reference.js

@@ -39,7 +39,7 @@ function resolveResultReferences(value, completedSteps) {
         }
         let resolved = step.result;
         for (const segment of path) {
-            if (!resolved || typeof resolved !== 'object' || !(segment in resolved)) {
+            if (!resolved || typeof resolved !== 'object' || !Object.hasOwn(resolved, segment)) {
                 throw new Error(`Result reference path not found: ${value.$ref}`);
             }
             resolved = resolved[segment];

package/dist/runtime/jobs/job-manager.js

@@ -14,20 +14,38 @@ const composite_log_sink_js_1 = require("../logging/composite-log-sink.js");
 const sqlite_log_sink_js_1 = require("../logging/sqlite-log-sink.js");
 class JobManager {
     async executePlan(plan, caller, authorizer = execution_authorizer_js_1.defaultExecutionAuthorizer) {
-        if (!plan.steps.length) {
+        // Own the structural envelope before admission; nested input remains shared.
+        const capturedGoal = plan.goal;
+        const idempotencyKey = plan.idempotencyKey;
+        const submittedSteps = plan.steps;
+        const steps = new Array(submittedSteps.length);
+        for (let index = 0; index < steps.length; index += 1) {
+            if (!(index in submittedSteps))
+                continue;
+            const step = submittedSteps[index];
+            steps[index] = {
+                id: step.id,
+                capability: step.capability,
+                capabilityVersion: step.capabilityVersion,
+                input: step.input,
+                reason: step.reason,
+                idempotencyKey: step.idempotencyKey,
+            };
+        }
+        if (!steps.length) {
             throw new Error('Execution plan contains no steps');
         }
-        const validation = (0, plan_validator_js_1.validatePlan)(plan.steps);
+        const validation = (0, plan_validator_js_1.validatePlan)(steps);
         if (!validation.valid) {
             throw new Error(`Execution plan failed validation: ${validation.errors
                 .map((error) => error.message)
                 .join('; ')}`);
         }
-        const goal = plan.goal?.trim() ||
+        const goal = capturedGoal?.trim() ||
             'External execution plan';
         const job = await this.create(goal);
-        job.idempotencyKey = plan.idempotencyKey;
-        job.steps = plan.steps.map((step) => ({
+        job.idempotencyKey = idempotencyKey;
+        job.steps = steps.map((step) => ({
             ...step,
             status: 'pending',
             createdAt: new Date().toISOString(),
@@ -112,8 +130,22 @@ class JobManager {
                         input: resolvedInput,
                         caller,
                     });
-                    if (authorization.decision === 'deny') {
-                        const message = authorization.reason ??
+                    if (typeof authorization !== 'object' ||
+                        authorization === null ||
+                        Array.isArray(authorization) ||
+                        !Object.hasOwn(authorization, 'decision')) {
+                        throw new Error('Invalid authorization decision');
+                    }
+                    const decision = authorization.decision;
+                    if (decision !== 'allow' && decision !== 'deny') {
+                        throw new Error('Invalid authorization decision');
+                    }
+                    if (decision === 'deny') {
+                        const reason = authorization.reason;
+                        if (reason !== undefined && typeof reason !== 'string') {
+                            throw new Error('Invalid authorization decision');
+                        }
+                        const message = reason ??
                             `Capability not permitted: ${step.capability}`;
                         step.status = 'failed';
                         step.error = message;
@@ -122,7 +154,7 @@ class JobManager {
                             stepId: step.id,
                             capability: capability.name,
                             risk: capability.risk,
-                            reason: authorization.reason,
+                            reason,
                         });
                         throw new AuthorizationDeniedError(message);
                     }

package/dist/runtime/operator-runtime.d.ts

@@ -1,3 +1,4 @@
+import type { CapabilityDescriptor } from './registry/capability.js';
 import { Job } from './jobs/job.js';
 import { JobListFilter } from './jobs/job-store.js';
 import { ExecutionCaller } from './execution/execution-context.js';
@@ -23,13 +24,8 @@ export declare class OperatorRuntime {
     run(goal: string, options?: RunJobOptions): Promise<Job>;
     getJob(id: string): Promise<Job | undefined>;
     listJobs(filter?: JobListFilter): Promise<Job[]>;
-    listCapabilities(): {
-        name: string;
-        version: string;
-        description: string;
-        risk: import("./registry/capability.js").CapabilityRisk;
-        inputSchema: Record<string, import("./registry/capability.js").CapabilityInputField>;
-    }[];
+    listCapabilities(): CapabilityDescriptor[];
+    describeCapability(name: string, version?: string): CapabilityDescriptor | undefined;
     listPlanners(): {
         name: string;
     }[];

package/dist/runtime/operator-runtime.js

@@ -70,6 +70,9 @@ class OperatorRuntime {
     listCapabilities() {
         return registry_js_1.capabilityRegistry.list();
     }
+    describeCapability(name, version) {
+        return registry_js_1.capabilityRegistry.describe(name, version);
+    }
     listPlanners() {
         return planner_registry_js_1.plannerRegistry.list();
     }

package/dist/runtime/registry/capability.d.ts

@@ -13,3 +13,12 @@ export interface Capability<TInput = unknown, TResult = unknown> {
     inputSchema?: Record<string, CapabilityInputField>;
     execute(input: TInput, context?: ExecutionContext): Promise<TResult>;
 }
+/** Detached execution metadata. Introspection is not authorization. */
+export interface CapabilityDescriptor {
+    name: string;
+    version: string;
+    description: string;
+    risk: CapabilityRisk;
+    /** Limited Veil field contract, not full JSON Schema. */
+    inputSchema: Record<string, CapabilityInputField>;
+}

package/dist/runtime/registry/registry.d.ts

@@ -1,15 +1,10 @@
-import { Capability } from './capability.js';
+import { Capability, CapabilityDescriptor } from './capability.js';
 declare class CapabilityRegistry {
     private capabilities;
     register(capability: Capability): void;
     get(name: string): Capability | undefined;
-    list(): {
-        name: string;
-        version: string;
-        description: string;
-        risk: import("./capability.js").CapabilityRisk;
-        inputSchema: Record<string, import("./capability.js").CapabilityInputField>;
-    }[];
+    describe(name: string, version?: string): CapabilityDescriptor | undefined;
+    list(): CapabilityDescriptor[];
 }
 export declare const capabilityRegistry: CapabilityRegistry;
 export {};

package/dist/runtime/registry/registry.js

@@ -12,14 +12,29 @@ class CapabilityRegistry {
     get(name) {
         return this.capabilities.get(name);
     }
+    describe(name, version) {
+        const capability = this.get(name);
+        if (!capability || (version !== undefined && version !== capability.version)) {
+            return undefined;
+        }
+        return describeCapability(capability);
+    }
     list() {
-        return Array.from(this.capabilities.values()).map((capability) => ({
-            name: capability.name,
-            version: capability.version,
-            description: capability.description,
-            risk: capability.risk,
-            inputSchema: capability.inputSchema ?? {},
-        }));
+        return Array.from(this.capabilities.values(), describeCapability);
     }
 }
 exports.capabilityRegistry = new CapabilityRegistry();
+// Explicitly project passive metadata; never copy implementation properties.
+function describeCapability(capability) {
+    return {
+        name: capability.name,
+        version: capability.version,
+        description: capability.description,
+        risk: capability.risk,
+        inputSchema: Object.fromEntries(Object.entries(capability.inputSchema ?? {}).map(([name, field]) => [name, {
+                type: field.type,
+                required: field.required,
+                description: field.description,
+            }])),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veil-runtime/core",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "A governed, capability-driven execution runtime",
   "license": "Apache-2.0",
   "repository": {
@@ -43,6 +43,8 @@
     "test": "tsc --project tsconfig.test.json && node --test .tmp/test-build/test/*.test.js",
     "verify:package": "npm run build && node tools/verify-package.mjs",
     "check": "npm run typecheck && npm test && npm run verify:package",
+    "quality": "node tools/quality.mjs",
+    "test:quality": "node --test tools/quality.test.mjs tools/quality-governance.test.mjs",
     "mcp:stdio": "tsx src/integrations/mcp/stdio-server.ts",
     "mcp:test": "tsx src/integrations/mcp/test-client.ts",
     "mcp:test:outbound": "tsx src/integrations/mcp/test-outbound.ts"
@@ -61,6 +63,7 @@
     "better-sqlite3": "^13.0.3"
   },
   "devDependencies": {
+    "@babel/parser": "8.0.5",
     "@types/better-sqlite3": "^9.6.0",
     "@types/node": "^26.2.0",
     "fastify": "^5.11.3",