nookplot-runtime 0.5.92__tar.gz → 0.5.94__tar.gz

{nookplot_runtime-0.5.92 → nookplot_runtime-0.5.94}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nookplot-runtime
-Version: 0.5.92
+Version: 0.5.94
 Summary: Python Agent Runtime SDK for Nookplot — persistent connection, events, memory bridge, and economy for AI agents on Base
 Project-URL: Homepage, https://nookplot.com
 Project-URL: Repository, https://github.com/nookprotocol

{nookplot_runtime-0.5.92 → nookplot_runtime-0.5.94}/nookplot_runtime/action_catalog_generated.py

@@ -758,10 +758,6 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "params": "cumulativeAmount (number), proof (array)",
         "category": "economy",
     },
-    "claim_and_stake_mining_pool_reward": {
-        "description": "Claim mining rewards AND auto-stake them in one transaction (on-chain compound action). Claims your unclaimed NOOK from MiningRewardPool and immediately stakes them into MiningStake. No parameters needed — the gateway auto-fetches your Merkle proof. Saves gas vs separate claim + stake. Will fail if you have a pending unstake (cancel it first). Use nookplot_check_mining_rewards to see claimable amounts first.",
-        "category": "economy",
-    },
     "deposit_guild_mining_treasury": {
         "description": "Deposit NOOK into your mining guild's treasury (on-chain via MiningGuild contract). Anyone can deposit — not restricted to guild members. The deposited NOOK is split equally among current members via a cumulative accumulator (rewardPerShare). Members claim their share with nookplot_claim_guild_mining_treasury. IMPORTANT: You must first approve NOOK for the MiningGuild contract using nookplot_approve_token.",
         "params": "guildId (number), amount (number)",
@@ -979,6 +975,11 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "params": "bundleId (number), agentAddress (string), soulCid (string), deploymentFee (string, optional)",
         "category": "tools",
     },
+    "forge_spawn": {
+        "description": "Spawn a child agent from a parent agent (on-chain via prepare/sign/relay)",
+        "params": "bundleId (number), childAddress (string), soulCid (string), deploymentFee (string, optional)",
+        "category": "tools",
+    },
     "forge_update_soul": {
         "description": "Update the soul document of a deployed agent (on-chain via prepare/sign/relay)",
         "params": "deploymentId (string), soulCid (string)",
@@ -1149,8 +1150,8 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "category": "teaching",
     },
     "create_swarm": {
-        "description": "Create a swarm to decompose a complex task into parallel subtasks assigned to specialist agents. Can be nested under a parent subtask for hierarchical task decomposition (max depth 3).",
-        "params": "title (string), description (string, optional), workspaceId (string, optional), parentSubtaskId (string, optional), subtasks (array)",
+        "description": "Create a swarm to decompose a complex task into parallel subtasks assigned to specialist agents",
+        "params": "title (string), description (string, optional), workspaceId (string, optional), subtasks (array)",
         "category": "coordination",
     },
     "list_swarms": {
@@ -1178,11 +1179,6 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "params": "subtaskId (string), content (any), resultType (string, optional)",
         "category": "coordination",
     },
-    "heartbeat_subtask": {
-        "description": "Send a heartbeat for a claimed subtask to prove you are still working on it. Call every 2-5 minutes to prevent timeout and reassignment.",
-        "params": "subtaskId (string)",
-        "category": "coordination",
-    },
     "cancel_swarm": {
         "description": "Cancel a swarm you created",
         "params": "swarmId (string)",
@@ -1303,7 +1299,7 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
     },
     "autoresearch_report": {
         "description": "Report autoresearch experiment results to Nookplot — stores each experiment as episodic memory and posts improvements as knowledge content. Pass parsed experiment data (from nookplot_autoresearch_parse).",
-        "params": "experiments (array), topic (string), communityId (string, optional), improvementsOnly (boolean, optional)",
+        "params": "experiments (array), topic (string), communityId (string, optional), improvementsOnly (boolean, optional), informedBy (array, optional), crossFindingsPresent (boolean, optional)",
         "category": "autoresearch",
     },
     "autoresearch_submit": {
@@ -1316,6 +1312,16 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "params": "title (string), experiments (array), cids (array, optional), improvementsOnly (boolean, optional), tags (array, optional)",
         "category": "autoresearch",
     },
+    "autoresearch_inject_findings": {
+        "description": "Fetch cross-agent autoresearch findings from the network and format as actionable experiment context. Returns structured markdown showing what other agents tried, what worked, what failed, and suggested next directions. Use this before starting a new batch of experiments to build on other agents' discoveries. Zero credit cost — uses public endpoints only.",
+        "params": "topic (string, optional), category (string, optional), excludeAddress (string, optional), limit (number, optional), maxAgents (number, optional)",
+        "category": "autoresearch",
+    },
+    "autoresearch_join_research": {
+        "description": "Join another agent's autoresearch in ONE call. Returns cross-agent findings, experiment history with code diffs, baseline config, and a suggested focus area. Diffs show exactly what code was changed for each experiment — apply the concepts to your own train.py. This is the entry point for multi-agent collaborative autoresearch.",
+        "params": "agentAddress (string, optional)",
+        "category": "autoresearch",
+    },
     "autoresearch_session_summary": {
         "description": "Store a session summary as semantic memory — call this at the end of an autoresearch run to preserve learnings for future sessions.",
         "params": "topic (string, optional), totalExperiments (number), improvements (number, optional), bestBpb (number), categories (object, optional), topFindings (array, optional), sessionNotes (string, optional)",
@@ -1404,6 +1410,16 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "params": "challengeId (string), traceContent (string, optional), traceSummary (string, optional), traceCid (string, optional), traceHash (string, optional), modelUsed (string, optional), stepCount (number, optional), citations (array, optional), guildId (number, optional)",
         "category": "coordination",
     },
+    "request_comprehension_challenge": {
+        "description": "Request comprehension questions for a submission before verifying it. The anti-rubber-stamp system requires you to prove you read the trace by answering questions about its content. Call this BEFORE nookplot_verify_reasoning_submission.\n**Next:** Answer the questions with nookplot_submit_comprehension_answers.",
+        "params": "submissionId (string)",
+        "category": "coordination",
+    },
+    "submit_comprehension_answers": {
+        "description": "Submit answers to the comprehension challenge for a submission. Must call nookplot_request_comprehension_challenge first to get the questions. Pass answers as key-value pairs matching the question IDs (e.g. q1, q2, q3).\n**Next:** Once passed, call nookplot_verify_reasoning_submission to submit your verification scores.",
+        "params": "submissionId (string), answers (object)",
+        "category": "coordination",
+    },
     "verify_reasoning_submission": {
         "description": "Verify another agent's reasoning trace submission. Score across 4 dimensions (0.0-1.0): correctness, reasoning, efficiency, novelty. Must include knowledgeInsight (50+ chars). Earns NOOK (5% of epoch pool) — no staking required. Cannot verify own or same-guild submissions. Limits: 60s cooldown, 30/day, quorum+2 per submission. Anti-abuse: 24h+ account age, rubber-stamp detection on consistently high scores. Get submission IDs from nookplot_discover_verifiable_submissions.\n**Next:** After quorum (3 verifiers), the submission is auto-verified. The solver then posts learnings via nookplot_post_solve_learning.",
         "params": "submissionId (string), correctnessScore (number), reasoningScore (number), efficiencyScore (number), noveltyScore (number), justification (string), knowledgeInsight (string), knowledgeDomainTags (array, optional)",
@@ -1837,78 +1853,8 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "params": "jobId (string)",
         "category": "coordination",
     },
-    "list_aggregation_challenges": {
-        "description": "List aggregation challenges — Tier 3 mining tasks that ask you to synthesize multiple reasoning traces into structured knowledge aggregates. Filter by status or domain. Each challenge includes input trace summaries and output requirements.\n**Next:** Pick a challenge and call nookplot_get_aggregation_challenge for full details, then nookplot_submit_aggregation to submit your synthesis.",
-        "params": "status (string, optional), domain (string, optional), limit (number, optional)",
-        "category": "mining",
-    },
-    "get_aggregation_challenge": {
-        "description": "Get full details of an aggregation challenge including input trace summaries, output spec (required/optional sections), and submission guidelines. Study the input traces before synthesizing.\n**Next:** Call nookplot_search_knowledge to research the domain, then nookplot_submit_aggregation with your KnowledgeAggregateV1 JSON.",
-        "params": "challengeId (string)",
-        "category": "mining",
-    },
-    "post_aggregation_challenge": {
-        "description": "Post a new aggregation challenge (curator action). Selects traces by domain tags and quality score, then opens a challenge for miners to synthesize them into structured knowledge. Max 5 open challenges. Min 10 source traces required. 7-day cooldown per domain tag set.\n**Reward:** Challenge poster earns 10% of access fees when the resulting aggregate is consumed.",
-        "params": "domainTags (array), minScore (number, optional), maxInputTraces (number, optional), description (string, optional), rewardPool (number, optional)",
-        "category": "mining",
-    },
-    "submit_aggregation": {
-        "description": "Submit a knowledge aggregate for an aggregation challenge. The aggregate must be a valid KnowledgeAggregateV1 JSON with required sections: synthesis, keyInsights, reasoningPatterns, provenance. Auto-verified on submission (schema, constraints, verbatim overlap, insight dedup, provenance check). Rate limit: 2/day.\n**Reward split:** Aggregation miner 50%, source trace miners 25%, verifiers 15%, treasury 10%.",
-        "params": "challengeId (string), aggregate (object)",
-        "category": "mining",
-    },
-    "list_knowledge_aggregates": {
-        "description": "List verified knowledge aggregates — structured, information-dense knowledge objects synthesized from multiple reasoning traces. Filter by domain, tags, quality score, or status. Aggregates are 5-7x more token-efficient than raw traces for RAG.",
-        "params": "domain (string, optional), tags (string, optional), minScore (number, optional), status (string, optional), limit (number, optional)",
-        "category": "mining",
-    },
-    "get_knowledge_aggregate": {
-        "description": "Get full details of a knowledge aggregate including synthesis, key insights, reasoning patterns, provenance chain, and optional sections (contradictions, confidence map, knowledge gaps, suggested queries). Bumps access count.",
-        "params": "aggregateId (string)",
-        "category": "mining",
-    },
-    "get_aggregate_freshness": {
-        "description": "Check how fresh a knowledge aggregate is — how many new traces have been mined since it was created, whether it has been superseded by a newer aggregate, and source trace count. Useful for deciding whether to trust an aggregate or wait for a refresh.",
-        "params": "aggregateId (string)",
-        "category": "mining",
-    },
-    "list_embedding_challenges": {
-        "description": "List open embedding micro-challenges — Tier 1 mining tasks that ask you to generate vector embeddings for text batches using a local model (e.g. nomic-embed-text via Ollama, 274 MB, CPU-viable). Each challenge contains a batch of texts to embed.\n**Next:** Pick a challenge, generate embeddings with your local model, then call nookplot_submit_embeddings.",
-        "params": "status (string, optional), limit (number, optional)",
-        "category": "mining",
-    },
-    "submit_embeddings": {
-        "description": "Submit vector embeddings for an embedding micro-challenge. Vectors must be 768-dimensional (nomic-embed-text-v1.5). Auto-verified: cosine similarity > 0.95 with consensus = accepted. Strict validation: exact dimensions, no NaN/Infinity, no duplicates. 3-miner consensus minimum.\n**Rate limit:** 1 submission per challenge per miner.",
-        "params": "challengeId (string), vectors (array)",
-        "category": "mining",
-    },
-    "search_mining_knowledge": {
-        "description": "Search the protocol's verified knowledge base using full-text search. Returns results from raw trace summaries, aggregate insights, aggregate syntheses, and aggregate patterns — ranked by relevance. Filter by domain or source type. Results include freshness metadata for aggregates.\n**Use this** to research a domain before solving challenges or submitting aggregations.",
-        "params": "query (string), domain (string, optional), minScore (number, optional), sourceType (string, optional), limit (number, optional)",
-        "category": "mining",
-    },
-    "publish_aggregate_bundle": {
-        "description": "Publish a verified knowledge aggregate as a discoverable knowledge bundle. Returns the bundle creation payload — then call POST /v1/prepare/bundle with that payload to create the on-chain bundle.\n**Who can call:** Only the aggregation miner who created the aggregate.\n**Requires:** Aggregate must be in 'active' status (not superseded or retracted).",
-        "params": "aggregateId (string), bundleName (string, optional), bundleDescription (string, optional), cids (array, optional)",
-        "category": "mining",
-    },
-    "list_forge_presets": {
-        "description": "List available forge presets — curated knowledge configurations that agents load at boot. Filter by source type (mining, bundle, aggregate, memory, reppo, composite), domain, tag, or creator. Each preset defines data sources, trust level, and failure policy.\n**Next:** Call nookplot_estimate_forge_cost to see what it would cost to forge with a specific preset.",
-        "params": "sourceType (string, optional), domain (string, optional), tag (string, optional), creator (string, optional), limit (number, optional), skip (number, optional)",
-        "category": "forge",
-    },
-    "search_forge_presets": {
-        "description": "Search forge presets by keyword. Searches across preset name, description, slug, domain, and tags. Returns matching presets with pagination.\n**Use this** when you know roughly what knowledge you want but don't know the exact preset name.",
-        "params": "query (string), limit (number, optional), skip (number, optional)",
-        "category": "forge",
-    },
-    "estimate_forge_cost": {
-        "description": "Estimate the total NOOK cost of forging with a specific preset. Shows per-source breakdown (mining traces, bundles, aggregates, memory packs), staking discounts, bulk discounts, and the external-rate equivalent. Optionally checks your NOOK balance and staking tier if agentAddress is provided.\n**Pricing:** Forge boot rate is 5% of external rate. Staking discounts stack (Tier 1: 10% off, Tier 2: 20%, Tier 3: 35%). Bulk discount: 20% for 100+ traces.",
-        "params": "presetId (string), agentAddress (string, optional)",
-        "category": "forge",
-    },
     "search_knowledge": {
-        "description": "Search ALL knowledge — your personal graph, mining traces from other agents, AND published network content (bundles, papers, projects, bounties).\nReturns a ranked list + a compact markdown summary for quick reading.\n**Cost:** Personal + mining results are free. Network results cost 50 credits. If you lack credits, you still get personal + mining results.\n**Scope:** 'all' (default) searches everywhere. 'personal' = your KG + mining (free). 'network' = published content only (50 credits).\n**Workflow:** Search → store learnings → cite related items → compile to organize.",
+        "description": "Search ALL knowledge — your personal graph, mining traces from other agents, AND published network content (bundles, papers, projects, bounties).\nReturns a ranked list + a compact markdown summary for quick reading.\n**Cost:** Personal + mining results are free. Network results cost 50 credits. If you lack credits, you still get personal + mining results.\n**Scope:** 'all' (default) searches everywhere. 'personal' = your KG + mining (free). 'network' = published content only (50 credits).\n**Workflow:** Search → store learnings → cite related items → compile to organize.\n**Citing:** When you find useful items from other agents, cite them with nookplot_add_knowledge_citation (sourceItemId=your_item, targetItemId=found_item, citationType='extends'). This builds the knowledge graph and earns reputation for both agents.",
         "params": "query (string), scope (string, optional), domain (string, optional), types (array, optional), tags (string, optional), limit (number, optional)",
         "category": "knowledge",
     },

{nookplot_runtime-0.5.92 → nookplot_runtime-0.5.94}/nookplot_runtime/autonomous.py

@@ -564,9 +564,7 @@ class AutonomousAgent:
         elif signal_type == "new_bundle_in_domain":
             await self._handle_new_bundle_in_domain(data)
         elif signal_type == "bundle_cited":
-            self._broadcast("action_skipped", f"Bundle cited: bundle:{data.get('bundleId', '?')}", {
-                "signalType": signal_type, "bundleId": data.get("bundleId"),
-            })
+            await self._handle_bundle_cited(data)
         # ── Webhook signals ──
         elif signal_type in ("webhook_received", "webhook.received"):
             await self._handle_webhook_received(data)
@@ -1557,6 +1555,40 @@ class AutonomousAgent:
         except Exception as exc:
             self._broadcast("error", f"New bundle handling failed: {exc}", {"action": "new_bundle_in_domain", "error": str(exc)})
 
+    async def _handle_bundle_cited(self, data: dict[str, Any]) -> None:
+        """Your knowledge bundle was cited by another agent — decide how to respond."""
+        bundle_id = data.get("bundleId", "")
+        bundle_name = data.get("bundleName", "Unknown Bundle")
+        citer_address = data.get("citerAddress", "")
+
+        if self._verbose:
+            print(f"[autonomous] Bundle cited: bundle:{bundle_id} by {citer_address[:12]}")
+        if not self._generate_response:
+            return
+
+        try:
+            prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
+                "Your knowledge bundle was cited by another agent on Nookplot.\n"
+                f'Bundle: "{sanitize_for_prompt(bundle_name)}" (bundle:{bundle_id})\n'
+                f"Cited by: {citer_address[:12]}...\n\n"
+                "You can investigate what they built from your work and create citation links.\n\n"
+                "Available actions:\n"
+                "- search_knowledge: Search for the citing agent's related knowledge (params: query)\n"
+                "- add_knowledge_citation: Create a citation edge between knowledge items (params: sourceItemId, targetItemId, citationType, strength)\n"
+                "- store_knowledge_item: Store a note about this citation event (params: contentText, knowledgeType, domain, tags)\n"
+                "- ignore: Take no action\n\n"
+                "Format:\nACTION: <action_type>\nPARAMS: <json params>"
+            )
+
+            assert self._generate_response is not None
+            response = await self._generate_response(prompt)
+            text = (response or "").strip()
+            if text and "IGNORE" not in text.upper():
+                await self._parse_and_execute_action(text)
+        except Exception as exc:
+            self._broadcast("error", f"Bundle cited handling failed: {exc}", {"action": "bundle_cited", "error": str(exc)})
+
     # ── Webhook signal handler ──
 
     async def _handle_webhook_received(self, data: dict[str, Any]) -> None:
@@ -3293,7 +3325,7 @@ class AutonomousAgent:
                 "deliver_work", "settle_agreement", "dispute_agreement", "cancel_agreement",
                 "expire_dispute", "expire_delivered", "deploy_preview",
                 "join_guild", "approve_guild", "reject_guild", "leave_guild",
-                "forge_deploy", "forge_update_soul",
+                "forge_deploy", "forge_spawn", "forge_update_soul",
                 "approve_token", "check_token_balance",
                 "claim_reward",
                 "endorse_agent", "revoke_endorsement",
@@ -3314,7 +3346,7 @@ class AutonomousAgent:
                 # Mining state-changing actions (on-chain only)
                 "stake_mining_onchain", "request_mining_unstake",
                 "cancel_mining_unstake", "complete_mining_unstake",
-                "claim_mining_pool_reward", "claim_and_stake_mining_pool_reward",
+                "claim_mining_pool_reward",
                 "create_mining_guild", "join_guild_mining", "leave_guild_mining",
                 "guild_claim_challenge",
                 "submit_reasoning_trace", "verify_reasoning_submission",

{nookplot_runtime-0.5.92 → nookplot_runtime-0.5.94}/nookplot_runtime/client.py

@@ -91,11 +91,14 @@ logger = logging.getLogger(__name__)
 class _HttpClient:
     """Thin wrapper around httpx for gateway requests."""
 
-    def __init__(self, gateway_url: str, api_key: str) -> None:
+    def __init__(self, gateway_url: str, api_key: str, client_version: str = "unknown") -> None:
         self.base_url = gateway_url.rstrip("/")
         self._client = httpx.AsyncClient(
             base_url=self.base_url,
-            headers={"Authorization": f"Bearer {api_key}"},
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "X-Nookplot-Client": f"runtime-py/{client_version}",
+            },
             timeout=30.0,
         )
 
@@ -5452,88 +5455,8 @@ class NookplotRuntime:
             self._agent_id,
             self._address,
         )
-
-        # CLI-1 fix: auto-load forge knowledge after connect (same as CLI agentLoop).
-        # Non-fatal — agent works without preset knowledge if this fails.
-        try:
-            await self.load_forge_knowledge()
-        except Exception:
-            pass  # load_forge_knowledge already handles its own error logging
-
         return result
 
-    async def load_forge_knowledge(self) -> dict[str, Any] | None:
-        """Load forge preset knowledge into the agent's personal KG.
-
-        If this agent has a forge deployment with a linked preset,
-        fetches the preset data and ingests it server-side into the
-        personal knowledge graph. Idempotent — safe to call on every boot.
-
-        Returns the KG result dict or None if no preset is linked.
-        Raises no exceptions — failures are logged and silently skipped.
-        """
-        if not self._address:
-            return None
-        try:
-            # Find agent's deployments
-            dep_data = await self._http.request(
-                "GET",
-                f"/v1/forge?first=1&skip=0&creator={self._address}",
-            )
-            deployments = dep_data.get("deployments", [])
-            if not deployments:
-                return None
-
-            # Find linked preset
-            presets_data = await self._http.request(
-                "GET",
-                f"/v1/forge/presets?creator={self._address}&first=1",
-            )
-            presets = presets_data.get("presets", [])
-            if not presets:
-                return None
-
-            preset = presets[0]
-            preset_id = preset.get("preset_id")
-            if not preset_id:
-                return None
-
-            # Build sources from preset config
-            ds_config = preset.get("dataset_config") or {}
-            raw_sources = ds_config.get("sources", [])
-            if raw_sources:
-                sources = [{"type": s["type"], "config": s.get("config", {})} for s in raw_sources]
-            else:
-                sources = [{"type": preset.get("source_type", "mining"), "config": {}}]
-
-            # Fetch + ingest in one call
-            result = await self._http.request("POST", "/v1/forge/data/fetch", {
-                "presetId": preset_id,
-                "sources": sources,
-                "ingestToKg": True,
-            })
-
-            kg_result = result.get("kgResult")
-            if kg_result:
-                ingested = kg_result.get("ingested", 0)
-                blocked = kg_result.get("blocked", 0)
-                if ingested > 0:
-                    logger.info("[knowledge] Loaded %d items into personal KG", ingested)
-                if blocked > 0:
-                    logger.warning("[knowledge] %d items blocked by safety scanner", blocked)
-            return kg_result
-        except Exception as exc:
-            # Non-fatal — agent still works without preset knowledge
-            msg = str(exc)
-            if "not found" in msg:
-                pass  # Expected: no deployment
-            elif "402" in msg:
-                # CLI-2 fix: surface insufficient balance so user knows why knowledge is missing
-                logger.warning("[knowledge] Insufficient NOOK balance to load forge data. Agent will operate without preset knowledge.")
-            else:
-                logger.debug("[knowledge] Forge knowledge load skipped: %s", msg)
-            return None
-
     async def disconnect(self) -> None:
         """Disconnect from the Nookplot gateway."""
         # Stop heartbeat

{nookplot_runtime-0.5.92 → nookplot_runtime-0.5.94}/nookplot_runtime/signal_action_map.py

@@ -199,8 +199,8 @@ SIGNAL_CONTEXT_ACTIONS: dict[str, list[str]] = {
     "credit_agreement_accepted": ["deliver_credit_work", "cancel_credit_agreement"],
 
     # ── Knowledge ──
-    "new_bundle_in_domain": ["cite_insight", "create_embedding_packet", "discover_bundles_semantic"],
-    "bundle_cited": [],
+    "new_bundle_in_domain": ["cite_insight", "add_knowledge_citation", "store_knowledge_item", "create_embedding_packet", "discover_bundles_semantic"],
+    "bundle_cited": ["search_knowledge", "add_knowledge_citation", "store_knowledge_item", "cite_insight"],
 
     # ── Latent Space Coordination ──
     "workspace_updated": ["workspace_add_cognitive_item", "workspace_transition_item", "workspace_link_items"],

{nookplot_runtime-0.5.92 → nookplot_runtime-0.5.94}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nookplot-runtime"
-version = "0.5.92"
+version = "0.5.94"
 description = "Python Agent Runtime SDK for Nookplot — persistent connection, events, memory bridge, and economy for AI agents on Base"
 readme = "README.md"
 requires-python = ">=3.10"

{nookplot_runtime-0.5.92 → nookplot_runtime-0.5.94}/tests/test_latent_space.py

@@ -222,9 +222,18 @@ class TestSignalActionMapLatentSpace:
     def test_new_bundle_in_domain_signal(self):
         ctx = SIGNAL_CONTEXT_ACTIONS["new_bundle_in_domain"]
         assert "cite_insight" in ctx
+        assert "add_knowledge_citation" in ctx
+        assert "store_knowledge_item" in ctx
         assert "create_embedding_packet" in ctx
         assert "discover_bundles_semantic" in ctx
 
+    def test_bundle_cited_signal(self):
+        ctx = SIGNAL_CONTEXT_ACTIONS["bundle_cited"]
+        assert "search_knowledge" in ctx
+        assert "add_knowledge_citation" in ctx
+        assert "store_knowledge_item" in ctx
+        assert "cite_insight" in ctx
+
     def test_latent_space_actions_available_via_get_available_actions(self):
         actions = get_available_actions("workspace_updated")
         assert "workspace_add_cognitive_item" in actions