chain-insights 0.60.0 → 0.62.1

package/README.md

@@ -182,7 +182,12 @@ an address instead. A thing has one name on every layer: `address`, `tx_id`,
 
 Agent installs include `chain-insights-cypher` for graph-query dialect rules,
 one query for each kind of graph search, and how to find the fields of the
-EVM / Robinhood graph.
+EVM / Robinhood graph. Protocol skills sit beside it and load only when a
+question names their protocol:
+
+- `chain-insights-virtuals`: Virtuals Protocol agents on robinhood: who
+  created an agent, who is behind a creator wallet, whether an agent was
+  dumped, and whether its buyers form a cartel.
 
 ## Billing: Billable Units
 

package/bin/install.cjs

@@ -49,8 +49,9 @@ const homeDir = os.homedir()
 const dataDir = path.join(homeDir, '.chain-insights')
 const configPath = path.join(dataDir, 'config.json')
 const srcSkillsDir = path.join(__dirname, '..', 'skills')
-const PUBLIC_SKILL_NAMES = Object.freeze(['chain-insights-cypher'])
 const SKILL_VERSION_FILE = '.chain-insights-version'
+// The core skill every install carries. Protocol skills sit beside it.
+const CORE_SKILL_NAME = 'chain-insights-cypher'
 const RETIRED_SKILL_NAMES = Object.freeze([
   'chain-insights-address-risk',
   'chain-insights-bittensor-cypher',
@@ -63,6 +64,21 @@ const RETIRED_SKILL_NAMES = Object.freeze([
   'test-chain-insights-graph',
 ])
 
+// The shipped skills, read from the package's own skills/ at run time: the core
+// skill, then every protocol skill. A shipped skill is a directory named
+// chain-insights-* that holds a SKILL.md. src/skill-refresh.ts and
+// scripts/sync-plugin-skills.mjs apply the same rule.
+function publicSkillNames(skillsDir) {
+  const names = fs
+    .readdirSync(skillsDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && /^chain-insights-[a-z0-9-]+$/.test(entry.name))
+    .map((entry) => entry.name)
+    .filter((name) => !RETIRED_SKILL_NAMES.includes(name))
+    .filter((name) => fs.existsSync(path.join(skillsDir, name, 'SKILL.md')))
+    .sort()
+  return [CORE_SKILL_NAME, ...names.filter((name) => name !== CORE_SKILL_NAME)]
+}
+
 // Determine skills targets
 const skillsTargets = []
 if (hasClaude)
@@ -110,7 +126,7 @@ function copyCommandsAsClaudeSkills(srcDir, targetDir) {
     fs.rmSync(path.join(targetDir, skillName), { recursive: true, force: true })
   }
 
-  for (const skillName of PUBLIC_SKILL_NAMES) {
+  for (const skillName of publicSkillNames(srcDir)) {
     const skillSrc = path.join(srcDir, skillName)
     const skillDest = path.join(targetDir, skillName)
     if (!fs.existsSync(skillSrc) || !fs.statSync(skillSrc).isDirectory()) {

package/dist/mcp-proxy.cjs

@@ -222,7 +222,7 @@ const ROUTING_HANDOFF = "The layers hand each other keys, and each key keeps its
 * A whole-chain question is a time-bounded topology search, sent only when the
 * family of its link type is close to the head; a refusal names the family.
 */
-const ROUTING_NOT_SERVED = "A question about the whole chain (recent activity, the biggest senders, a top list) is a `USE topology` search: bound it by time with `f.last_seen_timestamp >= <epoch ms>` on the `FLOWS_TO` link, then sort and `LIMIT`. A search has 10 s. Read `Head` first (`USE chain MATCH (h:Head) RETURN h.behind_money, h.behind_dex`, under a second): a `FLOWS_TO` search is sent when `behind_money` is at most 100000; a `SWAPPED`, `ADDED_LIQUIDITY` or `REMOVED_LIQUIDITY` search when `behind_dex` is at most 100000 (100000 blocks is a few hours: a robinhood block is about a tenth of a second apart from the next). When the family is further behind, the search cannot finish, so do not send it: say which family, how many blocks, and ask for an address. On a server whose Head has no `behind_money`, read `h.graph_blocks_behind` and hold it to the same limit. Never turn the block count into days or hours by head. To say how fresh the data is, give the newest `_utc` time you read on the layer you used: a family's lag counts its slowest layer, and the links of an address and the facts rows are often newer than it. If the server refuses the search with `anchor_missing` or `family_behind`, or stops it with `query_timeout`, it cannot search the whole chain now: say so in one line, name the family the refusal names, and ask for an address or drop the link type that is behind. A narrower window times out the same way, so do not send it again.";
+const ROUTING_NOT_SERVED = "A question about the whole chain (recent activity, the biggest senders, a top list) is a `USE topology` search: bound it by time with `f.last_seen_timestamp >= <epoch ms>` on the `FLOWS_TO` link, then sort and `LIMIT`. A search has 10 s. Read `Head` first (`USE chain MATCH (h:Head) RETURN h.behind_money, h.behind_dex, h.behind_transfers`, under a second): a `FLOWS_TO` search is sent when `behind_money` is at most 100000; a `SWAPPED`, `ADDED_LIQUIDITY` or `REMOVED_LIQUIDITY` search when `behind_dex` is at most 100000; a `TRANSFERRED` search when `behind_transfers` is at most 100000 (100000 blocks is a few hours: a robinhood block is about a tenth of a second apart from the next). When the family is further behind, the search cannot finish, so do not send it: say which family, how many blocks, and ask for an address. On a server whose Head has no `behind_money`, read `h.graph_blocks_behind` and hold it to the same limit. On a server whose Head has no `behind_transfers`, it serves no `TRANSFERRED` link: send no `TRANSFERRED` search. Never turn the block count into days or hours by head. To say how fresh the data is, give the newest `_utc` time you read on the layer you used: a family's lag counts its slowest layer, and the links of an address and the facts rows are often newer than it. If the server refuses the search with `anchor_missing` or `family_behind`, or stops it with `query_timeout`, it cannot search the whole chain now: say so in one line, name the family the refusal names, and ask for an address or drop the link type that is behind. A narrower window times out the same way, so do not send it again.";
 /** What a refusal carries, and which part of it decides the move. */
 const MOVE_INTRO = "A refused, killed, busy or failed query comes back with `error_detail`: `code`, `rule`, `class`, `fix` and `example`. The `class` decides your next move.";
 /** The move for each class of the refusal envelope. */
@@ -1362,9 +1362,9 @@ async function createProxy() {
 		return;
 	}
 	if (process.env["CHAIN_INSIGHTS_SKILL_REFRESH"] !== "0") try {
-		const { refreshInstalledSkills } = await Promise.resolve().then(() => require("./skill-refresh-DQZ2gox4.cjs"));
+		const { refreshInstalledSkills } = await Promise.resolve().then(() => require("./skill-refresh-FXhQpW94.cjs"));
 		const refresh = refreshInstalledSkills(require_print_result.PACKAGE_VERSION);
-		if (refresh.refreshed.length > 0 || refresh.failed.length > 0) await logger.info("skills.refresh", {
+		if (refresh.refreshed.length > 0 || refresh.installed.length > 0 || refresh.failed.length > 0) await logger.info("skills.refresh", {
 			version: require_print_result.PACKAGE_VERSION,
 			...refresh
 		});
@@ -1732,7 +1732,7 @@ async function createProxy() {
 			openWorldHint: false
 		}
 	}, async () => {
-		const { readPackagedSkillRules } = await Promise.resolve().then(() => require("./skill-refresh-DQZ2gox4.cjs"));
+		const { readPackagedSkillRules } = await Promise.resolve().then(() => require("./skill-refresh-FXhQpW94.cjs"));
 		return {
 			content: [{
 				type: "text",

package/dist/mcp-proxy.mjs

@@ -218,7 +218,7 @@ const ROUTING_HANDOFF = "The layers hand each other keys, and each key keeps its
 * A whole-chain question is a time-bounded topology search, sent only when the
 * family of its link type is close to the head; a refusal names the family.
 */
-const ROUTING_NOT_SERVED = "A question about the whole chain (recent activity, the biggest senders, a top list) is a `USE topology` search: bound it by time with `f.last_seen_timestamp >= <epoch ms>` on the `FLOWS_TO` link, then sort and `LIMIT`. A search has 10 s. Read `Head` first (`USE chain MATCH (h:Head) RETURN h.behind_money, h.behind_dex`, under a second): a `FLOWS_TO` search is sent when `behind_money` is at most 100000; a `SWAPPED`, `ADDED_LIQUIDITY` or `REMOVED_LIQUIDITY` search when `behind_dex` is at most 100000 (100000 blocks is a few hours: a robinhood block is about a tenth of a second apart from the next). When the family is further behind, the search cannot finish, so do not send it: say which family, how many blocks, and ask for an address. On a server whose Head has no `behind_money`, read `h.graph_blocks_behind` and hold it to the same limit. Never turn the block count into days or hours by head. To say how fresh the data is, give the newest `_utc` time you read on the layer you used: a family's lag counts its slowest layer, and the links of an address and the facts rows are often newer than it. If the server refuses the search with `anchor_missing` or `family_behind`, or stops it with `query_timeout`, it cannot search the whole chain now: say so in one line, name the family the refusal names, and ask for an address or drop the link type that is behind. A narrower window times out the same way, so do not send it again.";
+const ROUTING_NOT_SERVED = "A question about the whole chain (recent activity, the biggest senders, a top list) is a `USE topology` search: bound it by time with `f.last_seen_timestamp >= <epoch ms>` on the `FLOWS_TO` link, then sort and `LIMIT`. A search has 10 s. Read `Head` first (`USE chain MATCH (h:Head) RETURN h.behind_money, h.behind_dex, h.behind_transfers`, under a second): a `FLOWS_TO` search is sent when `behind_money` is at most 100000; a `SWAPPED`, `ADDED_LIQUIDITY` or `REMOVED_LIQUIDITY` search when `behind_dex` is at most 100000; a `TRANSFERRED` search when `behind_transfers` is at most 100000 (100000 blocks is a few hours: a robinhood block is about a tenth of a second apart from the next). When the family is further behind, the search cannot finish, so do not send it: say which family, how many blocks, and ask for an address. On a server whose Head has no `behind_money`, read `h.graph_blocks_behind` and hold it to the same limit. On a server whose Head has no `behind_transfers`, it serves no `TRANSFERRED` link: send no `TRANSFERRED` search. Never turn the block count into days or hours by head. To say how fresh the data is, give the newest `_utc` time you read on the layer you used: a family's lag counts its slowest layer, and the links of an address and the facts rows are often newer than it. If the server refuses the search with `anchor_missing` or `family_behind`, or stops it with `query_timeout`, it cannot search the whole chain now: say so in one line, name the family the refusal names, and ask for an address or drop the link type that is behind. A narrower window times out the same way, so do not send it again.";
 /** What a refusal carries, and which part of it decides the move. */
 const MOVE_INTRO = "A refused, killed, busy or failed query comes back with `error_detail`: `code`, `rule`, `class`, `fix` and `example`. The `class` decides your next move.";
 /** The move for each class of the refusal envelope. */
@@ -1358,9 +1358,9 @@ async function createProxy() {
 		return;
 	}
 	if (process.env["CHAIN_INSIGHTS_SKILL_REFRESH"] !== "0") try {
-		const { refreshInstalledSkills } = await import("./skill-refresh-Dya9LQKN.mjs");
+		const { refreshInstalledSkills } = await import("./skill-refresh-I5MSULwP.mjs");
 		const refresh = refreshInstalledSkills(PACKAGE_VERSION);
-		if (refresh.refreshed.length > 0 || refresh.failed.length > 0) await logger.info("skills.refresh", {
+		if (refresh.refreshed.length > 0 || refresh.installed.length > 0 || refresh.failed.length > 0) await logger.info("skills.refresh", {
 			version: PACKAGE_VERSION,
 			...refresh
 		});
@@ -1728,7 +1728,7 @@ async function createProxy() {
 			openWorldHint: false
 		}
 	}, async () => {
-		const { readPackagedSkillRules } = await import("./skill-refresh-Dya9LQKN.mjs");
+		const { readPackagedSkillRules } = await import("./skill-refresh-I5MSULwP.mjs");
 		return {
 			content: [{
 				type: "text",