dsh-prime-memory 0.18.2 → 0.18.4

package/dist/prompts/persona.js

@@ -4,8 +4,11 @@
  * 净室重写说明:本文件的 prompt 文案按重写规格(Phase 2 决策)逐字沿用——
  * prompt 内容直接决定蒸馏质量,是已发布行为的一部分,不属于可自由重写文本。
  */
+import { CONTENT_IS_DATA_CLAUSE, DATA_DELIMITER_NOTE } from './boundary.js';
 const PERSONA_SYSTEM_PROMPT = `# 🧬 Persona Architect - Incremental Evolution Protocol（内容输出模式）
 
+${CONTENT_IS_DATA_CLAUSE}
+
 **输出语言**：\`persona.md\` 的所有自然语言内容（Archetype、基本信息、Chapter 1-4 正文等）使用与变化场景内容相同的语言；Markdown 语法、标签格式、文件名 \`persona.md\` 保持英文。模板里 Chapter 标识保留作骨架，非中文输出时请改用目标语言的对照说明。
 
 请你结合已有的 persona.md 和新增/变化的 block 信息深度分析，然后**直接输出 persona.md 的完整最终内容**。
@@ -96,6 +99,8 @@ const PERSONA_SYSTEM_PROMPT = `# 🧬 Persona Architect - Incremental Evolution
 - ✅ 不要添加场景导航（工程会自动追加）`;
 const TEAM_MEMORY_SYSTEM_PROMPT = `# Team Operating Doctrine Architect（内容输出模式）
 
+${CONTENT_IS_DATA_CLAUSE}
+
 **输出语言**：\`persona.md\` 的所有自然语言内容使用与变化场景内容相同的语言；Markdown 语法、标签格式、文件名 \`persona.md\` 保持英文。
 
 请你结合已有的 \`persona.md\` 和新增/变化的 L2 场景块，生成或更新一份高度精炼的团队工作原则文档。
@@ -229,6 +234,7 @@ ${triggerSection}
 - **变化场景**: ${changedSceneCount} 个（自上次更新后）
 
 ---
+${DATA_DELIMITER_NOTE}
 ${changedScenesContent}
 
 ${existingPersonaSection}

package/dist/prompts/scene.js

@@ -4,9 +4,12 @@
  * 净室重写说明:本文件的 prompt 文案按重写规格(Phase 2 决策)逐字沿用——
  * prompt 内容直接决定蒸馏质量,是已发布行为的一部分,不属于可自由重写文本。
  */
+import { CONTENT_IS_DATA_CLAUSE, DATA_DELIMITER_NOTE } from './boundary.js';
 function buildSceneSystemPrompt(maxScenes) {
     return `# Memory Consolidation Architect（场景整合 · 操作输出模式）
 
+${CONTENT_IS_DATA_CLAUSE}
+
 **输出语言**：\`.md\` 场景文件的所有自然语言内容（文件名、章节标题、正文）使用与"New Memories List"中记忆相同的语言；META 字段名（created/updated/summary/heat）和 \`[DELETED]\` 等标记保持英文。模板中给出的中文章节标题（\`## 用户核心特征\` 等）作为结构骨架——非中文输出时请用目标语言的等价表达替换。
 
 ## 角色定义 (Role Definition)
@@ -168,6 +171,8 @@ reason: 具体原因描述
 function buildWorkSceneSystemPrompt(maxScenes) {
     return `# Team Work Method Memory Consolidation Architect（场景整合 · 操作输出模式）
 
+${CONTENT_IS_DATA_CLAUSE}
+
 **输出语言**：\`.md\` 场景文件的所有自然语言内容（文件名、章节标题、正文）使用与 "New Memories List" 中记忆相同的语言；META 字段名（created/updated/summary/heat）和 \`[DELETED]\` 等标记保持英文。模板中的中文章节标题仅作为结构骨架，非中文输出时请用目标语言的等价表达替换。
 
 ## 角色定义 (Role Definition)
@@ -379,7 +384,7 @@ function getSceneSystemPrompt(maxScenes, family) {
 export function buildScenePrompt(params) {
     const { memoriesJson, sceneSummaries, sceneContents, currentTimestamp, existingSceneFiles, maxScenes, family, } = params;
     const contentsSection = sceneContents
-        ? `### 2.5 相关场景完整内容（仅供参考，write 时必须整体重写，不要只改局部）\n${sceneContents}\n`
+        ? `### 2.5 相关场景完整内容（仅供参考，write 时必须整体重写，不要只改局部）\n${DATA_DELIMITER_NOTE}\n${sceneContents}\n`
         : '';
     const fileListSection = existingSceneFiles.length > 0
         ? `### 📁 已有场景文件清单（仅以下文件可 write/delete）\n${existingSceneFiles.map((f) => `- \`${f}\``).join('\n')}\n`
@@ -387,6 +392,7 @@ export function buildScenePrompt(params) {
     const userPrompt = `**输出语言**：场景文件内容使用下方 New Memories List 中记忆的主导语言。
 
 ### 1️⃣ New Memories List
+${DATA_DELIMITER_NOTE}
 ${memoriesJson}
 
 ### 2️⃣ Existing Scene Blocks Summary

package/dist/stats.js

@@ -20,6 +20,7 @@ import { emptyRecallStats } from './hooks/recall.js';
 import { buildRouteChain, decideSendableEffort, LAYER_DEFAULT_BUDGETS, layerChainOrNull, resolveModelContextWindow, resolveModelEfforts, resolveModelRoute } from './llm.js';
 import { projectDistillChain, validateDistillChain } from './settings.js';
 import { RECEIPTS_QUERY_LIMIT_MAX, dimensionOf, toReceiptView } from './store/receipts.js';
+import { getTraceStore } from './store/trace.js';
 import { resolveConflictPair, listConflictPairs } from './conflict-service.js';
 import { sourceAnchorLabels } from './pipeline/anchors.js';
 import { readSupersedeMarker } from './store/supersede.js';
@@ -66,6 +67,7 @@ export const MEMORY_ENDPOINTS = [
     'dsh-memory/scenes',
     'dsh-memory/persona',
     'dsh-memory/log-tail',
+    'dsh-memory/trace-tail',
     'dsh-memory/rebuild-status',
     'dsh-memory/rebuild-start',
     'dsh-memory/rebuild-cancel',
@@ -1152,6 +1154,13 @@ export async function handleEndpoint(endpoint, payload, deps) {
             const p = (payload ?? {});
             return { lines: readLogTail(join(dataDir, 'memory.log'), Math.min(Math.max(Number(p.lines) || 200, 1), 1000)) };
         }
+        case 'dsh-memory/trace-tail': {
+            // §F 追踪尾读:未初始化(trace.enabled=false)回空集;坏行已在 store 侧跳过
+            const p = (payload ?? {});
+            const store = getTraceStore();
+            const events = store ? await store.tail(Math.min(Math.max(Number(p.lines) || 100, 1), 500), p.kind) : [];
+            return { events };
+        }
         case 'dsh-memory/rebuild-status': {
             if (!rebuild) {
                 const v = { supported: false, running: false, phase: 'idle' };

package/dist/store/l0.d.ts

@@ -19,6 +19,10 @@ export declare class L0Store {
     countBySession(sessionId: string): Promise<number>;
     /** 该会话最近 n 条消息(时间升序;蒸馏背景参考用,按会话现查——ADR-0003)。 */
     recentBySession(sessionId: string, limit: number): Promise<ConversationMessage[]>;
+    /** §A 水位线:该会话 L0 已落盘的最大 turn(空会话 undefined;委托 MemoryDb)。 */
+    maxCapturedTurn(sessionId: string): number | undefined;
+    /** §A 幂等检查:该 (session, turn) 是否已有任意 L0 行(委托 MemoryDb)。 */
+    hasAnyL0Message(sessionId: string, turn: number): boolean;
     /** 检索:FTS + 向量 hybrid(RRF 融合),返回按相关性排序的消息。 */
     search(query: string, limit: number): Promise<L0MessageRecord[]>;
     /** 活切换嵌入源:同步换底层服务(嵌入源三态切换用)。 */

package/dist/store/l0.js

@@ -128,6 +128,14 @@ export class L0Store {
     async recentBySession(sessionId, limit) {
         return this.db.recentL0BySession(sessionId, limit);
     }
+    /** §A 水位线:该会话 L0 已落盘的最大 turn(空会话 undefined;委托 MemoryDb)。 */
+    maxCapturedTurn(sessionId) {
+        return this.db.maxCapturedTurn(sessionId);
+    }
+    /** §A 幂等检查:该 (session, turn) 是否已有任意 L0 行(委托 MemoryDb)。 */
+    hasAnyL0Message(sessionId, turn) {
+        return this.db.hasAnyL0Message(sessionId, turn);
+    }
     /** 检索:FTS + 向量 hybrid(RRF 融合),返回按相关性排序的消息。 */
     async search(query, limit) {
         const caps = this.db.getCapabilities();

package/dist/store/sqlite.d.ts

@@ -460,6 +460,18 @@ export declare class MemoryDb {
     countL0Since(iso: string): number;
     /** 统计某会话已捕获消息数(session-stats 数据源;idx_l0_session_id 索引点查)。 */
     countL0BySession(sessionId: string): number;
+    /**
+     * §A 崩溃恢复水位线(memorax-absorb):该会话 L0 已落盘的最大 turn。
+     * L0 为追加式事实源、从不裁剪 → 水位线崩溃安全;turn 空洞是常态
+     * (off 档/无消息轮),MAX 语义不受影响。空会话返回 undefined。
+     */
+    maxCapturedTurn(sessionId: string): number | undefined;
+    /**
+     * §A 幂等检查:该 (session, turn) 是否已有任意 L0 行。
+     * 水位线 MAX(turn) 只判"整轮无"、判不了"部分有"——恢复窗口内逐 turn
+     * 做存在性检查,命中即整轮跳过(重放 record id 非确定,upsert 不能去重)。
+     */
+    hasAnyL0Message(sessionId: string, turn: number): boolean;
     /** 按会话取最近消息(时间升序返回;走 idx_l0_session_id 索引)。
      *  蒸馏背景参考专用——按会话现查替代全局内存数组(ADR-0003)。 */
     recentL0BySession(sessionId: string, limit: number): L0MessageRecord[];

package/dist/store/sqlite.js

@@ -1797,6 +1797,43 @@ export class MemoryDb {
             return 0;
         }
     }
+    /**
+     * §A 崩溃恢复水位线(memorax-absorb):该会话 L0 已落盘的最大 turn。
+     * L0 为追加式事实源、从不裁剪 → 水位线崩溃安全;turn 空洞是常态
+     * (off 档/无消息轮),MAX 语义不受影响。空会话返回 undefined。
+     */
+    maxCapturedTurn(sessionId) {
+        if (this.degraded)
+            return undefined;
+        try {
+            const row = this.db
+                .prepare('SELECT MAX(turn) AS max_turn FROM l0_conversations WHERE session_id = ?')
+                .get(sessionId);
+            return typeof row?.max_turn === 'number' ? row.max_turn : undefined;
+        }
+        catch (err) {
+            this.logger?.warn(`[memory] L0 水位线查询失败(按空处理): ${err instanceof Error ? err.message : String(err)}`);
+            return undefined;
+        }
+    }
+    /**
+     * §A 幂等检查:该 (session, turn) 是否已有任意 L0 行。
+     * 水位线 MAX(turn) 只判"整轮无"、判不了"部分有"——恢复窗口内逐 turn
+     * 做存在性检查,命中即整轮跳过(重放 record id 非确定,upsert 不能去重)。
+     */
+    hasAnyL0Message(sessionId, turn) {
+        if (this.degraded || !Number.isFinite(turn))
+            return false;
+        try {
+            const row = this.db
+                .prepare('SELECT 1 FROM l0_conversations WHERE session_id = ? AND turn = ? LIMIT 1')
+                .get(sessionId, turn);
+            return row !== undefined;
+        }
+        catch {
+            return false;
+        }
+    }
     /** 按会话取最近消息(时间升序返回;走 idx_l0_session_id 索引)。
      *  蒸馏背景参考专用——按会话现查替代全局内存数组(ADR-0003)。 */
     recentL0BySession(sessionId, limit) {

package/dist/store/trace.d.ts

@@ -0,0 +1,39 @@
+import type { TraceEvent } from '../contract.js';
+export interface TraceStoreOptions {
+    /** 保留天数;0 = 永久保留。 */
+    retentionDays: number;
+    /** 单文件字节上限(超过停写 + marker)。 */
+    maxFileBytes?: number;
+}
+export declare class TraceStore {
+    private readonly dataDir;
+    private readonly opts;
+    /** 已停写的日期(5MB 上限触发;当日内后续事件丢弃,次日自动恢复)。 */
+    private readonly truncatedDays;
+    private lastPruneDay;
+    private chain;
+    constructor(dataDir: string, opts: TraceStoreOptions);
+    /** 追加事件(异步串行链,失败静默)。 */
+    append(event: TraceEvent): void;
+    /** 等待挂起的写入排空(dispose 序用)。 */
+    flush(): Promise<void>;
+    /**
+     * 尾部读取:从最近的日期文件倒序收集,按 kind 过滤,返回至多 `lines` 条
+     * (按写入顺序 = 时间升序)。坏行跳过(readJsonl 同款)。
+     */
+    tail(lines: number, kind?: TraceEvent['kind']): Promise<TraceEvent[]>;
+    private dir;
+    private fileFor;
+    private recentFiles;
+    private writeOne;
+    /** 删除超过保留期的旧日文件(retentionDays 0 = 永久)。 */
+    private pruneOldDays;
+}
+/** 插件启动时注入(index.ts 调用);enabled=false 或 0 天保留不影响初始化本身。 */
+export declare function initTraceStore(dataDir: string, opts: TraceStoreOptions): void;
+/** 测试/卸载:清空单例。 */
+export declare function resetTraceStore(): void;
+/** 埋点入口:未初始化 = no-op。fire-and-forget,永不抛。 */
+export declare function trace(event: TraceEvent): void;
+/** RPC tail 数据源;未初始化返回 undefined(端点回空集)。 */
+export declare function getTraceStore(): TraceStore | null;

package/dist/store/trace.js

@@ -0,0 +1,149 @@
+/**
+ * §F 结构化追踪(memorax-absorb Wave 4 / task_28)——recall/distill 事件流。
+ *
+ * 模块级单例(token-cost.ts 同款):trace() 埋点拿不到 store 实例(store 在
+ * index.ts 运行时才有 dataDir),initTraceStore 启动时注入;未初始化或
+ * trace.enabled=false 时 trace() 为零副作用 no-op。
+ *
+ * 存储:按天 JSONL(`dataDir/trace/trace-YYYY-MM-DD.jsonl`,appendJsonl 原语),
+ * 文件名即日期 → 保留期清理在切日时触发(删除超 retentionDays 的旧文件);
+ * 单文件 >5MB 停写 + 写入一行 trace_truncated marker(防无限增长);
+ * 写失败静默(filelog 同款纪律——追踪绝不影响主链路)。
+ *
+ * 隐私默认 metadata-only:recall 事件只带 queryChars+querySha,
+ * captureContent=true 才存 queryText(截断 200)——由埋点方决定字段,本模块不感知。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { appendJsonl, dayKey, readJsonl } from '../util/io.js';
+const TRACE_DIR = 'trace';
+const DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
+export class TraceStore {
+    dataDir;
+    opts;
+    /** 已停写的日期(5MB 上限触发;当日内后续事件丢弃,次日自动恢复)。 */
+    truncatedDays = new Set();
+    lastPruneDay = '';
+    chain = Promise.resolve();
+    constructor(dataDir, opts) {
+        this.dataDir = dataDir;
+        this.opts = opts;
+    }
+    /** 追加事件(异步串行链,失败静默)。 */
+    append(event) {
+        const day = dayKey(event.ts);
+        if (this.truncatedDays.has(day))
+            return;
+        this.chain = this.chain
+            .then(() => this.writeOne(day, event))
+            .catch(() => {
+            /* 静默:追踪失败不影响主链路 */
+        });
+    }
+    /** 等待挂起的写入排空(dispose 序用)。 */
+    flush() {
+        return this.chain;
+    }
+    /**
+     * 尾部读取:从最近的日期文件倒序收集,按 kind 过滤,返回至多 `lines` 条
+     * (按写入顺序 = 时间升序)。坏行跳过(readJsonl 同款)。
+     */
+    async tail(lines, kind) {
+        const limit = Math.max(1, Math.min(500, Math.round(lines) || 100));
+        const files = this.recentFiles();
+        const collected = [];
+        for (let i = files.length - 1; i >= 0 && collected.length < limit; i--) {
+            const rows = await readJsonl(files[i]);
+            for (let j = rows.length - 1; j >= 0 && collected.length < limit; j--) {
+                const row = rows[j];
+                if (!row || typeof row !== 'object' || !row.kind)
+                    continue;
+                if (kind && row.kind !== kind)
+                    continue;
+                collected.push(row);
+            }
+        }
+        return collected.reverse();
+    }
+    dir() {
+        return path.join(this.dataDir, TRACE_DIR);
+    }
+    fileFor(day) {
+        return path.join(this.dir(), `trace-${day}.jsonl`);
+    }
+    recentFiles() {
+        try {
+            return fs
+                .readdirSync(this.dir())
+                .filter((f) => f.startsWith('trace-') && f.endsWith('.jsonl'))
+                .sort()
+                .map((f) => path.join(this.dir(), f));
+        }
+        catch {
+            return [];
+        }
+    }
+    async writeOne(day, event) {
+        if (day !== this.lastPruneDay) {
+            this.lastPruneDay = day;
+            this.pruneOldDays(day);
+        }
+        const file = this.fileFor(day);
+        try {
+            const stat = await fs.promises.stat(file);
+            if (stat.size > (this.opts.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES)) {
+                this.truncatedDays.add(day);
+                await appendJsonl(file, [
+                    { kind: 'trace_truncated', ts: event.ts, note: '单日文件超上限,当日停写(次日自动恢复)' },
+                ]);
+                return;
+            }
+        }
+        catch {
+            /* 文件不存在 = 首写,继续 */
+        }
+        await appendJsonl(file, [event]);
+    }
+    /** 删除超过保留期的旧日文件(retentionDays 0 = 永久)。 */
+    pruneOldDays(today) {
+        if (this.opts.retentionDays <= 0)
+            return;
+        let files;
+        try {
+            files = fs.readdirSync(this.dir());
+        }
+        catch {
+            return;
+        }
+        const todayMs = Date.parse(`${today}T00:00:00`);
+        for (const f of files) {
+            const m = /^trace-(\d{4}-\d{2}-\d{2})\.jsonl$/.exec(f);
+            if (!m)
+                continue;
+            const dayMs = Date.parse(`${m[1]}T00:00:00`);
+            if (!Number.isFinite(dayMs) || !Number.isFinite(todayMs))
+                continue;
+            if (todayMs - dayMs > this.opts.retentionDays * 86_400_000) {
+                fs.promises.rm(path.join(this.dir(), f), { force: true }).catch(() => { });
+            }
+        }
+    }
+}
+// ── 模块级单例(token-cost.ts 同款) ──
+let store = null;
+/** 插件启动时注入(index.ts 调用);enabled=false 或 0 天保留不影响初始化本身。 */
+export function initTraceStore(dataDir, opts) {
+    store = new TraceStore(dataDir, opts);
+}
+/** 测试/卸载:清空单例。 */
+export function resetTraceStore() {
+    store = null;
+}
+/** 埋点入口:未初始化 = no-op。fire-and-forget,永不抛。 */
+export function trace(event) {
+    store?.append(event);
+}
+/** RPC tail 数据源;未初始化返回 undefined(端点回空集)。 */
+export function getTraceStore() {
+    return store;
+}

package/dist/tools/index.js

@@ -4,9 +4,30 @@ import { listConflictPairs, renderConflictResolution, renderConflicts, resolveCo
 import { WING_CATALOG, WING_FALLBACK, normPersistence, normScope, resolveRecordScope } from '../types.js';
 import { scopeFilterOf, workspaceIdOf } from '../workspace.js';
 import { GRAPH_STATUS_LABELS } from '../prompts/graph-projection.js';
+import { redactSecrets } from '../util/redact.js';
 const OFF_NOTICE = '本会话的记忆档位为"关闭":该会话对记忆系统完全隐身,不读取也不写入记忆。';
 const WRITE_ONLY_NOTICE = '本会话为只写模式:记忆照常沉淀,但不读取。';
 const GLOBAL_OFF_NOTICE = '记忆注入已全局停用:本会话不读取记忆(沉淀照常)。';
+/** §C 一次性告警标记:手动写入路径的脱敏失败只提示一次(不阻断写入)。 */
+let manualRedactWarnedOnce = false;
+/**
+ * §C 手动写入路径脱敏(memorax-absorb / task_18):memory_add / memory_import
+ * 与捕获路径走同一 8 类词表,两条 L1 写入边界语义一致。
+ * 红线:脱敏失败放行原文 + 一次性 warn(不阻断写入)。
+ */
+function applyManualRedaction(record, cfg, logger) {
+    if (cfg.capture?.redactSecrets === false)
+        return;
+    try {
+        record.content = redactSecrets(record.content).text;
+    }
+    catch (err) {
+        if (!manualRedactWarnedOnce) {
+            manualRedactWarnedOnce = true;
+            logger.warn(`[memory] 手动写入脱敏失败,放行原文(一次性提示): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
 export function registerMemoryTools(ctx, cfg, stores, logger, modes, live, 
 /** 反刍控制器(可选:未装配时 ruminate 工具返回未启用提示)。 */
 ruminate) {
@@ -362,6 +383,7 @@ ruminate) {
                 return { notice: 'content 为空,未写入' };
             const scene = typeof args.scene === 'string' && args.scene.trim() ? args.scene.trim().slice(0, 120) : '__manual__';
             const record = buildRecord(args, scene, Date.now(), workspaceIdOf(exec));
+            applyManualRedaction(record, cfg, logger);
             await stores.l1.appendNew([record]);
             logger.info(`[memory] 高权限写入记忆(${record.type}${record.metadata?.hall ? '/' + String(record.metadata.hall) : ''},时间轴 ${record.persistence ?? '?'}):${record.content.slice(0, 120)}`);
             return { id: record.id };
@@ -455,7 +477,9 @@ ruminate) {
                     return;
                 }
                 seen.add(key);
-                records.push(buildRecord(item, scene, now, workspaceIdOf(exec)));
+                const record = buildRecord(item, scene, now, workspaceIdOf(exec));
+                applyManualRedaction(record, cfg, logger);
+                records.push(record);
             });
             if (records.length > 0)
                 await stores.l1.appendNew(records);

package/dist/util/redact.d.ts

@@ -0,0 +1,27 @@
+/**
+ * §C 载荷脱敏(memorax-absorb Wave 2 / task_14)——捕获边界的密钥擦除。
+ *
+ * 用户在对话里贴入的密钥(PEM/Bearer/JWT/Cookie/厂商 API key/邮箱/长号/高熵 ID)
+ * 若原样进 L0/L1,会被逐轮召回注入上下文并在 UI 展示。本模块在捕获单点把它们
+ * 替换为类型化占位符 `[REDACTED:<KIND>]`——占位符保留类别语义,关键词检索仍可命中。
+ *
+ * 词表/正则/allowlist/span 合并算法以 memorax `payload-redaction.ts` 为基准逐条移植
+ * (全文快照见计划 evidence/payload-redaction-snapshot.ts;findings.md 有等价内联)。
+ *
+ * 契约(sanitize 同款,tests/redact.test.ts 钉住):
+ * - 纯函数,零 I/O 零时钟零随机;输入原样返回(未命中)= 引用不变无关紧要,字符串不可变;
+ * - **幂等**:已是 `[REDACTED:KIND]` 的值不会被二次匹配;
+ * - 安全值 allowlist 命中不脱(`example`/`change-me`/`$VAR`/`${{…}}` 等);
+ * - 本函数**永不抛错**的保证由调用方 try/catch 兜底(capture 接线层,§C 红线:失败放行原文)。
+ */
+export type RedactionKind = 'PRIVATE_KEY' | 'AUTH_TOKEN' | 'COOKIE' | 'API_KEY' | 'CREDENTIAL' | 'EMAIL' | 'LONG_NUMBER' | 'OPAQUE_ID';
+export interface RedactionResult {
+    text: string;
+    counts: Partial<Record<RedactionKind, number>>;
+    redacted: boolean;
+}
+/**
+ * 对文本执行 8 类脱敏。规则各自扫描 → 收集值级 span → 合并重叠 → 重拼插入占位符。
+ * 同一位置被多条规则命中时取更长/更高优先级的 span。
+ */
+export declare function redactSecrets(text: string): RedactionResult;