sandoichi 0.1.4 → 0.1.6

package/README.md

@@ -10,6 +10,20 @@ npm install sandoichi
 import { optimizeToolOutput, createProviderProxy } from 'sandoichi';
 ```
 
+Project-specific detectors can be declared in `.sando/redaction.json`:
+
+```json
+{
+  "schema": "sando-redaction/v1",
+  "rules": [
+    { "type": "assignment-key", "key": "DATABASE_URL" },
+    { "type": "token-prefix", "prefix": "acme_", "minLength": 24, "maxLength": 128 }
+  ]
+}
+```
+
+Built-ins stay enabled. Profiles are declarative and local to the current project; invalid profiles fail visibly.
+
 The library requires Node.js `>=22.22.0 <23` and has no runtime dependencies. Installing it does not install or enable the plugin.
 
 For plugin installation, see the [main project README](https://github.com/yuzushi-dev/Sando#readme).

package/index.mjs

@@ -5,6 +5,8 @@ export {
   normalizePolicy,
   optimizeToolOutput,
 } from './src/core.mjs';
+export { createRedactionProfile } from './src/redaction-profile.mjs';
+export { loadProjectRedactionProfile } from './src/redaction-config.mjs';
 export { detectProviderBody, listSemanticCandidates, transformProviderRequest } from './src/context-transform.mjs';
 export {
   buildSemanticPrompt,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sandoichi",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Reduce repeated tool-output context in Claude Code and Codex.",
   "license": "MIT",
   "author": "yuzushi",

package/src/core.mjs

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 
 import { planToolRoute, ROUTING_POLICY_VERSION } from './routing.mjs';
-import { redact } from './secret-redaction.mjs';
+import { loadProjectRedactionProfile } from './redaction-config.mjs';
 
 const DEFAULT_POLICY = Object.freeze({
   mode: 'apply', maxInlineBytes: 4096, maxArtifactBytes: 65536, headBytes: undefined, tailBytes: undefined,
@@ -31,6 +31,14 @@ function textOutput(output) {
   return value;
 }
 
+function resolveRedactionProfile(cwd, candidate) {
+  const profile = candidate ?? loadProjectRedactionProfile(cwd).profile;
+  if (!profile || typeof profile.redact !== 'function' || typeof profile.digest !== 'string') {
+    throw new TypeError('redactionProfile is invalid');
+  }
+  return profile;
+}
+
 function truncateUtf8(text, maxBytes) {
   if (Buffer.byteLength(text) <= maxBytes) return text;
   let bytes = 0;
@@ -140,7 +148,7 @@ export function normalizePolicy(policy = {}) {
 
 export function optimizeToolOutput({
   toolName, output, cwd, policy, selector, raw, lineCount, fileBytes, prose, summarizeProse,
-  summarizeEnabled, grepScope, outputBytes, toolInput,
+  summarizeEnabled, grepScope, outputBytes, toolInput, redactionProfile,
 } = {}) {
   if (typeof toolName !== 'string' || !toolName.trim() || toolName.length > 128) throw new Error('toolName is invalid');
   if (typeof cwd !== 'string' || !cwd) throw new Error('cwd is invalid');
@@ -154,7 +162,8 @@ export function optimizeToolOutput({
     lineCount: derivedLineCount, fileBytes: derivedFileBytes, prose, summarizeProse, summarizeEnabled, grepScope,
     outputBytes: outputBytes ?? Buffer.byteLength(input),
   });
-  const redacted = normalizedPolicy.redact ? redact(input) : { text: input, count: 0 };
+  const profile = normalizedPolicy.redact ? resolveRedactionProfile(cwd, redactionProfile) : null;
+  const redacted = profile ? profile.redact(input) : { text: input, count: 0 };
   let modelText = name === 'bash' && normalizedPolicy.maxColumns >= 32
     ? collapseRepeatedLines(redacted.text)
     : redacted.text;
@@ -192,7 +201,7 @@ export function optimizeToolOutput({
       sourceBytes,
       truncated: false,
     };
-    const header = `artifact ${artifact.ref} ${artifact.bytes}B\n`;
+    const header = `[sando] artifact ${artifact.ref} ${artifact.bytes}B\n`;
     const viewBudget = Math.max(1, routePolicy.maxInlineBytes - Buffer.byteLength(header));
     inline = `${truncateUtf8(header, routePolicy.maxInlineBytes)}${inlineView(
       modelText,
@@ -214,7 +223,10 @@ export function optimizeToolOutput({
     redactions: redacted.count,
     artifactTruncated: artifact?.truncated ?? false,
   };
-  const result = { inline, route: route.route, reason: route.source, policyVersion: ROUTING_POLICY_VERSION, stats };
+  const result = {
+    inline, route: route.route, reason: route.source, policyVersion: ROUTING_POLICY_VERSION,
+    redactionProfileDigest: profile?.digest ?? null, stats,
+  };
   if (artifact) result.artifact = artifact;
   return result;
 }
@@ -252,7 +264,8 @@ export function createReceipt({ host, event, optimization, replacement } = {}) {
     sessionId: event.sessionId ?? null, inputDigest: sha256(textOutput(event.output)),
     inlineDigest: sha256(textOutput(replacement === undefined ? optimization.inline : replacement)), artifactRef: optimization.artifact?.ref ?? null,
     route: optimization.route ?? 'passthrough', reason: optimization.reason ?? 'spike-default',
-    policyVersion: optimization.policyVersion ?? ROUTING_POLICY_VERSION, stats: optimization.stats,
+    policyVersion: optimization.policyVersion ?? ROUTING_POLICY_VERSION,
+    redactionProfileDigest: optimization.redactionProfileDigest ?? null, stats: optimization.stats,
   };
   return { ...body, digest: sha256(stableJson(body)) };
 }

package/src/hook-cli.mjs

@@ -3,6 +3,7 @@ import { randomUUID } from 'node:crypto';
 import path from 'node:path';
 
 import { createReceipt, normalizeEvent, normalizePolicy, optimizeToolOutput } from './core.mjs';
+import { loadProjectRedactionProfile } from './redaction-config.mjs';
 import { defaultMetricsPath, recordMetrics } from './metrics.mjs';
 import {
   closeFinishedDays, defaultTelemetryConfigPath, defaultTelemetryStatePaths, incrementCounter, readTelemetryConfig,
@@ -87,7 +88,8 @@ export function runHookCli({ host, env = process.env } = {}) {
     const eventName = input.hook_event_name ?? input.hookEventName ?? input.event_name ?? input.eventName;
     if (eventName === 'PostToolUse') {
       const event = normalizeEvent(input);
-      const optimization = optimizeToolOutput({ toolName: event.toolName, toolInput: event.toolInput, output: event.output, cwd: event.cwd, policy });
+      const redactionProfile = policy.redact ? loadProjectRedactionProfile(event.cwd).profile : undefined;
+      const optimization = optimizeToolOutput({ toolName: event.toolName, toolInput: event.toolInput, output: event.output, cwd: event.cwd, policy, redactionProfile });
       let shaped;
       if (host === 'claude' && policy.mode === 'apply') {
         shaped = shapeForClaude({
@@ -95,7 +97,7 @@ export function runHookCli({ host, env = process.env } = {}) {
           optimization,
           toolName: event.toolName,
           toolInput: event.toolInput,
-          cwd: event.cwd,
+          cwd: event.cwd, redactionProfile,
           policy,
         });
       }
@@ -117,7 +119,12 @@ export function runHookCli({ host, env = process.env } = {}) {
         }
       }
     }
-  } catch {}
+  } catch (error) {
+    if (error?.code === 'SANDO_REDACTION_CONFIG') {
+      process.stderr.write(`sando invalid redaction config: ${error.message}\n`);
+      process.exitCode = 2;
+    }
+  }
   process.stdout.write('{}\n');
 }
 
@@ -135,19 +142,19 @@ export function buildCodexFallback({ optimization, cwd }) {
   };
 }
 
-function shapeForClaude({ original, optimization, toolName, toolInput, cwd, policy }) {
+function shapeForClaude({ original, optimization, toolName, toolInput, cwd, policy, redactionProfile }) {
   if (typeof original === 'string') return materialize(optimization, cwd);
   if (!original || typeof original !== 'object' || Array.isArray(original)
     || !Object.hasOwn(original, 'stdout') || !Object.hasOwn(original, 'stderr')
     || typeof original.stdout !== 'string' || typeof original.stderr !== 'string'
     || (Object.hasOwn(original, 'interrupted') && typeof original.interrupted !== 'boolean')
     || (Object.hasOwn(original, 'isImage') && typeof original.isImage !== 'boolean')) return undefined;
-  const result = { ...original };
+  const result = policy.redact ? redactionProfile.redactStructured(original).value : { ...original };
   if (typeof original.stdout === 'string') {
-    result.stdout = materialize(optimizeToolOutput({ toolName, toolInput, output: original.stdout, cwd, policy }), cwd);
+    result.stdout = materialize(optimizeToolOutput({ toolName, toolInput, output: original.stdout, cwd, policy, redactionProfile }), cwd);
   }
   if (typeof original.stderr === 'string') {
-    result.stderr = materialize(optimizeToolOutput({ toolName, toolInput, output: original.stderr, cwd, policy }), cwd);
+    result.stderr = materialize(optimizeToolOutput({ toolName, toolInput, output: original.stderr, cwd, policy, redactionProfile }), cwd);
   }
   return result;
 }

package/src/redaction-config.mjs

@@ -0,0 +1,104 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { createRedactionProfile } from './redaction-profile.mjs';
+
+const MAX_CONFIG_BYTES = 64 * 1024;
+const cache = new Map();
+const builtInProfile = createRedactionProfile([]);
+
+function lstatIfPresent(target) {
+  try {
+    return fs.lstatSync(target);
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+function readBoundedFile(configPath, expectedStat) {
+  const flags = fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0);
+  const descriptor = fs.openSync(configPath, flags);
+  try {
+    const stat = fs.fstatSync(descriptor);
+    if (!stat.isFile()) throw new Error(`redaction config is not a regular file: ${configPath}`);
+    if (stat.dev !== expectedStat.dev || stat.ino !== expectedStat.ino) {
+      throw new Error(`redaction config changed while opening: ${configPath}`);
+    }
+    if (stat.size > MAX_CONFIG_BYTES) {
+      throw new Error(`redaction config exceeds 64 KiB: ${configPath}`);
+    }
+
+    const content = Buffer.alloc(MAX_CONFIG_BYTES + 1);
+    let bytesRead = 0;
+    while (bytesRead < content.length) {
+      const count = fs.readSync(descriptor, content, bytesRead, content.length - bytesRead, null);
+      if (count === 0) break;
+      bytesRead += count;
+    }
+    if (bytesRead > MAX_CONFIG_BYTES) {
+      throw new Error(`redaction config exceeds 64 KiB: ${configPath}`);
+    }
+    return new TextDecoder('utf-8', { fatal: true }).decode(content.subarray(0, bytesRead));
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+function parseConfig(source, configPath) {
+  let config;
+  try {
+    config = JSON.parse(source);
+  } catch (error) {
+    throw new Error(`invalid JSON in redaction config ${configPath}: ${error.message}`, { cause: error });
+  }
+
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    throw new Error(`invalid redaction config schema: ${configPath}`);
+  }
+  const keys = Object.keys(config).sort();
+  if (keys.length !== 2 || keys[0] !== 'rules' || keys[1] !== 'schema'
+      || config.schema !== 'sando-redaction/v1' || !Array.isArray(config.rules)) {
+    throw new Error(`invalid redaction config schema: ${configPath}`);
+  }
+  return config;
+}
+
+export function loadProjectRedactionProfile(cwd) {
+  try {
+    return loadProjectRedactionProfileUnsafe(cwd);
+  } catch (error) {
+    if (error?.code === 'SANDO_REDACTION_CONFIG') throw error;
+    const wrapped = new Error(error instanceof Error ? error.message : String(error), { cause: error });
+    wrapped.code = 'SANDO_REDACTION_CONFIG';
+    throw wrapped;
+  }
+}
+
+function loadProjectRedactionProfileUnsafe(cwd) {
+  const configDirectory = path.resolve(cwd, '.sando');
+  const directoryStat = lstatIfPresent(configDirectory);
+  if (!directoryStat) return { profile: builtInProfile, path: null };
+  if (directoryStat.isSymbolicLink()) {
+    throw new Error(`redaction config directory must not be a symlink: ${configDirectory}`);
+  }
+  if (!directoryStat.isDirectory()) {
+    throw new Error(`redaction config directory is not a directory: ${configDirectory}`);
+  }
+
+  const configPath = path.join(configDirectory, 'redaction.json');
+  const stat = lstatIfPresent(configPath);
+  if (!stat) return { profile: builtInProfile, path: null };
+  if (stat.isSymbolicLink()) throw new Error(`redaction config must not be a symlink: ${configPath}`);
+  if (!stat.isFile()) throw new Error(`redaction config is not a regular file: ${configPath}`);
+  if (stat.size > MAX_CONFIG_BYTES) throw new Error(`redaction config exceeds 64 KiB: ${configPath}`);
+
+  const cached = cache.get(configPath);
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) return cached.result;
+
+  const source = readBoundedFile(configPath, stat);
+  const config = parseConfig(source, configPath);
+  const result = { profile: createRedactionProfile(config.rules), path: configPath };
+  cache.set(configPath, { mtimeMs: stat.mtimeMs, size: stat.size, result });
+  return result;
+}

package/src/redaction-profile.mjs

@@ -0,0 +1,163 @@
+import { createHash } from 'node:crypto';
+
+const BUILT_IN_MATCHERS = Object.freeze([
+  [/-----BEGIN [A-Z ]+ KEY-----[\s\S]*?-----END [A-Z ]+ KEY-----/g, '[REDACTED PRIVATE KEY]'],
+  [/(authorization\s*[:=]\s*(?!(?:bearer\s+)?\[REDACTED(?: (?:PRIVATE KEY|TOKEN))?\](?=$|[\s,"'}]))(?:bearer\s+)?)[^\s,"'}]+/gi,
+    (_match, prefix) => `${prefix}[REDACTED]`],
+  [/(["']?(?:api[_-]?key|access[_-]?token|password|secret|private[_-]?key)["']?\s*[:=]\s*["']?)(?!\[REDACTED(?: (?:PRIVATE KEY|TOKEN))?\](?=$|[\s,"'}]))[^\s,"'}]+/gi,
+    (_match, prefix) => `${prefix}[REDACTED]`],
+  [/\b(?:sk|rk)-[A-Za-z0-9_-]{12,}\b/g, '[REDACTED TOKEN]'],
+  [/\bgh[pousr]_[A-Za-z0-9_-]{12,}\b/g, '[REDACTED TOKEN]'],
+  [/\bgithub_pat_[A-Za-z0-9_-]{20,}\b/g, '[REDACTED TOKEN]'],
+  [/\bAKIA[0-9A-Z]{16}\b/g, '[REDACTED TOKEN]'],
+]);
+const PROFILE_SCHEMA = 'sando-redaction-profile-v1';
+const MAX_CUSTOM_RULES = 100;
+const MAX_NAME_LENGTH = 64;
+const MAX_TOKEN_LENGTH = 4096;
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function compareCanonical(left, right) {
+  const a = JSON.stringify(left);
+  const b = JSON.stringify(right);
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function normalizeRules(customRules) {
+  if (!Array.isArray(customRules)) throw new TypeError('customRules must be an array');
+  if (customRules.length > MAX_CUSTOM_RULES) throw new TypeError('customRules must contain at most 100 rules');
+  const identities = new Set();
+  const normalized = customRules.map((rule) => {
+    if (!rule || typeof rule !== 'object' || Array.isArray(rule)
+      || ![Object.prototype, null].includes(Object.getPrototypeOf(rule))) {
+      throw new TypeError('each custom rule must be a plain object');
+    }
+    let result;
+    let identity;
+    if (rule.type === 'assignment-key') {
+      const allowed = new Set(['type', 'key']);
+      if (Reflect.ownKeys(rule).some((field) => typeof field !== 'string' || !allowed.has(field))
+        || typeof rule.key !== 'string'
+        || !new RegExp(`^[A-Za-z0-9][A-Za-z0-9_.-]{0,${MAX_NAME_LENGTH - 1}}$`).test(rule.key)) {
+        throw new TypeError('invalid assignment-key rule');
+      }
+      const key = rule.key.toLowerCase();
+      result = { type: rule.type, key };
+      identity = `${rule.type}:${key}`;
+    } else if (rule.type === 'token-prefix') {
+      const allowed = new Set(['type', 'prefix', 'minLength', 'maxLength']);
+      if (Reflect.ownKeys(rule).some((field) => typeof field !== 'string' || !allowed.has(field))
+        || typeof rule.prefix !== 'string'
+        || !new RegExp(`^[\\x21-\\x7e]{1,${MAX_NAME_LENGTH}}$`).test(rule.prefix)) {
+        throw new TypeError('invalid token-prefix rule');
+      }
+      const minLength = Object.hasOwn(rule, 'minLength') ? rule.minLength : 12;
+      const maxLength = Object.hasOwn(rule, 'maxLength') ? rule.maxLength : null;
+      if (!Number.isSafeInteger(minLength) || minLength < 1 || minLength > MAX_TOKEN_LENGTH
+        || (maxLength !== null
+          && (!Number.isSafeInteger(maxLength) || maxLength < minLength || maxLength > MAX_TOKEN_LENGTH))
+        || (Object.hasOwn(rule, 'maxLength') && rule.maxLength === null)) {
+        throw new TypeError('invalid token-prefix lengths');
+      }
+      result = { type: rule.type, prefix: rule.prefix, minLength, maxLength };
+      identity = `${rule.type}:${rule.prefix}`;
+    } else {
+      throw new TypeError('unsupported custom rule type');
+    }
+    if (identities.has(identity)) throw new TypeError('duplicate custom rule');
+    identities.add(identity);
+    return result;
+  });
+  return normalized.sort(compareCanonical);
+}
+
+function customMatchers(rules) {
+  const assignments = [];
+  const tokens = [];
+  for (const rule of rules) {
+    if (rule.type === 'assignment-key') {
+      const key = escapeRegExp(rule.key);
+      assignments.push([
+        new RegExp(`(?<![A-Za-z0-9_.-])(["']?${key}["']?\\s*[:=]\\s*["']?)(?!\\[REDACTED\\](?=$|[\\s,"'}]))[^\\s,"'}]+`, 'gi'),
+        (_match, prefix) => `${prefix}[REDACTED]`,
+      ]);
+    } else {
+      const maximum = rule.maxLength === null ? '' : rule.maxLength;
+      tokens.push([
+        new RegExp(`(?<![A-Za-z0-9_-])${escapeRegExp(rule.prefix)}[A-Za-z0-9_-]{${rule.minLength},${maximum}}(?![A-Za-z0-9_-])`, 'g'),
+        '[REDACTED]',
+      ]);
+    }
+  }
+  return { assignments, tokens };
+}
+
+function applyMatchers(text, matchers) {
+  let count = 0;
+  for (const [pattern, replacement] of matchers) {
+    text = text.replace(pattern, (...args) => {
+      count += 1;
+      return typeof replacement === 'function' ? replacement(...args) : replacement;
+    });
+  }
+  return { text, count };
+}
+
+export function createRedactionProfile(customRules = []) {
+  const rules = normalizeRules(customRules);
+  const custom = customMatchers(rules);
+  const matchers = [
+    ...BUILT_IN_MATCHERS.slice(0, 3),
+    ...custom.assignments,
+    ...BUILT_IN_MATCHERS.slice(3),
+    ...custom.tokens,
+  ];
+  const digest = `sha256:${createHash('sha256')
+    .update(JSON.stringify({ schema: PROFILE_SCHEMA, customRules: rules }))
+    .digest('hex')}`;
+  const redact = (text) => {
+    if (typeof text !== 'string') throw new TypeError('text must be a string');
+    return applyMatchers(text, matchers);
+  };
+  const redactStructured = (value) => {
+    const ancestors = new Set();
+    const visit = (item) => {
+      if (typeof item === 'string') {
+        const result = redact(item);
+        return { value: result.text, count: result.count };
+      }
+      if (item === null || typeof item === 'boolean' || typeof item === 'number') {
+        return { value: item, count: 0 };
+      }
+      if (typeof item !== 'object'
+        || (!Array.isArray(item) && ![Object.prototype, null].includes(Object.getPrototypeOf(item)))) {
+        throw new TypeError('value must contain only plain objects, arrays, and JSON primitives');
+      }
+      if (ancestors.has(item)) throw new TypeError('value must not be cyclic');
+      ancestors.add(item);
+      let count = 0;
+      const entries = Object.entries(item).map(([key, child]) => {
+        const result = visit(child);
+        count += result.count;
+        return [key, result.value];
+      });
+      ancestors.delete(item);
+      return {
+        value: Array.isArray(item) ? entries.map(([, child]) => child) : Object.fromEntries(entries),
+        count,
+      };
+    };
+    return visit(value);
+  };
+  return {
+    digest,
+    redact,
+    redactStructured,
+    hasSecret(text) {
+      return redact(text).count > 0;
+    },
+  };
+}

package/src/secret-redaction.mjs

@@ -1,21 +1,17 @@
+import { createRedactionProfile } from './redaction-profile.mjs';
+
+const builtInProfile = createRedactionProfile();
+
+export { createRedactionProfile };
+
 export function redact(text) {
-  let count = 0;
-  const replace = (pattern, replacement) => {
-    text = text.replace(pattern, (...args) => {
-      count += 1;
-      return typeof replacement === 'function' ? replacement(...args) : replacement;
-    });
-  };
-  replace(/-----BEGIN [A-Z ]+ KEY-----[\s\S]*?-----END [A-Z ]+ KEY-----/g, '[REDACTED PRIVATE KEY]');
-  replace(/\b(?:sk|rk)-[A-Za-z0-9_-]{12,}\b/g, '[REDACTED TOKEN]');
-  replace(/\bgh[pousr]_[A-Za-z0-9_-]{12,}\b/g, '[REDACTED TOKEN]');
-  replace(/\bgithub_pat_[A-Za-z0-9_-]{20,}\b/g, '[REDACTED TOKEN]');
-  replace(/\bAKIA[0-9A-Z]{16}\b/g, '[REDACTED TOKEN]');
-  replace(/(authorization\s*[:=]\s*(?:bearer\s+)?)[^\s,"'}]+/gi, (_match, prefix) => `${prefix}[REDACTED]`);
-  replace(/(["']?(?:api[_-]?key|access[_-]?token|password|secret|private[_-]?key)["']?\s*[:=]\s*["']?)[^\s,"'}]+/gi, (_match, prefix) => `${prefix}[REDACTED]`);
-  return { text, count };
+  return builtInProfile.redact(text);
+}
+
+export function redactStructured(value, enabled = true) {
+  return enabled ? builtInProfile.redactStructured(value).value : value;
 }
 
 export function hasSecret(text) {
-  return /(?:authorization|api[_-]?key|access[_-]?token|password|secret|private[_-]?key)\s*[:=]\s*(?!\[REDACTED\])\S+|-----BEGIN [A-Z ]+ KEY-----|\b(?:sk|rk)-[A-Za-z0-9_-]{12,}\b|\bgh[pousr]_[A-Za-z0-9_-]{12,}\b|\bgithub_pat_[A-Za-z0-9_-]{20,}\b|\bAKIA[0-9A-Z]{16}\b/i.test(text);
+  return builtInProfile.hasSecret(text);
 }

package/src/semantic-compactor.mjs

@@ -60,7 +60,9 @@ export function buildSemanticPrompt({ provider, model, toolName, text, requiredF
   ].join('\n');
 }
 
-export function validateSemanticSummary({ originalText, summary, requiredFacts = [], maxSummaryRatio = DEFAULT_POLICY.maxSummaryRatio } = {}) {
+export function validateSemanticSummary({
+  originalText, summary, requiredFacts = [], maxSummaryRatio = DEFAULT_POLICY.maxSummaryRatio, redactionProfile,
+} = {}) {
   if (typeof originalText !== 'string' || typeof summary !== 'string') {
     return { valid: false, reason: 'invalid-text' };
   }
@@ -77,7 +79,9 @@ export function validateSemanticSummary({ originalText, summary, requiredFacts =
   }
   const missing = required.find((fact) => !summary.includes(fact));
   if (missing) return { valid: false, reason: 'missing-required-fact', missing, inputTokens, outputTokens };
-  if (hasSecret(summary)) return { valid: false, reason: 'secret-detected', inputTokens, outputTokens };
+  if ((redactionProfile ? redactionProfile.hasSecret(summary) : hasSecret(summary))) {
+    return { valid: false, reason: 'secret-detected', inputTokens, outputTokens };
+  }
   return { valid: true, inputTokens, outputTokens };
 }
 
@@ -111,12 +115,15 @@ async function withTimeout(complete, request, timeoutMs) {
   }
 }
 
-export function createSemanticCompactor({ complete, cache = new Map(), policy } = {}) {
+export function createSemanticCompactor({ complete, cache = new Map(), policy, redactionProfile } = {}) {
   if (typeof complete !== 'function') throw new TypeError('semantic compactor complete callback is required');
   if (!cache || typeof cache.get !== 'function' || typeof cache.set !== 'function') {
     throw new TypeError('semantic compactor cache must implement get and set');
   }
   const options = validatePolicy(policy);
+  if (redactionProfile && (typeof redactionProfile.redact !== 'function' || typeof redactionProfile.hasSecret !== 'function')) {
+    throw new TypeError('redactionProfile is invalid');
+  }
 
   return async function compact({ provider, model, toolName, text, historical = true, isError = false, requiredFacts = [] } = {}) {
     if (typeof text !== 'string') throw new TypeError('semantic compactor text must be a string');
@@ -136,8 +143,8 @@ export function createSemanticCompactor({ complete, cache = new Map(), policy }
     if (isError) return { ...base, status: 'skipped', reason: 'error-result' };
     if (inputTokens < options.minInputTokens) return { ...base, status: 'skipped', reason: 'below-threshold' };
 
-    const safe = redact(text);
-    const safeFacts = required.map((fact) => redact(fact).text);
+    const safe = redactionProfile ? redactionProfile.redact(text) : redact(text);
+    const safeFacts = required.map((fact) => (redactionProfile ? redactionProfile.redact(fact) : redact(fact)).text);
     const prompt = buildSemanticPrompt({ provider, model, toolName, text: safe.text, requiredFacts: safeFacts });
     const key = cacheKey({ provider, model, toolName, text: safe.text, requiredFacts: safeFacts });
     const started = Date.now();
@@ -147,6 +154,7 @@ export function createSemanticCompactor({ complete, cache = new Map(), policy }
       const validation = validateSemanticSummary({
         originalText: text, summary: cached.summary, requiredFacts: required,
         maxSummaryRatio: options.maxSummaryRatio,
+        redactionProfile,
       });
       if (validation.valid) {
         const grossSavedTokens = inputTokens - validation.outputTokens;
@@ -191,6 +199,7 @@ export function createSemanticCompactor({ complete, cache = new Map(), policy }
     const validation = validateSemanticSummary({
       originalText: text, summary, requiredFacts: required,
       maxSummaryRatio: options.maxSummaryRatio,
+      redactionProfile,
     });
     if (!validation.valid) return { ...base, reason: validation.reason, latencyMs: Date.now() - started };