@bolloon/bolloon-agent 0.2.8 → 0.2.10

package/dist/bootstrap/lifecycle-hooks.js

@@ -9,7 +9,6 @@ import * as os from 'os';
 import * as path from 'path';
 import { getCachedBolloonContext, clearBolloonContextCache } from './context-collector.js';
 import { formatContextForSystemPrompt } from './project-context.js';
-import { loadPersonaDocs, formatPersonaForSystemPrompt } from './persona-loader.js';
 let lastSessionStartAt = 0;
 const MIN_INTERVAL_MS = 5000; // 同一进程 5s 内最多触发一次, 防止循环
 export async function onSessionStart(opts = {}) {
@@ -26,23 +25,10 @@ export async function onSessionStart(opts = {}) {
         if (opts.channelId) {
             systemAddition = `# 当前 channel: ${opts.channelId}\n\n` + systemAddition;
         }
-        // 在头部最前拼 persona 文档 (如果 agentId 存在)
-        if (opts.agentId) {
-            try {
-                const docs = await loadPersonaDocs(opts.agentId);
-                const personaText = formatPersonaForSystemPrompt(docs);
-                if (personaText) {
-                    systemAddition = personaText + '\n\n' + systemAddition;
-                }
-            }
-            catch (err) {
-                console.warn('[lifecycle-hooks] loadPersonaDocs failed (silent):', err);
-            }
-        }
         return {
             systemAddition,
             collectMs: Date.now() - start,
-            truncated: systemAddition.length > 0 && systemAddition.includes('截断'),
+            truncated: systemAddition.length > 0 && systemAddition.includes('截断模式'),
         };
     }
     catch (err) {

package/dist/cli-entry.js

@@ -13,7 +13,6 @@
 import { spawn } from 'child_process';
 import * as path from 'path';
 import * as fs from 'fs';
-import { fileURLToPath } from 'url';
 const isWindows = process.platform === 'win32';
 // ANSI 颜色
 const RESET = '\x1b[0m';
@@ -28,50 +27,47 @@ function log(msg, color = RESET) {
     console.log(`${color}${msg}${RESET}`);
 }
 function printBanner() {
-    console.log(`
-${CYAN}${BOLD}
-   ╔═══════════════════════════════════════════╗
-   ║      🤖 Bolloon Agent ${VERSION}              ║
-   ║      P2P AI Document Processor            ║
-   ╚═══════════════════════════════════════════╝${RESET}
+    console.log(`
+${CYAN}${BOLD}
+   ╔═══════════════════════════════════════════╗
+   ║      🤖 Bolloon Agent ${VERSION}              ║
+   ║      P2P AI Document Processor            ║
+   ╚═══════════════════════════════════════════╝${RESET}
 `);
 }
 function printHelp() {
-    console.log(`
-${BOLD}用法:${RESET}
-  bolloon [选项] [命令] [参数]
-
-${BOLD}选项:${RESET}
-  --gui, -g           启动图形界面 (Electron)
-  --web, -w           启动 Web UI (浏览器)
-  --cli, -c           启动命令行界面
-  --version, -v       显示版本信息
-  --help, -h          显示帮助信息
-
-${BOLD}命令:${RESET}
-  bolloon --read <file>           读取文档
-  bolloon --summarize <file>      总结文档
-  bolloon --improve <file> <req>  改进文档
-
-${BOLD}示例:${RESET}
-  bolloon                    # 启动图形界面
-  bolloon --web              # 启动 Web UI
-  bolloon --read 想法.md     # 读取文档
-  bolloon --cli              # 命令行模式
-
-${BOLD}环境变量:${RESET}
-  MINIMAX_API_KEY           MiniMax API 密钥
-  OPENAI_API_KEY            OpenAI API 密钥
-  ANTHROPIC_API_KEY         Anthropic API 密钥
-  PORT                      Web 服务端口 (默认 54188)
+    console.log(`
+${BOLD}用法:${RESET}
+  bolloon [选项] [命令] [参数]
+
+${BOLD}选项:${RESET}
+  --gui, -g           启动图形界面 (Electron)
+  --web, -w           启动 Web UI (浏览器)
+  --cli, -c           启动命令行界面
+  --version, -v       显示版本信息
+  --help, -h          显示帮助信息
+
+${BOLD}命令:${RESET}
+  bolloon --read <file>           读取文档
+  bolloon --summarize <file>      总结文档
+  bolloon --improve <file> <req>  改进文档
+
+${BOLD}示例:${RESET}
+  bolloon                    # 启动图形界面
+  bolloon --web              # 启动 Web UI
+  bolloon --read 想法.md     # 读取文档
+  bolloon --cli              # 命令行模式
+
+${BOLD}环境变量:${RESET}
+  MINIMAX_API_KEY           MiniMax API 密钥
+  OPENAI_API_KEY            OpenAI API 密钥
+  ANTHROPIC_API_KEY         Anthropic API 密钥
+  PORT                      Web 服务端口 (默认 54188)
 `);
 }
 function getDistDir() {
-    // 2026-07-01: ESM 模块无 __dirname, 用 import.meta.url + path.dirname 拿当前文件所在目录.
-    // 对于打包后的应用, 这是 dist 目录; 对于 tsx 跑 src/index.ts 时, 是 src/ 目录
-    // (后续 getMainScript 会优先用 dist/cli-entry.js, 不依赖这里的返回值)
-    const __filename_esm = fileURLToPath(import.meta.url);
-    return path.dirname(__filename_esm);
+    // 对于打包后的应用，__dirname 是 dist 目录
+    return __dirname;
 }
 function getMainScript() {
     const distDir = getDistDir();

package/dist/constraint-runtime/src/_archive_helper.js

@@ -0,0 +1,9 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function loadArchiveMetadata(packageName) {
+    const snapshotPath = path.join(__dirname, 'reference_data', 'subsystems', `${packageName}.json`);
+    return JSON.parse(fs.readFileSync(snapshotPath, 'utf-8'));
+}

package/dist/constraint-runtime/src/agent/coordinator.js

@@ -0,0 +1,48 @@
+import { DeepThinkingEngine } from '../thinking/engine.js';
+export class AgentCoordinator {
+    engine;
+    constructor(maxDepth = 3) {
+        this.engine = new DeepThinkingEngine(maxDepth);
+    }
+    async dispatch(prompt, parallelCount = 3) {
+        const tasks = this.splitTask(prompt, parallelCount);
+        const results = await Promise.all(tasks.map(task => this.executeTask(task)));
+        return this.aggregate(results);
+    }
+    splitTask(prompt, count) {
+        const words = prompt.split(/\s+/);
+        const chunkSize = Math.ceil(words.length / count);
+        const chunks = [];
+        for (let i = 0; i < count; i++) {
+            const chunk = words.slice(i * chunkSize, (i + 1) * chunkSize).join(' ');
+            if (chunk) {
+                chunks.push({
+                    id: `task-${i}`,
+                    description: chunk,
+                    priority: i
+                });
+            }
+        }
+        return chunks;
+    }
+    async executeTask(task) {
+        try {
+            const thinkResult = await this.engine.think(task.description);
+            return {
+                taskId: task.id,
+                output: thinkResult.finalOutput,
+                success: true
+            };
+        }
+        catch (error) {
+            return {
+                taskId: task.id,
+                output: String(error),
+                success: false
+            };
+        }
+    }
+    aggregate(results) {
+        return results.sort((a, b) => a.taskId.localeCompare(b.taskId));
+    }
+}

package/dist/constraint-runtime/src/agent/index.js

@@ -0,0 +1 @@
+export { AgentCoordinator } from './coordinator.js';

package/dist/constraint-runtime/src/assistant/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('assistant');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/src/bootstrap/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('bootstrap');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/src/bootstrap_graph.js

@@ -0,0 +1,13 @@
+export function buildBootstrapGraph() {
+    return {
+        stages: [
+            'top-level prefetch side effects',
+            'warning handler and environment guards',
+            'CLI parser and pre-action trust gate',
+            'setup() + commands/agents parallel load',
+            'deferred init after trust',
+            'mode routing: local / remote / ssh / teleport / direct-connect / deep-link',
+            'query engine submit loop',
+        ],
+    };
+}

package/dist/constraint-runtime/src/bridge/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('bridge');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/src/buddy/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('buddy');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/src/cli/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('cli');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/src/command_graph.js

@@ -0,0 +1,10 @@
+import { getCommands } from './commands.js';
+export function buildCommandGraph() {
+    const commands = getCommands();
+    return {
+        builtins: commands.filter(m => !m.sourceHint.toLowerCase().includes('plugin') &&
+            !m.sourceHint.toLowerCase().includes('skills')),
+        pluginLike: commands.filter(m => m.sourceHint.toLowerCase().includes('plugin')),
+        skillLike: commands.filter(m => m.sourceHint.toLowerCase().includes('skills')),
+    };
+}

package/dist/constraint-runtime/src/commands.js

@@ -0,0 +1,60 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const SNAPSHOT_PATH = path.join(__dirname, 'reference_data', 'commands_snapshot.json');
+function loadCommandSnapshot() {
+    try {
+        if (!fs.existsSync(SNAPSHOT_PATH)) {
+            console.warn(`[commands] Snapshot not found: ${SNAPSHOT_PATH}, using empty list`);
+            return [];
+        }
+        const raw = JSON.parse(fs.readFileSync(SNAPSHOT_PATH, 'utf-8'));
+        return raw.map((e) => ({
+            name: e.name,
+            responsibility: e.responsibility,
+            sourceHint: e.source_hint,
+            status: 'mirrored',
+        }));
+    }
+    catch (error) {
+        console.warn(`[commands] Failed to load snapshot: ${error}, using empty list`);
+        return [];
+    }
+}
+export const PORTED_COMMANDS = loadCommandSnapshot();
+export function builtInCommandNames() {
+    return new Set(PORTED_COMMANDS.map(m => m.name));
+}
+export function getCommand(name) {
+    const needle = name.toLowerCase();
+    return PORTED_COMMANDS.find(m => m.name.toLowerCase() === needle);
+}
+export function getCommands(includePluginCommands = true, includeSkillCommands = true) {
+    let commands = [...PORTED_COMMANDS];
+    if (!includePluginCommands) {
+        commands = commands.filter(m => !m.sourceHint.toLowerCase().includes('plugin'));
+    }
+    if (!includeSkillCommands) {
+        commands = commands.filter(m => !m.sourceHint.toLowerCase().includes('skills'));
+    }
+    return commands;
+}
+export function findCommands(query, limit = 20) {
+    const needle = query.toLowerCase();
+    return PORTED_COMMANDS.filter(m => m.name.toLowerCase().includes(needle) || m.sourceHint.toLowerCase().includes(needle)).slice(0, limit);
+}
+export function executeCommand(name, prompt = '') {
+    const module = getCommand(name);
+    if (!module) {
+        return { name, sourceHint: '', prompt, handled: false, message: `Unknown mirrored command: ${name}` };
+    }
+    return {
+        name: module.name,
+        sourceHint: module.sourceHint,
+        prompt,
+        handled: true,
+        message: `Mirrored command '${module.name}' from ${module.sourceHint} would handle prompt.`,
+    };
+}

package/dist/constraint-runtime/src/components/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('components');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/src/constants/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('constants');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/src/constraint/budget.js

@@ -0,0 +1,22 @@
+export class BudgetTracker {
+    maxBudgetTokens;
+    maxTurns;
+    compactAfterTurns;
+    constructor(maxBudgetTokens = 2000, maxTurns = 8, compactAfterTurns = 12) {
+        this.maxBudgetTokens = maxBudgetTokens;
+        this.maxTurns = maxTurns;
+        this.compactAfterTurns = compactAfterTurns;
+    }
+    addTurn(inputTokens, outputTokens) {
+        return { inputTokens, outputTokens };
+    }
+    isBudgetExceeded(usage) {
+        return usage.inputTokens + usage.outputTokens > this.maxBudgetTokens;
+    }
+    isTurnLimitExceeded(currentTurns) {
+        return currentTurns >= this.maxTurns;
+    }
+    shouldCompact(turnCount) {
+        return turnCount > this.compactAfterTurns;
+    }
+}

package/dist/constraint-runtime/src/constraint/index.js

@@ -0,0 +1,2 @@
+export { ToolPermissionContext } from './permission.js';
+export { BudgetTracker } from './budget.js';

package/dist/constraint-runtime/src/constraint/permission.js

@@ -0,0 +1,20 @@
+export class ToolPermissionContext {
+    denyTools;
+    denyPrefixes;
+    constructor(denyTools, denyPrefixes) {
+        this.denyTools = denyTools;
+        this.denyPrefixes = denyPrefixes;
+    }
+    static fromIterables(denyTools = [], denyPrefixes = []) {
+        return new ToolPermissionContext(new Set(denyTools.map(t => t.toLowerCase())), denyPrefixes);
+    }
+    blocks(name) {
+        const lower = name.toLowerCase();
+        if (this.denyTools.has(lower))
+            return true;
+        return this.denyPrefixes.some(p => lower.startsWith(p.toLowerCase()));
+    }
+    createDenial(toolName, reason) {
+        return { toolName, reason };
+    }
+}

package/dist/constraint-runtime/src/context.js

@@ -0,0 +1,30 @@
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function buildPortContext(base) {
+    const root = base || __dirname;
+    const srcRoot = path.join(root, 'src');
+    const testsRoot = path.join(root, 'tests');
+    const assetsRoot = path.join(root, 'assets');
+    const archiveRoot = path.join(root, 'archive');
+    return {
+        sourceRoot: srcRoot,
+        testsRoot: testsRoot,
+        assetsRoot: assetsRoot,
+        archiveRoot: archiveRoot,
+        pythonFileCount: 0,
+        testFileCount: 0,
+        assetFileCount: 0,
+        archiveAvailable: false,
+    };
+}
+export function renderContext(context) {
+    return [
+        `Source root: ${context.sourceRoot}`,
+        `Test root: ${context.testsRoot}`,
+        `Assets root: ${context.assetsRoot}`,
+        `Archive root: ${context.archiveRoot}`,
+        `Archive available: ${context.archiveAvailable}`,
+    ].join('\n');
+}

package/dist/constraint-runtime/src/coordinator/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('coordinator');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/src/cost_hook.js

@@ -0,0 +1,4 @@
+export function applyCostHook(tracker, label, units) {
+    tracker.record(label, units);
+    return tracker;
+}

package/dist/constraint-runtime/src/cost_tracker.js

@@ -0,0 +1,8 @@
+export class CostTracker {
+    totalUnits = 0;
+    events = [];
+    record(label, units) {
+        this.totalUnits += units;
+        this.events.push(`${label}:${units}`);
+    }
+}

package/dist/constraint-runtime/src/deferred_init.js

@@ -0,0 +1,10 @@
+export function runDeferredInit(trusted) {
+    const enabled = Boolean(trusted);
+    return {
+        trusted,
+        pluginInit: enabled,
+        skillInit: enabled,
+        mcpPrefetch: enabled,
+        sessionHooks: enabled,
+    };
+}

package/dist/constraint-runtime/src/direct_modes.js

@@ -0,0 +1,6 @@
+export function runDirectConnect(target) {
+    return { mode: 'direct-connect', target, active: true };
+}
+export function runDeepLink(target) {
+    return { mode: 'deep-link', target, active: true };
+}

package/dist/constraint-runtime/src/dynamic-tool-loader.js

@@ -0,0 +1,85 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function resolveToolPath(sourceHint) {
+    return path.join(__dirname, sourceHint);
+}
+function inferFunctionName(sourceHint) {
+    const basename = path.basename(sourceHint, path.extname(sourceHint));
+    const nameMap = {
+        listMarkets: 'listMarkets',
+        getMarket: 'getMarket',
+        createOrder: 'createOrder',
+        cancelOrder: 'cancelOrder',
+        getOrders: 'getOrders',
+        createTransaction: 'createTransaction',
+        proposeTransaction: 'proposeTransaction',
+        confirmTransaction: 'confirmTransaction',
+        executeTransaction: 'executeTransaction',
+        getPendingTransactions: 'getPendingTransactions',
+        getBalance: 'getBalance',
+        deploySafe: 'deploySafe',
+        runCommand: 'runCommand',
+        listAdapters: 'listAdapters',
+        execAdapter: 'execAdapter',
+    };
+    return nameMap[basename] || basename;
+}
+export async function executeToolFromSnapshot(sourceHint, params) {
+    try {
+        const fullPath = resolveToolPath(sourceHint);
+        if (!fs.existsSync(fullPath)) {
+            return {
+                success: false,
+                error: `Tool file not found: ${fullPath}`,
+            };
+        }
+        const module = await import(`file://${fullPath}?t=${Date.now()}`);
+        const functionName = inferFunctionName(sourceHint);
+        if (typeof module[functionName] !== 'function') {
+            return {
+                success: false,
+                error: `Function '${functionName}' not found in ${sourceHint}`,
+            };
+        }
+        const result = await module[functionName](params);
+        return {
+            success: true,
+            data: result,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export class DynamicToolExecutor {
+    async loadAndExecute(modulePath, functionName, params) {
+        try {
+            const fullPath = resolveToolPath(modulePath);
+            if (!fs.existsSync(fullPath)) {
+                return { success: false, error: `Module not found: ${fullPath}` };
+            }
+            const module = await import(`file://${fullPath}?t=${Date.now()}`);
+            if (typeof module[functionName] !== 'function') {
+                return {
+                    success: false,
+                    error: `Function '${functionName}' not exported from ${modulePath}`,
+                };
+            }
+            const result = await module[functionName](params);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}
+export const defaultExecutor = new DynamicToolExecutor();

package/dist/constraint-runtime/src/entrypoints/index.js

@@ -0,0 +1,12 @@
+import { loadArchiveMetadata } from '../_archive_helper.js';
+const SNAPSHOT = loadArchiveMetadata('entrypoints');
+export const ARCHIVE_NAME = SNAPSHOT['archive_name'];
+export const MODULE_COUNT = SNAPSHOT['module_count'];
+export const SAMPLE_FILES = SNAPSHOT['sample_files'];
+export const PORTING_NOTE = `Python placeholder package for '${ARCHIVE_NAME}' with ${MODULE_COUNT} archived module references.`;
+export default {
+    ARCHIVE_NAME,
+    MODULE_COUNT,
+    PORTING_NOTE,
+    SAMPLE_FILES,
+};

package/dist/constraint-runtime/src/execution_registry.js

@@ -0,0 +1,44 @@
+import { PORTED_COMMANDS, executeCommand } from './commands.js';
+import { PORTED_TOOLS, executeTool } from './tools.js';
+export class MirroredCommand {
+    name;
+    sourceHint;
+    constructor(name, sourceHint) {
+        this.name = name;
+        this.sourceHint = sourceHint;
+    }
+    execute(prompt) {
+        return executeCommand(this.name, prompt).message;
+    }
+}
+export class MirroredTool {
+    name;
+    sourceHint;
+    constructor(name, sourceHint) {
+        this.name = name;
+        this.sourceHint = sourceHint;
+    }
+    async execute(payload) {
+        const result = await executeTool(this.name, payload);
+        return result.message;
+    }
+}
+export class ExecutionRegistry {
+    commands;
+    tools;
+    constructor(commands, tools) {
+        this.commands = commands;
+        this.tools = tools;
+    }
+    command(name) {
+        const lowered = name.toLowerCase();
+        return this.commands.find(c => c.name.toLowerCase() === lowered);
+    }
+    tool(name) {
+        const lowered = name.toLowerCase();
+        return this.tools.find(t => t.name.toLowerCase() === lowered);
+    }
+}
+export function buildExecutionRegistry() {
+    return new ExecutionRegistry(PORTED_COMMANDS.map(m => new MirroredCommand(m.name, m.sourceHint)), PORTED_TOOLS.map(m => new MirroredTool(m.name, m.sourceHint)));
+}

package/dist/constraint-runtime/src/history.js

@@ -0,0 +1,9 @@
+export class HistoryLog {
+    events = [];
+    add(title, detail) {
+        this.events.push({ title, detail });
+    }
+    asMarkdown() {
+        return ['# Session History', '', ...this.events.map(e => `- ${e.title}: ${e.detail}`)].join('\n');
+    }
+}