@wowok/agent-mcp 2.3.14 → 2.3.18

package/dist/loop-engineering/diagnose.js

@@ -1,3 +1,4 @@
+import { listIndustriesWithSignals, getIndustryEvolutionStatus, getPendingSuggestions, getIndustrySignalCount, } from "../knowledge/flywheel-loop.js";
 const THRESHOLDS = {
     UNKNOWN_ERROR_RATE_P0: 0.15,
     UNKNOWN_ERROR_RATE_P1: 0.08,
@@ -154,6 +155,98 @@ function diagnoseLatencyAnomalies(stats) {
     }
     return diagnoses;
 }
+const INDUSTRY_HEALTH_THRESHOLDS = {
+    CRITICAL_HEALTH_SCORE: 45,
+    STRESSED_HEALTH_SCORE: 65,
+    HIGH_PENDING_SUGGESTIONS: 3,
+    STALE_SIGNAL_THRESHOLD: 20,
+};
+export function diagnoseIndustryHealth(industries) {
+    const targets = industries ?? listIndustriesWithSignals();
+    const diagnoses = [];
+    for (const industry of targets) {
+        const status = getIndustryEvolutionStatus(industry);
+        const pendingDetail = getPendingSuggestions(industry);
+        const signalCount = getIndustrySignalCount(industry);
+        if (status.health) {
+            const score = status.health.health_score;
+            if (score < INDUSTRY_HEALTH_THRESHOLDS.CRITICAL_HEALTH_SCORE) {
+                diagnoses.push({
+                    diagnosis_id: `DIAG-IND-${Date.now()}-${industry}-critical`,
+                    type: "industry_health_anomaly",
+                    severity: "P0",
+                    title: `Industry '${industry}' health critical (${score}/100, ${status.health.level})`,
+                    description: `Industry health score is in the danger zone. Weaknesses: ${status.health.weaknesses.join("; ") || "none"}. Recommendations: ${status.health.recommendations.join("; ") || "none"}.`,
+                    evidence: {
+                        industry,
+                        health_score: score,
+                        health_level: status.health.level,
+                        weaknesses: status.health.weaknesses,
+                        recommendations: status.health.recommendations,
+                        signal_count: signalCount,
+                    },
+                    target: `industry:${industry}`,
+                    proposed_improvement_type: "industry_update_application",
+                });
+            }
+            else if (score < INDUSTRY_HEALTH_THRESHOLDS.STRESSED_HEALTH_SCORE) {
+                diagnoses.push({
+                    diagnosis_id: `DIAG-IND-${Date.now()}-${industry}-stressed`,
+                    type: "industry_health_anomaly",
+                    severity: "P1",
+                    title: `Industry '${industry}' health stressed (${score}/100, ${status.health.level})`,
+                    description: `Industry health score is under pressure. Weaknesses: ${status.health.weaknesses.join("; ") || "none"}.`,
+                    evidence: {
+                        industry,
+                        health_score: score,
+                        health_level: status.health.level,
+                        weaknesses: status.health.weaknesses,
+                        signal_count: signalCount,
+                    },
+                    target: `industry:${industry}`,
+                    proposed_improvement_type: "industry_update_application",
+                });
+            }
+        }
+        if (pendingDetail.length >= INDUSTRY_HEALTH_THRESHOLDS.HIGH_PENDING_SUGGESTIONS) {
+            const highPriority = pendingDetail.filter((s) => s.priority === "high");
+            diagnoses.push({
+                diagnosis_id: `DIAG-IND-${Date.now()}-${industry}-pending`,
+                type: "industry_health_anomaly",
+                severity: highPriority.length > 0 ? "P1" : "P2",
+                title: `Industry '${industry}' has ${pendingDetail.length} pending suggestions (${highPriority.length} high priority)`,
+                description: `Industry has ${pendingDetail.length} pending evolution suggestions unprocessed. Review and apply promptly to drive industry evolution.`,
+                evidence: {
+                    industry,
+                    pending_count: pendingDetail.length,
+                    high_priority_count: highPriority.length,
+                    suggestion_types: pendingDetail.map((s) => s.suggestion_type),
+                    suggestion_summaries: pendingDetail.map((s) => ({ type: s.suggestion_type, field: s.field, priority: s.priority })),
+                },
+                target: `industry:${industry}:pending_suggestions`,
+                proposed_improvement_type: "industry_update_application",
+            });
+        }
+        if (signalCount >= INDUSTRY_HEALTH_THRESHOLDS.STALE_SIGNAL_THRESHOLD && !status.health) {
+            diagnoses.push({
+                diagnosis_id: `DIAG-IND-${Date.now()}-${industry}-stale`,
+                type: "industry_health_anomaly",
+                severity: "P2",
+                title: `Industry '${industry}' has ${signalCount} signals but no health report (evolution stale)`,
+                description: `Industry has accumulated ${signalCount} signals but health score has not been recalculated. May need to manually trigger updateIndustryCognition or check scheduling configuration.`,
+                evidence: {
+                    industry,
+                    signal_count: signalCount,
+                    evolution_ready: status.evolution_ready,
+                    version: status.version,
+                },
+                target: `industry:${industry}:cognition`,
+                proposed_improvement_type: "industry_update_application",
+            });
+        }
+    }
+    return diagnoses;
+}
 export function diagnose(stats) {
     const all = [
         ...diagnoseRuleGaps(stats),
@@ -161,6 +254,7 @@ export function diagnose(stats) {
         ...diagnoseSkillNeeds(stats),
         ...diagnoseRecoveryIneffectiveness(stats),
         ...diagnoseLatencyAnomalies(stats),
+        ...diagnoseIndustryHealth(),
     ];
     const severityOrder = { P0: 0, P1: 1, P2: 2, P3: 3 };
     all.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);

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

@@ -1,5 +1,5 @@
 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 ProposalType = "error_rule_addition" | "intent_rule_addition" | "description_rewrite" | "skill_creation" | "recovery_priority_adjustment" | "investigation" | "industry_update_application";
 export type AutomationLevel = "full" | "semi" | "manual";
 export interface ImprovementProposal {
     proposal_id: string;

package/dist/loop-engineering/improve.js

@@ -1,3 +1,4 @@
+import { getPendingSuggestions } from "../knowledge/flywheel-loop.js";
 function proposeErrorRuleAddition(diagnosis) {
     const evidence = diagnosis.evidence;
     const topMessages = evidence.top_error_messages || [];
@@ -54,7 +55,7 @@ function proposeDescriptionRewrite(diagnosis) {
             current_semantic_hit_rate: evidence.semantic_hit_rate,
             target_semantic_hit_rate: 0.80,
             rewrite_guidelines: [
-                "Follow 4-part format: 含义 + Constraint + Relation + Example",
+                "Follow 4-part format: Meaning + Constraint + Relation + Example",
                 "Add explicit intent signals to INTENT_RULES",
                 "Include concrete examples for common operation types",
             ],
@@ -139,6 +140,53 @@ function proposeInvestigation(diagnosis) {
         ab_test_recommended: false,
     };
 }
+function proposeIndustryUpdate(diagnosis) {
+    const evidence = diagnosis.evidence;
+    const industry = evidence.industry ?? diagnosis.target.split(":")[1] ?? "unknown";
+    const pendingSuggestions = industry !== "unknown"
+        ? getPendingSuggestions(industry)
+        : [];
+    const changes = pendingSuggestions.map((s) => ({
+        suggestion_type: s.suggestion_type,
+        field: s.field,
+        suggested_value: s.suggested_value,
+        evidence: s.evidence,
+        confidence: s.confidence,
+        priority: s.priority,
+    }));
+    const isHealthCritical = evidence.health_score !== undefined && evidence.health_score < 45;
+    const hasHighPrioritySuggestions = (evidence.high_priority_count ?? 0) > 0;
+    return {
+        proposal_id: `PROP-IND-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        source_diagnosis_id: diagnosis.diagnosis_id,
+        type: "industry_update_application",
+        priority: diagnosis.severity,
+        automation: isHealthCritical ? "semi" : "manual",
+        title: `Apply ${pendingSuggestions.length} evolution suggestions for industry '${industry}'`,
+        description: `Industry '${industry}' has health anomaly (health score ${evidence.health_score ?? "N/A"}, level ${evidence.health_level ?? "N/A"}). ` +
+            `Has ${pendingSuggestions.length} pending evolution suggestions (${(evidence.high_priority_count ?? 0)} high priority). ` +
+            `Review and apply to drive industry cognition evolution. Weaknesses: ${(evidence.weaknesses ?? []).join("; ") || "none"}.`,
+        target: `industry:${industry}`,
+        proposed_change: {
+            action: "apply_industry_updates",
+            industry,
+            current_health_score: evidence.health_score,
+            current_health_level: evidence.health_level,
+            weaknesses: evidence.weaknesses ?? [],
+            recommendations: evidence.recommendations ?? [],
+            pending_suggestion_count: pendingSuggestions.length,
+            high_priority_count: evidence.high_priority_count ?? 0,
+            suggestions: changes,
+            auto_applicable_suggestions: changes.filter((c) => c.confidence >= 0.85 && c.priority === "high"),
+            apply_guidance: hasHighPrioritySuggestions
+                ? "Prioritize reviewing high-priority suggestions; high-confidence (≥0.85) suggestions can be semi-automatically applied"
+                : "No high-priority suggestions, review via normal process",
+        },
+        evidence: diagnosis.evidence,
+        review_status: "pending",
+        ab_test_recommended: false,
+    };
+}
 export function generateImprovements(report) {
     const proposals = [];
     for (const diagnosis of report.diagnoses) {
@@ -156,6 +204,9 @@ export function generateImprovements(report) {
             case "recovery_priority_adjustment":
                 proposal = proposeRecoveryAdjustment(diagnosis);
                 break;
+            case "industry_update_application":
+                proposal = proposeIndustryUpdate(diagnosis);
+                break;
             default:
                 proposal = proposeInvestigation(diagnosis);
         }

package/dist/project/graph.d.ts

@@ -0,0 +1,71 @@
+import type { ProjectObjectType } from "./namespace.js";
+export type EdgeKind = "machine" | "order_allocators" | "arbitrations" | "compensation_fund" | "rewards" | "buy_guard" | "permission" | "guard" | "prev" | "next" | "forward" | "parent" | "service" | "progress" | "arbitration" | "sub_order" | "references";
+export interface GraphNode {
+    id: string;
+    project?: string;
+    type?: ProjectObjectType;
+    address?: string;
+    decision_contexts?: GraphDecisionContext[];
+}
+export interface GraphDecisionContext {
+    id: string;
+    decided_at: number;
+    decider: "user" | "ai" | "system";
+    industry?: string;
+    intent?: string;
+    alternatives?: string[];
+    rationale?: string;
+    outcome?: "success" | "failed" | "pending";
+}
+export interface GraphEdge {
+    from: string;
+    to: string;
+    kind: EdgeKind;
+}
+export interface GraphSnapshot {
+    nodes: Record<string, GraphNode>;
+    edges: GraphEdge[];
+    cycles: string[][];
+    version: number;
+    updatedAt: number;
+}
+export declare class ProjectGraph {
+    private nodes;
+    private edges;
+    private outEdges;
+    private inEdges;
+    private cycles;
+    private updatedAt;
+    upsertNode(node: GraphNode): GraphNode;
+    addEdge(from: string, to: string, kind: EdgeKind): void;
+    removeNode(id: string): void;
+    getNode(id: string): GraphNode | undefined;
+    listNodes(projectPrefix?: string): GraphNode[];
+    getDependencies(id: string): GraphEdge[];
+    getReferencedBy(id: string): GraphEdge[];
+    detectCycles(): string[][];
+    findDanglingDependencies(): Array<{
+        from: string;
+        missing: string[];
+    }>;
+    snapshot(): GraphSnapshot;
+    restore(snap: GraphSnapshot): void;
+    clear(): void;
+    get nodeCount(): number;
+    get edgeCount(): number;
+    getEdges(): GraphEdge[];
+    attachDecisionContext(nodeId: string, ctx: Omit<GraphDecisionContext, "id" | "decided_at"> & Partial<Pick<GraphDecisionContext, "id" | "decided_at">>): GraphDecisionContext | undefined;
+    getDecisionContexts(nodeId: string): GraphDecisionContext[];
+    queryDecisionContextsByIndustry(industry: string): Array<{
+        node_id: string;
+        ctx: GraphDecisionContext;
+    }>;
+    backfillDecisionOutcome(decisionId: string, outcome: "success" | "failed" | "pending"): boolean;
+}
+export interface ExtractedReference {
+    field: string;
+    target: string;
+    kind: EdgeKind;
+}
+export declare function extractReferences(operation_type: string, data: any): ExtractedReference[];
+export declare function nodeIdOf(name?: string, address?: string): string | undefined;

package/dist/project/graph.js

@@ -0,0 +1,314 @@
+export class ProjectGraph {
+    nodes = new Map();
+    edges = [];
+    outEdges = new Map();
+    inEdges = new Map();
+    cycles = [];
+    updatedAt = Date.now();
+    upsertNode(node) {
+        const existing = this.nodes.get(node.id);
+        if (existing) {
+            this.nodes.set(node.id, {
+                ...existing,
+                ...node,
+                project: node.project ?? existing.project,
+                type: node.type ?? existing.type,
+                address: node.address ?? existing.address,
+            });
+            return this.nodes.get(node.id);
+        }
+        this.nodes.set(node.id, { ...node });
+        return node;
+    }
+    addEdge(from, to, kind) {
+        if (from === to)
+            return;
+        if (!this.nodes.has(from))
+            this.upsertNode({ id: from });
+        if (!this.nodes.has(to))
+            this.upsertNode({ id: to });
+        const dup = this.edges.some((e) => e.from === from && e.to === to && e.kind === kind);
+        if (dup)
+            return;
+        const idx = this.edges.length;
+        this.edges.push({ from, to, kind });
+        if (!this.outEdges.has(from))
+            this.outEdges.set(from, new Set());
+        this.outEdges.get(from).add(idx);
+        if (!this.inEdges.has(to))
+            this.inEdges.set(to, new Set());
+        this.inEdges.get(to).add(idx);
+        this.updatedAt = Date.now();
+    }
+    removeNode(id) {
+        if (!this.nodes.has(id))
+            return;
+        this.nodes.delete(id);
+        const outSet = this.outEdges.get(id);
+        const inSet = this.inEdges.get(id);
+        const indicesToRemove = new Set([
+            ...(outSet ?? []),
+            ...(inSet ?? []),
+        ]);
+        const newEdges = [];
+        const indexMap = new Map();
+        for (let i = 0; i < this.edges.length; i++) {
+            if (indicesToRemove.has(i))
+                continue;
+            indexMap.set(i, newEdges.length);
+            newEdges.push(this.edges[i]);
+        }
+        this.edges = newEdges;
+        this.outEdges.clear();
+        this.inEdges.clear();
+        for (let i = 0; i < this.edges.length; i++) {
+            const e = this.edges[i];
+            if (!this.outEdges.has(e.from))
+                this.outEdges.set(e.from, new Set());
+            this.outEdges.get(e.from).add(i);
+            if (!this.inEdges.has(e.to))
+                this.inEdges.set(e.to, new Set());
+            this.inEdges.get(e.to).add(i);
+        }
+        this.updatedAt = Date.now();
+    }
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    listNodes(projectPrefix) {
+        const all = Array.from(this.nodes.values());
+        if (!projectPrefix)
+            return all;
+        return all.filter((n) => n.project === projectPrefix);
+    }
+    getDependencies(id) {
+        const idxs = this.outEdges.get(id);
+        if (!idxs)
+            return [];
+        return Array.from(idxs).map((i) => this.edges[i]);
+    }
+    getReferencedBy(id) {
+        const idxs = this.inEdges.get(id);
+        if (!idxs)
+            return [];
+        return Array.from(idxs).map((i) => this.edges[i]);
+    }
+    detectCycles() {
+        const WHITE = 0, GRAY = 1, BLACK = 2;
+        const color = new Map();
+        for (const id of this.nodes.keys())
+            color.set(id, WHITE);
+        const cycles = [];
+        const stack = [];
+        const dfs = (u) => {
+            color.set(u, GRAY);
+            stack.push(u);
+            const outIdxs = this.outEdges.get(u);
+            if (outIdxs) {
+                for (const i of outIdxs) {
+                    const v = this.edges[i].to;
+                    if (color.get(v) === GRAY) {
+                        const start = stack.indexOf(v);
+                        if (start >= 0) {
+                            cycles.push(stack.slice(start).concat(v));
+                        }
+                    }
+                    else if (color.get(v) === WHITE) {
+                        dfs(v);
+                    }
+                }
+            }
+            stack.pop();
+            color.set(u, BLACK);
+        };
+        for (const id of this.nodes.keys()) {
+            if (color.get(id) === WHITE)
+                dfs(id);
+        }
+        this.cycles = cycles;
+        return cycles;
+    }
+    findDanglingDependencies() {
+        const result = [];
+        for (const [id, node] of this.nodes) {
+            const deps = this.getDependencies(id);
+            const missing = deps
+                .map((e) => this.nodes.get(e.to))
+                .filter((n) => !!n)
+                .filter((n) => !n.address && !n.project)
+                .map((n) => n.id);
+            if (missing.length > 0) {
+                result.push({ from: id, missing: Array.from(new Set(missing)) });
+            }
+        }
+        return result;
+    }
+    snapshot() {
+        return {
+            nodes: Object.fromEntries(this.nodes),
+            edges: this.edges,
+            cycles: this.cycles,
+            version: 1,
+            updatedAt: this.updatedAt,
+        };
+    }
+    restore(snap) {
+        this.nodes.clear();
+        this.edges = [];
+        this.outEdges.clear();
+        this.inEdges.clear();
+        for (const [id, node] of Object.entries(snap.nodes)) {
+            this.nodes.set(id, { ...node });
+        }
+        for (const e of snap.edges) {
+            this.addEdge(e.from, e.to, e.kind);
+        }
+        this.cycles = snap.cycles ?? [];
+        this.updatedAt = snap.updatedAt ?? Date.now();
+    }
+    clear() {
+        this.nodes.clear();
+        this.edges = [];
+        this.outEdges.clear();
+        this.inEdges.clear();
+        this.cycles = [];
+        this.updatedAt = Date.now();
+    }
+    get nodeCount() { return this.nodes.size; }
+    get edgeCount() { return this.edges.length; }
+    getEdges() {
+        return this.edges;
+    }
+    attachDecisionContext(nodeId, ctx) {
+        if (!nodeId)
+            return undefined;
+        const node = this.nodes.get(nodeId) ?? this.upsertNode({ id: nodeId });
+        const fullCtx = {
+            id: ctx.id ?? `${nodeId}_${Date.now()}`,
+            decided_at: ctx.decided_at ?? Date.now(),
+            decider: ctx.decider,
+            industry: ctx.industry,
+            intent: ctx.intent,
+            alternatives: ctx.alternatives,
+            rationale: ctx.rationale,
+            outcome: ctx.outcome,
+        };
+        if (!node.decision_contexts)
+            node.decision_contexts = [];
+        node.decision_contexts.push(fullCtx);
+        this.updatedAt = Date.now();
+        return fullCtx;
+    }
+    getDecisionContexts(nodeId) {
+        return this.nodes.get(nodeId)?.decision_contexts ?? [];
+    }
+    queryDecisionContextsByIndustry(industry) {
+        const results = [];
+        for (const [id, node] of this.nodes) {
+            if (!node.decision_contexts)
+                continue;
+            for (const ctx of node.decision_contexts) {
+                if (ctx.industry === industry) {
+                    results.push({ node_id: id, ctx });
+                }
+            }
+        }
+        results.sort((a, b) => b.ctx.decided_at - a.ctx.decided_at);
+        return results;
+    }
+    backfillDecisionOutcome(decisionId, outcome) {
+        for (const node of this.nodes.values()) {
+            if (!node.decision_contexts)
+                continue;
+            const ctx = node.decision_contexts.find((c) => c.id === decisionId);
+            if (ctx) {
+                ctx.outcome = outcome;
+                this.updatedAt = Date.now();
+                return true;
+            }
+        }
+        return false;
+    }
+}
+export function extractReferences(operation_type, data) {
+    const refs = [];
+    if (!data || typeof data !== "object")
+        return refs;
+    const pushRef = (field, val, kind) => {
+        if (!val)
+            return;
+        if (typeof val === "string") {
+            if (val.trim())
+                refs.push({ field, target: val.trim(), kind });
+        }
+        else if (Array.isArray(val)) {
+            for (const v of val)
+                pushRef(field, v, kind);
+        }
+        else if (typeof val === "object") {
+            const name = val.name_or_address ?? val.name ?? val.address;
+            if (typeof name === "string" && name.trim()) {
+                refs.push({ field, target: name.trim(), kind });
+            }
+        }
+    };
+    if (operation_type === "service") {
+        pushRef("machine", data.machine, "machine");
+        pushRef("order_allocators", data.order_allocators, "order_allocators");
+        pushRef("arbitrations", data.arbitrations, "arbitrations");
+        pushRef("compensation_fund", data.compensation_fund, "compensation_fund");
+        pushRef("rewards", data.rewards, "rewards");
+        pushRef("buy_guard", data.buy_guard, "buy_guard");
+        pushRef("permission", data.permission, "permission");
+    }
+    if (operation_type === "order") {
+        pushRef("service", data.service, "service");
+        pushRef("progress", data.progress, "progress");
+        pushRef("arbitration", data.arbitration, "arbitration");
+    }
+    if (operation_type === "machine" && Array.isArray(data.node?.nodes)) {
+        for (const n of data.node.nodes) {
+            if (!n || typeof n !== "object")
+                continue;
+            const nodeName = n.name;
+            if (typeof nodeName !== "string")
+                continue;
+            if (Array.isArray(n.pairs)) {
+                for (const p of n.pairs) {
+                    if (p && typeof p === "object") {
+                        if (typeof p.prev === "string") {
+                            refs.push({ field: `node.${nodeName}.prev`, target: p.prev, kind: "prev" });
+                        }
+                        if (typeof p.next === "string") {
+                            refs.push({ field: `node.${nodeName}.next`, target: p.next, kind: "next" });
+                        }
+                    }
+                }
+            }
+            if (Array.isArray(n.forward)) {
+                for (const f of n.forward) {
+                    if (f && typeof f === "object" && typeof f.next === "string") {
+                        refs.push({ field: `node.${nodeName}.forward`, target: f.next, kind: "forward" });
+                    }
+                }
+            }
+        }
+    }
+    if (operation_type === "progress" && data.parent) {
+        pushRef("parent", data.parent, "parent");
+    }
+    if (data.permission)
+        pushRef("permission", data.permission, "permission");
+    if (data.guard)
+        pushRef("guard", data.guard, "guard");
+    if (data.buy_guard)
+        pushRef("buy_guard", data.buy_guard, "buy_guard");
+    return refs;
+}
+export function nodeIdOf(name, address) {
+    if (name && typeof name === "string" && name.trim())
+        return name.trim();
+    if (address && typeof address === "string" && address.trim())
+        return address.trim();
+    return undefined;
+}

package/dist/project/index.d.ts

@@ -0,0 +1,62 @@
+import { type ProjectObjectType, type ProjectRole, type IndustryMode } from "./namespace.js";
+import { ProjectGraph } from "./graph.js";
+import { type ProjectInfo, type DependencyTrace, type ReverseTrace } from "./query.js";
+export * from "./namespace.js";
+export * from "./graph.js";
+export * from "./query.js";
+export declare function isProjectServiceEnabled(): boolean;
+export declare function getGraph(): ProjectGraph;
+export declare function setGraph(g: ProjectGraph): void;
+export interface NormalizeCallInput {
+    operation_type: string;
+    data: any;
+    projectPrefix?: string;
+    role?: ProjectRole;
+    industry?: IndustryMode;
+    version?: string;
+    shareable?: boolean;
+}
+export interface NormalizeCallResult {
+    data: any;
+    warnings: string[];
+    project?: {
+        prefix: string;
+        type?: ProjectObjectType;
+        version?: string;
+    };
+}
+export declare function normalize(input: NormalizeCallInput): NormalizeCallResult;
+export declare function observe(operation_type: string, data: any, result?: any): void;
+export declare function queryProjects(): Promise<ProjectInfo[]>;
+export declare function queryProjectObjects(prefix: string): Promise<{
+    name?: string;
+    address?: string;
+    type?: string;
+}[]>;
+export declare function queryShareableObjects(): Promise<{
+    name?: string;
+    address?: string;
+    type?: string;
+    project?: string;
+}[]>;
+export declare function queryDependencies(objectId: string): DependencyTrace;
+export declare function queryReferencedBy(objectId: string): ReverseTrace;
+export declare function queryPrePublishCheck(serviceId: string): string[];
+export declare function queryCrossProjectReferences(): {
+    edge: import("./graph.js").GraphEdge;
+    fromProject?: string;
+    toProject?: string;
+}[];
+export declare function queryGraphStats(): {
+    nodeCount: number;
+    edgeCount: number;
+    cycles: string[][];
+    dangling: {
+        from: string;
+        missing: string[];
+    }[];
+};
+export declare function saveGraph(): string;
+export declare function loadGraph(): boolean;
+export declare function hasPersistedGraph(): boolean;
+export declare const PROJECT_SERVICE_VERSION = 1;