berry-agent 0.1.0-alpha.1

package/dist/host/issue-session.js

@@ -0,0 +1,241 @@
+import { createBudgetBroadcast } from './budget-broadcast.js';
+/** 首跑 source（03 §2.2 provenance 盖章——core:issue 件身份；plugin: 域谱系） */
+const ISSUE_SUBMIT_SOURCE = 'plugin:core:issue';
+/** 唤醒消息 source（04 §5 + 05 §3.1 同笔词行——source 闭集恰六字面量成员） */
+const WAKE_SOURCE = 'budget-extended';
+/** 唤醒消息文本（durable user/message 载体——模型侧「预算恢复继续任务」指令） */
+const WAKE_MESSAGE = '后台预算日池已恢复（budget_extended）——请继续此前停靠时未完成的任务，完成后按原交付纪律收口。';
+/** watchdog / 唤醒 watcher 轮询间隔缺省（1s——观测粒度与轮询成本的折中；测试注窄值） */
+const DEFAULT_POLL_MS = 1000;
+/** assistant/message 事件计数（每 issue 帽的计量面——messagesUsed 同源） */
+function countAssistantMessages(events) {
+    let count = 0;
+    for (const event of events) {
+        if (event.type === 'assistant/message')
+            count += 1;
+    }
+    return count;
+}
+/** 尾扫末条 assistant 消息文本（summary 来源——subagent-factory 同型扫描） */
+function lastAssistantText(events) {
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const event = events[i];
+        if (event === undefined || event.type !== 'assistant/message')
+            continue;
+        const blocks = event.data?.content;
+        if (!Array.isArray(blocks))
+            return '';
+        return blocks
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text)
+            .join('');
+    }
+    return '';
+}
+/** 被拒审批计数（needs-human 检测——decision ∉ {approve, always} 即被拒面） */
+function deniedApprovalCount(events) {
+    let count = 0;
+    for (const event of events) {
+        if (event.type !== 'approval/decided')
+            continue;
+        const decision = event.data?.decision;
+        if (decision !== 'approve' && decision !== 'always')
+            count += 1;
+    }
+    return count;
+}
+/**
+ * issue headless 会话真工厂（CorePluginHostDeps.issueSession seam 的本体——
+ * 装配根接线后 core:issue 主闸三通过，生产面件装载解锁）。
+ */
+export function createIssueSessionFactory(options) {
+    const { stack, canAfford } = options;
+    const warn = options.warn ?? ((message) => console.error(message));
+    const pollMs = options.pollMs ?? DEFAULT_POLL_MS;
+    /** 停靠登记表（唤醒 watcher 扫描面——跨 startHeadless 共享，进程生命周期） */
+    const parked = new Set();
+    // 广播件解析（u-3——04 §5 定形注①升格）：注入形 = 宿主单真身（三停靠面
+    // 同播，dispose 归宿主停机序不归本工厂）；缺席 = 自建私有实例（同一实现
+    // 单源——独立装配形/测试形零降级，工厂 dispose 时同笔收口）
+    const ownsBroadcast = options.broadcast === undefined;
+    const broadcast = options.broadcast ?? createBudgetBroadcast({ canAfford, pollMs });
+    async function startHeadless(req) {
+        // 终局外壳：停靠 = 保持 pending（编排层 await 悬停——04 §5 不落终态语义
+        // 的实现载体）；dispose 的 paused 收口也走同一 settle（一次结算幂等护栏）
+        let settleOutcome;
+        const outcome = new Promise((resolve) => {
+            settleOutcome = resolve;
+        });
+        // 会话装配（origin 'trigger'——SessionOrigin 闭集五值无 issue 位，触发
+        // 谱系归并；workspaceRoot = worktree canonical 路径——fs fence/bash 沙箱
+        // 锚定；extraTools = 件注册的只读工具面经管道注册位并入）
+        const child = stack.manager.create({
+            origin: 'trigger',
+            workspaceRoot: req.cwd,
+            title: 'issue（headless）',
+            extraTools: () => req.tools,
+        });
+        const driver = child.driver;
+        const sessionId = child.sessionId;
+        let finished = false; // 终局已收口（settle 幂等护栏）
+        let running = false; // 在飞旗（watchdog 只在飞时执法——停靠/idle 期不误伤）
+        let abortCause; // watchdog abort 归因（外部 abort 缺席）
+        const eventsOf = () => driver.session.events();
+        const messagesUsed = () => countAssistantMessages(eventsOf());
+        let watchdog;
+        const stopWatchdog = () => {
+            if (watchdog !== undefined) {
+                clearInterval(watchdog);
+                watchdog = undefined;
+            }
+        };
+        /** 终局收口（一次结算 + 清轮询 + 双侧摘登记 + 单会话收口——subagent-factory 同律） */
+        const finish = (result) => {
+            if (finished)
+                return;
+            finished = true;
+            parked.delete(entry);
+            broadcast.unregister(entry); // 广播侧同笔摘（宿主级面不再扫描已收口项）
+            stopWatchdog();
+            stack.manager.retire(sessionId); // dismantle 终态停摆 + 摘活体登记（05 §7 retire 律）
+            settleOutcome(result);
+        };
+        /** 停靠登记（04 §5——outcome 悬置 + 会话上下文保留，驱动活体不 dismantle）。
+         *  u-3 落词（04 §5 定形注②）：预算语境停靠在目标会话落 session/paused
+         *  （reason 'budget'）——daemon 猝死后冷启动可恢复呈现；两触发位（起跑前
+         *  池检/watchdog 收口后）皆在 run 收口后或未起跑，词行「收口后落词」合规。
+         *  复停靠（唤醒轮再停靠）再落一笔——append 事实流，尾条即停靠态由
+         *  SessionLiveState 推导 */
+        const parkNow = (reason) => {
+            parked.add(entry);
+            broadcast.register(entry); // 宿主级广播面登记（canAfford 恢复同播三面之一）
+            driver.session.append('session/paused', { reason: 'budget' });
+            warn(`issue 会话停靠（${sessionId}）：${reason}——待 budget_extended 唤醒（04 §5 不落终态）`);
+        };
+        /**
+         * 单轮起跑编舞（首跑与唤醒轮共用）：起跑前池检 → watchdog 启动 →
+         * submit → 终局映射。
+         */
+        const runRound = async (text, source, backgroundWake) => {
+            if (finished)
+                return;
+            // 起跑前池检（04 §5 有帽 run 池尽停靠——首跑与唤醒轮同律）
+            if (!canAfford()) {
+                parkNow('起跑前日池尽');
+                return;
+            }
+            abortCause = undefined;
+            running = true;
+            // watchdog 两执法（在飞期轮询——主 loop stream 道无预算闸，会话侧停靠
+            // 执法位在此；先帽后池序：每 issue 帽是编排纪律、日池是全局纪律）
+            watchdog = setInterval(() => {
+                if (!running || abortCause !== undefined)
+                    return;
+                if (messagesUsed() >= req.budgetMessages) {
+                    abortCause = 'cap';
+                    driver.abort();
+                    return;
+                }
+                if (!canAfford()) {
+                    abortCause = 'budget';
+                    driver.abort();
+                }
+            }, pollMs);
+            watchdog.unref();
+            let result;
+            try {
+                result = await driver.submit(text, { source, ...(backgroundWake ? { backgroundWake: true } : {}) });
+            }
+            catch (err) {
+                // 驱动层永不抛（契约位）——防御收口：诚实 failed 不悬挂编排层
+                running = false;
+                stopWatchdog();
+                finish({
+                    status: 'failed',
+                    messagesUsed: messagesUsed(),
+                    reason: `会话提交异常（防御位——驱动层契约永不抛）：${err instanceof Error ? err.message : String(err)}`,
+                });
+                return;
+            }
+            running = false;
+            stopWatchdog();
+            if (finished)
+                return; // dispose 已收口（迟到结算弃）
+            const used = messagesUsed();
+            if (result.status === 'completed') {
+                // needs-human 检测（04 §10 消费注执法细则）：被拒审批在场 = 成果需
+                // 人审（保守偏向——判定纯事件载荷闭集，不猜模型文本）
+                const denied = deniedApprovalCount(eventsOf());
+                if (denied > 0) {
+                    finish({
+                        status: 'needs-human',
+                        messagesUsed: used,
+                        reason: `审批被拒 ${denied} 次（无人应答收口/守门拒——04 §9 fail-closed），成果需人审`,
+                    });
+                    return;
+                }
+                finish({ status: 'completed', messagesUsed: used, summary: lastAssistantText(eventsOf()) });
+                return;
+            }
+            if (result.status === 'failed') {
+                finish({ status: 'failed', messagesUsed: used, reason: result.errorMessage ?? 'run 失败（无错误详情）' });
+                return;
+            }
+            if (result.status === 'aborted') {
+                if (abortCause === 'budget') {
+                    parkNow('run 中日池尽（watchdog 协作中止）');
+                    return;
+                }
+                if (abortCause === 'cap') {
+                    finish({
+                        status: 'failed',
+                        messagesUsed: used,
+                        reason: `每 issue 预算帽耗尽（${req.budgetMessages} 条——04 §5 每 issue 帽与全局池两层分账）`,
+                    });
+                    return;
+                }
+                finish({ status: 'failed', messagesUsed: used, reason: 'run 被外部中止' });
+                return;
+            }
+            // injected / wake-refused（通道收执形）：活体 driver 提交 injected 理论
+            // 不达；wake-refused 真实可达（连续后台唤醒超帽——鲸鱼任务诚实边界）
+            finish({
+                status: 'failed',
+                messagesUsed: used,
+                reason: result.status === 'wake-refused'
+                    ? '连续后台唤醒超帽（04 §4 maxConsecutiveWakes=3——鲸鱼任务跨 4 个日池窗，需人工介入或提额）'
+                    : `提交未起跑（${result.status}——理论不达防御位，诚实回执）`,
+            });
+        };
+        const entry = {
+            wake() {
+                parked.delete(entry); // 先摘（再停靠时 parkNow 重登记——双侧同笔）
+                broadcast.unregister(entry);
+                void runRound(WAKE_MESSAGE, WAKE_SOURCE, true);
+            },
+            dispose() {
+                finish({
+                    status: 'paused',
+                    reason: '宿主停机收口——停靠项保留 worktree 与授予（orphanScan 标注，重轮询再入走让位序）',
+                });
+            },
+        };
+        // 首轮起跑（fire——outcome promise 即回执，编排层自行 await）
+        void runRound(req.prompt, ISSUE_SUBMIT_SOURCE, false);
+        return { sessionId, outcome };
+    }
+    // 唤醒扫描（u-3 升格——04 §5 定形注①）：原工厂私有 watcher 已升格宿主级
+    // 广播件（budget-broadcast.ts 装配根单真身三停靠面同播；电平判语义逐字
+    // 平移——有停靠项且 canAfford 恢复即触发，防环不靠边沿靠 driver 三帽）。
+    // 本工厂只持登记面（parkNow 双登记 / finish·wake 双侧摘）
+    return {
+        startHeadless,
+        dispose() {
+            for (const entry of [...parked])
+                entry.dispose(); // finish 内双侧摘登记
+            // 自建私有形同笔收口；注入形宿主真身归停机序——不可在此关闭
+            if (ownsBroadcast)
+                broadcast.dispose();
+        },
+    };
+}

package/dist/host/loader.js

@@ -0,0 +1,372 @@
+/**
+ * host/loader — 插件装载管线（03 §1.3/§1.4/§3/§5.7；批 12d）。
+ *
+ * 装载序 = 服务可用性驱动的 Kahn 轮次（§1.3「inject 求值后服务缺席即拒启」
+ * 的排序真源）：逐行扫描，inject ⊆ 现行服务集者装载——apply 期间 ctx.provide
+ * 落新服务，后续轮次自然解锁依赖方；不动点余行 = inject 不可达（用户行
+ * 隔离降级 PLUGIN_INJECT_UNRESOLVED，core: 行 fail-loud 拒启——狗粮纪律）。
+ *
+ * 双轨装载（§1.4）：core: 官方引用形对象直调 apply（零 jiti 零门禁——同仓
+ * 同版本）；用户插件磁盘装载——jiti 实例（virtualModules 宿主面直注〔防双
+ * 实例〕+ import 门禁字面量腿〔transform throw 形 + fsCache 关——03 §3.3
+ * 批 12d 勘正〕+ interop default）。入口解析序三态承 manifest 件（12a）：
+ * entry-file / 纯声明包（零码装载）/ default-export（包主入口）。
+ *
+ * 失败三档（§5.7）：① 清单校验失败拒换——归调用方（parseEnabledRows 先行）；
+ * ② 用户行装载失败 = 行级隔离降级——onBootFailure 记账（boot-failures 件
+ * 接线位）+ 其余行照常；③ disposer 回卷失败 = 降级存活（unload 聚合报告）。
+ * core: 行装载失败 = fail-loud 抛（已活行 LIFO 回卷后不留半装配）。
+ *
+ * 时钟（§3.4）：apply 10s / 插件 disposer 回卷 1s——超时按失败处置不悬挂。
+ * ctx 面归调用方（createContext 注入——泛型 TCtx；注册动词族/服务目录随
+ * conversation/TUI 装配批定形）。
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createJiti } from 'jiti';
+import { BaseError } from '../contracts/index.js';
+import { providerApiFace } from '../llm/index.js';
+import { synthesizePluginConfig } from './config-schema.js';
+import { createGateTransform } from './import-gate.js';
+import { withoutSessionAnchor } from './session-anchor.js';
+import { withTimeout } from './runtime.js';
+/**
+ * 声明载荷目录解析 + 包根包含执法（生态启动批 eco-1——pi 反面实证：pi-lens
+ * 声明 `"skills": ["../../skills"]` 裸 resolve 逃逸包根仍被装载）。resolve
+ * 归一后须等于基或以 `<base>/` 开头（同 isWithinRoots 谓词形——port.ts/
+ * skills manage 同律）；违例抛 PLUGIN_SHAPE_INVALID（磁盘行折失败行隔离降级）。
+ */
+function resolveDeclaredDirs(dirs, base, pluginId) {
+    return (dirs ?? []).map((dir) => {
+        const abs = resolve(base, dir);
+        if (abs !== base && !abs.startsWith(base + sep)) {
+            throw new BaseError('PLUGIN_SHAPE_INVALID', `声明载荷目录逃逸装载基（插件 ${pluginId}：${dir} 解析为 ${abs}、出界基 ${base}——须相对包根内路径）`);
+        }
+        return abs;
+    });
+}
+/** core: 行声明基（宿主包根——src/host 与 dist/host 双形态上推两级皆包根） */
+const hostPackageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+/** core: 行 fail-loud 抛形（已活行已 LIFO 回卷——不留半装配） */
+export class CorePluginBootError extends BaseError {
+    failure;
+    constructor(failure, options) {
+        super(failure.code, `core: 官方件装载失败拒启（${failure.id}）：${failure.message}`, options);
+        this.failure = failure;
+    }
+}
+/**
+ * 装载管线主入口（async——jiti ESM 求值 + 虚拟面 lazy 直注）。
+ */
+export async function loadPlugins(options) {
+    const applyBudgetMs = options.applyBudgetMs ?? 10_000;
+    const disposerBudgetMs = options.disposerBudgetMs ?? 1_000;
+    const virtualFaces = options.virtualFaces ?? (await loadDefaultVirtualFaces());
+    const activated = [];
+    const failed = [];
+    const skipped = [];
+    // 回卷栈：依激活序入栈——unload LIFO 全序（§5.7 档③）
+    const disposeStack = [];
+    let unloaded = false;
+    const pending = [];
+    for (const row of options.plan) {
+        if (row.disabled)
+            skipped.push({ id: row.id, reason: 'disabled（启用行禁用位）' });
+        else
+            pending.push(row);
+    }
+    // Kahn 轮次：每轮取首条 inject 可满足行装载（apply 落新服务解锁后续轮）
+    while (pending.length > 0) {
+        const index = pending.findIndex((row) => injectOf(row).every((name) => options.services.get(name) !== undefined));
+        if (index === -1)
+            break; // 不动点——余行 inject 不可达
+        const [row] = pending.splice(index, 1);
+        try {
+            await loadRow(row, { options, virtualFaces, applyBudgetMs, disposeStack, activated });
+        }
+        catch (err) {
+            const failure = toFailure(row.id, err);
+            if (row.kind === 'core') {
+                // core: fail-loud 拒启——已活行 LIFO 回卷后抛（不留半装配）
+                await rollback(disposeStack, disposerBudgetMs);
+                throw new CorePluginBootError(failure, { cause: err });
+            }
+            failed.push(failure); // 用户行隔离降级——其余行照常（档②）
+            options.onBootFailure?.(row.id, row.manifest?.version ?? '', failure);
+        }
+    }
+    // 不动点余行：inject 不可达（含环——环成员互等永不满足）
+    for (const row of pending.splice(0)) {
+        const missing = injectOf(row).filter((name) => options.services.get(name) === undefined);
+        const failure = {
+            id: row.id,
+            code: 'PLUGIN_INJECT_UNRESOLVED',
+            message: `硬依赖服务不可达：${missing.length > 0 ? missing.join('、') : '（环依赖）'}`,
+        };
+        if (row.kind === 'core') {
+            await rollback(disposeStack, disposerBudgetMs);
+            throw new CorePluginBootError(failure);
+        }
+        failed.push(failure);
+        options.onBootFailure?.(row.id, row.manifest.version ?? '', failure);
+    }
+    return {
+        activated,
+        failed,
+        skipped,
+        unload: async () => {
+            if (unloaded)
+                return { disposed: [], failed: [] }; // 幂等
+            unloaded = true;
+            const disposed = [];
+            const unloadFailed = [];
+            while (disposeStack.length > 0) {
+                const item = disposeStack.pop();
+                try {
+                    await withTimeout(Promise.resolve(item.fn()), disposerBudgetMs, `disposer ${item.id}`);
+                    disposed.push(item.id);
+                }
+                catch (err) {
+                    // 档③降级存活——聚合报告不炸
+                    unloadFailed.push({ id: item.id, error: err });
+                }
+            }
+            return { disposed, failed: unloadFailed };
+        },
+    };
+}
+/** 单行装载（行内失败上抛——由调用侧分档处置） */
+async function loadRow(row, state) {
+    const { options, applyBudgetMs } = state;
+    try {
+        // 开门授予集只随磁盘行透传（core: 行无 opens 位——读侧已拒，结构性保证）
+        const ctx = options.createContext(row.id, row.kind === 'disk' ? row.opens : undefined);
+        // 装载位配置合成（ix-3——03 §1.2 合成序）：configSchema 缺席 = 行为零变化
+        // （原值直传零校验——双轨同判）；在场 = 行 config 整值覆盖宿主默认 → 字段级
+        // 校验 → default 兜底 → secret 凭证直取 → 未声明键透传。磁盘轨宿主默认
+        // 回落 = 清单 config 键（schema/值分键后值单源；旧「config 当 typebox
+        // schema 消费」路径已拆）；core 轨 = 引用形 config 位（既有回落不变）。
+        const defaultConfig = row.kind === 'core' ? row.reference.config : row.manifest.config;
+        const config = synthesizePluginConfig({
+            pluginId: row.id,
+            ...(row.kind === 'core'
+                ? row.reference.configSchema !== undefined && { fields: row.reference.configSchema }
+                : row.manifest.configSchema !== undefined && { fields: row.manifest.configSchema }),
+            ...(row.config !== undefined && { rowConfig: row.config }),
+            ...(defaultConfig !== undefined && { defaultConfig }),
+            ...(options.getConfigSecret !== undefined && {
+                getSecret: (key) => options.getConfigSecret?.(row.id, key),
+            }),
+            ...(options.allowMissingRequiredSecret === true && { allowMissingRequiredSecret: true }),
+            ...(options.warn !== undefined && { warn: options.warn }),
+        });
+        if (row.kind === 'core') {
+            // §1.4 直调轨：零 jiti 零门禁；其余契约（时钟/回卷）与磁盘插件同轨
+            warnMissingOptional(row.id, row.reference.optionalInject, state);
+            await invokeApply(row.id, row.reference.apply, ctx, config, applyBudgetMs, state.disposeStack, 
+            // 官方件宿主面（core 行独有——03 §2.1 官方件异步续段通道；缺席位
+            // undefined = 直调形）
+            state.options.coreHostChannel?.(row.id));
+            // core 行声明基 = 宿主包根（06 §11.6 位 6 注记：core: 件出厂内容经位 4
+            // 声明即达——官方件技能/agents 从属资源与磁盘件同形同律）
+            state.activated.push({
+                id: row.id,
+                skillDirs: resolveDeclaredDirs(row.reference.skills, hostPackageRoot, row.id),
+                agentDirs: resolveDeclaredDirs(row.reference.agents, hostPackageRoot, row.id),
+            });
+            return;
+        }
+        // 磁盘轨：行 config 形状执法已随 typebox 旧路径拆除（ix-3——行 config
+        // 须对象在 readEnabledRows 行校验层；字段级校验/secret 明文拒在上方
+        // 合成步统一执法——configSchema 缺席时零变化原值直传）
+        // 纯声明包（entryPlan 三态之一）：零码装载——声明载荷清单随行激活（相对
+        // pluginDir 解析 + 包根包含执法；skills/agents 任一缺席 = 该清单空数组）
+        if (row.manifest.entryPlan.kind === 'declared-payload') {
+            state.activated.push({
+                id: row.id,
+                skillDirs: resolveDeclaredDirs(row.manifest.skills, row.pluginDir, row.id),
+                agentDirs: resolveDeclaredDirs(row.manifest.agents, row.pluginDir, row.id),
+            });
+            return;
+        }
+        const module = await loadDiskModule(row, state.options.jitiFactory, state.virtualFaces);
+        const apply = module.default;
+        if (typeof apply !== 'function') {
+            throw new BaseError('PLUGIN_SHAPE_INVALID', `入口 default export 缺席或非函数（插件 ${row.id}）`);
+        }
+        // 模块内 inject 执法（装载位——两段式的执法腿）：硬依赖缺席拒启
+        const missing = (module.inject ?? []).filter((name) => options.services.get(name) === undefined);
+        if (missing.length > 0) {
+            throw new BaseError('PLUGIN_INJECT_UNRESOLVED', `硬依赖服务不可达（模块声明）：${missing.join('、')}`);
+        }
+        warnMissingOptional(row.id, module.optionalInject, state);
+        await invokeApply(row.id, apply, ctx, config, applyBudgetMs, state.disposeStack);
+        state.activated.push({
+            id: row.id,
+            skillDirs: resolveDeclaredDirs(row.manifest.skills, row.pluginDir, row.id),
+            agentDirs: resolveDeclaredDirs(row.manifest.agents, row.pluginDir, row.id),
+        });
+    }
+    finally {
+        // 行收口即关窗（finally 语义——成功/失败/零码行皆达；03 §2.1 装载窗口）
+        options.onApplySettled?.(row.id);
+    }
+}
+/**
+ * 软依赖缺席 warn（03 §1.3「缺席仅记 warn、注入值 undefined」——诚实降级
+ * 不拒启）。逐名点名：present 名不记、全 present 不记、warn 落点缺席不记。
+ */
+function warnMissingOptional(pluginId, names, state) {
+    if (names === undefined || names.length === 0 || state.options.warn === undefined)
+        return;
+    const missing = names.filter((name) => state.options.services.get(name) === undefined);
+    if (missing.length > 0) {
+        state.options.warn(`插件 ${pluginId} 软依赖缺席（注入值 undefined——诚实降级）：${missing.join('、')}`);
+    }
+}
+/** 磁盘模块装载（jiti 轨——入口解析三态的文件级落点） */
+async function loadDiskModule(row, jitiFactory, virtualFaces) {
+    const faces = { ...virtualFaces }; // 面快照（本插件 jiti 实例的直注集）
+    const opts = {
+        virtualModules: faces,
+        transform: createGateTransform({ pluginId: row.id, pluginDir: row.pluginDir }),
+    };
+    const jiti = jitiFactory?.(row.pluginDir, opts) ??
+        createJiti(join(row.pluginDir, 'package.json'), {
+            virtualModules: faces,
+            transform: opts.transform,
+            interopDefault: true,
+            moduleCache: true,
+            fsCache: false, // 门禁身份不入缓存键——缓存命中即跳过 transform 穿门（03 §3.3 勘正）
+        });
+    const entryId = row.manifest.entryPlan.kind === 'entry-file'
+        ? join(row.pluginDir, row.manifest.entryPlan.entry)
+        : join(row.pluginDir, resolvePkgMain(row.pluginDir));
+    let namespace;
+    try {
+        namespace = (await jiti.import(entryId));
+    }
+    catch (err) {
+        throw mapJitiError(row.id, err);
+    }
+    return {
+        default: namespace.default,
+        inject: asStringArray(namespace.inject, row.id, 'inject'),
+        optionalInject: asStringArray(namespace.optionalInject, row.id, 'optionalInject'),
+        events: asStringArray(namespace.events, row.id, 'events'),
+    };
+}
+/**
+ * 缺省虚拟面五键（宿主模块对象直注——防双实例）。
+ *
+ * typebox 三键 = 宿主进程同一份（插件经虚拟键拿到的 Type/Value/Compile 与
+ * 宿主共用模块实例——Kind 符号失配结构性不可能）；berry-agent 主键 =
+ * contracts 公开面；berry-agent/llm 键 = llm/provider-face 的 providerApiFace
+ * （生态启动批 eco-1 接线——face 件/API 注册表/surface 三处早已在册而装载
+ * 注入缺席，provider 插件装载必炸于模块解析的三读分叉收口）。
+ * `berry-agent/sqlite` 键仍随 persist SqliteFace 落码批接入（无真身不进表）。
+ *
+ * export（装机面落码批 #10——install 收割腿与装载器同源共用：虚拟面单源，
+ * 不散拷）。
+ */
+export async function loadDefaultVirtualFaces() {
+    const [contracts, typebox, typeboxValue, typeboxCompile] = await Promise.all([
+        import('../contracts/index.js'),
+        import('typebox'),
+        import('typebox/value'),
+        import('typebox/compile'),
+    ]);
+    return {
+        'berry-agent': contracts,
+        typebox,
+        'typebox/value': typeboxValue,
+        'typebox/compile': typeboxCompile,
+        // 顶层导出形直注（非命名空间整包）——与 surface.json 收割的 4 符号面同源
+        'berry-agent/llm': providerApiFace,
+    };
+}
+/** jiti 错误映射（三码分流：门禁拒 / 入口不可达 / 装载失败） */
+function mapJitiError(pluginId, err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (err instanceof BaseError && err.code === 'PLUGIN_IMPORT_FORBIDDEN')
+        return err; // 字面量腿原样透传
+    if (message.includes('PLUGIN_IMPORT_FORBIDDEN')) {
+        // 兜底腿毒丸（裸 Error 码前缀形——毒丸经 jiti eval 不得 import 宿主面）
+        return new BaseError('PLUGIN_IMPORT_FORBIDDEN', `[${pluginId}] ${message}`, { cause: err });
+    }
+    if (message.includes('Cannot find module') || err.code === 'MODULE_NOT_FOUND') {
+        return new BaseError('PLUGIN_ENTRY_UNRESOLVED', `入口模块解析失败（插件 ${pluginId}）：${message}`, {
+            cause: err,
+        });
+    }
+    return new BaseError('PLUGIN_LOAD_FAILED', `jiti 装载失败（插件 ${pluginId}）：${message}`, { cause: err });
+}
+/** apply 三态包装：时钟帽 + disposer 收栈 + 错误归一 PLUGIN_APPLY_FAILED */
+async function invokeApply(id, apply, ctx, config, applyBudgetMs, disposeStack, host) {
+    let returned;
+    try {
+        // 时钟帽包裹（返回值经闭包捕获——withTimeout 面 Promise<void>）+
+        // 装载期语境遮蔽（ix-2——07 §4.3 档位 2 两处遮蔽之二）：apply 即使处
+        // 命令异步链内（/reload、/plugins install 等命令触发的装载流）亦按无锚
+        // 判——装载期结构性无自动锚（apply 内 ctx.ui 阻塞三件拒、单向原语
+        // no-op warn）。ALS.exit 语境跟随 async：apply 全执行段均在遮蔽内。
+        await withTimeout(withoutSessionAnchor(() => Promise.resolve(apply(ctx, config, host)).then((r) => {
+            returned = r;
+        })), applyBudgetMs, `apply ${id}`);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new BaseError('PLUGIN_APPLY_FAILED', `apply 抛错/超时（插件 ${id}，帽 ${applyBudgetMs}ms）：${message}`, {
+            cause: err,
+        });
+    }
+    if (typeof returned === 'function') {
+        disposeStack.push({ id, fn: returned }); // 激活序入栈——unload LIFO
+    }
+}
+/**
+ * 包主入口解析（default-export 态：package.json main；缺省 index.js）。
+ * export（装机面落码批 #10——install 收割腿与装载器同源共用：入口解析序
+ * 单源，不散拷）。
+ */
+export function resolvePkgMain(pluginDir) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(pluginDir, 'package.json'), 'utf8'));
+        return pkg.main !== undefined && pkg.main.length > 0 ? pkg.main : 'index.js';
+    }
+    catch {
+        return 'index.js'; // package.json 不可读——入口解析交给 jiti 失败红（ENTRY_UNRESOLVED）
+    }
+}
+/** named export 字符串数组形执法（坏形 = 形状违例） */
+function asStringArray(value, id, field) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.some((v) => typeof v !== 'string')) {
+        throw new BaseError('PLUGIN_SHAPE_INVALID', `入口 named export ${field} 须字符串数组（插件 ${id}）`);
+    }
+    return value;
+}
+/** 行 inject 面（排序位）：core: 注册表声明 / 磁盘行预收割位（两段式——装载位另执法） */
+function injectOf(row) {
+    return row.kind === 'core' ? (row.reference.inject ?? []) : (row.inject ?? []);
+}
+/** 不动点回卷（core: fail-loud 前置清场——已活行 LIFO） */
+async function rollback(disposeStack, disposerBudgetMs) {
+    while (disposeStack.length > 0) {
+        const item = disposeStack.pop();
+        try {
+            await withTimeout(Promise.resolve(item.fn()), disposerBudgetMs, `disposer ${item.id}`);
+        }
+        catch {
+            // 清场路径静默——主错误（拒启因由）才是呈报面
+        }
+    }
+}
+/** 失败归一（BaseError 直取码身份；裸错误归 PLUGIN_LOAD_FAILED 位） */
+function toFailure(id, err) {
+    if (err instanceof BaseError)
+        return { id, code: err.code, message: err.message };
+    return { id, code: 'PLUGIN_LOAD_FAILED', message: err instanceof Error ? err.message : String(err) };
+}