maka-agent 0.2.0-dev.26.20260909 → 0.2.0-dev.28.20260911

package/node_modules/@maka/runtime/dist/plugin-attachment-service.js

@@ -0,0 +1,53 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+/** Session-owned rich result publication and retrieval. */
+export class PluginAttachmentService extends Service {
+    agents;
+    attachmentRuntime;
+    constructor(ctx, agents) {
+        super(ctx, 'attachments');
+        this.agents = agents;
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error('Only the Host may bind the Attachment Runtime');
+        if (this.attachmentRuntime)
+            throw new Error('Plugin Attachment Runtime is already bound');
+        this.attachmentRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.attachmentRuntime === runtime)
+                this.attachmentRuntime = undefined;
+        }, 'attachments.bindRuntime()');
+    }
+    create(input) {
+        return this.runtime().create(input, this.agents.requireInvocation());
+    }
+    read(ref) {
+        return this.runtime().read(ref, this.agents.requireInvocation());
+    }
+    list() {
+        return this.runtime().list(this.agents.requireInvocation());
+    }
+    runtime() {
+        if (!this.attachmentRuntime)
+            throw new Error('Plugin Attachment Runtime is unavailable');
+        return this.attachmentRuntime;
+    }
+}

package/node_modules/@maka/runtime/dist/plugin-command-service.js

@@ -0,0 +1,100 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+import { PluginScopeRegistry } from './plugin-scope-registry.js';
+import { pluginIdentity, registerPluginContribution, MakaPluginRuntimeError, } from './plugin-runtime.js';
+/** Scoped interactive command contribution registry. Client surfaces consume summaries only. */
+export class PluginCommandService extends Service {
+    registry = new PluginScopeRegistry();
+    constructor(ctx) {
+        super(ctx, 'commands');
+    }
+    register(definition) {
+        validate(definition);
+        const identity = pluginIdentity(this.ctx);
+        return registerPluginContribution(this.ctx, `commands.register(${JSON.stringify(definition.name)})`, () => {
+            const rootId = identity.scopeId;
+            for (const key of keys(definition)) {
+                const existing = this.registry.get(rootId, key);
+                if (existing && existing.entryId !== identity.entryId)
+                    throw new MakaPluginRuntimeError('activation_failed', `Plugin Command ${JSON.stringify(key)} is already registered by ${existing.entryId}`);
+            }
+            const entry = {
+                ...identity,
+                definition: Object.freeze({
+                    ...definition,
+                    aliases: Object.freeze([...(definition.aliases ?? [])]),
+                }),
+                token: Symbol(definition.name),
+                retired: false,
+            };
+            const disposers = keys(definition).map((key) => this.registry.publish(rootId, key, entry));
+            return async () => {
+                await Promise.all(disposers.reverse().map((dispose) => dispose()));
+            };
+        });
+    }
+    list(sessionId) {
+        const visible = this.registry.visible(assertSessionId(sessionId));
+        const seen = new Set();
+        return Object.freeze([...visible.values()]
+            .filter((entry) => !seen.has(entry) && Boolean(seen.add(entry)))
+            .sort((a, b) => a.definition.name.localeCompare(b.definition.name))
+            .map(({ definition, extensionId }) => Object.freeze({
+            name: definition.name,
+            description: definition.description,
+            aliases: Object.freeze([...(definition.aliases ?? [])]),
+            extensionId,
+        })));
+    }
+    async execute(name, context) {
+        const entry = this.registry.visible(assertSessionId(context.sessionId)).get(name);
+        if (!entry)
+            throw new Error(`Plugin Command is unavailable: ${name}`);
+        return await entry.definition.execute(Object.freeze({ ...context, args: Object.freeze([...context.args]) }));
+    }
+    inspect(rootId) {
+        const seen = new Set();
+        return Object.freeze([...this.registry.entries(rootId)]
+            .filter((entry) => !seen.has(entry) && Boolean(seen.add(entry)))
+            .sort((a, b) => a.definition.name.localeCompare(b.definition.name))
+            .map(({ definition, token: _token, retired: _retired, ...identity }) => Object.freeze({
+            ...identity,
+            name: definition.name,
+            description: definition.description,
+            aliases: Object.freeze([...(definition.aliases ?? [])]),
+        })));
+    }
+}
+function keys(definition) {
+    return Object.freeze([definition.name, ...(definition.aliases ?? [])]);
+}
+function validate(definition) {
+    const all = keys(definition);
+    if (!definition.description.trim() || typeof definition.execute !== 'function')
+        throw new TypeError('Plugin Command description and execute are required');
+    if (new Set(all).size !== all.length ||
+        all.some((name) => !/^[a-z][a-z0-9]*(?:[-_:][a-z0-9]+)*$/u.test(name)))
+        throw new TypeError('Plugin Command names and aliases are invalid');
+}
+function assertSessionId(value) {
+    if (!value || /[\0\r\n]/u.test(value))
+        throw new TypeError('Session id is invalid');
+    return value;
+}

package/node_modules/@maka/runtime/dist/plugin-composition-loader.js

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+/// <reference lib="es2023.collection" />
 import { Context } from './plugin-kernel.js';
 import { fiberStateName, MakaPluginRuntimeError, MakaPluginTransactionBuffer, validateCompositionEntry, validatePluginPackage, validatePluginRootId, } from './plugin-runtime.js';
 const FIBER_PENDING = 0;
@@ -25,7 +26,13 @@ export class MakaCompositionLoader {
     #packages = new Map();
     #roots = new Map();
     #entries = new Map();
+    // Contexts and services can outlive their entries, so intern by symbol lifetime.
     #isolationLabels = new Map();
+    #isolationLabelFinalizer = new FinalizationRegistry(({ label, reference }) => {
+        // An old finalizer must not evict a newer incarnation of the same label.
+        if (this.#isolationLabels.get(label) === reference)
+            this.#isolationLabels.delete(label);
+    });
     #transaction;
     #compositionGeneration = 0;
     #fiberGeneration = 0;
@@ -675,10 +682,12 @@ export class MakaCompositionLoader {
         });
     }
     #isolationLabel(label) {
-        let symbol = this.#isolationLabels.get(label);
+        let symbol = this.#isolationLabels.get(label)?.deref();
         if (!symbol) {
             symbol = Symbol(label);
-            this.#isolationLabels.set(label, symbol);
+            const reference = new WeakRef(symbol);
+            this.#isolationLabels.set(label, reference);
+            this.#isolationLabelFinalizer.register(symbol, { label, reference });
         }
         return symbol;
     }

package/node_modules/@maka/runtime/dist/plugin-data-services.js

@@ -0,0 +1,332 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+import { pluginIdentity, registerPluginContribution } from './plugin-runtime.js';
+class PluginNamespacedDataService extends Service {
+    domain;
+    dataRuntime;
+    constructor(ctx, name, domain) {
+        super(ctx, name);
+        this.domain = domain;
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error(`Only the Host may bind the Plugin ${this.domain} Runtime`);
+        if (this.dataRuntime)
+            throw new Error(`Plugin ${this.domain} Runtime is already bound`);
+        this.dataRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.dataRuntime === runtime)
+                this.dataRuntime = undefined;
+        }, `${this.domain}.bindRuntime()`);
+    }
+    runtime() {
+        if (!this.dataRuntime)
+            throw new Error(`Plugin ${this.domain} Runtime is unavailable`);
+        return this.dataRuntime;
+    }
+    namespace() {
+        const { extensionId, scopeId } = pluginIdentity(this.ctx);
+        return Object.freeze({ extensionId, scopeId });
+    }
+    readValue(key) {
+        return this.runtime().read(this.namespace(), this.domain, validKey(key));
+    }
+    listValues(prefix) {
+        return this.runtime().list(this.namespace(), this.domain, prefix === undefined ? undefined : validPrefix(prefix));
+    }
+    mutateValues(mutations) {
+        return this.runtime().mutate(this.namespace(), this.domain, Object.freeze(mutations.map((mutation) => Object.freeze({
+            ...mutation,
+            key: validKey(mutation.key),
+            ...(mutation.value === undefined ? {} : { value: detached(mutation.value) }),
+        }))));
+    }
+    watchValues(listener) {
+        const subscribe = this.runtime().subscribe;
+        if (!subscribe)
+            throw new Error(`Plugin ${this.domain} subscriptions are unavailable`);
+        return subscribe(this.namespace(), this.domain, listener);
+    }
+}
+/** Per-extension Settings with schema contributions, CAS revisions, and no global-policy access. */
+export class PluginSettingsService extends PluginNamespacedDataService {
+    definitions = new Map();
+    constructor(ctx) {
+        super(ctx, 'settings', 'settings');
+    }
+    define(definition) {
+        validateSettingDefinition(definition);
+        const identity = pluginIdentity(this.ctx);
+        return registerPluginContribution(this.ctx, `settings.define(${JSON.stringify(definition.key)})`, () => {
+            const id = `${identity.scopeId}\0${identity.extensionId}\0${definition.key}`;
+            if (this.definitions.has(id))
+                throw new Error(`Plugin Setting is already defined: ${definition.key}`);
+            this.definitions.set(id, Object.freeze({
+                ...definition,
+                ...(definition.defaultValue === undefined
+                    ? {}
+                    : { defaultValue: detached(definition.defaultValue) }),
+            }));
+            return () => {
+                this.definitions.delete(id);
+            };
+        });
+    }
+    async get(key) {
+        const snapshot = await this.readValue(key);
+        if (snapshot.value !== undefined)
+            return snapshot;
+        const definition = this.definition(key);
+        return definition?.defaultValue === undefined
+            ? snapshot
+            : Object.freeze({
+                revision: snapshot.revision,
+                value: detached(definition.defaultValue),
+            });
+    }
+    async set(key, value, options = {}) {
+        const definition = this.definition(key);
+        if (!definition)
+            throw new Error(`Plugin Setting is not defined: ${key}`);
+        if (definition.secret)
+            throw new Error(`Secret Setting must use ctx.authorization: ${key}`);
+        if (definition.validate && !definition.validate(value))
+            throw new TypeError(`Plugin Setting failed validation: ${key}`);
+        const result = await this.mutateValues([{ key, value, ...options }]);
+        return result[key];
+    }
+    async delete(key, options = {}) {
+        const result = await this.mutateValues([{ key, ...options }]);
+        return result[key];
+    }
+    list(prefix) {
+        return this.listValues(prefix);
+    }
+    watch(listener) {
+        return this.watchValues(listener);
+    }
+    definition(key) {
+        const identity = pluginIdentity(this.ctx);
+        return this.definitions.get(`${identity.scopeId}\0${identity.extensionId}\0${validKey(key)}`);
+    }
+}
+/** Per-extension durable KV/blob-safe JSON surface with atomic batch mutations. */
+export class PluginStorageService extends PluginNamespacedDataService {
+    constructor(ctx) {
+        super(ctx, 'storage', 'storage');
+    }
+    get(key) {
+        return this.readValue(key);
+    }
+    async set(key, value, options = {}) {
+        const result = await this.mutateValues([{ key, value, ...options }]);
+        return result[key];
+    }
+    async delete(key, options = {}) {
+        const result = await this.mutateValues([{ key, ...options }]);
+        return result[key];
+    }
+    list(prefix) {
+        return this.listValues(prefix);
+    }
+    transaction(mutations) {
+        if (!mutations.length)
+            throw new TypeError('Plugin Storage transaction must not be empty');
+        return this.mutateValues(mutations);
+    }
+    watch(listener) {
+        return this.watchValues(listener);
+    }
+}
+const authorizationCommit = Symbol('authorizationCommit');
+/** Declared Secret Slots. Values stay in Host custody and are never enumerable. */
+export class PluginCredentialService extends Service {
+    dataRuntime;
+    slots = new Map();
+    constructor(ctx) {
+        super(ctx, 'credentials');
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error('Only the Host may bind the Credential Runtime');
+        if (this.dataRuntime)
+            throw new Error('Plugin Credential Runtime is already bound');
+        this.dataRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.dataRuntime === runtime)
+                this.dataRuntime = undefined;
+        }, 'credentials.bindRuntime()');
+    }
+    declare(slot) {
+        validateSlot(slot);
+        const identity = namespace(this.ctx);
+        const id = slotId(identity, slot.name);
+        return registerPluginContribution(this.ctx, `credentials.declare(${JSON.stringify(slot.name)})`, () => {
+            if (this.slots.has(id))
+                throw new Error(`Credential Slot is already declared: ${slot.name}`);
+            this.slots.set(id, { identity, definition: Object.freeze({ ...slot }) });
+            return () => {
+                this.slots.delete(id);
+            };
+        });
+    }
+    has(name) {
+        const slot = this.requireSlot(name);
+        return this.runtime().hasCredential(slot.identity, slot.definition.name);
+    }
+    use(name, operation) {
+        if (typeof operation !== 'function')
+            throw new TypeError('Credential use callback is required');
+        const slot = this.requireSlot(name);
+        return this.runtime().useCredential(slot.identity, slot.definition.name, operation);
+    }
+    remove(name) {
+        const slot = this.requireSlot(name);
+        return this.runtime().removeCredential(slot.identity, slot.definition.name);
+    }
+    async [authorizationCommit](name, secret, metadata) {
+        if (!secret)
+            throw new TypeError('Credential secret must not be empty');
+        const slot = this.requireSlot(name);
+        await this.runtime().commitCredential(slot.identity, slot.definition.name, secret, metadata);
+    }
+    requireSlot(name) {
+        const identity = namespace(this.ctx);
+        const slot = this.slots.get(slotId(identity, validName(name)));
+        if (!slot)
+            throw new Error(`Credential Slot is not declared: ${name}`);
+        return slot;
+    }
+    runtime() {
+        if (!this.dataRuntime)
+            throw new Error('Plugin Credential Runtime is unavailable');
+        return this.dataRuntime;
+    }
+}
+/** Effect-owned authorization flows with one cancellable attempt per Secret Slot. */
+export class PluginAuthorizationService extends Service {
+    flows = new Map();
+    active = new Map();
+    constructor(ctx, _credentials) {
+        super(ctx, 'authorization');
+    }
+    register(flow) {
+        validateFlow(flow);
+        const identity = namespace(this.ctx);
+        const id = slotId(identity, flow.slot);
+        return registerPluginContribution(this.ctx, `authorization.register(${JSON.stringify(flow.slot)})`, () => {
+            if (this.flows.has(id))
+                throw new Error(`Authorization Flow is already registered: ${flow.slot}`);
+            this.flows.set(id, flow);
+            return () => {
+                this.active.get(id)?.abort(new Error('Authorization Flow disposed'));
+                this.active.delete(id);
+                this.flows.delete(id);
+            };
+        });
+    }
+    async begin(slot, method, signal) {
+        const identity = namespace(this.ctx);
+        const id = slotId(identity, validName(slot));
+        const flow = this.flows.get(id);
+        if (!flow)
+            throw new Error(`Authorization Flow is unavailable: ${slot}`);
+        if (this.active.has(id))
+            throw new Error(`Authorization is already in progress: ${slot}`);
+        const selected = method ?? flow.methods[0].id;
+        if (!flow.methods.some(({ id }) => id === selected))
+            throw new Error(`Authorization method is unavailable: ${selected}`);
+        const controller = new AbortController();
+        const onAbort = () => controller.abort(signal?.reason);
+        signal?.addEventListener('abort', onAbort, { once: true });
+        this.active.set(id, controller);
+        let committed = false;
+        try {
+            const outcome = await flow.run({
+                method: selected,
+                signal: controller.signal,
+                commit: async (secret, metadata) => {
+                    await this.ctx.credentials[authorizationCommit](slot, secret, metadata);
+                    committed = true;
+                },
+            });
+            if (outcome === 'authorized' && !committed)
+                throw new Error('Authorization Flow returned authorized without committing a credential');
+            return outcome;
+        }
+        finally {
+            signal?.removeEventListener('abort', onAbort);
+            if (this.active.get(id) === controller)
+                this.active.delete(id);
+        }
+    }
+    cancel(slot) {
+        const identity = namespace(this.ctx);
+        this.active.get(slotId(identity, validName(slot)))?.abort(new Error('Authorization cancelled'));
+    }
+}
+function namespace(ctx) {
+    const { extensionId, scopeId } = pluginIdentity(ctx);
+    return Object.freeze({ extensionId, scopeId });
+}
+function slotId(identity, name) {
+    return `${identity.scopeId}\0${identity.extensionId}\0${name}`;
+}
+function validName(value) {
+    if (!/^[a-z][a-z0-9]*(?:[-_.][a-z0-9]+)*$/u.test(value))
+        throw new TypeError(`Invalid plugin name: ${value}`);
+    return value;
+}
+function validKey(value) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._/-]{0,255}$/u.test(value) || value.includes('..'))
+        throw new TypeError(`Invalid plugin data key: ${value}`);
+    return value;
+}
+function validPrefix(value) {
+    if (value === '')
+        return value;
+    return validKey(value);
+}
+function detached(value) {
+    const json = JSON.stringify(value);
+    if (json === undefined)
+        throw new TypeError('Plugin data must be JSON-serializable');
+    if (Buffer.byteLength(json, 'utf8') > 1024 * 1024)
+        throw new TypeError('Plugin data value exceeds 1 MiB');
+    return JSON.parse(json);
+}
+function validateSettingDefinition(value) {
+    validKey(value.key);
+    if (!value.title.trim())
+        throw new TypeError('Plugin Setting title must not be empty');
+}
+function validateSlot(value) {
+    validName(value.name);
+    if (!value.label.trim())
+        throw new TypeError('Credential Slot label must not be empty');
+}
+function validateFlow(value) {
+    validName(value.slot);
+    if (!value.label.trim() || typeof value.run !== 'function' || value.methods.length === 0)
+        throw new TypeError('Invalid Authorization Flow');
+    const ids = value.methods.map(({ id }) => validName(id));
+    if (new Set(ids).size !== ids.length || value.methods.some(({ label }) => !label.trim()))
+        throw new TypeError('Invalid Authorization methods');
+}

package/node_modules/@maka/runtime/dist/plugin-fs-service.js

@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+/** Full-fidelity filesystem entry point bound to Maka's canonical workspace authority. */
+export class PluginFilesystemService extends Service {
+    agents;
+    filesystemRuntime;
+    constructor(ctx, agents) {
+        super(ctx, 'fs');
+        this.agents = agents;
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error('Only the Host may bind the Filesystem Runtime');
+        if (this.filesystemRuntime)
+            throw new Error('Plugin Filesystem Runtime is already bound');
+        this.filesystemRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.filesystemRuntime === runtime)
+                this.filesystemRuntime = undefined;
+        }, 'fs.bindRuntime()');
+    }
+    execute(operation) {
+        if (!this.filesystemRuntime)
+            throw new Error('Plugin Filesystem Runtime is unavailable');
+        return this.filesystemRuntime.execute(operation, this.agents.requireInvocation());
+    }
+    read(path, options = {}) {
+        return this.execute({ kind: 'read', path, ...options });
+    }
+    write(path, content) {
+        return this.execute({ kind: 'write', path, content });
+    }
+    edit(path, oldString, newString) {
+        return this.execute({ kind: 'edit', path, oldString, newString });
+    }
+    glob(pattern, options = {}) {
+        return this.execute({ kind: 'glob', pattern, ...options });
+    }
+    grep(pattern, options = {}) {
+        return this.execute({ kind: 'grep', pattern, ...options });
+    }
+    applyPatch(patch) {
+        return this.execute({ kind: 'apply_patch', patch });
+    }
+}

package/node_modules/@maka/runtime/dist/plugin-goal-service.js

@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Service } from './plugin-kernel.js';
+/** Current-Session Goal facade; mutations retain Maka's Turn lease and revision authority. */
+export class PluginGoalService extends Service {
+    agents;
+    goalRuntime;
+    constructor(ctx, agents) {
+        super(ctx, 'goals');
+        this.agents = agents;
+    }
+    bindRuntime(runtime) {
+        if (this.ctx.maka)
+            throw new Error('Only the Host may bind the Goal Runtime');
+        if (this.goalRuntime)
+            throw new Error('Plugin Goal Runtime is already bound');
+        this.goalRuntime = runtime;
+        return this.ctx.effect(() => () => {
+            if (this.goalRuntime === runtime)
+                this.goalRuntime = undefined;
+        }, 'goals.bindRuntime()');
+    }
+    get() {
+        return this.execute({ kind: 'get' });
+    }
+    create(input) {
+        if (!input.objective.trim())
+            throw new TypeError('Goal objective must not be empty');
+        return this.execute({ ...input, kind: 'create', objective: input.objective.trim() });
+    }
+    clear() {
+        return this.execute({ kind: 'clear' });
+    }
+    pause() {
+        return this.execute({ kind: 'pause' });
+    }
+    resume() {
+        return this.execute({ kind: 'resume' });
+    }
+    execute(operation) {
+        if (!this.goalRuntime)
+            throw new Error('Plugin Goal Runtime is unavailable');
+        return this.goalRuntime.execute(operation, this.agents.requireInvocation());
+    }
+}

package/node_modules/@maka/runtime/dist/plugin-invocation-signal.js

@@ -0,0 +1,24 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/** Preserve Host cancellation when a plugin adds its own cancellation source. */
+export function pluginInvocationSignal(invocationSignal, pluginSignal) {
+    if (!pluginSignal || pluginSignal === invocationSignal)
+        return invocationSignal;
+    return AbortSignal.any([invocationSignal, pluginSignal]);
+}