@wowok/agent-mcp 2.3.13 → 2.3.14

package/dist/loop-engineering/aggregate.js

@@ -0,0 +1,132 @@
+function percentile(sortedValues, p) {
+    if (sortedValues.length === 0)
+        return 0;
+    const idx = Math.ceil((p / 100) * sortedValues.length) - 1;
+    return sortedValues[Math.max(0, idx)];
+}
+function topMessages(messages, limit = 5) {
+    const counts = new Map();
+    for (const msg of messages) {
+        if (!msg)
+            continue;
+        counts.set(msg, (counts.get(msg) || 0) + 1);
+    }
+    return Array.from(counts.entries())
+        .map(([message, count]) => ({ message, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, limit);
+}
+export function aggregateByTool(events) {
+    const groups = new Map();
+    for (const e of events) {
+        const key = e.tool_name || "unknown";
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(e);
+    }
+    const results = [];
+    for (const [tool_name, group] of groups) {
+        const total = group.length;
+        const success = group.filter((e) => e.status === "success").length;
+        const failed = group.filter((e) => e.status === "failed").length;
+        const pending = group.filter((e) => e.status === "pending_input").length;
+        const semanticHits = group.filter((e) => e.semantic_hit).length;
+        const durations = group.map((e) => e.duration_ms).sort((a, b) => a - b);
+        const errorDist = {};
+        const errorMsgs = [];
+        for (const e of group) {
+            if (e.error_code) {
+                errorDist[e.error_code] = (errorDist[e.error_code] || 0) + 1;
+            }
+            if (e.error_message)
+                errorMsgs.push(e.error_message);
+        }
+        results.push({
+            tool_name,
+            total_calls: total,
+            success_count: success,
+            failed_count: failed,
+            pending_input_count: pending,
+            success_rate: total > 0 ? success / total : 0,
+            avg_duration_ms: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
+            p50_duration_ms: percentile(durations, 50),
+            p95_duration_ms: percentile(durations, 95),
+            semantic_hit_rate: total > 0 ? semanticHits / total : 0,
+            error_distribution: errorDist,
+            top_error_messages: topMessages(errorMsgs),
+        });
+    }
+    return results.sort((a, b) => b.total_calls - a.total_calls);
+}
+export function aggregateByOperation(events) {
+    const groups = new Map();
+    for (const e of events) {
+        const key = e.operation_type || "unknown";
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(e);
+    }
+    const results = [];
+    for (const [operation_type, group] of groups) {
+        const total = group.length;
+        const success = group.filter((e) => e.status === "success").length;
+        const semanticHits = group.filter((e) => e.semantic_hit).length;
+        const errorDist = {};
+        for (const e of group) {
+            if (e.error_code) {
+                errorDist[e.error_code] = (errorDist[e.error_code] || 0) + 1;
+            }
+        }
+        results.push({
+            operation_type,
+            total_calls: total,
+            success_rate: total > 0 ? success / total : 0,
+            semantic_hit_rate: total > 0 ? semanticHits / total : 0,
+            error_distribution: errorDist,
+        });
+    }
+    return results.sort((a, b) => b.total_calls - a.total_calls);
+}
+export function aggregate(events) {
+    const total = events.length;
+    const success = events.filter((e) => e.status === "success").length;
+    const semanticHits = events.filter((e) => e.semantic_hit).length;
+    const unknownErrors = events.filter((e) => e.error_code === "unknown").length;
+    const durations = events.map((e) => e.duration_ms);
+    const errorDist = {};
+    const intentDist = {};
+    for (const e of events) {
+        if (e.error_code) {
+            errorDist[e.error_code] = (errorDist[e.error_code] || 0) + 1;
+        }
+        if (e.intent) {
+            intentDist[e.intent] = (intentDist[e.intent] || 0) + 1;
+        }
+    }
+    const timestamps = events
+        .map((e) => e.timestamp)
+        .filter(Boolean)
+        .sort();
+    return {
+        aggregation_date: new Date().toISOString(),
+        total_events: total,
+        date_range: {
+            earliest: timestamps[0] || "",
+            latest: timestamps[timestamps.length - 1] || "",
+        },
+        per_tool: aggregateByTool(events),
+        per_operation: aggregateByOperation(events),
+        overall: {
+            total_calls: total,
+            success_count: success,
+            failed_count: events.filter((e) => e.status === "failed").length,
+            success_rate: total > 0 ? success / total : 0,
+            semantic_hit_rate: total > 0 ? semanticHits / total : 0,
+            unknown_error_count: unknownErrors,
+            unknown_error_rate: total > 0 ? unknownErrors / total : 0,
+            avg_duration_ms: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
+        },
+        error_code_distribution: errorDist,
+        intent_distribution: intentDist,
+    };
+}

package/dist/loop-engineering/diagnose.d.ts

@@ -0,0 +1,21 @@
+import type { AggregatedStats } from "./aggregate.js";
+export type DiagnosisType = "rule_gap" | "description_quality" | "skill_need" | "recovery_ineffectiveness" | "latency_anomaly";
+export type DiagnosisSeverity = "P0" | "P1" | "P2" | "P3";
+export interface Diagnosis {
+    diagnosis_id: string;
+    type: DiagnosisType;
+    severity: DiagnosisSeverity;
+    title: string;
+    description: string;
+    evidence: Record<string, unknown>;
+    target: string;
+    proposed_improvement_type: "rule_addition" | "description_rewrite" | "skill_creation" | "recovery_priority_adjustment" | "investigation";
+}
+export interface DiagnosisReport {
+    report_id: string;
+    diagnosis_date: string;
+    total_diagnoses: number;
+    diagnoses: Diagnosis[];
+    summary: string;
+}
+export declare function diagnose(stats: AggregatedStats): DiagnosisReport;

package/dist/loop-engineering/diagnose.js

@@ -0,0 +1,179 @@
+const THRESHOLDS = {
+    UNKNOWN_ERROR_RATE_P0: 0.15,
+    UNKNOWN_ERROR_RATE_P1: 0.08,
+    LOW_SEMANTIC_HIT_RATE: 0.50,
+    LOW_SUCCESS_RATE: 0.70,
+    HIGH_LATENCY_MS: 5000,
+    MIN_SAMPLE_SIZE: 10,
+    MIN_UNKNOWN_ERRORS_FOR_RULE: 3,
+};
+function diagnoseRuleGaps(stats) {
+    const diagnoses = [];
+    if (stats.overall.unknown_error_rate >= THRESHOLDS.UNKNOWN_ERROR_RATE_P1 &&
+        stats.overall.unknown_error_count >= THRESHOLDS.MIN_UNKNOWN_ERRORS_FOR_RULE) {
+        const severity = stats.overall.unknown_error_rate >= THRESHOLDS.UNKNOWN_ERROR_RATE_P0 ? "P0" : "P1";
+        const unknownMessages = [];
+        for (const tool of stats.per_tool) {
+            for (const msg of tool.top_error_messages) {
+                unknownMessages.push(msg);
+            }
+        }
+        diagnoses.push({
+            diagnosis_id: `DIAG-RULE-${Date.now()}-001`,
+            type: "rule_gap",
+            severity,
+            title: `High unknown error rate (${(stats.overall.unknown_error_rate * 100).toFixed(1)}%)`,
+            description: `${stats.overall.unknown_error_count} errors classified as 'unknown' out of ${stats.overall.total_calls} total calls. The ERROR_RULES table does not cover these error patterns.`,
+            evidence: {
+                unknown_error_count: stats.overall.unknown_error_count,
+                unknown_error_rate: stats.overall.unknown_error_rate,
+                top_error_messages: unknownMessages.slice(0, 5),
+            },
+            target: "ERROR_RULES",
+            proposed_improvement_type: "rule_addition",
+        });
+    }
+    for (const tool of stats.per_tool) {
+        const unknownCount = tool.error_distribution["unknown"] || 0;
+        if (unknownCount >= THRESHOLDS.MIN_UNKNOWN_ERRORS_FOR_RULE) {
+            diagnoses.push({
+                diagnosis_id: `DIAG-RULE-${Date.now()}-${tool.tool_name}`,
+                type: "rule_gap",
+                severity: "P2",
+                title: `Tool '${tool.tool_name}' has ${unknownCount} unknown errors`,
+                description: `Tool-specific error patterns not covered by ERROR_RULES.`,
+                evidence: {
+                    tool_name: tool.tool_name,
+                    unknown_error_count: unknownCount,
+                    top_error_messages: tool.top_error_messages.slice(0, 3),
+                },
+                target: `ERROR_RULES (for ${tool.tool_name})`,
+                proposed_improvement_type: "rule_addition",
+            });
+        }
+    }
+    return diagnoses;
+}
+function diagnoseDescriptionQuality(stats) {
+    const diagnoses = [];
+    for (const tool of stats.per_tool) {
+        if (tool.total_calls < THRESHOLDS.MIN_SAMPLE_SIZE)
+            continue;
+        if (tool.semantic_hit_rate < THRESHOLDS.LOW_SEMANTIC_HIT_RATE) {
+            const severity = tool.semantic_hit_rate < 0.25 ? "P1" : "P2";
+            diagnoses.push({
+                diagnosis_id: `DIAG-DESC-${Date.now()}-${tool.tool_name}`,
+                type: "description_quality",
+                severity,
+                title: `Low semantic hit rate for '${tool.tool_name}' (${(tool.semantic_hit_rate * 100).toFixed(1)}%)`,
+                description: `The semantic layer is not producing summaries for most calls to this tool. This may indicate description gaps or missing INTENT_RULES for this operation type.`,
+                evidence: {
+                    tool_name: tool.tool_name,
+                    semantic_hit_rate: tool.semantic_hit_rate,
+                    total_calls: tool.total_calls,
+                },
+                target: `${tool.tool_name} description / INTENT_RULES`,
+                proposed_improvement_type: "description_rewrite",
+            });
+        }
+    }
+    return diagnoses;
+}
+function diagnoseSkillNeeds(stats) {
+    const diagnoses = [];
+    for (const op of stats.per_operation) {
+        if (op.total_calls < THRESHOLDS.MIN_SAMPLE_SIZE)
+            continue;
+        if (op.success_rate < THRESHOLDS.LOW_SUCCESS_RATE && op.success_rate > 0) {
+            diagnoses.push({
+                diagnosis_id: `DIAG-SKILL-${Date.now()}-${op.operation_type}`,
+                type: "skill_need",
+                severity: "P2",
+                title: `Operation '${op.operation_type}' has low success rate (${(op.success_rate * 100).toFixed(1)}%)`,
+                description: `This operation type has a high failure rate, suggesting users may lack guidance. A Skill with step-by-step dialogue and failure playbooks could help.`,
+                evidence: {
+                    operation_type: op.operation_type,
+                    success_rate: op.success_rate,
+                    total_calls: op.total_calls,
+                    error_distribution: op.error_distribution,
+                },
+                target: `new Skill for ${op.operation_type}`,
+                proposed_improvement_type: "skill_creation",
+            });
+        }
+    }
+    return diagnoses;
+}
+function diagnoseRecoveryIneffectiveness(stats) {
+    const diagnoses = [];
+    const errorEntries = Object.entries(stats.error_code_distribution)
+        .filter(([code]) => code !== "unknown")
+        .sort((a, b) => b[1] - a[1]);
+    for (const [errorCode, count] of errorEntries) {
+        const total = stats.overall.total_calls;
+        if (total > 0 && count / total > 0.10 && count >= THRESHOLDS.MIN_SAMPLE_SIZE) {
+            diagnoses.push({
+                diagnosis_id: `DIAG-RECOV-${Date.now()}-${errorCode}`,
+                type: "recovery_ineffectiveness",
+                severity: "P2",
+                title: `Error code '${errorCode}' accounts for ${count} failures (${((count / total) * 100).toFixed(1)}%)`,
+                description: `This error code is frequent. The recovery strategy may need priority adjustment or the root cause should be addressed at the source.`,
+                evidence: {
+                    error_code: errorCode,
+                    count,
+                    percentage: count / total,
+                },
+                target: `RECOVERY_RULES['${errorCode}']`,
+                proposed_improvement_type: "recovery_priority_adjustment",
+            });
+        }
+    }
+    return diagnoses;
+}
+function diagnoseLatencyAnomalies(stats) {
+    const diagnoses = [];
+    for (const tool of stats.per_tool) {
+        if (tool.total_calls < THRESHOLDS.MIN_SAMPLE_SIZE)
+            continue;
+        if (tool.p95_duration_ms > THRESHOLDS.HIGH_LATENCY_MS) {
+            diagnoses.push({
+                diagnosis_id: `DIAG-LATENCY-${Date.now()}-${tool.tool_name}`,
+                type: "latency_anomaly",
+                severity: "P3",
+                title: `Tool '${tool.tool_name}' has high p95 latency (${tool.p95_duration_ms}ms)`,
+                description: `The 95th percentile latency exceeds the threshold. This may indicate performance issues or RPC bottlenecks.`,
+                evidence: {
+                    tool_name: tool.tool_name,
+                    p95_duration_ms: tool.p95_duration_ms,
+                    avg_duration_ms: tool.avg_duration_ms,
+                },
+                target: tool.tool_name,
+                proposed_improvement_type: "investigation",
+            });
+        }
+    }
+    return diagnoses;
+}
+export function diagnose(stats) {
+    const all = [
+        ...diagnoseRuleGaps(stats),
+        ...diagnoseDescriptionQuality(stats),
+        ...diagnoseSkillNeeds(stats),
+        ...diagnoseRecoveryIneffectiveness(stats),
+        ...diagnoseLatencyAnomalies(stats),
+    ];
+    const severityOrder = { P0: 0, P1: 1, P2: 2, P3: 3 };
+    all.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+    const p0Count = all.filter((d) => d.severity === "P0").length;
+    const p1Count = all.filter((d) => d.severity === "P1").length;
+    const summary = `${all.length} diagnoses: ${p0Count} P0, ${p1Count} P1, ${all.length - p0Count - p1Count} P2/P3. ` +
+        `Overall success rate: ${(stats.overall.success_rate * 100).toFixed(1)}%. ` +
+        `Unknown error rate: ${(stats.overall.unknown_error_rate * 100).toFixed(1)}%.`;
+    return {
+        report_id: `DIAG-REPORT-${Date.now()}`,
+        diagnosis_date: new Date().toISOString(),
+        total_diagnoses: all.length,
+        diagnoses: all,
+        summary,
+    };
+}

package/dist/loop-engineering/improve.d.ts

@@ -0,0 +1,26 @@
+import type { DiagnosisReport } from "./diagnose.js";
+export type ProposalType = "error_rule_addition" | "intent_rule_addition" | "description_rewrite" | "skill_creation" | "recovery_priority_adjustment" | "investigation";
+export type AutomationLevel = "full" | "semi" | "manual";
+export interface ImprovementProposal {
+    proposal_id: string;
+    source_diagnosis_id: string;
+    type: ProposalType;
+    priority: string;
+    automation: AutomationLevel;
+    title: string;
+    description: string;
+    target: string;
+    proposed_change: Record<string, unknown>;
+    evidence: Record<string, unknown>;
+    review_status: "pending" | "approved" | "rejected" | "applied";
+    ab_test_recommended: boolean;
+}
+export interface ImprovementReport {
+    report_id: string;
+    generated_date: string;
+    source_diagnosis_report_id: string;
+    total_proposals: number;
+    proposals: ImprovementProposal[];
+    summary: string;
+}
+export declare function generateImprovements(report: DiagnosisReport): ImprovementReport;

package/dist/loop-engineering/improve.js

@@ -0,0 +1,178 @@
+function proposeErrorRuleAddition(diagnosis) {
+    const evidence = diagnosis.evidence;
+    const topMessages = evidence.top_error_messages || [];
+    const candidatePatterns = topMessages.slice(0, 3).map((m) => {
+        const msg = m.message.toLowerCase();
+        let pattern = msg
+            .replace(/0x[0-9a-f]+/gi, "0xADDR")
+            .replace(/\d+/g, "\\d+")
+            .replace(/[^\w\s\\]/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        if (pattern.length > 60)
+            pattern = pattern.slice(0, 60);
+        return { pattern, sample_count: m.count };
+    });
+    return {
+        proposal_id: `PROP-RULE-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        source_diagnosis_id: diagnosis.diagnosis_id,
+        type: "error_rule_addition",
+        priority: diagnosis.severity,
+        automation: "semi",
+        title: `Add ERROR_RULES entries for ${diagnosis.target}`,
+        description: `Generate new error classification rules to cover patterns currently falling into 'unknown'. AI should draft regex patterns; human reviewer validates accuracy and assigns correct error_code.`,
+        target: "ERROR_RULES",
+        proposed_change: {
+            action: "append",
+            rules: candidatePatterns.map((p) => ({
+                pattern: p.pattern,
+                error_code: "unknown",
+                retryable: false,
+                recovery_hint: "TODO: assign by reviewer",
+                sample_message: p.sample_count,
+            })),
+            note: "error_code must be assigned by human reviewer based on semantic analysis",
+        },
+        evidence: diagnosis.evidence,
+        review_status: "pending",
+        ab_test_recommended: true,
+    };
+}
+function proposeDescriptionRewrite(diagnosis) {
+    const evidence = diagnosis.evidence;
+    return {
+        proposal_id: `PROP-DESC-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        source_diagnosis_id: diagnosis.diagnosis_id,
+        type: "description_rewrite",
+        priority: diagnosis.severity,
+        automation: "semi",
+        title: `Rewrite description for ${evidence.tool_name || diagnosis.target}`,
+        description: `The semantic layer produces no summary for ${((1 - (evidence.semantic_hit_rate || 0)) * 100).toFixed(1)}% of calls to this tool. AI should rewrite the tool description and INTENT_RULES to improve coverage. A/B test before merging.`,
+        target: diagnosis.target,
+        proposed_change: {
+            action: "rewrite",
+            current_semantic_hit_rate: evidence.semantic_hit_rate,
+            target_semantic_hit_rate: 0.80,
+            rewrite_guidelines: [
+                "Follow 4-part format: 含义 + Constraint + Relation + Example",
+                "Add explicit intent signals to INTENT_RULES",
+                "Include concrete examples for common operation types",
+            ],
+        },
+        evidence: diagnosis.evidence,
+        review_status: "pending",
+        ab_test_recommended: true,
+    };
+}
+function proposeSkillCreation(diagnosis) {
+    const evidence = diagnosis.evidence;
+    return {
+        proposal_id: `PROP-SKILL-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        source_diagnosis_id: diagnosis.diagnosis_id,
+        type: "skill_creation",
+        priority: diagnosis.severity,
+        automation: "semi",
+        title: `Create new Skill for '${evidence.operation_type}' operations`,
+        description: `This operation type has a ${(evidence.success_rate ? (1 - evidence.success_rate) * 100 : 0).toFixed(1)}% failure rate across ${evidence.total_calls} calls. A Skill with R1-R10 dialogue scripts, decision trees, and failure playbooks could guide users to success.`,
+        target: `wowok-${evidence.operation_type}-guide`,
+        proposed_change: {
+            action: "create",
+            skill_name: `wowok-${evidence.operation_type}-guide`,
+            skill_structure: {
+                sections: ["R1-R10 dialogues", "Decision trees", "Failure playbooks", "Tier layering"],
+                target_role: "provider",
+                loading: "on-demand",
+            },
+            top_errors: evidence.error_distribution,
+        },
+        evidence: diagnosis.evidence,
+        review_status: "pending",
+        ab_test_recommended: false,
+    };
+}
+function proposeRecoveryAdjustment(diagnosis) {
+    const evidence = diagnosis.evidence;
+    return {
+        proposal_id: `PROP-RECOV-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        source_diagnosis_id: diagnosis.diagnosis_id,
+        type: "recovery_priority_adjustment",
+        priority: diagnosis.severity,
+        automation: "semi",
+        title: `Review recovery strategy for '${evidence.error_code}' errors`,
+        description: `Error code '${evidence.error_code}' accounts for ${evidence.count} failures (${((evidence.percentage || 0) * 100).toFixed(1)}%). The current recovery strategy may need tuning — consider increasing max_attempts, adjusting automation level, or addressing the root cause.`,
+        target: `RECOVERY_RULES['${evidence.error_code}']`,
+        proposed_change: {
+            action: "review_and_adjust",
+            current_strategy: "see RECOVERY_RULES table",
+            suggestions: [
+                "Increase max_attempts if failures are transient",
+                "Reduce max_attempts if failures are persistent (wastes user time)",
+                "Upgrade automation from 'semi' to 'full' if recovery is deterministic",
+                "Consider root-cause fix in description/rules to prevent the error",
+            ],
+        },
+        evidence: diagnosis.evidence,
+        review_status: "pending",
+        ab_test_recommended: false,
+    };
+}
+function proposeInvestigation(diagnosis) {
+    return {
+        proposal_id: `PROP-INV-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        source_diagnosis_id: diagnosis.diagnosis_id,
+        type: "investigation",
+        priority: diagnosis.severity,
+        automation: "manual",
+        title: diagnosis.title,
+        description: `Manual investigation required. ${diagnosis.description}`,
+        target: diagnosis.target,
+        proposed_change: {
+            action: "investigate",
+            steps: [
+                "Collect additional telemetry around the anomaly",
+                "Check if the issue is reproducible",
+                "Determine if the root cause is in the SDK, MCP layer, or user behavior",
+            ],
+        },
+        evidence: diagnosis.evidence,
+        review_status: "pending",
+        ab_test_recommended: false,
+    };
+}
+export function generateImprovements(report) {
+    const proposals = [];
+    for (const diagnosis of report.diagnoses) {
+        let proposal;
+        switch (diagnosis.proposed_improvement_type) {
+            case "rule_addition":
+                proposal = proposeErrorRuleAddition(diagnosis);
+                break;
+            case "description_rewrite":
+                proposal = proposeDescriptionRewrite(diagnosis);
+                break;
+            case "skill_creation":
+                proposal = proposeSkillCreation(diagnosis);
+                break;
+            case "recovery_priority_adjustment":
+                proposal = proposeRecoveryAdjustment(diagnosis);
+                break;
+            default:
+                proposal = proposeInvestigation(diagnosis);
+        }
+        proposals.push(proposal);
+    }
+    const p0Count = proposals.filter((p) => p.priority === "P0").length;
+    const semiCount = proposals.filter((p) => p.automation === "semi").length;
+    const abTestCount = proposals.filter((p) => p.ab_test_recommended).length;
+    const summary = `${proposals.length} proposals generated from ${report.total_diagnoses} diagnoses. ` +
+        `${p0Count} P0, ${semiCount} semi-automatic, ${abTestCount} recommend A/B testing. ` +
+        `All proposals require human review before application.`;
+    return {
+        report_id: `IMPROVE-REPORT-${Date.now()}`,
+        generated_date: new Date().toISOString(),
+        source_diagnosis_report_id: report.report_id,
+        total_proposals: proposals.length,
+        proposals,
+        summary,
+    };
+}

package/dist/loop-engineering/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./aggregate.js";
+export * from "./diagnose.js";
+export * from "./improve.js";
+export * from "./pipeline.js";

package/dist/loop-engineering/index.js

@@ -0,0 +1,4 @@
+export * from "./aggregate.js";
+export * from "./diagnose.js";
+export * from "./improve.js";
+export * from "./pipeline.js";

package/dist/loop-engineering/pipeline.d.ts

@@ -0,0 +1,17 @@
+import type { TelemetryEvent } from "../telemetry/index.js";
+import { type AggregatedStats } from "./aggregate.js";
+import { type DiagnosisReport } from "./diagnose.js";
+import { type ImprovementReport } from "./improve.js";
+export interface LoopEngineeringReport {
+    pipeline_run_id: string;
+    run_date: string;
+    stage: "aggregate" | "diagnose" | "improve" | "complete";
+    aggregated_stats: AggregatedStats | null;
+    diagnosis_report: DiagnosisReport | null;
+    improvement_report: ImprovementReport | null;
+    error?: string;
+}
+export declare function runLoopEngineeringPipeline(): Promise<LoopEngineeringReport>;
+export declare function runDiagnoseFromStats(stats: AggregatedStats): DiagnosisReport;
+export declare function runImproveFromDiagnoses(report: DiagnosisReport): ImprovementReport;
+export declare function runAggregateFromEvents(events: TelemetryEvent[]): AggregatedStats;

package/dist/loop-engineering/pipeline.js

@@ -0,0 +1,56 @@
+import { getStorage } from "../telemetry/storage.js";
+import { aggregate } from "./aggregate.js";
+import { diagnose } from "./diagnose.js";
+import { generateImprovements } from "./improve.js";
+async function loadTelemetryEvents() {
+    const storage = getStorage();
+    const rawEvents = await storage.query({});
+    return rawEvents;
+}
+async function runAggregateStage() {
+    const events = await loadTelemetryEvents();
+    return aggregate(events);
+}
+function runDiagnoseStage(stats) {
+    return diagnose(stats);
+}
+function runImproveStage(diagnosisReport) {
+    return generateImprovements(diagnosisReport);
+}
+export async function runLoopEngineeringPipeline() {
+    const runId = `LE-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const runDate = new Date().toISOString();
+    try {
+        const aggregatedStats = await runAggregateStage();
+        const diagnosisReport = runDiagnoseStage(aggregatedStats);
+        const improvementReport = runImproveStage(diagnosisReport);
+        return {
+            pipeline_run_id: runId,
+            run_date: runDate,
+            stage: "complete",
+            aggregated_stats: aggregatedStats,
+            diagnosis_report: diagnosisReport,
+            improvement_report: improvementReport,
+        };
+    }
+    catch (error) {
+        return {
+            pipeline_run_id: runId,
+            run_date: runDate,
+            stage: "complete",
+            aggregated_stats: null,
+            diagnosis_report: null,
+            improvement_report: null,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export function runDiagnoseFromStats(stats) {
+    return runDiagnoseStage(stats);
+}
+export function runImproveFromDiagnoses(report) {
+    return runImproveStage(report);
+}
+export function runAggregateFromEvents(events) {
+    return aggregate(events);
+}

package/dist/mode-market/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./registry.js";
+export * from "./review.js";
+export * from "./submission.js";

package/dist/mode-market/index.js

@@ -0,0 +1,3 @@
+export * from "./registry.js";
+export * from "./review.js";
+export * from "./submission.js";