/**
 * `defineMemory(...)` — the root memory declaration for a deployment.
 *
 * Memory is opt-in and this is its only owner. It is authoring-time config
 * construction plus eager validation, with no runtime dependency: the CLI
 * discovers the `memory` export from a root `memory.{ts,tsx,mts,cts}` and hands
 * the resolved config to the managed runtime.
 *
 * The declaration is configuration, not the memory itself — durable content
 * lives in managed Context Hub storage, so a deploy never overwrites what
 * earlier runs learned.
 */
import type { MemoryDefinition, MemoryOptions } from "./types.js";
/**
 * Declare durable memory for the deployment.
 *
 * The launch contract is one deployment-shared slice, mounted read/write at
 * `/memories/agent/` with `/memories/agent/AGENTS.md` loaded into every run:
 *
 * ```ts
 * export const memory = defineMemory({ scope: "agent" });
 * ```
 *
 * Every caller of the deployment shares that slice and can write to it, so it
 * holds procedural knowledge — never per-person facts or credentials.
 *
 * **The shared slice is a trust boundary.** Hot memory is injected into every
 * run, and ordinary runs can write it, so anything one caller persuades the agent
 * to save is read by every later caller — including instructions. On a
 * deployment reachable by people who should not influence each other, that is a
 * cross-caller channel: treat memory content as untrusted input, keep authority
 * (tool access, approvals) in the agent definition rather than in memory, and
 * prefer `"none"` when callers are mutually untrusted. A privileged-writer policy
 * that closes this is future work; the launch mount is read/write.
 *
 * Omit the file (or pass `"none"`) when the agent should keep no durable memory.
 */
export declare function defineMemory(options?: MemoryOptions): MemoryDefinition;
//# sourceMappingURL=define-memory.d.ts.map