@iwo-szapar/data-mcp 0.4.0 → 0.6.0

package/dist/adapter/factory.d.ts

@@ -1,9 +1,9 @@
 /**
  * Adapter factory — creates the correct DataAdapter based on configuration.
  *
- * Always wraps the adapter in SchemaMapProxy (transparent if no mappings).
+ * Wraps adapters in SchemaMapProxy and optional OwnerScopeProxy.
  */
 import type { Config } from '../config.js';
 import type { DataAdapter } from './types.js';
 export declare function createAdapter(config: Config): DataAdapter;
-//# sourceMappingURL=factory.d.ts.map
+//# sourceMappingURL=factory.d.ts.map

package/dist/adapter/factory.js

@@ -1,12 +1,13 @@
 /**
  * Adapter factory — creates the correct DataAdapter based on configuration.
  *
- * Always wraps the adapter in SchemaMapProxy (transparent if no mappings).
+ * Wraps adapters in SchemaMapProxy and optional OwnerScopeProxy.
  */
 import { PocketBaseAdapter } from './pocketbase.js';
 import { SupabaseAdapter } from './supabase.js';
 import { MarkdownAdapter } from './markdown.js';
 import { SchemaMap, SchemaMapProxy } from './schema-map.js';
+import { OwnerScopeProxy } from './owner-scope.js';
 export function createAdapter(config) {
     let adapter;
     if (config.backend === 'pocketbase') {
@@ -20,8 +21,11 @@ export function createAdapter(config) {
     }
     const schemaMap = new SchemaMap(config.schemaMap);
     if (!schemaMap.isEmpty) {
-        return new SchemaMapProxy(adapter, schemaMap);
+        adapter = new SchemaMapProxy(adapter, schemaMap);
+    }
+    if (config.backend !== 'pocketbase' && config.ownerRouting) {
+        adapter = new OwnerScopeProxy(adapter, config.ownerRouting);
     }
     return adapter;
 }
-//# sourceMappingURL=factory.js.map
+//# sourceMappingURL=factory.js.map

package/dist/adapter/owner-scope.d.ts

@@ -0,0 +1,31 @@
+import type { DataAdapter, Filter, ListResult, PageOptions, SortClause } from './types.js';
+export interface OwnerRoutingConfig {
+    ownerId: string;
+    sharedOwnerId: string;
+}
+export declare class OwnerScopeProxy implements DataAdapter {
+    private inner;
+    private ownerId;
+    private sharedOwnerId;
+    readonly ownerScopeEnabled = true;
+    constructor(inner: DataAdapter, config: OwnerRoutingConfig);
+    get backend(): 'pocketbase' | 'supabase' | 'markdown';
+    create<T extends Record<string, unknown>>(collection: string, data: Record<string, unknown>): Promise<T>;
+    getOne<T extends Record<string, unknown>>(collection: string, id: string): Promise<T>;
+    list<T extends Record<string, unknown>>(collection: string, options?: {
+        filter?: Filter;
+        sort?: SortClause[];
+        page?: PageOptions;
+    }): Promise<ListResult<T>>;
+    textSearch<T extends Record<string, unknown>>(collection: string, query: string, options?: {
+        fields?: string[];
+        filter?: Filter;
+        limit?: number;
+    }): Promise<T[]>;
+    update<T extends Record<string, unknown>>(collection: string, id: string, data: Record<string, unknown>): Promise<T>;
+    delete(collection: string, id: string): Promise<void>;
+    upsert<T extends Record<string, unknown>>(collection: string, data: Record<string, unknown>, uniqueFields: string[]): Promise<T>;
+    count(collection: string, filter?: Filter): Promise<number>;
+    collectionExists(collection: string): Promise<boolean>;
+    listCollections(): Promise<string[]>;
+}

package/dist/adapter/owner-scope.js

@@ -0,0 +1,155 @@
+import { AdapterError } from '../errors/adapter-error.js';
+
+const DEFAULT_SCOPED_COLLECTIONS = new Set([
+    'knowledge',
+    'decisions',
+    'sessions',
+    'goals',
+    'tasks',
+    'contacts',
+    'knowledge_links',
+]);
+
+export class OwnerScopeProxy {
+    inner;
+    ownerId;
+    sharedOwnerId;
+    ownerScopeEnabled = true;
+    constructor(inner, config) {
+        this.inner = inner;
+        this.ownerId = config.ownerId;
+        this.sharedOwnerId = config.sharedOwnerId;
+    }
+    get backend() {
+        return this.inner.backend;
+    }
+    async create(collection, data) {
+        return this.inner.create(collection, this.withWriteOwner(collection, data));
+    }
+    async getOne(collection, id) {
+        const record = await this.inner.getOne(collection, id);
+        this.assertReadable(collection, record);
+        return record;
+    }
+    async list(collection, options) {
+        return this.inner.list(collection, this.withReadFilter(collection, options));
+    }
+    async textSearch(collection, query, options) {
+        return this.inner.textSearch(collection, query, this.withReadFilter(collection, options));
+    }
+    async update(collection, id, data) {
+        await this.getOne(collection, id);
+        return this.inner.update(collection, id, this.withUpdateOwner(collection, data));
+    }
+    async delete(collection, id) {
+        await this.getOne(collection, id);
+        return this.inner.delete(collection, id);
+    }
+    async upsert(collection, data, uniqueFields) {
+        const scopedData = this.withWriteOwner(collection, data);
+        const scopedUniqueFields = this.isScoped(collection) && !uniqueFields.includes('owner_id')
+            ? [...uniqueFields, 'owner_id']
+            : uniqueFields;
+        return this.inner.upsert(collection, scopedData, scopedUniqueFields);
+    }
+    async count(collection, filter) {
+        return this.inner.count(collection, this.ownerFilter(collection, filter));
+    }
+    async collectionExists(collection) {
+        return this.inner.collectionExists(collection);
+    }
+    async listCollections() {
+        return this.inner.listCollections();
+    }
+    isScoped(collection) {
+        return DEFAULT_SCOPED_COLLECTIONS.has(collection);
+    }
+    visibleOwners() {
+        return this.ownerId === this.sharedOwnerId
+            ? [this.sharedOwnerId]
+            : [this.ownerId, this.sharedOwnerId];
+    }
+    ownerFilter(collection, filter) {
+        if (!this.isScoped(collection))
+            return filter;
+        const groups = filter && filter.length > 0 ? filter : [[]];
+        return groups.map((andGroup) => {
+            let requestedOwners;
+            const cleanGroup = [];
+            for (const clause of andGroup) {
+                if (clause.field === 'owner_scope') {
+                    requestedOwners = this.resolveReadOwners(clause.value);
+                    continue;
+                }
+                cleanGroup.push(clause);
+            }
+            const owners = requestedOwners ?? this.visibleOwners();
+            const ownerClause = owners.length === 1
+                ? { field: 'owner_id', op: 'eq', value: owners[0] }
+                : { field: 'owner_id', op: 'in', value: owners };
+            return [...cleanGroup, ownerClause];
+        });
+    }
+    withReadFilter(collection, options) {
+        if (!this.isScoped(collection))
+            return options;
+        return { ...options, filter: this.ownerFilter(collection, options?.filter) };
+    }
+    withWriteOwner(collection, data) {
+        if (!this.isScoped(collection))
+            return stripOwnerScope(data);
+        const ownerId = this.resolveWriteOwner(data);
+        return { ...stripOwnerScope(data), owner_id: ownerId };
+    }
+    withUpdateOwner(collection, data) {
+        if (!this.isScoped(collection))
+            return stripOwnerScope(data);
+        if (!hasOwnerIntent(data))
+            return stripOwnerScope(data);
+        const ownerId = this.resolveWriteOwner(data);
+        return { ...stripOwnerScope(data), owner_id: ownerId };
+    }
+    resolveWriteOwner(data) {
+        const ownerScope = typeof data.owner_scope === 'string' ? data.owner_scope : undefined;
+        if (ownerScope === 'shared')
+            return this.sharedOwnerId;
+        if (ownerScope === 'private')
+            return this.ownerId;
+        const requestedOwner = typeof data.owner_id === 'string' ? data.owner_id.trim() : '';
+        if (!requestedOwner)
+            return this.ownerId;
+        if (requestedOwner === this.ownerId || requestedOwner === this.sharedOwnerId)
+            return requestedOwner;
+        throw new AdapterError('VALIDATION_ERROR', 'owner_id must be the current owner or shared owner');
+    }
+    resolveReadOwners(value) {
+        const scopes = Array.isArray(value) ? value : [value];
+        const owners = [];
+        for (const scope of scopes) {
+            if (scope === 'private')
+                owners.push(this.ownerId);
+            else if (scope === 'shared')
+                owners.push(this.sharedOwnerId);
+            else
+                throw new AdapterError('VALIDATION_ERROR', 'owner_scope must be private or shared');
+        }
+        return [...new Set(owners)];
+    }
+    assertReadable(collection, record) {
+        if (!this.isScoped(collection))
+            return;
+        if (this.visibleOwners().includes(record.owner_id))
+            return;
+        throw new AdapterError('RECORD_NOT_FOUND', `Record not found in '${collection}'`);
+    }
+}
+
+function stripOwnerScope(data) {
+    const { owner_scope: _ownerScope, ...clean } = data;
+    return clean;
+}
+
+function hasOwnerIntent(data) {
+    return Object.prototype.hasOwnProperty.call(data, 'owner_scope')
+        || Object.prototype.hasOwnProperty.call(data, 'owner_id');
+}

package/dist/adapter/types.d.ts

@@ -63,5 +63,6 @@ export interface DataAdapter {
     collectionExists(collection: string): Promise<boolean>;
     /** List all collection names */
     listCollections(): Promise<string[]>;
+    readonly ownerScopeEnabled?: boolean;
 }
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=types.d.ts.map

package/dist/config.d.ts

@@ -1,16 +1,19 @@
 /**
  * Configuration parsing from environment variables.
  *
- * SB_BACKEND: 'pocketbase' | 'supabase' (required)
+ * SB_BACKEND: 'pocketbase' | 'supabase' | 'markdown' (required)
  * SB_POCKETBASE_URL: PocketBase server URL (required if backend=pocketbase)
  * SB_POCKETBASE_ADMIN_EMAIL: PocketBase admin email (required if backend=pocketbase)
  * SB_POCKETBASE_ADMIN_PASSWORD: PocketBase admin password (required if backend=pocketbase)
  * SB_SUPABASE_URL: Supabase project URL (required if backend=supabase)
  * SB_SUPABASE_KEY: Supabase service role key (required if backend=supabase)
+ * SB_MARKDOWN_ROOT: filesystem path to the memory/ folder (required if backend=markdown)
  * SB_SCHEMA_MAP: JSON string mapping logical names to actual table names (optional)
  * SB_RESEND_API_KEY: Resend API key for email sending (optional)
+ * MEMORYOS_OWNER_ID: current memory owner id, enables owner routing when set (optional)
+ * MEMORYOS_SHARED_OWNER_ID: shared/team memory owner id (optional, default: firma)
  */
-export type Backend = 'pocketbase' | 'supabase';
+export type Backend = 'pocketbase' | 'supabase' | 'markdown';
 export interface PocketBaseConfig {
     backend: 'pocketbase';
     pocketbaseUrl: string;
@@ -18,6 +21,7 @@ export interface PocketBaseConfig {
     pocketbaseAdminPassword: string;
     schemaMap: Record<string, string>;
     resendApiKey?: string;
+    ownerRouting?: OwnerRoutingConfig;
 }
 export interface SupabaseConfig {
     backend: 'supabase';
@@ -25,7 +29,19 @@ export interface SupabaseConfig {
     supabaseKey: string;
     schemaMap: Record<string, string>;
     resendApiKey?: string;
+    ownerRouting?: OwnerRoutingConfig;
 }
-export type Config = PocketBaseConfig | SupabaseConfig;
+export interface MarkdownConfig {
+    backend: 'markdown';
+    markdownRoot: string;
+    schemaMap: Record<string, string>;
+    resendApiKey?: string;
+    ownerRouting?: OwnerRoutingConfig;
+}
+export interface OwnerRoutingConfig {
+    ownerId: string;
+    sharedOwnerId: string;
+}
+export type Config = PocketBaseConfig | SupabaseConfig | MarkdownConfig;
 export declare function parseConfig(): Config;
-//# sourceMappingURL=config.d.ts.map
+//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -10,6 +10,8 @@
  * SB_MARKDOWN_ROOT: filesystem path to the memory/ folder (required if backend=markdown)
  * SB_SCHEMA_MAP: JSON string mapping logical names to actual table names (optional)
  * SB_RESEND_API_KEY: Resend API key for email sending (optional)
+ * MEMORYOS_OWNER_ID: current memory owner id, enables owner routing when set (optional)
+ * MEMORYOS_SHARED_OWNER_ID: shared/team memory owner id (optional, default: firma)
  */
 const ALLOWED_BACKENDS = ['pocketbase', 'supabase', 'markdown'];
 export function parseConfig() {
@@ -19,6 +21,7 @@ export function parseConfig() {
     }
     const schemaMap = parseSchemaMap(process.env.SB_SCHEMA_MAP);
     const resendApiKey = process.env.SB_RESEND_API_KEY || undefined;
+    const ownerRouting = parseOwnerRouting();
     if (backend === 'pocketbase') {
         return {
             backend,
@@ -27,6 +30,7 @@ export function parseConfig() {
             pocketbaseAdminPassword: requireEnv('SB_POCKETBASE_ADMIN_PASSWORD'),
             schemaMap,
             resendApiKey,
+            ownerRouting,
         };
     }
     if (backend === 'markdown') {
@@ -35,6 +39,7 @@ export function parseConfig() {
             markdownRoot: requireEnv('SB_MARKDOWN_ROOT'),
             schemaMap,
             resendApiKey,
+            ownerRouting,
         };
     }
     return {
@@ -43,6 +48,7 @@ export function parseConfig() {
         supabaseKey: requireEnv('SB_SUPABASE_KEY'),
         schemaMap,
         resendApiKey,
+        ownerRouting,
     };
 }
 function requireEnv(name) {
@@ -69,4 +75,11 @@ function parseSchemaMap(raw) {
         throw err;
     }
 }
-//# sourceMappingURL=config.js.map
+function parseOwnerRouting() {
+    const ownerId = process.env.MEMORYOS_OWNER_ID?.trim();
+    if (!ownerId)
+        return undefined;
+    const sharedOwnerId = process.env.MEMORYOS_SHARED_OWNER_ID?.trim() || 'firma';
+    return { ownerId, sharedOwnerId };
+}
+//# sourceMappingURL=config.js.map

package/dist/server.js

@@ -29,8 +29,8 @@ const SERVER_INSTRUCTIONS = `You are the user's AI Second Brain data layer. This
 - Use setup_status to check database readiness`;
 export function createServer(adapter) {
     const server = new McpServer({
-        name: '@iwo-szapar/data-mcp',
-        version: '0.3.3',
+        name: '@second-brain/data-mcp',
+        version: '0.1.0',
     }, {
         instructions: SERVER_INSTRUCTIONS,
     });

package/dist/tools/memory/contact-create.js

@@ -15,6 +15,7 @@ export function registerContactCreate(server, adapter) {
         relationship: z.enum(['colleague', 'client', 'prospect', 'partner', 'other']).optional().describe('Relationship type'),
         notes: z.string().max(5000).optional().describe('Notes about the contact'),
         tags: z.array(z.string().max(100)).max(20).optional().describe('Tags for categorization'),
+        owner_scope: z.enum(['private', 'shared']).optional().describe('Store privately for this user or in shared team memory'),
     }, withGracefulDegradation('contacts', adapter, async (params) => {
         try {
             const record = await adapter.create('contacts', {
@@ -26,6 +27,7 @@ export function registerContactCreate(server, adapter) {
                 relationship: params.relationship ?? null,
                 notes: params.notes ?? null,
                 tags: params.tags ?? [],
+                ...(adapter.ownerScopeEnabled ? { owner_scope: params.owner_scope } : {}),
                 last_contact_date: null,
             });
             return makeToolResponse({
@@ -39,4 +41,4 @@ export function registerContactCreate(server, adapter) {
         }
     }));
 }
-//# sourceMappingURL=contact-create.js.map
+//# sourceMappingURL=contact-create.js.map

package/dist/tools/memory/goal-create.js

@@ -16,6 +16,7 @@ export function registerGoalCreate(server, adapter) {
             current: z.union([z.number(), z.string()]).optional(),
         })).optional().describe('Key results to track progress'),
         tags: z.array(z.string().max(100)).max(20).optional().describe('Tags for categorization'),
+        owner_scope: z.enum(['private', 'shared']).optional().describe('Store privately for this user or in shared team memory'),
     }, withGracefulDegradation('goals', adapter, async (params) => {
         try {
             const record = await adapter.create('goals', {
@@ -25,6 +26,7 @@ export function registerGoalCreate(server, adapter) {
                 status: 'active',
                 key_results: params.key_results ?? [],
                 tags: params.tags ?? [],
+                ...(adapter.ownerScopeEnabled ? { owner_scope: params.owner_scope } : {}),
             });
             return makeToolResponse({
                 created: true,
@@ -37,4 +39,4 @@ export function registerGoalCreate(server, adapter) {
         }
     }));
 }
-//# sourceMappingURL=goal-create.js.map
+//# sourceMappingURL=goal-create.js.map

package/dist/tools/memory/knowledge-decide.js

@@ -14,6 +14,7 @@ export function registerKnowledgeDecide(server, adapter) {
         chosen_option: z.string().min(1).max(500).describe('The option that was chosen'),
         rationale: z.string().max(5000).optional().describe('Why this option was chosen'),
         tags: z.array(z.string().max(100)).max(20).optional().describe('Tags for categorization'),
+        owner_scope: z.enum(['private', 'shared']).optional().describe('Store privately for this user or in shared team memory'),
     }, withGracefulDegradation('decisions', adapter, async (params) => {
         try {
             const record = await adapter.create('decisions', {
@@ -24,6 +25,7 @@ export function registerKnowledgeDecide(server, adapter) {
                 rationale: params.rationale ?? null,
                 outcome: null,
                 tags: params.tags ?? [],
+                ...(adapter.ownerScopeEnabled ? { owner_scope: params.owner_scope } : {}),
             });
             return makeToolResponse({
                 stored: true,
@@ -36,4 +38,4 @@ export function registerKnowledgeDecide(server, adapter) {
         }
     }));
 }
-//# sourceMappingURL=knowledge-decide.js.map
+//# sourceMappingURL=knowledge-decide.js.map

package/dist/tools/memory/knowledge-learn.js

@@ -13,6 +13,7 @@ export function registerKnowledgeLearn(server, adapter) {
         content: z.string().min(1).max(10000).describe('Detailed description of the learning'),
         tags: z.array(z.string().max(100)).max(20).optional().describe('Tags for categorization'),
         source: z.string().max(500).optional().describe('Context where this was learned'),
+        owner_scope: z.enum(['private', 'shared']).optional().describe('Store privately for this user or in shared team memory'),
     }, withGracefulDegradation('knowledge', adapter, async (params) => {
         try {
             const record = await adapter.create('knowledge', {
@@ -22,6 +23,7 @@ export function registerKnowledgeLearn(server, adapter) {
                 summary: generateSummary(params.content),
                 tags: params.tags ?? [],
                 source: params.source ?? null,
+                ...(adapter.ownerScopeEnabled ? { owner_scope: params.owner_scope } : {}),
                 confidence: 0.8,
                 last_validated_at: new Date().toISOString(),
             });
@@ -36,4 +38,4 @@ export function registerKnowledgeLearn(server, adapter) {
         }
     }));
 }
-//# sourceMappingURL=knowledge-learn.js.map
+//# sourceMappingURL=knowledge-learn.js.map

package/dist/tools/memory/knowledge-list.js

@@ -9,6 +9,7 @@ export function registerKnowledgeList(server, adapter) {
     server.tool('knowledge_list', 'List knowledge items with optional type and tag filters. Supports pagination.', {
         type: z.enum(['fact', 'pattern', 'insight', 'lesson', 'reference']).optional().describe('Filter by knowledge type'),
         tags: z.array(z.string()).optional().describe('Filter by tags (items must contain ALL specified tags)'),
+        owner_scope: z.enum(['private', 'shared']).optional().describe('Filter to private or shared team memory'),
         limit: z.number().int().min(1).max(100).optional().describe('Max results (default 20)'),
         offset: z.number().int().min(0).optional().describe('Offset for pagination (default 0)'),
     }, { readOnlyHint: true }, withGracefulDegradation('knowledge', adapter, async (params) => {
@@ -22,6 +23,9 @@ export function registerKnowledgeList(server, adapter) {
                     clauses.push({ field: 'tags', op: 'contains', value: tag });
                 }
             }
+            if (params.owner_scope && adapter.ownerScopeEnabled) {
+                clauses.push({ field: 'owner_scope', op: 'eq', value: params.owner_scope });
+            }
             const filter = clauses.length > 0 ? [clauses] : undefined;
             const result = await adapter.list('knowledge', {
                 filter,
@@ -40,4 +44,4 @@ export function registerKnowledgeList(server, adapter) {
         }
     }));
 }
-//# sourceMappingURL=knowledge-list.js.map
+//# sourceMappingURL=knowledge-list.js.map

package/dist/tools/memory/knowledge-recall.js

@@ -12,15 +12,21 @@ export function registerKnowledgeRecall(server, adapter) {
     server.tool('knowledge_recall', 'Search your persistent memory. Full-text search across knowledge items and decisions. Empty query returns most recent items. Supports alias expansion (e.g., "payment" also finds "stripe").', {
         query: z.string().max(500).optional().describe('Search query (full-text search). Empty returns recent items.'),
         type: z.enum(['fact', 'pattern', 'insight', 'lesson', 'reference']).optional().describe('Filter by knowledge type'),
+        owner_scope: z.enum(['private', 'shared']).optional().describe('Filter to private or shared team memory'),
         limit: z.number().int().min(1).max(50).optional().describe('Max results (default 10)'),
     }, { readOnlyHint: true }, withGracefulDegradation('knowledge', adapter, async (params) => {
         try {
             const resultLimit = params.limit ?? 10;
             // Empty query: return most recent items
             if (!params.query || params.query.trim() === '') {
-                const filter = params.type
-                    ? [[{ field: 'type', op: 'eq', value: params.type }]]
-                    : undefined;
+                const clauses = [];
+                if (params.type) {
+                    clauses.push({ field: 'type', op: 'eq', value: params.type });
+                }
+                if (params.owner_scope && adapter.ownerScopeEnabled) {
+                    clauses.push({ field: 'owner_scope', op: 'eq', value: params.owner_scope });
+                }
+                const filter = clauses.length > 0 ? [clauses] : undefined;
                 const result = await adapter.list('knowledge', {
                     filter,
                     sort: [{ field: 'created_at', direction: 'desc' }],
@@ -38,9 +44,14 @@ export function registerKnowledgeRecall(server, adapter) {
             const expandedTerms = await expandQueryWithAliases(adapter, searchQuery);
             const expandedQuery = expandedTerms.join(' ');
             // Search knowledge
-            const typeFilter = params.type
-                ? [[{ field: 'type', op: 'eq', value: params.type }]]
-                : undefined;
+            const clauses = [];
+            if (params.type) {
+                clauses.push({ field: 'type', op: 'eq', value: params.type });
+            }
+            if (params.owner_scope && adapter.ownerScopeEnabled) {
+                clauses.push({ field: 'owner_scope', op: 'eq', value: params.owner_scope });
+            }
+            const typeFilter = clauses.length > 0 ? [clauses] : undefined;
             const knowledgeResults = await adapter.textSearch('knowledge', expandedQuery, {
                 fields: ['title', 'content', 'summary'],
                 filter: typeFilter,
@@ -51,8 +62,12 @@ export function registerKnowledgeRecall(server, adapter) {
             try {
                 const decisionsExist = await adapter.collectionExists('decisions');
                 if (decisionsExist) {
+                    const decisionFilter = params.owner_scope && adapter.ownerScopeEnabled
+                        ? [[{ field: 'owner_scope', op: 'eq', value: params.owner_scope }]]
+                        : undefined;
                     decisionResults = await adapter.textSearch('decisions', expandedQuery, {
                         fields: ['title', 'context', 'chosen_option'],
+                        filter: decisionFilter,
                         limit: 5,
                     });
                 }
@@ -76,4 +91,4 @@ export function registerKnowledgeRecall(server, adapter) {
         }
     }));
 }
-//# sourceMappingURL=knowledge-recall.js.map
+//# sourceMappingURL=knowledge-recall.js.map

package/dist/tools/memory/knowledge-store.js

@@ -13,14 +13,19 @@ export function registerKnowledgeStore(server, adapter) {
         content: z.string().min(1).max(10000).describe('Content of the knowledge item'),
         tags: z.array(z.string().max(100)).max(20).optional().describe('Tags for categorization'),
         source: z.string().max(500).optional().describe('Source of the knowledge (URL, book, conversation, etc.)'),
+        owner_scope: z.enum(['private', 'shared']).optional().describe('Store privately for this user or in shared team memory'),
     }, withGracefulDegradation('knowledge', adapter, async (params) => {
         try {
             // Dedup: check for existing item with same type + title
+            const dedupFilter = [
+                { field: 'type', op: 'eq', value: params.type },
+                { field: 'title', op: 'eq', value: params.title.trim() },
+            ];
+            if (adapter.ownerScopeEnabled) {
+                dedupFilter.push({ field: 'owner_scope', op: 'eq', value: params.owner_scope ?? 'private' });
+            }
             const existing = await adapter.list('knowledge', {
-                filter: [[
-                        { field: 'type', op: 'eq', value: params.type },
-                        { field: 'title', op: 'eq', value: params.title.trim() },
-                    ]],
+                filter: [dedupFilter],
                 page: { limit: 1, offset: 0 },
             });
             if (existing.items.length > 0) {
@@ -39,6 +44,7 @@ export function registerKnowledgeStore(server, adapter) {
                 summary: generateSummary(params.content),
                 tags: params.tags ?? [],
                 source: params.source ?? null,
+                ...(adapter.ownerScopeEnabled ? { owner_scope: params.owner_scope } : {}),
                 confidence: 0.8,
                 last_validated_at: new Date().toISOString(),
             });
@@ -53,4 +59,4 @@ export function registerKnowledgeStore(server, adapter) {
         }
     }));
 }
-//# sourceMappingURL=knowledge-store.js.map
+//# sourceMappingURL=knowledge-store.js.map

package/dist/tools/memory/link-create.js

@@ -12,12 +12,13 @@ export function registerLinkCreate(server, adapter) {
         'Links express how knowledge items relate: supports, contradicts, derived_from, etc. ' +
         'Deduplicates by (source, target, relation_type).', {
         source_type: z.enum(ENTITY_TYPES).describe('Type of the source entity'),
-        source_id: z.string().min(1).max(50).describe('ID of the source entity (UUID on Supabase, 15-char native ID on PocketBase)'),
+        source_id: z.string().uuid().describe('UUID of the source entity'),
         target_type: z.enum(ENTITY_TYPES).describe('Type of the target entity'),
-        target_id: z.string().min(1).max(50).describe('ID of the target entity (UUID on Supabase, 15-char native ID on PocketBase)'),
+        target_id: z.string().uuid().describe('UUID of the target entity'),
         relation_type: z.enum(RELATION_TYPES).describe('Type of relationship'),
         confidence: z.number().min(0).max(1).optional().default(0.8).describe('Confidence in this relationship (0-1)'),
         notes: z.string().max(500).optional().describe('Optional context for why this link exists'),
+        owner_scope: z.enum(['private', 'shared']).optional().describe('Store privately for this user or in shared team memory'),
     }, withGracefulDegradation('knowledge_links', adapter, async (params) => {
         try {
             if (params.source_type === params.target_type && params.source_id === params.target_id) {
@@ -26,14 +27,18 @@ export function registerLinkCreate(server, adapter) {
                     message: 'Cannot create a self-link.',
                 });
             }
+            const dedupFilter = [
+                { field: 'source_type', op: 'eq', value: params.source_type },
+                { field: 'source_id', op: 'eq', value: params.source_id },
+                { field: 'target_type', op: 'eq', value: params.target_type },
+                { field: 'target_id', op: 'eq', value: params.target_id },
+                { field: 'relation_type', op: 'eq', value: params.relation_type },
+            ];
+            if (adapter.ownerScopeEnabled) {
+                dedupFilter.push({ field: 'owner_scope', op: 'eq', value: params.owner_scope ?? 'private' });
+            }
             const existing = await adapter.list('knowledge_links', {
-                filter: [[
-                        { field: 'source_type', op: 'eq', value: params.source_type },
-                        { field: 'source_id', op: 'eq', value: params.source_id },
-                        { field: 'target_type', op: 'eq', value: params.target_type },
-                        { field: 'target_id', op: 'eq', value: params.target_id },
-                        { field: 'relation_type', op: 'eq', value: params.relation_type },
-                    ]],
+                filter: [dedupFilter],
                 page: { limit: 1, offset: 0 },
             });
             if (existing.items.length > 0) {
@@ -51,6 +56,7 @@ export function registerLinkCreate(server, adapter) {
                 relation_type: params.relation_type,
                 confidence: params.confidence ?? 0.8,
                 notes: params.notes ?? null,
+                ...(adapter.ownerScopeEnabled ? { owner_scope: params.owner_scope } : {}),
                 auto_suggested: false,
             });
             return makeToolResponse({

package/dist/tools/memory/link-delete.js

@@ -7,7 +7,7 @@ import { z } from 'zod';
 import { makeToolResponse, handleAdapterError, withGracefulDegradation } from '../shared.js';
 export function registerLinkDelete(server, adapter) {
     server.tool('link_delete', 'Delete a knowledge link by its ID.', {
-        link_id: z.string().min(1).max(50).describe('ID of the link to delete'),
+        link_id: z.string().uuid().describe('UUID of the link to delete'),
     }, withGracefulDegradation('knowledge_links', adapter, async (params) => {
         try {
             try {

package/dist/tools/memory/link-related.js

@@ -9,7 +9,7 @@ const ENTITY_TYPES = ['knowledge', 'decision', 'session', 'blog_post', 'prospect
 export function registerLinkRelated(server, adapter) {
     server.tool('link_related', 'Get all links for an entity. Shows outgoing and incoming relationships with resolved titles.', {
         entity_type: z.enum(ENTITY_TYPES).describe('Type of the entity'),
-        entity_id: z.string().min(1).max(50).describe('ID of the entity (UUID on Supabase, 15-char native ID on PocketBase)'),
+        entity_id: z.string().uuid().describe('UUID of the entity'),
         direction: z.enum(['both', 'outgoing', 'incoming']).optional().default('both').describe('Filter direction'),
         relation_type: z.enum(['supports', 'contradicts', 'derived_from', 'example_of', 'supersedes', 'part_of', 'prerequisite'])
             .optional().describe('Filter by relation type'),

package/dist/tools/memory/link-suggest.js

@@ -8,7 +8,7 @@ import { makeToolResponse, handleAdapterError, withGracefulDegradation } from '.
 export function registerLinkSuggest(server, adapter) {
     server.tool('link_suggest', 'Find knowledge items similar to a given item and suggest links. ' +
         'Uses text search to find related items. Returns matches with suggested relation types.', {
-        item_id: z.string().min(1).max(50).describe('ID of the knowledge item to find suggestions for'),
+        item_id: z.string().uuid().describe('UUID of the knowledge item to find suggestions for'),
         limit: z.number().min(1).max(20).optional().default(5).describe('Max suggestions'),
     }, withGracefulDegradation('knowledge', adapter, async (params) => {
         try {