@bolloon/bolloon-agent 0.1.0 → 0.1.2

package/dist/bollharness-integration/context-chain-router.js

@@ -0,0 +1,383 @@
+/**
+ * Context Chain Router - Session summary chain injection
+ *
+ * Integrates with existing ContextRouter and Judgment systems.
+ *
+ * Architecture:
+ * - Session end → extract summary by work_type → store in .boll/state/context-chains/
+ * - Session start (Gate 0/3) → lookup related chains → inject summaries
+ * - Work type: code_change | review | design | question | planning | debugging
+ *
+ * Integration points:
+ * - Uses existing context-router-judgment.ts pattern (extends, not replaces)
+ * - Gate injection via gate-judgment-inject.ts
+ * - Storage in .boll/state/context-chains/
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+export const CONTEXT_CHAINS_DIR = path.join('.boll', 'state', 'context-chains');
+/**
+ * Ensure context-chains directory exists
+ */
+function ensureDir() {
+    if (!fs.existsSync(CONTEXT_CHAINS_DIR)) {
+        fs.mkdirSync(CONTEXT_CHAINS_DIR, { recursive: true });
+    }
+}
+/**
+ * Get current month directory path
+ */
+function getMonthDir() {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    return path.join(CONTEXT_CHAINS_DIR, `${year}-${month}`);
+}
+/**
+ * Generate session ID
+ */
+function generateSessionId() {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    const seq = getTodaySequence() + 1;
+    return `${year}${month}${day}-${String(seq).padStart(3, '0')}`;
+}
+/**
+ * Get today's sequence number
+ */
+function getTodaySequence() {
+    const dir = getMonthDir();
+    if (!fs.existsSync(dir))
+        return 0;
+    const todayPrefix = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+    const files = fs.readdirSync(dir)
+        .filter(f => f.startsWith(todayPrefix) && f.endsWith('.yaml'));
+    return files.length;
+}
+/**
+ * Save a context chain summary
+ */
+export function saveContextChain(summary) {
+    ensureDir();
+    const monthDir = getMonthDir();
+    if (!fs.existsSync(monthDir)) {
+        fs.mkdirSync(monthDir, { recursive: true });
+    }
+    const filename = `${summary.session_id}-${summary.work_type}-${getTodaySequence() + 1}.yaml`;
+    const filepath = path.join(monthDir, filename);
+    const yaml = contextChainToYaml(summary);
+    fs.writeFileSync(filepath, yaml, 'utf-8');
+    return filepath;
+}
+/**
+ * Convert context chain to YAML string
+ */
+function contextChainToYaml(summary) {
+    const lines = [
+        `session_id: "${summary.session_id}"`,
+        `work_type: ${summary.work_type}`,
+        `created_at: "${summary.created_at}"`,
+        `gate_at_session: ${summary.gate_at_session}`,
+        '',
+        '关联上下文:',
+    ];
+    for (const ref of summary['关联上下文']) {
+        lines.push(`  - session_id: "${ref.session_id}"`);
+        lines.push(`    reason: "${ref.reason}"`);
+        lines.push(`    relevance: ${ref.relevance}`);
+    }
+    lines.push('');
+    lines.push('核心摘要:');
+    const core = summary['核心摘要'];
+    for (const [key, value] of Object.entries(core)) {
+        if (Array.isArray(value)) {
+            lines.push(`  ${key}:`);
+            for (const item of value) {
+                if (typeof item === 'object') {
+                    for (const [k, v] of Object.entries(item)) {
+                        lines.push(`    - ${k}: ${JSON.stringify(v)}`);
+                    }
+                }
+                else {
+                    lines.push(`    - ${JSON.stringify(item)}`);
+                }
+            }
+        }
+        else if (typeof value === 'object' && value !== null) {
+            lines.push(`  ${key}:`);
+            for (const [k, v] of Object.entries(value)) {
+                lines.push(`    ${k}: ${JSON.stringify(v)}`);
+            }
+        }
+        else {
+            lines.push(`  ${key}: ${JSON.stringify(value)}`);
+        }
+    }
+    if (summary['决策缺口'] && summary['决策缺口'].length > 0) {
+        lines.push('');
+        lines.push('决策缺口:');
+        for (const gap of summary['决策缺口']) {
+            lines.push(`  - 描述: "${gap.描述}"`);
+            lines.push(`    影响: "${gap.影响}"`);
+            lines.push(`    需要什么才能关闭: "${gap.需要什么才能关闭}"`);
+        }
+    }
+    if (summary['风险点'] && summary['风险点'].length > 0) {
+        lines.push('');
+        lines.push('风险点:');
+        for (const risk of summary['风险点']) {
+            lines.push(`  - 描述: "${risk.描述}"`);
+            lines.push(`    概率: ${risk.概率}`);
+            lines.push(`    缓解措施: "${risk.缓解措施}"`);
+        }
+    }
+    if (summary['遗迹'] && summary['遗迹'].length > 0) {
+        lines.push('');
+        lines.push('遗迹:');
+        for (const relic of summary['遗迹']) {
+            lines.push(`  - "${relic}"`);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Load a single context chain by session_id
+ */
+export function loadContextChain(sessionId) {
+    const pattern = new RegExp(`^${sessionId.replace(/-/g, '.*')}-.*\\.yaml$`);
+    const dirs = fs.existsSync(CONTEXT_CHAINS_DIR)
+        ? fs.readdirSync(CONTEXT_CHAINS_DIR)
+        : [];
+    for (const dir of dirs) {
+        const dirPath = path.join(CONTEXT_CHAINS_DIR, dir);
+        if (!fs.statSync(dirPath).isDirectory())
+            continue;
+        const files = fs.readdirSync(dirPath).filter(f => pattern.test(f));
+        if (files.length > 0) {
+            const content = fs.readFileSync(path.join(dirPath, files[0]), 'utf-8');
+            return parseContextChainYaml(content);
+        }
+    }
+    return null;
+}
+/**
+ * Parse YAML content to ContextChainSummary
+ */
+function parseContextChainYaml(content) {
+    const result = {};
+    const lines = content.split('\n');
+    let currentKey = '';
+    let currentArray = [];
+    let inArray = false;
+    for (const line of lines) {
+        if (line.includes(':') && !line.startsWith('  ')) {
+            const [key, ...valueParts] = line.split(':');
+            const value = valueParts.join(':').trim();
+            if (inArray && currentKey) {
+                result[currentKey] = currentArray;
+                currentArray = [];
+                inArray = false;
+            }
+            currentKey = key.trim();
+            if (value) {
+                result[currentKey] = value.replace(/^["']|["']$/g, '');
+            }
+        }
+        else if (line.startsWith('  - ')) {
+            inArray = true;
+            currentArray.push(line.replace(/^  - /, '').replace(/^["']|["']$/g, ''));
+        }
+    }
+    if (inArray && currentKey) {
+        result[currentKey] = currentArray;
+    }
+    return result;
+}
+/**
+ * Find related context chains by work type and relevance
+ */
+export function findRelatedChains(options = {}) {
+    const { workType, minRelevance = 0.5, maxTokens = 2000, gate, } = options;
+    if (!fs.existsSync(CONTEXT_CHAINS_DIR)) {
+        return [];
+    }
+    const chains = [];
+    const dirs = fs.readdirSync(CONTEXT_CHAINS_DIR);
+    for (const dir of dirs) {
+        const dirPath = path.join(CONTEXT_CHAINS_DIR, dir);
+        if (!fs.statSync(dirPath).isDirectory())
+            continue;
+        const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.yaml'));
+        for (const file of files) {
+            const content = fs.readFileSync(path.join(dirPath, file), 'utf-8');
+            const chain = parseContextChainYaml(content);
+            if (workType && chain.work_type !== workType)
+                continue;
+            if (gate !== undefined && chain.gate_at_session !== gate)
+                continue;
+            chains.push(chain);
+        }
+    }
+    // Sort by relevance and recency
+    chains.sort((a, b) => {
+        const aRecency = new Date(a.created_at).getTime();
+        const bRecency = new Date(b.created_at).getTime();
+        return bRecency - aRecency;
+    });
+    // Apply token budget
+    let totalTokens = 0;
+    const selected = [];
+    for (const chain of chains) {
+        const estimatedTokens = estimateTokens(chain);
+        if (totalTokens + estimatedTokens > maxTokens)
+            break;
+        selected.push(chain);
+        totalTokens += estimatedTokens;
+    }
+    return selected;
+}
+/**
+ * Estimate token count for a chain
+ */
+function estimateTokens(chain) {
+    const yaml = contextChainToYaml(chain);
+    return Math.ceil(yaml.length / 4);
+}
+/**
+ * Generate injection for Gate 0/3
+ */
+export async function generateContextChainInjection(gate, workType) {
+    const chains = findRelatedChains({
+        workType,
+        gate: gate === 0 ? undefined : gate,
+        maxTokens: 2000,
+    });
+    if (chains.length === 0) {
+        return '';
+    }
+    const header = gate === 0
+        ? '# Context Chains — Recent Session Summaries'
+        : `# Context Chains — Gate ${gate} Related Sessions`;
+    const lines = [
+        header,
+        `# Injected at session start — chains from related prior sessions`,
+        `# Total chains: ${chains.length} | Token budget: ~2000`,
+        '',
+        'context_chains:',
+    ];
+    for (const chain of chains) {
+        lines.push(`  - session_id: "${chain.session_id}"`);
+        lines.push(`    work_type: ${chain.work_type}`);
+        lines.push(`    created_at: "${chain.created_at}"`);
+        lines.push(`    gate_at_session: ${chain.gate_at_session}`);
+        if (chain['关联上下文'].length > 0) {
+            lines.push(`    关联上下文:`);
+            for (const ref of chain['关联上下文']) {
+                lines.push(`      - session_id: "${ref.session_id}"`);
+                lines.push(`        relevance: ${ref.relevance}`);
+            }
+        }
+        lines.push(`    核心摘要:`);
+        const core = chain['核心摘要'];
+        for (const [key, value] of Object.entries(core)) {
+            if (Array.isArray(value)) {
+                lines.push(`      ${key}:`);
+                for (const item of value.slice(0, 3)) {
+                    if (typeof item === 'object') {
+                        lines.push(`        - ${JSON.stringify(item).slice(0, 100)}`);
+                    }
+                    else {
+                        lines.push(`        - ${JSON.stringify(item).slice(0, 100)}`);
+                    }
+                }
+                if (value.length > 3) {
+                    lines.push(`        ... (${value.length - 3} more)`);
+                }
+            }
+            else if (typeof value === 'string' && value.length > 100) {
+                lines.push(`      ${key}: "${value.slice(0, 100)}..."`);
+            }
+            else {
+                lines.push(`      ${key}: ${JSON.stringify(value)}`);
+            }
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Create a new context chain summary from conversation
+ */
+export function createContextChain(params) {
+    const sessionId = generateSessionId();
+    const summary = {
+        session_id: sessionId,
+        work_type: params.workType,
+        created_at: new Date().toISOString(),
+        gate_at_session: params.gate,
+        '关联上下文': (params.relatedSessions || []).map(r => ({
+            session_id: r.sessionId,
+            reason: r.reason,
+            relevance: r.relevance,
+        })),
+        '核心摘要': extractCoreSummary(params.workType, params.conversationText),
+        '决策缺口': [],
+        '风险点': [],
+        '遗迹': [],
+    };
+    return summary;
+}
+/**
+ * Extract core summary based on work type
+ */
+function extractCoreSummary(workType, text) {
+    switch (workType) {
+        case 'code_change':
+            return extractCodeChangeSummary(text);
+        case 'review':
+            return extractReviewSummary(text);
+        case 'design':
+            return extractDesignSummary(text);
+        case 'planning':
+            return extractPlanningSummary(text);
+        case 'debugging':
+            return extractDebuggingSummary(text);
+        case 'question':
+            return extractQuestionSummary(text);
+        default:
+            return { raw: text.slice(0, 500) };
+    }
+}
+function extractCodeChangeSummary(text) {
+    const files = [];
+    // Extract file paths from common patterns
+    const filePattern = /(?:modified|changed|added|deleted):\s+([^\s]+)/gi;
+    let match;
+    while ((match = filePattern.exec(text)) !== null) {
+        files.push({ path: match[1], change_type: 'modify', reason: '' });
+    }
+    return { files_changed: files, decisions: [], adr_linked: [] };
+}
+function extractReviewSummary(text) {
+    const hasBlock = text.toLowerCase().includes('block') || text.toLowerCase().includes('reject');
+    return {
+        verdict: hasBlock ? 'BLOCK' : 'PASS',
+        reviewed_artifact: '',
+        blocking_issues: [],
+        non_blocking_observations: [],
+    };
+}
+function extractDesignSummary(text) {
+    return { design_choices: [], constraints: [], consumers: [] };
+}
+function extractPlanningSummary(text) {
+    return { goals: [], dependencies: [], risks: [], decision_gaps: [] };
+}
+function extractDebuggingSummary(text) {
+    return { root_cause: '', symptoms_observed: [], fix_applied: [], files_touched: [] };
+}
+function extractQuestionSummary(text) {
+    return { question_type: 'unknown', answer_summary: '', source: '' };
+}

package/dist/bollharness-integration/context-router-judgment.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Judgment-Aware Context Router
  *
@@ -14,14 +13,8 @@
  * - Extends with judgment lookup based on fragment context
  * - Injects at Gate 0, Gate 3, and file-edit time
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getJudgmentsForFragment = getJudgmentsForFragment;
-exports.getJudgmentsForPath = getJudgmentsForPath;
-exports.getCoreJudgmentsForSession = getCoreJudgmentsForSession;
-exports.getJudgmentsForContextRequest = getJudgmentsForContextRequest;
-exports.generateJudgmentInjection = generateJudgmentInjection;
-const context_router_js_1 = require("./context-router.js");
-const index_js_1 = require("../pi-ecosystem-judgment/index.js");
+import { match as contextMatch, } from './context-router.js';
+import { getCombinedJudgments, getJudgmentsForContext, calculateConfidence, } from '../pi-ecosystem-judgment/index.js';
 const DEFAULT_OPTIONS = {
     minConfidence: 0.7,
     maxJudgments: 5,
@@ -31,8 +24,8 @@ const DEFAULT_OPTIONS = {
 /**
  * Get judgments associated with a fragment name
  */
-async function getJudgmentsForFragment(fragmentName) {
-    const allJudgments = await (0, index_js_1.getCombinedJudgments)();
+export async function getJudgmentsForFragment(fragmentName) {
+    const allJudgments = await getCombinedJudgments();
     // Map fragment to judgment context categories
     const fragmentContextMap = {
         'truth-source-hierarchy': ['truth-source', 'code', 'architecture', 'hierarchy', 'priority'],
@@ -62,10 +55,10 @@ async function getJudgmentsForFragment(fragmentName) {
 /**
  * Get high-confidence judgments for a file path
  */
-async function getJudgmentsForPath(filePath, options = {}) {
+export async function getJudgmentsForPath(filePath, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
     // Get associated fragment names
-    const fragmentNames = (0, context_router_js_1.match)(filePath);
+    const fragmentNames = contextMatch(filePath);
     const allFragments = fragmentNames.length > 0 ? fragmentNames : ['general-dev-principles'];
     // Get judgments for each fragment
     const allJudgments = [];
@@ -89,7 +82,7 @@ async function getJudgmentsForPath(filePath, options = {}) {
     // Limit count
     const limitedJudgments = filteredJudgments.slice(0, opts.maxJudgments);
     // Calculate overall confidence
-    const overallConfidence = (0, index_js_1.calculateConfidence)(limitedJudgments);
+    const overallConfidence = calculateConfidence(limitedJudgments);
     // Format as YAML
     const contextYaml = formatJudgmentsAsYaml(limitedJudgments, opts);
     return {
@@ -102,8 +95,8 @@ async function getJudgmentsForPath(filePath, options = {}) {
 /**
  * Get core judgments for session start (high confidence only)
  */
-async function getCoreJudgmentsForSession(minConfidence = 0.9) {
-    const allJudgments = await (0, index_js_1.getCombinedJudgments)();
+export async function getCoreJudgmentsForSession(minConfidence = 0.9) {
+    const allJudgments = await getCombinedJudgments();
     const highConfidence = allJudgments
         .filter(j => j.confidence >= minConfidence && j.source === 'human')
         .sort((a, b) => b.confidence - a.confidence)
@@ -130,14 +123,14 @@ async function getCoreJudgmentsForSession(minConfidence = 0.9) {
 /**
  * Get judgments for a specific context (e.g., "investment", "code-review")
  */
-async function getJudgmentsForContextRequest(context, options = {}) {
+export async function getJudgmentsForContextRequest(context, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
-    const judgments = await (0, index_js_1.getJudgmentsForContext)(context);
+    const judgments = await getJudgmentsForContext(context);
     const filtered = judgments
         .filter(j => j.confidence >= opts.minConfidence)
         .sort((a, b) => b.confidence - a.confidence)
         .slice(0, opts.maxJudgments);
-    const overallConfidence = (0, index_js_1.calculateConfidence)(filtered);
+    const overallConfidence = calculateConfidence(filtered);
     const contextYaml = formatJudgmentsAsYaml(filtered, opts);
     return {
         fragments: [],
@@ -232,7 +225,7 @@ function escapeYamlString(str) {
 /**
  * Generate injection prompt for a file path
  */
-async function generateJudgmentInjection(filePath, gate, options = {}) {
+export async function generateJudgmentInjection(filePath, gate, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
     // Gate-specific confidence thresholds
     const gateConfidence = {
@@ -266,4 +259,3 @@ async function generateJudgmentInjection(filePath, gate, options = {}) {
 
 ${result.contextYaml}`;
 }
-//# sourceMappingURL=context-router-judgment.js.map

package/dist/bollharness-integration/context-router.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Context Router - Port of Bollharness context-fragments to Bolloon
  *
@@ -7,54 +6,15 @@
  *
  * Loads fragments from src/bollharness/scripts/context-fragments/
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONTEXT_FRAGMENTS = exports.ContextRouter = exports.FALLBACK_FRAGMENTS = exports.CONTEXT_MAP = exports.FRAGMENTS_DIR = exports.BOLLHARNESS_CONTEXT_DIR = void 0;
-exports.loadFragment = loadFragment;
-exports.match = match;
-exports.getFragments = getFragments;
-exports.loadFragments = loadFragments;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-exports.BOLLHARNESS_CONTEXT_DIR = path.join('src', 'bollharness', 'scripts', 'context-fragments');
-exports.FRAGMENTS_DIR = exports.BOLLHARNESS_CONTEXT_DIR;
+import * as fs from 'fs';
+import * as path from 'path';
+export const BOLLHARNESS_CONTEXT_DIR = path.join('src', 'bollharness', 'scripts', 'context-fragments');
+export const FRAGMENTS_DIR = BOLLHARNESS_CONTEXT_DIR;
 /**
  * Context Map - Maps file paths to relevant context fragments
  * Uses actual fragment filenames from src/bollharness/scripts/context-fragments/
  */
-exports.CONTEXT_MAP = {
+export const CONTEXT_MAP = {
     'src/agents/': ['truth-source-hierarchy', 'protocol-consumers'],
     'src/documents/': ['truth-source-hierarchy', 'db-shared-structures'],
     'src/network/': ['truth-source-hierarchy', 'protocol-consumers'],
@@ -71,17 +31,17 @@ exports.CONTEXT_MAP = {
 /**
  * Default fragments to inject when no specific match
  */
-exports.FALLBACK_FRAGMENTS = ['general-dev-principles', 'code-quality'];
+export const FALLBACK_FRAGMENTS = ['general-dev-principles', 'code-quality'];
 /**
  * Load a context fragment by name
  */
-function loadFragment(name) {
+export function loadFragment(name) {
     if (!name)
         return '';
-    const candidate = path.join(exports.FRAGMENTS_DIR, `${name}.md`);
+    const candidate = path.join(FRAGMENTS_DIR, `${name}.md`);
     try {
         const resolved = path.resolve(candidate);
-        const fragmentsDirResolved = path.resolve(exports.FRAGMENTS_DIR);
+        const fragmentsDirResolved = path.resolve(FRAGMENTS_DIR);
         if (!resolved.startsWith(fragmentsDirResolved))
             return '';
         if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
@@ -95,7 +55,7 @@ function loadFragment(name) {
  * Match file path to context fragments
  * Adapted from bollharness's match() function
  */
-function match(filePath) {
+export function match(filePath) {
     if (!filePath)
         return [];
     if (path.isAbsolute(filePath))
@@ -105,10 +65,10 @@ function match(filePath) {
         return [];
     }
     const matched = [];
-    const sortedPatterns = Object.keys(exports.CONTEXT_MAP).sort((a, b) => b.length - a.length);
+    const sortedPatterns = Object.keys(CONTEXT_MAP).sort((a, b) => b.length - a.length);
     for (const pattern of sortedPatterns) {
         if (normalized.startsWith(pattern) || normalized.endsWith(pattern)) {
-            matched.push(...exports.CONTEXT_MAP[pattern]);
+            matched.push(...CONTEXT_MAP[pattern]);
         }
     }
     return [...new Set(matched)];
@@ -116,17 +76,17 @@ function match(filePath) {
 /**
  * Get all fragments for a file
  */
-function getFragments(filePath) {
+export function getFragments(filePath) {
     let fragments = match(filePath);
     if (!fragments.length) {
-        fragments = Array.isArray(exports.FALLBACK_FRAGMENTS) ? exports.FALLBACK_FRAGMENTS : [exports.FALLBACK_FRAGMENTS];
+        fragments = Array.isArray(FALLBACK_FRAGMENTS) ? FALLBACK_FRAGMENTS : [FALLBACK_FRAGMENTS];
     }
     return fragments;
 }
 /**
  * Load all fragments for a file
  */
-function loadFragments(filePath) {
+export function loadFragments(filePath) {
     const fragmentNames = getFragments(filePath);
     const contentParts = [];
     for (const name of fragmentNames) {
@@ -139,12 +99,12 @@ function loadFragments(filePath) {
 /**
  * Context Router class for integration with Bolloon
  */
-class ContextRouter {
+export class ContextRouter {
     fragmentsDir;
     injectedFile;
     injectedTTL = 3600; // 1 hour
     constructor(fragmentsDir) {
-        this.fragmentsDir = fragmentsDir || exports.FRAGMENTS_DIR;
+        this.fragmentsDir = fragmentsDir || FRAGMENTS_DIR;
         this.injectedFile = path.join('.boll', 'guard', 'injected.json');
     }
     /**
@@ -177,7 +137,7 @@ class ContextRouter {
      */
     async getJudgmentsForPath(filePath, minConfidence = 0.7) {
         try {
-            const { getJudgmentsForPath } = await Promise.resolve().then(() => __importStar(require('./context-router-judgment.js')));
+            const { getJudgmentsForPath } = await import('./context-router-judgment.js');
             const result = await getJudgmentsForPath(filePath, { minConfidence });
             return result.contextYaml;
         }
@@ -190,7 +150,7 @@ class ContextRouter {
      */
     async getCoreJudgments(minConfidence = 0.9) {
         try {
-            const { getCoreJudgmentsForSession } = await Promise.resolve().then(() => __importStar(require('./context-router-judgment.js')));
+            const { getCoreJudgmentsForSession } = await import('./context-router-judgment.js');
             return await getCoreJudgmentsForSession(minConfidence);
         }
         catch {
@@ -202,7 +162,7 @@ class ContextRouter {
      */
     async getJudgmentsForContext(context, minConfidence = 0.7) {
         try {
-            const { getJudgmentsForContextRequest } = await Promise.resolve().then(() => __importStar(require('./context-router-judgment.js')));
+            const { getJudgmentsForContextRequest } = await import('./context-router-judgment.js');
             const result = await getJudgmentsForContextRequest(context, { minConfidence });
             return result.contextYaml;
         }
@@ -215,7 +175,7 @@ class ContextRouter {
      */
     async generateJudgmentInjection(filePath, gate) {
         try {
-            const { generateJudgmentInjection } = await Promise.resolve().then(() => __importStar(require('./context-router-judgment.js')));
+            const { generateJudgmentInjection } = await import('./context-router-judgment.js');
             return await generateJudgmentInjection(filePath, gate);
         }
         catch {
@@ -259,12 +219,11 @@ class ContextRouter {
         fs.writeFileSync(this.injectedFile, JSON.stringify(data, null, 2), 'utf-8');
     }
 }
-exports.ContextRouter = ContextRouter;
 /**
  * Context fragments content
  * These can be stored in context-fragments/ directory
  */
-exports.CONTEXT_FRAGMENTS = {
+export const CONTEXT_FRAGMENTS = {
     'general-dev-principles': `# General Development Principles
 
 ## Core Values
@@ -581,4 +540,3 @@ Bolloon is a P2P AI document processing system with multi-agent collaboration.
 - Coordinate with peers
 - Monitor performance`,
 };
-//# sourceMappingURL=context-router.js.map