claude-memory-layer 1.0.46 → 1.0.47

package/dist/core/index.js

@@ -2622,6 +2622,7 @@ var VectorOutbox = class {
 // src/core/retrieval-debug-lanes.ts
 var RETRIEVAL_DEBUG_LANE_NAMES = [
   "raw_event",
+  "session_event",
   "session_summary",
   "graph_path",
   "facet_match"
@@ -11046,6 +11047,7 @@ var Retriever = class {
   }
   async retrieve(query, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
+    const retrievalMode = options.retrievalMode ?? ((options.strategy ?? DEFAULT_OPTIONS.strategy) === "auto" ? "session-event-hybrid" : "event");
     const sessionFilter = opts.scope?.sessionId ?? opts.sessionId;
     const fallbackTrace = [];
     const qualityQuery = buildRetrievalQualityQuery(query);
@@ -11076,6 +11078,7 @@ var Retriever = class {
       decayPolicy: opts.decayPolicy,
       intentRewrite: opts.intentRewrite === true,
       graphHop: opts.graphHop,
+      retrievalMode,
       projectScopeMode: opts.projectScopeMode,
       projectHash: opts.projectHash,
       allowedProjectHashes: opts.allowedProjectHashes,
@@ -11094,6 +11097,7 @@ var Retriever = class {
         rerankWeights: opts.rerankWeights,
         decayPolicy: opts.decayPolicy,
         graphHop: opts.graphHop,
+        retrievalMode,
         projectScopeMode: opts.projectScopeMode,
         projectHash: opts.projectHash,
         allowedProjectHashes: opts.allowedProjectHashes,
@@ -11113,6 +11117,7 @@ var Retriever = class {
         rerankWeights: opts.rerankWeights,
         decayPolicy: opts.decayPolicy,
         graphHop: opts.graphHop,
+        retrievalMode,
         projectScopeMode: opts.projectScopeMode,
         projectHash: opts.projectHash,
         allowedProjectHashes: opts.allowedProjectHashes,
@@ -11133,10 +11138,26 @@ var Retriever = class {
         query,
         minScore: opts.minScore
       });
+      const expandedSummary = retrievalMode === "session-event-hybrid" ? await this.expandSessionEventHybrid(filteredSummary, {
+        query: qualityQuery,
+        currentStateQuery: query,
+        limit: opts.topK * 4
+      }) : filteredSummary;
+      const scopedExpandedSummary = retrievalMode === "session-event-hybrid" ? await this.applyScopeFilters(expandedSummary, {
+        scope: opts.scope,
+        projectScopeMode: opts.projectScopeMode,
+        projectHash: opts.projectHash,
+        allowedProjectHashes: opts.allowedProjectHashes,
+        facets: opts.facets
+      }) : expandedSummary;
+      const finalSummary = retrievalMode === "session-event-hybrid" ? this.applyQualityFilters(scopedExpandedSummary, {
+        query,
+        minScore: opts.minScore
+      }) : scopedExpandedSummary;
       current = {
-        results: filteredSummary,
-        candidateResults: filteredSummary,
-        matchResult: this.matcher.matchSearchResults(filteredSummary, () => 0)
+        results: finalSummary,
+        candidateResults: finalSummary,
+        matchResult: this.matcher.matchSearchResults(finalSummary, () => 0)
       };
       fallbackTrace.push("fallback:summary");
     }
@@ -11222,13 +11243,18 @@ var Retriever = class {
         initialResults = this.mergeResults(initialResults, rewrittenResults, input.topK * 3);
       }
     }
-    const expandedResults = input.graphHop?.enabled === false ? initialResults : await this.expandGraphHops(initialResults, {
+    const graphExpandedResults = input.graphHop?.enabled === false ? initialResults : await this.expandGraphHops(initialResults, {
       query,
       queryGraphEnabled: this.queryGraphExpansionEnabled,
       maxHops: clampGraphHops(input.graphHop?.maxHops ?? 1),
       hopPenalty: Math.max(0, input.graphHop?.hopPenalty ?? 0.08),
       limit: input.topK * 4
     });
+    const expandedResults = input.retrievalMode === "session-event-hybrid" ? await this.expandSessionEventHybrid(graphExpandedResults, {
+      query: rerankQuery,
+      currentStateQuery: query,
+      limit: input.topK * 4
+    }) : graphExpandedResults;
     const rerankedResults = input.rerankWithKeyword ? this.rerankByKeywordOverlap(expandedResults, rerankQuery, input.rerankWeights, input.decayPolicy) : expandedResults;
     const filtered = await this.applyScopeFilters(rerankedResults, {
       scope: input.scope,
@@ -11276,6 +11302,47 @@ var Retriever = class {
     }
     return [...byId.values()].sort((a, b) => b.score - a.score).slice(0, limit);
   }
+  async expandSessionEventHybrid(seeds, opts) {
+    if (seeds.length === 0 || opts.limit <= seeds.length) return seeds;
+    const queryTokens = this.tokenize(opts.query);
+    if (queryTokens.length === 0) return seeds;
+    const byId = /* @__PURE__ */ new Map();
+    for (const seed of seeds) byId.set(seed.eventId, seed);
+    const bestSeedBySession = /* @__PURE__ */ new Map();
+    for (const seed of [...seeds].sort((a, b) => b.score - a.score || compareStable(a.eventId, b.eventId))) {
+      if (!seed.sessionId || bestSeedBySession.has(seed.sessionId)) continue;
+      bestSeedBySession.set(seed.sessionId, seed);
+    }
+    const suppressStaleState = isCurrentStateQuery(opts.currentStateQuery);
+    for (const [sessionId, seed] of bestSeedBySession) {
+      const sessionEvents = await this.eventStore.getSessionEvents(sessionId);
+      for (const event of [...sessionEvents].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime())) {
+        if (byId.has(event.id)) continue;
+        if (isLowSignalContextContent(event.content)) continue;
+        if (suppressStaleState && isStaleOrSupersededContent(event.content)) continue;
+        const lexicalScore = this.keywordOverlap(queryTokens, this.tokenize(event.content));
+        if (lexicalScore <= 0) continue;
+        if (shouldApplyTechnicalGuard(opts.query) && !hasTechnicalTermOverlap(opts.query, event.content)) continue;
+        const score = Math.min(0.95, Math.max(0.35, seed.score * 0.72 + lexicalScore * 0.28));
+        const row = withRetrievalLane({
+          id: `session-event-${seed.eventId}-${event.id}`,
+          eventId: event.id,
+          content: event.content,
+          score,
+          sessionId: event.sessionId,
+          eventType: event.eventType,
+          timestamp: event.timestamp.toISOString(),
+          semanticScore: seed.semanticScore ?? seed.score,
+          lexicalScore,
+          recencyScore: seed.recencyScore
+        }, { lane: "session_event", reason: `same_session:${seed.eventId}`, score });
+        byId.set(row.eventId, row);
+        if (byId.size >= opts.limit) break;
+      }
+      if (byId.size >= opts.limit) break;
+    }
+    return [...byId.values()].sort((a, b) => b.score - a.score || compareStable(a.eventId, b.eventId)).slice(0, opts.limit);
+  }
   async expandGraphHops(seeds, opts) {
     const byId = /* @__PURE__ */ new Map();
     for (const s of seeds) byId.set(s.eventId, s);
@@ -17286,6 +17353,985 @@ function renderProductValidationMatrixMarkdown(matrix = productValidationMatrix)
 `;
 }
 
+// src/core/source/source-schema.ts
+var SOURCE_PRIVACY_CLASSES = Object.freeze(["public", "internal", "confidential", "restricted"]);
+var SOURCE_CAPTURE_MODES = Object.freeze(["snapshot", "append-only-log", "stream", "metadata-only", "history_import"]);
+var SourceContractValidationError = class extends Error {
+  violations;
+  constructor(violations) {
+    super(`Source contract validation failed: ${violations.map((violation2) => violation2.code).join(", ")}`);
+    this.name = "SourceContractValidationError";
+    this.violations = violations;
+  }
+};
+function isSourcePrivacyClass(value) {
+  return isOneOf(SOURCE_PRIVACY_CLASSES, value);
+}
+function isSourceCaptureMode(value) {
+  return isOneOf(SOURCE_CAPTURE_MODES, value);
+}
+function defineSourceSchema(schema) {
+  const prepared = prepareSourceSchema(schema);
+  if (prepared.violations.length > 0 || !prepared.record) {
+    throw new SourceContractValidationError(prepared.violations);
+  }
+  return Object.freeze(freezeSourceSchemaDeclaration(prepared.record));
+}
+function validateSourceSchema(schema, path8 = "source") {
+  return prepareSourceSchema(schema, path8).violations;
+}
+function prepareSourceSchema(schema, path8 = "source") {
+  const snapshot = snapshotAllowedRecordFields(schema, ["id", "version", "privacyClass", "captureMode", "description", "metadataSchema"], {
+    path: path8,
+    requiredCode: "source.required",
+    requiredMessage: "Source schema declaration is required.",
+    unknownCode: "source.unknown_field",
+    unknownMessage: "Source schema declaration contains unsupported fields.",
+    accessorCode: "source.accessor_field",
+    accessorMessage: "Source schema declaration fields must be data properties."
+  });
+  if (!snapshot.record) return snapshot;
+  return {
+    record: snapshot.record,
+    violations: validateSourceSchemaRecord(snapshot.record, path8, snapshot.violations)
+  };
+}
+function validateSourceSchemaRecord(schema, path8, initialViolations) {
+  const violations = [...initialViolations];
+  const id = getOwnField(schema, "id");
+  const version = getOwnField(schema, "version");
+  const privacyClass = getOwnField(schema, "privacyClass");
+  const captureMode = getOwnField(schema, "captureMode");
+  const description = getOwnField(schema, "description");
+  const metadataSchema = getOwnField(schema, "metadataSchema");
+  if (!hasText(id)) {
+    violations.push(violation("source.id.required", `${path8}.id`, "Source schema id must be non-empty."));
+  } else {
+    if (!isStableContractIdentifier(id)) {
+      violations.push(violation("source.id.unstable", `${path8}.id`, "Source schema id must be stable and must not include a local absolute path."));
+    }
+    if (looksLikePrivacySensitiveSourceValue(id)) {
+      violations.push(violation("source.id.privacy_sensitive", `${path8}.id`, "Source schema id must not leak local state handles or credential-shaped values."));
+    }
+  }
+  if (!hasText(version)) {
+    violations.push(violation("source.version.required", `${path8}.version`, "Source schema version must be non-empty."));
+  } else if (looksLikePrivacySensitiveSourceValue(version)) {
+    violations.push(violation("source.version.privacy_sensitive", `${path8}.version`, "Source schema version must not leak local state handles or credential-shaped values."));
+  }
+  if (!isSourcePrivacyClass(privacyClass)) {
+    violations.push(violation("source.privacyClass.invalid", `${path8}.privacyClass`, "Source schema privacyClass must be one of the bounded source privacy classes."));
+  }
+  if (!isSourceCaptureMode(captureMode)) {
+    violations.push(violation("source.captureMode.invalid", `${path8}.captureMode`, "Source schema captureMode must be one of the bounded source capture modes."));
+  }
+  if (description !== void 0 && typeof description !== "string") {
+    violations.push(violation("source.description.invalid", `${path8}.description`, "Source schema description must be a string when present."));
+  } else if (hasText(description) && looksLikePrivacySensitiveSourceValue(description)) {
+    violations.push(violation("source.description.privacy_sensitive", `${path8}.description`, "Source schema description must not leak local state handles or credential-shaped values."));
+  }
+  if (metadataSchema !== void 0 && typeof metadataSchema !== "string") {
+    violations.push(violation("source.metadataSchema.invalid", `${path8}.metadataSchema`, "Source schema metadataSchema must be a string when present."));
+  } else if (hasText(metadataSchema) && looksLikePrivacySensitiveSourceValue(metadataSchema)) {
+    violations.push(violation("source.metadataSchema.privacy_sensitive", `${path8}.metadataSchema`, "Source schema metadataSchema must not leak local state handles or credential-shaped values."));
+  }
+  return violations;
+}
+function freezeSourceSchemaDeclaration(schema) {
+  const id = getOwnField(schema, "id");
+  const version = getOwnField(schema, "version");
+  const privacyClass = getOwnField(schema, "privacyClass");
+  const captureMode = getOwnField(schema, "captureMode");
+  const ownDescription = getOwnField(schema, "description");
+  const ownMetadataSchema = getOwnField(schema, "metadataSchema");
+  const defined = {
+    id,
+    version,
+    privacyClass,
+    captureMode
+  };
+  if (ownDescription !== void 0) defined.description = ownDescription;
+  if (ownMetadataSchema !== void 0) defined.metadataSchema = ownMetadataSchema;
+  return defined;
+}
+function hasText(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isArrayForSourceSnapshot(value) {
+  try {
+    return Array.isArray(value);
+  } catch {
+    return false;
+  }
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !isArrayForSourceSnapshot(value);
+}
+function hasOwnField(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+function getOwnField(record, key) {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(record, key);
+    return descriptor && "value" in descriptor ? descriptor.value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function safeOwnKeysForSourceSnapshot(value, path8, code, message) {
+  try {
+    return { keys: Reflect.ownKeys(value), violations: [] };
+  } catch {
+    return { keys: [], violations: [violation(code, path8, message)] };
+  }
+}
+function safeGetOwnPropertyDescriptorForSourceSnapshot(value, key, path8, code, message) {
+  try {
+    return { descriptor: Object.getOwnPropertyDescriptor(value, key), violations: [] };
+  } catch {
+    return { violations: [violation(code, path8, message)] };
+  }
+}
+function safeReadOwnDataPropertyForSourceSnapshot(value, key, descriptor, path8, code, message) {
+  if (!("value" in descriptor)) {
+    return { violations: [violation(code, path8, message)] };
+  }
+  try {
+    const readValue = Reflect.get(value, key, value);
+    if (!Object.is(readValue, descriptor.value)) {
+      return { violations: [violation(code, path8, message)] };
+    }
+    return { value: descriptor.value, violations: [] };
+  } catch {
+    return { violations: [violation(code, path8, message)] };
+  }
+}
+function snapshotAllowedRecordFields(value, allowedFields, options) {
+  if (!isRecord6(value)) {
+    return {
+      record: void 0,
+      violations: [violation(options.requiredCode, options.path, options.requiredMessage)]
+    };
+  }
+  const allowed = new Set(allowedFields);
+  const record = /* @__PURE__ */ Object.create(null);
+  const keySnapshot = safeOwnKeysForSourceSnapshot(value, options.path, options.accessorCode, options.accessorMessage);
+  const violations = [...keySnapshot.violations];
+  for (const key of keySnapshot.keys) {
+    if (typeof key !== "string" || !allowed.has(key)) {
+      violations.push(violation(options.unknownCode, options.path, options.unknownMessage));
+      continue;
+    }
+    const descriptorSnapshot = safeGetOwnPropertyDescriptorForSourceSnapshot(value, key, `${options.path}.${key}`, options.accessorCode, options.accessorMessage);
+    violations.push(...descriptorSnapshot.violations);
+    const descriptor = descriptorSnapshot.descriptor;
+    if (!descriptor || !("value" in descriptor)) {
+      violations.push(violation(options.accessorCode, `${options.path}.${key}`, options.accessorMessage));
+      continue;
+    }
+    const readSnapshot = safeReadOwnDataPropertyForSourceSnapshot(value, key, descriptor, `${options.path}.${key}`, options.accessorCode, options.accessorMessage);
+    violations.push(...readSnapshot.violations);
+    if (readSnapshot.violations.length > 0) continue;
+    record[key] = readSnapshot.value;
+  }
+  return { record, violations };
+}
+function isStableContractIdentifier(value) {
+  if (!hasText(value)) return false;
+  if (looksLikeLocalAbsolutePath(value)) return false;
+  return /^[A-Za-z0-9][A-Za-z0-9._:@-]*$/.test(value);
+}
+function looksLikeLocalAbsolutePath(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return false;
+  return sourceValueVariants(trimmed).some((candidate) => {
+    const normalized = candidate.replace(/\\/g, "/");
+    return /^file:\/*/i.test(normalized) || /[A-Za-z]:\//.test(normalized) || normalized.startsWith("/") || /(?:^|[^A-Za-z0-9])file:\/*/i.test(normalized) || /(?:^|[^A-Za-z0-9])\/(?!\/)/.test(normalized) || /(?:^|[^A-Za-z0-9])(?:Users|home|root|tmp|var|data)(?:\/|$)/.test(normalized) || /(?:^|\/(?:\/*))(?:Users|home|root|tmp|var|data)(?:\/|$)/.test(normalized) || /(?:^|[^A-Za-z0-9])\\\\/.test(candidate);
+  });
+}
+function looksLikePrivacySensitiveSourceValue(value, fieldName = "") {
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return false;
+  return sourceValueVariants(trimmed).some((candidate) => {
+    const normalized = candidate.replace(/\\/g, "/");
+    return looksLikeLocalAbsolutePath(candidate) || /(?:^|[\s:=,;|()[\]{}<>"'`])~(?:\/|$)/.test(normalized) || /(?:^|\/)\.hermes(?:\/|$)/i.test(normalized) || /(?:^|[^A-Za-z0-9])state\.db(?:$|[^A-Za-z0-9])/i.test(normalized) || looksLikeCredentialAssignment(candidate) || looksLikeBareCredentialToken(candidate) || looksLikeCredentialFieldValue(fieldName, candidate) || /\bBearer\s+(?!\[?redacted\]?(?:$|[\s&;,|()[\]{}<>"'`]))[A-Za-z0-9._~+/=-]{3,}/i.test(candidate) || /(?:^|[\s:=,;|()[\]{}<>"'`])[a-z][a-z0-9+.-]*:\/\/[^\s/@:]+:[^\s/@]+@/i.test(candidate) || /(?:^|[\s:=,;|()[\]{}<>"'`])[a-z][a-z0-9+.-]*:\/\/:[^\s/@]+@/i.test(candidate);
+  });
+}
+function violation(code, path8, message) {
+  return { code, path: path8, message };
+}
+function looksLikeCredentialAssignment(value) {
+  return /(?:^|[^A-Za-z0-9_-])(?:api[_-]?key|access[_-]?token|auth[_-]?token|client[_-]?secret|secret|password|passwd|authorization|token)\s*[:=]\s*(?!(?:Bearer\s+)?\[?redacted\]?(?:$|[\s&;,|()[\]{}<>"'`]))(?:Bearer\s+)?[^\s&;,|]{3,}/i.test(value);
+}
+function looksLikeBareCredentialToken(value) {
+  if (/^\[?redacted\]?$/i.test(value.trim())) return false;
+  const tokenBoundary = "(?:^|[^A-Za-z0-9_-])";
+  const tokenEnd = "(?:$|[^A-Za-z0-9_-])";
+  return [
+    new RegExp(`${tokenBoundary}sk[-_][A-Za-z0-9][A-Za-z0-9_-]{2,}${tokenEnd}`),
+    new RegExp(`${tokenBoundary}gh[a-z]_[A-Za-z0-9_]{3,}${tokenEnd}`),
+    new RegExp(`${tokenBoundary}github_pat_[A-Za-z0-9_]{3,}${tokenEnd}`),
+    new RegExp(`${tokenBoundary}xox[abprs]-[A-Za-z0-9-]{3,}${tokenEnd}`),
+    new RegExp(`${tokenBoundary}hf_[A-Za-z0-9]{3,}${tokenEnd}`),
+    new RegExp(`${tokenBoundary}glpat-[A-Za-z0-9_-]{3,}${tokenEnd}`),
+    new RegExp(`${tokenBoundary}(?:AKIA|ASIA)[A-Z0-9]{8,}${tokenEnd}`),
+    new RegExp(`${tokenBoundary}AIza[A-Za-z0-9_-]{3,}${tokenEnd}`),
+    new RegExp(`${tokenBoundary}eyJ[A-Za-z0-9_-]*.[A-Za-z0-9_-]{3,}.[A-Za-z0-9_-]{3,}${tokenEnd}`)
+  ].some((pattern) => pattern.test(value));
+}
+function sourceValueVariants(value) {
+  const variants = /* @__PURE__ */ new Set([value]);
+  let current = value;
+  for (let attempt = 0; attempt < 5 && current.includes("%"); attempt += 1) {
+    const decoded = decodePercentEncodedBestEffort(current);
+    if (decoded === current) break;
+    variants.add(decoded);
+    current = decoded;
+  }
+  return [...variants];
+}
+function decodePercentEncodedBestEffort(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value.replace(/%[0-9A-Fa-f]{2}/g, (match) => String.fromCharCode(Number.parseInt(match.slice(1), 16)));
+  }
+}
+function looksLikeCredentialFieldValue(fieldName, value) {
+  return /^(?:api[_-]?key|access[_-]?token|auth[_-]?token|client[_-]?secret|secret|password|passwd|authorization|token)$/i.test(fieldName.trim()) && !/^\[?redacted\]?$/i.test(value.trim());
+}
+function isOneOf(values, value) {
+  return typeof value === "string" && values.includes(value);
+}
+
+// src/core/source/source-ref.ts
+function createSourceRef(ref) {
+  const prepared = prepareSourceRef(ref);
+  if (prepared.violations.length > 0 || !prepared.record) {
+    throw new SourceContractValidationError(prepared.violations);
+  }
+  const kind = getOwnField(prepared.record, "kind");
+  const stableId = getOwnField(prepared.record, "stableId");
+  const publicHandle = getOwnField(prepared.record, "publicHandle");
+  const evidenceHandle = getOwnField(prepared.record, "evidenceHandle");
+  const privacyClass = getOwnField(prepared.record, "privacyClass");
+  const captureMode = getOwnField(prepared.record, "captureMode");
+  return Object.freeze({
+    kind,
+    stableId,
+    publicHandle,
+    ...evidenceHandle !== void 0 ? { evidenceHandle } : {},
+    privacyClass,
+    captureMode,
+    ...prepared.metadata !== void 0 ? { metadata: prepared.metadata } : {}
+  });
+}
+function validateSourceRef(ref, path8 = "sourceRef") {
+  return prepareSourceRef(ref, path8).violations;
+}
+function prepareSourceRef(ref, path8 = "sourceRef") {
+  const snapshot = snapshotAllowedRecordFields(ref, ["kind", "stableId", "publicHandle", "evidenceHandle", "privacyClass", "captureMode", "metadata"], {
+    path: path8,
+    requiredCode: "sourceRef.required",
+    requiredMessage: "Source ref is required.",
+    unknownCode: "sourceRef.unknown_field",
+    unknownMessage: "Source ref contains unsupported fields.",
+    accessorCode: "sourceRef.accessor_field",
+    accessorMessage: "Source ref fields must be data properties."
+  });
+  if (!snapshot.record) {
+    return { violations: snapshot.violations };
+  }
+  const violations = [...snapshot.violations];
+  const kind = getOwnField(snapshot.record, "kind");
+  const stableId = getOwnField(snapshot.record, "stableId");
+  const publicHandle = getOwnField(snapshot.record, "publicHandle");
+  const evidenceHandle = getOwnField(snapshot.record, "evidenceHandle");
+  const privacyClass = getOwnField(snapshot.record, "privacyClass");
+  const captureMode = getOwnField(snapshot.record, "captureMode");
+  const metadata = getOwnField(snapshot.record, "metadata");
+  if (!hasText(kind)) {
+    violations.push(violation("sourceRef.kind.required", `${path8}.kind`, "Source ref kind must be non-empty."));
+  } else if (looksLikePrivacySensitiveSourceValue(kind)) {
+    violations.push(violation("sourceRef.kind.privacy_sensitive", `${path8}.kind`, "Source ref kind must not leak local state handles or credential-shaped values."));
+  }
+  if (!hasText(stableId)) {
+    violations.push(violation("sourceRef.stableId.required", `${path8}.stableId`, "Source ref stableId must be non-empty."));
+  } else {
+    if (looksLikeLocalAbsolutePath(stableId)) {
+      violations.push(violation("sourceRef.stableId.absolute_local_path", `${path8}.stableId`, "Source ref stableId must not be a local absolute path."));
+    }
+    if (looksLikePrivacySensitiveSourceValue(stableId)) {
+      violations.push(violation("sourceRef.stableId.privacy_sensitive", `${path8}.stableId`, "Source ref stableId must not leak local state handles or credential-shaped values."));
+    }
+  }
+  validatePublicHandle(publicHandle, `${path8}.publicHandle`, violations);
+  validateEvidenceHandle(evidenceHandle, `${path8}.evidenceHandle`, violations);
+  if (!isSourcePrivacyClass(privacyClass)) {
+    violations.push(violation("sourceRef.privacyClass.invalid", `${path8}.privacyClass`, "Source ref privacyClass must be one of the bounded source privacy classes."));
+  }
+  if (!isSourceCaptureMode(captureMode)) {
+    violations.push(violation("sourceRef.captureMode.invalid", `${path8}.captureMode`, "Source ref captureMode must be one of the bounded source capture modes."));
+  }
+  const metadataSnapshot = snapshotSourceRefMetadata(metadata, `${path8}.metadata`);
+  violations.push(...metadataSnapshot.violations);
+  return {
+    record: snapshot.record,
+    metadata: metadataSnapshot.record,
+    violations
+  };
+}
+function validatePublicHandle(value, path8, violations) {
+  if (!hasText(value)) {
+    violations.push(violation("sourceRef.publicHandle.required", path8, "Source ref publicHandle must be non-empty."));
+    return;
+  }
+  if (looksLikeLocalAbsolutePath(value)) {
+    violations.push(violation("sourceRef.publicHandle.absolute_local_path", path8, "Source ref publicHandle must not leak a local absolute path."));
+  }
+  if (looksLikePrivacySensitiveSourceValue(value)) {
+    violations.push(violation("sourceRef.publicHandle.privacy_sensitive", path8, "Source ref publicHandle must not leak local state handles or credential-shaped values."));
+  }
+}
+function validateEvidenceHandle(value, path8, violations) {
+  if (value === void 0) return;
+  if (!hasText(value)) {
+    violations.push(violation("sourceRef.evidenceHandle.invalid", path8, "Source ref evidenceHandle must be a non-empty string when present."));
+    return;
+  }
+  if (looksLikeLocalAbsolutePath(value)) {
+    violations.push(violation("sourceRef.evidenceHandle.absolute_local_path", path8, "Source ref evidenceHandle must not leak a local absolute path."));
+  }
+  if (looksLikePrivacySensitiveSourceValue(value)) {
+    violations.push(violation("sourceRef.evidenceHandle.privacy_sensitive", path8, "Source ref evidenceHandle must not leak local state handles or credential-shaped values."));
+  }
+}
+function snapshotSourceRefMetadata(metadata, path8) {
+  if (metadata === void 0) return { violations: [] };
+  if (!isRecord6(metadata)) {
+    return {
+      violations: [violation("sourceRef.metadata.invalid", path8, "Source ref metadata must be an object when present.")]
+    };
+  }
+  const snapshot = /* @__PURE__ */ Object.create(null);
+  const keySnapshot = safeOwnKeysForSourceSnapshot(metadata, path8, "sourceRef.metadata.accessor_field", "Source ref metadata values must be data properties.");
+  const violations = [...keySnapshot.violations];
+  keySnapshot.keys.forEach((key, index) => {
+    if (typeof key !== "string") {
+      const valuePath2 = `${path8}.[symbol-${index}]`;
+      violations.push(violation("sourceRef.metadata.invalid_key", valuePath2, "Source ref metadata keys must be strings."));
+      const descriptorSnapshot2 = safeGetOwnPropertyDescriptorForSourceSnapshot(metadata, key, valuePath2, "sourceRef.metadata.accessor_field", "Source ref metadata values must be data properties.");
+      violations.push(...descriptorSnapshot2.violations);
+      const descriptor2 = descriptorSnapshot2.descriptor;
+      if (!descriptor2 || !("value" in descriptor2)) {
+        violations.push(violation("sourceRef.metadata.accessor_field", valuePath2, "Source ref metadata values must be data properties."));
+        return;
+      }
+      const readSnapshot2 = safeReadOwnDataPropertyForSourceSnapshot(metadata, key, descriptor2, valuePath2, "sourceRef.metadata.accessor_field", "Source ref metadata values must be data properties.");
+      violations.push(...readSnapshot2.violations);
+      if (readSnapshot2.violations.length > 0) return;
+      validateMetadataValue(readSnapshot2.value, valuePath2, propertyKeyDescription(key), violations);
+      return;
+    }
+    const valuePath = metadataEntryPath(path8, key, index);
+    if (looksLikePrivacySensitiveSourceValue(key)) {
+      violations.push(violation("sourceRef.metadata.privacy_sensitive", valuePath, "Source ref metadata keys must not leak local state handles or credential-shaped values."));
+    }
+    const descriptorSnapshot = safeGetOwnPropertyDescriptorForSourceSnapshot(metadata, key, valuePath, "sourceRef.metadata.accessor_field", "Source ref metadata values must be data properties.");
+    violations.push(...descriptorSnapshot.violations);
+    const descriptor = descriptorSnapshot.descriptor;
+    if (!descriptor || !("value" in descriptor)) {
+      violations.push(violation("sourceRef.metadata.accessor_field", valuePath, "Source ref metadata values must be data properties."));
+      return;
+    }
+    const readSnapshot = safeReadOwnDataPropertyForSourceSnapshot(metadata, key, descriptor, valuePath, "sourceRef.metadata.accessor_field", "Source ref metadata values must be data properties.");
+    violations.push(...readSnapshot.violations);
+    if (readSnapshot.violations.length > 0) return;
+    validateMetadataValue(readSnapshot.value, valuePath, key, violations);
+    if (isSourceRefMetadataValue(readSnapshot.value)) {
+      snapshot[key] = readSnapshot.value;
+    }
+  });
+  return { record: Object.freeze(snapshot), violations };
+}
+function isSourceRefMetadataValue(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function validateMetadataValue(value, valuePath, key, violations) {
+  if (value === null) return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      violations.push(violation("sourceRef.metadata.invalid_value", valuePath, "Source ref metadata numbers must be finite."));
+    }
+    if (looksLikePrivacySensitiveSourceValue(String(value), key)) {
+      violations.push(violation("sourceRef.metadata.privacy_sensitive", valuePath, "Source ref metadata must not leak local state handles or credential-shaped values."));
+    }
+    return;
+  }
+  if (typeof value === "boolean") {
+    if (looksLikePrivacySensitiveSourceValue(String(value), key)) {
+      violations.push(violation("sourceRef.metadata.privacy_sensitive", valuePath, "Source ref metadata must not leak local state handles or credential-shaped values."));
+    }
+    return;
+  }
+  if (typeof value === "string") {
+    if (looksLikePrivacySensitiveSourceValue(value, key)) {
+      violations.push(violation("sourceRef.metadata.privacy_sensitive", valuePath, "Source ref metadata must not leak local state handles or credential-shaped values."));
+    }
+    return;
+  }
+  violations.push(violation("sourceRef.metadata.invalid_value", valuePath, "Source ref metadata values must be scalar strings, finite numbers, booleans, or null."));
+}
+function propertyKeyDescription(key) {
+  return typeof key === "symbol" ? String(key.description ?? "") : "";
+}
+function metadataEntryPath(path8, key, index) {
+  if (looksLikePrivacySensitiveSourceValue(key)) {
+    return `${path8}.[redacted-key-${index}]`;
+  }
+  const sanitizedKey = key.replace(/[^A-Za-z0-9._:-]+/g, "_").slice(0, 64);
+  return sanitizedKey ? `${path8}.${sanitizedKey}` : `${path8}.${index}`;
+}
+
+// src/core/source/source-transformations.ts
+var MAX_SOURCE_TRANSFORMATION_DECLARATIONS = 1e3;
+var SOURCE_TRANSFORMATION_KINDS = Object.freeze(["extract", "normalize", "privacy-filter", "map", "enrich"]);
+function isSourceTransformationKind(value) {
+  return typeof value === "string" && SOURCE_TRANSFORMATION_KINDS.includes(value);
+}
+function defineSourceTransformation(transformation) {
+  const prepared = prepareSourceTransformationDeclaration(transformation);
+  if (prepared.violations.length > 0 || !prepared.record) {
+    throw new SourceContractValidationError(prepared.violations);
+  }
+  return Object.freeze(freezeSourceTransformationDeclaration(prepared.record));
+}
+function defineSourceTransformations(transformations) {
+  const prepared = prepareSourceTransformationDeclarations(transformations, "transformations");
+  if (prepared.violations.length > 0) {
+    throw new SourceContractValidationError(prepared.violations);
+  }
+  return Object.freeze(prepared.records.map((transformation) => Object.freeze(freezeSourceTransformationDeclaration(transformation))));
+}
+function validateSourceTransformationDeclarations(transformations, path8 = "transformations") {
+  return prepareSourceTransformationDeclarations(transformations, path8).violations;
+}
+function prepareSourceTransformationDeclarations(transformations, path8) {
+  const snapshot = snapshotSourceTransformationArray(transformations, path8);
+  const violations = [...snapshot.violations];
+  const records = [];
+  for (let index = 0; index < snapshot.items.length; index += 1) {
+    const prepared = prepareSourceTransformationDeclaration(snapshot.items[index], `${path8}.${index}`);
+    violations.push(...prepared.violations);
+    if (prepared.record) records[index] = prepared.record;
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const transformation of records) {
+    if (!isRecord6(transformation)) continue;
+    const id = getOwnField(transformation, "id");
+    if (!hasText(id)) continue;
+    if (seenIds.has(id)) {
+      violations.push(violation("transformation.id.duplicate", path8, "Duplicate transformation id."));
+    }
+    seenIds.add(id);
+  }
+  return { records, violations };
+}
+function snapshotSourceTransformationArray(transformations, path8) {
+  if (!isArrayForSourceSnapshot(transformations)) {
+    return {
+      items: [],
+      violations: [violation("transformations.required", path8, "At least one source transformation declaration is required.")]
+    };
+  }
+  const lengthDescriptorSnapshot = safeGetOwnPropertyDescriptorForSourceSnapshot(
+    transformations,
+    "length",
+    path8,
+    "transformations.length.invalid",
+    "Source transformation declarations must expose a stable bounded array length."
+  );
+  if (lengthDescriptorSnapshot.violations.length > 0) {
+    return { items: [], violations: lengthDescriptorSnapshot.violations };
+  }
+  const lengthDescriptor = lengthDescriptorSnapshot.descriptor;
+  if (!lengthDescriptor || !("value" in lengthDescriptor)) {
+    return {
+      items: [],
+      violations: [violation("transformations.length.invalid", path8, "Source transformation declarations must expose a stable bounded array length.")]
+    };
+  }
+  const lengthReadSnapshot = safeReadOwnDataPropertyForSourceSnapshot(
+    transformations,
+    "length",
+    lengthDescriptor,
+    path8,
+    "transformations.length.invalid",
+    "Source transformation declarations must expose a stable bounded array length."
+  );
+  if (lengthReadSnapshot.violations.length > 0) {
+    return { items: [], violations: lengthReadSnapshot.violations };
+  }
+  const length = lengthReadSnapshot.value;
+  if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0 || length > MAX_SOURCE_TRANSFORMATION_DECLARATIONS) {
+    return {
+      items: [],
+      violations: [violation("transformations.length.invalid", path8, "Source transformation declarations must expose a stable bounded array length.")]
+    };
+  }
+  if (length === 0) {
+    return {
+      items: [],
+      violations: [violation("transformations.required", path8, "At least one source transformation declaration is required.")]
+    };
+  }
+  const items = new Array(length);
+  const violations = [];
+  for (let index = 0; index < length; index += 1) {
+    const itemPath = `${path8}.${index}`;
+    const descriptorSnapshot = safeGetOwnPropertyDescriptorForSourceSnapshot(
+      transformations,
+      String(index),
+      itemPath,
+      "transformations.accessor_field",
+      "Source transformation declaration array entries must be data properties."
+    );
+    violations.push(...descriptorSnapshot.violations);
+    const descriptor = descriptorSnapshot.descriptor;
+    if (!descriptor) {
+      violations.push(violation("transformations.missing_index", itemPath, "Source transformation declarations must be a dense array."));
+      continue;
+    }
+    if (!("value" in descriptor)) {
+      violations.push(violation("transformations.accessor_field", itemPath, "Source transformation declaration array entries must be data properties."));
+      continue;
+    }
+    const readSnapshot = safeReadOwnDataPropertyForSourceSnapshot(
+      transformations,
+      String(index),
+      descriptor,
+      itemPath,
+      "transformations.accessor_field",
+      "Source transformation declaration array entries must be data properties."
+    );
+    violations.push(...readSnapshot.violations);
+    if (readSnapshot.violations.length > 0) continue;
+    items[index] = readSnapshot.value;
+  }
+  return { items, violations };
+}
+function validateSourceTransformationDeclaration(transformation, path8 = "transformation") {
+  return prepareSourceTransformationDeclaration(transformation, path8).violations;
+}
+function prepareSourceTransformationDeclaration(transformation, path8 = "transformation") {
+  const snapshot = snapshotAllowedRecordFields(transformation, ["id", "version", "kind", "inputSchema", "outputSchema", "deterministic", "description"], {
+    path: path8,
+    requiredCode: "transformation.required",
+    requiredMessage: "Source transformation declaration is required.",
+    unknownCode: "transformation.unknown_field",
+    unknownMessage: "Source transformation declaration contains unsupported fields.",
+    accessorCode: "transformation.accessor_field",
+    accessorMessage: "Source transformation declaration fields must be data properties."
+  });
+  if (!snapshot.record) return { violations: snapshot.violations };
+  const violations = [...snapshot.violations];
+  const id = getOwnField(snapshot.record, "id");
+  const version = getOwnField(snapshot.record, "version");
+  const kind = getOwnField(snapshot.record, "kind");
+  const inputSchema = getOwnField(snapshot.record, "inputSchema");
+  const outputSchema = getOwnField(snapshot.record, "outputSchema");
+  const deterministic = getOwnField(snapshot.record, "deterministic");
+  const description = getOwnField(snapshot.record, "description");
+  if (!hasText(id)) {
+    violations.push(violation("transformation.id.required", `${path8}.id`, "Source transformation id must be non-empty."));
+  } else {
+    if (!isStableContractIdentifier(id)) {
+      violations.push(violation("transformation.id.unstable", `${path8}.id`, "Source transformation id must be stable and must not include a local absolute path."));
+    }
+    if (looksLikePrivacySensitiveSourceValue(id)) {
+      violations.push(violation("transformation.id.privacy_sensitive", `${path8}.id`, "Source transformation id must not leak local state handles or credential-shaped values."));
+    }
+  }
+  if (!hasText(version)) {
+    violations.push(violation("transformation.version.required", `${path8}.version`, "Source transformation version must be non-empty."));
+  } else if (looksLikePrivacySensitiveSourceValue(version)) {
+    violations.push(violation("transformation.version.privacy_sensitive", `${path8}.version`, "Source transformation version must not leak local state handles or credential-shaped values."));
+  }
+  if (!isSourceTransformationKind(kind)) {
+    violations.push(violation("transformation.kind.invalid", `${path8}.kind`, "Source transformation kind must be one of the bounded source transformation kinds."));
+  }
+  if (!hasText(inputSchema)) {
+    violations.push(violation("transformation.inputSchema.required", `${path8}.inputSchema`, "Source transformation inputSchema must be non-empty."));
+  } else if (looksLikePrivacySensitiveSourceValue(inputSchema)) {
+    violations.push(violation("transformation.inputSchema.privacy_sensitive", `${path8}.inputSchema`, "Source transformation inputSchema must not leak local state handles or credential-shaped values."));
+  }
+  if (!hasText(outputSchema)) {
+    violations.push(violation("transformation.outputSchema.required", `${path8}.outputSchema`, "Source transformation outputSchema must be non-empty."));
+  } else if (looksLikePrivacySensitiveSourceValue(outputSchema)) {
+    violations.push(violation("transformation.outputSchema.privacy_sensitive", `${path8}.outputSchema`, "Source transformation outputSchema must not leak local state handles or credential-shaped values."));
+  }
+  if (deterministic !== void 0 && typeof deterministic !== "boolean") {
+    violations.push(violation("transformation.deterministic.invalid", `${path8}.deterministic`, "Source transformation deterministic must be a boolean when present."));
+  }
+  if (description !== void 0 && typeof description !== "string") {
+    violations.push(violation("transformation.description.invalid", `${path8}.description`, "Source transformation description must be a string when present."));
+  } else if (hasText(description) && looksLikePrivacySensitiveSourceValue(description)) {
+    violations.push(violation("transformation.description.privacy_sensitive", `${path8}.description`, "Source transformation description must not leak local state handles or credential-shaped values."));
+  }
+  return { record: snapshot.record, violations };
+}
+function freezeSourceTransformationDeclaration(transformation) {
+  const id = getOwnField(transformation, "id");
+  const version = getOwnField(transformation, "version");
+  const kind = getOwnField(transformation, "kind");
+  const inputSchema = getOwnField(transformation, "inputSchema");
+  const outputSchema = getOwnField(transformation, "outputSchema");
+  const deterministic = getOwnField(transformation, "deterministic");
+  const description = getOwnField(transformation, "description");
+  const defined = {
+    id,
+    version,
+    kind,
+    inputSchema,
+    outputSchema
+  };
+  if (deterministic !== void 0) defined.deterministic = deterministic;
+  if (description !== void 0) defined.description = description;
+  return defined;
+}
+
+// src/core/source/source-adapter.ts
+function validateSourceAdapterIdentity(identity, path8 = "identity") {
+  return prepareSourceAdapterIdentity(identity, path8).violations;
+}
+function prepareSourceAdapterIdentity(identity, path8 = "identity") {
+  const snapshot = snapshotAllowedRecordFields(identity, ["id", "version", "displayName"], {
+    path: path8,
+    requiredCode: "identity.required",
+    requiredMessage: "Source adapter identity is required.",
+    unknownCode: "identity.unknown_field",
+    unknownMessage: "Source adapter contract object contains unsupported fields.",
+    accessorCode: "identity.accessor_field",
+    accessorMessage: "Source adapter identity fields must be data properties."
+  });
+  if (!snapshot.record) return { violations: snapshot.violations };
+  const violations = [...snapshot.violations];
+  const id = getOwnField(snapshot.record, "id");
+  const version = getOwnField(snapshot.record, "version");
+  const displayName = getOwnField(snapshot.record, "displayName");
+  if (!hasText(id)) {
+    violations.push(violation("identity.id.required", `${path8}.id`, "Source adapter identity id must be non-empty."));
+  } else {
+    if (!isStableContractIdentifier(id)) {
+      violations.push(violation("identity.id.unstable", `${path8}.id`, "Source adapter identity id must be stable and must not include a local absolute path."));
+    }
+    if (looksLikePrivacySensitiveSourceValue(id)) {
+      violations.push(violation("identity.id.privacy_sensitive", `${path8}.id`, "Source adapter identity id must not leak local state handles or credential-shaped values."));
+    }
+  }
+  if (!hasText(version)) {
+    violations.push(violation("identity.version.required", `${path8}.version`, "Source adapter identity version must be non-empty."));
+  } else if (looksLikePrivacySensitiveSourceValue(version)) {
+    violations.push(violation("identity.version.privacy_sensitive", `${path8}.version`, "Source adapter identity version must not leak local state handles or credential-shaped values."));
+  }
+  if (displayName !== void 0 && typeof displayName !== "string") {
+    violations.push(violation("identity.displayName.invalid", `${path8}.displayName`, "Source adapter displayName must be a string when present."));
+  } else if (hasText(displayName) && looksLikePrivacySensitiveSourceValue(displayName)) {
+    violations.push(violation("identity.displayName.privacy_sensitive", `${path8}.displayName`, "Source adapter displayName must not leak local state handles or credential-shaped values."));
+  }
+  return { record: snapshot.record, violations };
+}
+function freezeSourceAdapterIdentity(identity) {
+  const id = getOwnField(identity, "id");
+  const version = getOwnField(identity, "version");
+  const displayName = getOwnField(identity, "displayName");
+  const defined = {
+    id,
+    version
+  };
+  if (displayName !== void 0) defined.displayName = displayName;
+  return Object.freeze(defined);
+}
+function validateSourceAdapterCapabilities(capabilities, path8 = "capabilities") {
+  return prepareSourceAdapterCapabilities(capabilities, path8).violations;
+}
+function prepareSourceAdapterCapabilities(capabilities, path8 = "capabilities") {
+  if (!isRecord6(capabilities)) {
+    return {
+      violations: [violation("capabilities.required", path8, "Source adapter capabilities with currentnessStrategy are required.")]
+    };
+  }
+  const record = /* @__PURE__ */ Object.create(null);
+  const keySnapshot = safeOwnKeysForSourceSnapshot(capabilities, path8, "capabilities.accessor_field", "Source adapter capability fields must be data properties.");
+  const violations = [...keySnapshot.violations];
+  keySnapshot.keys.forEach((key, index) => {
+    if (typeof key !== "string") {
+      const valuePath2 = `${path8}.[symbol-${index}]`;
+      violations.push(violation("capabilities.invalid_key", valuePath2, "Source adapter capability keys must be strings."));
+      const descriptorSnapshot2 = safeGetOwnPropertyDescriptorForSourceSnapshot(capabilities, key, valuePath2, "capabilities.accessor_field", "Source adapter capability fields must be data properties.");
+      violations.push(...descriptorSnapshot2.violations);
+      const descriptor2 = descriptorSnapshot2.descriptor;
+      if (!descriptor2 || !("value" in descriptor2)) {
+        violations.push(violation("capabilities.accessor_field", valuePath2, "Source adapter capability fields must be data properties."));
+        return;
+      }
+      const readSnapshot2 = safeReadOwnDataPropertyForSourceSnapshot(capabilities, key, descriptor2, valuePath2, "capabilities.accessor_field", "Source adapter capability fields must be data properties.");
+      violations.push(...readSnapshot2.violations);
+      if (readSnapshot2.violations.length > 0) return;
+      validateCapabilityValue(propertyKeyDescription2(key), readSnapshot2.value, valuePath2, violations);
+      return;
+    }
+    const valuePath = capabilityEntryPath(path8, key, index);
+    const descriptorSnapshot = safeGetOwnPropertyDescriptorForSourceSnapshot(capabilities, key, valuePath, "capabilities.accessor_field", "Source adapter capability fields must be data properties.");
+    violations.push(...descriptorSnapshot.violations);
+    const descriptor = descriptorSnapshot.descriptor;
+    if (!descriptor || !("value" in descriptor)) {
+      violations.push(violation("capabilities.accessor_field", valuePath, "Source adapter capability fields must be data properties."));
+      return;
+    }
+    const readSnapshot = safeReadOwnDataPropertyForSourceSnapshot(capabilities, key, descriptor, valuePath, "capabilities.accessor_field", "Source adapter capability fields must be data properties.");
+    violations.push(...readSnapshot.violations);
+    if (readSnapshot.violations.length > 0) return;
+    record[key] = readSnapshot.value;
+    validateCapabilityValue(key, readSnapshot.value, valuePath, violations);
+  });
+  const currentnessStrategy = getOwnField(record, "currentnessStrategy");
+  if (!hasOwnField(record, "currentnessStrategy") || !hasText(currentnessStrategy)) {
+    violations.push(violation("capabilities.currentnessStrategy.required", `${path8}.currentnessStrategy`, "Source adapter capabilities must declare a deterministic currentnessStrategy."));
+  } else if (!isStableContractIdentifier(currentnessStrategy)) {
+    violations.push(violation("capabilities.currentnessStrategy.unstable", `${path8}.currentnessStrategy`, "Source adapter currentnessStrategy must be stable and must not include a local absolute path."));
+  }
+  return { record, violations };
+}
+function freezeSourceAdapterCapabilities(capabilities) {
+  const keySnapshot = safeOwnKeysForSourceSnapshot(capabilities, "capabilities", "capabilities.accessor_field", "Source adapter capability fields must be data properties.");
+  const safeEntries = [];
+  keySnapshot.keys.forEach((key) => {
+    if (typeof key !== "string") return;
+    const descriptorSnapshot = safeGetOwnPropertyDescriptorForSourceSnapshot(capabilities, key, `capabilities.${key}`, "capabilities.accessor_field", "Source adapter capability fields must be data properties.");
+    const descriptor = descriptorSnapshot.descriptor;
+    if (descriptor && "value" in descriptor) safeEntries.push([key, descriptor.value]);
+  });
+  return Object.freeze(Object.fromEntries(safeEntries));
+}
+function propertyKeyDescription2(key) {
+  return typeof key === "symbol" ? String(key.description ?? "") : "";
+}
+function capabilityEntryPath(path8, key, index) {
+  if (looksLikePrivacySensitiveSourceValue(key)) {
+    return `${path8}.[redacted-key-${index}]`;
+  }
+  const sanitizedKey = key.replace(/[^A-Za-z0-9._:-]+/g, "_").slice(0, 64);
+  return sanitizedKey ? `${path8}.${sanitizedKey}` : `${path8}.${index}`;
+}
+function validateCapabilityValue(key, value, path8, violations) {
+  if (looksLikePrivacySensitiveSourceValue(key)) {
+    violations.push(violation("capabilities.privacy_sensitive", path8, "Source adapter capability keys must not leak local state handles or credential-shaped values."));
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      violations.push(violation("capabilities.invalid_value", path8, "Source adapter capability numbers must be finite."));
+    }
+    if (looksLikePrivacySensitiveSourceValue(String(value), key)) {
+      violations.push(violation("capabilities.privacy_sensitive", path8, "Source adapter capability values must not leak local state handles or credential-shaped values."));
+    }
+    return;
+  }
+  if (typeof value === "boolean") return;
+  if (typeof value === "string") {
+    if (looksLikePrivacySensitiveSourceValue(value, key)) {
+      violations.push(violation("capabilities.privacy_sensitive", path8, "Source adapter capability values must not leak local state handles or credential-shaped values."));
+    }
+    return;
+  }
+  violations.push(violation("capabilities.invalid_value", path8, "Source adapter capability values must be scalar strings, finite numbers, or booleans."));
+}
+
+// src/core/source/source-adapter-contract-suite.ts
+var MAX_SAMPLE_SOURCE_REFS = 1e3;
+function validateSourceAdapterContract(adapter, path8 = "adapter") {
+  return prepareSourceAdapterContract(adapter, path8).violations;
+}
+function assertSourceAdapterContract(adapter) {
+  return defineSourceAdapter(adapter);
+}
+function defineSourceAdapter(adapter) {
+  const prepared = prepareSourceAdapterContract(adapter);
+  if (prepared.violations.length > 0 || !prepared.contract) {
+    throw new SourceContractValidationError(prepared.violations);
+  }
+  return Object.freeze(prepared.contract);
+}
+function prepareSourceAdapterContract(adapter, path8 = "adapter") {
+  const snapshot = snapshotAllowedRecordFields(adapter, ["identity", "source", "transformations", "sampleSourceRefs", "capabilities"], {
+    path: path8,
+    requiredCode: "adapter.required",
+    requiredMessage: "Source adapter contract is required.",
+    unknownCode: "adapter.unknown_field",
+    unknownMessage: "Source adapter contract contains unsupported fields.",
+    accessorCode: "adapter.accessor_field",
+    accessorMessage: "Source adapter contract fields must be data properties."
+  });
+  if (!snapshot.record) return { violations: snapshot.violations };
+  const violations = [...snapshot.violations];
+  const identityInput = getOwnField(snapshot.record, "identity");
+  const sourceInput = getOwnField(snapshot.record, "source");
+  const transformationsInput = getOwnField(snapshot.record, "transformations");
+  const capabilitiesInput = getOwnField(snapshot.record, "capabilities");
+  const sampleSourceRefsInput = getOwnField(snapshot.record, "sampleSourceRefs");
+  const identityPrepared = prepareSourceAdapterIdentity(identityInput, `${path8}.identity`);
+  violations.push(...identityPrepared.violations);
+  const sourcePrepared = defineSafeResult(
+    () => defineSourceSchema(sourceInput),
+    "source",
+    `${path8}.source`,
+    "source.validation_error",
+    "Source schema validation failed unexpectedly."
+  );
+  violations.push(...sourcePrepared.violations);
+  const transformationsPrepared = defineSafeResult(
+    () => defineSourceTransformations(transformationsInput),
+    "transformations",
+    `${path8}.transformations`,
+    "transformations.validation_error",
+    "Source transformation validation failed unexpectedly."
+  );
+  violations.push(...transformationsPrepared.violations);
+  const capabilitiesPrepared = prepareSourceAdapterCapabilities(capabilitiesInput, `${path8}.capabilities`);
+  violations.push(...capabilitiesPrepared.violations);
+  const sampleSourceRefsPrepared = defineSampleSourceRefs(sampleSourceRefsInput, `${path8}.sampleSourceRefs`);
+  violations.push(...sampleSourceRefsPrepared.violations);
+  if (violations.length > 0 || !identityPrepared.record || !sourcePrepared.value || !transformationsPrepared.value || !capabilitiesPrepared.record) {
+    return { violations };
+  }
+  const contract = {
+    identity: freezeSourceAdapterIdentity(identityPrepared.record),
+    source: sourcePrepared.value,
+    transformations: transformationsPrepared.value,
+    sampleSourceRefs: sampleSourceRefsPrepared.value,
+    capabilities: freezeSourceAdapterCapabilities(capabilitiesPrepared.record)
+  };
+  return { contract, violations };
+}
+function defineSampleSourceRefs(sampleSourceRefs, path8) {
+  if (sampleSourceRefs === void 0) return { violations: [] };
+  if (!isArrayForSourceSnapshot(sampleSourceRefs)) {
+    return {
+      violations: [violation("sampleSourceRefs.invalid", path8, "sampleSourceRefs must be an array when present.")]
+    };
+  }
+  const snapshot = snapshotSampleSourceRefArray(sampleSourceRefs, path8);
+  const violations = [...snapshot.violations];
+  const refs = [];
+  for (let index = 0; index < snapshot.items.length; index += 1) {
+    const defined = defineSafeResult(
+      () => createSourceRef(snapshot.items[index]),
+      "sourceRef",
+      `${path8}.${index}`,
+      "sampleSourceRefs.validation_error",
+      "Sample source ref validation failed unexpectedly."
+    );
+    violations.push(...defined.violations);
+    if (defined.value) refs[index] = defined.value;
+  }
+  return {
+    value: violations.length === 0 ? Object.freeze(refs) : void 0,
+    violations
+  };
+}
+function snapshotSampleSourceRefArray(sampleSourceRefs, path8) {
+  const lengthDescriptorSnapshot = safeGetOwnPropertyDescriptorForSourceSnapshot(
+    sampleSourceRefs,
+    "length",
+    path8,
+    "sampleSourceRefs.length.invalid",
+    "sampleSourceRefs must expose a stable bounded array length."
+  );
+  if (lengthDescriptorSnapshot.violations.length > 0) {
+    return { items: [], violations: lengthDescriptorSnapshot.violations };
+  }
+  const lengthDescriptor = lengthDescriptorSnapshot.descriptor;
+  if (!lengthDescriptor || !("value" in lengthDescriptor)) {
+    return {
+      items: [],
+      violations: [violation("sampleSourceRefs.length.invalid", path8, "sampleSourceRefs must expose a stable bounded array length.")]
+    };
+  }
+  const lengthReadSnapshot = safeReadOwnDataPropertyForSourceSnapshot(
+    sampleSourceRefs,
+    "length",
+    lengthDescriptor,
+    path8,
+    "sampleSourceRefs.length.invalid",
+    "sampleSourceRefs must expose a stable bounded array length."
+  );
+  if (lengthReadSnapshot.violations.length > 0) {
+    return { items: [], violations: lengthReadSnapshot.violations };
+  }
+  const length = lengthReadSnapshot.value;
+  if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0 || length > MAX_SAMPLE_SOURCE_REFS) {
+    return {
+      items: [],
+      violations: [violation("sampleSourceRefs.length.invalid", path8, "sampleSourceRefs must expose a stable bounded array length.")]
+    };
+  }
+  const items = new Array(length);
+  const violations = [];
+  for (let index = 0; index < length; index += 1) {
+    const itemPath = `${path8}.${index}`;
+    const descriptorSnapshot = safeGetOwnPropertyDescriptorForSourceSnapshot(
+      sampleSourceRefs,
+      String(index),
+      itemPath,
+      "sampleSourceRefs.accessor_field",
+      "sampleSourceRefs array entries must be data properties."
+    );
+    violations.push(...descriptorSnapshot.violations);
+    const descriptor = descriptorSnapshot.descriptor;
+    if (!descriptor) {
+      violations.push(violation("sampleSourceRefs.missing_index", itemPath, "sampleSourceRefs must be a dense array."));
+      continue;
+    }
+    if (!("value" in descriptor)) {
+      violations.push(violation("sampleSourceRefs.accessor_field", itemPath, "sampleSourceRefs array entries must be data properties."));
+      continue;
+    }
+    const readSnapshot = safeReadOwnDataPropertyForSourceSnapshot(
+      sampleSourceRefs,
+      String(index),
+      descriptor,
+      itemPath,
+      "sampleSourceRefs.accessor_field",
+      "sampleSourceRefs array entries must be data properties."
+    );
+    violations.push(...readSnapshot.violations);
+    if (readSnapshot.violations.length > 0) continue;
+    items[index] = readSnapshot.value;
+  }
+  return { items, violations };
+}
+function defineSafeResult(define, sourcePathPrefix, targetPathPrefix, fallbackCode, fallbackMessage) {
+  try {
+    return { value: define(), violations: [] };
+  } catch (error) {
+    if (error instanceof SourceContractValidationError) {
+      return {
+        violations: error.violations.map((violationItem) => ({
+          ...violationItem,
+          path: remapPathPrefix(violationItem.path, sourcePathPrefix, targetPathPrefix)
+        }))
+      };
+    }
+    return { violations: [violation(fallbackCode, targetPathPrefix, fallbackMessage)] };
+  }
+}
+function remapPathPrefix(path8, sourcePathPrefix, targetPathPrefix) {
+  if (path8 === sourcePathPrefix) return targetPathPrefix;
+  if (path8.startsWith(`${sourcePathPrefix}.`)) return `${targetPathPrefix}${path8.slice(sourcePathPrefix.length)}`;
+  return path8;
+}
+
 // src/core/evidence-aligner.ts
 import { createHash as createHash8 } from "crypto";
 var DEFAULT_OPTIONS2 = {
@@ -19596,6 +20642,9 @@ export {
   RetrievalResultTypeSchema,
   Retriever,
   RuleBasedPerspectiveObservationExtractor,
+  SOURCE_CAPTURE_MODES,
+  SOURCE_PRIVACY_CLASSES,
+  SOURCE_TRANSFORMATION_KINDS,
   SQLiteEventStore,
   SearchIndexItemSchema,
   SessionActorRepository,
@@ -19611,6 +20660,7 @@ export {
   SharedStoreConfigSchema,
   SharedTroubleshootingEntrySchema,
   SharedVectorStore,
+  SourceContractValidationError,
   SummaryDeriver,
   SyncWorker,
   TaskActionProjector,
@@ -19641,6 +20691,7 @@ export {
   VectorWorkerV2,
   WorkingSetItemSchema,
   actionIdForTaskEntity,
+  assertSourceAdapterContract,
   backfillPerspectiveSessionActors,
   buildMemoryActorId,
   createEmbeddingBackendUnavailableError,
@@ -19665,9 +20716,14 @@ export {
   createSharedPromoter,
   createSharedStore,
   createSharedVectorStore,
+  createSourceRef,
   createSummaryDeriver,
   createVectorWorker,
   createVectorWorkerV2,
+  defineSourceAdapter,
+  defineSourceSchema,
+  defineSourceTransformation,
+  defineSourceTransformations,
   detectContextContentType,
   emptyRetentionAuditReport,
   evaluateRetentionPolicy,
@@ -19683,7 +20739,12 @@ export {
   isKnownBenignTransformersWarning,
   isMissingTransformersDependencyError,
   isSameCanonicalKey,
+  isSourceCaptureMode,
+  isSourcePrivacyClass,
+  isSourceTransformationKind,
   loadSessionRegistry,
+  looksLikeLocalAbsolutePath,
+  looksLikePrivacySensitiveSourceValue,
   makeArtifactKey,
   makeCanonicalKey,
   makeDedupeKey,
@@ -19716,6 +20777,13 @@ export {
   toDateFromSQLite,
   toDisclosureResultId,
   toSQLiteTimestamp,
+  validateSourceAdapterCapabilities,
+  validateSourceAdapterContract,
+  validateSourceAdapterIdentity,
+  validateSourceRef,
+  validateSourceSchema,
+  validateSourceTransformationDeclaration,
+  validateSourceTransformationDeclarations,
   withSuppressedKnownTransformersWarnings,
   writeGovernanceAuditEntry
 };