@unson/brainbase-mcp 0.6.0 → 0.7.0

package/dist/foundation-catalog.js

@@ -0,0 +1,206 @@
+import { createHash } from 'node:crypto';
+import { validateFoundationDefinition, validateFoundationRelation } from './ontology-foundation.js';
+const revisionPattern = /^[1-9]\d*$/;
+const digestPattern = /^sha256:[0-9a-f]{64}$/;
+/**
+ * The key is an encoded tuple rather than `${type}:${id}` so IDs containing a
+ * colon cannot alias another logical resource.
+ */
+export function foundationKey(reference) {
+    return JSON.stringify([reference.type, reference.id]);
+}
+export function createEmptyFoundationCatalog() {
+    return {
+        version: 1,
+        records: [],
+        latest: {},
+        relations: []
+    };
+}
+export function cloneFoundationCatalog(catalog) {
+    return JSON.parse(JSON.stringify(catalog));
+}
+export function cloneFoundationDefinition(definition) {
+    return JSON.parse(JSON.stringify(definition));
+}
+export function foundationRef(record) {
+    return {
+        id: record.definition.id,
+        type: record.definition.type,
+        revision: record.definition.revision,
+        digest: record.digest
+    };
+}
+/**
+ * Hashes the complete definition, with object keys sorted recursively. Array
+ * order remains significant because criteria, provenance, and authorized uses
+ * are ordered contracts in the shared ontology.
+ */
+export function digestFoundationDefinition(definition) {
+    const canonical = canonicalJson(definition);
+    return `sha256:${createHash('sha256').update(canonical, 'utf8').digest('hex')}`;
+}
+export function nextFoundationRevision(revision) {
+    assertRevision(revision, 'revision');
+    return (BigInt(revision) + 1n).toString();
+}
+export function assertFoundationRevision(value, label = 'revision') {
+    if (!isRecord(value)
+        || typeof value.id !== 'string'
+        || value.id.length === 0
+        || !isFoundationType(value.type)
+        || typeof value.revision !== 'string') {
+        throw new Error(`FOUNDATION-INVALID-REFERENCE: ${label} must contain id, type, and revision`);
+    }
+    assertRevision(value.revision, `${label}.revision`);
+}
+export function assertFoundationCatalog(value) {
+    if (value === undefined)
+        return;
+    if (!isRecord(value) || value.version !== 1 || !Array.isArray(value.records) || !Array.isArray(value.relations) || !isRecord(value.latest)) {
+        throw new Error('FOUNDATION-CATALOG-CORRUPT: version, records, latest, and relations are required');
+    }
+    const recordsByRevision = new Map();
+    const latestByLogical = new Map();
+    for (const [index, item] of value.records.entries()) {
+        if (!isRecord(item) || !isRecord(item.definition) || typeof item.digest !== 'string') {
+            throw new Error(`FOUNDATION-CATALOG-CORRUPT: records[${index}] must contain a definition and digest`);
+        }
+        const definition = item.definition;
+        assertDefinitionShape(definition, `records[${index}].definition`);
+        const revisionKey = `${foundationKey(definition)}@${definition.revision}`;
+        if (recordsByRevision.has(revisionKey)) {
+            throw new Error(`FOUNDATION-CATALOG-CORRUPT: duplicate revision ${revisionKey}`);
+        }
+        if (!digestPattern.test(item.digest) || item.digest !== digestFoundationDefinition(definition)) {
+            throw new Error(`FOUNDATION-CATALOG-CORRUPT: digest mismatch for ${revisionKey}`);
+        }
+        const record = item;
+        recordsByRevision.set(revisionKey, record);
+        const logicalKey = foundationKey(definition);
+        const previous = latestByLogical.get(logicalKey);
+        if (!previous || compareRevisions(definition.revision, previous.definition.revision) > 0) {
+            latestByLogical.set(logicalKey, record);
+        }
+    }
+    const latest = value.latest;
+    const latestKeys = Object.keys(latest);
+    if (latestKeys.length !== latestByLogical.size) {
+        throw new Error('FOUNDATION-CATALOG-CORRUPT: latest pointers do not match records');
+    }
+    for (const [logicalKey, record] of latestByLogical) {
+        const pointer = latest[logicalKey];
+        assertFoundationRevision(pointer, `latest[${logicalKey}]`);
+        if (foundationKey(pointer) !== logicalKey || pointer.revision !== record.definition.revision) {
+            throw new Error(`FOUNDATION-CATALOG-CORRUPT: latest pointer mismatch for ${logicalKey}`);
+        }
+        if (!recordsByRevision.has(`${logicalKey}@${pointer.revision}`)) {
+            throw new Error(`FOUNDATION-CATALOG-CORRUPT: latest pointer has no record for ${logicalKey}@${pointer.revision}`);
+        }
+    }
+    for (const [index, relation] of value.relations.entries()) {
+        if (!isRecord(relation))
+            throw new Error(`FOUNDATION-CATALOG-CORRUPT: relations[${index}] is not an object`);
+        const result = safeValidateRelation(relation);
+        if (!result.valid) {
+            throw new Error(`FOUNDATION-CATALOG-CORRUPT: relations[${index}] ${result.issues.map((issue) => issue.message).join('; ')}`);
+        }
+        for (const endpoint of [relation.source, relation.target]) {
+            if (!isRecord(endpoint) || typeof endpoint.id !== 'string' || !isFoundationType(endpoint.type) || typeof endpoint.revision !== 'string')
+                continue;
+            assertRevision(endpoint.revision, `relations[${index}] endpoint.revision`);
+            const endpointKey = `${foundationKey({ id: endpoint.id, type: endpoint.type })}@${endpoint.revision}`;
+            if (!recordsByRevision.has(endpointKey)) {
+                throw new Error(`FOUNDATION-CATALOG-CORRUPT: relation endpoint ${endpointKey} has no record`);
+            }
+        }
+    }
+}
+export function foundationCatalogOrEmpty(value) {
+    if (value === undefined)
+        return createEmptyFoundationCatalog();
+    assertFoundationCatalog(value);
+    return cloneFoundationCatalog(value);
+}
+export function findFoundationRecord(catalog, reference) {
+    assertFoundationRevision(reference);
+    return catalog.records.find((record) => (record.definition.id === reference.id
+        && record.definition.type === reference.type
+        && record.definition.revision === reference.revision));
+}
+export function findLatestFoundationRecord(catalog, type, id) {
+    const pointer = catalog.latest[foundationKey({ type, id })];
+    return pointer ? findFoundationRecord(catalog, pointer) : undefined;
+}
+function assertDefinitionShape(definition, label) {
+    if (!isRecord(definition)
+        || typeof definition.id !== 'string'
+        || definition.id.length === 0
+        || !isFoundationType(definition.type)
+        || typeof definition.revision !== 'string') {
+        throw new Error(`FOUNDATION-CATALOG-CORRUPT: ${label} has an invalid identity`);
+    }
+    assertRevision(definition.revision, `${label}.revision`);
+    if (!isRecord(definition.acl)
+        || typeof definition.acl.ownerId !== 'string'
+        || definition.acl.ownerId.length === 0
+        || !Array.isArray(definition.acl.readerIds)
+        || !Array.isArray(definition.acl.writerIds)
+        || !['private', 'project', 'organization', 'public'].includes(definition.acl.visibility)) {
+        throw new Error(`FOUNDATION-CATALOG-CORRUPT: ${label}.acl is invalid`);
+    }
+    const result = safeValidateDefinition(definition);
+    if (!result.valid) {
+        throw new Error(`FOUNDATION-CATALOG-CORRUPT: ${label} ${result.issues.map((issue) => issue.message).join('; ')}`);
+    }
+}
+function safeValidateDefinition(definition) {
+    try {
+        return validateFoundationDefinition(definition, { use: 'draft' });
+    }
+    catch (error) {
+        throw new Error(`invalid definition: ${formatError(error)}`);
+    }
+}
+function safeValidateRelation(relation) {
+    try {
+        return validateFoundationRelation(relation);
+    }
+    catch (error) {
+        throw new Error(`invalid relation: ${formatError(error)}`);
+    }
+}
+function assertRevision(value, label) {
+    if (!revisionPattern.test(value)) {
+        throw new Error(`FOUNDATION-INVALID-REVISION: ${label} must be a positive canonical decimal`);
+    }
+}
+function compareRevisions(left, right) {
+    const leftValue = BigInt(left);
+    const rightValue = BigInt(right);
+    return leftValue < rightValue ? -1 : leftValue > rightValue ? 1 : 0;
+}
+function isFoundationType(value) {
+    return value === 'objective' || value === 'variable' || value === 'model' || value === 'constraint';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function canonicalJson(value) {
+    const canonical = canonicalize(value);
+    const serialized = JSON.stringify(canonical);
+    if (serialized === undefined)
+        throw new Error('FOUNDATION-DIGEST-INVALID: definition is not JSON serializable');
+    return serialized;
+}
+function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map((item) => canonicalize(item));
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.keys(value).sort().flatMap((key) => (value[key] === undefined ? [] : [[key, canonicalize(value[key])]])));
+    }
+    return value;
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/foundation-constraint-store.d.ts

@@ -0,0 +1,50 @@
+import type { FoundationRevisionStore } from './foundation-store.js';
+import { type ConstraintAuthorizationContext, type ConstraintExceptionQuery, type ConstraintExceptionRecord, type ConstraintProjection, type ConstraintStore, type ConstraintStoreQuery } from './constraint-resolution.js';
+/**
+ * Exception records are deliberately a host supplied boundary.  The shared
+ * foundation catalog currently stores the ontology-level exception reference
+ * (Decision revision and scope), while Story04 also needs approval metadata,
+ * expiry, and rationale.  A host must therefore provide the canonical
+ * evidence/execution adapter for that record until the shared contract grows
+ * those fields; this module never creates a private sidecar file.
+ */
+export interface ConstraintExceptionStore {
+    append(exception: ConstraintExceptionRecord, context: ConstraintAuthorizationContext): Promise<ConstraintExceptionRecord>;
+    list(query: ConstraintExceptionQuery, context: ConstraintAuthorizationContext): Promise<readonly ConstraintExceptionRecord[]>;
+}
+export interface FoundationConstraintStoreOptions {
+    foundationStore: FoundationRevisionStore;
+    exceptionStore: ConstraintExceptionStore;
+}
+/**
+ * Adapts the Objective Story's GraphFoundationRevisionStore to the resolver's
+ * ConstraintStore port.  Definitions are persisted in the existing PersonalOs
+ * aggregate through FoundationRevisionStore; no second Graph or file is
+ * created here.
+ */
+export declare class FoundationConstraintStore<TConstraint extends ConstraintProjection = ConstraintProjection> implements ConstraintStore<TConstraint> {
+    private readonly foundationStore;
+    private readonly exceptionStore;
+    constructor(options: FoundationConstraintStoreOptions);
+    append(input: {
+        record: TConstraint;
+        expectedPreviousRevision?: string | null;
+    }, context?: ConstraintAuthorizationContext): Promise<TConstraint>;
+    get(ref: {
+        id: string;
+        revision: string;
+    }, context?: ConstraintAuthorizationContext): Promise<TConstraint | null>;
+    getLatest(id: string, context?: ConstraintAuthorizationContext): Promise<TConstraint | null>;
+    list(query: ConstraintStoreQuery, context?: ConstraintAuthorizationContext): Promise<readonly TConstraint[]>;
+    appendException(exception: ConstraintExceptionRecord, context?: ConstraintAuthorizationContext): Promise<ConstraintExceptionRecord>;
+    listExceptions(query: ConstraintExceptionQuery, context?: ConstraintAuthorizationContext): Promise<readonly ConstraintExceptionRecord[]>;
+    /**
+     * The injected exception boundary is intentionally persistence-only and may
+     * not enforce Foundation ACLs itself.  Resolve the referenced Constraint at
+     * this adapter boundary before allowing exception evidence to cross it.
+     * Current ACL controls access even when an exception points at an older
+     * revision; the exact revision is still read to reject dangling references.
+     */
+    private authorizeExceptionTarget;
+}
+export declare function createFoundationConstraintStore(options: FoundationConstraintStoreOptions): ConstraintStore;

package/dist/foundation-constraint-store.js

@@ -0,0 +1,215 @@
+import { FoundationStoreError } from './foundation-store.js';
+import { ConstraintError, validateConstraintExceptionRecord, } from './constraint-resolution.js';
+/**
+ * Adapts the Objective Story's GraphFoundationRevisionStore to the resolver's
+ * ConstraintStore port.  Definitions are persisted in the existing PersonalOs
+ * aggregate through FoundationRevisionStore; no second Graph or file is
+ * created here.
+ */
+export class FoundationConstraintStore {
+    foundationStore;
+    exceptionStore;
+    constructor(options) {
+        this.foundationStore = options.foundationStore;
+        this.exceptionStore = options.exceptionStore;
+    }
+    async append(input, context) {
+        const storeContext = toFoundationContext(context);
+        let reference;
+        try {
+            if (input.expectedPreviousRevision === null) {
+                reference = await this.foundationStore.create(input.record, storeContext);
+            }
+            else if (input.expectedPreviousRevision !== undefined) {
+                reference = await this.foundationStore.update({
+                    reference: {
+                        id: input.record.id,
+                        type: 'constraint',
+                        revision: input.expectedPreviousRevision,
+                    },
+                    next: input.record,
+                    expectedRevision: input.expectedPreviousRevision,
+                }, storeContext);
+            }
+            else {
+                throw new ConstraintError('revision_conflict', 'Foundation constraint append requires an explicit previous revision or null for create', 409);
+            }
+        }
+        catch (error) {
+            throw normalizeFoundationError(error, input.record.id);
+        }
+        if (reference.id !== input.record.id || reference.type !== 'constraint' || reference.revision !== input.record.revision) {
+            throw new ConstraintError('constraint_store_corrupt', 'Foundation store returned a different constraint revision than requested', 500, {
+                id: input.record.id,
+                requestedRevision: input.record.revision,
+                storedRevision: reference.revision,
+            });
+        }
+        const readback = await this.get({ id: reference.id, revision: reference.revision }, context);
+        if (!readback) {
+            throw new ConstraintError('constraint_store_corrupt', 'Foundation constraint readback was empty', 500, {
+                id: reference.id,
+                revision: reference.revision,
+            });
+        }
+        return readback;
+    }
+    async get(ref, context) {
+        const storeContext = toFoundationContext(context);
+        try {
+            const record = await this.foundationStore.read({ id: ref.id, type: 'constraint', revision: ref.revision }, storeContext);
+            return record?.definition.type === 'constraint' ? record.definition : null;
+        }
+        catch (error) {
+            throw normalizeFoundationError(error, ref.id);
+        }
+    }
+    async getLatest(id, context) {
+        const storeContext = toFoundationContext(context);
+        try {
+            const record = await this.foundationStore.readLatest('constraint', id, storeContext);
+            return record?.definition.type === 'constraint' ? record.definition : null;
+        }
+        catch (error) {
+            throw normalizeFoundationError(error, id);
+        }
+    }
+    async list(query, context) {
+        const storeContext = toFoundationContext(context);
+        try {
+            if (query.revision !== undefined && query.id !== undefined) {
+                const exact = await this.get({ id: query.id, revision: query.revision }, context);
+                return exact && (query.ownerId === undefined || exact.acl.ownerId === query.ownerId) ? [exact] : [];
+            }
+            const records = await this.foundationStore.list('constraint', storeContext);
+            return records
+                .map((record) => record.definition)
+                .filter((definition) => definition.type === 'constraint')
+                .filter((definition) => query.id === undefined || definition.id === query.id)
+                .filter((definition) => query.ownerId === undefined || definition.acl.ownerId === query.ownerId)
+                .map((definition) => definition);
+        }
+        catch (error) {
+            throw normalizeFoundationError(error);
+        }
+    }
+    async appendException(exception, context) {
+        const resolvedContext = context ?? missingContext();
+        try {
+            validateConstraintExceptionRecord(exception);
+            await this.authorizeExceptionTarget(exception.constraintRef.id, exception.constraintRef.revision, resolvedContext, 'write');
+            return await this.exceptionStore.append(exception, resolvedContext);
+        }
+        catch (error) {
+            throw normalizeFoundationError(error, exceptionConstraintId(exception));
+        }
+    }
+    async listExceptions(query, context) {
+        const resolvedContext = context ?? missingContext();
+        try {
+            if (query.constraintId !== undefined) {
+                await this.authorizeExceptionTarget(query.constraintId, query.constraintRevision, resolvedContext, 'read');
+            }
+            const exceptions = await this.exceptionStore.list(query, resolvedContext);
+            for (const exception of exceptions) {
+                validateConstraintExceptionRecord(exception);
+                await this.authorizeExceptionTarget(exception.constraintRef.id, exception.constraintRef.revision, resolvedContext, 'read');
+            }
+            return exceptions;
+        }
+        catch (error) {
+            throw normalizeFoundationError(error, query.constraintId);
+        }
+    }
+    /**
+     * The injected exception boundary is intentionally persistence-only and may
+     * not enforce Foundation ACLs itself.  Resolve the referenced Constraint at
+     * this adapter boundary before allowing exception evidence to cross it.
+     * Current ACL controls access even when an exception points at an older
+     * revision; the exact revision is still read to reject dangling references.
+     */
+    async authorizeExceptionTarget(constraintId, constraintRevision, context, access) {
+        const storeContext = toFoundationContext(context);
+        const current = await this.foundationStore.readLatest('constraint', constraintId, storeContext);
+        if (!current || current.definition.type !== 'constraint') {
+            throw new ConstraintError('constraint_not_found', 'exception target constraint was not found', 404, { id: constraintId });
+        }
+        if (constraintRevision !== undefined) {
+            const referenced = await this.foundationStore.read({
+                id: constraintId,
+                type: 'constraint',
+                revision: constraintRevision,
+            }, storeContext);
+            if (!referenced || referenced.definition.type !== 'constraint') {
+                throw new ConstraintError('constraint_not_found', 'exception target constraint revision was not found', 404, { id: constraintId, revision: constraintRevision });
+            }
+        }
+        const target = current.definition;
+        if (target.acl.ownerId !== context.ownerId) {
+            throw new ConstraintError('scope_violation', 'exception target constraint is outside the authorization context', 403, { id: target.id, ownerId: target.acl.ownerId });
+        }
+        const canRead = target.acl.visibility === 'public'
+            || target.acl.ownerId === context.actorId
+            || target.acl.readerIds.includes(context.actorId)
+            || target.acl.writerIds.includes(context.actorId);
+        if (!canRead) {
+            throw new ConstraintError('authorization_denied', 'actor cannot read the exception target constraint', 403, { id: target.id });
+        }
+        if (access === 'write') {
+            const canWrite = target.acl.ownerId === context.actorId || target.acl.writerIds.includes(context.actorId);
+            if (!canWrite) {
+                throw new ConstraintError('authorization_denied', 'actor cannot write exceptions for the target constraint', 403, { id: target.id });
+            }
+        }
+    }
+}
+function exceptionConstraintId(exception) {
+    if (!exception || typeof exception !== 'object')
+        return undefined;
+    const reference = exception.constraintRef;
+    if (!reference || typeof reference !== 'object')
+        return undefined;
+    const id = reference.id;
+    return typeof id === 'string' ? id : undefined;
+}
+export function createFoundationConstraintStore(options) {
+    return new FoundationConstraintStore(options);
+}
+function toFoundationContext(context) {
+    // `ownerId` identifies the target scope.  It is caller supplied request
+    // data and must never be promoted to an authenticated principal.  The
+    // principal is the actor identity established by the trusted auth boundary.
+    if (!context?.actorId)
+        return missingContext();
+    return { principal: context.actorId };
+}
+function missingContext() {
+    throw new ConstraintError('authorization_denied', 'Foundation constraint persistence requires an authenticated actor context', 403);
+}
+function normalizeFoundationError(error, id) {
+    if (error instanceof ConstraintError)
+        return error;
+    if (error instanceof FoundationStoreError) {
+        switch (error.code) {
+            case 'invalid_input':
+                return new ConstraintError('invalid_constraint', error.message, 400, { id });
+            case 'not_found':
+                return new ConstraintError('constraint_not_found', error.message, 404, { id });
+            case 'revision_conflict':
+                return new ConstraintError('revision_conflict', error.message, 409, {
+                    id,
+                    currentRevision: error.currentRevision,
+                });
+            case 'authorization_denied':
+                return new ConstraintError('authorization_denied', error.message, 403, { id });
+            case 'scope_violation':
+                return new ConstraintError('scope_violation', error.message, 403, { id });
+            case 'corrupt_catalog':
+            case 'readback_mismatch':
+                return new ConstraintError('constraint_store_corrupt', error.message, 500, { id });
+            case 'unsupported_graph':
+                return new ConstraintError('constraint_store_unavailable', error.message, 503, { id });
+        }
+    }
+    return new ConstraintError('constraint_store_unavailable', 'Foundation constraint store failed', 503, { id });
+}

package/dist/foundation-http.d.ts

@@ -0,0 +1,90 @@
+import type { CompanyOsObjectives } from './company-os-objectives.js';
+import { type FoundationStoreContext } from './foundation-store.js';
+import type { FoundationRef } from './foundation-catalog.js';
+import type { FoundationRevision, ObjectiveDefinition } from './ontology-foundation.js';
+import type { FoundationCatalogRecord } from './types.js';
+/**
+ * HTTP boundary shared by the OSS Objective UI and organization adapters.
+ *
+ * This module intentionally exposes a Fetch-style route handler instead of
+ * opening a listener.  A local host can mount it beside Reservation,
+ * Decision, or another Company OS route on one server.  Authentication,
+ * tenant scope, and CSRF are supplied by that host; none of them are read
+ * from a JSON request body.
+ */
+export declare const FOUNDATION_HTTP_CONTRACT_VERSION: "brainbase.foundation-http.v1";
+export declare const FOUNDATION_HTTP_PREFIX: "/api/foundation";
+export declare const FOUNDATION_OBJECTIVE_ROUTE_PREFIX: "/api/foundation/objectives";
+export declare const FOUNDATION_OBJECTIVE_ROUTES: readonly string[];
+type MaybePromise<T> = T | Promise<T>;
+export interface FoundationHttpRouteContext {
+    /** Resolved by the host's trusted auth/tenant boundary. */
+    readonly context: FoundationStoreContext;
+    readonly request: Request;
+}
+/**
+ * A route is deliberately a small composable unit.  `null` means that the
+ * route does not own this request, allowing a reservation/decision route to
+ * be mounted beside it without a second server or a route-specific BFF.
+ */
+export interface FoundationHttpRoute {
+    readonly name: string;
+    readonly methods: readonly string[];
+    readonly paths: readonly string[];
+    matches(request: Request): boolean;
+    handle(request: Request, input: FoundationHttpRouteContext): Promise<Response>;
+}
+export interface FoundationHttpCsrfVerifier {
+    verify(request: Request, context: FoundationStoreContext): MaybePromise<void | boolean>;
+}
+export interface FoundationHttpRouterOptions {
+    /** Return null to fail closed before any route handler is called. */
+    resolveContext(request: Request): MaybePromise<FoundationStoreContext | null>;
+    /** Mutation routes return 501 when no verifier is configured. */
+    csrf?: FoundationHttpCsrfVerifier;
+    routes: readonly FoundationHttpRoute[];
+    bodyLimitBytes?: number;
+}
+export interface FoundationHttpRouter {
+    readonly contractVersion: typeof FOUNDATION_HTTP_CONTRACT_VERSION;
+    readonly routes: readonly FoundationHttpRoute[];
+    handle(request: Request): Promise<Response>;
+}
+export interface ObjectiveDefinitionBuilderInput {
+    operation: 'create' | 'update';
+    /** Sanitized domain fields. Authorization fields have already been rejected. */
+    body: Readonly<Record<string, unknown>>;
+    context: FoundationStoreContext;
+    current?: ObjectiveDefinition;
+    expectedRevision?: string;
+}
+/**
+ * Hosts must construct ACL/scope/provenance/storage from trusted context.  A
+ * request body is only a proposal for domain fields and cannot authorize a
+ * tenant, principal, visibility, or permitted use.
+ */
+export type ObjectiveDefinitionBuilder = (input: ObjectiveDefinitionBuilderInput) => MaybePromise<ObjectiveDefinition>;
+export interface ObjectiveFoundationHttpRouteOptions {
+    objectives: Pick<CompanyOsObjectives, 'createObjective' | 'readObjective' | 'updateObjective' | 'checkObjectiveReadiness'> & {
+        list?(type: 'objective', context: FoundationStoreContext): Promise<FoundationCatalogRecord[]>;
+    };
+    /** Required for writes; the host supplies trusted ACL/scope fields. */
+    buildDefinition?: ObjectiveDefinitionBuilder;
+    /** Typed relation reads remain owned by the Story provider. */
+    listStoryObjectiveLinks?: (storyId: string, context: FoundationStoreContext) => MaybePromise<unknown>;
+    /** Constraint relation reads/writes remain owned by the canonical adapter. */
+    listObjectiveConstraintRefs?: (reference: FoundationRevision, context: FoundationStoreContext) => MaybePromise<unknown>;
+    replaceObjectiveConstraintRefs?: (reference: FoundationRef, refs: readonly FoundationRevision[], context: FoundationStoreContext) => MaybePromise<unknown>;
+    bodyLimitBytes?: number;
+}
+/**
+ * Compose OSS Company OS routes under one local server boundary.  The
+ * resolver is called only for a matching route and the resulting trusted
+ * context is passed to that route.  Unknown routes remain an ordinary 404 so
+ * the host can mount this handler beside other app routes.
+ */
+export declare function createFoundationHttpRouter(options: FoundationHttpRouterOptions): FoundationHttpRouter;
+/** Convenience constructor for a local/organization host with Objective routes only. */
+export declare function createObjectiveFoundationHttpHandler(options: ObjectiveFoundationHttpRouteOptions & Omit<FoundationHttpRouterOptions, 'routes'>): FoundationHttpRouter;
+export declare function createObjectiveFoundationRoute(options: ObjectiveFoundationHttpRouteOptions): FoundationHttpRoute;
+export {};