@noopolis/mneme 0.1.0

package/dist/policy/policy.js

@@ -0,0 +1,123 @@
+import { canonicalPrincipalKey, canonicalScopeKey, sanitizePrincipalQualifier } from "../identity/ids.js";
+const isPairMatch = (request, source, candidateVisibility) => {
+    if (candidateVisibility !== "pair" && candidateVisibility !== "private") {
+        return false;
+    }
+    if (request.scope === "pair" && source.scope === "pair") {
+        return sanitizePrincipalQualifier(request.qualifier) === sanitizePrincipalQualifier(source.qualifier);
+    }
+    return request.agentId === source.agentId && request.qualifier !== undefined && source.qualifier !== undefined
+        ? request.qualifier.toLowerCase() === source.qualifier.toLowerCase()
+        : false;
+};
+const samePrincipal = (a, b) => a.agentId === b.agentId && a.scope === b.scope &&
+    sanitizePrincipalQualifier(a.qualifier) === sanitizePrincipalQualifier(b.qualifier);
+const roomMatch = (a, b) => a.scope === "room" && b.scope === "room" && a.agentId === b.agentId &&
+    sanitizePrincipalQualifier(a.qualifier) === sanitizePrincipalQualifier(b.qualifier);
+const teamMatch = (a, b) => a.scope === "team" && b.scope === "team" && a.agentId === b.agentId &&
+    sanitizePrincipalQualifier(a.qualifier) === sanitizePrincipalQualifier(b.qualifier);
+const roleMatch = (a, b) => a.scope === "role" && b.scope === "role" && a.agentId === b.agentId &&
+    sanitizePrincipalQualifier(a.qualifier) === sanitizePrincipalQualifier(b.qualifier);
+const eventScopeMatchesPrincipal = (candidate) => canonicalScopeKey(candidate.scope) === canonicalScopeKey(canonicalPrincipalKey(candidate.principal));
+const scopePriority = (request, candidate) => {
+    if (samePrincipal(request, candidate)) {
+        return 100;
+    }
+    if (roomMatch(request, candidate) || roleMatch(request, candidate)) {
+        return 80;
+    }
+    if (teamMatch(request, candidate)) {
+        return 70;
+    }
+    if (request.scope === "pair" && candidate.scope === "pair") {
+        return 90;
+    }
+    return 40;
+};
+export const memoryPolicy = ({ request, candidate }) => {
+    const visible = candidate.visibility;
+    const sensitive = candidate.sensitivity;
+    if (visible === "sealed") {
+        return {
+            decision: "deny",
+            reason: "sealed content"
+        };
+    }
+    if (samePrincipal(request, candidate.principal)) {
+        return {
+            decision: "allow_raw",
+            reason: "same principal"
+        };
+    }
+    if (visible === "private") {
+        return isPairMatch(request, candidate.principal, visible)
+            ? {
+                decision: "allow_raw",
+                reason: "pair requester context"
+            }
+            : {
+                decision: "known_but_private",
+                reason: "private visibility"
+            };
+    }
+    if (visible === "pair") {
+        return isPairMatch(request, candidate.principal, visible)
+            ? {
+                decision: sensitive === "secret" ? "allow_summary" : "allow_raw",
+                reason: "pair scope match"
+            }
+            : {
+                decision: "known_but_private",
+                reason: "pair visibility mismatch"
+            };
+    }
+    if (visible === "team" &&
+        candidate.principal.scope === "team" &&
+        request.agentId === candidate.principal.agentId &&
+        eventScopeMatchesPrincipal(candidate)) {
+        if (sensitive === "secret") {
+            return {
+                decision: "allow_summary",
+                reason: "team scope match with sensitive visibility"
+            };
+        }
+        return {
+            decision: "allow_summary",
+            reason: "team scope match"
+        };
+    }
+    if (visible === "room" &&
+        candidate.principal.scope === "room" &&
+        request.agentId === candidate.principal.agentId &&
+        eventScopeMatchesPrincipal(candidate)) {
+        if (sensitive === "secret") {
+            return {
+                decision: "allow_redacted_summary",
+                reason: "room scope match with secret visibility"
+            };
+        }
+        return {
+            decision: "allow_summary",
+            reason: "room scope match"
+        };
+    }
+    if (visible === "global" && candidate.principal.scope === "global") {
+        return {
+            decision: "allow_summary",
+            reason: "global visibility"
+        };
+    }
+    if (visible === "public") {
+        return {
+            decision: "allow_summary",
+            reason: "public visibility"
+        };
+    }
+    return {
+        decision: "deny",
+        reason: "scope mismatch"
+    };
+};
+export const memoryPriority = (request, candidate) => scopePriority(request, candidate);
+export const shouldRecordDecisionEvent = (decision) => decision !== "allow_summary" && decision !== "allow_raw";
+export const principalKey = canonicalPrincipalKey;

package/dist/recall/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./recall.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/recall/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/recall/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/recall/index.js

@@ -0,0 +1 @@
+export * from "./recall.js";

package/dist/recall/recall.d.ts

@@ -0,0 +1,28 @@
+import type { MemoryEvent, MemoryPrincipalRef, MemoryRecallAudit, MemoryDecision, WakeMemoryContext, MemoryPacket } from "../contract/types.js";
+export interface RecallInput {
+    actor: MemoryPrincipalRef;
+    scopeIds: string[];
+    events: MemoryEvent[];
+    query: string;
+    maxTokens: number;
+}
+export interface RecallSelection {
+    packet: MemoryPacket;
+    audit: MemoryRecallAudit;
+    selected: Array<{
+        event: MemoryEvent;
+        decision: MemoryDecision;
+        representation: string;
+        scope: string;
+    }>;
+}
+export declare const rankCandidates: (input: RecallInput) => Array<{
+    event: MemoryEvent;
+    decision: MemoryDecision;
+    score: number;
+    representation: string;
+    scope: string;
+}>;
+export declare const runRecall: (input: RecallInput) => RecallSelection;
+export declare const buildWakePacketText: (context: WakeMemoryContext, wakeText: string, packet: MemoryPacket) => string;
+//# sourceMappingURL=recall.d.ts.map

package/dist/recall/recall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recall.d.ts","sourceRoot":"","sources":["../../src/recall/recall.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,WAAW,EACX,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,YAAY,EACb,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,kBAAkB,CAAC;IAC1B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,iBAAiB,CAAC;IACzB,QAAQ,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,WAAW,CAAC;QAAC,QAAQ,EAAE,cAAc,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC1G;AAuDD,eAAO,MAAM,cAAc,GAAI,OAAO,WAAW,KAAG,KAAK,CAAC;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CA8D/J,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,OAAO,WAAW,KAAG,eAwD9C,CAAC;AAkBF,eAAO,MAAM,mBAAmB,GAAI,SAAS,iBAAiB,EAAE,UAAU,MAAM,EAAE,QAAQ,YAAY,KAAG,MAgBxG,CAAC"}

package/dist/recall/recall.js

@@ -0,0 +1,178 @@
+import { canonicalPrincipalKey } from "../identity/ids.js";
+import { memoryPriority, memoryPolicy } from "../policy/policy.js";
+const estimateTokens = (text) => Math.max(1, Math.ceil(text.length / 4));
+const textFromEvent = (event) => {
+    const fallback = JSON.stringify(event.content);
+    if (event.content.kind === "text") {
+        return event.content.text.trim();
+    }
+    if (event.content.kind === "decision") {
+        return `${event.content.decision}${event.content.rationale ? ` — ${event.content.rationale}` : ""}`;
+    }
+    if (event.content.kind === "artifact") {
+        return event.content.description;
+    }
+    if (event.content.kind === "relationship") {
+        return `${event.content.from} ${event.content.relation} ${event.content.to}`;
+    }
+    if (event.content.kind === "claim") {
+        return `${event.content.subject} ${event.content.predicate} ${event.content.object}`;
+    }
+    return fallback;
+};
+const buildRepresentation = (decision, event) => {
+    const base = textFromEvent(event);
+    if (decision === "allow_raw") {
+        return base;
+    }
+    if (decision === "allow_summary") {
+        const summary = base.slice(0, 140);
+        return summary.length < base.length ? `${summary}...` : summary;
+    }
+    if (decision === "allow_redacted_summary") {
+        return `[redacted] ${base.slice(0, 100)}...`;
+    }
+    if (decision === "known_but_private") {
+        return "Related private context is available behind policy.";
+    }
+    return "Memory was blocked by policy.";
+};
+const scoreEvent = (actor, candidateScope, event, queryText) => {
+    const text = textFromEvent(event).toLowerCase();
+    const overlap = queryText
+        .split(" ")
+        .map((value) => value.trim().toLowerCase())
+        .filter((value) => value.length > 2)
+        .reduce((total, token) => total + (text.includes(token) ? 2 : 0), 0);
+    const scopeScore = memoryPriority(actor, candidateScope ? { ...event.principal, scope: event.principal.scope } : event.principal);
+    const freshness = Date.parse(event.createdAt) / 1000_000;
+    return overlap + scopeScore + (freshness % 30_000) / 1000;
+};
+export const rankCandidates = (input) => {
+    const allowedScopeSet = new Set(input.scopeIds);
+    const query = input.query.toLowerCase();
+    const candidateRows = [];
+    for (const event of input.events) {
+        const policy = memoryPolicy({
+            request: input.actor,
+            activeScope: input.actor,
+            candidate: event
+        });
+        if (!allowedScopeSet.has(event.scope)) {
+            continue;
+        }
+        if (policy.decision === "deny") {
+            continue;
+        }
+        const representation = buildRepresentation(policy.decision, event);
+        candidateRows.push({
+            event,
+            decision: policy.decision,
+            scope: event.scope,
+            score: scoreEvent(input.actor, event.scope, event, query),
+            representation
+        });
+    }
+    return candidateRows
+        .sort((left, right) => {
+        const scoreDelta = right.score - left.score;
+        if (scoreDelta !== 0) {
+            return scoreDelta;
+        }
+        const timeDelta = Date.parse(right.event.createdAt) - Date.parse(left.event.createdAt);
+        if (timeDelta !== 0) {
+            return timeDelta;
+        }
+        const scopeDelta = left.scope.localeCompare(right.scope);
+        if (scopeDelta !== 0) {
+            return scopeDelta;
+        }
+        const idDelta = left.event.id.localeCompare(right.event.id);
+        if (idDelta !== 0) {
+            return idDelta;
+        }
+        return left.event.checksum.localeCompare(right.event.checksum);
+    })
+        .map((row) => ({
+        event: row.event,
+        decision: row.decision,
+        score: row.score,
+        representation: row.representation,
+        scope: row.scope
+    }));
+};
+export const runRecall = (input) => {
+    const candidates = rankCandidates(input);
+    const selected = [];
+    const auditDecisions = [];
+    let usedTokens = 0;
+    let redactions = 0;
+    for (const candidate of candidates) {
+        const tokens = estimateTokens(candidate.representation);
+        if (usedTokens + tokens > input.maxTokens && selected.length > 0) {
+            continue;
+        }
+        selected.push({
+            event: candidate.event,
+            decision: candidate.decision,
+            representation: candidate.representation,
+            scope: candidate.scope
+        });
+        usedTokens += tokens;
+        if (candidate.decision === "allow_redacted_summary" || candidate.decision === "known_but_private") {
+            redactions += 1;
+        }
+        auditDecisions.push({
+            eventId: candidate.event.id,
+            decision: candidate.decision,
+            reason: "policy + recall ranking"
+        });
+    }
+    return {
+        packet: {
+            principal: input.actor,
+            sections: selected.map((entry) => ({
+                heading: `${entry.scope}: ${entry.event.type}`,
+                text: entry.representation
+            })),
+            rawHint: queryHint(selected, input.actor, input.scopeIds)
+        },
+        selected,
+        audit: {
+            totalCandidates: candidates.length,
+            selectedEventIds: selected.map((entry) => entry.event.id),
+            selected: selected.map((entry) => ({
+                eventId: entry.event.id,
+                decision: entry.decision,
+                scope: entry.scope,
+                representation: entry.representation
+            })),
+            decisions: auditDecisions,
+            tokenBudgetUsed: usedTokens,
+            redactionCount: redactions
+        }
+    };
+};
+const queryHint = (selections, actor, scopeIds) => {
+    const pending = scopeIds.filter((scope) => !selections.some((selection) => selection.scope === scope));
+    if (pending.length > 0) {
+        return `Active memory principal ${canonicalPrincipalKey(actor)} has access to ${scopeIds.length} scopes. Missing active data in: ${pending.join(", ")}`;
+    }
+    return `Active memory principal ${canonicalPrincipalKey(actor)} has no known denials.`;
+};
+export const buildWakePacketText = (context, wakeText, packet) => {
+    const room = context.roomId ? `${context.networkId ?? "unknown"}/${context.roomId}` : "global";
+    const lines = [
+        "## Memory context",
+        `Agent: ${packet.principal.agentId}`,
+        `Active scope: ${packet.principal.scope}${packet.principal.qualifier ? ` (${packet.principal.qualifier})` : ""}`,
+        `Active room: ${room}`,
+        "",
+        ...packet.sections.map((section) => `- ${section.heading}\n${section.text}`),
+        packet.rawHint ? `\nHints: ${packet.rawHint}` : "",
+        "",
+        "Wake event:",
+        wakeText
+    ];
+    return lines.filter((line) => line.length > 0).join("\n\n");
+};

package/dist/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./runtime.js";
+export * from "./support.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC"}

package/dist/runtime/index.js

@@ -0,0 +1,2 @@
+export * from "./runtime.js";
+export * from "./support.js";

package/dist/runtime/runtime.d.ts

@@ -0,0 +1,19 @@
+import type { MemoryKernel, MemoryPrepareTurnResult, MemoryRecallRequest, MemoryRuntime, MemoryTurnRecord } from "../contract/types.js";
+export interface JsonlMemoryRuntimeConfig {
+    agentId: string;
+    runtimeHomePath: string;
+    source?: string;
+    tokenBudget?: number;
+}
+export declare class JsonlMemoryRuntime implements MemoryRuntime {
+    private readonly options;
+    private readonly store;
+    private readonly source;
+    private readonly defaultTokenBudget;
+    readonly kernel: MemoryKernel;
+    constructor(options: JsonlMemoryRuntimeConfig);
+    prepareTurn(request: MemoryRecallRequest): Promise<MemoryPrepareTurnResult>;
+    recordTurn(input: MemoryTurnRecord): Promise<void>;
+}
+export declare const createMemoryRuntime: (options: JsonlMemoryRuntimeConfig) => MemoryRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/runtime.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAEV,YAAY,EACZ,uBAAuB,EACvB,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAEjB,MAAM,sBAAsB,CAAC;AAY9B,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,kBAAmB,YAAW,aAAa;IAM1C,OAAO,CAAC,QAAQ,CAAC,OAAO;IALpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,SAAgB,MAAM,EAAE,YAAY,CAAC;gBAER,OAAO,EAAE,wBAAwB;IAUxD,WAAW,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAmE3E,UAAU,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;CAuCzD;AAED,eAAO,MAAM,mBAAmB,GAAI,SAAS,wBAAwB,KAAG,aACvC,CAAC"}

package/dist/runtime/runtime.js

@@ -0,0 +1,129 @@
+import { buildWakePacketText } from "../recall/recall.js";
+import { JsonlMemoryStore } from "../store/store.js";
+import { memoryScopeId } from "../identity/ids.js";
+import { readMemoryContext, resolveScopePlan } from "../identity/scope.js";
+import { createMemoryKernel } from "../kernel/kernel.js";
+import { buildDecisionEvents, buildRecallInput, clampTokenBudget, defaultSource, deniedMemoryEvents, normalizeScopeIds, readByScopes, recallableEvents, selectToolSummary } from "./support.js";
+const resolveContextFromRequest = (request) => {
+    return readMemoryContext({
+        kind: request.kind,
+        from: request.from,
+        text: request.text,
+        id: request.eventId,
+        context: request.context
+    });
+};
+export class JsonlMemoryRuntime {
+    options;
+    store;
+    source;
+    defaultTokenBudget;
+    kernel;
+    constructor(options) {
+        this.options = options;
+        this.store = new JsonlMemoryStore(options.runtimeHomePath);
+        this.source = options.source ?? defaultSource(options.agentId);
+        this.defaultTokenBudget = clampTokenBudget(options.tokenBudget);
+        this.kernel = createMemoryKernel({
+            runtimeHomePath: options.runtimeHomePath,
+            source: this.source
+        });
+    }
+    async prepareTurn(request) {
+        const context = resolveContextFromRequest(request);
+        const scopePlan = resolveScopePlan({
+            agentId: this.options.agentId,
+            context,
+            wake: {
+                id: request.eventId,
+                kind: request.kind,
+                from: request.from
+            }
+        });
+        const scopeIds = normalizeScopeIds(scopePlan.readableScopes.map(memoryScopeId));
+        const events = recallableEvents(await readByScopes(this.store, scopeIds));
+        const recall = buildRecallInput({
+            actor: scopePlan.activePrincipal,
+            scopeIds,
+            events,
+            text: request.text,
+            maxTokens: request.tokenBudget ?? this.defaultTokenBudget
+        });
+        const denied = deniedMemoryEvents({
+            requester: scopePlan.activePrincipal,
+            activeScope: scopePlan.activePrincipal,
+            events,
+            selectedIds: new Set(recall.audit.selectedEventIds)
+        });
+        if (denied.length > 0) {
+            await this.store.appendBatch(denied.map(({ event, reason }) => ({
+                type: "memory.denied",
+                principal: scopePlan.activePrincipal,
+                scope: memoryScopeId(scopePlan.activePrincipal),
+                visibility: "private",
+                source: this.source,
+                content: {
+                    kind: "text",
+                    text: `Denied ${event.id}: ${reason}`
+                },
+                tags: ["denied", "recall"],
+                entities: [event.id],
+                parentEventIds: [event.id],
+                sensitivity: "normal"
+            })));
+        }
+        const wakeText = [
+            "## Wake",
+            `id: ${request.eventId}`,
+            `kind: ${request.kind}`,
+            `from: ${request.from ?? "operator"}`,
+            `network: ${context.networkId ?? "global"}`,
+            `room: ${context.roomId ?? "global"}`,
+            "",
+            request.text
+        ].join("\n");
+        const promptText = buildWakePacketText(context, wakeText, recall.packet);
+        return {
+            principal: scopePlan.activePrincipal,
+            packet: recall.packet,
+            promptText,
+            recall: recall.audit
+        };
+    }
+    async recordTurn(input) {
+        const scope = memoryScopeId(input.principal);
+        const parentEventIds = (await this.store.read({
+            principalAgentId: input.principal.agentId,
+            principalScope: input.principal.scope
+        })).map((event) => event.id);
+        const recall = input.recall ?? {
+            totalCandidates: 0,
+            selectedEventIds: [],
+            selected: [],
+            decisions: [],
+            tokenBudgetUsed: 0,
+            redactionCount: 0
+        };
+        const events = buildDecisionEvents({
+            principal: input.principal,
+            scope,
+            source: this.source,
+            request: input.request,
+            packet: input.prompt,
+            recall,
+            result: input.result,
+            outputText: input.outputText,
+            error: input.error,
+            parentEventIds
+        });
+        const toolSummary = selectToolSummary(input.toolEvents ?? []);
+        if (toolSummary) {
+            toolSummary.parentEventIds = parentEventIds;
+            toolSummary.scope = scope;
+            toolSummary.principal = input.principal;
+            events.push(toolSummary);
+        }
+        await this.store.appendBatch(events);
+    }
+}
+export const createMemoryRuntime = (options) => new JsonlMemoryRuntime(options);

package/dist/runtime/support.d.ts

@@ -0,0 +1,52 @@
+import { runRecall } from "../recall/recall.js";
+import { JsonlMemoryStore } from "../store/store.js";
+import type { MemoryDecision, MemoryEvent, MemoryEventInput, MemoryPacket, MemoryPrincipalRef, MemoryRecallAudit, MemoryRecallRequest, MemoryTurnRecord } from "../contract/types.js";
+export interface MemoryRecallEntry {
+    event: MemoryEvent;
+    decision: MemoryDecision;
+    representation: string;
+    scope: string;
+}
+export declare const defaultSource: (agentId: string) => string;
+export declare const clampTokenBudget: (value: number | undefined) => number;
+export declare const normalizeScopeIds: (ids: string[]) => string[];
+export declare const readByScopes: (store: JsonlMemoryStore, scopeIds: string[]) => Promise<MemoryEvent[]>;
+export declare const recallableEvents: (events: MemoryEvent[]) => MemoryEvent[];
+export declare const deniedMemoryEvents: (input: {
+    requester: MemoryPrincipalRef;
+    activeScope: MemoryPrincipalRef;
+    events: MemoryEvent[];
+    selectedIds: Set<string>;
+}) => Array<{
+    event: MemoryEvent;
+    reason: string;
+}>;
+export declare const buildRecallInput: (input: {
+    actor: MemoryPrincipalRef;
+    scopeIds: string[];
+    events: MemoryEvent[];
+    text: string;
+    maxTokens?: number;
+}) => ReturnType<typeof runRecall>;
+export declare const buildDecisionEvents: (input: {
+    principal: MemoryPrincipalRef;
+    scope: string;
+    source: string;
+    request: MemoryRecallRequest;
+    packet: MemoryPacket;
+    recall: MemoryRecallAudit;
+    result: MemoryTurnRecord["result"];
+    outputText: string;
+    error?: string;
+    parentEventIds: string[];
+}) => MemoryEventInput[];
+export declare const selectToolSummary: (toolEvents: unknown[]) => MemoryEventInput | undefined;
+export declare const runMemorySelection: (input: {
+    requester: MemoryPrincipalRef;
+    scopeIds: string[];
+    events: MemoryEvent[];
+    query: string;
+    maxResults?: number;
+}) => MemoryRecallEntry[];
+export { runRecall };
+//# sourceMappingURL=support.d.ts.map

package/dist/runtime/support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"support.d.ts","sourceRoot":"","sources":["../../src/runtime/support.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EACX,gBAAgB,EAChB,YAAY,EAEZ,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAEjB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,cAAc,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf;AAKD,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,KAAG,MAA6C,CAAC;AAE9F,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,GAAG,SAAS,KAAG,MAK5D,CAAC;AAOF,eAAO,MAAM,iBAAiB,GAAI,KAAK,MAAM,EAAE,KAAG,MAAM,EAEvD,CAAC;AAWF,eAAO,MAAM,YAAY,GACvB,OAAO,gBAAgB,EACvB,UAAU,MAAM,EAAE,KACjB,OAAO,CAAC,WAAW,EAAE,CAcvB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,QAAQ,WAAW,EAAE,KAAG,WAAW,EAanE,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,OAAO;IACxC,SAAS,EAAE,kBAAkB,CAAC;IAC9B,WAAW,EAAE,kBAAkB,CAAC;IAChC,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC1B,KAAG,KAAK,CAAC;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAa5C,CAAC;AAEL,eAAO,MAAM,gBAAgB,GAAI,OAAO;IACtC,KAAK,EAAE,kBAAkB,CAAC;IAC1B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,KAAG,UAAU,CAAC,OAAO,SAAS,CAQ9B,CAAC;AAiEF,eAAO,MAAM,mBAAmB,GAAI,OAAO;IACzC,SAAS,EAAE,kBAAkB,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,mBAAmB,CAAC;IAC7B,MAAM,EAAE,YAAY,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,KAAG,gBAAgB,EAqFnB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,YAAY,OAAO,EAAE,KAAG,gBAAgB,GAAG,SAsB5E,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,OAAO;IACxC,SAAS,EAAE,kBAAkB,CAAC;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,KAAG,iBAAiB,EAgBpB,CAAC;AAEF,OAAO,EAAE,SAAS,EAAE,CAAC"}