@polypixel/memoir-sdk 0.1.0

package/dist/memoir/v1/memory_pb.d.ts

@@ -0,0 +1,1448 @@
+import type { GenEnum, GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv2";
+import type { Duration, Timestamp } from "@bufbuild/protobuf/wkt";
+import type { JsonObject, Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file memoir/v1/memory.proto.
+ */
+export declare const file_memoir_v1_memory: GenFile;
+/**
+ * Scope uniquely identifies a memory partition. Memories written under one
+ * scope are never returned under another. The triple matches the manifesto's
+ * SDK pseudocode and the Tier-1 integration shape.
+ *
+ * @generated from message memoir.v1.Scope
+ */
+export type Scope = Message<"memoir.v1.Scope"> & {
+    /**
+     * @generated from field: string agent_id = 1;
+     */
+    agentId: string;
+    /**
+     * @generated from field: string org_id = 2;
+     */
+    orgId: string;
+    /**
+     * @generated from field: string user_id = 3;
+     */
+    userId: string;
+};
+/**
+ * Describes the message memoir.v1.Scope.
+ * Use `create(ScopeSchema)` to create a new message.
+ */
+export declare const ScopeSchema: GenMessage<Scope>;
+/**
+ * @generated from message memoir.v1.Memory
+ */
+export type Memory = Message<"memoir.v1.Memory"> & {
+    /**
+     * @generated from field: string pid = 1;
+     */
+    pid: string;
+    /**
+     * @generated from field: memoir.v1.Scope scope = 2;
+     */
+    scope?: Scope;
+    /**
+     * @generated from field: string content = 3;
+     */
+    content: string;
+    /**
+     * @generated from field: google.protobuf.Struct metadata = 4;
+     */
+    metadata?: JsonObject;
+    /**
+     * @generated from field: google.protobuf.Timestamp created_at = 5;
+     */
+    createdAt?: Timestamp;
+    /**
+     * Set when the worker has fully processed the memory (embedding + any
+     * extraction). As of memoir-core v0.1 the library does not yet populate
+     * a dedicated `processed_at` column — the field stays unset for now;
+     * consumers should rely on `status == MEMORY_STATUS_PROCESSED` as the
+     * canonical "ready" signal. The proto field is preserved so a future
+     * library schema migration can backfill it without a proto bump.
+     *
+     * @generated from field: optional google.protobuf.Timestamp processed_at = 6;
+     */
+    processedAt?: Timestamp;
+    /**
+     * Lifecycle state. Maps from memoir-core's `memories.qdrant_status`
+     * column (`pending` / `indexed` / `failed`) to PENDING / PROCESSED /
+     * FAILED at the handler boundary.
+     *
+     * @generated from field: memoir.v1.MemoryStatus status = 7;
+     */
+    status: MemoryStatus;
+    /**
+     * Wall-clock time of the row's last in-place edit. Equals `created_at`
+     * for memories never edited. Maps from memoir-core's `Memory.updated_at`.
+     *
+     * @generated from field: google.protobuf.Timestamp updated_at = 8;
+     */
+    updatedAt?: Timestamp;
+    /**
+     * Event-time of the thing being remembered, distinct from `created_at`
+     * (when memoir was told). Unset when no event-time is known (preferences,
+     * identity facts). Maps from memoir-core's `Memory.event_at`.
+     *
+     * @generated from field: optional google.protobuf.Timestamp event_at = 9;
+     */
+    eventAt?: Timestamp;
+    /**
+     * Soft-deletion marker; unset when the memory is active. Maps from
+     * memoir-core's `Memory.supersession` (`SupersessionInfo`).
+     *
+     * @generated from field: optional memoir.v1.Supersession supersession = 10;
+     */
+    supersession?: Supersession;
+    /**
+     * Episodic (raw utterance written via Remember) or semantic (a fact the
+     * extraction worker derived from an episodic source). Maps from
+     * memoir-core's `Memory.kind`.
+     *
+     * @generated from field: memoir.v1.MemoryKind kind = 11;
+     */
+    kind: MemoryKind;
+};
+/**
+ * Describes the message memoir.v1.Memory.
+ * Use `create(MemorySchema)` to create a new message.
+ */
+export declare const MemorySchema: GenMessage<Memory>;
+/**
+ * Latest supersession state for a Memory — winner pid and decision time.
+ * Mirrors memoir-core's `SupersessionInfo`. Present only on superseded rows.
+ *
+ * @generated from message memoir.v1.Supersession
+ */
+export type Supersession = Message<"memoir.v1.Supersession"> & {
+    /**
+     * @generated from field: string winner_pid = 1;
+     */
+    winnerPid: string;
+    /**
+     * @generated from field: google.protobuf.Timestamp at = 2;
+     */
+    at?: Timestamp;
+};
+/**
+ * Describes the message memoir.v1.Supersession.
+ * Use `create(SupersessionSchema)` to create a new message.
+ */
+export declare const SupersessionSchema: GenMessage<Supersession>;
+/**
+ * Selects which memory kinds a read includes. Mirrors memoir-core's
+ * `KindSelector`. Per the library's semantics, a selector with BOTH fields
+ * false (the proto3 default, or an omitted selector) means "all kinds" —
+ * not "no kinds". Setting exactly one field filters to that kind.
+ *
+ * @generated from message memoir.v1.KindSelector
+ */
+export type KindSelector = Message<"memoir.v1.KindSelector"> & {
+    /**
+     * @generated from field: bool episodic = 1;
+     */
+    episodic: boolean;
+    /**
+     * @generated from field: bool semantic = 2;
+     */
+    semantic: boolean;
+};
+/**
+ * Describes the message memoir.v1.KindSelector.
+ * Use `create(KindSelectorSchema)` to create a new message.
+ */
+export declare const KindSelectorSchema: GenMessage<KindSelector>;
+/**
+ * Search result with similarity score attached.
+ *
+ * @generated from message memoir.v1.SearchHit
+ */
+export type SearchHit = Message<"memoir.v1.SearchHit"> & {
+    /**
+     * @generated from field: memoir.v1.Memory memory = 1;
+     */
+    memory?: Memory;
+    /**
+     * Cosine similarity, higher = closer. Range [-1.0, 1.0]; in practice
+     * memoir-core's embedding model yields scores in [0.0, 1.0] for typical
+     * semantic content. memoir-core's vector index returns this value
+     * verbatim (no rank normalization), sourced from Qdrant's `query`
+     * response per `packages/memoir-core/src/vector/qdrant.rs`.
+     *
+     * @generated from field: float score = 2;
+     */
+    score: number;
+};
+/**
+ * Describes the message memoir.v1.SearchHit.
+ * Use `create(SearchHitSchema)` to create a new message.
+ */
+export declare const SearchHitSchema: GenMessage<SearchHit>;
+/**
+ * @generated from message memoir.v1.SearchRequest
+ */
+export type SearchRequest = Message<"memoir.v1.SearchRequest"> & {
+    /**
+     * @generated from field: memoir.v1.Scope scope = 1;
+     */
+    scope?: Scope;
+    /**
+     * @generated from field: string query = 2;
+     */
+    query: string;
+    /**
+     * Maximum hits to return. memoir-core treats `limit = 0` as "use library
+     * default" (currently 10, per `packages/memoir-core/src/client/search.rs`
+     * `DEFAULT_LIMIT`). The handler in memoir-service enforces a soft cap on
+     * very large values — agents typically request 5-50. No cursor-based
+     * pagination in v0.1.
+     *
+     * @generated from field: int32 limit = 3;
+     */
+    limit: number;
+    /**
+     * Optional caller-supplied metadata filter, AND-joined with the scope
+     * and kind conditions enforced by the library. Caller-supplied conditions
+     * cannot widen scope. See `MemoryFilter` for shape.
+     *
+     * @generated from field: optional memoir.v1.MemoryFilter metadata_filter = 4;
+     */
+    metadataFilter?: MemoryFilter;
+    /**
+     * Optional similarity floor in [-1.0, 1.0]. Hits with score below this
+     * value are dropped by the vector backend before they reach the response.
+     * Unset = no floor.
+     *
+     * @generated from field: optional float min_similarity = 5;
+     */
+    minSimilarity?: number;
+    /**
+     * Restricts retrieval to the selected memory kind(s). Omitted or
+     * both-false = all kinds (see `KindSelector`). Maps to the library's
+     * `SearchBuilder::episodic` / `::semantic` toggles.
+     *
+     * @generated from field: optional memoir.v1.KindSelector kinds = 6;
+     */
+    kinds?: KindSelector;
+};
+/**
+ * Describes the message memoir.v1.SearchRequest.
+ * Use `create(SearchRequestSchema)` to create a new message.
+ */
+export declare const SearchRequestSchema: GenMessage<SearchRequest>;
+/**
+ * Caller-supplied filter applied at search time. Mirrors Qdrant's payload
+ * filter structure one-to-one but is a memoir-owned type so consumers do not
+ * take a transitive Qdrant dependency. Sections combine as:
+ *   - `must` — AND
+ *   - `must_not` — AND-NOT
+ *   - `should` — OR (at least one)
+ * An empty filter (all sections empty) is inert.
+ *
+ * @generated from message memoir.v1.MemoryFilter
+ */
+export type MemoryFilter = Message<"memoir.v1.MemoryFilter"> & {
+    /**
+     * @generated from field: repeated memoir.v1.FilterCondition must = 1;
+     */
+    must: FilterCondition[];
+    /**
+     * @generated from field: repeated memoir.v1.FilterCondition must_not = 2;
+     */
+    mustNot: FilterCondition[];
+    /**
+     * @generated from field: repeated memoir.v1.FilterCondition should = 3;
+     */
+    should: FilterCondition[];
+};
+/**
+ * Describes the message memoir.v1.MemoryFilter.
+ * Use `create(MemoryFilterSchema)` to create a new message.
+ */
+export declare const MemoryFilterSchema: GenMessage<MemoryFilter>;
+/**
+ * One field-targeted condition inside a [`MemoryFilter`].
+ *
+ * @generated from message memoir.v1.FilterCondition
+ */
+export type FilterCondition = Message<"memoir.v1.FilterCondition"> & {
+    /**
+     * Payload field name to apply the condition against.
+     *
+     * @generated from field: string field = 1;
+     */
+    field: string;
+    /**
+     * @generated from oneof memoir.v1.FilterCondition.condition
+     */
+    condition: {
+        /**
+         * Field equals a single value.
+         *
+         * @generated from field: memoir.v1.MatchValue equals = 2;
+         */
+        value: MatchValue;
+        case: "equals";
+    } | {
+        /**
+         * Field equals any value in the list — `IN (...)` semantics.
+         *
+         * @generated from field: memoir.v1.MatchValues in_values = 3;
+         */
+        value: MatchValues;
+        case: "inValues";
+    } | {
+        /**
+         * Field is a number within the range.
+         *
+         * @generated from field: memoir.v1.NumericRange range = 4;
+         */
+        value: NumericRange;
+        case: "range";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message memoir.v1.FilterCondition.
+ * Use `create(FilterConditionSchema)` to create a new message.
+ */
+export declare const FilterConditionSchema: GenMessage<FilterCondition>;
+/**
+ * Concrete value for equality matching. Mirrors memoir-core's `MatchValue`.
+ *
+ * @generated from message memoir.v1.MatchValue
+ */
+export type MatchValue = Message<"memoir.v1.MatchValue"> & {
+    /**
+     * @generated from oneof memoir.v1.MatchValue.value
+     */
+    value: {
+        /**
+         * @generated from field: string keyword = 1;
+         */
+        value: string;
+        case: "keyword";
+    } | {
+        /**
+         * @generated from field: int64 integer = 2;
+         */
+        value: bigint;
+        case: "integer";
+    } | {
+        /**
+         * @generated from field: bool boolean = 3;
+         */
+        value: boolean;
+        case: "boolean";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message memoir.v1.MatchValue.
+ * Use `create(MatchValueSchema)` to create a new message.
+ */
+export declare const MatchValueSchema: GenMessage<MatchValue>;
+/**
+ * List of values for `IN (...)` matching. Mirrors memoir-core's `MatchValues`.
+ *
+ * @generated from message memoir.v1.MatchValues
+ */
+export type MatchValues = Message<"memoir.v1.MatchValues"> & {
+    /**
+     * @generated from oneof memoir.v1.MatchValues.values
+     */
+    values: {
+        /**
+         * @generated from field: memoir.v1.KeywordList keywords = 1;
+         */
+        value: KeywordList;
+        case: "keywords";
+    } | {
+        /**
+         * @generated from field: memoir.v1.IntegerList integers = 2;
+         */
+        value: IntegerList;
+        case: "integers";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message memoir.v1.MatchValues.
+ * Use `create(MatchValuesSchema)` to create a new message.
+ */
+export declare const MatchValuesSchema: GenMessage<MatchValues>;
+/**
+ * @generated from message memoir.v1.KeywordList
+ */
+export type KeywordList = Message<"memoir.v1.KeywordList"> & {
+    /**
+     * @generated from field: repeated string values = 1;
+     */
+    values: string[];
+};
+/**
+ * Describes the message memoir.v1.KeywordList.
+ * Use `create(KeywordListSchema)` to create a new message.
+ */
+export declare const KeywordListSchema: GenMessage<KeywordList>;
+/**
+ * @generated from message memoir.v1.IntegerList
+ */
+export type IntegerList = Message<"memoir.v1.IntegerList"> & {
+    /**
+     * @generated from field: repeated int64 values = 1;
+     */
+    values: bigint[];
+};
+/**
+ * Describes the message memoir.v1.IntegerList.
+ * Use `create(IntegerListSchema)` to create a new message.
+ */
+export declare const IntegerListSchema: GenMessage<IntegerList>;
+/**
+ * Half-open or closed numeric range. All bounds optional; an entirely-unbounded
+ * range matches every numeric value (and is a no-op — prefer omitting the
+ * condition).
+ *
+ * @generated from message memoir.v1.NumericRange
+ */
+export type NumericRange = Message<"memoir.v1.NumericRange"> & {
+    /**
+     * @generated from field: optional double lt = 1;
+     */
+    lt?: number;
+    /**
+     * @generated from field: optional double lte = 2;
+     */
+    lte?: number;
+    /**
+     * @generated from field: optional double gt = 3;
+     */
+    gt?: number;
+    /**
+     * @generated from field: optional double gte = 4;
+     */
+    gte?: number;
+};
+/**
+ * Describes the message memoir.v1.NumericRange.
+ * Use `create(NumericRangeSchema)` to create a new message.
+ */
+export declare const NumericRangeSchema: GenMessage<NumericRange>;
+/**
+ * @generated from message memoir.v1.SearchResponse
+ */
+export type SearchResponse = Message<"memoir.v1.SearchResponse"> & {
+    /**
+     * @generated from field: repeated memoir.v1.SearchHit hits = 1;
+     */
+    hits: SearchHit[];
+};
+/**
+ * Describes the message memoir.v1.SearchResponse.
+ * Use `create(SearchResponseSchema)` to create a new message.
+ */
+export declare const SearchResponseSchema: GenMessage<SearchResponse>;
+/**
+ * @generated from message memoir.v1.RecallRequest
+ */
+export type RecallRequest = Message<"memoir.v1.RecallRequest"> & {
+    /**
+     * @generated from field: string pid = 1;
+     */
+    pid: string;
+};
+/**
+ * Describes the message memoir.v1.RecallRequest.
+ * Use `create(RecallRequestSchema)` to create a new message.
+ */
+export declare const RecallRequestSchema: GenMessage<RecallRequest>;
+/**
+ * @generated from message memoir.v1.RecallResponse
+ */
+export type RecallResponse = Message<"memoir.v1.RecallResponse"> & {
+    /**
+     * @generated from field: memoir.v1.Memory memory = 1;
+     */
+    memory?: Memory;
+};
+/**
+ * Describes the message memoir.v1.RecallResponse.
+ * Use `create(RecallResponseSchema)` to create a new message.
+ */
+export declare const RecallResponseSchema: GenMessage<RecallResponse>;
+/**
+ * @generated from message memoir.v1.RememberRequest
+ */
+export type RememberRequest = Message<"memoir.v1.RememberRequest"> & {
+    /**
+     * @generated from field: memoir.v1.Scope scope = 1;
+     */
+    scope?: Scope;
+    /**
+     * @generated from field: string content = 2;
+     */
+    content: string;
+    /**
+     * @generated from field: optional google.protobuf.Struct metadata = 3;
+     */
+    metadata?: JsonObject;
+};
+/**
+ * Describes the message memoir.v1.RememberRequest.
+ * Use `create(RememberRequestSchema)` to create a new message.
+ */
+export declare const RememberRequestSchema: GenMessage<RememberRequest>;
+/**
+ * @generated from message memoir.v1.RememberResponse
+ */
+export type RememberResponse = Message<"memoir.v1.RememberResponse"> & {
+    /**
+     * The persisted memory. `status` is always `MEMORY_STATUS_PENDING` at
+     * write time — the worker drains the embed (and, if configured, extract)
+     * queue asynchronously. Consumers needing job-state visibility use the
+     * `AdminService` (see `admin.proto`) rather than additional fields here.
+     *
+     * @generated from field: memoir.v1.Memory memory = 1;
+     */
+    memory?: Memory;
+};
+/**
+ * Describes the message memoir.v1.RememberResponse.
+ * Use `create(RememberResponseSchema)` to create a new message.
+ */
+export declare const RememberResponseSchema: GenMessage<RememberResponse>;
+/**
+ * @generated from message memoir.v1.ForgetRequest
+ */
+export type ForgetRequest = Message<"memoir.v1.ForgetRequest"> & {
+    /**
+     * Either pid (target a single memory) OR scope (target every memory in a scope).
+     * Exactly one must be set.
+     *
+     * @generated from oneof memoir.v1.ForgetRequest.target
+     */
+    target: {
+        /**
+         * @generated from field: string pid = 1;
+         */
+        value: string;
+        case: "pid";
+    } | {
+        /**
+         * @generated from field: memoir.v1.Scope scope = 2;
+         */
+        value: Scope;
+        case: "scope";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+    /**
+     * When false, soft-delete (status preserved, memory excluded from search).
+     *
+     * @generated from field: bool hard_delete = 3;
+     */
+    hardDelete: boolean;
+};
+/**
+ * Describes the message memoir.v1.ForgetRequest.
+ * Use `create(ForgetRequestSchema)` to create a new message.
+ */
+export declare const ForgetRequestSchema: GenMessage<ForgetRequest>;
+/**
+ * @generated from message memoir.v1.ForgetResponse
+ */
+export type ForgetResponse = Message<"memoir.v1.ForgetResponse"> & {
+    /**
+     * The pids that were actually removed from the source of truth. Empty
+     * when the target matched no rows (not an error). Mirrors the library's
+     * `Client::forget` return shape (`Vec<String>`).
+     *
+     * @generated from field: repeated string deleted_pids = 1;
+     */
+    deletedPids: string[];
+};
+/**
+ * Describes the message memoir.v1.ForgetResponse.
+ * Use `create(ForgetResponseSchema)` to create a new message.
+ */
+export declare const ForgetResponseSchema: GenMessage<ForgetResponse>;
+/**
+ * @generated from message memoir.v1.TimelineRequest
+ */
+export type TimelineRequest = Message<"memoir.v1.TimelineRequest"> & {
+    /**
+     * @generated from field: memoir.v1.Scope scope = 1;
+     */
+    scope?: Scope;
+    /**
+     * Restricts to the selected kind(s). Omitted or both-false = all kinds.
+     *
+     * @generated from field: optional memoir.v1.KindSelector kinds = 2;
+     */
+    kinds?: KindSelector;
+    /**
+     * Half-open time windows. `*_after` is inclusive (>=), `*_before` is
+     * exclusive (<), matching the library's `start..end` convention. All
+     * optional; unset = unbounded on that side. `created_*` filters on
+     * write-time, `event_at_*` on event-time (rows with no event_at are
+     * excluded by an event_at bound).
+     *
+     * @generated from field: optional google.protobuf.Timestamp created_after = 3;
+     */
+    createdAfter?: Timestamp;
+    /**
+     * @generated from field: optional google.protobuf.Timestamp created_before = 4;
+     */
+    createdBefore?: Timestamp;
+    /**
+     * @generated from field: optional google.protobuf.Timestamp event_at_after = 5;
+     */
+    eventAtAfter?: Timestamp;
+    /**
+     * @generated from field: optional google.protobuf.Timestamp event_at_before = 6;
+     */
+    eventAtBefore?: Timestamp;
+    /**
+     * Drops superseded rows when true. Default (false/omitted) INCLUDES them —
+     * timeline is the audit view. The field is named for the non-default
+     * action so proto3's false-default aligns with the library's
+     * include-by-default behavior.
+     *
+     * @generated from field: bool exclude_superseded = 7;
+     */
+    excludeSuperseded: boolean;
+    /**
+     * Maximum rows. `0` = library default (50, `DEFAULT_TIMELINE_LIMIT`).
+     *
+     * @generated from field: int32 limit = 8;
+     */
+    limit: number;
+    /**
+     * Oldest-first when true. Default (false/omitted) is newest-first by
+     * created_at, matching the library default.
+     *
+     * @generated from field: bool ascending = 9;
+     */
+    ascending: boolean;
+};
+/**
+ * Describes the message memoir.v1.TimelineRequest.
+ * Use `create(TimelineRequestSchema)` to create a new message.
+ */
+export declare const TimelineRequestSchema: GenMessage<TimelineRequest>;
+/**
+ * @generated from message memoir.v1.TimelineResponse
+ */
+export type TimelineResponse = Message<"memoir.v1.TimelineResponse"> & {
+    /**
+     * Memories in the requested order. `score` is never set (timeline computes
+     * no similarity). Mirrors `Client::timeline`'s `Vec<Memory>` return.
+     *
+     * @generated from field: repeated memoir.v1.Memory memories = 1;
+     */
+    memories: Memory[];
+};
+/**
+ * Describes the message memoir.v1.TimelineResponse.
+ * Use `create(TimelineResponseSchema)` to create a new message.
+ */
+export declare const TimelineResponseSchema: GenMessage<TimelineResponse>;
+/**
+ * @generated from message memoir.v1.RecallAsOfRequest
+ */
+export type RecallAsOfRequest = Message<"memoir.v1.RecallAsOfRequest"> & {
+    /**
+     * @generated from field: memoir.v1.Scope scope = 1;
+     */
+    scope?: Scope;
+    /**
+     * The point in time to reconstruct. Memories created on or before this
+     * instant that were active (not yet superseded) as of it are returned.
+     * A future `as_of` yields current state; one before any memory existed
+     * yields empty — both fall out of the library semantics.
+     *
+     * @generated from field: google.protobuf.Timestamp as_of = 2;
+     */
+    asOf?: Timestamp;
+    /**
+     * Restricts to the selected kind(s). Omitted or both-false = all kinds.
+     *
+     * @generated from field: optional memoir.v1.KindSelector kinds = 3;
+     */
+    kinds?: KindSelector;
+    /**
+     * Maximum rows. `0` = library default (50, `DEFAULT_TIMELINE_LIMIT`).
+     *
+     * @generated from field: int32 limit = 4;
+     */
+    limit: number;
+};
+/**
+ * Describes the message memoir.v1.RecallAsOfRequest.
+ * Use `create(RecallAsOfRequestSchema)` to create a new message.
+ */
+export declare const RecallAsOfRequestSchema: GenMessage<RecallAsOfRequest>;
+/**
+ * @generated from message memoir.v1.RecallAsOfResponse
+ */
+export type RecallAsOfResponse = Message<"memoir.v1.RecallAsOfResponse"> & {
+    /**
+     * Memories active as of the requested instant, newest-first. `score` is
+     * never set. Mirrors `Client::recall_as_of`'s `Vec<Memory>` return.
+     *
+     * @generated from field: repeated memoir.v1.Memory memories = 1;
+     */
+    memories: Memory[];
+};
+/**
+ * Describes the message memoir.v1.RecallAsOfResponse.
+ * Use `create(RecallAsOfResponseSchema)` to create a new message.
+ */
+export declare const RecallAsOfResponseSchema: GenMessage<RecallAsOfResponse>;
+/**
+ * How Query orders candidates. Mirrors memoir-core's `RankingStrategy`.
+ * A message-with-oneof (not a bare enum) so new strategies and their
+ * parameters are additive — matching the Rust enum's `#[non_exhaustive]`
+ * posture. An unset oneof means "use the library default" (hybrid).
+ *
+ * @generated from message memoir.v1.Ranking
+ */
+export type Ranking = Message<"memoir.v1.Ranking"> & {
+    /**
+     * @generated from oneof memoir.v1.Ranking.strategy
+     */
+    strategy: {
+        /**
+         * @generated from field: memoir.v1.Hybrid hybrid = 1;
+         */
+        value: Hybrid;
+        case: "hybrid";
+    } | {
+        /**
+         * @generated from field: memoir.v1.Blended blended = 2;
+         */
+        value: Blended;
+        case: "blended";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message memoir.v1.Ranking.
+ * Use `create(RankingSchema)` to create a new message.
+ */
+export declare const RankingSchema: GenMessage<Ranking>;
+/**
+ * Blend of cosine similarity and recency. Mirrors `RankingStrategy::Hybrid`.
+ * score = alpha * cosine + (1 - alpha) * decay(age).
+ *
+ * @generated from message memoir.v1.Hybrid
+ */
+export type Hybrid = Message<"memoir.v1.Hybrid"> & {
+    /**
+     * Weight on cosine in [0.0, 1.0]; (1 - alpha) weights recency.
+     *
+     * @generated from field: float alpha = 1;
+     */
+    alpha: number;
+    /**
+     * Recency-decay function applied to the memory's age.
+     *
+     * @generated from field: memoir.v1.Decay decay = 2;
+     */
+    decay?: Decay;
+};
+/**
+ * Describes the message memoir.v1.Hybrid.
+ * Use `create(HybridSchema)` to create a new message.
+ */
+export declare const HybridSchema: GenMessage<Hybrid>;
+/**
+ * Linear blend of cosine, confidence, recency, and a category bonus.
+ * Mirrors `RankingStrategy::Blended`. score =
+ *   w_cos*cosine + w_conf*(confidence/100) + w_rec*decay(age)
+ *   + category_bonus (when the memory's category is preferred).
+ *
+ * @generated from message memoir.v1.Blended
+ */
+export type Blended = Message<"memoir.v1.Blended"> & {
+    /**
+     * @generated from field: memoir.v1.BlendWeights weights = 1;
+     */
+    weights?: BlendWeights;
+    /**
+     * Recency-decay function applied to the memory's age.
+     *
+     * @generated from field: memoir.v1.Decay decay = 2;
+     */
+    decay?: Decay;
+};
+/**
+ * Describes the message memoir.v1.Blended.
+ * Use `create(BlendedSchema)` to create a new message.
+ */
+export declare const BlendedSchema: GenMessage<Blended>;
+/**
+ * Signal weights for `Blended`. Mirrors memoir-core's `BlendWeights`.
+ *
+ * @generated from message memoir.v1.BlendWeights
+ */
+export type BlendWeights = Message<"memoir.v1.BlendWeights"> & {
+    /**
+     * Weight on cosine similarity.
+     *
+     * @generated from field: float cosine = 1;
+     */
+    cosine: number;
+    /**
+     * Weight on confidence (0-100 normalized to [0, 1]).
+     *
+     * @generated from field: float confidence = 2;
+     */
+    confidence: number;
+    /**
+     * Weight on the recency-decay term.
+     *
+     * @generated from field: float recency = 3;
+     */
+    recency: number;
+    /**
+     * Additive bonus when a memory's category is in preferred_categories.
+     *
+     * @generated from field: float category_bonus = 4;
+     */
+    categoryBonus: number;
+    /**
+     * Categories that earn the bonus. Empty disables it.
+     *
+     * @generated from field: repeated string preferred_categories = 5;
+     */
+    preferredCategories: string[];
+};
+/**
+ * Describes the message memoir.v1.BlendWeights.
+ * Use `create(BlendWeightsSchema)` to create a new message.
+ */
+export declare const BlendWeightsSchema: GenMessage<BlendWeights>;
+/**
+ * Recency-decay function. Mirrors memoir-core's `DecayFn`. Message-with-oneof
+ * for the same additive-forward-compat reason as `Ranking`.
+ *
+ * @generated from message memoir.v1.Decay
+ */
+export type Decay = Message<"memoir.v1.Decay"> & {
+    /**
+     * @generated from oneof memoir.v1.Decay.function
+     */
+    function: {
+        /**
+         * @generated from field: memoir.v1.ExponentialDecay exponential = 1;
+         */
+        value: ExponentialDecay;
+        case: "exponential";
+    } | {
+        /**
+         * @generated from field: memoir.v1.ReciprocalDecay reciprocal = 2;
+         */
+        value: ReciprocalDecay;
+        case: "reciprocal";
+    } | {
+        /**
+         * @generated from field: memoir.v1.StepDecay step = 3;
+         */
+        value: StepDecay;
+        case: "step";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+};
+/**
+ * Describes the message memoir.v1.Decay.
+ * Use `create(DecaySchema)` to create a new message.
+ */
+export declare const DecaySchema: GenMessage<Decay>;
+/**
+ * exp(-ln(2) * age / half_life); reaches 0.5 at half_life.
+ *
+ * @generated from message memoir.v1.ExponentialDecay
+ */
+export type ExponentialDecay = Message<"memoir.v1.ExponentialDecay"> & {
+    /**
+     * @generated from field: google.protobuf.Duration half_life = 1;
+     */
+    halfLife?: Duration;
+};
+/**
+ * Describes the message memoir.v1.ExponentialDecay.
+ * Use `create(ExponentialDecaySchema)` to create a new message.
+ */
+export declare const ExponentialDecaySchema: GenMessage<ExponentialDecay>;
+/**
+ * 1 / (1 + age / scale); reaches 0.5 at scale, slower tail than exponential.
+ *
+ * @generated from message memoir.v1.ReciprocalDecay
+ */
+export type ReciprocalDecay = Message<"memoir.v1.ReciprocalDecay"> & {
+    /**
+     * @generated from field: google.protobuf.Duration scale = 1;
+     */
+    scale?: Duration;
+};
+/**
+ * Describes the message memoir.v1.ReciprocalDecay.
+ * Use `create(ReciprocalDecaySchema)` to create a new message.
+ */
+export declare const ReciprocalDecaySchema: GenMessage<ReciprocalDecay>;
+/**
+ * Bucketed decay. Buckets are ordered by ascending boundary; an age within
+ * [prev_boundary, boundary] takes that bucket's value; ages past the last
+ * boundary take the last value.
+ *
+ * @generated from message memoir.v1.StepDecay
+ */
+export type StepDecay = Message<"memoir.v1.StepDecay"> & {
+    /**
+     * @generated from field: repeated memoir.v1.DecayBucket buckets = 1;
+     */
+    buckets: DecayBucket[];
+};
+/**
+ * Describes the message memoir.v1.StepDecay.
+ * Use `create(StepDecaySchema)` to create a new message.
+ */
+export declare const StepDecaySchema: GenMessage<StepDecay>;
+/**
+ * @generated from message memoir.v1.DecayBucket
+ */
+export type DecayBucket = Message<"memoir.v1.DecayBucket"> & {
+    /**
+     * @generated from field: google.protobuf.Duration boundary = 1;
+     */
+    boundary?: Duration;
+    /**
+     * @generated from field: float value = 2;
+     */
+    value: number;
+};
+/**
+ * Describes the message memoir.v1.DecayBucket.
+ * Use `create(DecayBucketSchema)` to create a new message.
+ */
+export declare const DecayBucketSchema: GenMessage<DecayBucket>;
+/**
+ * Query result with its hybrid (blended cosine + recency) score attached.
+ * Distinct from `SearchHit`: that hit's `score` is raw cosine; this one's
+ * is the post-re-rank hybrid score.
+ *
+ * @generated from message memoir.v1.QueryHit
+ */
+export type QueryHit = Message<"memoir.v1.QueryHit"> & {
+    /**
+     * @generated from field: memoir.v1.Memory memory = 1;
+     */
+    memory?: Memory;
+    /**
+     * @generated from field: float score = 2;
+     */
+    score: number;
+};
+/**
+ * Describes the message memoir.v1.QueryHit.
+ * Use `create(QueryHitSchema)` to create a new message.
+ */
+export declare const QueryHitSchema: GenMessage<QueryHit>;
+/**
+ * @generated from message memoir.v1.QueryRequest
+ */
+export type QueryRequest = Message<"memoir.v1.QueryRequest"> & {
+    /**
+     * @generated from field: memoir.v1.Scope scope = 1;
+     */
+    scope?: Scope;
+    /**
+     * @generated from field: string query = 2;
+     */
+    query: string;
+    /**
+     * Maximum hits to return. `0` = library default (10, `DEFAULT_QUERY_LIMIT`).
+     *
+     * @generated from field: int32 limit = 3;
+     */
+    limit: number;
+    /**
+     * Restricts to the selected kind(s). Omitted or both-false = all kinds.
+     *
+     * @generated from field: optional memoir.v1.KindSelector kinds = 4;
+     */
+    kinds?: KindSelector;
+    /**
+     * Optional caller-supplied metadata filter, AND-joined with scope+kind.
+     *
+     * @generated from field: optional memoir.v1.MemoryFilter metadata_filter = 5;
+     */
+    metadataFilter?: MemoryFilter;
+    /**
+     * Optional cosine floor applied at CANDIDATE-RETRIEVAL, before hybrid
+     * re-ranking — NOT a floor on the final hybrid score. Candidates below
+     * this raw-cosine value never enter the re-rank. Unset = no floor.
+     *
+     * @generated from field: optional float min_similarity = 6;
+     */
+    minSimilarity?: number;
+    /**
+     * Half-open time windows on write-time / event-time. See `TimelineRequest`
+     * for the inclusive-after / exclusive-before convention.
+     *
+     * @generated from field: optional google.protobuf.Timestamp created_after = 7;
+     */
+    createdAfter?: Timestamp;
+    /**
+     * @generated from field: optional google.protobuf.Timestamp created_before = 8;
+     */
+    createdBefore?: Timestamp;
+    /**
+     * @generated from field: optional google.protobuf.Timestamp event_at_after = 9;
+     */
+    eventAtAfter?: Timestamp;
+    /**
+     * @generated from field: optional google.protobuf.Timestamp event_at_before = 10;
+     */
+    eventAtBefore?: Timestamp;
+    /**
+     * Ranking strategy. Unset = library default hybrid (parameters may drift
+     * pre-1.0; pin an explicit Ranking for stable behavior).
+     *
+     * @generated from field: optional memoir.v1.Ranking ranking = 11;
+     */
+    ranking?: Ranking;
+};
+/**
+ * Describes the message memoir.v1.QueryRequest.
+ * Use `create(QueryRequestSchema)` to create a new message.
+ */
+export declare const QueryRequestSchema: GenMessage<QueryRequest>;
+/**
+ * @generated from message memoir.v1.QueryResponse
+ */
+export type QueryResponse = Message<"memoir.v1.QueryResponse"> & {
+    /**
+     * Ranked hits, best-first. Each carries its hybrid score.
+     *
+     * @generated from field: repeated memoir.v1.QueryHit hits = 1;
+     */
+    hits: QueryHit[];
+    /**
+     * The ranking that produced this result, with library defaults filled in
+     * when the request left `ranking` unset. Mirrors
+     * `MemoryContext::strategy_used()`.
+     *
+     * @generated from field: memoir.v1.Ranking ranking_used = 2;
+     */
+    rankingUsed?: Ranking;
+};
+/**
+ * Describes the message memoir.v1.QueryResponse.
+ * Use `create(QueryResponseSchema)` to create a new message.
+ */
+export declare const QueryResponseSchema: GenMessage<QueryResponse>;
+/**
+ * @generated from message memoir.v1.EditRequest
+ */
+export type EditRequest = Message<"memoir.v1.EditRequest"> & {
+    /**
+     * The memory to edit.
+     *
+     * @generated from field: string pid = 1;
+     */
+    pid: string;
+    /**
+     * Fields to overwrite. Each is independent: an unset field is left
+     * untouched, a set field is overwritten. An EditRequest with no fields
+     * set is a no-op that returns the current row. There is no way to clear
+     * `event_at` back to unset over the wire (mirrors the library, which
+     * only supports setting it).
+     *
+     * @generated from field: optional string content = 2;
+     */
+    content?: string;
+    /**
+     * @generated from field: optional google.protobuf.Struct metadata = 3;
+     */
+    metadata?: JsonObject;
+    /**
+     * @generated from field: optional google.protobuf.Timestamp event_at = 4;
+     */
+    eventAt?: Timestamp;
+};
+/**
+ * Describes the message memoir.v1.EditRequest.
+ * Use `create(EditRequestSchema)` to create a new message.
+ */
+export declare const EditRequestSchema: GenMessage<EditRequest>;
+/**
+ * @generated from message memoir.v1.EditResponse
+ */
+export type EditResponse = Message<"memoir.v1.EditResponse"> & {
+    /**
+     * The updated memory. After a content edit the row is re-embedding, so
+     * `status` is PENDING and the row is briefly excluded from search —
+     * same lifecycle as a fresh Remember.
+     *
+     * @generated from field: memoir.v1.Memory memory = 1;
+     */
+    memory?: Memory;
+};
+/**
+ * Describes the message memoir.v1.EditResponse.
+ * Use `create(EditResponseSchema)` to create a new message.
+ */
+export declare const EditResponseSchema: GenMessage<EditResponse>;
+/**
+ * @generated from message memoir.v1.FeedbackRequest
+ */
+export type FeedbackRequest = Message<"memoir.v1.FeedbackRequest"> & {
+    /**
+     * The wrong *semantic* memory the user is correcting (the fact they saw in
+     * recall). Must be a semantic row with an episodic source; an episodic pid
+     * is rejected (correct those via Edit).
+     *
+     * @generated from field: string pid = 1;
+     */
+    pid: string;
+    /**
+     * The user's correction, woven into the re-extraction prompt so the model
+     * fixes its reasoning. Optional, but supplying it is the point — without it
+     * the source is re-extracted blind.
+     *
+     * @generated from field: optional string correction = 2;
+     */
+    correction?: string;
+};
+/**
+ * Describes the message memoir.v1.FeedbackRequest.
+ * Use `create(FeedbackRequestSchema)` to create a new message.
+ */
+export declare const FeedbackRequestSchema: GenMessage<FeedbackRequest>;
+/**
+ * Empty: feedback is fire-and-forget. The correction completes behind the
+ * worker queue; re-Recall later to observe the corrected rows.
+ *
+ * @generated from message memoir.v1.FeedbackResponse
+ */
+export type FeedbackResponse = Message<"memoir.v1.FeedbackResponse"> & {};
+/**
+ * Describes the message memoir.v1.FeedbackResponse.
+ * Use `create(FeedbackResponseSchema)` to create a new message.
+ */
+export declare const FeedbackResponseSchema: GenMessage<FeedbackResponse>;
+/**
+ * @generated from message memoir.v1.SupersessionHistoryRequest
+ */
+export type SupersessionHistoryRequest = Message<"memoir.v1.SupersessionHistoryRequest"> & {
+    /**
+     * The memory whose supersession trail to read.
+     *
+     * @generated from field: string pid = 1;
+     */
+    pid: string;
+};
+/**
+ * Describes the message memoir.v1.SupersessionHistoryRequest.
+ * Use `create(SupersessionHistoryRequestSchema)` to create a new message.
+ */
+export declare const SupersessionHistoryRequestSchema: GenMessage<SupersessionHistoryRequest>;
+/**
+ * @generated from message memoir.v1.SupersessionHistoryResponse
+ */
+export type SupersessionHistoryResponse = Message<"memoir.v1.SupersessionHistoryResponse"> & {
+    /**
+     * The full event trail, oldest first. Empty when the memory was never
+     * superseded (or doesn't exist — both produce no rows).
+     *
+     * @generated from field: repeated memoir.v1.SupersessionEvent events = 1;
+     */
+    events: SupersessionEvent[];
+};
+/**
+ * Describes the message memoir.v1.SupersessionHistoryResponse.
+ * Use `create(SupersessionHistoryResponseSchema)` to create a new message.
+ */
+export declare const SupersessionHistoryResponseSchema: GenMessage<SupersessionHistoryResponse>;
+/**
+ * @generated from message memoir.v1.ListAgentsRequest
+ */
+export type ListAgentsRequest = Message<"memoir.v1.ListAgentsRequest"> & {
+    /**
+     * The org whose agents to list.
+     *
+     * @generated from field: string org_id = 1;
+     */
+    orgId: string;
+    /**
+     * The user whose agents to list.
+     *
+     * @generated from field: string user_id = 2;
+     */
+    userId: string;
+};
+/**
+ * Describes the message memoir.v1.ListAgentsRequest.
+ * Use `create(ListAgentsRequestSchema)` to create a new message.
+ */
+export declare const ListAgentsRequestSchema: GenMessage<ListAgentsRequest>;
+/**
+ * @generated from message memoir.v1.ListAgentsResponse
+ */
+export type ListAgentsResponse = Message<"memoir.v1.ListAgentsResponse"> & {
+    /**
+     * Distinct agent ids in the org + user scope, sorted ascending. Empty
+     * when the scope has no memories yet.
+     *
+     * @generated from field: repeated string agent_ids = 1;
+     */
+    agentIds: string[];
+};
+/**
+ * Describes the message memoir.v1.ListAgentsResponse.
+ * Use `create(ListAgentsResponseSchema)` to create a new message.
+ */
+export declare const ListAgentsResponseSchema: GenMessage<ListAgentsResponse>;
+/**
+ * One supersede or unsupersede decision against a memory. Mirrors memoir-
+ * core's `SupersessionEvent`. Distinct from `Supersession` (current marker,
+ * non-null winner): `winner_pid` here is optional because unsupersede events
+ * carry no winner.
+ *
+ * @generated from message memoir.v1.SupersessionEvent
+ */
+export type SupersessionEvent = Message<"memoir.v1.SupersessionEvent"> & {
+    /**
+     * @generated from field: optional string winner_pid = 1;
+     */
+    winnerPid?: string;
+    /**
+     * @generated from field: google.protobuf.Timestamp decided_at = 2;
+     */
+    decidedAt?: Timestamp;
+};
+/**
+ * Describes the message memoir.v1.SupersessionEvent.
+ * Use `create(SupersessionEventSchema)` to create a new message.
+ */
+export declare const SupersessionEventSchema: GenMessage<SupersessionEvent>;
+/**
+ * @generated from enum memoir.v1.MemoryStatus
+ */
+export declare enum MemoryStatus {
+    /**
+     * @generated from enum value: MEMORY_STATUS_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * Written, not yet processed by the worker.
+     *
+     * @generated from enum value: MEMORY_STATUS_PENDING = 1;
+     */
+    PENDING = 1,
+    /**
+     * Extraction + embedding + graph update done.
+     *
+     * @generated from enum value: MEMORY_STATUS_PROCESSED = 2;
+     */
+    PROCESSED = 2,
+    /**
+     * Processing failed after max retries. See admin "failed writes" view.
+     *
+     * @generated from enum value: MEMORY_STATUS_FAILED = 3;
+     */
+    FAILED = 3
+}
+/**
+ * Describes the enum memoir.v1.MemoryStatus.
+ */
+export declare const MemoryStatusSchema: GenEnum<MemoryStatus>;
+/**
+ * @generated from enum memoir.v1.MemoryKind
+ */
+export declare enum MemoryKind {
+    /**
+     * @generated from enum value: MEMORY_KIND_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * Raw utterance written via Remember.
+     *
+     * @generated from enum value: MEMORY_KIND_EPISODIC = 1;
+     */
+    EPISODIC = 1,
+    /**
+     * Fact derived from an episodic source by extraction.
+     *
+     * @generated from enum value: MEMORY_KIND_SEMANTIC = 2;
+     */
+    SEMANTIC = 2
+}
+/**
+ * Describes the enum memoir.v1.MemoryKind.
+ */
+export declare const MemoryKindSchema: GenEnum<MemoryKind>;
+/**
+ * MemoryService is the canonical read/write surface for processed memories.
+ *
+ * v0.1: handlers return Unimplemented. The proto is defined now to lock in
+ * the SDK surface so consumers can integrate against stable types.
+ * The memory epic implements real handlers.
+ *
+ * @generated from service memoir.v1.MemoryService
+ */
+export declare const MemoryService: GenService<{
+    /**
+     * Semantic retrieval within a scope. Vector + optional graph traversal,
+     * no LLM call. Hot path — designed to add minimal latency to agent loops.
+     *
+     * @generated from rpc memoir.v1.MemoryService.Search
+     */
+    search: {
+        methodKind: "unary";
+        input: typeof SearchRequestSchema;
+        output: typeof SearchResponseSchema;
+    };
+    /**
+     * Direct lookup by memory pid. Bypasses vector search.
+     *
+     * @generated from rpc memoir.v1.MemoryService.Recall
+     */
+    recall: {
+        methodKind: "unary";
+        input: typeof RecallRequestSchema;
+        output: typeof RecallResponseSchema;
+    };
+    /**
+     * Write a memory. Returns immediately after persisting raw content;
+     * extraction / embedding / contradiction detection happen asynchronously.
+     *
+     * @generated from rpc memoir.v1.MemoryService.Remember
+     */
+    remember: {
+        methodKind: "unary";
+        input: typeof RememberRequestSchema;
+        output: typeof RememberResponseSchema;
+    };
+    /**
+     * Soft- or hard-delete a memory or a scope's worth of memories.
+     *
+     * @generated from rpc memoir.v1.MemoryService.Forget
+     */
+    forget: {
+        methodKind: "unary";
+        input: typeof ForgetRequestSchema;
+        output: typeof ForgetResponseSchema;
+    };
+    /**
+     * Chronological event-log read within a scope. Postgres-only — no vector
+     * search, no LLM. Includes superseded rows by default (audit view).
+     * Newest-first unless `ascending` is set. Wraps memoir-core's
+     * `Client::timeline`.
+     *
+     * @generated from rpc memoir.v1.MemoryService.Timeline
+     */
+    timeline: {
+        methodKind: "unary";
+        input: typeof TimelineRequestSchema;
+        output: typeof TimelineResponseSchema;
+    };
+    /**
+     * Point-in-time read: memoir's state of knowledge as of a timestamp.
+     * Returns memories created on or before `as_of` that were not yet
+     * superseded then. Postgres-only. Wraps memoir-core's
+     * `Client::recall_as_of`.
+     *
+     * @generated from rpc memoir.v1.MemoryService.RecallAsOf
+     */
+    recallAsOf: {
+        methodKind: "unary";
+        input: typeof RecallAsOfRequestSchema;
+        output: typeof RecallAsOfResponseSchema;
+    };
+    /**
+     * Hybrid-ranked retrieval: vector candidates re-ranked by a blend of
+     * cosine similarity and recency, returning prompt-shaped context. Wraps
+     * memoir-core's `Client::query`. The response carries raw memories +
+     * their hybrid score + the strategy used; rendering to a prompt string
+     * is the SDK's job, not the wire's.
+     *
+     * @generated from rpc memoir.v1.MemoryService.Query
+     */
+    query: {
+        methodKind: "unary";
+        input: typeof QueryRequestSchema;
+        output: typeof QueryResponseSchema;
+    };
+    /**
+     * In-place correction of an existing memory — distinct from supersession
+     * (edit overwrites because the original was wrong; supersede preserves
+     * because new info obsoletes old). Content changes trigger re-embedding,
+     * so the row is briefly unsearchable. Wraps memoir-core's `Client::edit`.
+     *
+     * @generated from rpc memoir.v1.MemoryService.Edit
+     */
+    edit: {
+        methodKind: "unary";
+        input: typeof EditRequestSchema;
+        output: typeof EditResponseSchema;
+    };
+    /**
+     * Corrects a wrong extraction by teaching, not editing. The pid is the
+     * wrong *semantic* memory the user saw; memoir retires its derived rows
+     * and re-derives from the episodic source with the correction in context.
+     * Fire-and-forget: returns once the reprocess is enqueued. To correct the
+     * episodic record itself, use Edit. Wraps memoir-core's `Client::feedback`.
+     *
+     * @generated from rpc memoir.v1.MemoryService.Feedback
+     */
+    feedback: {
+        methodKind: "unary";
+        input: typeof FeedbackRequestSchema;
+        output: typeof FeedbackResponseSchema;
+    };
+    /**
+     * Returns every supersede/unsupersede decision against a memory in
+     * chronological order — the full audit trail behind a row's current
+     * `Memory.supersession` marker. A pid with no events (never superseded
+     * or simply absent) returns an empty list. Wraps memoir-core's
+     * `Client::supersession_history`.
+     *
+     * @generated from rpc memoir.v1.MemoryService.SupersessionHistory
+     */
+    supersessionHistory: {
+        methodKind: "unary";
+        input: typeof SupersessionHistoryRequestSchema;
+        output: typeof SupersessionHistoryResponseSchema;
+    };
+    /**
+     * Lists the distinct agent ids that have memories under an org + user.
+     * Caller-scoped agent discovery for pickers/autocomplete — a tenant sees
+     * only their own agents. An empty org/user returns no agents. Wraps
+     * memoir-core's `Client::list_agents`.
+     *
+     * @generated from rpc memoir.v1.MemoryService.ListAgents
+     */
+    listAgents: {
+        methodKind: "unary";
+        input: typeof ListAgentsRequestSchema;
+        output: typeof ListAgentsResponseSchema;
+    };
+}>;
+//# sourceMappingURL=memory_pb.d.ts.map