hyacinth-ai 0.9.6

package/dist/context/router.js

@@ -0,0 +1,291 @@
+// ============================================================
+// ContextRouter — 统一上下文路由器
+// ============================================================
+//
+// 每个模式（normal / companion / world_sim 等）对应一个 Router 实例。
+// Router 统一接管原本散落在 ContextProfile + ComposeStrategy + 硬编码判断
+// 中的全部上下文行为。
+//
+// 新增模式只需：
+//   1. 实现 IContextRouter 接口
+//   2. 在 registerRouter() 调用中注册
+//   3. 调用 switchRouter(name) 即可全局切换
+// ============================================================
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { filterToolRounds } from './precision/companion.js';
+import { CompanionSessionManager } from '../memory/companion-session.js';
+import { parseNarration } from '../bypass/agents/companion/index.js';
+import { companionUserId, mainUserId, narrationUserId, orchestratorUserId } from '../provider/user-id.js';
+// ── NormalRouter ───────────────────────────────────────────
+// 正常模式：全部工具、全部 sections、默认 persona、默认 memory。
+// 行为等价于 NORMAL_PROFILE + DefaultStrategy。
+export class NormalRouter {
+    name = 'normal';
+    toolAllowlist = [];
+    toolBlacklist = ['reset_companion_session'];
+    skipSections = [];
+    skipRuntimeSources = [];
+    sourceOverrides = {};
+    filterHistory(history) {
+        return history;
+    }
+    getTaskPrompt(taskName) {
+        return `[Scheduled Task Triggered]\nYour scheduled task "${taskName}" has just been triggered. Execute it now. If this was a one-shot task, it has completed — no need to reschedule.`;
+    }
+}
+// ── CompanionRouter ────────────────────────────────────────
+// 陪伴模式：精简工具、跳过框架能力/注册表、陪伴 persona、陪伴 memory。
+// 行为等价于 COMPANION_PROFILE + CompanionStrategy + 硬编码 companion 判断。
+const COMPANION_TOOL_ALLOWLIST = [
+    'companion_mode', 'reset_companion_session',
+    'add_task', 'list_tasks', 'remove_task', 'toggle_task',
+    'read', 'write', 'edit',
+];
+const COMPANION_SKIP_SECTIONS = [
+    'persona_soul', 'framework_capabilities', 'tool_rules', 'attention', 'project_context',
+];
+const COMPANION_SKIP_RUNTIME_SOURCES = [
+    'skills', 'agents', 'mcp', 'tool_bundles', 'tool_bundle_expand', 'mcp_live', 'tools_live',
+    'flow', 'channel_context',
+];
+const COMPANION_TOOL_PROMPT = '有些事，你可以这样去做：' +
+    '他离开了，道个别（companion_mode deactivate）。' +
+    '这样可以和他重新聊聊了（reset_companion_session）。' +
+    '得记住他刚才说的东西，到时候叫他（add_task）。' +
+    '得回想一下，有哪些需要提醒他的东西。现况如何？（list_tasks）。' +
+    '他之前说的那个东西不用管了，不叫了（remove_task）。' +
+    '关于提醒这个事儿，他有别的想法（toggle_task）。' +
+    '需要看点别的东西了（read）。' +
+    '写东西喽（write）。' +
+    '得改一下了（edit）。';
+// ── 时间戳概率注入 ────────────────────────────────────────
+// 从 section-resolver.ts 迁移至此。模拟人对时间的不经意感知：
+//   首条消息 / 用户主动问时间 → 100% 注入
+//   连续对话中的随机轮次 → 10% 概率注入
+const TIMESTAMP_INJECT_PROBABILITY = 0.30;
+const FIRST_CONTACT_THRESHOLD = 4;
+const TIME_QUERY_RE = /时间|几点|什么时候|时候|几点了|现在几点|什么时候了|几点钟|现在时间|现在什么时候|这会儿几点|多晚了/;
+function countUserMessages(history) {
+    if (!history)
+        return 0;
+    return history.filter(m => m.role === 'user').length;
+}
+function shouldInjectTimestamp(ctx) {
+    // 首次接触：每轮都注入时间，帮助建立时间感
+    const userMsgCount = countUserMessages(ctx.history);
+    if (userMsgCount <= FIRST_CONTACT_THRESHOLD)
+        return true;
+    // 用户主动问时间 → 必须注入
+    if (ctx.userInput && TIME_QUERY_RE.test(ctx.userInput))
+        return true;
+    // 连续对话：掷骰子
+    return Math.random() < TIMESTAMP_INJECT_PROBABILITY;
+}
+/** 取某角色最后一条消息里的纯文本（供世界引擎观察上一轮对话） */
+function lastTextByRole(history, role) {
+    for (let i = history.length - 1; i >= 0; i--) {
+        const m = history[i];
+        if (m.role !== role)
+            continue;
+        const blocks = Array.isArray(m.content) ? m.content : [m.content];
+        const text = blocks
+            .filter((b) => b?.type === 'text')
+            .map(b => b.text)
+            .join('')
+            .trim();
+        if (text)
+            return text;
+    }
+    return '';
+}
+export class CompanionRouter {
+    name = 'companion';
+    toolAllowlist = COMPANION_TOOL_ALLOWLIST;
+    toolBlacklist = [];
+    skipSections = COMPANION_SKIP_SECTIONS;
+    skipRuntimeSources = COMPANION_SKIP_RUNTIME_SOURCES;
+    sourceOverrides = {
+        persona_soul: {
+            source: 'prompts/persona/PartnerSoul',
+            append: COMPANION_TOOL_PROMPT,
+        },
+        memory: {
+            source: 'companion_memory',
+        },
+    };
+    /** 世界引擎旁路Agent 引用（通过 BypassManager 获取） */
+    worldEngineAgent = null;
+    get worldEngineEnabled() {
+        return this.worldEngineAgent?.enabled ?? false;
+    }
+    /** 当前活跃的陪伴角色名（如"柔柔"），决定世界数据与对话的存储路径 */
+    activeCompanionName = '';
+    /** 本轮 timestamp 槽位是否被世界旁白顶替——决定它以 assistant（内心独白）还是 user 注入 */
+    _timestampIsNarration = false;
+    /**
+     * 本轮是否为「纯旁白轮」（用户只发 [[环境]]、无对话）。
+     * 纯旁白轮里，环境信息已由 transformUserInput 作为本轮 user 输入注入，
+     * 故 beforeSection 不再在 timestamp 槽重复注入旁白（也避免二次调用旁路 LLM）。
+     */
+    _pureNarrationTurn = false;
+    ephemeralInput = null;
+    filterHistory(history) {
+        return filterToolRounds(history);
+    }
+    /**
+     * 陪伴模式旁白路由：解析 [[...]] 旁白 → 交给旁路落实进世界 → 返回剥离后的对话。
+     * 纯旁白（无对话）时返回一个轻量触发，让陪伴角色对更新后的场景做出反应。
+     * 世界引擎未开启则原样返回（等价无操作）。
+     */
+    async transformUserInput(userInput) {
+        this._pureNarrationTurn = false; // 每轮先复位
+        this.ephemeralInput = null; // 每轮先清除
+        if (!this.worldEngineEnabled)
+            return userInput;
+        const agent = this.worldEngineAgent;
+        const { narration, dialogue } = parseNarration(userInput);
+        // 总是刷新本轮旁白（无 [[]] 则设空，避免上一轮旁白泄漏到这一轮）
+        agent.setPendingNarration(narration);
+        if (!narration)
+            return userInput; // 没有旁白，对话原样
+        if (dialogue)
+            return dialogue; // 混合输入：只把对话部分交给主 LLM，旁白已并入 narrate
+        // 纯旁白（用户只发 [[环境]]、无对话）：
+        //   先跑旁路 LLM，产出的环境信息作为本轮「瞬态 input」——
+        //   它触发主 LLM 回应，但绝不落盘到 conversation.jsonl，
+        //   下一轮发送自然消失，不会被当成用户消息。
+        this._pureNarrationTurn = true;
+        // 纯旁白轮不走 bypassManager.preTurn（那里等着也拿不到 pendingNarration），
+        // 直接调 engine.narrate() 后立即返回
+        const enriched = await agent.narrate();
+        const trigger = enriched || narration;
+        this.ephemeralInput = trigger; // loop 用它注入 compose，但不 append
+        return trigger;
+    }
+    async beforeSection(sec, ctx) {
+        // 角色 persona：从角色目录读取（~/.agent/companion/<name>/persona.md）
+        if (sec.name === 'persona_soul' && this.activeCompanionName) {
+            const file = path.join(os.homedir(), '.agent', 'companion', this.activeCompanionName, 'persona.md');
+            try {
+                let content = await fs.readFile(file, 'utf-8');
+                const append = this.sourceOverrides['persona_soul']?.append;
+                if (append)
+                    content = content + '\n\n' + append;
+                return content;
+            }
+            catch {
+                // 文件不存在 → 返回空 persona（不降级到旧路径）
+                return '';
+            }
+        }
+        // 时间戳 section：
+        // 世界引擎旁白已由 BypassManager.preTurn → bypassInjections 处理，
+        // 此处只处理时间戳概率注入（世界引擎未启用/世界为空时的回落逻辑）。
+        if (sec.name === 'timestamp') {
+            this._timestampIsNarration = false;
+            // 纯旁白轮跳过
+            if (this._pureNarrationTurn) {
+                return null;
+            }
+            // 世界引擎启用 → 旁白由 bypassInjections 处理，此处跳过正常时间戳
+            if (this.worldEngineEnabled) {
+                this._timestampIsNarration = true;
+                return null; // 让 bypassInjections 的 replace 模式接管
+            }
+            // 无世界引擎 → 正常时间戳概率注入
+            if (!shouldInjectTimestamp(ctx)) {
+                return null;
+            }
+        }
+        return undefined; // 其他 section：继续正常解析
+    }
+    /** 世界旁白顶替 timestamp 槽位时，以 assistant 身份注入，读起来像陪伴者的内心独白 */
+    roleForSection(name) {
+        if (name === 'timestamp' && this._timestampIsNarration)
+            return 'assistant';
+        return undefined;
+    }
+    async onActivate(loop) {
+        // 角色名未设置时，尝试从 .last-character 恢复上次使用的角色
+        if (!this.activeCompanionName) {
+            try {
+                const last = await fs.readFile(path.join(os.homedir(), '.agent', 'companion', '.last-character'), 'utf-8');
+                const restored = last.trim();
+                if (restored)
+                    this.activeCompanionName = restored;
+            }
+            catch { }
+        }
+        if (!this.activeCompanionName)
+            return;
+        const name = this.activeCompanionName;
+        // 保存正常 session 路径（用于 deactivate 时切换回去）
+        if (!loop._normalSessionDir) {
+            loop._normalSessionDir = loop.sessionDir;
+        }
+        const sm = CompanionSessionManager.getInstance();
+        sm.setCharacter(name);
+        const companionDir = sm.getOrCreate();
+        await loop.switchSession(companionDir);
+        // 通知 TUI session 已切换，触发界面刷新
+        loop._sessionSwitched = companionDir;
+        // 切换到陪伴模式的 KVCache 隔离 ID（主Agent + 旁路）
+        loop.setActiveUserId(companionUserId(name));
+        loop.setBypassUserId(narrationUserId());
+        // 通过 BypassManager 激活世界引擎旁路Agent
+        const bypassMgr = loop.bypassManager;
+        if (bypassMgr) {
+            // 确保 WorldEngine 使用正确的角色名
+            const existing = bypassMgr.getAgent('world-engine');
+            if (existing) {
+                // 更新角色名并重新注册
+                const { WorldEngine } = await import('../bypass/agents/companion/index.js');
+                bypassMgr.register(new WorldEngine(name));
+            }
+            // 激活陪伴模式的旁路Agent
+            await bypassMgr.activateForMode('companion');
+            // 获取激活后的 WorldEngine 引用
+            this.worldEngineAgent = bypassMgr.getAgent('world-engine');
+        }
+    }
+    async onDeactivate(loop) {
+        // 通过 BypassManager 停用旁路Agent
+        try {
+            await loop.bypassManager?.deactivateAll();
+        }
+        catch { /* 忽略 */ }
+        this.worldEngineAgent = null;
+        let normalDir = loop._normalSessionDir;
+        // Fallback：从存档恢复的陪伴会话没有保存 _normalSessionDir，需要创建新 normal session
+        if (!normalDir) {
+            const { SessionManager } = await import('../memory/session.js');
+            const sm = new SessionManager(process.cwd());
+            const session = await sm.create('normal');
+            normalDir = sm.getSessionDir(session.id);
+        }
+        await loop.switchSession(normalDir);
+        loop._normalSessionDir = undefined;
+        // 恢复到普通模式的 KVCache 隔离 ID（主Agent + 旁路）
+        loop.setActiveUserId(mainUserId(path.basename(normalDir)));
+        loop.setBypassUserId(orchestratorUserId());
+        // 通知 TUI session 已切换，触发界面刷新
+        loop._sessionSwitched = normalDir;
+    }
+    getTaskPrompt(_taskName) {
+        return '（你忽然想和他说句话...）';
+    }
+    async onPostTurn(loop, taskName, toolWasCalled) {
+        // 世界引擎 postTurn 已由 BypassManager.postTurn 统一调度，此处只处理陪伴模式特有的 JSONL 清理
+        if (taskName !== null) {
+            // 定时任务触发：删触发词+工具链，保留模型自然回复（看起来像主动搭话）
+            await loop.removeTriggerFromJsonl();
+        }
+        else if (toolWasCalled) {
+            // 普通工具调用：整轮抹除（用户消息+工具调用+回复全丢，模型不感知）
+            await loop.cleanCompanionJsonl();
+        }
+    }
+}
+//# sourceMappingURL=router.js.map

package/dist/context/section-resolver.d.ts

@@ -0,0 +1,38 @@
+import type { Message } from '../types.js';
+import type { SectionEntry } from './manifest-types.js';
+import type { TokenCounter } from './tokenizer.js';
+import type { ContextSource } from './interface.js';
+import type { GitManager } from '../evolution/git-manager.js';
+import type { ContextProfile } from './profiles.js';
+import type { IContextRouter } from './router.js';
+import type { Injection } from '../bypass/types.js';
+export interface ResolverContext {
+    cwd: string;
+    tools: Array<{
+        name: string;
+    }>;
+    userInput: string;
+    timestamp: string;
+    historySummary?: string;
+    currentPlan?: string;
+    impactInfo?: string;
+    history?: Message[];
+    fullHistory?: Message[];
+    zone3Hashes?: Set<string>;
+    maxContextTokens: number;
+    sources?: Map<string, ContextSource>;
+    selectedSkills?: string[];
+    selectedAgents?: string[];
+    gitManager?: GitManager;
+    tokenCounter: TokenCounter;
+    activeConditions?: Set<string>;
+    /** 当前模式 profile——保留向后兼容，新代码使用 router */
+    profile: ContextProfile;
+    /** 当前模式 router——统一上下文路由入口 */
+    router: IContextRouter;
+    /** 旁路Agent注入列表（由 BypassManager.preTurn 产出） */
+    bypassInjections?: Injection[];
+}
+export declare function resolveSection(sec: SectionEntry, ctx: ResolverContext): Promise<string | undefined>;
+export declare function buildSoulSection(): string;
+//# sourceMappingURL=section-resolver.d.ts.map