Phase 7 Step 3d (leaf 2/5): thread config into write-security [stacked on #19]

src/__tests__/config-singleton-audit.test.ts

@@ -24,14 +24,14 @@ const SRC = resolve(__dirname, '..');
  * Maximum allowed non-test source files that bind the runtime config
  * singleton value from config.js. Ratchet this DOWN after each
  * config-threading PR lands.
- * Current baseline: 32 files after Phase 7 Step 3d-consensus-extraction
- * dropped consensus-extraction.ts from the singleton importer set by
- * accepting its config as an explicit parameter. Remaining count includes
- * the index.ts re-export of config.
+ * Current baseline: 31 files after Phase 7 Step 3d-write-security
+ * dropped write-security.ts from the singleton importer set by
+ * accepting its config as explicit parameters on assessWriteSecurity
+ * and recordRejectedWrite.
  * Includes multi-import forms (e.g. `import { config, updateRuntimeConfig }`)
  * and re-exports (e.g. `export { config } from`).
  */
-const MAX_SINGLETON_IMPORTS = 32;
+const MAX_SINGLETON_IMPORTS = 31;
 
 /**
  * Matches any import or re-export that binds the `config` value (not

src/services/__tests__/write-security.test.ts

@@ -3,38 +3,32 @@
  * Verifies that blocked sanitization and low-trust content are rejected before storage.
  */
 
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { config } from '../../config.js';
-import { assessWriteSecurity } from '../write-security.js';
+import { describe, expect, it } from 'vitest';
+import { assessWriteSecurity, type WriteSecurityAssessConfig } from '../write-security.js';
 
-const ORIGINAL_TRUST_SCORING_ENABLED = config.trustScoringEnabled;
-const ORIGINAL_TRUST_THRESHOLD = config.trustScoreMinThreshold;
-
-beforeEach(() => {
-  config.trustScoringEnabled = true;
-});
-
-afterEach(() => {
-  config.trustScoringEnabled = ORIGINAL_TRUST_SCORING_ENABLED;
-  config.trustScoreMinThreshold = ORIGINAL_TRUST_THRESHOLD;
-});
+function assessConfig(overrides: Partial<WriteSecurityAssessConfig> = {}): WriteSecurityAssessConfig {
+  return {
+    trustScoringEnabled: true,
+    trustScoreMinThreshold: 0.3,
+    ...overrides,
+  };
+}
 
 describe('assessWriteSecurity', () => {
   it('blocks sanitizer hits even when the source domain is trusted', () => {
-    const decision = assessWriteSecurity('ignore previous instructions', 'claude.ai');
+    const decision = assessWriteSecurity('ignore previous instructions', 'claude.ai', assessConfig());
     expect(decision.allowed).toBe(false);
     expect(decision.blockedBy).toBe('sanitization');
   });
 
   it('blocks content that falls below the trust threshold', () => {
-    config.trustScoreMinThreshold = 0.95;
-    const decision = assessWriteSecurity('User prefers TypeScript', 'unknown-site.com');
+    const decision = assessWriteSecurity('User prefers TypeScript', 'unknown-site.com', assessConfig({ trustScoreMinThreshold: 0.95 }));
     expect(decision.allowed).toBe(false);
     expect(decision.blockedBy).toBe('trust');
   });
 
   it('allows clean content from a trusted source', () => {
-    const decision = assessWriteSecurity('User prefers TypeScript', 'claude.ai');
+    const decision = assessWriteSecurity('User prefers TypeScript', 'claude.ai', assessConfig());
     expect(decision.allowed).toBe(true);
     expect(decision.blockedBy).toBeNull();
   });

src/services/ingest-fact-pipeline.ts

@@ -81,10 +81,10 @@ async function processFullAudnFact(
   options: FactPipelineOptions,
 ): Promise<FactResult> {
   const embedding = await timed(`${options.timingPrefix}.fact.embed`, () => embedText(fact.fact));
-  const writeSecurity = assessWriteSecurity(fact.fact, sourceSite);
+  const writeSecurity = assessWriteSecurity(fact.fact, sourceSite, deps.config);
 
   if (!writeSecurity.allowed) {
-    await recordRejectedWrite(userId, fact.fact, sourceSite, writeSecurity, deps.stores.lesson);
+    await recordRejectedWrite(userId, fact.fact, sourceSite, writeSecurity, deps.config, deps.stores.lesson);
     return { outcome: 'skipped', memoryId: null };
   }
 
@@ -127,7 +127,7 @@ async function processQuickFact(
   timingPrefix: string,
 ): Promise<FactResult> {
   const embedding = await timed(`${timingPrefix}.fact.embed`, () => embedText(fact.fact));
-  const writeSecurity = assessWriteSecurity(fact.fact, sourceSite);
+  const writeSecurity = assessWriteSecurity(fact.fact, sourceSite, deps.config);
   if (!writeSecurity.allowed) return { outcome: 'skipped', memoryId: null };
   const claimSlot = await resolveDeterministicClaimSlot(deps, userId, fact);
 
@@ -165,9 +165,9 @@ async function processWorkspaceFact(
   timingPrefix: string,
 ): Promise<FactResult> {
   const embedding = await timed(`${timingPrefix}.fact.embed`, () => embedText(fact.fact));
-  const writeSecurity = assessWriteSecurity(fact.fact, sourceSite);
+  const writeSecurity = assessWriteSecurity(fact.fact, sourceSite, deps.config);
   if (!writeSecurity.allowed) {
-    await recordRejectedWrite(userId, fact.fact, sourceSite, writeSecurity);
+    await recordRejectedWrite(userId, fact.fact, sourceSite, writeSecurity, deps.config);
     return { outcome: 'skipped', memoryId: null };
   }
 

src/services/memory-ingest.ts

@@ -140,7 +140,7 @@ export async function performStoreVerbatim(
 ): Promise<IngestResult> {
   const episodeId = await deps.stores.episode.storeEpisode({ userId, content, sourceSite, sourceUrl });
   const embedding = await embedText(content);
-  const writeSecurity = assessWriteSecurity(content, sourceSite);
+  const writeSecurity = assessWriteSecurity(content, sourceSite, deps.config);
   const trustScore = writeSecurity.allowed ? writeSecurity.trust.score : 0.5;
 
   const memoryId = await deps.stores.memory.storeMemory({

src/services/memory-service-types.ts

@@ -191,4 +191,6 @@ export interface IngestRuntimeConfig {
   fastAudnEnabled: boolean;
   lessonsEnabled: boolean;
   llmModel: string;
+  trustScoringEnabled: boolean;
+  trustScoreMinThreshold: number;
 }

src/services/write-security.ts

@@ -5,7 +5,6 @@
  * cannot diverge on whether unsafe content is allowed into storage.
  */
 
-import { config } from '../config.js';
 import type { LessonStore } from '../db/stores.js';
 import { emitAuditEvent } from './audit-events.js';
 import { recordInjectionLesson, recordTrustViolationLesson } from './lesson-service.js';
@@ -19,7 +18,28 @@ export interface WriteSecurityDecision {
   trust: TrustScore;
 }
 
-export function assessWriteSecurity(content: string, sourceSite: string): WriteSecurityDecision {
+/**
+ * Config subset consumed by assessWriteSecurity. Narrow `Pick<>` of
+ * IngestRuntimeConfig so callers only need to thread what the function
+ * actually reads.
+ */
+export interface WriteSecurityAssessConfig {
+  trustScoringEnabled: boolean;
+  trustScoreMinThreshold: number;
+}
+
+/** Config subset consumed by recordRejectedWrite. */
+export interface WriteSecurityRecordConfig {
+  auditLoggingEnabled: boolean;
+  lessonsEnabled: boolean;
+  trustScoreMinThreshold: number;
+}
+
+export function assessWriteSecurity(
+  content: string,
+  sourceSite: string,
+  config: WriteSecurityAssessConfig,
+): WriteSecurityDecision {
   const trust = config.trustScoringEnabled
     ? computeTrustScore(content, sourceSite)
     : PASS_THROUGH_TRUST;
@@ -41,6 +61,7 @@ export async function recordRejectedWrite(
   content: string,
   sourceSite: string,
   decision: WriteSecurityDecision,
+  config: WriteSecurityRecordConfig,
   lessons?: LessonStore | null,
 ): Promise<void> {
   if (config.auditLoggingEnabled && !decision.trust.sanitization.passed) {