audrey 1.0.1 → 1.0.3

package/dist/mcp-server/tool-schemas.d.ts

@@ -0,0 +1,341 @@
+/**
+ * Zod tool-input schemas for the MCP memory tools. These are pure schema
+ * declarations consumed by the MCP server registration in index.ts and
+ * re-exported from there for tests and embedders.
+ */
+import { z } from 'zod';
+export declare const memoryEncodeToolSchema: {
+    content: z.ZodString;
+    source: z.ZodEnum<{
+        "direct-observation": "direct-observation";
+        "told-by-user": "told-by-user";
+        "tool-result": "tool-result";
+        inference: "inference";
+        "model-generated": "model-generated";
+    }>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    salience: z.ZodOptional<z.ZodNumber>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    affect: z.ZodOptional<z.ZodObject<{
+        valence: z.ZodNumber;
+        arousal: z.ZodOptional<z.ZodNumber>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    private: z.ZodOptional<z.ZodBoolean>;
+    wait_for_consolidation: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const memoryRecallToolSchema: {
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        episodic: "episodic";
+        semantic: "semantic";
+        procedural: "procedural";
+    }>>>;
+    min_confidence: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sources: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "direct-observation": "direct-observation";
+        "told-by-user": "told-by-user";
+        "tool-result": "tool-result";
+        inference: "inference";
+        "model-generated": "model-generated";
+    }>>>;
+    after: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    mood: z.ZodOptional<z.ZodObject<{
+        valence: z.ZodNumber;
+        arousal: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    retrieval: z.ZodOptional<z.ZodEnum<{
+        vector: "vector";
+        hybrid: "hybrid";
+    }>>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        shared: "shared";
+        agent: "agent";
+    }>>;
+};
+export declare const memoryImportToolSchema: {
+    snapshot: z.ZodObject<{
+        version: z.ZodString;
+        exportedAt: z.ZodOptional<z.ZodString>;
+        episodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            source: z.ZodEnum<{
+                "direct-observation": "direct-observation";
+                "told-by-user": "told-by-user";
+                "tool-result": "tool-result";
+                inference: "inference";
+                "model-generated": "model-generated";
+            }>;
+            agent: z.ZodOptional<z.ZodString>;
+            source_reliability: z.ZodOptional<z.ZodNumber>;
+            salience: z.ZodOptional<z.ZodNumber>;
+            context: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            affect: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            tags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            causal_trigger: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            causal_consequence: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            created_at: z.ZodString;
+            embedding_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            embedding_version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            supersedes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            superseded_by: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            consolidated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+            private: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+        }, z.core.$strip>>;
+        semantics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            agent: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                active: "active";
+                disputed: "disputed";
+                superseded: "superseded";
+                context_dependent: "context_dependent";
+                dormant: "dormant";
+                rolled_back: "rolled_back";
+            }>;
+            conditions: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            evidence_episode_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            evidence_count: z.ZodOptional<z.ZodNumber>;
+            supporting_count: z.ZodOptional<z.ZodNumber>;
+            contradicting_count: z.ZodOptional<z.ZodNumber>;
+            source_type_diversity: z.ZodOptional<z.ZodNumber>;
+            consolidation_checkpoint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            embedding_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            embedding_version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            consolidation_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            consolidation_prompt_hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            created_at: z.ZodString;
+            last_reinforced_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            retrieval_count: z.ZodOptional<z.ZodNumber>;
+            challenge_count: z.ZodOptional<z.ZodNumber>;
+            interference_count: z.ZodOptional<z.ZodNumber>;
+            salience: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        procedures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            agent: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                active: "active";
+                disputed: "disputed";
+                superseded: "superseded";
+                context_dependent: "context_dependent";
+                dormant: "dormant";
+                rolled_back: "rolled_back";
+            }>;
+            trigger_conditions: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            evidence_episode_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            success_count: z.ZodOptional<z.ZodNumber>;
+            failure_count: z.ZodOptional<z.ZodNumber>;
+            embedding_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            embedding_version: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            created_at: z.ZodString;
+            last_reinforced_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            retrieval_count: z.ZodOptional<z.ZodNumber>;
+            interference_count: z.ZodOptional<z.ZodNumber>;
+            salience: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        causalLinks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            cause_id: z.ZodString;
+            effect_id: z.ZodString;
+            link_type: z.ZodOptional<z.ZodEnum<{
+                causal: "causal";
+                correlational: "correlational";
+                temporal: "temporal";
+            }>>;
+            mechanism: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            confidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            evidence_count: z.ZodOptional<z.ZodNumber>;
+            created_at: z.ZodString;
+        }, z.core.$strip>>>;
+        contradictions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            claim_a_id: z.ZodString;
+            claim_a_type: z.ZodString;
+            claim_b_id: z.ZodString;
+            claim_b_type: z.ZodString;
+            state: z.ZodEnum<{
+                context_dependent: "context_dependent";
+                open: "open";
+                resolved: "resolved";
+                reopened: "reopened";
+            }>;
+            resolution: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            resolved_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            reopened_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            reopen_evidence_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            created_at: z.ZodString;
+        }, z.core.$strip>>>;
+        consolidationRuns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            checkpoint_cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            input_episode_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            output_memory_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            confidence_deltas: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            consolidation_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            consolidation_prompt_hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            completed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            status: z.ZodEnum<{
+                rolled_back: "rolled_back";
+                running: "running";
+                completed: "completed";
+                failed: "failed";
+            }>;
+        }, z.core.$strip>>>;
+        consolidationMetrics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            run_id: z.ZodString;
+            min_cluster_size: z.ZodNumber;
+            similarity_threshold: z.ZodNumber;
+            episodes_evaluated: z.ZodNumber;
+            clusters_found: z.ZodNumber;
+            principles_extracted: z.ZodNumber;
+            created_at: z.ZodString;
+        }, z.core.$strip>>>;
+        memoryEvents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            session_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            event_type: z.ZodString;
+            source: z.ZodString;
+            actor_agent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tool_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            input_hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            output_hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            outcome: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                unknown: "unknown";
+                failed: "failed";
+                succeeded: "succeeded";
+                blocked: "blocked";
+                skipped: "skipped";
+            }>>>;
+            error_summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            cwd: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            file_fingerprints: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            redaction_state: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                clean: "clean";
+                redacted: "redacted";
+                unreviewed: "unreviewed";
+                quarantined: "quarantined";
+            }>>>;
+            metadata: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            created_at: z.ZodString;
+        }, z.core.$strip>>>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>;
+};
+export declare const memoryForgetToolSchema: {
+    id: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    min_similarity: z.ZodOptional<z.ZodNumber>;
+    purge: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const memoryValidateToolSchema: {
+    id: z.ZodString;
+    outcome: z.ZodEnum<{
+        used: "used";
+        helpful: "helpful";
+        wrong: "wrong";
+    }>;
+};
+export declare const memoryPreflightToolSchema: {
+    action: z.ZodString;
+    tool: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    strict: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    budget_chars: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        balanced: "balanced";
+        conservative: "conservative";
+        aggressive: "aggressive";
+    }>>;
+    failure_window_hours: z.ZodOptional<z.ZodNumber>;
+    include_status: z.ZodOptional<z.ZodBoolean>;
+    record_event: z.ZodOptional<z.ZodBoolean>;
+    include_capsule: z.ZodOptional<z.ZodBoolean>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        shared: "shared";
+        agent: "agent";
+    }>>;
+};
+export declare const memoryGuardBeforeToolSchema: {
+    session_id: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    action: z.ZodString;
+    tool: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    strict: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    budget_chars: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        balanced: "balanced";
+        conservative: "conservative";
+        aggressive: "aggressive";
+    }>>;
+    failure_window_hours: z.ZodOptional<z.ZodNumber>;
+    include_status: z.ZodOptional<z.ZodBoolean>;
+    include_capsule: z.ZodOptional<z.ZodBoolean>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        shared: "shared";
+        agent: "agent";
+    }>>;
+};
+export declare const memoryGuardAfterToolSchema: {
+    receipt_id: z.ZodString;
+    tool: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodUnknown>;
+    output: z.ZodOptional<z.ZodUnknown>;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        failed: "failed";
+        succeeded: "succeeded";
+        blocked: "blocked";
+        skipped: "skipped";
+    }>>;
+    error_summary: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    retain_details: z.ZodOptional<z.ZodBoolean>;
+    evidence_feedback: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        used: "used";
+        helpful: "helpful";
+        wrong: "wrong";
+    }>>>;
+};
+export declare const memoryReflexesToolSchema: {
+    include_preflight: z.ZodOptional<z.ZodBoolean>;
+    action: z.ZodString;
+    tool: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    strict: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    budget_chars: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        balanced: "balanced";
+        conservative: "conservative";
+        aggressive: "aggressive";
+    }>>;
+    failure_window_hours: z.ZodOptional<z.ZodNumber>;
+    include_status: z.ZodOptional<z.ZodBoolean>;
+    record_event: z.ZodOptional<z.ZodBoolean>;
+    include_capsule: z.ZodOptional<z.ZodBoolean>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        shared: "shared";
+        agent: "agent";
+    }>>;
+};
+//# sourceMappingURL=tool-schemas.d.ts.map

package/dist/mcp-server/tool-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-schemas.d.ts","sourceRoot":"","sources":["../../mcp-server/tool-schemas.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;CA6ClC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4ClC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAElC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;CAgBlC,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;CAOpC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;CAiErC,CAAC;AAIF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;CAUvC,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;CAkDtC,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;CAMpC,CAAC"}

package/dist/mcp-server/tool-schemas.js

@@ -0,0 +1,248 @@
+/**
+ * Zod tool-input schemas for the MCP memory tools. These are pure schema
+ * declarations consumed by the MCP server registration in index.ts and
+ * re-exported from there for tests and embedders.
+ */
+import { z } from 'zod';
+import { importSnapshotSchema } from '../src/import.js';
+import { MAX_MEMORY_CONTENT_LENGTH, VALID_SOURCES, VALID_TYPES, isNonEmptyText, } from './tool-validation.js';
+export const memoryEncodeToolSchema = {
+    content: z
+        .string()
+        .max(MAX_MEMORY_CONTENT_LENGTH)
+        .refine(isNonEmptyText, 'Content must not be empty')
+        .describe('The memory content to encode'),
+    source: z.enum(VALID_SOURCES).describe('Source type of the memory'),
+    tags: z.array(z.string()).optional().describe('Optional tags for categorization'),
+    salience: z.number().min(0).max(1).optional().describe('Importance weight 0-1'),
+    context: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Situational context as key-value pairs (e.g., {task: "debugging", domain: "payments"})'),
+    affect: z
+        .object({
+        valence: z
+            .number()
+            .min(-1)
+            .max(1)
+            .describe('Emotional valence: -1 (very negative) to 1 (very positive)'),
+        arousal: z
+            .number()
+            .min(0)
+            .max(1)
+            .optional()
+            .describe('Emotional arousal: 0 (calm) to 1 (highly activated)'),
+        label: z
+            .string()
+            .optional()
+            .describe('Human-readable emotion label (e.g., "curiosity", "frustration", "relief")'),
+    })
+        .optional()
+        .describe('Emotional affect - how this memory feels'),
+    private: z
+        .boolean()
+        .optional()
+        .describe('If true, memory is only visible to the AI and excluded from public recall results'),
+    wait_for_consolidation: z
+        .boolean()
+        .optional()
+        .describe('If true, wait for post-encode validation/interference/resonance work before returning. Defaults to false.'),
+};
+export const memoryRecallToolSchema = {
+    query: z.string().describe('Search query to match against memories'),
+    limit: z.number().min(1).max(50).optional().describe('Max results (default 10)'),
+    types: z.array(z.enum(VALID_TYPES)).optional().describe('Memory types to search'),
+    min_confidence: z.number().min(0).max(1).optional().describe('Minimum confidence threshold'),
+    tags: z.array(z.string()).optional().describe('Only return episodic memories with these tags'),
+    sources: z
+        .array(z.enum(VALID_SOURCES))
+        .optional()
+        .describe('Only return episodic memories from these sources'),
+    after: z.string().optional().describe('Only return memories created after this ISO date'),
+    before: z.string().optional().describe('Only return memories created before this ISO date'),
+    context: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Retrieval context - memories encoded in matching context get boosted'),
+    mood: z
+        .object({
+        valence: z
+            .number()
+            .min(-1)
+            .max(1)
+            .describe('Current emotional valence: -1 (negative) to 1 (positive)'),
+        arousal: z
+            .number()
+            .min(0)
+            .max(1)
+            .optional()
+            .describe('Current arousal: 0 (calm) to 1 (activated)'),
+    })
+        .optional()
+        .describe('Current mood - boosts recall of memories encoded in similar emotional state'),
+    retrieval: z
+        .enum(['hybrid', 'vector'])
+        .optional()
+        .describe('Retrieval strategy. hybrid is the default (vector + FTS/BM25 fusion); vector bypasses FTS for lower latency but loses lexical exact-match signal.'),
+    scope: z
+        .enum(['agent', 'shared'])
+        .optional()
+        .describe('agent restricts recall to this MCP server agent identity. shared searches the whole store. Defaults to shared for backward compatibility.'),
+};
+export const memoryImportToolSchema = {
+    snapshot: importSnapshotSchema.describe('A validated snapshot from memory_export'),
+};
+export const memoryForgetToolSchema = {
+    id: z.string().optional().describe('ID of the memory to forget'),
+    query: z
+        .string()
+        .optional()
+        .describe('Semantic query to find and forget the closest matching memory'),
+    min_similarity: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe('Minimum similarity for query-based forget (default 0.9)'),
+    purge: z
+        .boolean()
+        .optional()
+        .describe('Hard-delete the memory permanently (default false, soft-delete)'),
+};
+export const memoryValidateToolSchema = {
+    id: z.string().describe('ID of the memory to validate'),
+    outcome: z
+        .enum(['used', 'helpful', 'wrong'])
+        .describe('How the memory played out: "used" (referenced without obvious value), "helpful" (drove a correct action — reinforces salience and retrieval), "wrong" (memory was misleading — bumps challenge_count and decreases salience).'),
+};
+export const memoryPreflightToolSchema = {
+    action: z
+        .string()
+        .refine(isNonEmptyText, 'Action must not be empty')
+        .describe('Natural-language description of the action the agent is about to take.'),
+    tool: z
+        .string()
+        .optional()
+        .describe('Tool or command family about to be used, e.g. Bash, npm test, Edit, deploy.'),
+    session_id: z
+        .string()
+        .optional()
+        .describe('Session identifier for grouping the optional preflight event.'),
+    cwd: z.string().optional().describe('Working directory for the action.'),
+    files: z
+        .array(z.string())
+        .optional()
+        .describe('File paths to fingerprint if record_event is true.'),
+    strict: z
+        .boolean()
+        .optional()
+        .describe('If true, high-severity memory warnings produce decision=block instead of caution.'),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .optional()
+        .describe('Max recall results to consider before preflight categorization.'),
+    budget_chars: z
+        .number()
+        .int()
+        .min(200)
+        .max(32000)
+        .optional()
+        .describe('Capsule budget in characters.'),
+    mode: z
+        .enum(['balanced', 'conservative', 'aggressive'])
+        .optional()
+        .describe('Underlying capsule mode. Defaults to conservative.'),
+    failure_window_hours: z
+        .number()
+        .int()
+        .min(1)
+        .max(8760)
+        .optional()
+        .describe('How far back to check failed tool events. Defaults to 168 hours.'),
+    include_status: z
+        .boolean()
+        .optional()
+        .describe('Include memory health in the response and warning calculation. Defaults to true.'),
+    record_event: z
+        .boolean()
+        .optional()
+        .describe('Record a redacted PreToolUse event for this preflight. Defaults to false.'),
+    include_capsule: z
+        .boolean()
+        .optional()
+        .describe('If false, omit the embedded Memory Capsule from the response.'),
+    scope: z
+        .enum(['agent', 'shared'])
+        .optional()
+        .describe('agent restricts memory recall to this server agent identity. shared searches the whole store. Defaults to agent.'),
+};
+const { record_event: _preflightRecordEvent, ...memoryGuardBeforeFields } = memoryPreflightToolSchema;
+export const memoryGuardBeforeToolSchema = {
+    ...memoryGuardBeforeFields,
+    session_id: z
+        .string()
+        .optional()
+        .describe('Session identifier for grouping the required guard receipt event.'),
+    files: z
+        .array(z.string())
+        .optional()
+        .describe('File paths to fingerprint in the required guard receipt.'),
+};
+export const memoryGuardAfterToolSchema = {
+    receipt_id: z
+        .string()
+        .refine(isNonEmptyText, 'Receipt id must not be empty')
+        .describe('Receipt id returned by memory_guard_before.'),
+    tool: z
+        .string()
+        .optional()
+        .describe('Tool or command family that completed, e.g. Bash, npm test, Edit, deploy.'),
+    session_id: z
+        .string()
+        .optional()
+        .describe('Session identifier for grouping related guard events.'),
+    input: z
+        .unknown()
+        .optional()
+        .describe('Tool input. Hashed and never stored raw; redacted metadata is only stored when retain_details is true.'),
+    output: z
+        .unknown()
+        .optional()
+        .describe('Tool output. Same redaction and storage policy as input.'),
+    outcome: z
+        .enum(['succeeded', 'failed', 'blocked', 'skipped', 'unknown'])
+        .optional()
+        .describe('Outcome classification'),
+    error_summary: z
+        .string()
+        .optional()
+        .describe('Short error description if the action failed. Redacted and truncated to 2 KB.'),
+    cwd: z.string().optional().describe('Working directory at the time of the action.'),
+    files: z
+        .array(z.string())
+        .optional()
+        .describe('File paths to fingerprint (size + mtime + content hash).'),
+    metadata: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe('Arbitrary structured metadata (redacted before storage).'),
+    retain_details: z
+        .boolean()
+        .optional()
+        .describe('If true, redacted input and output payloads are stored alongside hashes. Defaults to false.'),
+    evidence_feedback: z
+        .record(z.string(), z.enum(['used', 'helpful', 'wrong']))
+        .optional()
+        .describe('Map of evidence ids from the guard receipt to memory validation outcomes.'),
+};
+export const memoryReflexesToolSchema = {
+    ...memoryPreflightToolSchema,
+    include_preflight: z
+        .boolean()
+        .optional()
+        .describe('If true, include the full underlying preflight report.'),
+};
+//# sourceMappingURL=tool-schemas.js.map

package/dist/mcp-server/tool-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-schemas.js","sourceRoot":"","sources":["../../mcp-server/tool-schemas.ts"],"names":[],"mappings":"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"}

package/dist/mcp-server/tool-validation.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared validation primitives and admin/embedding guards for the MCP tool and
+ * CLI surfaces. Kept separate from tool-schemas.ts and index.ts so both can
+ * import them without a circular dependency.
+ */
+import type { EmbeddingProvider } from '../src/types.js';
+export declare const VALID_SOURCES: readonly ["direct-observation", "told-by-user", "tool-result", "inference", "model-generated"];
+export declare const VALID_TYPES: readonly ["episodic", "semantic", "procedural"];
+export declare const MAX_MEMORY_CONTENT_LENGTH = 50000;
+export declare const ADMIN_TOOLS_ENV = "AUDREY_ENABLE_ADMIN_TOOLS";
+export declare function isNonEmptyText(value: unknown): boolean;
+export declare function validateMemoryContent(content: string): void;
+export declare function validateForgetSelection(id?: string, query?: string): void;
+export declare function isAdminToolsEnabled(env?: Record<string, string | undefined>): boolean;
+export declare function requireAdminTools(env?: Record<string, string | undefined>): void;
+export declare function initializeEmbeddingProvider(provider: EmbeddingProvider): Promise<void>;
+//# sourceMappingURL=tool-validation.d.ts.map

package/dist/mcp-server/tool-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-validation.d.ts","sourceRoot":"","sources":["../../mcp-server/tool-validation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,eAAO,MAAM,aAAa,gGAMhB,CAAC;AAEX,eAAO,MAAM,WAAW,iDAAkD,CAAC;AAE3E,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAChD,eAAO,MAAM,eAAe,8BAA8B,CAAC;AAE3D,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEtD;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAO3D;AAED,wBAAgB,uBAAuB,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAIzE;AAED,wBAAgB,mBAAmB,CACjC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,OAAO,CAGT;AAED,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GAAG,IAAI,CAM7F;AAED,wBAAsB,2BAA2B,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAI5F"}

package/dist/mcp-server/tool-validation.js

@@ -0,0 +1,41 @@
+export const VALID_SOURCES = [
+    'direct-observation',
+    'told-by-user',
+    'tool-result',
+    'inference',
+    'model-generated',
+];
+export const VALID_TYPES = ['episodic', 'semantic', 'procedural'];
+export const MAX_MEMORY_CONTENT_LENGTH = 50_000;
+export const ADMIN_TOOLS_ENV = 'AUDREY_ENABLE_ADMIN_TOOLS';
+export function isNonEmptyText(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+export function validateMemoryContent(content) {
+    if (!isNonEmptyText(content)) {
+        throw new Error('content must be a non-empty string');
+    }
+    if (content.length > MAX_MEMORY_CONTENT_LENGTH) {
+        throw new Error(`content exceeds maximum length of ${MAX_MEMORY_CONTENT_LENGTH} characters`);
+    }
+}
+export function validateForgetSelection(id, query) {
+    if ((id && query) || (!id && !query)) {
+        throw new Error('Provide exactly one of id or query');
+    }
+}
+export function isAdminToolsEnabled(env = process.env) {
+    const value = env[ADMIN_TOOLS_ENV]?.toLowerCase();
+    return value === '1' || value === 'true' || value === 'yes';
+}
+export function requireAdminTools(env = process.env) {
+    if (!isAdminToolsEnabled(env)) {
+        throw new Error(`Admin memory tools are disabled. Set ${ADMIN_TOOLS_ENV}=1 to enable export, import, and forget operations.`);
+    }
+}
+export async function initializeEmbeddingProvider(provider) {
+    if (provider && typeof provider.ready === 'function') {
+        await provider.ready();
+    }
+}
+//# sourceMappingURL=tool-validation.js.map