@prmichaelsen/remember-mcp 2.8.0 → 3.12.0

package/src/services/space-config.service.ts

@@ -0,0 +1,79 @@
+/**
+ * Space/Group Configuration Service
+ *
+ * Per-space and per-group behavioral configuration stored in Firestore.
+ * Controls moderation requirements, write modes, and other behavioral rules.
+ */
+
+import { getDocument, setDocument } from '../firestore/init.js';
+import { logger } from '../utils/logger.js';
+import type { WriteMode } from '../types/auth.js';
+
+export interface SpaceConfig {
+  require_moderation: boolean;
+  default_write_mode: WriteMode;
+}
+
+export const DEFAULT_SPACE_CONFIG: SpaceConfig = {
+  require_moderation: false,
+  default_write_mode: 'owner_only',
+};
+
+/**
+ * Get the Firestore path for a space or group config document.
+ */
+function getConfigPath(id: string, type: 'space' | 'group'): { collectionPath: string; docId: string } {
+  const prefix = type === 'space' ? 'spaces' : 'groups';
+  return {
+    collectionPath: `${prefix}/${id}/config`,
+    docId: 'settings',
+  };
+}
+
+/**
+ * Get configuration for a space or group.
+ * Returns defaults merged with any stored config.
+ */
+export async function getSpaceConfig(
+  id: string,
+  type: 'space' | 'group'
+): Promise<SpaceConfig> {
+  try {
+    const { collectionPath, docId } = getConfigPath(id, type);
+    const doc = await getDocument(collectionPath, docId);
+
+    if (!doc) {
+      return { ...DEFAULT_SPACE_CONFIG };
+    }
+
+    return { ...DEFAULT_SPACE_CONFIG, ...doc };
+  } catch (error) {
+    logger.error('Failed to get space config', {
+      service: 'SpaceConfigService',
+      id,
+      type,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return { ...DEFAULT_SPACE_CONFIG };
+  }
+}
+
+/**
+ * Set configuration for a space or group.
+ * Merges partial config with existing values.
+ */
+export async function setSpaceConfig(
+  id: string,
+  type: 'space' | 'group',
+  config: Partial<SpaceConfig>
+): Promise<void> {
+  const { collectionPath, docId } = getConfigPath(id, type);
+  await setDocument(collectionPath, docId, config, { merge: true });
+
+  logger.info('Space config updated', {
+    service: 'SpaceConfigService',
+    id,
+    type,
+    updatedKeys: Object.keys(config),
+  });
+}

package/src/services/trust-enforcement.spec.ts

@@ -0,0 +1,309 @@
+import {
+  buildTrustFilter,
+  formatMemoryForPrompt,
+  getTrustLevelLabel,
+  getTrustInstructions,
+  redactSensitiveFields,
+  isTrustSufficient,
+  resolveEnforcementMode,
+  TRUST_THRESHOLDS,
+} from './trust-enforcement.js';
+import type { Memory } from '../types/memory.js';
+
+// ─── Test Fixtures ─────────────────────────────────────────────────────────
+
+const mockMemory: Memory = {
+  id: 'mem-1',
+  user_id: 'user-owner',
+  doc_type: 'memory',
+  content: 'My private journal entry about my feelings.',
+  title: 'Journal Entry: Feb 2026',
+  summary: 'Reflections on the month of February.',
+  type: 'journal',
+  weight: 0.5,
+  trust: 0.75,
+  location: {
+    gps: { latitude: 37.7749, longitude: -122.4194, timestamp: '2026-01-01T00:00:00Z' },
+    address: { formatted: '123 Main St, San Francisco, CA' },
+    source: 'gps',
+    confidence: 0.9,
+    is_approximate: false,
+  },
+  context: {
+    timestamp: '2026-02-15T10:00:00Z',
+    source: { type: 'manual' },
+    participants: [{ user_id: 'user-owner', role: 'user' }],
+    environment: { device: 'laptop' },
+    notes: 'Written during morning coffee',
+  },
+  relationships: ['rel-1'],
+  access_count: 5,
+  last_accessed_at: '2026-02-20T08:00:00Z',
+  created_at: '2026-02-15T10:00:00Z',
+  updated_at: '2026-02-20T08:00:00Z',
+  version: 2,
+  tags: ['personal', 'reflection'],
+  references: ['https://private-blog.example.com/entry-1'],
+  base_weight: 0.5,
+};
+
+// Mock Weaviate collection
+function createMockCollection() {
+  const filterResult = { lessThanOrEqual: jest.fn().mockReturnValue('trust_filter') };
+  return {
+    filter: {
+      byProperty: jest.fn().mockReturnValue(filterResult),
+    },
+    _filterResult: filterResult,
+  };
+}
+
+// ─── buildTrustFilter ──────────────────────────────────────────────────────
+
+describe('buildTrustFilter', () => {
+  it('creates a filter for trust_score <= accessorTrustLevel', () => {
+    const collection = createMockCollection();
+    const result = buildTrustFilter(collection, 0.5);
+    expect(collection.filter.byProperty).toHaveBeenCalledWith('trust_score');
+    expect(collection._filterResult.lessThanOrEqual).toHaveBeenCalledWith(0.5);
+    expect(result).toBe('trust_filter');
+  });
+
+  it('works with trust level 0', () => {
+    const collection = createMockCollection();
+    buildTrustFilter(collection, 0);
+    expect(collection._filterResult.lessThanOrEqual).toHaveBeenCalledWith(0);
+  });
+
+  it('works with trust level 1 (includes trust 1.0 memories for acknowledgment)', () => {
+    const collection = createMockCollection();
+    buildTrustFilter(collection, 1.0);
+    expect(collection._filterResult.lessThanOrEqual).toHaveBeenCalledWith(1.0);
+  });
+});
+
+// ─── formatMemoryForPrompt ─────────────────────────────────────────────────
+
+describe('formatMemoryForPrompt', () => {
+  it('returns full content at trust 1.0', () => {
+    const result = formatMemoryForPrompt(mockMemory, 1.0);
+    expect(result.trust_tier).toBe('Full Access');
+    expect(result.content).toContain(mockMemory.content);
+    expect(result.content).toContain(mockMemory.title!);
+    expect(result.content).toContain(mockMemory.summary!);
+    expect(result.content).toContain('personal, reflection');
+    expect(result.content).toContain(mockMemory.created_at);
+    expect(result.memory_id).toBe('mem-1');
+  });
+
+  it('returns redacted content at trust 0.75', () => {
+    const result = formatMemoryForPrompt(mockMemory, 0.75);
+    expect(result.trust_tier).toBe('Partial Access');
+    expect(result.content).toContain(mockMemory.content);
+    expect(result.content).toContain('personal, reflection');
+    // Should not contain full summary (only in full access)
+    expect(result.content).not.toContain(mockMemory.summary!);
+  });
+
+  it('returns summary only at trust 0.5', () => {
+    const result = formatMemoryForPrompt(mockMemory, 0.5);
+    expect(result.trust_tier).toBe('Summary Only');
+    expect(result.content).toContain(mockMemory.title!);
+    expect(result.content).toContain(mockMemory.summary!);
+    expect(result.content).not.toContain(mockMemory.content);
+  });
+
+  it('returns (No summary available) when summary missing at trust 0.5', () => {
+    const noSummary = { ...mockMemory, summary: undefined };
+    const result = formatMemoryForPrompt(noSummary, 0.5);
+    expect(result.content).toContain('(No summary available)');
+  });
+
+  it('returns metadata only at trust 0.25', () => {
+    const result = formatMemoryForPrompt(mockMemory, 0.25);
+    expect(result.trust_tier).toBe('Metadata Only');
+    expect(result.content).toContain('[journal]');
+    expect(result.content).toContain('personal, reflection');
+    expect(result.content).not.toContain(mockMemory.content);
+    expect(result.content).not.toContain(mockMemory.summary!);
+  });
+
+  it('returns existence only at trust 0', () => {
+    const result = formatMemoryForPrompt(mockMemory, 0);
+    expect(result.trust_tier).toBe('Existence Only');
+    expect(result.content).toBe('A memory exists about this topic.');
+    expect(result.content).not.toContain(mockMemory.content);
+    expect(result.content).not.toContain(mockMemory.title!);
+  });
+
+  it('handles memory without title gracefully', () => {
+    const noTitle = { ...mockMemory, title: undefined };
+    const result = formatMemoryForPrompt(noTitle, 1.0);
+    expect(result.content).toContain('Untitled');
+  });
+
+  it('handles memory with empty tags', () => {
+    const noTags = { ...mockMemory, tags: [] };
+    const result = formatMemoryForPrompt(noTags, 1.0);
+    expect(result.content).not.toContain('Tags:');
+  });
+
+  describe('trust 1.0 memories (existence-only for cross-users)', () => {
+    const trust1Memory = { ...mockMemory, trust: 1.0 };
+
+    it('returns existence-only for cross-user even at accessor trust 1.0', () => {
+      const result = formatMemoryForPrompt(trust1Memory, 1.0);
+      expect(result.trust_tier).toBe('Existence Only');
+      expect(result.content).toBe('A memory exists about this topic.');
+    });
+
+    it('returns existence-only for cross-user at any trust level', () => {
+      for (const trust of [0, 0.25, 0.5, 0.75, 1.0]) {
+        const result = formatMemoryForPrompt(trust1Memory, trust);
+        expect(result.trust_tier).toBe('Existence Only');
+        expect(result.content).not.toContain(trust1Memory.content);
+      }
+    });
+
+    it('returns full content for owner (isSelfAccess = true)', () => {
+      const result = formatMemoryForPrompt(trust1Memory, 1.0, true);
+      expect(result.trust_tier).toBe('Full Access');
+      expect(result.content).toContain(trust1Memory.content);
+    });
+
+    it('does not leak title, summary, or tags for cross-user', () => {
+      const result = formatMemoryForPrompt(trust1Memory, 1.0);
+      expect(result.content).not.toContain(trust1Memory.title!);
+      expect(result.content).not.toContain(trust1Memory.summary!);
+      expect(result.content).not.toContain('personal');
+    });
+  });
+});
+
+// ─── getTrustLevelLabel ────────────────────────────────────────────────────
+
+describe('getTrustLevelLabel', () => {
+  it('returns Full Access at 1.0', () => {
+    expect(getTrustLevelLabel(1.0)).toBe('Full Access');
+  });
+
+  it('returns Partial Access at 0.75', () => {
+    expect(getTrustLevelLabel(0.75)).toBe('Partial Access');
+  });
+
+  it('returns Summary Only at 0.5', () => {
+    expect(getTrustLevelLabel(0.5)).toBe('Summary Only');
+  });
+
+  it('returns Metadata Only at 0.25', () => {
+    expect(getTrustLevelLabel(0.25)).toBe('Metadata Only');
+  });
+
+  it('returns Existence Only at 0', () => {
+    expect(getTrustLevelLabel(0)).toBe('Existence Only');
+  });
+
+  it('maps intermediate values to nearest lower threshold', () => {
+    expect(getTrustLevelLabel(0.9)).toBe('Partial Access');
+    expect(getTrustLevelLabel(0.6)).toBe('Summary Only');
+    expect(getTrustLevelLabel(0.3)).toBe('Metadata Only');
+    expect(getTrustLevelLabel(0.1)).toBe('Existence Only');
+  });
+});
+
+// ─── getTrustInstructions ──────────────────────────────────────────────────
+
+describe('getTrustInstructions', () => {
+  it('returns appropriate instructions for each tier', () => {
+    expect(getTrustInstructions(1.0)).toContain('full access');
+    expect(getTrustInstructions(0.75)).toContain('partial access');
+    expect(getTrustInstructions(0.5)).toContain('summary');
+    expect(getTrustInstructions(0.25)).toContain('metadata');
+    expect(getTrustInstructions(0)).toContain('acknowledge');
+  });
+});
+
+// ─── redactSensitiveFields ─────────────────────────────────────────────────
+
+describe('redactSensitiveFields', () => {
+  it('clears GPS and address from location', () => {
+    const redacted = redactSensitiveFields(mockMemory, 0.75);
+    expect(redacted.location.gps).toBeNull();
+    expect(redacted.location.address).toBeNull();
+    expect(redacted.location.source).toBe('unavailable');
+  });
+
+  it('clears context participants and environment', () => {
+    const redacted = redactSensitiveFields(mockMemory, 0.75);
+    expect(redacted.context.participants).toBeUndefined();
+    expect(redacted.context.environment).toBeUndefined();
+    expect(redacted.context.notes).toBeUndefined();
+  });
+
+  it('clears references', () => {
+    const redacted = redactSensitiveFields(mockMemory, 0.75);
+    expect(redacted.references).toBeUndefined();
+  });
+
+  it('preserves content and tags', () => {
+    const redacted = redactSensitiveFields(mockMemory, 0.75);
+    expect(redacted.content).toBe(mockMemory.content);
+    expect(redacted.tags).toEqual(mockMemory.tags);
+    expect(redacted.title).toBe(mockMemory.title);
+  });
+
+  it('preserves core context fields', () => {
+    const redacted = redactSensitiveFields(mockMemory, 0.75);
+    expect(redacted.context.timestamp).toBe(mockMemory.context.timestamp);
+    expect(redacted.context.source).toEqual(mockMemory.context.source);
+  });
+
+  it('does not mutate original memory', () => {
+    const originalLocation = mockMemory.location.gps;
+    redactSensitiveFields(mockMemory, 0.75);
+    expect(mockMemory.location.gps).toBe(originalLocation);
+  });
+});
+
+// ─── isTrustSufficient ─────────────────────────────────────────────────────
+
+describe('isTrustSufficient', () => {
+  it('returns true when accessor trust >= memory trust', () => {
+    expect(isTrustSufficient(0.5, 0.75)).toBe(true);
+    expect(isTrustSufficient(0.5, 0.5)).toBe(true);
+    expect(isTrustSufficient(0, 0)).toBe(true);
+    expect(isTrustSufficient(1.0, 1.0)).toBe(true);
+  });
+
+  it('returns false when accessor trust < memory trust', () => {
+    expect(isTrustSufficient(0.75, 0.5)).toBe(false);
+    expect(isTrustSufficient(1.0, 0.99)).toBe(false);
+    expect(isTrustSufficient(0.25, 0)).toBe(false);
+  });
+});
+
+// ─── resolveEnforcementMode ────────────────────────────────────────────────
+
+describe('resolveEnforcementMode', () => {
+  it('returns the provided mode', () => {
+    expect(resolveEnforcementMode('query')).toBe('query');
+    expect(resolveEnforcementMode('prompt')).toBe('prompt');
+    expect(resolveEnforcementMode('hybrid')).toBe('hybrid');
+  });
+
+  it('defaults to query when undefined', () => {
+    expect(resolveEnforcementMode(undefined)).toBe('query');
+  });
+});
+
+// ─── TRUST_THRESHOLDS ──────────────────────────────────────────────────────
+
+describe('TRUST_THRESHOLDS', () => {
+  it('has correct values', () => {
+    expect(TRUST_THRESHOLDS.FULL_ACCESS).toBe(1.0);
+    expect(TRUST_THRESHOLDS.PARTIAL_ACCESS).toBe(0.75);
+    expect(TRUST_THRESHOLDS.SUMMARY_ONLY).toBe(0.5);
+    expect(TRUST_THRESHOLDS.METADATA_ONLY).toBe(0.25);
+    expect(TRUST_THRESHOLDS.EXISTENCE_ONLY).toBe(0.0);
+  });
+});

package/src/services/trust-enforcement.ts

@@ -0,0 +1,197 @@
+/**
+ * Trust enforcement service — 3 configurable modes for cross-user memory access.
+ *
+ * - query mode (default): memories above trust threshold never returned from Weaviate
+ * - prompt mode: all memories returned, formatted/redacted by trust level
+ * - hybrid mode: query filter for trust 0.0, prompt filter for rest
+ *
+ * See agent/design/local.ghost-persona-system.md
+ */
+
+import type { Memory } from '../types/memory.js';
+import type { TrustEnforcementMode } from '../types/ghost-config.js';
+
+// ─── Trust Level Thresholds ────────────────────────────────────────────────
+
+/** Trust level thresholds mapping continuous 0-1 values to discrete behavior tiers */
+export const TRUST_THRESHOLDS = {
+  FULL_ACCESS: 1.0,
+  PARTIAL_ACCESS: 0.75,
+  SUMMARY_ONLY: 0.5,
+  METADATA_ONLY: 0.25,
+  EXISTENCE_ONLY: 0.0,
+} as const;
+
+// ─── Query-Level Enforcement ───────────────────────────────────────────────
+
+/**
+ * Build a Weaviate filter that restricts memories by trust score.
+ * Only returns memories where trust_score <= accessorTrustLevel.
+ *
+ * Trust 1.0 memories require accessor trust >= 1.0 to even appear in results.
+ * When they do appear, formatMemoryForPrompt caps output to existence-only.
+ *
+ * @param collection - Weaviate collection instance
+ * @param accessorTrustLevel - The accessor's trust level (0-1)
+ * @returns Weaviate filter object
+ */
+export function buildTrustFilter(collection: any, accessorTrustLevel: number): any {
+  return collection.filter.byProperty('trust_score').lessThanOrEqual(accessorTrustLevel);
+}
+
+// ─── Prompt-Level Enforcement ──────────────────────────────────────────────
+
+/**
+ * Formatted memory representation for prompt-level enforcement.
+ * Content is redacted/formatted based on trust level.
+ */
+export interface FormattedMemory {
+  memory_id: string;
+  trust_tier: string;
+  content: string;
+}
+
+/**
+ * Format a memory for inclusion in an LLM prompt, redacted by trust level.
+ *
+ * Trust tiers:
+ * - 1.0  Full Access:    full content, all details
+ * - 0.75 Partial Access: content with sensitive fields redacted
+ * - 0.5  Summary Only:   title + summary, no content
+ * - 0.25 Metadata Only:  type, date, tags — no content or summary
+ * - 0.0  Existence Only: "A memory exists about this topic"
+ *
+ * Trust 1.0 memories are always existence-only for cross-users, regardless of
+ * accessor trust level. Use `isSelfAccess = true` to bypass for owner access.
+ *
+ * @param memory - The memory to format
+ * @param accessorTrustLevel - The accessor's trust level (0-1)
+ * @param isSelfAccess - True if the accessor is the memory owner (bypasses trust 1.0 cap)
+ * @returns Formatted memory for prompt inclusion
+ */
+export function formatMemoryForPrompt(memory: Memory, accessorTrustLevel: number, isSelfAccess = false): FormattedMemory {
+  // Trust 1.0 = existence-only for cross-users (acknowledged but never revealed)
+  if (!isSelfAccess && memory.trust >= 1.0) {
+    return {
+      memory_id: memory.id,
+      trust_tier: 'Existence Only',
+      content: 'A memory exists about this topic.',
+    };
+  }
+
+  const tier = getTrustLevelLabel(accessorTrustLevel);
+
+  if (accessorTrustLevel >= TRUST_THRESHOLDS.FULL_ACCESS) {
+    // Full Access — all content
+    const parts = [`[${memory.type}] ${memory.title || 'Untitled'}`];
+    parts.push(memory.content);
+    if (memory.summary) parts.push(`Summary: ${memory.summary}`);
+    if (memory.tags.length > 0) parts.push(`Tags: ${memory.tags.join(', ')}`);
+    if (memory.created_at) parts.push(`Created: ${memory.created_at}`);
+    return { memory_id: memory.id, trust_tier: tier, content: parts.join('\n') };
+  }
+
+  if (accessorTrustLevel >= TRUST_THRESHOLDS.PARTIAL_ACCESS) {
+    // Partial Access — redact sensitive fields
+    const redacted = redactSensitiveFields(memory, accessorTrustLevel);
+    const parts = [`[${redacted.type}] ${redacted.title || 'Untitled'}`];
+    parts.push(redacted.content);
+    if (redacted.tags.length > 0) parts.push(`Tags: ${redacted.tags.join(', ')}`);
+    return { memory_id: memory.id, trust_tier: tier, content: parts.join('\n') };
+  }
+
+  if (accessorTrustLevel >= TRUST_THRESHOLDS.SUMMARY_ONLY) {
+    // Summary Only — title + summary, no content body
+    const parts = [`[${memory.type}] ${memory.title || 'Untitled'}`];
+    if (memory.summary) {
+      parts.push(memory.summary);
+    } else {
+      parts.push('(No summary available)');
+    }
+    return { memory_id: memory.id, trust_tier: tier, content: parts.join('\n') };
+  }
+
+  if (accessorTrustLevel >= TRUST_THRESHOLDS.METADATA_ONLY) {
+    // Metadata Only — type, date, tags
+    const parts = [`[${memory.type}]`];
+    if (memory.created_at) parts.push(`Created: ${memory.created_at}`);
+    if (memory.tags.length > 0) parts.push(`Tags: ${memory.tags.join(', ')}`);
+    return { memory_id: memory.id, trust_tier: tier, content: parts.join('\n') };
+  }
+
+  // Existence Only — minimal hint
+  return {
+    memory_id: memory.id,
+    trust_tier: tier,
+    content: 'A memory exists about this topic.',
+  };
+}
+
+// ─── Shared Utilities ──────────────────────────────────────────────────────
+
+/**
+ * Get a human-readable label for a trust level.
+ */
+export function getTrustLevelLabel(trust: number): string {
+  if (trust >= TRUST_THRESHOLDS.FULL_ACCESS) return 'Full Access';
+  if (trust >= TRUST_THRESHOLDS.PARTIAL_ACCESS) return 'Partial Access';
+  if (trust >= TRUST_THRESHOLDS.SUMMARY_ONLY) return 'Summary Only';
+  if (trust >= TRUST_THRESHOLDS.METADATA_ONLY) return 'Metadata Only';
+  return 'Existence Only';
+}
+
+/**
+ * Get LLM instruction text describing what to reveal at a given trust level.
+ */
+export function getTrustInstructions(trust: number): string {
+  if (trust >= TRUST_THRESHOLDS.FULL_ACCESS) {
+    return 'You have full access to this memory. Share all content and details freely.';
+  }
+  if (trust >= TRUST_THRESHOLDS.PARTIAL_ACCESS) {
+    return 'You have partial access. Share the main content but do not reveal sensitive personal details like exact locations, contact information, or financial data.';
+  }
+  if (trust >= TRUST_THRESHOLDS.SUMMARY_ONLY) {
+    return 'You have summary-level access. Share the title and summary only. Do not reveal the full content of this memory.';
+  }
+  if (trust >= TRUST_THRESHOLDS.METADATA_ONLY) {
+    return 'You have metadata-level access only. You may mention the type, date, and tags, but do not reveal any content or summary.';
+  }
+  return 'You may only acknowledge that a memory exists about this topic. Do not reveal any details.';
+}
+
+/**
+ * Redact sensitive fields from a memory for partial access.
+ * Returns a copy with location, context, and references cleared.
+ */
+export function redactSensitiveFields(memory: Memory, _trust: number): Memory {
+  return {
+    ...memory,
+    // Clear sensitive location data
+    location: { gps: null, address: null, source: 'unavailable', confidence: 0, is_approximate: true },
+    // Strip context details
+    context: {
+      ...memory.context,
+      participants: undefined,
+      environment: undefined,
+      notes: undefined,
+    },
+    // Clear references (may contain private URLs)
+    references: undefined,
+  };
+}
+
+/**
+ * Check whether an accessor's trust level is sufficient for a memory.
+ * Access is granted when accessorTrust >= memoryTrust.
+ */
+export function isTrustSufficient(memoryTrust: number, accessorTrust: number): boolean {
+  return accessorTrust >= memoryTrust;
+}
+
+/**
+ * Determine the enforcement mode to use.
+ * Convenience function that returns the mode from GhostConfig or falls back to 'query'.
+ */
+export function resolveEnforcementMode(mode?: TrustEnforcementMode): TrustEnforcementMode {
+  return mode ?? 'query';
+}

package/src/services/trust-validator.spec.ts

@@ -0,0 +1,108 @@
+import { validateTrustAssignment, suggestTrustLevel } from './trust-validator.js';
+
+describe('validateTrustAssignment', () => {
+  it('accepts trust levels in valid range', () => {
+    expect(validateTrustAssignment(0).valid).toBe(true);
+    expect(validateTrustAssignment(0.5).valid).toBe(true);
+    expect(validateTrustAssignment(1.0).valid).toBe(true);
+  });
+
+  it('rejects trust levels below 0', () => {
+    const result = validateTrustAssignment(-0.1);
+    expect(result.valid).toBe(false);
+    expect(result.warning).toContain('-0.1');
+  });
+
+  it('rejects trust levels above 1', () => {
+    const result = validateTrustAssignment(1.5);
+    expect(result.valid).toBe(false);
+    expect(result.warning).toContain('1.5');
+  });
+
+  it('warns for trust < 0.25', () => {
+    const result = validateTrustAssignment(0.1);
+    expect(result.valid).toBe(true);
+    expect(result.warning).toContain('very restrictive');
+  });
+
+  it('warns for trust 0', () => {
+    const result = validateTrustAssignment(0);
+    expect(result.valid).toBe(true);
+    expect(result.warning).toContain('very restrictive');
+  });
+
+  it('does not warn for trust >= 0.25', () => {
+    expect(validateTrustAssignment(0.25).warning).toBeUndefined();
+    expect(validateTrustAssignment(0.5).warning).toBeUndefined();
+    expect(validateTrustAssignment(1.0).warning).toBeUndefined();
+  });
+});
+
+describe('suggestTrustLevel', () => {
+  describe('tag overrides', () => {
+    it('returns 0.1 for private tag', () => {
+      expect(suggestTrustLevel('note', ['private'])).toBe(0.1);
+    });
+
+    it('returns 0.1 for secret tag', () => {
+      expect(suggestTrustLevel('note', ['Secret'])).toBe(0.1);
+    });
+
+    it('returns 1.0 for public tag', () => {
+      expect(suggestTrustLevel('journal', ['public'])).toBe(1.0);
+    });
+
+    it('tag override takes priority over content type', () => {
+      // journal normally suggests 0.75, but 'private' overrides to 0.1
+      expect(suggestTrustLevel('journal', ['private'])).toBe(0.1);
+    });
+  });
+
+  describe('content type suggestions', () => {
+    it('suggests 0.75 for personal types', () => {
+      expect(suggestTrustLevel('journal')).toBe(0.75);
+      expect(suggestTrustLevel('memory')).toBe(0.75);
+      expect(suggestTrustLevel('event')).toBe(0.75);
+    });
+
+    it('suggests 0.5 for system types', () => {
+      expect(suggestTrustLevel('system')).toBe(0.5);
+      expect(suggestTrustLevel('audit')).toBe(0.5);
+      expect(suggestTrustLevel('action')).toBe(0.5);
+      expect(suggestTrustLevel('history')).toBe(0.5);
+    });
+
+    it('suggests 0.5 for business types', () => {
+      expect(suggestTrustLevel('invoice')).toBe(0.5);
+      expect(suggestTrustLevel('contract')).toBe(0.5);
+    });
+
+    it('suggests 0.5 for communication types', () => {
+      expect(suggestTrustLevel('email')).toBe(0.5);
+      expect(suggestTrustLevel('conversation')).toBe(0.5);
+      expect(suggestTrustLevel('meeting')).toBe(0.5);
+    });
+
+    it('suggests 0.75 for ghost type', () => {
+      expect(suggestTrustLevel('ghost')).toBe(0.75);
+    });
+
+    it('suggests 0.25 for general/creative types', () => {
+      expect(suggestTrustLevel('note')).toBe(0.25);
+      expect(suggestTrustLevel('code')).toBe(0.25);
+      expect(suggestTrustLevel('article')).toBe(0.25);
+      expect(suggestTrustLevel('recipe')).toBe(0.25);
+      expect(suggestTrustLevel('bookmark')).toBe(0.25);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('handles empty tags array', () => {
+      expect(suggestTrustLevel('note', [])).toBe(0.25);
+    });
+
+    it('handles undefined tags', () => {
+      expect(suggestTrustLevel('note')).toBe(0.25);
+    });
+  });
+});