spawnfile 0.1.12 → 0.1.14

package/dist/ledger/principal.js

@@ -0,0 +1,121 @@
+import { PRINCIPAL_GRAMMAR_SOURCE } from "@noopolis/stele";
+export { PRINCIPAL_GRAMMAR_SOURCE };
+/** Boolean grammar test built from the single source of truth, `PRINCIPAL_GRAMMAR_SOURCE`. */
+const PRINCIPAL_PATTERN = new RegExp(PRINCIPAL_GRAMMAR_SOURCE, "u");
+/**
+ * `system:moltnet.anonymous` is moltnet's stamped principal for the
+ * unauthenticated dev-mode case (no authn claims on the request context at
+ * all) — see `ecosystem/moltnet/internal/rooms/causal.go`. It is grammar-
+ * valid (a real `system:` principal) but conformance treats it as
+ * unauthenticated on purpose: it is a placeholder for "no principal",
+ * never a credential to attribute causal events to.
+ */
+export const ANONYMOUS_SYSTEM_PRINCIPAL = "system:moltnet.anonymous";
+/** The literal bare string some legacy/dev paths might stamp instead of a real principal. */
+const ANONYMOUS_LITERAL = "anonymous";
+/**
+ * Parses a `principal_id` string against the grammar. Returns a
+ * `PrincipalParseError` (never throws) for anything that does not match
+ * `^(agent|operator|system):.+` — a bare id with no prefix, an unknown
+ * prefix, or an empty string all land here.
+ */
+export const parsePrincipal = (value) => {
+    if (typeof value !== "string" || value.length === 0) {
+        return { message: "principal_id must be a non-empty string" };
+    }
+    if (!PRINCIPAL_PATTERN.test(value)) {
+        return {
+            message: `principal_id "${value}" does not match the <agent|operator|system>:<id> grammar (specs/CAUSAL.md §3)`
+        };
+    }
+    // PRINCIPAL_PATTERN already guarantees a `<kind>:<rest>` shape with a
+    // known kind prefix, so a plain split on the first colon is safe and
+    // avoids maintaining a second, capturing copy of the same pattern.
+    const separatorIndex = value.indexOf(":");
+    const kind = value.slice(0, separatorIndex);
+    const id = value.slice(separatorIndex + 1);
+    return { id, kind };
+};
+export const isPrincipalParseError = (value) => "message" in value;
+/**
+ * True only for a principal that is both grammar-valid and represents a
+ * real authenticated identity: grammar mismatches, a bare id, an empty
+ * trailing id, the literal `anonymous`, and `system:moltnet.anonymous`
+ * (moltnet's unauthenticated dev-mode placeholder) are all rejected.
+ * Conformance (`conformance.ts`) uses this as its per-event grammar check.
+ */
+export const isAuthenticatedPrincipal = (value) => {
+    if (typeof value !== "string") {
+        return false;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0 || trimmed === ANONYMOUS_LITERAL || trimmed === ANONYMOUS_SYSTEM_PRINCIPAL) {
+        return false;
+    }
+    const parsed = parsePrincipal(trimmed);
+    if (isPrincipalParseError(parsed)) {
+        return false;
+    }
+    return parsed.id.trim().length > 0;
+};
+/** `type`s whose `principal_id` must exactly equal `emitter.stream_id` (a daimon `agent:<id>` stream). */
+const AGENT_STREAM_TURN_EVENT_TYPES = new Set(["turn.input.submitted", "turn.output.completed"]);
+/**
+ * Principal-grammar check (specs/CAUSAL.md §3, B62 enforcement point #4a):
+ * every event's `principal_id` must be an authenticated `agent:`/`operator:`/
+ * `system:` principal — never a bare id, the literal `anonymous`, or
+ * moltnet's `system:moltnet.anonymous` unauthenticated placeholder.
+ */
+export const checkPrincipalGrammar = (event, sourceName) => {
+    if (isAuthenticatedPrincipal(event.principal_id)) {
+        return [];
+    }
+    return [
+        {
+            message: `event ${event.event_id} has principal_id "${event.principal_id}", which is not an authenticated ` +
+                `agent:/operator:/system: principal (specs/CAUSAL.md §3)`,
+            source: sourceName
+        }
+    ];
+};
+/**
+ * Stream/principal consistency check (B62 enforcement point #4b): for
+ * daimon's turn events, `principal_id` must exactly equal `emitter.stream_id`
+ * — the agent whose stream this is must be the agent this event is
+ * attributed to. This deliberately does NOT apply to daimon's control-wake
+ * events (`control.wake.accepted`/`control.wake.denied`), whose stream is
+ * the *target* agent being woken but whose principal is the *operator* who
+ * requested the wake — an intentional mismatch, not a violation.
+ */
+export const checkStreamPrincipalConsistency = (event, sourceName) => {
+    if (event.emitter.system !== "daimon" || !AGENT_STREAM_TURN_EVENT_TYPES.has(event.type)) {
+        return [];
+    }
+    if (!event.emitter.stream_id.startsWith("agent:") || event.principal_id === event.emitter.stream_id) {
+        return [];
+    }
+    return [
+        {
+            message: `event ${event.event_id} is on stream ${event.emitter.stream_id} but has principal_id ` +
+                `"${event.principal_id}" — daimon turn events must be attributed to the agent that owns their stream`,
+            source: sourceName
+        }
+    ];
+};
+/**
+ * Per-event checks `conformance.ts`'s `runSyntheticConformance` AND (as of
+ * the B62 fix) `runRealConformance` both layer on top of schema parsing +
+ * payload minimums, via `validateConformanceSources`'s `extraChecks`
+ * parameter. Wiring this into `runRealConformance` is what gives the real
+ * `npm run test:causal-conformance` path teeth: without it, a real sibling
+ * emitter stamping a non-grammar `principal_id` would pass conformance
+ * silently (the schema-level `PRINCIPAL_GRAMMAR_SOURCE` regex in
+ * `envelope.ts` already rejects most malformed principals at parse time, but
+ * `checkStreamPrincipalConsistency` in particular is conformance-only — it
+ * has no envelope-schema equivalent). `realConformance.test.ts`'s hand-
+ * authored fixtures are kept grammar-compliant for exactly this reason.
+ */
+export const PRINCIPAL_DISCIPLINE_CHECKS = [
+    checkPrincipalGrammar,
+    checkStreamPrincipalConsistency
+];

package/dist/manifest/externalParticipantSchemas.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const externalParticipantServiceSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"service">;
+    surfaces: z.ZodObject<{
+        moltnet: z.ZodArray<z.ZodObject<{
+            network: z.ZodString;
+            auth: z.ZodObject<{
+                token_id: z.ZodString;
+            }, z.core.$strict>;
+            dms: z.ZodObject<{
+                enabled: z.ZodLiteral<true>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ExternalParticipantService = z.infer<typeof externalParticipantServiceSchema>;
+export type ExternalParticipantMoltnetAttachment = ExternalParticipantService["surfaces"]["moltnet"][number];

package/dist/manifest/externalParticipantSchemas.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+const segment = z.string().regex(/^[a-z][a-z0-9-]{0,62}$/u);
+const attachmentSchema = z.object({
+    network: segment,
+    auth: z.object({ token_id: segment }).strict(),
+    dms: z.object({ enabled: z.literal(true) }).strict()
+}).strict();
+export const externalParticipantServiceSchema = z.object({
+    id: segment,
+    kind: z.literal("service"),
+    surfaces: z.object({ moltnet: z.array(attachmentSchema).min(1).max(16) }).strict()
+}).strict().superRefine((value, context) => {
+    const networks = value.surfaces.moltnet.map((entry) => entry.network);
+    if (new Set(networks).size !== networks.length) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "external participant networks must be unique" });
+    }
+});

package/dist/manifest/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./inlineAgentMember.js";
 export * from "./loadManifest.js";
 export * from "./renderSpawnfile.js";
 export * from "./scaffold.js";

package/dist/manifest/index.js

@@ -1,3 +1,4 @@
+export * from "./inlineAgentMember.js";
 export * from "./loadManifest.js";
 export * from "./renderSpawnfile.js";
 export * from "./scaffold.js";

package/dist/manifest/inlineAgentMember.d.ts

@@ -0,0 +1,2 @@
+import type { AgentManifest, InlineAgentMember, TeamManifest } from "./schemas.js";
+export declare const materializeInlineAgentManifest: (team: TeamManifest, member: InlineAgentMember) => AgentManifest;

package/dist/manifest/inlineAgentMember.js

@@ -0,0 +1,9 @@
+export const materializeInlineAgentManifest = (team, member) => {
+    const { id, ...agentFields } = member;
+    return {
+        spawnfile_version: team.spawnfile_version,
+        kind: "agent",
+        name: id,
+        ...agentFields
+    };
+};

package/dist/manifest/loadManifest.js

@@ -3,7 +3,7 @@ import { parse as parseYaml } from "yaml";
 import { z } from "zod";
 import { fileExists, isSymlink, readUtf8File, resolveProjectPath } from "../filesystem/index.js";
 import { SpawnfileError } from "../shared/index.js";
-import { isAgentManifest, isTeamManifest, manifestSchema } from "./schemas.js";
+import { isAgentManifest, isInlineAgentMember, isReferencedMember, isTeamManifest, manifestSchema } from "./schemas.js";
 import { parseSkillFrontmatter } from "./skillFrontmatter.js";
 const ensureUniqueNames = (names, label) => {
     const seen = new Set();
@@ -84,16 +84,19 @@ const validateSkills = async (manifestPath, skills) => {
         parseSkillFrontmatter(await readUtf8File(skillFilePath));
     }));
 };
-const validateLocalAgentManifest = async (manifestPath, manifest) => {
-    const agentWorkspaceSkills = manifest.workspace?.skills;
-    const agentEnvironment = manifest.environment;
+const validateLocalAgentConfiguration = async (manifestPath, agent) => {
+    const agentWorkspaceSkills = agent.workspace?.skills;
+    const agentEnvironment = agent.environment;
     ensureUniqueNames((agentEnvironment?.mcp_servers ?? []).map((server) => server.name), "MCP server");
-    ensureUniqueNames((manifest.subagents ?? []).map((subagent) => subagent.id), "subagent id");
-    await validateDocFiles(manifestPath, manifest.workspace?.docs);
+    await validateDocFiles(manifestPath, agent.workspace?.docs);
     await validateSkills(manifestPath, agentWorkspaceSkills);
-    await validateManifestRefs(manifestPath, manifest.subagents?.map((subagent) => subagent.ref), "Subagent");
     validateSkillRequirements(agentWorkspaceSkills, getMcpNames(agentEnvironment?.mcp_servers));
 };
+const validateLocalAgentManifest = async (manifestPath, manifest) => {
+    ensureUniqueNames((manifest.subagents ?? []).map((subagent) => subagent.id), "subagent id");
+    await validateLocalAgentConfiguration(manifestPath, manifest);
+    await validateManifestRefs(manifestPath, manifest.subagents?.map((subagent) => subagent.ref), "Subagent");
+};
 const getSharedMcpNames = (shared) => getMcpNames(shared?.environment?.mcp_servers);
 const validateLocalTeamManifest = async (manifestPath, manifest) => {
     const sharedWorkspace = manifest.shared?.workspace;
@@ -102,7 +105,10 @@ const validateLocalTeamManifest = async (manifestPath, manifest) => {
     ensureUniqueNames(manifest.members.map((member) => member.id), "member id");
     await validateDocFiles(manifestPath, sharedWorkspace?.docs);
     await validateSkills(manifestPath, sharedWorkspace?.skills);
-    await validateManifestRefs(manifestPath, manifest.members.map((member) => member.ref), "Member");
+    await validateManifestRefs(manifestPath, manifest.members.filter(isReferencedMember).map((member) => member.ref), "Member");
+    await Promise.all(manifest.members
+        .filter(isInlineAgentMember)
+        .map((member) => validateLocalAgentConfiguration(manifestPath, member)));
     validateSkillRequirements(sharedWorkspace?.skills, getSharedMcpNames(manifest.shared));
     const memberIds = new Set(manifest.members.map((member) => member.id));
     if (manifest.lead && !memberIds.has(manifest.lead)) {

package/dist/manifest/mcpSchemas.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare const mcpServerSchema: z.ZodObject<{
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    auth: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodLiteral<"bearer">>;
+        secret: z.ZodString;
+    }, z.core.$strict>>;
+    command: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    name: z.ZodString;
+    transport: z.ZodEnum<{
+        sse: "sse";
+        stdio: "stdio";
+        streamable_http: "streamable_http";
+    }>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;

package/dist/manifest/mcpSchemas.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+const mcpAuthSchema = z
+    .object({
+    mode: z.literal("bearer").optional(),
+    secret: z.string()
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.mode === "bearer" && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(value.secret)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["secret"],
+            message: "bearer auth.secret must be a valid shell environment-variable name"
+        });
+    }
+});
+export const mcpServerSchema = z
+    .object({
+    args: z.array(z.string()).optional(),
+    auth: mcpAuthSchema.optional(),
+    command: z.string().optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    name: z.string().min(1),
+    transport: z.enum(["sse", "stdio", "streamable_http"]),
+    url: z.string().optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.name.startsWith("spawnfile.") || value.name.startsWith("mneme-")) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "MCP server name is reserved for compiler-owned generated services" });
+    }
+    if (value.transport === "stdio" && !value.command) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "stdio MCP servers must declare command" });
+    }
+    if (value.transport === "stdio" && value.auth?.mode === "bearer") {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "stdio MCP servers do not support bearer auth" });
+    }
+    if (value.transport !== "stdio" && !value.url) {
+        context.addIssue({ code: z.ZodIssueCode.custom, message: `${value.transport} MCP servers must declare url` });
+    }
+});

package/dist/manifest/memorySchemas.d.ts

@@ -0,0 +1,245 @@
+import { z } from "zod";
+export declare const memoryStoreSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"sqlite">;
+    path: z.ZodOptional<z.ZodString>;
+    persistence: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            durable: "durable";
+            ephemeral: "ephemeral";
+        }>;
+        mount: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"json">;
+    path: z.ZodOptional<z.ZodString>;
+    persistence: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            durable: "durable";
+            ephemeral: "ephemeral";
+        }>;
+        mount: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"postgres">;
+    dsn_secret: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"memory">;
+}, z.core.$strict>], "kind">;
+declare const memoryIndexSchema: z.ZodObject<{
+    graph: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            entity_graph: "entity_graph";
+            temporal_kg: "temporal_kg";
+        }>>;
+    }, z.core.$strict>>;
+    lexical: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        engine: z.ZodOptional<z.ZodEnum<{
+            sqlite_fts: "sqlite_fts";
+            bm25: "bm25";
+        }>>;
+    }, z.core.$strict>>;
+    rerank: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$strict>>;
+    vector: z.ZodOptional<z.ZodObject<{
+        base_url: z.ZodOptional<z.ZodString>;
+        dimensions: z.ZodOptional<z.ZodNumber>;
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        model: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodEnum<{
+            ollama: "ollama";
+        }>>;
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const memoryConsolidationSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        disabled: "disabled";
+        on_threshold: "on_threshold";
+        scheduled: "scheduled";
+    }>>>;
+    schedule: z.ZodOptional<z.ZodString>;
+    summarize_after_events: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare const memoryRetentionSchema: z.ZodObject<{
+    forgetting: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        manual: "manual";
+        decay: "decay";
+        ttl: "ttl";
+    }>>>;
+    ttl: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const memoryAccessSchema: z.ZodObject<{
+    members: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const memoryBankSchema: z.ZodObject<{
+    access: z.ZodOptional<z.ZodObject<{
+        members: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    consolidation: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            disabled: "disabled";
+            on_threshold: "on_threshold";
+            scheduled: "scheduled";
+        }>>>;
+        schedule: z.ZodOptional<z.ZodString>;
+        summarize_after_events: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    index: z.ZodOptional<z.ZodObject<{
+        graph: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                entity_graph: "entity_graph";
+                temporal_kg: "temporal_kg";
+            }>>;
+        }, z.core.$strict>>;
+        lexical: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            engine: z.ZodOptional<z.ZodEnum<{
+                sqlite_fts: "sqlite_fts";
+                bm25: "bm25";
+            }>>;
+        }, z.core.$strict>>;
+        rerank: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strict>>;
+        vector: z.ZodOptional<z.ZodObject<{
+            base_url: z.ZodOptional<z.ZodString>;
+            dimensions: z.ZodOptional<z.ZodNumber>;
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            model: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodEnum<{
+                ollama: "ollama";
+            }>>;
+            timeout_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    retention: z.ZodOptional<z.ZodObject<{
+        forgetting: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            manual: "manual";
+            decay: "decay";
+            ttl: "ttl";
+        }>>>;
+        ttl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    store: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"sqlite">;
+        path: z.ZodOptional<z.ZodString>;
+        persistence: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                durable: "durable";
+                ephemeral: "ephemeral";
+            }>;
+            mount: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"json">;
+        path: z.ZodOptional<z.ZodString>;
+        persistence: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                durable: "durable";
+                ephemeral: "ephemeral";
+            }>;
+            mount: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"postgres">;
+        dsn_secret: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"memory">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export declare const memoryBanksSchema: z.ZodArray<z.ZodObject<{
+    access: z.ZodOptional<z.ZodObject<{
+        members: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    consolidation: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            disabled: "disabled";
+            on_threshold: "on_threshold";
+            scheduled: "scheduled";
+        }>>>;
+        schedule: z.ZodOptional<z.ZodString>;
+        summarize_after_events: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    index: z.ZodOptional<z.ZodObject<{
+        graph: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                entity_graph: "entity_graph";
+                temporal_kg: "temporal_kg";
+            }>>;
+        }, z.core.$strict>>;
+        lexical: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            engine: z.ZodOptional<z.ZodEnum<{
+                sqlite_fts: "sqlite_fts";
+                bm25: "bm25";
+            }>>;
+        }, z.core.$strict>>;
+        rerank: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strict>>;
+        vector: z.ZodOptional<z.ZodObject<{
+            base_url: z.ZodOptional<z.ZodString>;
+            dimensions: z.ZodOptional<z.ZodNumber>;
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            model: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodEnum<{
+                ollama: "ollama";
+            }>>;
+            timeout_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    retention: z.ZodOptional<z.ZodObject<{
+        forgetting: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            manual: "manual";
+            decay: "decay";
+            ttl: "ttl";
+        }>>>;
+        ttl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    store: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"sqlite">;
+        path: z.ZodOptional<z.ZodString>;
+        persistence: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                durable: "durable";
+                ephemeral: "ephemeral";
+            }>;
+            mount: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"json">;
+        path: z.ZodOptional<z.ZodString>;
+        persistence: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                durable: "durable";
+                ephemeral: "ephemeral";
+            }>;
+            mount: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"postgres">;
+        dsn_secret: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"memory">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>>;
+export type MemoryAccess = z.infer<typeof memoryAccessSchema>;
+export type MemoryBank = z.infer<typeof memoryBankSchema>;
+export type MemoryConsolidation = z.infer<typeof memoryConsolidationSchema>;
+export type MemoryIndex = z.infer<typeof memoryIndexSchema>;
+export type MemoryRetention = z.infer<typeof memoryRetentionSchema>;
+export type MemoryStore = z.infer<typeof memoryStoreSchema>;
+export {};