principles-disciple 1.7.3 → 1.7.5

package/dist/hooks/lifecycle.js

@@ -4,6 +4,7 @@ import * as readline from 'readline';
 import { writePainFlag } from '../core/pain.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { PD_DIRS } from '../core/paths.js';
+import { extractWorkingMemory, mergeWorkingMemory } from '../core/focus-history.js';
 export async function handleBeforeReset(event, ctx) {
     if (!ctx.workspaceDir || !event.messages || event.messages.length === 0) {
         return;
@@ -147,6 +148,7 @@ export async function extractPainFromSessionFile(sessionFile, ctx) {
 export async function handleBeforeCompaction(event, ctx) {
     if (!ctx.workspaceDir)
         return;
+    const wctx = WorkspaceContext.fromHookContext(ctx);
     const dateStr = new Date().toISOString().split('T')[0];
     const checkpointPath = path.join(ctx.workspaceDir, PD_DIRS.MEMORY, `${dateStr}.md`);
     const log = `\n## [${new Date().toISOString()}] Pre-Compaction Checkpoint\n` +
@@ -161,8 +163,110 @@ export async function handleBeforeCompaction(event, ctx) {
     catch (_e) {
         console.error(`[PD:Lifecycle] Failed to write pre-compaction checkpoint: ${String(_e)}`);
     }
+    // 提取工作记忆（从 sessionFile）
     if (event.sessionFile) {
         await extractPainFromSessionFile(event.sessionFile, ctx);
+        // 新增：提取并保存工作记忆
+        await extractAndSaveWorkingMemory(event.sessionFile, ctx, wctx);
+    }
+}
+/**
+ * 从会话文件提取工作记忆并保存到 CURRENT_FOCUS.md
+ */
+async function extractAndSaveWorkingMemory(sessionFile, ctx, wctx) {
+    if (!fs.existsSync(sessionFile)) {
+        if (ctx.logger?.debug)
+            ctx.logger.debug(`[WorkingMemory] Session file not found: ${sessionFile}`);
+        return;
+    }
+    const messages = [];
+    let lineCount = 0;
+    const MAX_LINES = 1000; // 限制处理的行数，避免内存问题
+    // 读取会话文件
+    const fileStream = fs.createReadStream(sessionFile);
+    const rl = readline.createInterface({
+        input: fileStream,
+        crlfDelay: Infinity
+    });
+    try {
+        for await (const line of rl) {
+            if (lineCount >= MAX_LINES)
+                break;
+            if (!line.trim())
+                continue;
+            lineCount++;
+            try {
+                const msg = JSON.parse(line);
+                messages.push(msg);
+            }
+            catch {
+                // 忽略解析错误
+            }
+        }
+    }
+    finally {
+        try {
+            rl.close();
+            fileStream.destroy();
+        }
+        catch {
+            // 忽略清理错误
+        }
+    }
+    if (messages.length === 0) {
+        if (ctx.logger?.debug)
+            ctx.logger.debug(`[WorkingMemory] No messages found in session file`);
+        return;
+    }
+    // 提取工作记忆
+    const snapshot = extractWorkingMemory(messages, ctx.workspaceDir);
+    // 检查是否有有效内容
+    if (snapshot.artifacts.length === 0 &&
+        snapshot.activeProblems.length === 0 &&
+        snapshot.nextActions.length === 0) {
+        if (ctx.logger?.debug)
+            ctx.logger.debug(`[WorkingMemory] No working memory to preserve`);
+        return;
+    }
+    // 读取并更新 CURRENT_FOCUS.md
+    const focusPath = wctx.resolve('CURRENT_FOCUS');
+    try {
+        let content = '';
+        if (fs.existsSync(focusPath)) {
+            content = fs.readFileSync(focusPath, 'utf-8');
+            // 备份原文件（防止损坏）
+            const backupPath = `${focusPath}.wm-backup`;
+            fs.copyFileSync(focusPath, backupPath);
+        }
+        // 合并工作记忆
+        const updatedContent = mergeWorkingMemory(content, snapshot);
+        // 确保目录存在
+        const focusDir = path.dirname(focusPath);
+        if (!fs.existsSync(focusDir)) {
+            fs.mkdirSync(focusDir, { recursive: true });
+        }
+        // 写入文件
+        fs.writeFileSync(focusPath, updatedContent, 'utf-8');
+        if (ctx.logger) {
+            ctx.logger.info(`[WorkingMemory] Preserved ${snapshot.artifacts.length} artifacts, ` +
+                `${snapshot.activeProblems.length} problems, ` +
+                `${snapshot.nextActions.length} next actions to CURRENT_FOCUS.md`);
+        }
+    }
+    catch (err) {
+        console.error(`[PD:Lifecycle] Failed to save working memory: ${String(err)}`);
+        // 尝试恢复备份
+        const backupPath = `${focusPath}.wm-backup`;
+        if (fs.existsSync(backupPath)) {
+            try {
+                fs.copyFileSync(backupPath, focusPath);
+                if (ctx.logger)
+                    ctx.logger.warn(`[WorkingMemory] Restored from backup after failure`);
+            }
+            catch {
+                // 忽略恢复错误
+            }
+        }
     }
 }
 export async function handleAfterCompaction(event, ctx) {

package/dist/hooks/pain.js

@@ -6,6 +6,7 @@ import { getSession, trackFriction, resetFriction, getInjectedProbationIds, clea
 import { denoiseError, computeHash } from '../utils/hashing.js';
 import { SystemLogger } from '../core/system-logger.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
+import { getEvolutionLogger, createTraceId } from '../core/evolution-logger.js';
 const WRITE_TOOLS = ['write', 'edit', 'apply_patch', 'write_file', 'edit_file', 'replace'];
 function shouldAttributePrincipleToTool(principle, toolName) {
     return principle.contextTags.includes(toolName) || principle.trigger.includes(toolName);
@@ -38,6 +39,7 @@ export function handleAfterToolCall(event, ctx, api) {
     // 0. Special Case: Manual Pain Intervention
     if (event.toolName === 'pain' || event.toolName === 'skill:pain') {
         const reason = params.input || params.arguments || 'Manual intervention';
+        const traceId = createTraceId();
         trackFriction(sessionId, 100, 'manual_pain', effectiveWorkspaceDir);
         SystemLogger.log(effectiveWorkspaceDir, 'MANUAL_PAIN', `User manually triggered pain: ${reason}`);
         eventLog.recordPainSignal(sessionId, {
@@ -53,6 +55,16 @@ export function handleAfterToolCall(event, ctx, api) {
             reason: `User intervention: ${reason}`,
             origin: 'user_manual',
         });
+        // Log to EvolutionLogger
+        const evoLogger = getEvolutionLogger(effectiveWorkspaceDir, wctx.trajectory);
+        evoLogger.logPainDetected({
+            traceId,
+            source: 'manual',
+            reason: `User intervention: ${reason}`,
+            score: 100,
+            toolName: event.toolName,
+            sessionId,
+        });
         emitPainDetectedEvent(wctx, {
             ts: new Date().toISOString(),
             type: 'pain_detected',
@@ -63,6 +75,8 @@ export function handleAfterToolCall(event, ctx, api) {
                 reason: `User intervention: ${reason}`,
                 score: 100,
                 sessionId,
+                traceId,
+                agentId: ctx.agentId,
             },
         });
         return;
@@ -212,12 +226,16 @@ export function handleAfterToolCall(event, ctx, api) {
     }
     const isRisk = isRisky(relPath, profile.risk_paths);
     const painScore = computePainScore(1, false, false, isRisk ? 20 : 0, effectiveWorkspaceDir);
+    const traceId = createTraceId();
     const painData = {
         score: String(painScore),
         source: 'tool_failure',
         time: new Date().toISOString(),
         reason: `Tool ${event.toolName} failed on ${relPath}. Error: ${event.error ?? 'Non-zero exit code'}`,
         is_risky: String(isRisk),
+        trace_id: traceId,
+        session_id: sessionId,
+        agent_id: ctx.agentId || '',
     };
     writePainFlag(effectiveWorkspaceDir, painData);
     eventLog.recordPainSignal(sessionId, {
@@ -234,6 +252,17 @@ export function handleAfterToolCall(event, ctx, api) {
         severity: painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild',
         origin: 'system_infer',
     });
+    // Log to EvolutionLogger
+    const evoLogger = getEvolutionLogger(effectiveWorkspaceDir, wctx.trajectory);
+    evoLogger.logPainDetected({
+        traceId,
+        source: 'tool_failure',
+        reason: `Tool ${event.toolName} failed on ${relPath}`,
+        score: painScore,
+        toolName: event.toolName,
+        filePath: relPath,
+        sessionId,
+    });
     emitPainDetectedEvent(wctx, {
         ts: new Date().toISOString(),
         type: 'pain_detected',
@@ -244,6 +273,8 @@ export function handleAfterToolCall(event, ctx, api) {
             reason: `Tool ${event.toolName} failed on ${relPath}`,
             score: painScore,
             sessionId,
+            traceId,
+            agentId: ctx.agentId,
         },
     });
 }

package/dist/hooks/prompt.js

@@ -3,7 +3,7 @@ import * as path from 'path';
 import { clearInjectedProbationIds, getSession, resetFriction, setInjectedProbationIds } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { defaultContextConfig } from '../types.js';
-import { extractSummary, getHistoryVersions } from '../core/focus-history.js';
+import { extractSummary, getHistoryVersions, parseWorkingMemorySection, workingMemoryToInjection, autoCompressFocus, safeReadCurrentFocus } from '../core/focus-history.js';
 import { empathyObserverManager } from '../service/empathy-observer-manager.js';
 import { PathResolver } from '../core/path-resolver.js';
 /**
@@ -123,13 +123,15 @@ function resolveEvolutionTask(inProgressTask, messages, maxContextMessages = 4,
     const rawTask = typeof inProgressTask.task === 'string' ? inProgressTask.task.trim() : '';
     if (rawTask && rawTask.toLowerCase() !== 'undefined')
         return rawTask;
+    if (typeof inProgressTask.id !== 'string' || !inProgressTask.id.trim())
+        return null;
     const source = typeof inProgressTask.source === 'string' ? inProgressTask.source.trim() : 'unknown';
     const reason = typeof inProgressTask.reason === 'string' ? inProgressTask.reason.trim() : 'Systemic pain detected';
     const preview = typeof inProgressTask.trigger_text_preview === 'string' && inProgressTask.trigger_text_preview.trim()
         ? inProgressTask.trigger_text_preview.trim()
         : 'N/A';
-    if (typeof inProgressTask.id !== 'string' || !inProgressTask.id.trim())
-        return null;
+    const sessionId = typeof inProgressTask.session_id === 'string' ? inProgressTask.session_id.trim() : '';
+    const agentId = typeof inProgressTask.agent_id === 'string' ? inProgressTask.agent_id.trim() : '';
     const conversationContext = includeConversationContext
         ? extractRecentConversationContext(messages, maxContextMessages, maxCharsPerMsg)
         : '';
@@ -142,16 +144,60 @@ function resolveEvolutionTask(inProgressTask, messages, maxContextMessages = 4,
 `;
     taskDescription += `**Trigger Text**: "${preview}"
 `;
+    if (sessionId) {
+        taskDescription += `**Session ID**: ${sessionId}
+`;
+    }
+    if (agentId) {
+        taskDescription += `**Agent ID**: ${agentId}
+`;
+    }
     if (conversationContext) {
         taskDescription += `
 ---
 **Recent Conversation Context**:
 ${conversationContext}`;
+    }
+    else if (!sessionId) {
+        taskDescription += `
+---
+**Note**: 对话上下文不可用。请主动收集证据：
+1. 从 Reason 字段提取关键词，搜索相关代码
+2. 读取 .state/logs/events.jsonl 最近日志
+3. 基于 Reason 中的文件路径定位问题`;
     }
     taskDescription += `
 
 ---
-Analyze the root cause using 5 Whys methodology. Check evidence in codebase before concluding.`;
+## 执行指令
+
+使用 5 Whys 方法进行根因分析，输出 JSON 格式结果。
+
+### 必执行步骤：
+1. **Phase 1 - 证据收集**: 读取日志、搜索代码，记录证据来源
+2. **Phase 2 - 因果链构建**: 每个 Why 必须有证据支撑，最多 5 层
+3. **Phase 3 - 根因分类**: 归类为 People/Design/Assumption/Tooling
+4. **Phase 4 - 原则提炼**: 提炼可复用的防护原则
+
+### 终止条件（满足任一即停止）:
+- 找到可修改代码直接解决的问题
+- 找到缺失的门禁规则或检查机制
+- 连续 2 个 Why 无法提出更深假设
+
+### 输出格式：
+\`\`\`json
+{
+  "diagnosis_report": {
+    "task_id": "...",
+    "summary": "一句话总结根因",
+    "causal_chain": [...],
+    "root_cause": { "category": "Design", "description": "..." },
+    "principle": { "trigger_pattern": "...", "action": "..." }
+  }
+}
+\`\`\`
+
+详细执行协议请参考你的系统提示词。`;
     return taskDescription;
 }
 /**
@@ -199,7 +245,6 @@ export function resolveModelFromConfig(modelConfig, logger) {
     }
     // 闁哄秶鍘х槐?3: 闁轰焦澹嗙划宥夊冀閻撳海纭€闁挎稑鐗呯粭澶愬绩椤栨稑鐦柨娑樿嫰瑜板倿宕欐ウ娆惧妳闁告稑顭槐?
     if (Array.isArray(modelConfig)) {
-        console.warn(`[PD:Prompt] Array model config not supported. Expected "provider/model" string or { primary: "..." } object.`);
         logger?.warn(`[PD:Prompt] Array model config not supported. Expected "provider/model" string or { primary: "..." } object.`);
         return null;
     }
@@ -359,8 +404,8 @@ You are a **self-evolving AI agent** powered by Principles Disciple.
 **Tool Routing Rules**:
 - Use the current session for the normal user reply.
 - Use sessions_send for cross-session messaging.
-- Use agents_list / sessions_list / sessions_spawn for peer-agent or session orchestration.
-- Use pd_run_worker only for Principles Disciple internal workers such as diagnostician/explorer.
+- Use agents_list / sessions_list / sessions_spawn for peer-agent or peer-session orchestration.
+- Use sessions_spawn with pd-diagnostician/pd-explorer/etc skills for internal worker tasks.
 
 ## 妫ｅ啯鎯?INTERNAL SYSTEM LAYOUT
 - Your core plugin logic is rooted at: ${PathResolver.getExtensionRoot() || 'EXTENSION_ROOT (unresolved)'}
@@ -378,7 +423,7 @@ You are a **self-evolving AI agent** powered by Principles Disciple.
         trustContext += `Hygiene: ${hygiene.persistenceCount} persists today\n`;
         // Stage-based restrictions
         if (safeStage === 1) {
-            trustContext += `ACTION CONSTRAINT: You are in READ-ONLY MODE. You MUST use the internal pd_run_worker diagnostician worker to recover trust before writing files. Do not use it for peer-session messaging.\n`;
+            trustContext += `ACTION CONSTRAINT: You are in READ-ONLY MODE. You MUST use sessions_spawn with the pd-diagnostician skill to recover trust before writing files.\n`;
         }
         else if (safeStage === 2) {
             trustContext += `ACTION CONSTRAINT: LIMITED MODE. You are restricted to a maximum of 50 lines per edit.\n`;
@@ -397,47 +442,71 @@ You are a **self-evolving AI agent** powered by Principles Disciple.
     if (fs.existsSync(queuePath)) {
         try {
             const queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
-            const inProgressTask = queue.find((t) => t.status === 'in_progress');
-            if (inProgressTask) {
+            const inProgressTasks = [...queue]
+                .filter((t) => t.status === 'in_progress')
+                .sort((a, b) => {
+                const scoreA = Number.isFinite(a?.score) ? Number(a.score) : 0;
+                const scoreB = Number.isFinite(b?.score) ? Number(b.score) : 0;
+                return scoreB - scoreA;
+            });
+            for (const inProgressTask of inProgressTasks) {
                 const resolvedTask = resolveEvolutionTask(inProgressTask, event.messages, contextConfig.evolutionContext.maxMessages, contextConfig.evolutionContext.maxCharsPerMessage, contextConfig.evolutionContext.enabled);
                 if (!resolvedTask) {
-                    logger?.warn('[PD:Prompt] Skipping evolution task injection because task payload is invalid.');
+                    continue;
                 }
-                else {
-                    const escapedTask = JSON.stringify(resolvedTask);
-                    logger?.info(`[PD:Prompt] Injecting EVOLUTION TASK for: ${inProgressTask.id}`);
-                    if (trigger === 'user') {
-                        evolutionDirective = `<evolution_task priority="high">
+                const escapedTask = JSON.stringify(resolvedTask);
+                logger?.info(`[PD:Prompt] Injecting EVOLUTION TASK for: ${inProgressTask.id}`);
+                if (trigger === 'user') {
+                    evolutionDirective = `<evolution_task priority="high">
 TASK: ${escapedTask}
 
-REQUIRED ACTION:
-- First respond to the user's current request normally.
-- After finishing the user-facing response, call:
-  pd_run_worker agentType="diagnostician" task=${escapedTask} runInBackground=true
-- Treat pd_run_worker as an internal Principles Disciple worker, not a peer-session messaging tool.
+REQUIRED ACTION (两阶段回复):
+
+**阶段 1 - 立即回复用户:**
+简要告知用户你检测到的问题，例如：
+"我注意到刚才的操作遇到了一些问题（简述问题），我已安排诊断代理在后台分析根因。分析完成后会继续告诉你结果。"
+
+然后调用：
+  sessions_spawn(task="使用 pd-diagnostician skill 执行诊断任务。\n\n任务: ${escapedTask}")
+
+**阶段 2 - 收到子代理结果后:**
+当收到诊断代理的完成消息后，用以下格式回复用户：
+
+"**诊断完成** 🔍
+
+基于后台分析结果：
+- **根因**: [一句话总结]
+- **分类**: [People/Design/Assumption/Tooling]
+- **建议**: [可执行的改进建议]
+
+相关原则已记录到 PRINCIPLES.md。"
+
+IMPORTANT:
 - Do NOT reply with "[EVOLUTION_ACK]".
-- Do NOT let this task interrupt the current user interaction.
+- 子代理结果会作为新消息到达，届时再进行阶段2的回复。
 </evolution_task>\n`;
-                    }
-                    else {
-                        evolutionDirective = `<evolution_task priority="critical">
+                }
+                else {
+                    evolutionDirective = `<evolution_task priority="critical">
 TASK: ${escapedTask}
 
 REQUIRED ACTION:
 - Start diagnostics immediately by calling:
-  pd_run_worker agentType="diagnostician" task=${escapedTask} runInBackground=true
-- Treat pd_run_worker as an internal Principles Disciple worker, not a peer-session messaging tool.
+  sessions_spawn(task="使用 pd-diagnostician skill 执行诊断任务。\n\n任务: ${escapedTask}")
 - Do NOT reply with "[EVOLUTION_ACK]".
 </evolution_task>\n`;
-                    }
                 }
+                break;
+            }
+            if (!evolutionDirective && inProgressTasks.length > 0) {
+                logger?.warn('[PD:Prompt] Skipping evolution task injection because task payload is invalid.');
             }
         }
         catch (e) {
             logger?.error(`[PD:Prompt] Failed to parse EVOLUTION_QUEUE: ${String(e)}`);
         }
     }
-    // Inject evolution directive at the front of prependContext
+    // Inject queue-derived evolution task at the front of prependContext
     if (evolutionDirective) {
         prependContext = evolutionDirective + prependContext;
     }
@@ -541,31 +610,56 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
     }
     // Project Context (configurable: full/summary/off) - moved to appendSystemContext for WebUI UX
     let projectContextContent = '';
+    let workingMemoryContent = '';
     if (!isMinimalMode && contextConfig.projectFocus !== 'off') {
         const focusPath = wctx.resolve('CURRENT_FOCUS');
-        if (fs.existsSync(focusPath)) {
+        const extensionRoot = PathResolver.getExtensionRoot();
+        // 🔒 安全读取：自动验证格式，损坏时从模板恢复
+        const { content: currentFocus, recovered, validationErrors } = safeReadCurrentFocus(focusPath, extensionRoot || '', logger);
+        if (recovered) {
+            logger?.info?.(`[PD:Prompt] CURRENT_FOCUS.md was recovered from template`);
+        }
+        if (validationErrors.length > 0) {
+            logger?.warn?.(`[PD:Prompt] CURRENT_FOCUS validation errors: ${validationErrors.join(', ')}`);
+        }
+        if (currentFocus.trim()) {
             try {
-                const currentFocus = fs.readFileSync(focusPath, 'utf8').trim();
-                if (currentFocus) {
+                // 🚀 自动压缩门禁：检查文件大小，超过阈值自动压缩
+                const stateDir = wctx.stateDir;
+                const compressResult = autoCompressFocus(focusPath, workspaceDir, stateDir);
+                if (compressResult.compressed) {
+                    logger?.info?.(`[PD:Prompt] Auto-compressed CURRENT_FOCUS: ${compressResult.oldLines} → ${compressResult.newLines} lines. Milestones archived: ${compressResult.milestonesArchived}`);
+                }
+                else if (compressResult.reason === 'Rate limited (24h interval)') {
+                    logger?.debug?.(`[PD:Prompt] Auto-compress skipped: ${compressResult.reason}`);
+                }
+                // 重新读取（可能被压缩更新了）
+                const finalContent = fs.readFileSync(focusPath, 'utf8').trim();
+                if (finalContent) {
+                    // 解析工作记忆部分（用于独立注入）
+                    const workingMemorySnapshot = parseWorkingMemorySection(finalContent);
+                    if (workingMemorySnapshot) {
+                        workingMemoryContent = workingMemoryToInjection(workingMemorySnapshot);
+                    }
                     if (contextConfig.projectFocus === 'summary') {
                         // Summary mode: intelligent extraction prioritizing key sections
-                        projectContextContent = extractSummary(currentFocus, 30);
+                        projectContextContent = extractSummary(finalContent, 30);
                     }
                     else {
                         // Full mode: current version + recent history (3 versions)
                         const historyVersions = getHistoryVersions(focusPath, 3);
                         if (historyVersions.length > 0) {
-                            const historySections = historyVersions.map((v, i) => `\n---\n\n**闁告ê妫楄ぐ鍫曟偋閸喐鎷?v${historyVersions.length - i}**\n\n${v}`).join('');
-                            projectContextContent = `${currentFocus}${historySections}`;
+                            const historySections = historyVersions.map((v, i) => `\n---\n\n**历史版本 v${historyVersions.length - i}**\n\n${v}`).join('');
+                            projectContextContent = `${finalContent}${historySections}`;
                         }
                         else {
-                            projectContextContent = currentFocus;
+                            projectContextContent = finalContent;
                         }
                     }
                 }
             }
             catch (e) {
-                logger?.error(`[PD:Prompt] Failed to read CURRENT_FOCUS: ${String(e)}`);
+                logger?.error(`[PD:Prompt] Failed to process CURRENT_FOCUS: ${String(e)}`);
             }
         }
     }
@@ -607,12 +701,16 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
         logger?.warn?.(`[PD:Prompt] Failed to load evolution principles: ${String(e)}`);
     }
     // Build appendSystemContext with recency effect
-    // Content order (most important last): project_context -> reflection_log -> thinking_os -> principles
+    // Content order (most important last): project_context -> working_memory -> reflection_log -> thinking_os -> principles
     const appendParts = [];
     // 1. Project Context (lowest priority, goes first)
     if (projectContextContent) {
         appendParts.push(`<project_context>\n${projectContextContent}\n</project_context>`);
     }
+    // 1.5. Working Memory (preserved from last compaction)
+    if (workingMemoryContent) {
+        appendParts.push(workingMemoryContent);
+    }
     // 2. Reflection Log
     if (reflectionLogContent) {
         appendParts.push(`<reflection_log>\n${reflectionLogContent}\n</reflection_log>`);

package/dist/hooks/subagent.d.ts

@@ -4,6 +4,7 @@ type SubagentEndedHookContext = PluginHookSubagentContext & {
     api?: EmpathyObserverApi;
     workspaceDir?: string;
     sessionId?: string;
+    agentId?: string;
 };
 export declare function handleSubagentEnded(event: PluginHookSubagentEndedEvent, ctx: SubagentEndedHookContext): Promise<void>;
 export {};