@unson/brainbase-mcp 0.6.0 → 0.8.0

package/dist/philosophy-revision-reader.js

@@ -0,0 +1,241 @@
+import { createHash } from 'node:crypto';
+import { isActiveAt } from './canonical-graph.js';
+import { canonicalPortableJson } from './portable-graph.js';
+/** The host owns the canonical philosophy source; this package owns only the read port. */
+export const PHILOSOPHY_REVISION_READ_CONTRACT_VERSION = 'philosophy-revision-read.v1';
+const REVISION_PATTERN = /^[1-9]\d*$/u;
+const DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/u;
+const SCOPE_TYPES = ['personal', 'project', 'organization'];
+const ACL_VISIBILITIES = ['private', 'project', 'organization', 'public'];
+/**
+ * Computes the stable identity of a canonical philosophy revision.
+ * Current ACL and scope are intentionally excluded so authorization changes do
+ * not create a false content revision; they are checked on every read.
+ */
+export function philosophyRevisionDigest(input) {
+    assertPhilosophyRevisionIdentity(input);
+    assertPhilosophyRevisionPayload(input.payload);
+    assertPhilosophyRevisionApplicability(input.applicability);
+    const content = {
+        kind: input.kind,
+        id: input.id,
+        revision: input.revision,
+        payload: input.payload,
+        applicability: canonicalApplicability(input.applicability)
+    };
+    return `sha256:${createHash('sha256').update(canonicalPortableJson(content), 'utf8').digest('hex')}`;
+}
+/** Structural check for callers that need to validate a reference before I/O. */
+export function isPhilosophyRevisionReference(value) {
+    if (!isPlainRecord(value) || value.kind !== 'philosophy')
+        return false;
+    if (!isNonEmptyString(value.id) || !isPositiveRevision(value.revision) || !isDigest(value.digest))
+        return false;
+    if (!isPhilosophyRevisionScope(value.scope) || !isRfc3339(value.valid_from))
+        return false;
+    if (value.valid_to === undefined || value.valid_to === null)
+        return true;
+    return typeof value.valid_to === 'string' && isValidInterval(value.valid_from, value.valid_to);
+}
+/**
+ * Adapt canonical philosophy reads to `JudgmentProblemReferenceProvider.resolveOther`.
+ * Unknown reference kinds remain unresolved so the caller can compose other
+ * providers explicitly.
+ */
+export function createJudgmentProblemPhilosophyReferenceResolver(options) {
+    if (!options || !options.reader || typeof options.reader.read !== 'function') {
+        throw new TypeError('A PhilosophyRevisionReader is required');
+    }
+    return async (input) => {
+        if (input.reference.kind !== 'philosophy') {
+            return { status: 'unresolved', message: `Philosophy revision resolver does not handle ${input.reference.kind}` };
+        }
+        if (!isNonEmptyString(input.context.principal)) {
+            return { status: 'unauthorized', message: 'A trusted principal is required for philosophy revision reads' };
+        }
+        const reference = {
+            kind: 'philosophy',
+            id: input.reference.id,
+            revision: input.reference.revision,
+            digest: input.reference.digest,
+            scope: cloneScope(input.reference.scope),
+            valid_from: input.reference.valid_from,
+            ...(input.reference.valid_to == null ? {} : { valid_to: input.reference.valid_to })
+        };
+        if (!isPhilosophyRevisionReference(reference)) {
+            return { status: 'unresolved', message: 'Philosophy revision reference is invalid' };
+        }
+        let result;
+        try {
+            result = await options.reader.read({
+                reference,
+                phase: input.phase,
+                // Snapshot access has no caller-supplied mutable scope. The reference
+                // scope is the requested boundary; the host must bind it to its trusted
+                // current tenant/project context before returning a record.
+                context: { principal: input.context.principal, scope: cloneScope(reference.scope) }
+            });
+        }
+        catch {
+            return { status: 'unresolved', message: 'Philosophy revision reader failed closed' };
+        }
+        if (!isPlainRecord(result) || typeof result.status !== 'string') {
+            return { status: 'unresolved', message: 'Philosophy revision reader returned an invalid result' };
+        }
+        if (result.status === 'missing') {
+            return { status: 'missing', message: result.message ?? 'Philosophy revision was not found' };
+        }
+        if (result.status === 'unauthorized') {
+            return { status: 'unauthorized', message: result.message ?? 'Philosophy revision is not readable' };
+        }
+        if (result.status === 'corrupt') {
+            return { status: 'unresolved', message: result.message ?? 'Philosophy revision failed integrity validation' };
+        }
+        if (result.status !== 'resolved' || !isPlainRecord(result.record)) {
+            return { status: 'unresolved', message: 'Philosophy revision reader returned an invalid resolved record' };
+        }
+        const integrity = validateResolvedRecord(result.record, reference, input.context.principal, input.phase);
+        if (integrity.status !== 'resolved')
+            return integrity;
+        return { status: 'resolved', digest: reference.digest };
+    };
+}
+function validateResolvedRecord(record, reference, principal, phase) {
+    if (record.kind !== 'philosophy' || record.id !== reference.id || record.revision !== reference.revision) {
+        return { status: 'unresolved', message: 'Philosophy revision identity does not match the requested reference' };
+    }
+    if (!isDigest(record.digest) || record.digest !== reference.digest) {
+        return { status: 'unresolved', message: 'Philosophy revision digest does not match the requested reference' };
+    }
+    try {
+        assertPhilosophyRevisionPayload(record.payload);
+        assertPhilosophyRevisionApplicability(record.applicability);
+        if (philosophyRevisionDigest(record) !== record.digest) {
+            return { status: 'unresolved', message: 'Philosophy revision payload digest is corrupt' };
+        }
+    }
+    catch {
+        return { status: 'unresolved', message: 'Philosophy revision payload or applicability is corrupt' };
+    }
+    if (!isPhilosophyRevisionAcl(record.currentAcl) || !isPhilosophyRevisionScope(record.currentScope)) {
+        return { status: 'unresolved', message: 'Philosophy revision authorization metadata is corrupt' };
+    }
+    if (!sameScope(record.currentScope, reference.scope)) {
+        return { status: 'unauthorized', message: 'Philosophy revision is outside the requested tenant/project scope' };
+    }
+    // A current save/read must prove that the revision applies to this
+    // judgment.  Historical reads preserve the original reference and only
+    // re-check immutable content plus the current ACL/scope, matching the
+    // snapshot provider contract; applicability is not re-evaluated against a
+    // later policy boundary.
+    if (phase !== 'historical_read') {
+        if (!sameScope(record.applicability.scope, reference.scope)) {
+            return { status: 'not_applicable', message: 'Philosophy revision is outside the requested applicability scope' };
+        }
+        const referenceApplicability = referenceApplicabilityFrom(reference);
+        if (!periodContains(record.applicability, referenceApplicability)) {
+            return { status: 'not_applicable', message: 'Philosophy revision does not cover the requested applicability period' };
+        }
+    }
+    if (!canReadPhilosophyRevision(record.currentAcl, principal)) {
+        return { status: 'unauthorized', message: 'Philosophy revision is not readable by the current principal' };
+    }
+    return { status: 'resolved', digest: reference.digest };
+}
+function assertPhilosophyRevisionIdentity(value) {
+    if (value.kind !== 'philosophy' || !isNonEmptyString(value.id) || !isPositiveRevision(value.revision)) {
+        throw new TypeError('Philosophy revision identity requires kind, id, and a positive revision');
+    }
+}
+function assertPhilosophyRevisionPayload(value) {
+    try {
+        // canonicalPortableJson rejects undefined, non-JSON objects, non-finite
+        // numbers, and cyclic values while preserving opaque philosophy shape.
+        canonicalPortableJson(value);
+    }
+    catch {
+        throw new TypeError('Philosophy revision payload must be a JSON value');
+    }
+}
+function assertPhilosophyRevisionApplicability(value) {
+    if (!isPlainRecord(value) || !isPhilosophyRevisionScope(value.scope) || !isRfc3339(value.validFrom) ||
+        (value.validUntil !== undefined && !isRfc3339(value.validUntil)) ||
+        (typeof value.validUntil === 'string' && Date.parse(value.validFrom) > Date.parse(value.validUntil))) {
+        throw new TypeError('Philosophy revision applicability is invalid');
+    }
+}
+function referenceApplicabilityFrom(reference) {
+    return {
+        scope: cloneScope(reference.scope),
+        validFrom: reference.valid_from,
+        ...(reference.valid_to == null ? {} : { validUntil: reference.valid_to })
+    };
+}
+function canonicalApplicability(value) {
+    return {
+        scope: cloneScope(value.scope),
+        validFrom: value.validFrom,
+        ...(value.validUntil === undefined ? {} : { validUntil: value.validUntil })
+    };
+}
+function periodContains(source, requested) {
+    const sourceFrom = Date.parse(source.validFrom);
+    const sourceUntil = source.validUntil === undefined ? Number.POSITIVE_INFINITY : Date.parse(source.validUntil);
+    const requestedFrom = Date.parse(requested.validFrom);
+    const requestedUntil = requested.validUntil === undefined ? Number.POSITIVE_INFINITY : Date.parse(requested.validUntil);
+    return sourceFrom <= requestedFrom && sourceUntil >= requestedUntil;
+}
+function isValidInterval(from, to) {
+    return isRfc3339(from) && isRfc3339(to) && Date.parse(from) <= Date.parse(to);
+}
+function isPhilosophyRevisionAcl(value) {
+    if (!isPlainRecord(value) || !isNonEmptyString(value.ownerId) ||
+        !ACL_VISIBILITIES.includes(value.visibility) ||
+        !isStringArray(value.readerIds) || !isStringArray(value.writerIds))
+        return false;
+    return new Set(value.readerIds).size === value.readerIds.length && new Set(value.writerIds).size === value.writerIds.length;
+}
+function canReadPhilosophyRevision(acl, principal) {
+    return acl.visibility === 'public' || acl.ownerId === principal ||
+        acl.readerIds.includes(principal) || acl.writerIds.includes(principal);
+}
+function isPhilosophyRevisionScope(value) {
+    return isPlainRecord(value) && SCOPE_TYPES.includes(value.type) && isNonEmptyString(value.id);
+}
+function sameScope(left, right) {
+    return left.type === right.type && left.id === right.id;
+}
+function cloneScope(scope) {
+    return { type: scope.type, id: scope.id };
+}
+function isDigest(value) {
+    return typeof value === 'string' && DIGEST_PATTERN.test(value);
+}
+function isPositiveRevision(value) {
+    return typeof value === 'string' && REVISION_PATTERN.test(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0 && !value.includes('\0');
+}
+function isPlainRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => isNonEmptyString(item));
+}
+function isRfc3339(value) {
+    if (typeof value !== 'string')
+        return false;
+    try {
+        // Reuse the canonical Graph calendar validation so philosophy revision
+        // periods reject the same malformed timestamps as Graph records.
+        isActiveAt({ validFrom: value }, value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/portable-graph.d.ts

@@ -29,6 +29,30 @@ export declare function createPortableGraph(os: PersonalOs): PortableGraphBundle
 export declare function validatePortableGraph(value: unknown): asserts value is PortableGraphBundle;
 /** Rehydrate a validated bundle into the shared retrieval input shape. */
 export declare function hydratePortableGraph(bundle: PortableGraphBundle): PersonalOs;
+/** The ID an OSS Personal OS gives its owner; a host replaces it with the owner's own ID when reading a bundle. */
+export declare const PORTABLE_GRAPH_OWNER_PLACEHOLDER = "self";
+export interface PortableGraphOwner {
+    /** The owner's person ID in the host that stores the bundle (never `self`). */
+    personId: string;
+    /** The owner's name in that host, shown in place of the bundle's name for `self`. */
+    name?: string | null;
+}
+/**
+ * Read a bundle as its owner: every `self` becomes the owner's person ID in
+ * the host, and the owner's record carries the host's name for them (the
+ * bundle's own name stays as an alias).  Replaced: `graph.owner.id`, the
+ * entity `self`, relation endpoints, and in the foundation definitions
+ * `acl.ownerId` / `readerIds` / `writerIds`, `beneficiaryIds`,
+ * `accountableId` and the `subjectIds` of every scope (`scope`,
+ * `applicability`, constraint exception scopes).
+ *
+ * The result is a read projection, not a bundle to store or send: the input
+ * is not changed, relation IDs stay those of the stored bundle (they name the
+ * relation there) and foundation digests are not recomputed.  A bundle that
+ * already has another record with the owner's person ID is refused rather
+ * than merged.
+ */
+export declare function bindPortableGraphOwner(bundle: PortableGraphBundle, owner: PortableGraphOwner): PortableGraphBundle;
 /** Use exactly the OSS retrieval implementation against a portable bundle. */
 export declare function retrievePortableGraph(bundle: PortableGraphBundle, input: GraphRetrievalInput, provider?: EmbeddingProvider): Promise<GraphRetrievalResponse>;
 /** Canonical JSON with recursively sorted object keys and preserved array order. */

package/dist/portable-graph.js

@@ -102,6 +102,83 @@ export function hydratePortableGraph(bundle) {
         sourceCount: 0
     };
 }
+/** The ID an OSS Personal OS gives its owner; a host replaces it with the owner's own ID when reading a bundle. */
+export const PORTABLE_GRAPH_OWNER_PLACEHOLDER = 'self';
+/**
+ * Read a bundle as its owner: every `self` becomes the owner's person ID in
+ * the host, and the owner's record carries the host's name for them (the
+ * bundle's own name stays as an alias).  Replaced: `graph.owner.id`, the
+ * entity `self`, relation endpoints, and in the foundation definitions
+ * `acl.ownerId` / `readerIds` / `writerIds`, `beneficiaryIds`,
+ * `accountableId` and the `subjectIds` of every scope (`scope`,
+ * `applicability`, constraint exception scopes).
+ *
+ * The result is a read projection, not a bundle to store or send: the input
+ * is not changed, relation IDs stay those of the stored bundle (they name the
+ * relation there) and foundation digests are not recomputed.  A bundle that
+ * already has another record with the owner's person ID is refused rather
+ * than merged.
+ */
+export function bindPortableGraphOwner(bundle, owner) {
+    validatePortableGraph(bundle);
+    const personId = typeof owner?.personId === 'string' ? owner.personId.trim() : '';
+    if (!personId || personId === PORTABLE_GRAPH_OWNER_PLACEHOLDER) {
+        throw new Error('PORTABLE-GRAPH-OWNER: the owner person ID is required and cannot be self');
+    }
+    if (bundle.graph.entities.some((entity) => entity.id === personId)) {
+        throw new Error(`PORTABLE-GRAPH-OWNER-CONFLICT: the bundle already has a record ${personId}`);
+    }
+    const name = typeof owner.name === 'string' && owner.name.trim() ? owner.name.trim() : null;
+    const bound = structuredClone(bundle);
+    const swap = (id) => (id === PORTABLE_GRAPH_OWNER_PLACEHOLDER ? personId : id);
+    const swapAll = (ids) => {
+        if (!Array.isArray(ids))
+            return;
+        for (let index = 0; index < ids.length; index += 1)
+            if (typeof ids[index] === 'string')
+                ids[index] = swap(ids[index]);
+    };
+    const graph = bound.graph;
+    if (graph.owner) {
+        if (graph.owner.id === PORTABLE_GRAPH_OWNER_PLACEHOLDER)
+            graph.owner.id = personId;
+        if (name)
+            graph.owner.name = name;
+    }
+    for (const entity of graph.entities) {
+        if (entity.id !== PORTABLE_GRAPH_OWNER_PLACEHOLDER)
+            continue;
+        entity.id = personId;
+        if (name && name !== entity.name) {
+            const aliases = entity.aliases ?? [];
+            if (entity.name.trim() && !aliases.includes(entity.name))
+                aliases.push(entity.name);
+            entity.aliases = aliases;
+            entity.name = name;
+        }
+    }
+    for (const edge of graph.edges) {
+        edge.fromId = swap(edge.fromId);
+        edge.toId = swap(edge.toId);
+    }
+    for (const record of graph.foundation?.records ?? []) {
+        const definition = record.definition;
+        if (isPlainRecord(definition.acl)) {
+            if (typeof definition.acl.ownerId === 'string')
+                definition.acl.ownerId = swap(definition.acl.ownerId);
+            swapAll(definition.acl.readerIds);
+            swapAll(definition.acl.writerIds);
+        }
+        swapAll(definition.beneficiaryIds);
+        if (typeof definition.accountableId === 'string')
+            definition.accountableId = swap(definition.accountableId);
+        for (const scope of [definition.scope, definition.applicability, ...(Array.isArray(definition.exceptions) ? definition.exceptions.map((item) => item?.scope) : [])]) {
+            if (isPlainRecord(scope))
+                swapAll(scope.subjectIds);
+        }
+    }
+    return bound;
+}
 /** Use exactly the OSS retrieval implementation against a portable bundle. */
 export function retrievePortableGraph(bundle, input, provider) {
     return retrieveGraph(hydratePortableGraph(bundle), input, provider);

package/dist/problem-candidates.d.ts

@@ -0,0 +1,149 @@
+import type { FoundationRevisionStore } from './foundation-store.js';
+import type { FoundationAcl, FoundationRevision, FoundationScope } from './ontology-foundation.js';
+/**
+ * Problem candidates are evidence-sidecar records. They are deliberately not
+ * Graph entities: a candidate is a reviewable input to problem selection, not
+ * an approved problem or a canonical fact.
+ */
+export declare const PROBLEM_CANDIDATES_CONTRACT_VERSION: "problem-candidates.v1";
+export declare const PROBLEM_CANDIDATE_CATALOG_VERSION: 1;
+export declare const PROBLEM_CANDIDATES_SIDECAR: "evidence/problem-candidates.json";
+export type ProblemCandidateKind = 'gap' | 'opportunity' | 'threat' | 'uncertainty';
+export type ProblemCandidateStatus = 'candidate' | 'merged' | 'dismissed';
+export type ProblemCandidateSourceKind = 'event' | 'observation' | 'document' | 'decision' | 'import' | 'candidate' | 'evidence';
+export interface ProblemCandidateKnown<T> {
+    readonly status: 'known';
+    readonly value: T;
+}
+export interface ProblemCandidateUnknown {
+    readonly status: 'unknown';
+    readonly reason: string;
+}
+/** Unknown is explicit so missing data cannot become zero, empty, or success. */
+export type ProblemCandidateField<T> = ProblemCandidateKnown<T> | ProblemCandidateUnknown;
+export interface ProblemCandidateSourceRef {
+    readonly id: string;
+    readonly kind: ProblemCandidateSourceKind;
+    /** Optional immutable source digest. Evidence content is never embedded. */
+    readonly digest?: string;
+}
+export interface ProblemCandidateEventInput {
+    readonly id: string;
+    readonly occurredAt: string;
+    readonly recordedAt: string;
+    readonly sourceRefs: readonly ProblemCandidateSourceRef[];
+}
+export interface ProblemCandidateEvent extends ProblemCandidateEventInput {
+    readonly id: string;
+    readonly occurredAt: string;
+    readonly recordedAt: string;
+    readonly sourceRefs: readonly ProblemCandidateSourceRef[];
+}
+/** Exact Objective revision plus its canonical definition digest. */
+export interface ProblemCandidateObjectiveReference extends FoundationRevision {
+    readonly type: 'objective';
+    readonly digest: string;
+}
+export interface ProblemCandidateDeadline {
+    readonly dueAt: string;
+    readonly evaluationAt?: string;
+}
+export interface ProblemCandidateResource {
+    readonly id: string;
+    readonly kind: string;
+    readonly quantity?: number;
+    readonly unit?: string;
+}
+export interface ProblemCandidateInput {
+    readonly id: string;
+    readonly kind: ProblemCandidateKind;
+    readonly statement: string;
+    readonly objectiveRefs: readonly ProblemCandidateObjectiveReference[];
+    readonly event: ProblemCandidateEventInput;
+    readonly observedGap: ProblemCandidateField<string>;
+    readonly opportunity: ProblemCandidateField<string>;
+    readonly threat: ProblemCandidateField<string>;
+    readonly uncertainty: ProblemCandidateField<string>;
+    readonly deadline: ProblemCandidateField<ProblemCandidateDeadline>;
+    readonly expectedEffect: ProblemCandidateField<string>;
+    readonly requiredResources: ProblemCandidateField<readonly ProblemCandidateResource[]>;
+    readonly responsibleId: ProblemCandidateField<string>;
+    readonly ownerScope: FoundationScope;
+    readonly acl: FoundationAcl;
+    /** Only mergeCandidates may set this field. */
+    readonly mergedFrom?: readonly string[];
+    /** Optional creation time; defaults to event.recordedAt. */
+    readonly createdAt?: string;
+    /** Runtime input may carry candidate only; selection states are rejected. */
+    readonly status?: ProblemCandidateStatus;
+}
+export interface ProblemCandidateProvenance {
+    readonly eventIds: readonly string[];
+    readonly sourceRefs: readonly ProblemCandidateSourceRef[];
+    readonly candidateIds: readonly string[];
+}
+export interface ProblemCandidateRecord extends Omit<ProblemCandidateInput, 'mergedFrom' | 'createdAt' | 'status'> {
+    readonly contractVersion: typeof PROBLEM_CANDIDATES_CONTRACT_VERSION;
+    readonly status: ProblemCandidateStatus;
+    readonly mergedFrom: readonly string[];
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly provenance: ProblemCandidateProvenance;
+    readonly payloadDigest: string;
+}
+export interface ProblemCandidateQuery {
+    readonly ownerScope?: FoundationScope;
+    readonly responsibleId?: string;
+    readonly status?: ProblemCandidateStatus;
+}
+export interface ProblemCandidateMergeInput extends ProblemCandidateInput {
+    readonly sourceCandidateIds: readonly string[];
+}
+export interface ProblemCandidateStoreContext {
+    /** Identity and optional scope must come from a trusted caller boundary. */
+    readonly principal: string;
+    readonly scope?: FoundationScope;
+}
+export type ProblemCandidateEvidenceOperation = 'save' | 'read';
+/**
+ * Trusted current-access boundary for source evidence. Candidate ACLs are not
+ * evidence ACLs: every source reference, including roots reached through a
+ * merge, must be authorized by this provider before candidate text is exposed.
+ * The provider must fail closed when a source is missing or its digest is no
+ * longer readable for the principal.
+ */
+export interface ProblemCandidateEvidenceAccessProvider {
+    authorize(input: {
+        readonly operation: ProblemCandidateEvidenceOperation;
+        readonly context: ProblemCandidateStoreContext;
+        readonly source: ProblemCandidateSourceRef;
+    }): void | boolean | Promise<void | boolean>;
+}
+export type ProblemCandidateStoreErrorCode = 'invalid_input' | 'not_found' | 'revision_conflict' | 'event_conflict' | 'authorization_denied' | 'scope_violation' | 'unsupported_graph' | 'corrupt_record' | 'readback_mismatch';
+export declare class ProblemCandidateStoreError extends Error {
+    readonly code: ProblemCandidateStoreErrorCode;
+    constructor(code: ProblemCandidateStoreErrorCode, message: string);
+}
+export interface ProblemCandidateStore {
+    saveCandidate(input: ProblemCandidateInput, context: ProblemCandidateStoreContext): Promise<ProblemCandidateRecord>;
+    /** Alias kept explicit for callers that name the resource in the method. */
+    saveProblemCandidate(input: ProblemCandidateInput, context: ProblemCandidateStoreContext): Promise<ProblemCandidateRecord>;
+    mergeCandidates(input: ProblemCandidateMergeInput, context: ProblemCandidateStoreContext): Promise<ProblemCandidateRecord>;
+    readCandidate(id: string, context: ProblemCandidateStoreContext): Promise<ProblemCandidateRecord | null>;
+    listCandidates(query: ProblemCandidateQuery | undefined, context: ProblemCandidateStoreContext): Promise<readonly ProblemCandidateRecord[]>;
+}
+/**
+ * Validates, clones, and freezes a candidate input. The function is also a
+ * pure contract surface for providers that want to validate before storage.
+ */
+export declare function normalizeProblemCandidate(input: ProblemCandidateInput): ProblemCandidateInput;
+/** Returns validation without throwing, useful for contract fixtures. */
+export declare function validateProblemCandidate(input: ProblemCandidateInput): {
+    readonly valid: boolean;
+    readonly issues: readonly string[];
+};
+export declare function createProblemCandidateStore(options: {
+    readonly dataDir: string;
+    readonly foundationStore: FoundationRevisionStore;
+    readonly evidenceAccessProvider: ProblemCandidateEvidenceAccessProvider;
+}): ProblemCandidateStore;