@onesi/genesis 0.0.0-stage → 0.1.13

package/dist/lanes.d.ts

@@ -0,0 +1,267 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** Lanes agent context, Sandbox only. Every POST, including the read POSTs (retrieve, snapshots,
+ * cache lookup, tenant export), needs a stable idempotency key; a changed payload under it is 409. */
+export declare function lanesModule(client: GenesisClient): {
+    records: {
+        get: (recordId: string) => Promise<{
+            id?: string;
+            scope?: Record<string, never>;
+            subject?: string;
+            contentRef?: string;
+            summary?: string;
+            visibility?: import("./index.js").components["schemas"]["Lanes.Visibility"];
+            labels?: string[];
+        }>;
+        write: (body: {
+            subject: string;
+            contentRef: string;
+            summary: string;
+            visibility: import("./index.js").components["schemas"]["Lanes.Visibility"];
+            labels: string[];
+            proposedDataClass?: string;
+        }, idempotencyKey: string) => Promise<{
+            id?: string;
+            scope?: Record<string, never>;
+            subject?: string;
+            contentRef?: string;
+            summary?: string;
+            visibility?: import("./index.js").components["schemas"]["Lanes.Visibility"];
+            labels?: string[];
+        }>;
+        snapshot: (body: {
+            exportedBy: string;
+        }, idempotencyKey: string) => Promise<{
+            scope?: Record<string, never>;
+            exportedBy?: string;
+            evidenceRef?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        restore: (body: {
+            scope?: Record<string, never>;
+            exportedBy?: string;
+            evidenceRef?: string;
+        } & {
+            [key: string]: unknown;
+        }, idempotencyKey: string) => Promise<unknown>;
+    };
+    retrieve: (body: {
+        agentId: string;
+        taskId: string;
+        query: string;
+        allowRawContext: boolean;
+        tokenBudget: number;
+    } | {
+        subject: {
+            agentId: string;
+            runId?: string;
+            sessionId?: string;
+            userId?: string;
+        };
+        query: string;
+        allowRawContext?: boolean;
+        tokenBudget?: number;
+        maxResults?: number;
+    }, idempotencyKey: string) => Promise<{
+        frame?: import("./index.js").components["schemas"]["Lanes.Frame"];
+        route?: import("./index.js").components["schemas"]["Lanes.Route"];
+    }>;
+    frames: {
+        create: (body: {
+            agentId: string;
+            taskId: string;
+            query: string;
+            allowRawContext: boolean;
+            tokenBudget: number;
+        }, idempotencyKey: string) => Promise<{
+            frame?: import("./index.js").components["schemas"]["Lanes.Frame"];
+            route?: import("./index.js").components["schemas"]["Lanes.Route"];
+        }>;
+    };
+    answer: (body: {
+        agentId: string;
+        taskId: string;
+        query: string;
+        allowRawContext: boolean;
+        tokenBudget: number;
+    }, idempotencyKey: string) => Promise<{
+        frame?: import("./index.js").components["schemas"]["Lanes.Frame"];
+        routeDecision?: Record<string, never>;
+        route?: import("./index.js").components["schemas"]["Lanes.Route"];
+        cache?: Record<string, never>;
+        answer?: unknown;
+        policyDecisionIds?: string[];
+    }>;
+    ledger: {
+        frame: (frameId: string) => Promise<{
+            sequence?: number;
+            frameId?: string;
+            kind?: string;
+            detail?: unknown;
+        }[]>;
+        snapshot: (body: {
+            exportedBy: string;
+        }, idempotencyKey: string) => Promise<{
+            scope?: Record<string, never>;
+            exportedBy?: string;
+            evidenceRef?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        restore: (body: {
+            scope?: Record<string, never>;
+            exportedBy?: string;
+            evidenceRef?: string;
+        } & {
+            [key: string]: unknown;
+        }, idempotencyKey: string) => Promise<unknown>;
+    };
+    cache: {
+        lookup: (body: {
+            cacheKey: string;
+            cacheClass: string;
+            requestedBy: string;
+        }, idempotencyKey: string) => Promise<{
+            cacheKey?: string;
+            cacheClass?: string;
+            status?: string;
+            hit?: import("./index.js").components["schemas"]["Lanes.CacheArtifact"] | null;
+            policyDecisionIds?: string[];
+        }>;
+        write: (body: {
+            cacheKey: string;
+            cacheClass: string;
+            valueRef: string;
+            summary: string;
+            labels: string[];
+            sourceRecordIds: string[];
+            writtenBy: string;
+        }, idempotencyKey: string) => Promise<{
+            id?: string;
+            scope?: Record<string, never>;
+            cacheKey?: string;
+            cacheClass?: string;
+            valueRef?: string;
+            summary?: string;
+            labels?: string[];
+            sourceRecordIds?: string[];
+            status?: string;
+            evidenceRef?: string;
+            policyDecisionIds?: string[];
+        }>;
+        snapshot: (body: {
+            exportedBy: string;
+        }, idempotencyKey: string) => Promise<{
+            scope?: Record<string, never>;
+            exportedBy?: string;
+            evidenceRef?: string;
+        } & {
+            [key: string]: unknown;
+        }>;
+        restore: (body: {
+            scope?: Record<string, never>;
+            exportedBy?: string;
+            evidenceRef?: string;
+        } & {
+            [key: string]: unknown;
+        }, idempotencyKey: string) => Promise<unknown>;
+    };
+    recovery: {
+        restore: (body: {
+            [key: string]: unknown;
+        }, idempotencyKey: string) => Promise<{
+            scope?: Record<string, never>;
+            contextRecordsRestored?: number;
+            cacheArtifactsRestored?: number;
+            framesRestored?: number;
+            ledgerEntriesRestored?: number;
+            stageOrder?: string[];
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+    tenant: {
+        export: (body: {
+            requestedBy: string;
+            includeLedger: boolean;
+            includeOperationalRecords: boolean;
+        }, idempotencyKey: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        delete: (body: {
+            requestedBy: string;
+            reason: string;
+            legalHold: boolean;
+        }, idempotencyKey: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    policy: {
+        evaluate: (body: {
+            actorId: string;
+            action: string;
+            dataClass: string;
+            allowRawContext: boolean;
+            modelClass: string;
+        }, idempotencyKey: string) => Promise<{
+            decisionId?: string;
+            allowed?: boolean;
+            decision?: "allow" | "deny";
+            reason?: string;
+            requiresRedaction?: boolean;
+            auditLevel?: string;
+            reasons?: string[];
+            denialReasons?: string[];
+            explanation?: Record<string, never>;
+        }>;
+    };
+    foundryRoutes: {
+        enforce: (body: {
+            routeAlias: string;
+            modelClass: string;
+            dataUseTerms: string[];
+            tokenBudget: number;
+            inputTokens: number;
+        }, idempotencyKey: string) => Promise<{
+            allowed?: boolean;
+            routeAlias?: string;
+            modelClass?: string;
+            inputTokens?: number;
+            maxInputTokens?: number;
+            reasons?: string[];
+        }>;
+    };
+    promotions: {
+        list: () => Promise<{
+            [key: string]: unknown;
+        }[]>;
+        propose: (body: {
+            sourceRecordId: string;
+            proposedBy: string;
+            sanitizedContentRef?: string;
+            sanitizedSummary?: string;
+            labels?: string[];
+        }, idempotencyKey: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+        review: (promotionId: string, body: In<"lanes_reviewPromotion">["body"], idempotencyKey: string) => Promise<{
+            [key: string]: unknown;
+        }>;
+    };
+    operations: {
+        records: () => Promise<{
+            meterRecords?: Record<string, never>[];
+            auditRecords?: Record<string, never>[];
+            evidenceRecords?: Record<string, never>[];
+            probeEvents?: Record<string, never>[];
+        }>;
+        get: (operationId: string) => Promise<{
+            operationId?: string;
+            state?: string;
+            responseStatus?: number;
+        } & {
+            [key: string]: unknown;
+        }>;
+    };
+};

package/dist/lanes.js

@@ -0,0 +1,41 @@
+import { idempotencyHeaders } from './idempotency.js';
+/** Lanes agent context, Sandbox only. Every POST, including the read POSTs (retrieve, snapshots,
+ * cache lookup, tenant export), needs a stable idempotency key; a changed payload under it is 409. */
+export function lanesModule(client) {
+    const post = (id) => async (body, idempotencyKey) => client.request(id, { body }, { headers: idempotencyHeaders(id, idempotencyKey) });
+    return {
+        records: {
+            get: (recordId) => client.request('lanes_getRecord', { recordId }),
+            write: post('lanes_writeRecord'),
+            snapshot: post('lanes_snapshotRecords'),
+            restore: post('lanes_restoreRecords'),
+        },
+        retrieve: post('lanes_retrieve'),
+        frames: { create: post('lanes_createFrame') },
+        answer: post('lanes_answer'),
+        ledger: {
+            frame: (frameId) => client.request('lanes_getLedgerFrame', { frameId }),
+            snapshot: post('lanes_snapshotLedger'),
+            restore: post('lanes_restoreLedger'),
+        },
+        cache: {
+            lookup: post('lanes_cacheLookup'),
+            write: post('lanes_cacheWrite'),
+            snapshot: post('lanes_snapshotCache'),
+            restore: post('lanes_restoreCache'),
+        },
+        recovery: { restore: post('lanes_recoveryRestore') },
+        tenant: { export: post('lanes_exportTenant'), delete: post('lanes_deleteTenant') },
+        policy: { evaluate: post('lanes_evaluatePolicy') },
+        foundryRoutes: { enforce: post('lanes_enforceFoundryRoute') },
+        promotions: {
+            list: () => client.request('lanes_listPromotionCandidates'),
+            propose: post('lanes_proposePromotion'),
+            review: async (promotionId, body, idempotencyKey) => client.request('lanes_reviewPromotion', { promotionId, body }, { headers: idempotencyHeaders('lanes_reviewPromotion', idempotencyKey) }),
+        },
+        operations: {
+            records: () => client.request('lanes_listOperationalRecords'),
+            get: (operationId) => client.request('lanes_getOperation', { operationId }),
+        },
+    };
+}

package/dist/minds-agent.d.ts

@@ -0,0 +1,60 @@
+import type { GenesisClient } from './client.js';
+import { GenesisError } from './errors.js';
+export declare const mindsAgentOperations: readonly ["minds_agentInsertEpisodicMemory", "minds_agentGetEpisodicMemory", "minds_agentSearchMemory"];
+export declare const isMindsAgentOperation: (id: string) => boolean;
+declare const EVENT_TYPES: readonly ["Conversation", "Command", "Query", "Document", "Error", "Success", "Learning", "Decision", "Action", "Context", "Knowledge"];
+type Row = Record<string, unknown>;
+export interface MindsAgentEventInput {
+    id: string;
+    content: string;
+    timestamp: string;
+    event_type?: typeof EVENT_TYPES[number];
+    summary?: string | null;
+    tags?: string[];
+}
+export interface MindsAgentOptions {
+    /** Omit for the agent's private namespace; group authority is checked by the controller. */
+    group?: string;
+    /** Fresh caller-signed proof for the controller capability method and canonical URL. Never generated or retried by the SDK. */
+    dpopProof?: string;
+    signal?: AbortSignal;
+}
+/** Safe metadata from a failed agent-memory call; never contains credentials or proof bytes. */
+export declare class MindsAgentError extends GenesisError {
+    readonly dpopNonce?: string;
+    constructor(init: ConstructorParameters<typeof GenesisError>[0] & {
+        dpopNonce?: string;
+    });
+}
+/** A single agent request: no human context selection, credential exchange or automatic retry. */
+export declare function mindsAgentTransport(options: {
+    operationId: string;
+    input: Row;
+    headers?: Record<string, string>;
+    routing: string;
+    url: string;
+    credential: () => Promise<string | undefined>;
+    fetch: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<Response>;
+export declare function mindsAgentModule(client: GenesisClient): {
+    memory: {
+        insert: (mind: string, event: MindsAgentEventInput, options?: MindsAgentOptions) => Promise<{
+            id: string;
+        }>;
+        get: (mind: string, storage_id: string, options?: MindsAgentOptions) => Promise<{
+            item: import("./index.js").components["schemas"]["Minds.EpisodicEvent"] | null;
+        }>;
+        search: (mind: string, text: string, limit?: number, options?: MindsAgentOptions) => Promise<({
+            id: string;
+            content: string;
+            timestamp: string;
+            event_type: "Conversation" | "Command" | "Query" | "Document" | "Error" | "Success" | "Learning" | "Decision" | "Action" | "Context" | "Knowledge";
+            summary?: string | null;
+            tags: string[];
+        } & {
+            [key: string]: unknown;
+        })[]>;
+    };
+};
+export {};

package/dist/minds-agent.js

@@ -0,0 +1,190 @@
+import { envelopeExtrasValid, ENVELOPE_EXTRA_FIELDS, GenesisError } from './errors.js';
+export const mindsAgentOperations = ['minds_agentInsertEpisodicMemory', 'minds_agentGetEpisodicMemory', 'minds_agentSearchMemory'];
+export const isMindsAgentOperation = (id) => mindsAgentOperations.includes(id);
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const UUID4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const GROUP = /^agp_[0-7][0-9A-HJKMNP-TV-Z]{25}$/;
+const EVENT_TYPES = ['Conversation', 'Command', 'Query', 'Document', 'Error', 'Success', 'Learning', 'Decision', 'Action', 'Context', 'Knowledge'];
+/** Safe metadata from a failed agent-memory call; never contains credentials or proof bytes. */
+export class MindsAgentError extends GenesisError {
+    dpopNonce;
+    constructor(init) {
+        super(init);
+        this.dpopNonce = init.dpopNonce;
+    }
+}
+const row = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const exact = (value, required, optional = []) => required.every(key => Object.hasOwn(value, key))
+    && Object.keys(value).every(key => required.includes(key) || optional.includes(key));
+const bytes = (value) => new TextEncoder().encode(value).length;
+const text = (value, max) => typeof value === 'string' && value.length > 0 && bytes(value) <= max
+    && !/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(value);
+const date = (value) => text(value, 128) && /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d+)?(?:Z|[+-]\d\d:\d\d)$/.test(value) && Number.isFinite(Date.parse(value));
+const eventType = (value) => typeof value === 'string' && EVENT_TYPES.includes(value);
+function validEvent(value) {
+    if (!row(value) || !exact(value, ['id', 'content', 'timestamp'], ['event_type', 'summary', 'tags']))
+        return false;
+    return text(value.id, 36) && UUID4.test(value.id) && text(value.content, 16_000) && !!value.content.trim() && date(value.timestamp)
+        && (value.event_type === undefined || eventType(value.event_type))
+        && (value.summary == null || typeof value.summary === 'string' && bytes(value.summary) <= 2_000)
+        && (value.tags === undefined || Array.isArray(value.tags) && value.tags.length <= 16 && value.tags.every(tag => text(tag, 80)));
+}
+// Stored events have additional normalized metadata. Validate the producer's
+// stable required fields without reducing its returned event to the input DTO.
+function validStoredEvent(value) {
+    return row(value) && text(value.id, 36) && UUID.test(value.id) && text(value.content, 1_000_000)
+        && date(value.timestamp) && eventType(value.event_type) && Array.isArray(value.tags) && value.tags.every(tag => typeof tag === 'string');
+}
+/** A single agent request: no human context selection, credential exchange or automatic retry. */
+export async function mindsAgentTransport(options) {
+    const { operationId: id, input } = options;
+    const write = id === 'minds_agentInsertEpisodicMemory', read = id === 'minds_agentGetEpisodicMemory';
+    let dispatched = false;
+    const fail = (status, type, details = {}) => new MindsAgentError({
+        status, type, operationId: id, code: details.code, requestId: details.requestId, dpopNonce: details.dpopNonce,
+        message: 'Agent memory request was not confirmed. Inspect the error before an explicit retry.',
+        ...(details.unknown || write && dispatched && (status === 0 || status >= 500 || type === 'invalid_response' && status >= 200 && status < 300)
+            ? { body: { outcome: 'unknown' } } : {}),
+    });
+    const fields = read ? ['mind', 'storage_id'] : ['mind', 'body'];
+    if (options.routing !== 'gateway' || !isMindsAgentOperation(id) || !exact(input, fields, ['group'])
+        || typeof input.mind !== 'string' || !UUID.test(input.mind)
+        || input.group !== undefined && (typeof input.group !== 'string' || !GROUP.test(input.group))
+        || read && (typeof input.storage_id !== 'string' || !UUID.test(input.storage_id)))
+        throw fail(0, 'invalid_request');
+    if (!read && (!row(input.body) || (write ? !exact(input.body, ['event']) || !validEvent(input.body.event)
+        : !exact(input.body, ['text'], ['limit']) || !text(input.body.text, 1_000) || !input.body.text.trim()
+            || input.body.limit !== undefined && (!Number.isInteger(input.body.limit) || Number(input.body.limit) < 1 || Number(input.body.limit) > 100))))
+        throw fail(0, 'invalid_request');
+    const headerEntries = Object.entries(options.headers ?? {});
+    if (headerEntries.length > 1 || headerEntries.some(([name, value]) => name.toLowerCase() !== 'dpop' || !text(value, 16_384) || /[^\x21-\x7e]|,/.test(value)))
+        throw fail(0, 'invalid_request');
+    const body = read ? undefined : JSON.stringify(input.body);
+    if (body !== undefined && bytes(body) > 65_536)
+        throw fail(0, 'invalid_request');
+    const controller = new AbortController(), cancel = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener('abort', cancel, { once: true });
+    if (options.signal?.aborted)
+        cancel();
+    const timer = setTimeout(() => controller.abort(), 35_000);
+    async function bounded(work) {
+        controller.signal.throwIfAborted();
+        let abort = () => { };
+        const cancelled = new Promise((_, reject) => {
+            abort = () => reject(fail(0, 'transport_error'));
+            controller.signal.addEventListener('abort', abort, { once: true });
+        });
+        try {
+            controller.signal.throwIfAborted();
+            let pending;
+            try {
+                pending = work();
+            }
+            catch (error) {
+                pending = Promise.reject(error);
+            }
+            return await Promise.race([cancelled, pending]);
+        }
+        finally {
+            controller.signal.removeEventListener('abort', abort);
+        }
+    }
+    try {
+        const credential = await bounded(options.credential);
+        controller.signal.throwIfAborted();
+        if (!text(credential, 16_384) || /[^\x21-\x7e]|,/.test(credential))
+            throw fail(401, 'unauthenticated');
+        const response = await bounded(() => {
+            dispatched = true;
+            return options.fetch(options.url, { method: read ? 'GET' : 'POST', redirect: 'error', cache: 'no-store', signal: controller.signal,
+                headers: { authorization: `Bearer ${credential}`, accept: 'application/json', ...(body === undefined ? {} : { 'content-type': 'application/json' }),
+                    ...(headerEntries.length ? { dpop: headerEntries[0][1] } : {}) }, ...(body === undefined ? {} : { body }) }).then(response => {
+                if (controller.signal.aborted) {
+                    void response.body?.cancel().catch(() => { });
+                    throw fail(0, 'transport_error');
+                }
+                return response;
+            });
+        });
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw fail(response.status, 'invalid_response');
+        const chunks = [];
+        let size = 0;
+        const stop = () => { void reader.cancel().catch(() => { }); };
+        controller.signal.addEventListener('abort', stop, { once: true });
+        try {
+            for (;;) {
+                const next = await bounded(() => reader.read());
+                if (next.done)
+                    break;
+                size += next.value.length;
+                if (size > 2 * 1024 * 1024)
+                    throw fail(response.status, 'invalid_response');
+                chunks.push(next.value);
+            }
+        }
+        finally {
+            controller.signal.removeEventListener('abort', stop);
+            stop();
+            try {
+                reader.releaseLock();
+            }
+            catch { /* cancellation owns pending read */ }
+        }
+        const data = new Uint8Array(size);
+        let offset = 0;
+        for (const chunk of chunks) {
+            data.set(chunk, offset);
+            offset += chunk.length;
+        }
+        let value;
+        try {
+            value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(data));
+        }
+        catch {
+            throw fail(response.status, 'invalid_response');
+        }
+        if (!response.ok) {
+            if (!row(value) || !exact(value, ['error']) || !row(value.error) || !exact(value.error, ['code', 'request_id'], ['outcome', ...ENVELOPE_EXTRA_FIELDS]) || !envelopeExtrasValid(value.error)
+                || !text(value.error.code, 128) || !/^[A-Z][A-Z0-9_]*$/.test(value.error.code)
+                || !text(value.error.request_id, 256) || /[^\x21-\x7e]/.test(value.error.request_id)
+                || value.error.outcome !== undefined && value.error.outcome !== 'unknown')
+                throw fail(response.status, 'invalid_response');
+            const nonce = response.headers.get('dpop-nonce');
+            if (value.error.code === 'DPOP_NONCE_REQUIRED' && (response.status !== 401 || !nonce || !/^[A-Za-z0-9_-]{1,512}$/.test(nonce)))
+                throw fail(response.status, 'invalid_response');
+            throw fail(response.status, 'minds_agent_error', { code: value.error.code, requestId: value.error.request_id,
+                ...(value.error.code === 'DPOP_NONCE_REQUIRED' ? { dpopNonce: nonce } : {}), unknown: write && value.error.outcome === 'unknown' });
+        }
+        if (response.status !== 200 || (write ? !row(value) || !exact(value, ['id']) || !text(value.id, 36) || !UUID.test(value.id)
+            : read ? !row(value) || !exact(value, ['item']) || value.item !== null && !validStoredEvent(value.item)
+                : !Array.isArray(value) || value.length > Number(input.body.limit ?? 20) || !value.every(validStoredEvent)))
+            throw fail(response.status, 'invalid_response');
+        return Response.json(value, { status: 200, headers: { 'cache-control': 'private, no-store' } });
+    }
+    catch (error) {
+        if (error instanceof MindsAgentError)
+            throw error;
+        throw fail(0, 'transport_error');
+    }
+    finally {
+        clearTimeout(timer);
+        controller.abort();
+        options.signal?.removeEventListener('abort', cancel);
+    }
+}
+export function mindsAgentModule(client) {
+    const validOptions = (value) => row(value) && exact(value, [], ['group', 'dpopProof', 'signal']);
+    const init = (options) => {
+        if (!validOptions(options))
+            throw new MindsAgentError({ status: 0, type: 'invalid_request', message: 'Unknown agent memory option.' });
+        return { signal: options.signal, ...(options.dpopProof === undefined ? {} : { headers: { dpop: options.dpopProof } }) };
+    };
+    const query = (mind, options) => ({ mind, ...(options.group === undefined ? {} : { group: options.group }) });
+    return { memory: {
+            insert: (mind, event, options = {}) => client.request('minds_agentInsertEpisodicMemory', { ...query(mind, options), body: { event } }, init(options)),
+            get: (mind, storage_id, options = {}) => client.request('minds_agentGetEpisodicMemory', { ...query(mind, options), storage_id }, init(options)),
+            search: (mind, text, limit = 20, options = {}) => client.request('minds_agentSearchMemory', { ...query(mind, options), body: { text, limit } }, init(options)),
+        } };
+}

package/dist/minds-owner.d.ts

@@ -0,0 +1,110 @@
+import type { GenesisClient } from './client.js';
+import { GenesisError } from './errors.js';
+export declare const mindsOwnerOperations: readonly ["minds_listAgentGroups", "minds_createAgentGroup", "minds_listAgentGroupMembers", "minds_addAgentGroupMember", "minds_removeAgentGroupMember", "minds_listMindAttachments", "minds_attachMind", "minds_detachMind"];
+type OwnerOperation = typeof mindsOwnerOperations[number];
+export declare const isMindsOwnerOperation: (id: string) => id is OwnerOperation;
+export interface MindsOwnerOptions {
+    signal?: AbortSignal;
+}
+export interface MindsOwnerVersion {
+    operationId: string;
+    expectedVersion: number;
+}
+export type MindsAttachmentSubject = {
+    kind: 'agent';
+    agentId: string;
+} | {
+    kind: 'group';
+    groupId: string;
+};
+export interface MindsAttachInput extends MindsOwnerVersion {
+    subject: MindsAttachmentSubject;
+    permissions: ['minds.agent_data.read'] | ['minds.agent_data.read', 'minds.agent_data.write'];
+    expiresAt: number;
+}
+export declare class MindsOwnerError extends GenesisError {
+}
+type Row = Record<string, unknown>;
+/** Original-human owner operations. No context selection, token substitution or automatic retry. */
+export declare function mindsOwnerTransport(options: {
+    operationId: string;
+    input: Row;
+    headers?: Record<string, string>;
+    routing: string;
+    url: string;
+    credential: () => Promise<string | undefined>;
+    fetch: typeof fetch;
+    signal?: AbortSignal;
+}): Promise<Response>;
+export declare function mindsOwnerModule(client: GenesisClient): {
+    groups: {
+        list: (options?: MindsOwnerOptions) => Promise<{
+            groups: import("./index.js").components["schemas"]["Minds.OwnerAgentGroup"][];
+        }>;
+        create: (body: {
+            operationId: string;
+            name: string;
+        }, options?: MindsOwnerOptions) => Promise<{
+            id: string;
+            organizationId: string;
+            ownerId: string;
+            organizationGeneration: number;
+            name: string;
+            version: number;
+            revokedAt: number | null;
+        }>;
+        members: {
+            list: (group_id: string, options?: MindsOwnerOptions) => Promise<{
+                members: import("./index.js").components["schemas"]["Minds.OwnerAgentGroupMember"][];
+            }>;
+            add: (group_id: string, body: MindsOwnerVersion & {
+                agentId: string;
+            }, options?: MindsOwnerOptions) => Promise<{
+                groupId: string;
+                agentId: string;
+                agentDid: string;
+                agentCreatedAt: number;
+                version: number;
+                revokedAt: number | null;
+            }>;
+            remove: (group_id: string, agent_id: string, body: MindsOwnerVersion, options?: MindsOwnerOptions) => Promise<{
+                groupId: string;
+                agentId: string;
+                agentDid: string;
+                agentCreatedAt: number;
+                version: number;
+                revokedAt: number | null;
+            }>;
+        };
+    };
+    attachments: {
+        list: (mind_id: string, options?: MindsOwnerOptions) => Promise<{
+            attachments: import("./index.js").components["schemas"]["Minds.MindAttachment"][];
+        }>;
+        attach: (mind_id: string, body: MindsAttachInput, options?: MindsOwnerOptions) => Promise<{
+            id: string;
+            version: number;
+            organizationId: string;
+            projectId: string;
+            mindId: string;
+            subject: import("./index.js").components["schemas"]["Minds.MindAttachmentSubject"];
+            permissions: ["minds.agent_data.read"] | ["minds.agent_data.read", "minds.agent_data.write"];
+            sharedNamespace: string | null;
+            expiresAt: number;
+            revokedAt: number | null;
+        }>;
+        detach: (mind_id: string, attachment_id: string, body: MindsOwnerVersion, options?: MindsOwnerOptions) => Promise<{
+            id: string;
+            version: number;
+            organizationId: string;
+            projectId: string;
+            mindId: string;
+            subject: import("./index.js").components["schemas"]["Minds.MindAttachmentSubject"];
+            permissions: ["minds.agent_data.read"] | ["minds.agent_data.read", "minds.agent_data.write"];
+            sharedNamespace: string | null;
+            expiresAt: number;
+            revokedAt: number | null;
+        }>;
+    };
+};
+export {};