nexus-prime 6.6.2 → 7.0.0

package/README.md

@@ -137,6 +137,8 @@ That's it. Memory, budgeting, and safe execution are already on.
 
 Prefer one-liner installs? `curl -fsSL https://nexus-prime.cfd/install.sh | bash`
 
+Your agent calls `nexus_session_bootstrap` + `nexus_orchestrate` automatically. Auto-bootstrap runs on first non-bootstrap call, so you never have to wire the packet by hand.
+
 ---
 
 ## Features
@@ -253,6 +255,12 @@ Or just wire everything: **`nexus-prime setup all`**
 
 ---
 
+## Competitive position
+
+Nexus Prime is the only control plane that remembers the repo, budgets the tokens, and ghost-passes every mutation — locally, in one process. Compare head-to-head on [nexus-prime.cfd/comparison.html](https://nexus-prime.cfd/comparison.html) or read the full docs on [nexus-prime.cfd/knowledge-base.html](https://nexus-prime.cfd/knowledge-base.html).
+
+---
+
 ## What users see
 
 Numbers from real users running real workflows on their own machines:

package/dist/adapters/admin/authoring.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Admin adapter — authoring.
+ *
+ * Programmatic specialist / skill file creation. Authoritative home for
+ * the markdown builders that used to live in
+ * `src/dashboard/routes/authoring.ts` (POST handlers are being retired
+ * in PR7 Phase 3). Reachable from CLI and hosts without going through MCP.
+ */
+import type { CreateSpecialistInput, CreateSpecialistResult, CreateSkillInput, CreateSkillResult } from './types.js';
+export interface AuthoringAdmin {
+    createSpecialist(input: CreateSpecialistInput): Promise<CreateSpecialistResult>;
+    createSkill(input: CreateSkillInput): Promise<CreateSkillResult>;
+}
+export declare function createAuthoringAdmin(repoRoot: string): AuthoringAdmin;

package/dist/adapters/admin/authoring.js

@@ -0,0 +1,116 @@
+/**
+ * Admin adapter — authoring.
+ *
+ * Programmatic specialist / skill file creation. Authoritative home for
+ * the markdown builders that used to live in
+ * `src/dashboard/routes/authoring.ts` (POST handlers are being retired
+ * in PR7 Phase 3). Reachable from CLI and hosts without going through MCP.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/** Sanitize an id to safe filesystem characters. */
+function safeId(raw) {
+    return raw.replace(/[^a-z0-9._-]/gi, '-').toLowerCase().slice(0, 120);
+}
+/**
+ * Render a specialist definition to markdown in the format expected by
+ * the specialist detail loader at `.agents/specialists/<id>.md`.
+ */
+function specialistToMarkdown(input) {
+    const name = input.name;
+    const division = input.division ?? 'custom';
+    const description = input.description ?? '';
+    const emoji = input.emoji ?? '🤖';
+    const authority = input.authority ?? 'advisory';
+    const domains = input.domains ?? [];
+    const mission = input.mission ?? '';
+    const rules = input.rules ?? [];
+    const workflow = input.workflow ?? [];
+    const deliverables = input.deliverables ?? [];
+    const lines = [
+        `# ${emoji} ${name}`,
+        '',
+        `**Division**: ${division}  `,
+        `**Authority**: ${authority}  `,
+        `**Domains**: ${domains.join(', ') || '—'}  `,
+        '',
+        '## Description',
+        '',
+        description || '_No description provided._',
+        '',
+        '## Mission',
+        '',
+        mission || '_No mission provided._',
+        '',
+    ];
+    if (rules.length) {
+        lines.push('## Rules', '');
+        rules.forEach((r) => lines.push(`- ${r}`));
+        lines.push('');
+    }
+    if (workflow.length) {
+        lines.push('## Workflow', '');
+        workflow.forEach((w) => lines.push(`- ${w}`));
+        lines.push('');
+    }
+    if (deliverables.length) {
+        lines.push('## Deliverables', '');
+        deliverables.forEach((d) => lines.push(`- ${d}`));
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Render a skill definition to markdown for `.agents/skills/<id>.md`.
+ */
+function skillToMarkdown(input) {
+    const name = input.name;
+    const description = input.description ?? '';
+    const trigger = input.trigger ?? '';
+    const steps = input.steps ?? [];
+    const lines = [
+        `# ${name}`,
+        '',
+        description || '_No description provided._',
+        '',
+    ];
+    if (trigger) {
+        lines.push('## Trigger', '', trigger, '');
+    }
+    if (steps.length) {
+        lines.push('## Steps', '');
+        steps.forEach((s) => lines.push(`- ${s}`));
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function requireName(name, kind) {
+    if (typeof name !== 'string' || name.trim().length === 0) {
+        throw new Error(`admin.createAuthoring: ${kind} name is required`);
+    }
+    return name.trim();
+}
+export function createAuthoringAdmin(repoRoot) {
+    return {
+        async createSpecialist(input) {
+            const name = requireName(input.name, 'specialist');
+            const specialistId = safeId(name);
+            const dir = path.join(repoRoot, '.agents', 'specialists');
+            const filePath = path.join(dir, `${specialistId}.md`);
+            const content = specialistToMarkdown({ ...input, name });
+            await fs.promises.mkdir(dir, { recursive: true });
+            await fs.promises.writeFile(filePath, content, 'utf8');
+            return { ok: true, specialistId, filePath };
+        },
+        async createSkill(input) {
+            const name = requireName(input.name, 'skill');
+            const skillId = safeId(name);
+            const dir = path.join(repoRoot, '.agents', 'skills');
+            const filePath = path.join(dir, `${skillId}.md`);
+            const content = skillToMarkdown({ ...input, name });
+            await fs.promises.mkdir(dir, { recursive: true });
+            await fs.promises.writeFile(filePath, content, 'utf8');
+            return { ok: true, skillId, filePath };
+        },
+    };
+}

package/dist/adapters/admin/control.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Admin adapter — control.
+ *
+ * Thin facade over operator-grade runtime actions: license management and
+ * memory export/import. Exposes what already exists in the engines as a
+ * library call so hosts can trigger it without going through MCP JSON-RPC.
+ */
+import type { LicenseStatus } from '../../licensing/index.js';
+import type { MemoryEngine, MemoryExportBundle, MemoryImportResult, MemoryItem } from '../../engines/memory.js';
+export interface MemoryExportOptions {
+    limit?: number;
+    scope?: MemoryItem['scope'];
+    state?: MemoryItem['state'];
+    sessionId?: string;
+}
+export interface ControlLicenseAdmin {
+    /** Current license status (no I/O). */
+    status(): LicenseStatus;
+    /** Validate + persist a license key. Returns updated status. */
+    activate(token: string): LicenseStatus;
+    /** Remove the license key and reset to free tier. */
+    deactivate(): void;
+    /** Sync with the licensing backend. Requires network. */
+    sync(): Promise<LicenseStatus>;
+}
+export interface ControlMemoryAdmin {
+    /** Export in-memory items to a bundle. Requires ctx.memory. */
+    export(options?: MemoryExportOptions): MemoryExportBundle;
+    /** Import a bundle (from path or object). Requires ctx.memory. */
+    import(input: {
+        path?: string;
+        bundle?: MemoryExportBundle;
+    }): Promise<MemoryImportResult>;
+}
+export interface ControlAdmin {
+    license: ControlLicenseAdmin;
+    memory: ControlMemoryAdmin;
+}
+export declare function createControlAdmin(_repoRoot: string, memory?: MemoryEngine): ControlAdmin;

package/dist/adapters/admin/control.js

@@ -0,0 +1,41 @@
+/**
+ * Admin adapter — control.
+ *
+ * Thin facade over operator-grade runtime actions: license management and
+ * memory export/import. Exposes what already exists in the engines as a
+ * library call so hosts can trigger it without going through MCP JSON-RPC.
+ */
+import { getSharedLicenseManager, syncLicense } from '../../licensing/index.js';
+function requireMemory(memory) {
+    if (!memory) {
+        throw new Error('admin.control.memory: ctx.memory required — pass a MemoryEngine instance to createAdmin()');
+    }
+}
+export function createControlAdmin(_repoRoot, memory) {
+    return {
+        license: {
+            status() {
+                return getSharedLicenseManager().getStatus();
+            },
+            activate(token) {
+                return getSharedLicenseManager().activate(token);
+            },
+            deactivate() {
+                getSharedLicenseManager().deactivate();
+            },
+            sync() {
+                return syncLicense();
+            },
+        },
+        memory: {
+            export(options = {}) {
+                requireMemory(memory);
+                return memory.exportBundle(options);
+            },
+            async import(input) {
+                requireMemory(memory);
+                return memory.importBundle(input);
+            },
+        },
+    };
+}

package/dist/adapters/admin/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Admin adapter — barrel.
+ *
+ * Operator-grade, in-process host surface for authoring (specialist/skill
+ * file creation) and control-plane actions (license management, memory
+ * export/import) that don't belong on the observer-only dashboard and
+ * don't need to go through MCP JSON-RPC.
+ *
+ *   import { createAdmin } from 'nexus-prime/admin';
+ *
+ *   const admin = createAdmin({ repoRoot });
+ *   await admin.authoring.createSpecialist({ name: 'Fix Auth', ... });
+ *   admin.control.license.activate(token);
+ *   admin.control.memory.export();  // requires ctx.memory
+ *
+ * Layering:
+ * - may import from `src/kernel/**`, `src/engines/**`, `src/adapters/shared/**`.
+ * - MUST NOT import from `src/agents/adapters/mcp/**` or `src/dashboard/**`.
+ *   Enforced by `test/adapter-boundary.test.ts`.
+ */
+import { type AuthoringAdmin } from './authoring.js';
+import { type ControlAdmin } from './control.js';
+import type { AdminContext } from './types.js';
+export type { AdminContext, CreateSpecialistInput, CreateSpecialistResult, CreateSkillInput, CreateSkillResult, } from './types.js';
+export type { AuthoringAdmin, } from './authoring.js';
+export type { ControlAdmin, ControlLicenseAdmin, ControlMemoryAdmin, MemoryExportOptions, } from './control.js';
+export interface Admin {
+    authoring: AuthoringAdmin;
+    control: ControlAdmin;
+}
+/**
+ * Compose an admin surface bound to an absolute repoRoot. Fail-fast: throws
+ * if `ctx.repoRoot` is missing or not absolute, mirroring the hooks adapter
+ * contract from PR6.
+ *
+ * Pass `ctx.memory` to enable admin.control.memory.* methods.
+ */
+export declare function createAdmin(ctx: AdminContext): Admin;

package/dist/adapters/admin/index.js

@@ -0,0 +1,39 @@
+/**
+ * Admin adapter — barrel.
+ *
+ * Operator-grade, in-process host surface for authoring (specialist/skill
+ * file creation) and control-plane actions (license management, memory
+ * export/import) that don't belong on the observer-only dashboard and
+ * don't need to go through MCP JSON-RPC.
+ *
+ *   import { createAdmin } from 'nexus-prime/admin';
+ *
+ *   const admin = createAdmin({ repoRoot });
+ *   await admin.authoring.createSpecialist({ name: 'Fix Auth', ... });
+ *   admin.control.license.activate(token);
+ *   admin.control.memory.export();  // requires ctx.memory
+ *
+ * Layering:
+ * - may import from `src/kernel/**`, `src/engines/**`, `src/adapters/shared/**`.
+ * - MUST NOT import from `src/agents/adapters/mcp/**` or `src/dashboard/**`.
+ *   Enforced by `test/adapter-boundary.test.ts`.
+ */
+import * as path from 'node:path';
+import { createAuthoringAdmin } from './authoring.js';
+import { createControlAdmin } from './control.js';
+/**
+ * Compose an admin surface bound to an absolute repoRoot. Fail-fast: throws
+ * if `ctx.repoRoot` is missing or not absolute, mirroring the hooks adapter
+ * contract from PR6.
+ *
+ * Pass `ctx.memory` to enable admin.control.memory.* methods.
+ */
+export function createAdmin(ctx) {
+    if (!ctx.repoRoot || !path.isAbsolute(ctx.repoRoot)) {
+        throw new Error('createAdmin: ctx.repoRoot must be an absolute path');
+    }
+    return {
+        authoring: createAuthoringAdmin(ctx.repoRoot),
+        control: createControlAdmin(ctx.repoRoot, ctx.memory),
+    };
+}

package/dist/adapters/admin/types.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Admin adapter — shared input/output shapes.
+ *
+ * Operator-grade library surface for authoring and control-plane actions
+ * that do not belong on the observer-only dashboard and don't need to
+ * go through MCP JSON-RPC. Consumed by CLI, hosts, and future tooling.
+ */
+import type { MemoryEngine } from '../../engines/memory.js';
+export interface AdminContext {
+    /** Absolute path to the repo root the admin surface operates on. */
+    repoRoot: string;
+    /**
+     * MemoryEngine instance for admin.control.memory.* methods.
+     * Optional — authoring and license control work without it.
+     */
+    memory?: MemoryEngine;
+}
+export interface CreateSpecialistInput {
+    name: string;
+    division?: string;
+    description?: string;
+    emoji?: string;
+    authority?: string;
+    domains?: string[];
+    mission?: string;
+    rules?: string[];
+    workflow?: string[];
+    deliverables?: string[];
+}
+export interface CreateSpecialistResult {
+    ok: true;
+    specialistId: string;
+    filePath: string;
+}
+export interface CreateSkillInput {
+    name: string;
+    description?: string;
+    trigger?: string;
+    steps?: string[];
+}
+export interface CreateSkillResult {
+    ok: true;
+    skillId: string;
+    filePath: string;
+}

package/dist/adapters/admin/types.js

@@ -0,0 +1,8 @@
+/**
+ * Admin adapter — shared input/output shapes.
+ *
+ * Operator-grade library surface for authoring and control-plane actions
+ * that do not belong on the observer-only dashboard and don't need to
+ * go through MCP JSON-RPC. Consumed by CLI, hosts, and future tooling.
+ */
+export {};

package/dist/adapters/cli/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CLI adapter entry point.
+ *
+ * Re-exports the CLI program from `src/cli.ts` so that tooling can
+ * import from the canonical adapter path (`src/adapters/cli/index.ts`)
+ * while the implementation continues to live in `src/cli.ts` during
+ * the PR4+5 migration.
+ *
+ * PR4+5 W3: once the full adapter split lands, the CLI body will move
+ * here and `src/cli.ts` will become the shim.
+ */
+export * from '../../cli.js';

package/dist/adapters/cli/index.js

@@ -0,0 +1,12 @@
+/**
+ * CLI adapter entry point.
+ *
+ * Re-exports the CLI program from `src/cli.ts` so that tooling can
+ * import from the canonical adapter path (`src/adapters/cli/index.ts`)
+ * while the implementation continues to live in `src/cli.ts` during
+ * the PR4+5 migration.
+ *
+ * PR4+5 W3: once the full adapter split lands, the CLI body will move
+ * here and `src/cli.ts` will become the shim.
+ */
+export * from '../../cli.js';

package/dist/adapters/hooks/context.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Hooks adapter — context namespace.
+ *
+ * Direct pass-through over `kernel.run.*` context methods. No reimplementation,
+ * no side logic. Exists so hosts have a typed in-process surface that never
+ * imports MCP or dashboard code.
+ */
+import type { AssemblyResult, BudgetConfig, CompiledContextPack, CompiledContextRequest, ContextDelta, FileRef, ReadingPlan, SessionSummary, TokenBudget } from '../../kernel/context/index.js';
+export declare const ContextHooks: {
+    readonly init: () => Promise<void>;
+    readonly compile: (request: CompiledContextRequest) => Promise<CompiledContextPack>;
+    readonly hypertuneMax: (task: string, files: FileRef[], graphConnectivity?: (chunk: {
+        source: string;
+        label: string;
+    }) => number) => {
+        plan: ReadingPlan;
+        assembly: AssemblyResult;
+        budgetConfig: BudgetConfig;
+    };
+    readonly differential: (prev: SessionSummary, curr: FileRef[]) => ContextDelta;
+    readonly loadLatestSessionSummary: () => Promise<SessionSummary | null>;
+    readonly allocateBudget: (workers: Array<{
+        id: string;
+        estimatedValue: number;
+        estimatedCost: number;
+    }>, totalBudget?: number) => TokenBudget;
+};

package/dist/adapters/hooks/context.js

@@ -0,0 +1,28 @@
+/**
+ * Hooks adapter — context namespace.
+ *
+ * Direct pass-through over `kernel.run.*` context methods. No reimplementation,
+ * no side logic. Exists so hosts have a typed in-process surface that never
+ * imports MCP or dashboard code.
+ */
+import { kernel } from '../../kernel/index.js';
+export const ContextHooks = {
+    init() {
+        return kernel.run.init();
+    },
+    compile(request) {
+        return kernel.run.compileContext(request);
+    },
+    hypertuneMax(task, files, graphConnectivity) {
+        return kernel.run.hypertuneMax(task, files, graphConnectivity);
+    },
+    differential(prev, curr) {
+        return kernel.run.differential(prev, curr);
+    },
+    loadLatestSessionSummary() {
+        return kernel.run.loadLatestSessionSummary();
+    },
+    allocateBudget(workers, totalBudget) {
+        return kernel.run.allocateBudget(workers, totalBudget);
+    },
+};

package/dist/adapters/hooks/execution.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Hooks adapter — execution namespace.
+ *
+ * Direct pass-through over `kernel.run.step/verify/merge/execute`. The kernel
+ * owns the step→verify→merge invariants; hooks only adapt the call shape.
+ */
+import type { RunMergeRequest, RunMergeResult, RunStepRequest, RunStepResult, RunVerifyRequest, RunVerifyResult } from '../../kernel/execution/index.js';
+import type { ExecutedStep, RuntimeExecuteInput } from '../../kernel/runtime/index.js';
+export declare const ExecutionHooks: {
+    readonly step: (request: RunStepRequest) => Promise<RunStepResult>;
+    readonly verify: (request: RunVerifyRequest) => Promise<RunVerifyResult>;
+    readonly merge: (request: RunMergeRequest) => Promise<RunMergeResult>;
+    readonly execute: (request: RuntimeExecuteInput) => Promise<ExecutedStep>;
+};

package/dist/adapters/hooks/execution.js

@@ -0,0 +1,21 @@
+/**
+ * Hooks adapter — execution namespace.
+ *
+ * Direct pass-through over `kernel.run.step/verify/merge/execute`. The kernel
+ * owns the step→verify→merge invariants; hooks only adapt the call shape.
+ */
+import { kernel } from '../../kernel/index.js';
+export const ExecutionHooks = {
+    step(request) {
+        return kernel.run.step(request);
+    },
+    verify(request) {
+        return kernel.run.verify(request);
+    },
+    merge(request) {
+        return kernel.run.merge(request);
+    },
+    execute(request) {
+        return kernel.run.execute(request);
+    },
+};

package/dist/adapters/hooks/health.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Hooks adapter — health namespace.
+ *
+ * Thin wrapper that asks a host-supplied provider for the current
+ * RuntimeHealthEnvelope. The envelope construction lives in
+ * `src/engines/runtime-health.ts`; hooks just forwards the read.
+ */
+import type { RuntimeHealthEnvelope } from '../../engines/runtime-health.js';
+export interface HealthHooks {
+    runtime(): Promise<RuntimeHealthEnvelope>;
+}
+export declare function createHealthHooks(provider: () => RuntimeHealthEnvelope | Promise<RuntimeHealthEnvelope>): HealthHooks;

package/dist/adapters/hooks/health.js

@@ -0,0 +1,14 @@
+/**
+ * Hooks adapter — health namespace.
+ *
+ * Thin wrapper that asks a host-supplied provider for the current
+ * RuntimeHealthEnvelope. The envelope construction lives in
+ * `src/engines/runtime-health.ts`; hooks just forwards the read.
+ */
+export function createHealthHooks(provider) {
+    return {
+        async runtime() {
+            return await provider();
+        },
+    };
+}

package/dist/adapters/hooks/index.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Hooks adapter — barrel.
+ *
+ * In-process host surface over `kernel.run.*` and selected engine services.
+ * Consumers should import from this module:
+ *
+ *   import { Hooks, createHooks } from '../../adapters/hooks/index.js';
+ *
+ *   const hooks = createHooks({ repoRoot, memory, runtimeHealth });
+ *   await hooks.context.init();
+ *   const pack = await hooks.context.compile({ runId, host: 'cli', ... });
+ *
+ * The statically-exported `Hooks` namespace is a convenience for hosts that
+ * don't need multi-repo isolation — it uses kernel singletons rooted at
+ * process.cwd(). `createHooks()` returns a composed surface bound to the
+ * supplied `ctx.repoRoot` so hosts that manage multiple repos can isolate
+ * reads and mutations to the right working tree.
+ */
+import { ContextHooks } from './context.js';
+import { ExecutionHooks } from './execution.js';
+import { type HealthHooks } from './health.js';
+import { type MemoryHooks } from './memory.js';
+import type { HooksContext } from './types.js';
+import { type RunMergeRequest, type RunMergeResult, type RunStepRequest, type RunStepResult, type RunVerifyRequest, type RunVerifyResult } from '../../kernel/execution/index.js';
+import type { ExecutedStep, RuntimeExecuteInput } from '../../kernel/runtime/index.js';
+import type { CompiledContextRequest, FileRef } from '../../kernel/context/index.js';
+export type { HooksContext, HookResult } from './types.js';
+/**
+ * Stateless hooks that don't need a HooksContext.
+ * - Context + Execution delegate directly to kernel singletons rooted at
+ *   process.cwd(). Use `createHooks()` for multi-repo hosts.
+ */
+export declare const Hooks: {
+    readonly context: {
+        readonly init: () => Promise<void>;
+        readonly compile: (request: CompiledContextRequest) => Promise<import("../../kernel/index.js").CompiledContextPack>;
+        readonly hypertuneMax: (task: string, files: FileRef[], graphConnectivity?: (chunk: {
+            source: string;
+            label: string;
+        }) => number) => {
+            plan: import("../../engines/token-supremacy.js").ReadingPlan;
+            assembly: import("../../engines/context-assembler.js").AssemblyResult;
+            budgetConfig: import("../../engines/context-assembler.js").BudgetConfig;
+        };
+        readonly differential: (prev: import("../../engines/token-supremacy.js").SessionSummary, curr: FileRef[]) => import("../../engines/token-supremacy.js").ContextDelta;
+        readonly loadLatestSessionSummary: () => Promise<import("../../engines/token-supremacy.js").SessionSummary | null>;
+        readonly allocateBudget: (workers: Array<{
+            id: string;
+            estimatedValue: number;
+            estimatedCost: number;
+        }>, totalBudget?: number) => import("../../engines/token-supremacy.js").TokenBudget;
+    };
+    readonly execution: {
+        readonly step: (request: RunStepRequest) => Promise<RunStepResult>;
+        readonly verify: (request: RunVerifyRequest) => Promise<RunVerifyResult>;
+        readonly merge: (request: RunMergeRequest) => Promise<RunMergeResult>;
+        readonly execute: (request: RuntimeExecuteInput) => Promise<ExecutedStep>;
+    };
+};
+export type BoundContextHooks = typeof ContextHooks;
+export type BoundExecutionHooks = typeof ExecutionHooks;
+export interface ComposedHooks {
+    context: BoundContextHooks;
+    execution: BoundExecutionHooks;
+    health: HealthHooks;
+    memory: MemoryHooks;
+}
+/**
+ * Compose a fully-wired hooks namespace for a host that has memory + runtime
+ * providers. Throws at construction time if required providers are missing —
+ * fail-fast contract so hosts catch wiring errors early.
+ *
+ * Context + execution are bound to `ctx.repoRoot`:
+ * - context.compile / hypertuneMax / differential pre-resolve relative paths
+ *   against repoRoot before calling the kernel.
+ * - execution uses a dedicated KernelExecutionServiceImpl rooted at repoRoot;
+ *   the process-wide kernel singleton is left untouched.
+ */
+export declare function createHooks(ctx: HooksContext): ComposedHooks;
+export { ContextHooks } from './context.js';
+export { ExecutionHooks } from './execution.js';
+export type { HealthHooks } from './health.js';
+export type { MemoryHooks } from './memory.js';