@tealbrick/portal 0.1.2 → 0.2.5

package/MANAGEMENT.md

@@ -0,0 +1,147 @@
+# Routine activation (Eve 0.58.1)
+
+Explicitly mount `@tealbrick/portal/management/eve` in the agent. Installation
+alone exposes nothing. Only a Portal user with a signed `manage` grant for the
+configured organization and agent may invoke these routes; `use` and agent-to-agent
+grants cannot manage processes.
+
+```ts
+// agent/channels/management.ts
+import { managementChannel } from '@tealbrick/portal/management/eve';
+export default managementChannel({
+  auth: {
+    issuer: 'https://portal.tealbrick.com',
+    org: process.env.TEALBRICK_ORG!,
+    agent: process.env.TEALBRICK_AGENT!,
+  },
+  appRoot: '/srv/eve',
+  buildCommand: ['/usr/bin/npm', 'run', 'build'],
+  restartCommand: ['/usr/bin/systemctl', '--user', 'restart', 'eve.service'],
+});
+```
+
+Paths, service name and executable locations are deployment configuration, not
+portable defaults. The service must run the production `eve start` output, with
+persistent workflow storage. Do not use `eve dev` or an HTTP-only runner for cron.
+The agent service account must be allowed to restart only its own service. For
+system services use a narrowly scoped host supervisor helper instead of granting
+arbitrary sudo. The desktop never sends executable names, arguments or SSH keys.
+
+For AVMM, configure a supervisor that restarts the Eve service in the current
+worker and preserves its authored files. This is not a worker-disk rebuild or a
+VM stop/start: catalog activation can replace runtime files. No AVMM CLI runs on
+Puma. Configure and verify the adapter on the deployment host.
+
+GET `/eve/v1/tealbrick/management` reports supported operations and fails closed
+if build/restart configuration is missing. POST to the same route accepts:
+
+- `{operation: 'upsert', name, cron, instruction, requestId}` creates a new
+  root-authored TypeScript schedule; existing names are rejected (not overwritten).
+- `{operation: 'delete', name, requestId}` moves a root-authored `.ts` schedule
+  to receipt storage before rebuilding. Extension and Markdown definitions are
+  not deleted by this API.
+- `{operation: 'restart', requestId}` rebuilds and restarts without editing files.
+
+`requestId` must be unique per intended action (UUID recommended). Persisted
+receipts in `.tealbrick/activation/` prevent replaying the same action after a
+lost response. Reusing an ID with different content or identity is rejected.
+Do not automatically retry an uncertain action with a fresh ID.
+
+A failed build leaves the authored change saved and never restarts. Repair the
+source and invoke `restart` with a new ID. Deletion retains a source copy under
+the request ID. Restore it explicitly if rollback is needed. Preserve receipts
+and workflow state across service restarts. An interrupted activation may leave
+an `activation/lock` directory: inspect its receipt and running build before
+removing that lock during operator recovery.
+
+`202 / restart_queued` means build completed and the trusted command was queued,
+not that the new process started or a cron occurrence ran. The delayed command's
+completion/failure is recorded when possible; a service restart can terminate its
+reporter. Desktop observes the exact schedule in production `/eve/v1/info` and
+still does not claim execution or delivery. `hasRun` is handler presence only.
+
+Validation: authenticated disposable tests exercise actual build/restart child
+processes, failed builds, replay, grant denial, path rejection, missing config,
+and preserved deletion. They are not live AVMM or systemd acceptance. For each
+deployment require production discovery, a real cron tick and expected delivery.
+
+## Optional host wake
+
+Normal Eve scheduling remains the default. Supply `wake: HostWakeAdapter` in
+management configuration to offer host wake. GET reports support, managed routine
+names, requested wake names and `pending` reconciliation state. POST creation
+accepts `wake: true`; omitted/false creates no host registration. For a routine
+created by this management API, `{operation:'wake', name, wake:boolean, requestId}`
+changes wake registration without rebuilding or restarting Eve. Removing a routine
+also removes its registration. Existing source/extension routines are not inferred
+or imported into the management catalog.
+
+The AVMM implementation is exported from `@tealbrick/avm/wake`:
+
+```ts
+import { createAvmmWakeAdapter } from '@tealbrick/avm/wake';
+const wake = createAvmmWakeAdapter({
+  transport: hostOwnedTransport, // trusted host service, bound to one host
+  worker: 'my-durable-worker',
+  ownerKey: 'organization-id:logical-agent-id', // stable, unique server config
+  allowed: true, // explicit host operator authorization; never from browser input
+  timezone: 'UTC', // verify production Eve cron uses UTC before opting in
+  harness: 'eve',
+  leadSeconds: 60,
+});
+// Pass `wake` to managementChannel alongside the existing activation settings.
+```
+
+Keep host authority in a trusted host service. Do not put root/operator SSH keys
+in an Eve worker or the desktop. If management runs inside the worker, implement
+a narrow authenticated HostWakeAdapter RPC to that host service, fixed to that
+worker and logical agent. This package does not provision that deployment boundary.
+The AVMM CLI transport is host-owned; do not execute it locally on Puma.
+
+Capability checks read scheduler availability, durable-worker mode, harness grant
+and an idle timeout longer than the wake lead. Actual host writes remain subject
+to host authorization and may fail. Failure leaves explicit pending intent; an
+operator can reconcile it using Restart agent after repairing host access. This
+can delay activation of an explicitly opted-in routine; ordinary opt-out creation
+has no host dependency when there is no earlier pending wake change.
+
+AVMM registrations wake the worker ahead of the cron tick and run `/usr/bin/true`
+with `--keep-running`. They never invoke Eve or the routine payload. Existing host
+idle policy still applies. Supported timings are UTC minute/hour intervals that
+divide the hour/day, daily, weekly and weekdays. Monthly and other expressions
+are rejected when wake is requested. Late wakes, slow boot and missed ticks are
+not replayed. Wake registration is not proof of execution or delivery. Confirm
+boot time, idle behavior, a real tick and delivery on each deployment.
+
+exe.dev and other providers have no built-in wake adapter yet; they report
+unsupported unless the operator supplies a verified implementation. No provider
+is selected from an agent URL. Stable registration IDs are scoped by ownerKey and
+worker; reconciliation touches only that namespace. Preserve ownerKey and wake
+state across upgrades; deliberate ownership migration needs cleanup of old IDs.
+
+## Chat delivery and rotating AVMM credentials
+
+The native Eve management channel authors handler schedules that send through
+that same channel with Eve's application auth. `deliveryChannelImport` defaults
+to `../channels/management.js`; set it explicitly if the mounted file has another
+name. The signed managing user's subject owns the delivery, not browser input.
+GET management returns only that subject's completed text deliveries (last 100),
+plus authored instruction metadata. Durable files live in
+`.tealbrick/routine-delivery`; repeated event IDs replace the same file. Preserve
+this directory with workflow state. Retention beyond the returned 100 is an
+operator concern. The desktop merges these events by ID into the agent chat.
+
+AVMM assignments can rotate shared Codex broker leases. An OpenAI client that
+captures the startup lease will fail after the first wake assignment. Configure
+`createAvmmBrokerFetch` from `@tealbrick/provider-transport/avmm` as the provider's
+fetch implementation, with the trusted broker baseURL and
+`/run/agentvm/auth/codex.env`. It reads the current lease for every request and
+refuses other destinations. Only then set the host adapter's
+`credentialsRefreshOnRequest: true`. The adapter requires and requests the
+worker's existing `model:codex-subscription` capability for shared Codex auth.
+
+`examples/avmm-routine-wake/server.mjs` is a fixed-worker host RPC example. Its
+configuration must be root-owned, its bearer shared only with that worker, and
+both firewall layers must allow only the intended worker address/MAC to the
+host bridge port. The example does not provision firewall rules or systemd units.
+Recheck these rules after AVMM upgrades; generated nft configuration may change.

package/dist/client.js

@@ -10,6 +10,35 @@ export class PortalHttpError extends Error {
         this.name = "PortalHttpError";
     }
 }
+/** Bound untrusted control-plane responses, including error bodies. No payload logging. */
+async function boundedResponse(response) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        return null;
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > 2097152)
+                throw Error('portal_response_too_large');
+            chunks.push(value);
+        }
+        const bytes = new Uint8Array(size);
+        let offset = 0;
+        for (const part of chunks) {
+            bytes.set(part, offset);
+            offset += part.byteLength;
+        }
+        return JSON.parse(new TextDecoder().decode(bytes));
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+    }
+}
 /** No credential storage or logging; instantiate in a trusted runtime for agent credentials. */
 export class PortalClient {
     options;
@@ -46,7 +75,7 @@ export class PortalClient {
                 ])
                 : AbortSignal.timeout(this.options.timeoutMs ?? 15000),
         });
-        const data = await response.json().catch(() => null);
+        const data = await boundedResponse(response).catch(() => null);
         if (!response.ok)
             throw new PortalHttpError(response.status, typeof data?.error === "string" && /^[a-z_]+$/.test(data.error)
                 ? data.error

package/dist/knowledge-native.d.ts

@@ -0,0 +1,19 @@
+/** Versioned public Knowledge memory verbs, not upstream host administration. */
+export declare const nativeMemoryReads: readonly ["recall", "entity", "synthesize", "context_pack", "delta", "query", "search", "think", "get_page", "list_pages", "get_chunks", "resolve_slugs", "get_links", "get_backlinks", "traverse_graph", "get_timeline", "find_trajectory", "takes_list", "takes_search"];
+export declare const nativeMemoryOperations: readonly ["recall", "entity", "synthesize", "context_pack", "delta", "query", "search", "think", "get_page", "list_pages", "get_chunks", "resolve_slugs", "get_links", "get_backlinks", "traverse_graph", "get_timeline", "find_trajectory", "takes_list", "takes_search", "remember", "forget"];
+export type NativeRuntimeOperation = 'memory_tools' | `memory_native_${typeof nativeMemoryOperations[number]}`;
+export declare function nativeRequiredActions(operation: string): readonly ('create' | 'read' | 'update' | 'delete')[];
+export declare function nativeRequest(operation: string, input: Record<string, unknown>, partition: string): {
+    path: string;
+    method: string;
+    body: Record<string, unknown> | undefined;
+    key: string | undefined;
+} | {
+    path: string;
+    method: string;
+    body: {
+        partitionKey: string;
+        arguments: object;
+    };
+    key: string | undefined;
+};

package/dist/knowledge-native.js

@@ -0,0 +1,36 @@
+/** Versioned public Knowledge memory verbs, not upstream host administration. */
+export const nativeMemoryReads = ['recall', 'entity', 'synthesize', 'context_pack', 'delta', 'query', 'search', 'think', 'get_page', 'list_pages', 'get_chunks', 'resolve_slugs', 'get_links', 'get_backlinks', 'traverse_graph', 'get_timeline', 'find_trajectory', 'takes_list', 'takes_search'];
+export const nativeMemoryOperations = [...nativeMemoryReads, 'remember', 'forget'];
+export function nativeRequiredActions(operation) {
+    if (operation === 'memory_tools')
+        return ['read'];
+    if (operation === 'memory_native_remember')
+        return ['create', 'update'];
+    if (operation === 'memory_native_forget')
+        return ['delete'];
+    if (nativeMemoryReads.some(name => operation === `memory_native_${name}`))
+        return ['read'];
+    throw Error('runtime_action_denied');
+}
+export function nativeRequest(operation, input, partition) {
+    if (operation === 'memory_tools') {
+        if (Object.keys(input).length)
+            throw Error('runtime_invalid_input');
+        return { path: '/api/brain/native/tools?' + new URLSearchParams({ partitionKey: partition }), method: 'GET', body: undefined, key: undefined };
+    }
+    nativeRequiredActions(operation);
+    if (Object.keys(input).some(k => !['arguments', 'idempotencyKey'].includes(k)) || !input.arguments || typeof input.arguments !== 'object' || Array.isArray(input.arguments))
+        throw Error('runtime_invalid_input');
+    for (const reserved of ['source_id', 'source_ids', 'partitionKey', 'principalId', 'agentId', 'actorId', 'token', 'authorization'])
+        if (Object.hasOwn(input.arguments, reserved))
+            throw Error('runtime_invalid_input');
+    const name = operation.slice('memory_native_'.length), key = input.idempotencyKey;
+    if ((name === 'remember' || name === 'forget') && !key)
+        throw Error('runtime_idempotency_key_required');
+    if (key !== undefined && (typeof key !== 'string' || !/^[A-Za-z0-9._:-]{1,200}$/.test(key)))
+        throw Error('runtime_invalid_input');
+    const body = { partitionKey: partition, arguments: input.arguments };
+    if (Buffer.byteLength(JSON.stringify(body)) > 1024 * 1024)
+        throw Error('runtime_invalid_input');
+    return { path: '/api/brain/native/' + name, method: 'POST', body, key: key };
+}

package/dist/management-eve.d.ts

@@ -0,0 +1,7 @@
+import { type ManagementOptions } from './management.js';
+/** Explicit mount; importing the package starts no processes and registers no routes. */
+export declare function managementChannel(options: ManagementOptions): import("eve/channels").Channel<{
+    owner: string;
+    name: string;
+    occurrence: string;
+} | undefined, Record<string, unknown>, Record<string, unknown>>;

package/dist/management-eve.js

@@ -0,0 +1,31 @@
+import { saveRoutineDelivery } from './routine-delivery.js';
+import { defineChannel, GET, POST } from 'eve/channels';
+import { createManagementHandler } from './management.js';
+/** Explicit mount; importing the package starts no processes and registers no routes. */
+export function managementChannel(options) {
+    const handle = createManagementHandler({ ...options, deliveryChannelImport: options.deliveryChannelImport ?? "../channels/management.js" });
+    return defineChannel({
+        state: { owner: '', name: '', occurrence: '' },
+        context: state => ({ state }),
+        receive(input, { from }) {
+            const { owner, name } = input.target;
+            const occurrence = typeof input.target.occurrence === 'string' ? input.target.occurrence : '';
+            if (typeof owner !== 'string' || typeof name !== 'string')
+                throw Error('invalid_routine_target');
+            return from(JSON.stringify([owner, name, occurrence])).send(input.message, { auth: input.auth, state: { owner, name, occurrence }, title: `Routine: ${name}` });
+        },
+        events: {
+            async 'message.completed'(event, channel, ctx) {
+                if (!event.message || event.finishReason === 'tool-calls')
+                    return;
+                await saveRoutineDelivery(options.appRoot, { id: `${ctx.session.id}:${event.turnId}:${event.sequence}`, owner: channel.state.owner, name: channel.state.name, text: event.message, at: Date.now(), sessionId: ctx.session.id });
+                if (channel.state.occurrence && options.routines)
+                    await options.routines.call('complete', { id: channel.state.occurrence });
+            },
+        },
+        routes: [
+            GET('/eve/v1/tealbrick/management', request => handle('status', request)),
+            POST('/eve/v1/tealbrick/management', request => handle('apply', request)),
+        ]
+    });
+}

package/dist/management.d.ts

@@ -0,0 +1,18 @@
+import type { HostWakeAdapter } from './wake.js';
+import { type AuthOptions } from './auth.js';
+export interface ManagementOptions {
+    auth: AuthOptions;
+    wake?: HostWakeAdapter;
+    /** Scoped host routine bridge; operator-configured, never browser supplied. */
+    routines?: {
+        owner: string;
+        call(action: string, input?: Record<string, unknown>): Promise<any>;
+    };
+    /** Trusted authored channel import, enabled by managementChannel. */
+    deliveryChannelImport?: string;
+    appRoot: string;
+    /** Trusted operator configuration only. No shell expansion or request-supplied commands. */
+    buildCommand: readonly [string, ...string[]];
+    restartCommand: readonly [string, ...string[]];
+}
+export declare function createManagementHandler(options: ManagementOptions): (action: "status" | "apply", request: Request) => Promise<Response>;

package/dist/management.js

@@ -0,0 +1,215 @@
+import { readRoutineDeliveries } from './routine-delivery.js';
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, writeFile, rename, lstat, rm } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+import { createPortalVerifier } from './auth.js';
+const json = (data, status = 200) => Response.json(data, { status });
+export function createManagementHandler(options) {
+    const verifier = createPortalVerifier(options.auth);
+    const root = resolve(options.appRoot);
+    const state = join(root, '.tealbrick', 'activation');
+    return async (action, request) => {
+        const identity = await verifier.authenticate(request);
+        if (!identity.ok)
+            return json({ ok: false, error: identity.code }, identity.status);
+        if (identity.principal.type !== 'user' || identity.principal.level !== 'manage')
+            return json({ ok: false, error: 'manage_grant_required' }, 403);
+        if (options.routines && identity.principal.id !== options.routines.owner)
+            return json({ ok: false, error: 'routine_owner_not_granted' }, 403);
+        if (options.routines && action === 'status') {
+            try {
+                const snapshot = await options.routines.call('status');
+                return json({ ok: true, protocol: 2, activation: 'dynamic', dynamic: true, delivery: true, ...snapshot,
+                    definitions: Object.fromEntries(snapshot.routines.map((r) => [r.name, { cron: r.cron, markdown: r.instruction }])),
+                    deliveries: await readRoutineDeliveries(root, identity.principal.id), operations: ['upsert', 'update', 'delete', 'restart', 'wake'] });
+            }
+            catch {
+                return json({ ok: false, error: 'routine_host_unavailable' }, 503);
+            }
+        }
+        if (options.routines && action === 'apply') {
+            try {
+                const text = await request.text();
+                if (text.length > 20000)
+                    return json({ ok: false, error: 'request_too_large' }, 413);
+                const input = JSON.parse(text);
+                if (input.operation !== 'restart')
+                    return json(await options.routines.call('apply', input));
+                // Restart remains a separate explicit lifecycle action.
+                request = new Request(request.url, { method: 'POST', headers: request.headers, body: text });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : '';
+                const allowed = ['revision_conflict', 'schedule_exists', 'schedule_not_found', 'wake_unavailable', 'invalid_cron', 'unsupported_wake_cron', 'request_id_conflict'];
+                return json({ ok: false, error: allowed.includes(message) ? message : 'routine_change_failed' }, 409);
+            }
+        }
+        if (!options.buildCommand?.length || !options.restartCommand?.length)
+            return json({ ok: false, error: 'host_activation_not_configured' }, 503);
+        if (action === 'status') {
+            const wake = options.wake ? await options.wake.status().catch(() => ({ supported: false, reason: 'Host wake unavailable.' })) : { supported: false, reason: 'This host has no wake adapter configured.' };
+            const wakeState = JSON.parse(await readFile(join(state, 'wake.json'), 'utf8').catch(() => ' {"routines":[],"catalog":{}}'));
+            return json({ ok: true, protocol: 1, activation: 'build-restart', delivery: Boolean(options.deliveryChannelImport), deliveries: await readRoutineDeliveries(root, identity.principal.id), definitions: wakeState.definitions ?? {}, operations: ['upsert', 'delete', 'restart', 'wake'], wake: { ...wake, pending: Boolean(wakeState.dirty), managed: Object.keys(wakeState.catalog ?? {}), routines: wakeState.routines.map((r) => r.name) } });
+        }
+        let input;
+        try {
+            const text = await request.text();
+            if (text.length > 20000)
+                return json({ ok: false, error: 'request_too_large' }, 413);
+            input = JSON.parse(text);
+        }
+        catch {
+            return json({ ok: false, error: 'invalid_request' }, 400);
+        }
+        if (!input || typeof input !== 'object')
+            return json({ ok: false, error: 'invalid_request' }, 400);
+        const { operation, name, cron, instruction, requestId, wake = false } = input;
+        if (typeof wake !== "boolean")
+            return json({ ok: false, error: "invalid_wake_setting" }, 400);
+        if (wake && operation !== "upsert" && operation !== "wake")
+            return json({ ok: false, error: "invalid_wake_operation" }, 400);
+        if (!['upsert', 'delete', 'restart', 'wake'].includes(String(operation)) || typeof requestId !== 'string' || !/^[a-zA-Z0-9-]{16,80}$/.test(requestId))
+            return json({ ok: false, error: 'invalid_operation' }, 400);
+        if (operation !== 'restart' && (typeof name !== 'string' || !/^[a-z0-9][a-z0-9-]{0,47}$/.test(name)))
+            return json({ ok: false, error: 'invalid_schedule_name' }, 400);
+        if (operation === 'upsert' && (typeof cron !== 'string' || cron.length > 120 || cron.trim().split(/\s+/).length !== 5 || typeof instruction !== 'string' || !instruction.trim() || instruction.length > 12000))
+            return json({ ok: false, error: 'invalid_schedule' }, 400);
+        if (wake) {
+            if (!options.wake || !(await options.wake.status().catch(() => ({ supported: false }))).supported)
+                return json({ ok: false, error: 'host_wake_unavailable' }, 409);
+            try {
+                if (operation === 'upsert')
+                    options.wake.validate([{ name: String(name), cron: String(cron) }]);
+            }
+            catch {
+                return json({ ok: false, error: 'unsupported_wake_cron' }, 400);
+            }
+        }
+        const digest = createHash('sha256').update(JSON.stringify([identity.principal.id, operation, name, cron, instruction, wake])).digest('hex');
+        await mkdir(state, { recursive: true, mode: 0o700 });
+        const receipt = join(state, `${requestId}.json`);
+        const existing = await readFile(receipt, 'utf8').catch(() => null);
+        if (existing) {
+            const previous = JSON.parse(existing);
+            return previous.digest === digest ? json(previous, previous.ok ? 200 : 409) : json({ ok: false, error: 'request_id_conflict' }, 409);
+        }
+        const lock = join(state, 'lock');
+        try {
+            await mkdir(lock);
+        }
+        catch {
+            return json({ ok: false, error: 'activation_busy' }, 409);
+        }
+        let saved = false;
+        let queued = false;
+        const record = async (value) => {
+            const body = { requestId, digest, ...value };
+            const temp = `${receipt}.${randomUUID()}.tmp`;
+            await writeFile(temp, JSON.stringify(body), { mode: 0o600 });
+            await rename(temp, receipt);
+            return body;
+        };
+        try {
+            // Recheck after acquiring the inter-process lock. Never repeat an ambiguous operation.
+            const raced = await readFile(receipt, 'utf8').catch(() => null);
+            if (raced) {
+                const prior = JSON.parse(raced);
+                return prior.digest === digest ? json(prior, prior.ok ? 200 : 409) : json({ ok: false, error: 'request_id_conflict' }, 409);
+            }
+            const wakeFile = join(state, 'wake.json');
+            const wakeState = JSON.parse(await readFile(wakeFile, 'utf8').catch(() => ' {"dirty":false,"routines":[]}'));
+            const saveWake = async () => { const tmp = wakeFile + '.tmp'; await writeFile(tmp, JSON.stringify(wakeState), { mode: 0o600 }); await rename(tmp, wakeFile); };
+            wakeState.catalog ??= {};
+            wakeState.definitions ??= {};
+            if (operation === 'wake') {
+                const selectedCron = wakeState.catalog[String(name)];
+                if (!selectedCron)
+                    return json({ ok: false, error: 'routine_not_managed' }, 409);
+                if (wake)
+                    options.wake.validate([{ name: String(name), cron: selectedCron }]);
+                wakeState.routines = wakeState.routines.filter(r => r.name !== name);
+                if (wake)
+                    wakeState.routines.push({ name: String(name), cron: selectedCron });
+                wakeState.dirty = true;
+            }
+            if ((wake && operation === 'upsert') || (operation === 'delete' && wakeState.routines.some(r => r.name === name))) {
+                wakeState.routines = wakeState.routines.filter(r => r.name !== name);
+                if (wake)
+                    wakeState.routines.push({ name: String(name), cron: String(cron) });
+                wakeState.dirty = true;
+            }
+            await record({ ok: false, state: 'applying' });
+            if (operation === 'upsert' || operation === 'delete') {
+                const dir = join(root, 'agent', 'schedules');
+                await mkdir(dir, { recursive: true });
+                for (const path of [join(root, 'agent'), dir])
+                    if ((await lstat(path)).isSymbolicLink())
+                        throw Error('unsafe_schedule_path');
+                const file = join(dir, `${name}.ts`);
+                const stat = await lstat(file).catch(() => null);
+                if (stat?.isSymbolicLink())
+                    throw Error('unsafe_schedule_path');
+                if (operation === 'upsert') {
+                    if (stat)
+                        throw Error('schedule_exists');
+                    const source = options.deliveryChannelImport
+                        ? `import { defineSchedule } from "eve/schedules";\nimport delivery from ${JSON.stringify(options.deliveryChannelImport)};\nexport default defineSchedule({cron:${JSON.stringify(cron)},async run({to,waitUntil,appAuth}) { waitUntil(to(delivery,${JSON.stringify({ name, owner: identity.principal.id })}).send(${JSON.stringify(instruction)},{auth:appAuth})); }});\n`
+                        : `import { defineSchedule } from "eve/schedules";\nexport default defineSchedule(${JSON.stringify({ cron, markdown: instruction })});\n`;
+                    await writeFile(file, source, { flag: 'wx', mode: 0o600 });
+                }
+                else {
+                    if (!stat)
+                        throw Error('schedule_not_found');
+                    await rename(file, join(state, `${requestId}.schedule.ts`));
+                }
+                saved = true;
+                if (operation === 'upsert') {
+                    wakeState.catalog[String(name)] = String(cron);
+                    wakeState.definitions[String(name)] = { cron: String(cron), markdown: String(instruction) };
+                }
+                else {
+                    delete wakeState.catalog[String(name)];
+                    delete wakeState.definitions[String(name)];
+                }
+                await saveWake();
+            }
+            if (wakeState.dirty)
+                await saveWake();
+            if (operation !== 'wake')
+                await runBuild(options.buildCommand, root);
+            if (wakeState.dirty) {
+                if (!options.wake)
+                    throw Error('wake_adapter_missing');
+                await options.wake.reconcile(wakeState.routines);
+                wakeState.dirty = false;
+                await saveWake();
+            }
+            if (operation === 'wake')
+                return json(await record({ ok: true, state: 'wake_updated', saved: true }));
+            // Persist intent before spawning. A lost response must not repeat a restart.
+            await record({ ok: false, state: 'restart_pending', saved });
+            const script = `const {spawn}=require('node:child_process'); const fs=require('node:fs'); const [file,cwd,command,args,lock]=process.argv.slice(1); setTimeout(()=>{const p=spawn(command,JSON.parse(args),{cwd,stdio:'ignore',shell:false}); const unlock=()=>{try{fs.rmSync(lock,{recursive:true,force:true});}catch{}};p.on('spawn',unlock); const finish=(state)=>{unlock();try{const r=JSON.parse(fs.readFileSync(file,'utf8'));r.restartState=state;fs.writeFileSync(file,JSON.stringify(r),{mode:384});}catch{}};p.on('error',()=>finish('failed'));p.on('exit',code=>finish(code===0?'command_completed':'failed'));},1500);`;
+            const worker = spawn(process.execPath, ['-e', script, receipt, root, options.restartCommand[0], JSON.stringify(options.restartCommand.slice(1)), lock], { cwd: root, detached: true, stdio: 'ignore', shell: false });
+            await new Promise((yes, no) => { worker.once('spawn', yes); worker.once('error', no); });
+            worker.unref();
+            queued = true;
+            return json(await record({ ok: true, state: 'restart_queued', saved, name, restarted: true }), 202);
+        }
+        catch (error) {
+            const code = error instanceof Error && ['schedule_exists', 'schedule_not_found', 'unsafe_schedule_path'].includes(error.message) ? error.message : 'activation_failed';
+            return json(await record({ ok: false, state: 'failed', saved, error: code }), 409);
+        }
+        finally {
+            if (!queued)
+                await rm(lock, { recursive: true, force: true });
+        }
+    };
+}
+async function runBuild(command, cwd) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command[0], command.slice(1), { cwd, stdio: 'ignore', shell: false, timeout: 300000 });
+        child.once('error', reject);
+        child.once('exit', code => code === 0 ? resolve() : reject(Error('build_failed')));
+    });
+}

package/dist/routine-delivery.d.ts

@@ -0,0 +1,10 @@
+export interface RoutineDelivery {
+    id: string;
+    owner: string;
+    name: string;
+    text: string;
+    at: number;
+    sessionId: string;
+}
+export declare function saveRoutineDelivery(root: string, row: RoutineDelivery): Promise<void>;
+export declare function readRoutineDeliveries(root: string, owner: string): Promise<RoutineDelivery[]>;

package/dist/routine-delivery.js

@@ -0,0 +1,16 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, readdir, writeFile, rename } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function saveRoutineDelivery(root, row) {
+    const dir = join(root, '.tealbrick', 'routine-delivery');
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    const file = join(dir, createHash('sha256').update(row.id).digest('hex') + '.json');
+    await writeFile(file + '.tmp', JSON.stringify(row), { mode: 0o600 });
+    await rename(file + '.tmp', file);
+}
+export async function readRoutineDeliveries(root, owner) {
+    const dir = join(root, '.tealbrick', 'routine-delivery');
+    const files = await readdir(dir).catch(() => []);
+    const rows = await Promise.all(files.filter(f => /^[a-f0-9]{64}\.json$/.test(f)).map(async (f) => JSON.parse(await readFile(join(dir, f), 'utf8'))));
+    return rows.filter(r => r.owner === owner).sort((a, b) => a.at - b.at).slice(-100);
+}

package/dist/runtime.d.ts

@@ -0,0 +1,75 @@
+import { type JWTVerifyGetKey } from 'jose';
+import { type NativeRuntimeOperation } from './knowledge-native.js';
+export type CrudAction = 'create' | 'read' | 'update' | 'delete';
+export interface RuntimeApp {
+    registrationId: string;
+    appId: 'knowledge';
+    major: 1;
+    bindingRef: string;
+    instanceId: string;
+    companyId: string;
+    actions: CrudAction[];
+    entitlement: {
+        licenseId: string;
+        major: 1;
+    };
+}
+export interface RuntimeIdentity {
+    issuer: string;
+    org: string;
+    workspaceId: string;
+    agentId: string;
+    connectionId: string;
+}
+export interface LocalBinding {
+    endpoint: string;
+    instanceId: string;
+    companyId: string;
+    credentialRef: string;
+}
+export interface RuntimeOptions extends RuntimeIdentity {
+    credential: () => string | Promise<string>;
+    bindings: Record<string, LocalBinding>;
+    resolveCredential: (reference: string) => string | Promise<string>;
+    fetch?: typeof fetch;
+    keys?: JWTVerifyGetKey;
+    now?: () => number;
+    audit?: (event: {
+        connectionId: string;
+        registrationId: string;
+        operation: string;
+        outcome: 'success' | 'denied' | 'failed';
+        revision?: string;
+    }) => void;
+}
+type LegacyKnowledgeOperation = 'list_collections' | 'create_collection' | 'create_document' | 'get_document' | 'update_document' | 'delete_document' | 'search' | 'memory_recall' | 'memory_context' | 'memory_entities';
+export type KnowledgeOperation = LegacyKnowledgeOperation | NativeRuntimeOperation;
+export declare const knowledgeOperations: readonly KnowledgeOperation[];
+/** Customer-owned execution boundary. Portal receives configuration acknowledgments only. */
+export declare class RuntimeConnector {
+    private readonly options;
+    private readonly issuer;
+    private readonly fetcher;
+    private readonly keys;
+    private cached?;
+    private refreshing?;
+    constructor(options: RuntimeOptions);
+    private now;
+    private portal;
+    private refresh;
+    private matchBinding;
+    private current;
+    capabilities(force?: boolean): Promise<{
+        revision: string;
+        expiresAt: number;
+        apps: {
+            registrationId: string;
+            appId: "knowledge";
+            actions: CrudAction[];
+            available: boolean;
+            operations: KnowledgeOperation[];
+        }[];
+    }>;
+    call(registrationId: string, operation: KnowledgeOperation, input?: Record<string, unknown>, signal?: AbortSignal): Promise<any>;
+}
+export {};

package/dist/runtime.js

@@ -0,0 +1,284 @@
+import { createRemoteJWKSet, customFetch, jwtVerify } from 'jose';
+import { nativeMemoryOperations, nativeRequiredActions, nativeRequest } from './knowledge-native.js';
+const actions = { list_collections: 'read', create_collection: 'create', create_document: 'create', get_document: 'read', update_document: 'update', delete_document: 'delete', search: 'read', memory_recall: 'read', memory_context: 'read', memory_entities: 'read' };
+const allOperations = [...Object.keys(actions), 'memory_tools', ...nativeMemoryOperations.map(name => `memory_native_${name}`)];
+export const knowledgeOperations = Object.freeze([...allOperations]);
+function requiredActions(operation) { return Object.hasOwn(actions, operation) ? [actions[operation]] : nativeRequiredActions(operation); }
+const text = (v) => typeof v === 'string' && v.length > 0 && v.length <= 4096;
+const component = (v) => { if (!text(v) || !/^[a-zA-Z0-9_-]+$/.test(v))
+    throw Error('runtime_invalid_identifier'); return encodeURIComponent(v); };
+function origin(value) { const u = new URL(value); if (u.protocol !== 'https:' || u.username || u.password || u.pathname !== '/' || u.search || u.hash)
+    throw Error('runtime_invalid_issuer'); return u.origin; }
+function endpoint(value) { const u = new URL(value); if ((u.protocol !== 'https:' && !(u.protocol === 'http:' && ['127.0.0.1', '[::1]', 'localhost'].includes(u.hostname))) || u.username || u.password || u.search || u.hash || u.pathname !== '/')
+    throw Error('runtime_invalid_binding_endpoint'); return u.origin; }
+async function boundedJson(response, maxBytes) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw Error('runtime_invalid_response');
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > maxBytes)
+                throw Error('runtime_response_too_large');
+            chunks.push(value);
+        }
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+    }
+}
+function validateApps(value) {
+    if (!Array.isArray(value) || value.length > 100)
+        throw Error('runtime_invalid_config');
+    const ids = new Set();
+    for (const a of value) {
+        if (!a || a.appId !== 'knowledge' || a.major !== 1 || !['registrationId', 'bindingRef', 'instanceId', 'companyId'].every(k => text(a[k])) || ids.has(a.registrationId) || !Array.isArray(a.actions) || a.actions.some((v) => !['create', 'read', 'update', 'delete'].includes(String(v))) || new Set(a.actions).size !== a.actions.length || !text(a.entitlement?.licenseId) || a.entitlement.major !== 1)
+            throw Error('runtime_invalid_config');
+        ids.add(a.registrationId);
+    }
+    return value;
+}
+/** Customer-owned execution boundary. Portal receives configuration acknowledgments only. */
+export class RuntimeConnector {
+    options;
+    issuer;
+    fetcher;
+    keys;
+    cached;
+    refreshing;
+    constructor(options) {
+        this.options = options;
+        this.issuer = origin(options.issuer);
+        this.fetcher = options.fetch ?? fetch;
+        for (const v of Object.values(options.bindings)) {
+            endpoint(v.endpoint);
+            if (!text(v.instanceId) || !text(v.companyId) || !/^TEALBRICK_[A-Z0-9_]+$/.test(v.credentialRef))
+                throw Error('runtime_invalid_binding');
+        }
+        this.keys = options.keys ?? createRemoteJWKSet(new URL('/.well-known/jwks.json', this.issuer), { [customFetch]: (url, init) => this.fetcher(url, { ...init, redirect: 'error' }) });
+    }
+    now() { return this.options.now?.() ?? Date.now(); }
+    async portal(path, body) {
+        return this.fetcher(new URL(path, this.issuer), { method: body === undefined ? 'GET' : 'POST', headers: { authorization: `Bearer ${await this.options.credential()}`, ...(body === undefined ? {} : { 'content-type': 'application/json' }) }, ...(body === undefined ? {} : { body: JSON.stringify(body) }), redirect: 'error', signal: AbortSignal.timeout(15000) });
+    }
+    async refresh() {
+        let response;
+        try {
+            response = await this.portal('/api/runtime/config');
+        }
+        catch {
+            throw Error('runtime_portal_unavailable');
+        }
+        if (!response.ok) {
+            if (response.status === 401 || response.status === 403)
+                this.cached = undefined;
+            throw Error('runtime_config_unavailable');
+        }
+        try {
+            const envelope = await boundedJson(response, 262144);
+            const { payload } = await jwtVerify(envelope.config, this.keys, { issuer: this.issuer, audience: 'tealbrick-runtime', algorithms: ['ES256'], currentDate: new Date(this.now()), requiredClaims: ['iat', 'exp', 'sub'] });
+            const now = this.now() / 1000;
+            if (payload.typ !== 'tealbrick-runtime-config' || payload.version !== 1 || payload.sub !== this.options.agentId || payload.org !== this.options.org || payload.workspaceId !== this.options.workspaceId || payload.connectionId !== this.options.connectionId || !Number.isInteger(payload.iat) || !Number.isInteger(payload.exp) || payload.exp <= now || payload.iat > now + 5 || payload.exp - payload.iat > 300 || payload.exp - payload.iat <= 0 || typeof payload.revision !== 'string' || !/^[a-f0-9]{64}$/.test(payload.revision) || payload.revision !== envelope.revision)
+                throw Error('runtime_invalid_config');
+            const apps = validateApps(payload.apps);
+            this.cached = { apps, revision: payload.revision, expires: payload.exp * 1000, checked: this.now() };
+            const missing = apps.some(a => !this.matchBinding(a));
+            // An acknowledgement failure must not extend or replace the signed authorization lease.
+            await this.portal('/api/runtime/ack', { revision: payload.revision, status: missing ? 'unavailable' : 'effective', ...(missing ? { errorCode: 'binding_missing' } : {}) }).catch(() => undefined);
+        }
+        catch {
+            this.cached = undefined;
+            throw Error('runtime_configuration_rejected');
+        }
+    }
+    matchBinding(app) { const b = this.options.bindings[app.bindingRef]; return b && b.instanceId === app.instanceId && b.companyId === app.companyId ? b : undefined; }
+    async current(force = false) {
+        if (force || !this.cached || this.now() - this.cached.checked >= 30000) {
+            this.refreshing ??= this.refresh().finally(() => { this.refreshing = undefined; });
+            try {
+                await this.refreshing;
+            }
+            catch (error) {
+                if (force || !this.cached || this.now() >= this.cached.expires)
+                    throw error;
+            }
+        }
+        if (!this.cached || this.now() >= this.cached.expires)
+            throw Error('runtime_authorization_expired');
+        return this.cached;
+    }
+    async capabilities(force = false) { const c = await this.current(force); return { revision: c.revision, expiresAt: c.expires, apps: c.apps.map(a => ({ registrationId: a.registrationId, appId: a.appId, actions: [...a.actions], available: !!this.matchBinding(a), operations: allOperations.filter(op => requiredActions(op).every(action => a.actions.includes(action))) })) }; }
+    async call(registrationId, operation, input = {}, signal) {
+        let revision;
+        let outcome = 'denied';
+        try {
+            const c = await this.current();
+            revision = c.revision;
+            const app = c.apps.find(a => a.registrationId === registrationId);
+            if (!app || !allOperations.includes(operation) || !requiredActions(operation).every(action => app.actions.includes(action)))
+                throw Error('runtime_action_denied');
+            const b = this.matchBinding(app);
+            if (!b)
+                throw Error('runtime_binding_missing');
+            let path, method = 'GET', body, idempotencyKey;
+            const company = component(app.companyId);
+            switch (operation) {
+                default: {
+                    const native = nativeRequest(operation, input, app.companyId);
+                    path = native.path;
+                    method = native.method;
+                    body = native.body;
+                    idempotencyKey = native.key;
+                    break;
+                }
+                case 'list_collections':
+                    path = `/api/companies/${company}/knowledge/collections`;
+                    break;
+                case 'create_collection':
+                    if (!text(input.name))
+                        throw Error('runtime_invalid_input');
+                    path = `/api/companies/${company}/knowledge/collections`;
+                    method = 'POST';
+                    body = { name: input.name };
+                    break;
+                case 'create_document':
+                    if (!text(input.title) || typeof input.body !== 'string' || input.body.length > 100000)
+                        throw Error('runtime_invalid_input');
+                    path = `/api/knowledge/collections/${component(input.collectionId)}/documents`;
+                    method = 'POST';
+                    body = { title: input.title, body: input.body, bodyFormat: 'markdown' };
+                    break;
+                case 'get_document':
+                    path = `/api/knowledge/documents/${component(input.documentId)}`;
+                    break;
+                case 'update_document':
+                    path = `/api/knowledge/documents/${component(input.documentId)}`;
+                    method = 'PATCH';
+                    body = {};
+                    if (input.title !== undefined) {
+                        if (!text(input.title))
+                            throw Error('runtime_invalid_input');
+                        body.title = input.title;
+                    }
+                    if (input.body !== undefined) {
+                        if (typeof input.body !== 'string' || input.body.length > 100000)
+                            throw Error('runtime_invalid_input');
+                        body.body = input.body;
+                    }
+                    if (!Object.keys(body).length)
+                        throw Error('runtime_invalid_input');
+                    break;
+                case 'delete_document':
+                    path = `/api/knowledge/documents/${component(input.documentId)}`;
+                    method = 'DELETE';
+                    break;
+                case 'search':
+                    if (!text(input.query))
+                        throw Error('runtime_invalid_input');
+                    path = `/api/companies/${company}/knowledge/search?q=${encodeURIComponent(input.query)}`;
+                    break;
+                case 'memory_recall':
+                case 'memory_context': {
+                    if (operation === 'memory_context' && !text(input.query))
+                        throw Error('runtime_invalid_input');
+                    body = { partitionKey: app.companyId, scopeRef: app.companyId };
+                    const strings = operation === 'memory_context' ? ['query'] : ['query', 'entity', 'grep', 'sessionId', 'since'];
+                    for (const key of strings)
+                        if (input[key] !== undefined) {
+                            if (!text(input[key]))
+                                throw Error('runtime_invalid_input');
+                            body[key] = input[key];
+                        }
+                    for (const key of operation === 'memory_context' ? ['expand'] : ['includeExpired', 'includePending', 'supersessions'])
+                        if (input[key] !== undefined) {
+                            if (typeof input[key] !== 'boolean')
+                                throw Error('runtime_invalid_input');
+                            body[key] = input[key];
+                        }
+                    if (input.limit !== undefined) {
+                        if (!Number.isInteger(input.limit) || Number(input.limit) < 1 || Number(input.limit) > 100)
+                            throw Error('runtime_invalid_input');
+                        body.limit = input.limit;
+                    }
+                    if (operation === 'memory_context' && input.detail !== undefined) {
+                        if (!['low', 'medium', 'high'].includes(String(input.detail)))
+                            throw Error('runtime_invalid_input');
+                        body.detail = input.detail;
+                    }
+                    if (operation === 'memory_recall' && input.budgetTokens !== undefined) {
+                        if (!Number.isInteger(input.budgetTokens) || Number(input.budgetTokens) < 256 || Number(input.budgetTokens) > 32000)
+                            throw Error('runtime_invalid_input');
+                        body.budgetTokens = input.budgetTokens;
+                    }
+                    path = operation === 'memory_recall' ? '/api/brain/recall' : '/api/brain/context';
+                    method = 'POST';
+                    break;
+                }
+                case 'memory_entities': {
+                    const query = new URLSearchParams({ partitionKey: app.companyId });
+                    if (input.slug !== undefined) {
+                        if (!text(input.slug))
+                            throw Error('runtime_invalid_input');
+                        query.set('slug', input.slug);
+                    }
+                    if (input.limit !== undefined) {
+                        if (!Number.isInteger(input.limit) || Number(input.limit) < 1 || Number(input.limit) > 100)
+                            throw Error('runtime_invalid_input');
+                        query.set('limit', String(input.limit));
+                    }
+                    path = `/api/brain/entities?${query}`;
+                    break;
+                }
+            }
+            // Object IDs must remain within the signed registration partition even if the local
+            // app principal was configured with a broader ceiling. Knowledge checks resolved scope.
+            if (path.startsWith('/api/knowledge/'))
+                path += `?companyId=${company}`;
+            // Recheck after asynchronous credential resolution; no call may start with an expired lease.
+            const token = await this.options.resolveCredential(b.credentialRef);
+            if (!text(token) || /[\r\n]/.test(token))
+                throw Error('runtime_credential_unavailable');
+            if (!this.cached || this.cached.revision !== c.revision)
+                throw Error('runtime_configuration_changed');
+            if (this.now() >= c.expires)
+                throw Error('runtime_authorization_expired');
+            outcome = 'failed';
+            const deadline = AbortSignal.timeout(operation.startsWith('memory_native_') ? 610000 : operation.startsWith('memory_') ? 120000 : 30000);
+            const response = await this.fetcher(new URL(path, endpoint(b.endpoint)), { method, headers: { authorization: `Bearer ${token}`, ...(body ? { 'content-type': 'application/json' } : {}), ...(idempotencyKey ? { 'idempotency-key': idempotencyKey } : {}) }, ...(body ? { body: JSON.stringify(body) } : {}), redirect: 'error', signal: signal ? AbortSignal.any([signal, deadline]) : deadline });
+            if (operation === 'memory_tools' || operation.startsWith('memory_native_')) {
+                const result = await boundedJson(response, 8388608);
+                if (!result || typeof result.ok !== 'boolean' || (!response.ok && result.ok))
+                    throw Error('runtime_app_request_failed');
+                if (operation === 'memory_tools' && result.ok) {
+                    if (!Array.isArray(result.data?.tools))
+                        throw Error('runtime_app_request_failed');
+                    result.data.tools = result.data.tools.filter((tool) => nativeMemoryOperations.includes(tool.name) && nativeRequiredActions(`memory_native_${tool.name}`).every(action => app.actions.includes(action)));
+                }
+                outcome = result.ok ? 'success' : 'denied';
+                return JSON.parse(JSON.stringify(result).replaceAll(token, '[REDACTED]'));
+            }
+            if (!response.ok)
+                throw Error(response.status === 401 || response.status === 403 ? 'runtime_app_denied' : 'runtime_app_request_failed');
+            const result = response.status === 204 ? { ok: true } : await boundedJson(response, 2097152);
+            outcome = 'success';
+            return result;
+        }
+        catch (error) {
+            if (error instanceof Error && /^runtime_[a-z_]+$/.test(error.message))
+                throw error;
+            throw Error('runtime_app_unavailable');
+        }
+        finally {
+            try {
+                this.options.audit?.({ connectionId: this.options.connectionId, registrationId, operation, outcome, revision });
+            }
+            catch { /* Logging must not change execution outcome. */ }
+        }
+    }
+}

package/dist/wake.d.ts

@@ -0,0 +1,17 @@
+/** Optional host adapter. No provider is assumed from an agent's hostname. */
+export interface HostWakeAdapter {
+    status(): Promise<{
+        supported: boolean;
+        provider?: string;
+        timezone?: string;
+        reason?: string;
+    }>;
+    validate(routines: {
+        name: string;
+        cron: string;
+    }[]): void;
+    reconcile(routines: {
+        name: string;
+        cron: string;
+    }[]): Promise<void>;
+}

package/dist/wake.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,18 +1,23 @@
 {
   "name": "@tealbrick/portal",
-  "version": "0.1.2",
+  "version": "0.2.5",
   "type": "module",
   "license": "MIT",
   "files": [
     "dist",
     "README.md",
     "LICENSE",
-    "NOTICE"
+    "NOTICE",
+    "MANAGEMENT.md"
   ],
   "engines": {
     "node": ">=24"
   },
   "exports": {
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    },
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
@@ -20,6 +25,14 @@
     "./eve": {
       "types": "./dist/eve.d.ts",
       "import": "./dist/eve.js"
+    },
+    "./management": {
+      "types": "./dist/management.d.ts",
+      "import": "./dist/management.js"
+    },
+    "./management/eve": {
+      "types": "./dist/management-eve.d.ts",
+      "import": "./dist/management-eve.js"
     }
   },
   "scripts": {
@@ -31,7 +44,7 @@
     "jose": "^6.1.0"
   },
   "peerDependencies": {
-    "eve": ">=0.56.0 <0.57.0"
+    "eve": ">=0.64.1 <0.65.0"
   },
   "peerDependenciesMeta": {
     "eve": {