modular-studio 1.0.5 → 1.1.0

package/dist-server/src/graph/types.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Context Graph — Type Definitions
+ *
+ * Universal dependency graph for code, markdown, YAML, and JSON files.
+ * Tracks cross-file relations for query-driven context assembly.
+ */
+import type { TreeIndex } from '../services/treeIndexer.js';
+export type FileLanguage = 'typescript' | 'python' | 'markdown' | 'yaml' | 'json' | 'unknown';
+export type SymbolKind = 'function' | 'class' | 'interface' | 'type' | 'const' | 'enum' | 'heading' | 'anchor' | 'definition' | 'link_target' | 'tag' | 'key' | 'schema' | 'export';
+export interface SymbolDef {
+    name: string;
+    kind: SymbolKind;
+    signature?: string;
+    lineStart: number;
+    lineEnd: number;
+    isExported: boolean;
+    treeNodeId?: string;
+    docstring?: string;
+    tokens?: number;
+}
+export interface FileNode {
+    id: string;
+    path: string;
+    language: FileLanguage;
+    lastModified: number;
+    contentHash: string;
+    tokens: number;
+    treeIndex?: TreeIndex;
+    symbols: SymbolDef[];
+}
+export type RelationKind = 'imports' | 'calls' | 'extends' | 'implements' | 'uses_type' | 'tested_by' | 'tests' | 'links_to' | 'references' | 'continues' | 'supersedes' | 'depends_on' | 'defined_in' | 'documents' | 'configured_by' | 'related';
+export interface Relation {
+    id?: number;
+    sourceFile: string;
+    sourceSymbol?: string;
+    targetFile: string;
+    targetSymbol?: string;
+    kind: RelationKind;
+    weight: number;
+    metadata?: Record<string, string>;
+}
+export interface ContextGraph {
+    nodes: Map<string, FileNode>;
+    relations: Relation[];
+    outgoing: Map<string, Relation[]>;
+    incoming: Map<string, Relation[]>;
+    symbolIndex: Map<string, FileNode[]>;
+    rootPath: string;
+    lastFullScan: number;
+    version: number;
+}
+export interface TraversalConfig {
+    maxDepth: number;
+    maxFiles: number;
+    tokenBudget: number;
+    minWeight: number;
+    followImports: boolean;
+    followCallers: boolean;
+    followTests: boolean;
+    followDocs: boolean;
+    followLinks: boolean;
+    followReferences: boolean;
+}
+export interface TraversalResult {
+    files: TraversalFile[];
+    totalTokens: number;
+    graphStats: {
+        nodesTraversed: number;
+        edgesFollowed: number;
+        nodesIncluded: number;
+        nodesPruned: number;
+    };
+}
+export interface TraversalFile {
+    node: FileNode;
+    relevance: number;
+    distance: number;
+    reason: string;
+    includeSymbols?: string[];
+}
+export interface EntryPoint {
+    fileId: string;
+    symbolName?: string;
+    confidence: number;
+    reason: 'Direct mention' | 'Filename match' | 'Semantic match';
+}
+export interface PackedContext {
+    items: PackedItem[];
+    totalTokens: number;
+    budgetUtilization: number;
+}
+export interface PackedItem {
+    file: FileNode;
+    content: string;
+    depth: number;
+    tokens: number;
+    relevance: number;
+}
+export interface UpdateResult {
+    filesUpdated: number;
+    relationsAdded: number;
+    relationsRemoved: number;
+    staleFilesTriggered: number;
+    durationMs: number;
+}
+export interface ScanResult extends UpdateResult {
+    totalFiles: number;
+    totalSymbols: number;
+    totalRelations: number;
+}
+export type TaskType = 'fix' | 'review' | 'explain' | 'build' | 'document' | 'research';
+export declare const TRAVERSAL_PRESETS: Record<TaskType, Partial<TraversalConfig>>;
+/**
+ * Auto-detect task type from query keywords.
+ */
+export declare function detectTaskType(query: string): TaskType;
+//# sourceMappingURL=types.d.ts.map

package/dist-server/src/graph/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/graph/types.ts"],"names":[],"mappings":"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"}

package/dist-server/src/graph/types.js

@@ -0,0 +1,63 @@
+/**
+ * Context Graph — Type Definitions
+ *
+ * Universal dependency graph for code, markdown, YAML, and JSON files.
+ * Tracks cross-file relations for query-driven context assembly.
+ */
+export const TRAVERSAL_PRESETS = {
+    fix: {
+        maxDepth: 3, maxFiles: 15,
+        followImports: true, followCallers: false, followTests: true,
+        followDocs: false, followLinks: false, followReferences: false,
+        minWeight: 0.4,
+    },
+    review: {
+        maxDepth: 2, maxFiles: 25,
+        followImports: true, followCallers: true, followTests: true,
+        followDocs: true, followLinks: true, followReferences: false,
+        minWeight: 0.3,
+    },
+    explain: {
+        maxDepth: 4, maxFiles: 20,
+        followImports: true, followCallers: false, followTests: false,
+        followDocs: true, followLinks: true, followReferences: true,
+        minWeight: 0.3,
+    },
+    build: {
+        maxDepth: 2, maxFiles: 15,
+        followImports: true, followCallers: false, followTests: false,
+        followDocs: true, followLinks: false, followReferences: false,
+        minWeight: 0.5,
+    },
+    document: {
+        maxDepth: 3, maxFiles: 20,
+        followImports: true, followCallers: true, followTests: true,
+        followDocs: true, followLinks: true, followReferences: true,
+        minWeight: 0.3,
+    },
+    research: {
+        maxDepth: 4, maxFiles: 30,
+        followImports: false, followCallers: false, followTests: false,
+        followDocs: true, followLinks: true, followReferences: true,
+        minWeight: 0.2,
+    },
+};
+/**
+ * Auto-detect task type from query keywords.
+ */
+export function detectTaskType(query) {
+    const q = query.toLowerCase();
+    if (/fix|bug|error|crash|broken|issue/.test(q))
+        return 'fix';
+    if (/\bresearch\b|find|look.*up|what.*about/.test(q))
+        return 'research';
+    if (/\breview\b|pr\b|pull request|diff|changes/.test(q))
+        return 'review';
+    if (/explain|how does|what is|understand|walk.*through/.test(q))
+        return 'explain';
+    if (/add|build|create|implement|feature|new/.test(q))
+        return 'build';
+    if (/document|readme|write.*doc|api.*doc/.test(q))
+        return 'document';
+    return 'explain';
+}

package/dist-server/src/metaprompt/v2/assembler.d.ts

@@ -0,0 +1,3 @@
+import type { LLMCallConfig, ParsedInput, ResearchResult, PatternSelection, ContextStrategy, AssembledAgent } from './types.js';
+export declare function runAssembler(parsed: ParsedInput, research: ResearchResult, pattern: PatternSelection, context: ContextStrategy, llmConfig: LLMCallConfig): Promise<AssembledAgent>;
+//# sourceMappingURL=assembler.d.ts.map

package/dist-server/src/metaprompt/v2/assembler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembler.d.ts","sourceRoot":"","sources":["../../../../src/metaprompt/v2/assembler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,cAAc,EAKf,MAAM,YAAY,CAAC;AAuGpB,wBAAsB,YAAY,CAChC,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,cAAc,EACxB,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,eAAe,EACxB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,cAAc,CAAC,CA4DzB"}

package/dist-server/src/metaprompt/v2/assembler.js

@@ -0,0 +1,261 @@
+import { fetchCompletion } from '../../services/llmService.js';
+function parseJSON(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch { /* continue */ }
+    const fenceMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenceMatch) {
+        try {
+            return JSON.parse(fenceMatch[1].trim());
+        }
+        catch { /* continue */ }
+    }
+    const braceMatch = text.match(/\{[\s\S]*\}/);
+    if (braceMatch) {
+        try {
+            return JSON.parse(braceMatch[0]);
+        }
+        catch { /* continue */ }
+    }
+    return null;
+}
+const AGENTIC_PILLARS = {
+    persistence: 'Continue working until the task is fully complete. Do not stop at an intermediate step or ask the user to continue unless you are genuinely blocked.',
+    tool_discipline: 'Use available tools to verify information. Do not guess, hallucinate, or assume data you could look up. If a tool call fails, report the failure rather than making up a result.',
+    planning: 'Before each major step, briefly state what you are about to do and why. After completing a step, reflect: did it produce what was expected? If not, adjust before proceeding.',
+};
+const SELF_CHECK = {
+    questions: [
+        'Does every recommendation trace to specific evidence (quote, data, observation)?',
+        'Did I apply each framework as concrete steps, not just mention it?',
+        'Are there any claims I made without tool verification?',
+        'Is the output actionable by someone who has no prior context?',
+        'Did I flag uncertainties and assumptions explicitly?',
+    ],
+    action: 'If any answer is "no", fix it before delivering.',
+};
+function buildFrameworkContext(research) {
+    const parts = [];
+    for (const ef of research.expert_frameworks) {
+        parts.push(`EXPERT: ${ef.expert_name} — ${ef.framework_name}
+Core: ${ef.core_concept}
+Steps:
+${ef.steps.map((s, i) => `  ${i + 1}. ${s.step}\n     Input: ${s.input}\n     Process: ${s.process}\n     Output: ${s.output}`).join('\n')}
+Decision rules: ${ef.decision_rules.join('; ')}
+Artifacts: ${ef.artifacts.join(', ')}
+Confidence: ${ef.research_confidence}${ef.research_note ? ` — ${ef.research_note}` : ''}`);
+    }
+    for (const mf of research.methodology_frameworks) {
+        parts.push(`METHODOLOGY: ${mf.name}
+Purpose: ${mf.purpose}
+Inputs: ${mf.mechanics.inputs.join(', ')}
+${mf.mechanics.formula ? `Formula: ${mf.mechanics.formula}` : ''}
+${mf.mechanics.scoring ? `Scoring: ${JSON.stringify(mf.mechanics.scoring, null, 2)}` : ''}
+Output: ${mf.mechanics.output}
+Decision rules: ${mf.mechanics.decision_rules.join('; ')}
+Confidence: ${mf.research_confidence}${mf.research_note ? ` — ${mf.research_note}` : ''}`);
+    }
+    if (research.conflicts.length > 0) {
+        parts.push(`CONFLICTS:\n${research.conflicts.map(c => `- ${c.concern}: ${c.frameworks.join(' vs ')} → ${c.resolution}`).join('\n')}`);
+    }
+    return parts.join('\n\n');
+}
+const ASSEMBLER_SYSTEM_PROMPT = `You assemble AI agent configurations from decomposed frameworks. Your output must operationalize every framework as executable workflow steps.
+
+Return ONLY a JSON object:
+{
+  "persona": "<max 3 sentences. WHO the agent is. No framework names. No methodology lists.>",
+  "role": "<one sentence: what the agent does>",
+  "workflow_steps": [
+    {
+      "number": 1,
+      "name": "[Framework]: [Action verb]",
+      "pattern": "chaining|routing|parallel|orchestrator|evaluator",
+      "input": "Explicit reference to data source or prior step output",
+      "process": "Exact procedure with scoring criteria, scales, decision trees. NOT 'apply best practices'.",
+      "output": "Named artifact with defined format (table, tree, scorecard, etc.)",
+      "decision_rules": ["If X then Y", "Override: when Z..."],
+      "tools_used": ["tool1"]
+    }
+  ],
+  "context_strategy": "<brief description of document access approach>",
+  "output_schema": {
+    "primary_artifact": {
+      "name": "...",
+      "format": "Table|Tree|Narrative|Scorecard",
+      "required_fields": ["field1", "field2"]
+    },
+    "secondary_artifacts": [{ "name": "...", "format": "..." }],
+    "meta": {
+      "confidence_flags": "Required — tag uncertain items",
+      "source_citations": "Required — link claims to evidence"
+    }
+  }
+}
+
+CRITICAL RULES:
+1. Every decomposed framework MUST produce at least one workflow step with concrete mechanics
+2. Steps reference inputs explicitly ("pain point table from step 2", NOT "the data")
+3. Process fields have scoring scales, formulas, classification criteria — NOT vague phrases
+4. No duplicate content between persona and workflow
+5. Persona is max 3 sentences, no framework names
+6. Always end with a Self-Check step
+7. If a framework has low confidence, add ⚠️ in the step name`;
+export async function runAssembler(parsed, research, pattern, context, llmConfig) {
+    const frameworkContext = buildFrameworkContext(research);
+    const contextSummary = context.classified_documents.length > 0
+        ? context.classified_documents.map(d => `- ${d.path}: ${d.category} (${d.estimated_tokens} tokens) — ${d.reasoning}`).join('\n')
+        : 'No documents provided.';
+    const text = await fetchCompletion({
+        providerId: llmConfig.providerId,
+        model: llmConfig.model,
+        messages: [
+            { role: 'system', content: ASSEMBLER_SYSTEM_PROMPT },
+            {
+                role: 'user',
+                content: `Build an agent config from these inputs:
+
+ROLE: ${parsed.role}
+DOMAIN: ${parsed.domain}
+SUCCESS CRITERIA: ${parsed.success_criteria.join(', ')}
+CONSTRAINTS: ${parsed.constraints.join(', ')}
+OUTPUT EXPECTATIONS: ${parsed.output_expectations.join(', ')}
+
+WORKFLOW PATTERN: ${pattern.pattern} — ${pattern.justification}
+SUGGESTED STEPS: ${pattern.suggested_steps.join(' → ')}
+
+DECOMPOSED FRAMEWORKS:
+${frameworkContext}
+
+DOCUMENT STRATEGY:
+${contextSummary}
+
+TOOLS AVAILABLE: ${parsed.tools_requested.join(', ') || 'Filesystem, Web Search'}
+
+Generate the agent config. Every framework above MUST become at least one workflow step with specific mechanics.`,
+            },
+        ],
+        temperature: 0.3,
+        maxTokens: 4096,
+    });
+    const result = parseJSON(text);
+    if (!result) {
+        throw new Error(`Assembler: could not parse LLM response. Raw: ${text.slice(0, 300)}`);
+    }
+    // Post-process: ensure all required fields, inject pillars and self-check
+    const assembled = {
+        persona: result.persona ?? `You are a ${parsed.role} specializing in ${parsed.domain}.`,
+        role: result.role ?? `${parsed.role} for ${parsed.domain}`,
+        workflow_steps: ensureWorkflowSteps(result.workflow_steps ?? [], research, SELF_CHECK),
+        context_strategy: result.context_strategy ?? buildContextStrategyText(context),
+        output_schema: ensureOutputSchema(result.output_schema, parsed),
+        agentic_pillars: AGENTIC_PILLARS,
+        self_check: SELF_CHECK,
+    };
+    return assembled;
+}
+/**
+ * Ensure workflow steps cover all frameworks and end with self-check.
+ */
+function ensureWorkflowSteps(steps, research, selfCheck) {
+    const coveredExperts = new Set();
+    const coveredMethodologies = new Set();
+    for (const step of steps) {
+        const nameLower = step.name.toLowerCase();
+        for (const ef of research.expert_frameworks) {
+            if (nameLower.includes(ef.expert_name.toLowerCase()) || nameLower.includes(ef.framework_name.toLowerCase())) {
+                coveredExperts.add(ef.expert_name);
+            }
+        }
+        for (const mf of research.methodology_frameworks) {
+            if (nameLower.includes(mf.name.toLowerCase())) {
+                coveredMethodologies.add(mf.name);
+            }
+        }
+    }
+    // Add missing expert framework steps
+    for (const ef of research.expert_frameworks) {
+        if (!coveredExperts.has(ef.expert_name) && ef.steps.length > 0) {
+            const confLabel = ef.research_confidence === 'low' ? '⚠️ ' : '';
+            steps.push({
+                number: steps.length + 1,
+                name: `${confLabel}${ef.framework_name} (${ef.expert_name})`,
+                pattern: 'chaining',
+                input: ef.steps[0].input,
+                process: ef.steps.map(s => `${s.step}: ${s.process}`).join('\n'),
+                output: ef.steps[ef.steps.length - 1].output,
+                decision_rules: ef.decision_rules,
+                tools_used: [],
+            });
+        }
+    }
+    // Add missing methodology steps
+    for (const mf of research.methodology_frameworks) {
+        if (!coveredMethodologies.has(mf.name)) {
+            const confLabel = mf.research_confidence === 'low' ? '⚠️ ' : '';
+            steps.push({
+                number: steps.length + 1,
+                name: `${confLabel}${mf.name}`,
+                pattern: 'chaining',
+                input: mf.mechanics.inputs.join(', '),
+                process: [
+                    mf.mechanics.formula ? `Formula: ${mf.mechanics.formula}` : '',
+                    mf.mechanics.scoring ? `Scoring: ${Object.entries(mf.mechanics.scoring).map(([k, v]) => `${k}: ${v.description} (${v.scale})`).join('; ')}` : '',
+                ].filter(Boolean).join('\n'),
+                output: mf.mechanics.output,
+                decision_rules: mf.mechanics.decision_rules,
+                tools_used: [],
+            });
+        }
+    }
+    // Renumber and add self-check as final step
+    const hasCheck = steps.some(s => s.name.toLowerCase().includes('self-check') || s.name.toLowerCase().includes('self check'));
+    if (!hasCheck) {
+        steps.push({
+            number: steps.length + 1,
+            name: 'Self-Check',
+            pattern: 'evaluator',
+            input: 'All prior step outputs',
+            process: selfCheck.questions.map(q => `- ${q}`).join('\n'),
+            output: 'Validated output — all checks pass before delivery',
+            decision_rules: [selfCheck.action],
+            tools_used: [],
+        });
+    }
+    // Renumber
+    steps.forEach((s, i) => { s.number = i + 1; });
+    return steps;
+}
+function buildContextStrategyText(context) {
+    if (context.classified_documents.length === 0)
+        return 'No documents — agent works from conversation input.';
+    const loaded = context.classified_documents.filter(d => d.category === 'always_loaded');
+    const onDemand = context.classified_documents.filter(d => d.category === 'on_demand');
+    const parts = [];
+    if (loaded.length > 0)
+        parts.push(`Always loaded: ${loaded.map(d => d.path).join(', ')}`);
+    if (onDemand.length > 0)
+        parts.push(`Fetch on demand: ${onDemand.map(d => d.path).join(', ')}`);
+    return parts.join('. ');
+}
+function ensureOutputSchema(schema, parsed) {
+    if (schema?.primary_artifact?.name && schema.primary_artifact.required_fields?.length > 0) {
+        return schema;
+    }
+    // Build from output expectations
+    return {
+        primary_artifact: {
+            name: parsed.output_expectations[0] ?? 'Analysis Report',
+            format: 'Table',
+            required_fields: parsed.output_expectations.length > 0
+                ? parsed.output_expectations
+                : ['Finding', 'Evidence', 'Recommendation', 'Priority', 'Confidence'],
+        },
+        secondary_artifacts: parsed.output_expectations.slice(1).map(e => ({ name: e, format: 'Narrative' })),
+        meta: {
+            confidence_flags: 'Required — tag uncertain items',
+            source_citations: 'Required — link claims to evidence',
+        },
+    };
+}

package/dist-server/src/metaprompt/v2/context-strategist.d.ts

@@ -0,0 +1,3 @@
+import type { LLMCallConfig, ParsedInput, ContextStrategy } from './types.js';
+export declare function runContextStrategist(parsed: ParsedInput, tokenBudget: number, llmConfig: LLMCallConfig): Promise<ContextStrategy>;
+//# sourceMappingURL=context-strategist.d.ts.map

package/dist-server/src/metaprompt/v2/context-strategist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-strategist.d.ts","sourceRoot":"","sources":["../../../../src/metaprompt/v2/context-strategist.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,eAAe,EAAwC,MAAM,YAAY,CAAC;AAwDpH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,WAAW,EACnB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,eAAe,CAAC,CA4F1B"}

package/dist-server/src/metaprompt/v2/context-strategist.js

@@ -0,0 +1,173 @@
+import { fetchCompletion } from '../../services/llmService.js';
+function parseJSON(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch { /* continue */ }
+    const fenceMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenceMatch) {
+        try {
+            return JSON.parse(fenceMatch[1].trim());
+        }
+        catch { /* continue */ }
+    }
+    const braceMatch = text.match(/\{[\s\S]*\}|\[[\s\S]*\]/);
+    if (braceMatch) {
+        try {
+            return JSON.parse(braceMatch[0]);
+        }
+        catch { /* continue */ }
+    }
+    return null;
+}
+/**
+ * Rough token estimation based on file type and size description.
+ */
+function estimateTokens(doc) {
+    const sizeMap = {
+        small: 500,
+        medium: 2000,
+        large: 8000,
+        'very large': 20000,
+    };
+    const base = sizeMap[doc.size_estimate.toLowerCase()] ?? 2000;
+    // Transcripts and meeting notes tend to be verbose
+    if (doc.inferred_type === 'signal' || doc.path.match(/transcript|meeting|interview/i)) {
+        return base * 1.5;
+    }
+    // Compressed/summary docs are smaller
+    if (doc.path.match(/compressed|summary/i)) {
+        return Math.floor(base * 0.5);
+    }
+    return base;
+}
+const CONTEXT_SYSTEM_PROMPT = `You classify documents for an AI agent's context window. Each document gets one category:
+
+- always_loaded: Needed in every interaction. Small reference data (org charts, glossaries, key definitions). < ~2000 tokens.
+- on_demand: Large or situationally needed. Transcripts, full reports. Agent fetches via tool when needed.
+- compressed: Useful background but too large raw. Summarize for context, full available via tool.
+- never_loaded: Not relevant to agent's purpose, or duplicates another document.
+
+Return ONLY a JSON array:
+[
+  {
+    "path": "...",
+    "category": "always_loaded|on_demand|compressed|never_loaded",
+    "reasoning": "Why this classification",
+    "estimated_tokens": <number>
+  }
+]
+
+Rules:
+- Be aggressive about on_demand for large files. Transcripts are ALWAYS on_demand.
+- Compressed summaries (.compressed.md) can be always_loaded if small enough.
+- If two documents overlap significantly, mark the less useful one as never_loaded.`;
+export async function runContextStrategist(parsed, tokenBudget, llmConfig) {
+    if (parsed.documents.length === 0) {
+        return {
+            classified_documents: [],
+            total_always_loaded_tokens: 0,
+            token_budget: tokenBudget,
+        };
+    }
+    const docList = parsed.documents.map((d, i) => `${i + 1}. path: "${d.path}" | type: ${d.inferred_type} | size: ${d.size_estimate}`).join('\n');
+    const text = await fetchCompletion({
+        providerId: llmConfig.providerId,
+        model: llmConfig.model,
+        messages: [
+            { role: 'system', content: CONTEXT_SYSTEM_PROMPT },
+            {
+                role: 'user',
+                content: `Agent role: ${parsed.role}
+Agent domain: ${parsed.domain}
+Token budget: ${tokenBudget}
+
+Documents to classify:
+${docList}`,
+            },
+        ],
+        temperature: 0.1,
+        maxTokens: 2048,
+    });
+    const rawResult = parseJSON(text);
+    let classified;
+    if (Array.isArray(rawResult)) {
+        classified = rawResult.map((item, i) => {
+            const doc = parsed.documents[i] ?? { path: item.path ?? '', inferred_type: 'unknown' };
+            const validCategories = ['always_loaded', 'on_demand', 'compressed', 'never_loaded'];
+            const category = validCategories.includes(item.category)
+                ? item.category
+                : 'on_demand';
+            return {
+                path: item.path ?? doc.path,
+                inferred_type: doc.inferred_type,
+                category,
+                reasoning: item.reasoning ?? '',
+                estimated_tokens: item.estimated_tokens ?? estimateTokens(doc),
+            };
+        });
+    }
+    else {
+        // LLM parse failed — use heuristic fallback
+        classified = parsed.documents.map(doc => {
+            const tokens = estimateTokens(doc);
+            let category = 'on_demand';
+            if (doc.path.match(/compressed|summary|overview|glossary|structure/i) && tokens < 2000) {
+                category = 'always_loaded';
+            }
+            else if (doc.path.match(/transcript|meeting|interview/i)) {
+                category = 'on_demand';
+            }
+            else if (tokens > 5000) {
+                category = 'compressed';
+            }
+            else if (tokens <= 2000) {
+                category = 'always_loaded';
+            }
+            return {
+                path: doc.path,
+                inferred_type: doc.inferred_type,
+                category,
+                reasoning: 'Heuristic classification (LLM parse failed)',
+                estimated_tokens: tokens,
+            };
+        });
+    }
+    // Apply token budget rules
+    classified = applyTokenBudgetRules(classified, tokenBudget);
+    const totalAlwaysLoaded = classified
+        .filter(d => d.category === 'always_loaded')
+        .reduce((sum, d) => sum + d.estimated_tokens, 0);
+    const result = {
+        classified_documents: classified,
+        total_always_loaded_tokens: totalAlwaysLoaded,
+        token_budget: tokenBudget,
+    };
+    if (totalAlwaysLoaded > tokenBudget * 0.8) {
+        result.token_budget_warning = `⚠️ Always-loaded context uses ${Math.round(totalAlwaysLoaded / tokenBudget * 100)}% of token budget (${totalAlwaysLoaded}/${tokenBudget}). Consider increasing budget or moving documents to on-demand retrieval.`;
+    }
+    return result;
+}
+/**
+ * If always_loaded documents exceed 60% of budget, demote the largest ones.
+ */
+function applyTokenBudgetRules(docs, tokenBudget) {
+    const threshold = tokenBudget * 0.6;
+    let alwaysLoaded = docs.filter(d => d.category === 'always_loaded');
+    let totalTokens = alwaysLoaded.reduce((sum, d) => sum + d.estimated_tokens, 0);
+    if (totalTokens <= threshold)
+        return docs;
+    // Sort by tokens descending — demote largest first
+    const sorted = [...alwaysLoaded].sort((a, b) => b.estimated_tokens - a.estimated_tokens);
+    for (const doc of sorted) {
+        if (totalTokens <= threshold)
+            break;
+        const target = docs.find(d => d.path === doc.path);
+        if (target) {
+            target.category = 'on_demand';
+            target.reasoning += ' [Auto-demoted: exceeded 60% token budget threshold]';
+            totalTokens -= target.estimated_tokens;
+        }
+    }
+    return docs;
+}

package/dist-server/src/metaprompt/v2/evaluator.d.ts

@@ -0,0 +1,3 @@
+import type { LLMCallConfig, ParsedInput, ResearchResult, AssembledAgent, ContextStrategy, EvaluationResult } from './types.js';
+export declare function runEvaluator(parsed: ParsedInput, research: ResearchResult, assembled: AssembledAgent, context: ContextStrategy, llmConfig: LLMCallConfig): Promise<EvaluationResult>;
+//# sourceMappingURL=evaluator.d.ts.map

package/dist-server/src/metaprompt/v2/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../../../src/metaprompt/v2/evaluator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,cAAc,EACd,cAAc,EACd,eAAe,EACf,gBAAgB,EAEjB,MAAM,YAAY,CAAC;AAiOpB,wBAAsB,YAAY,CAChC,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,cAAc,EACxB,SAAS,EAAE,cAAc,EACzB,OAAO,EAAE,eAAe,EACxB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAkF3B"}