@unson/brainbase-mcp 0.21.2 → 0.22.0

package/dist/meeting-minutes-storage.js

@@ -0,0 +1,402 @@
+import { createHash } from 'node:crypto';
+import { constants as fsConstants } from 'node:fs';
+import { lstat, open, realpath } from 'node:fs/promises';
+import { TextDecoder } from 'node:util';
+import { isAbsolute, join, posix, relative, resolve, sep } from 'node:path';
+/** The first real provider adapter. Its root is supplied by the customer. */
+export const FILESYSTEM_MEETING_MINUTES_ADAPTER = 'filesystem';
+const FILESYSTEM_CAPABILITIES = Object.freeze({
+    save: false,
+    read: true,
+    read_only: true,
+    history: false,
+    current_acl: 'injected',
+    retention_delete: false,
+});
+const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+const READ_CHUNK_BYTES = 64 * 1024;
+/**
+ * Read-only adapter for a customer-selected filesystem root.
+ *
+ * The adapter keeps no native copy and performs no external write. A plain
+ * filesystem has no historical version contract, so old references fail with
+ * an integrity mismatch when the current file changes.
+ */
+export class FilesystemMeetingMinutesAdapter {
+    capabilities = FILESYSTEM_CAPABILITIES;
+    root;
+    provider;
+    authorize;
+    maxBytes;
+    constructor(options) {
+        if (!options || typeof options.root !== 'string' || !options.root.trim()) {
+            throw new MeetingMinutesStorageError('invalid_configuration', 'An absolute customer filesystem root is required');
+        }
+        if (!isAbsolute(options.root)) {
+            throw new MeetingMinutesStorageError('invalid_configuration', 'The filesystem root must be absolute');
+        }
+        const provider = options.provider ?? FILESYSTEM_MEETING_MINUTES_ADAPTER;
+        if (typeof provider !== 'string' || !provider.trim()) {
+            throw new MeetingMinutesStorageError('invalid_configuration', 'The provider identifier must not be empty');
+        }
+        if (typeof options.authorize !== 'function') {
+            throw new MeetingMinutesStorageError('invalid_configuration', 'A host authorization callback is required');
+        }
+        const maxBytes = options.max_bytes ?? DEFAULT_MAX_BYTES;
+        if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) {
+            throw new MeetingMinutesStorageError('invalid_configuration', 'max_bytes must be a positive safe integer');
+        }
+        this.root = resolve(options.root);
+        this.provider = provider;
+        this.authorize = options.authorize;
+        this.maxBytes = maxBytes;
+    }
+    async register(input) {
+        const authorizationError = await this.authorizationFailure(input?.request_context, 'register', { locator: typeof input?.locator === 'string' ? input.locator : '' });
+        if (authorizationError)
+            return this.registerFailure('denied', authorizationError);
+        const locator = normalizeLocator(input?.locator);
+        if (locator.status !== 'ok')
+            return this.registerFailure(locator.status, locator.reason);
+        const file = await this.resolveFile(locator.locator);
+        if (file.status !== 'ok')
+            return this.registerFailure(file.status, file.reason);
+        const content = await this.readStableFile(file);
+        if (content.status !== 'ok')
+            return this.registerFailure(content.status, content.reason);
+        try {
+            return {
+                status: 'registered',
+                reference: this.reference(locator.locator, content.bytes),
+                capabilities: this.capabilities,
+            };
+        }
+        catch (error) {
+            return this.registerFailure(...readFailure(error));
+        }
+    }
+    async read(input) {
+        const referenceError = this.referenceFailure(input?.reference);
+        if (referenceError)
+            return this.readFailure('invalid_reference', referenceError);
+        const authorizationError = await this.authorizationFailure(input?.request_context, 'read', { reference: input.reference });
+        if (authorizationError)
+            return this.readFailure('denied', authorizationError);
+        const locator = normalizeLocator(input.reference.locator);
+        if (locator.status !== 'ok')
+            return this.readFailure('invalid_reference', locator.reason);
+        const file = await this.resolveFile(locator.locator);
+        if (file.status !== 'ok')
+            return this.readFailure(file.status, file.reason);
+        const content = await this.readStableFile(file);
+        if (content.status !== 'ok')
+            return this.readFailure(content.status, content.reason);
+        const observed = this.reference(locator.locator, content.bytes);
+        if (observed.revision !== input.reference.revision || observed.digest !== input.reference.digest) {
+            return {
+                status: 'integrity_mismatch',
+                reason: 'The external source changed; the requested historical revision is unavailable',
+                observed_reference: observed,
+                capabilities: this.capabilities,
+            };
+        }
+        return {
+            status: 'available',
+            reference: observed,
+            body: content.body,
+            capabilities: this.capabilities,
+        };
+    }
+    async read_source(input) {
+        const source = input?.source_ref;
+        if (!source || typeof source !== 'object') {
+            return this.readFailure('invalid_reference', 'A persisted external source reference is required');
+        }
+        const reference = {
+            provider: source.provider,
+            locator: source.locator,
+            revision: source.revision,
+            digest: source.digest,
+            provenance: {
+                source: 'external',
+                adapter: FILESYSTEM_MEETING_MINUTES_ADAPTER,
+                observed_at: new Date().toISOString(),
+            },
+        };
+        return this.read({ reference, request_context: input.request_context });
+    }
+    async read_history(input) {
+        const authorizationError = await this.authorizationFailure(input?.request_context, 'read_history', { reference: input?.reference });
+        if (authorizationError) {
+            return {
+                status: 'denied',
+                reason: authorizationError,
+                capabilities: this.capabilities,
+            };
+        }
+        return this.unsupported('read_history', 'history', 'This filesystem adapter has no historical version provider');
+    }
+    async save(_input) {
+        return this.unsupported('save', 'save', 'The external filesystem is read-only through Brainbase');
+    }
+    async delete(input) {
+        const authorizationError = await this.authorizationFailure(input?.request_context, 'retention_delete', { reference: input?.reference });
+        if (authorizationError) {
+            return {
+                status: 'denied',
+                reason: authorizationError,
+                capabilities: this.capabilities,
+            };
+        }
+        return this.unsupported('retention_delete', 'retention_delete', 'Retention and deletion remain owned by the external storage policy');
+    }
+    async authorizationFailure(context, operation, target) {
+        if (!context || typeof context !== 'object')
+            return 'A host request context is required';
+        const requestContext = context;
+        if (typeof requestContext.principal_id !== 'string' || !requestContext.principal_id.trim()) {
+            return 'A host request principal is required';
+        }
+        let decision;
+        try {
+            decision = await this.authorize({ principal_id: requestContext.principal_id }, operation, target);
+        }
+        catch {
+            return 'The host authorization check could not be completed';
+        }
+        if (typeof decision === 'boolean') {
+            return decision ? undefined : 'The current host authorization does not allow this operation';
+        }
+        if (!decision || typeof decision !== 'object' || typeof decision.allowed !== 'boolean') {
+            return 'The host authorization check returned an invalid decision';
+        }
+        if (!decision.allowed)
+            return decision.reason ?? 'The current host authorization does not allow this operation';
+        if (decision.checked_at !== undefined && Number.isNaN(Date.parse(decision.checked_at))) {
+            return 'The host authorization decision timestamp is invalid';
+        }
+        return undefined;
+    }
+    async readStableFile(file) {
+        let handle;
+        try {
+            const noFollow = fsConstants.O_NOFOLLOW;
+            if (typeof noFollow !== 'number') {
+                return { status: 'unavailable', reason: 'The host does not provide O_NOFOLLOW for safe external reads' };
+            }
+            handle = await open(file.path, fsConstants.O_RDONLY | noFollow);
+            const opened = await handle.stat();
+            if (!sameFileIdentity(opened, file) || !opened.isFile()) {
+                return { status: 'unavailable', reason: 'The external source changed before it could be read safely' };
+            }
+            const openedRealPath = await realpath(file.path);
+            if (openedRealPath !== file.real_path) {
+                return { status: 'symlink_rejected', reason: 'The external source path changed outside the configured root' };
+            }
+            if (!Number.isSafeInteger(opened.size) || opened.size > this.maxBytes) {
+                return { status: 'too_large', reason: `The external source exceeds the ${this.maxBytes}-byte limit` };
+            }
+            const content = await readBounded(handle, this.maxBytes);
+            if (content.status !== 'ok')
+                return content;
+            const closedStat = await handle.stat();
+            if (!sameFileIdentity(closedStat, file) || closedStat.size !== opened.size) {
+                return { status: 'unavailable', reason: 'The external source changed while it was being read' };
+            }
+            const closedRealPath = await realpath(file.path);
+            if (closedRealPath !== file.real_path) {
+                return { status: 'symlink_rejected', reason: 'The external source path changed outside the configured root' };
+            }
+            let body;
+            try {
+                body = decodeUtf8(content.bytes);
+            }
+            catch {
+                return { status: 'invalid_encoding', reason: 'The external source is not valid UTF-8' };
+            }
+            return { status: 'ok', bytes: content.bytes, body };
+        }
+        catch (error) {
+            const [status, reason] = readFailure(error);
+            return { status, reason };
+        }
+        finally {
+            if (handle)
+                await handle.close().catch(() => undefined);
+        }
+    }
+    registerFailure(status, reason) {
+        if (status === 'registered')
+            throw new Error('A registration failure cannot be registered');
+        return { status, reason, capabilities: this.capabilities };
+    }
+    readFailure(status, reason) {
+        return { status, reason, capabilities: this.capabilities };
+    }
+    unsupported(operation, capability, reason) {
+        return { status: 'unsupported', operation, capability, reason, capabilities: this.capabilities };
+    }
+    reference(locator, bytes) {
+        const digest = `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+        return Object.freeze({
+            provider: this.provider,
+            locator,
+            revision: digest,
+            digest,
+            provenance: Object.freeze({
+                source: 'external',
+                adapter: FILESYSTEM_MEETING_MINUTES_ADAPTER,
+                observed_at: new Date().toISOString(),
+            }),
+        });
+    }
+    referenceFailure(reference) {
+        if (!reference || typeof reference !== 'object')
+            return 'An external reference is required';
+        const candidate = reference;
+        if (candidate.provider !== this.provider)
+            return 'The reference belongs to a different provider';
+        if (typeof candidate.locator !== 'string')
+            return 'The reference locator is invalid';
+        if (!isSha256(candidate.revision) || !isSha256(candidate.digest))
+            return 'The reference must include exact SHA-256 revision and digest';
+        if (candidate.revision !== candidate.digest)
+            return 'The filesystem revision must equal the source digest';
+        const provenance = candidate.provenance;
+        if (!provenance || typeof provenance !== 'object')
+            return 'The external reference provenance is required';
+        const candidateProvenance = provenance;
+        if (candidateProvenance.source !== 'external' || candidateProvenance.adapter !== FILESYSTEM_MEETING_MINUTES_ADAPTER) {
+            return 'The external reference provenance is invalid';
+        }
+        if (typeof candidateProvenance.observed_at !== 'string' || Number.isNaN(Date.parse(candidateProvenance.observed_at))) {
+            return 'The external reference observation timestamp is invalid';
+        }
+        return undefined;
+    }
+    async resolveFile(locator) {
+        let rootStat;
+        try {
+            rootStat = await lstat(this.root);
+        }
+        catch (error) {
+            return fsFailure(error, `The configured filesystem root is unavailable: ${this.root}`);
+        }
+        if (rootStat.isSymbolicLink()) {
+            return { status: 'symlink_rejected', reason: 'The configured filesystem root must not be a symlink' };
+        }
+        if (!rootStat.isDirectory()) {
+            return { status: 'not_found', reason: 'The configured filesystem root is not a directory' };
+        }
+        let current = this.root;
+        let finalStat;
+        const parts = locator.split('/');
+        for (const [index, part] of parts.entries()) {
+            current = join(current, part);
+            let stat;
+            try {
+                stat = await lstat(current);
+            }
+            catch (error) {
+                return fsFailure(error, `The external source does not exist at ${locator}`);
+            }
+            if (stat.isSymbolicLink()) {
+                return { status: 'symlink_rejected', reason: `Symlink path components are not allowed: ${locator}` };
+            }
+            if (index === parts.length - 1 ? !stat.isFile() : !stat.isDirectory()) {
+                return { status: 'not_found', reason: `The external source is not a regular file: ${locator}` };
+            }
+            if (index === parts.length - 1)
+                finalStat = stat;
+        }
+        let realFile;
+        try {
+            const realRoot = await realpath(this.root);
+            realFile = await realpath(current);
+            const escaped = relative(realRoot, realFile);
+            if (escaped === '..' || escaped.startsWith(`..${sep}`) || isAbsolute(escaped)) {
+                return { status: 'symlink_rejected', reason: `The external locator escapes the configured root: ${locator}` };
+            }
+        }
+        catch (error) {
+            return fsFailure(error, `The external source cannot be resolved at ${locator}`);
+        }
+        if (!finalStat)
+            return { status: 'not_found', reason: `The external source is not a regular file: ${locator}` };
+        return {
+            status: 'ok',
+            path: current,
+            real_path: realFile,
+            device: finalStat.dev,
+            inode: finalStat.ino,
+        };
+    }
+}
+export class MeetingMinutesStorageError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'MeetingMinutesStorageError';
+        this.code = code;
+    }
+}
+export function createFilesystemMeetingMinutesAdapter(options) {
+    return new FilesystemMeetingMinutesAdapter(options);
+}
+function normalizeLocator(locator) {
+    if (typeof locator !== 'string' || !locator.trim()) {
+        return { status: 'invalid_locator', reason: 'A root-relative locator is required' };
+    }
+    if (locator.includes('\0') || locator.includes('\\') || locator.startsWith('/') || posix.isAbsolute(locator)) {
+        return { status: 'invalid_locator', reason: 'The locator must be a root-relative POSIX path' };
+    }
+    const segments = locator.split('/');
+    if (segments.some((segment) => segment === '..')) {
+        return { status: 'invalid_locator', reason: 'Parent path segments are not allowed in an external locator' };
+    }
+    const normalized = posix.normalize(locator);
+    if (normalized === '.' || normalized === '..' || normalized.startsWith('../')) {
+        return { status: 'invalid_locator', reason: 'The locator must resolve to a file inside the configured root' };
+    }
+    return { status: 'ok', locator: normalized };
+}
+async function readBounded(handle, maxBytes) {
+    const chunks = [];
+    let total = 0;
+    while (total <= maxBytes) {
+        const chunkSize = Math.min(READ_CHUNK_BYTES, maxBytes - total + 1);
+        const chunk = Buffer.allocUnsafe(chunkSize);
+        const result = await handle.read(chunk, 0, chunkSize, null);
+        if (result.bytesRead === 0)
+            break;
+        total += result.bytesRead;
+        if (total > maxBytes) {
+            return { status: 'too_large', reason: `The external source exceeds the ${maxBytes}-byte limit` };
+        }
+        chunks.push(chunk.subarray(0, result.bytesRead));
+    }
+    return { status: 'ok', bytes: Buffer.concat(chunks, total) };
+}
+function sameFileIdentity(stat, file) {
+    return stat.dev === file.device && stat.ino === file.inode;
+}
+function decodeUtf8(bytes) {
+    return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+}
+function isSha256(value) {
+    return typeof value === 'string' && /^sha256:[0-9a-f]{64}$/.test(value);
+}
+function readFailure(error) {
+    const failure = fsFailure(error, 'The external source could not be read');
+    return [failure.status, failure.reason];
+}
+function fsFailure(error, fallback) {
+    const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : '';
+    if (code === 'ENOENT' || code === 'ENOTDIR')
+        return { status: 'not_found', reason: fallback };
+    if (code === 'ELOOP')
+        return { status: 'symlink_rejected', reason: fallback };
+    if (code === 'EACCES' || code === 'EPERM')
+        return { status: 'unavailable', reason: fallback };
+    return { status: 'unavailable', reason: fallback };
+}

package/dist/meeting-minutes.d.ts

@@ -0,0 +1,223 @@
+/** Provider-independent native meeting and minutes lifecycle. */
+export declare const MEETING_MINUTES_CONTRACT_VERSION: "brainbase.meeting-minutes.v1";
+export declare const MEETING_MINUTES_SNAPSHOT_VERSION: 1;
+export declare const MEETING_MINUTES_SIDECAR: "meeting-minutes.json";
+export declare const MEETING_MINUTES_BODY_DIGEST_ALGORITHM: "sha256";
+export type MeetingId = string;
+export type MinutesId = string;
+export type MinutesVersionId = string;
+export interface MeetingMinutesSourceRef {
+    /** Stable provider name supplied by an adapter, never used as the native id. */
+    readonly provider: string;
+    readonly locator: string;
+    /** Provider revision at which the source was observed. */
+    readonly revision: string;
+    /** Exact provider content digest for duplicate suppression and readback. */
+    readonly digest: string;
+    /** Adapter supplied provenance is retained as part of the source reference. */
+    readonly provenance?: Readonly<Record<string, unknown>>;
+    /** Provider adapters may carry additional opaque locator details. */
+    readonly [key: string]: unknown;
+}
+export interface MeetingMinutesAcl {
+    readonly owner_id: string;
+    readonly reader_ids: readonly string[];
+    readonly writer_ids: readonly string[];
+}
+export interface MeetingRecord {
+    readonly meeting_id: MeetingId;
+    readonly title: string;
+    readonly scheduled_at?: string;
+    readonly ended_at?: string;
+    readonly participant_ids: readonly string[];
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly acl: MeetingMinutesAcl;
+    readonly created_at: string;
+    readonly created_actor_id: string;
+    readonly revision: number;
+}
+export interface MinutesConfirmationReceipt {
+    readonly version_id: MinutesVersionId;
+    readonly actor_id: string;
+    readonly confirmed_at: string;
+}
+export interface MinutesVersionRecord {
+    readonly version_id: MinutesVersionId;
+    readonly minutes_id: MinutesId;
+    readonly meeting_id: MeetingId;
+    readonly predecessor_version_id?: MinutesVersionId;
+    /** Native versions carry the writable Brainbase body. External versions omit it. */
+    readonly body?: string;
+    readonly body_digest?: string;
+    readonly created_at: string;
+    readonly created_actor_id: string;
+    readonly confirmation?: MinutesConfirmationReceipt;
+    readonly source_ref?: MeetingMinutesSourceRef;
+}
+export interface MinutesDocumentRecord {
+    readonly minutes_id: MinutesId;
+    readonly meeting_id: MeetingId;
+    readonly title: string;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly acl: MeetingMinutesAcl;
+    readonly version_ids: readonly MinutesVersionId[];
+    readonly current_version_id: MinutesVersionId;
+    readonly created_at: string;
+    readonly created_actor_id: string;
+    readonly updated_at: string;
+    readonly revision: number;
+}
+export interface MeetingMinutesSnapshot {
+    readonly schema_version: typeof MEETING_MINUTES_SNAPSHOT_VERSION;
+    /** Aggregate revision used by the storage port's compare-and-swap. */
+    readonly revision: number;
+    readonly meetings: readonly MeetingRecord[];
+    readonly documents: readonly MinutesDocumentRecord[];
+    readonly versions: readonly MinutesVersionRecord[];
+    readonly idempotency: readonly MeetingMinutesIdempotencyRecord[];
+}
+export type MeetingMinutesIdempotencyOperation = 'create_meeting' | 'create_minutes' | 'save_version' | 'confirm_version';
+/** Durable write receipt.  It lets a retried mutation find its exact target after restart. */
+export interface MeetingMinutesIdempotencyRecord {
+    readonly key: string;
+    readonly principal_id: string;
+    readonly fingerprint: string;
+    readonly operation: MeetingMinutesIdempotencyOperation;
+    readonly meeting_id: MeetingId;
+    readonly minutes_id?: MinutesId;
+    readonly version_id?: MinutesVersionId;
+}
+export interface MeetingMinutesRequestContext {
+    /** Resolved by the host or organization auth boundary. Never read from input JSON. */
+    readonly principal_id: string;
+}
+export type MeetingMinutesResource = MeetingRecord | MinutesDocumentRecord | MinutesVersionRecord;
+export interface MeetingMinutesAuthorizer {
+    can_read?(resource: MeetingMinutesResource, context: MeetingMinutesRequestContext): boolean | Promise<boolean>;
+    can_write?(resource: MeetingMinutesResource, context: MeetingMinutesRequestContext): boolean | Promise<boolean>;
+}
+/** Minimal seam for organization storage adapters and future durable stores. */
+export interface MeetingMinutesStoragePort {
+    read(): Promise<MeetingMinutesSnapshot>;
+    /** Implementations must compare the on-disk/current revision before replacing the snapshot. */
+    write(next: MeetingMinutesSnapshot, expected_revision: number): Promise<void>;
+}
+export interface MeetingCreateInput {
+    readonly title: string;
+    readonly scheduled_at?: string;
+    readonly ended_at?: string;
+    readonly participant_ids?: readonly string[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly minutes_title?: string;
+    readonly minutes_metadata?: Readonly<Record<string, unknown>>;
+    readonly initial_body?: string;
+    readonly source_ref?: MeetingMinutesSourceRef;
+    readonly idempotency_key?: string;
+    readonly idempotency_fingerprint?: string;
+}
+export interface CreateMinutesInput {
+    readonly title?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    /** Exactly one of body and source_ref is required. */
+    readonly body?: string;
+    readonly source_ref?: MeetingMinutesSourceRef;
+    /** Aggregate snapshot revision observed by the caller. */
+    readonly expected_revision: number;
+    readonly idempotency_key?: string;
+    readonly idempotency_fingerprint?: string;
+}
+export interface SaveMinutesVersionInput {
+    readonly minutes_id: MinutesId;
+    /** Exactly one of body and source_ref is required. */
+    readonly body?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly source_ref?: MeetingMinutesSourceRef;
+    readonly expected_revision: number;
+    readonly predecessor_version_id?: MinutesVersionId;
+    readonly idempotency_key?: string;
+    readonly idempotency_fingerprint?: string;
+}
+export interface ConfirmMinutesVersionInput {
+    readonly minutes_id: MinutesId;
+    readonly version_id: MinutesVersionId;
+    readonly expected_revision: number;
+    readonly idempotency_key?: string;
+    readonly idempotency_fingerprint?: string;
+}
+export interface MeetingMinutesSummary {
+    readonly meeting: MeetingRecord;
+    readonly minutes: readonly MinutesDocumentRecord[];
+}
+export interface MeetingMinutesDetail extends MeetingMinutesSummary {
+    readonly versions: readonly MinutesVersionRecord[];
+    readonly snapshot_revision: number;
+}
+export type MeetingMinutesErrorCode = 'invalid_input' | 'not_found' | 'revision_conflict' | 'authorization_denied' | 'corrupt_record' | 'storage_unavailable' | 'readback_mismatch' | 'idempotency_conflict';
+export declare class MeetingMinutesError extends Error {
+    readonly code: MeetingMinutesErrorCode;
+    constructor(code: MeetingMinutesErrorCode, message: string);
+}
+export interface MeetingMinutesStoreOptions {
+    readonly data_dir?: string;
+    readonly storage?: MeetingMinutesStoragePort;
+    readonly now?: () => Date;
+    /** Test and adapter hook; generated IDs remain Brainbase-owned. */
+    readonly id_factory?: () => string;
+    readonly authorizer?: MeetingMinutesAuthorizer;
+    /** Optional external registration/deduplication seam. Native-only stores omit it. */
+    readonly external_source_hook?: MeetingMinutesExternalSourceHook;
+}
+export interface MeetingMinutesExternalSourceIdentity {
+    readonly meeting_id: MeetingId;
+    readonly minutes_id: MinutesId;
+    readonly version_id: MinutesVersionId;
+}
+export interface MeetingMinutesExternalSourceHook {
+    /** Return the exact previously registered identity, if any. */
+    find_existing(source_ref: MeetingMinutesSourceRef): Promise<MeetingMinutesExternalSourceIdentity | undefined>;
+    /** Register a successfully persisted external version for future deduplication. */
+    register(source_ref: MeetingMinutesSourceRef, identity: MeetingMinutesExternalSourceIdentity): Promise<void>;
+}
+export interface MeetingMinutesStore {
+    list_meetings(context: MeetingMinutesRequestContext): Promise<readonly MeetingMinutesSummary[]>;
+    create_meeting(input: MeetingCreateInput, context: MeetingMinutesRequestContext): Promise<MeetingMinutesDetail>;
+    create_minutes(meeting_id: MeetingId, input: CreateMinutesInput, context: MeetingMinutesRequestContext): Promise<MeetingMinutesDetail>;
+    get_meeting(meeting_id: MeetingId, context: MeetingMinutesRequestContext): Promise<MeetingMinutesDetail>;
+    get_version(meeting_id: MeetingId, minutes_id: MinutesId, version_id: MinutesVersionId, context: MeetingMinutesRequestContext): Promise<MinutesVersionRecord>;
+    save_version(input: SaveMinutesVersionInput, context: MeetingMinutesRequestContext): Promise<MeetingMinutesDetail>;
+    confirm_version(input: ConfirmMinutesVersionInput, context: MeetingMinutesRequestContext): Promise<MeetingMinutesDetail>;
+}
+/**
+ * Provider-neutral exact-version seam used by lineage and other read-only
+ * consumers.  The shape intentionally mirrors the lineage contract without
+ * importing that optional module into the native lifecycle.
+ */
+export interface MeetingMinutesVersionPortReference {
+    readonly meetingId: MeetingId;
+    readonly minutesId: MinutesId;
+    readonly versionId: MinutesVersionId;
+    readonly contentDigest: string | null;
+    readonly locator: unknown;
+    readonly provenance: Readonly<Record<string, unknown>>;
+}
+export interface MeetingMinutesVersionPortAccess {
+    readonly principal: string;
+    readonly [key: string]: unknown;
+}
+export interface MeetingMinutesVersionPort {
+    readExact(reference: MeetingMinutesVersionPortReference, access: MeetingMinutesVersionPortAccess): Promise<{
+        readonly reference: MeetingMinutesVersionPortReference;
+    } | null>;
+}
+export declare function createMeetingMinutesStore(options: MeetingMinutesStoreOptions): MeetingMinutesStore;
+/** Exposes the native file adapter for consumers that need an explicit port. */
+export declare function createMeetingMinutesStorage(data_dir: string): MeetingMinutesStoragePort;
+/** Stable body digest used by version readback and external source references. */
+export declare function meetingMinutesBodyDigest(body: string): string;
+/**
+ * Adapt one native store to the exact-version port. Every call delegates to
+ * `get_version`, so current ACL is evaluated by the same store instance that
+ * owns the native snapshot. The caller's reference is returned only after all
+ * stable source identity fields match the persisted version.
+ */
+export declare function createMeetingMinutesVersionPort(store: MeetingMinutesStore): MeetingMinutesVersionPort;