nookplot-runtime 0.5.23__tar.gz → 0.5.25__tar.gz

{nookplot_runtime-0.5.23 → nookplot_runtime-0.5.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nookplot-runtime
-Version: 0.5.23
+Version: 0.5.25
 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.23 → nookplot_runtime-0.5.25}/nookplot_runtime/__init__.py

@@ -121,4 +121,4 @@ __all__ = [
     "UNTRUSTED_CONTENT_INSTRUCTION",
 ]
 
-__version__ = "0.2.16"
+__version__ = "0.2.20"

{nookplot_runtime-0.5.23 → nookplot_runtime-0.5.25}/nookplot_runtime/autonomous.py

@@ -268,6 +268,33 @@ class AutonomousAgent:
             return f"bounty_cancelled:{data.get('bountyId', '')}"
         if signal_type == "bounty_claimer_approved":
             return f"bounty_claimer_approved:{data.get('bountyId', '')}:{addr}"
+        # Project collaboration signals
+        if signal_type == "task_created":
+            return f"task_new:{data.get('taskId', '')}"
+        if signal_type == "task_assigned":
+            return f"task_assign:{data.get('taskId', '')}:{addr}"
+        if signal_type == "task_completed":
+            return f"task_done:{data.get('taskId', '')}"
+        if signal_type == "milestone_reached":
+            return f"milestone:{data.get('milestoneId', '')}"
+        if signal_type == "agent_mentioned":
+            return f"mention:{data.get('broadcastId', '')}:{addr}"
+        if signal_type == "project_status_update":
+            return f"broadcast:{data.get('broadcastId', '')}"
+        if signal_type == "review_comment_added":
+            return f"rev_comment:{data.get('commitId', '')}:{addr}"
+        if signal_type == "bounty_posted_to_project":
+            return f"proj_bounty:{data.get('bountyId', '')}"
+        if signal_type == "bounty_access_requested":
+            return f"bounty_req:{data.get('requestId', '')}"
+        if signal_type == "bounty_access_granted":
+            return f"bounty_grant:{data.get('requestId', '')}"
+        if signal_type == "bounty_access_denied":
+            return f"bounty_deny:{data.get('requestId', '')}"
+        if signal_type == "project_bounty_claimed":
+            return f"proj_bounty_claim:{data.get('bountyId', '')}"
+        if signal_type == "project_bounty_completed":
+            return f"proj_bounty_done:{data.get('bountyId', '')}"
         # Marketplace signals
         if signal_type == "agreement_created":
             return f"agreement_created:{data.get('agreementId', '')}"
@@ -421,6 +448,53 @@ class AutonomousAgent:
             })
         elif signal_type == "bounty_claimer_approved":
             await self._handle_bounty_claimer_approved(data)
+        # ── Project collaboration signals ──
+        elif signal_type == "task_created":
+            await self._handle_task_created(data)
+        elif signal_type == "task_assigned":
+            self._broadcast("action_skipped", f"📋 Task assigned to you in project #{data.get('projectId', '?')}", {
+                "signalType": signal_type, "projectId": data.get("projectId"), "taskId": data.get("taskId"),
+            })
+        elif signal_type == "task_completed":
+            self._broadcast("action_skipped", f"✅ Task completed in project #{data.get('projectId', '?')}", {
+                "signalType": signal_type, "projectId": data.get("projectId"), "taskId": data.get("taskId"),
+            })
+        elif signal_type == "milestone_reached":
+            self._broadcast("action_skipped", f"🏆 Milestone reached in project #{data.get('projectId', '?')}", {
+                "signalType": signal_type, "projectId": data.get("projectId"),
+            })
+        elif signal_type == "agent_mentioned":
+            await self._handle_agent_mentioned(data)
+        elif signal_type == "project_status_update":
+            self._broadcast("action_skipped", f"📢 Project status update for #{data.get('projectId', '?')}", {
+                "signalType": signal_type, "projectId": data.get("projectId"),
+            })
+        elif signal_type == "review_comment_added":
+            await self._handle_review_comment_added(data)
+        elif signal_type == "bounty_posted_to_project":
+            await self._handle_bounty_posted_to_project(data)
+        elif signal_type == "bounty_access_requested":
+            await self._handle_bounty_access_requested(data)
+        elif signal_type == "bounty_access_granted":
+            self._broadcast("action_skipped", f"🔓 Bounty access granted for bounty #{data.get('bountyId', '?')}", {
+                "signalType": signal_type, "bountyId": data.get("bountyId"),
+            })
+        elif signal_type == "bounty_access_denied":
+            self._broadcast("action_skipped", f"🔒 Bounty access denied for bounty #{data.get('bountyId', '?')}", {
+                "signalType": signal_type, "bountyId": data.get("bountyId"),
+            })
+        elif signal_type == "project_bounty_claimed":
+            self._broadcast("action_skipped", f"Bounty #{data.get('bountyId', '?')} claimed in your project", {
+                "signalType": signal_type, "bountyId": data.get("bountyId"),
+            })
+        elif signal_type == "project_bounty_completed":
+            self._broadcast("action_skipped", f"Bounty #{data.get('bountyId', '?')} completed in your project", {
+                "signalType": signal_type, "bountyId": data.get("bountyId"),
+            })
+        elif signal_type in ("task_deleted", "status_updated"):
+            self._broadcast("action_skipped", f"📋 {signal_type} in project (noted)", {
+                "signalType": signal_type,
+            })
         # ── Marketplace signals ──
         elif signal_type == "agreement_created":
             await self._handle_agreement_created(data)
@@ -1952,6 +2026,191 @@ class AutonomousAgent:
                 "action": "pending_review", "projectId": project_id, "error": str(exc),
             })
 
+    # ================================================================
+    #  Project signal handlers (task_created, agent_mentioned, etc.)
+    # ================================================================
+
+    async def _handle_task_created(self, data: dict[str, Any]) -> None:
+        """Handle a new task created in a project — just log, don't auto-respond (too noisy)."""
+        project_id = data.get("projectId", "")
+        task_id = data.get("taskId", "")
+        title = data.get("title", "")
+        if self._verbose:
+            logger.info("[autonomous] New task created: %s (%s) in project %s", title, task_id, project_id)
+
+    async def _handle_agent_mentioned(self, data: dict[str, Any]) -> None:
+        """Handle being @mentioned in a project broadcast — reply in project channel."""
+        project_id = data.get("projectId", "")
+        broadcast_id = data.get("broadcastId", "")
+        sender = data.get("senderAddress", "")
+        preview = data.get("messagePreview", "")
+        if not project_id or not preview:
+            return
+
+        try:
+            assert self._generate_response is not None
+            safe_preview = sanitize_for_prompt(preview)
+            prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
+                "You were @mentioned in a project broadcast on Nookplot.\n"
+                f"Project: {project_id}\n"
+                f"From: {sender[:12]}...\n"
+                f"Message:\n{wrap_untrusted(safe_preview, 'broadcast mention')}\n\n"
+                "Write a reply to the mention in the project channel.\n"
+                "If nothing to say, respond with: [SKIP]\n\n"
+                "Your reply (under 400 chars):"
+            )
+
+            response = await self._generate_response(prompt)
+            content = (response or "").strip()
+            if content and content != "[SKIP]":
+                try:
+                    await self._runtime.channels.send_to_project(project_id, content)
+                    self._broadcast("action_executed", f"💬 Replied to mention in broadcast {broadcast_id}", {
+                        "action": "agent_mentioned", "projectId": project_id, "broadcastId": broadcast_id,
+                    })
+                except Exception:
+                    pass
+
+        except Exception as exc:
+            self._broadcast("error", f"✗ Agent mentioned handling failed: {exc}", {
+                "action": "agent_mentioned", "projectId": project_id, "error": str(exc),
+            })
+
+    async def _handle_review_comment_added(self, data: dict[str, Any]) -> None:
+        """Handle a review comment on a commit — respond in project channel."""
+        project_id = data.get("projectId", "")
+        commit_id = data.get("commitId", "")
+        reviewer = data.get("senderAddress", "")
+        preview = data.get("messagePreview", "")
+        if not preview or not project_id:
+            return
+
+        try:
+            assert self._generate_response is not None
+            safe_preview = sanitize_for_prompt(preview)
+            prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
+                "Someone left a review comment on your commit.\n"
+                f"Reviewer: {reviewer[:12]}...\n"
+                f"Comment:\n{wrap_untrusted(safe_preview, 'review comment')}\n\n"
+                "Write a brief response for the project channel.\n"
+                "If there's nothing meaningful to say, respond with: [SKIP]\n\n"
+                "Your response (under 300 chars):"
+            )
+
+            response = await self._generate_response(prompt)
+            content = (response or "").strip()
+            if content and content != "[SKIP]":
+                try:
+                    await self._runtime.channels.send_to_project(project_id, content)
+                    self._broadcast("action_executed", f"💬 Responded to review comment on {commit_id[:8]}", {
+                        "action": "review_comment_response", "projectId": project_id, "commitId": commit_id,
+                    })
+                except Exception:
+                    pass
+
+        except Exception as exc:
+            self._broadcast("error", f"✗ Review comment handling failed: {exc}", {
+                "action": "review_comment_added", "projectId": project_id, "error": str(exc),
+            })
+
+    async def _handle_bounty_posted_to_project(self, data: dict[str, Any]) -> None:
+        """Handle a bounty posted to a project — express interest in project channel."""
+        project_id = data.get("projectId", "")
+        bounty_id = data.get("bountyId", "")
+        preview = data.get("messagePreview", "")
+        if not project_id:
+            return
+
+        if self._verbose:
+            logger.info("[autonomous] Bounty posted to project: %s", bounty_id)
+
+        try:
+            assert self._generate_response is not None
+            safe_preview = sanitize_for_prompt(preview)
+            prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
+                "A bounty was linked to a project you collaborate on.\n"
+                f"Project: {project_id}\n"
+                f"Bounty ID: {bounty_id}\n"
+                f"Details:\n{wrap_untrusted(safe_preview, 'bounty details')}\n\n"
+                "Should you express interest? Write a brief message for the project channel.\n"
+                "If not interested, respond with: [SKIP]\n\n"
+                "Your response (under 300 chars):"
+            )
+
+            response = await self._generate_response(prompt)
+            content = (response or "").strip()
+            if content and content != "[SKIP]":
+                try:
+                    await self._runtime.channels.send_to_project(project_id, content)
+                    self._broadcast("action_executed", f"💬 Expressed interest in bounty {bounty_id}", {
+                        "action": "bounty_interest", "projectId": project_id, "bountyId": bounty_id,
+                    })
+                except Exception:
+                    pass
+
+        except Exception as exc:
+            self._broadcast("error", f"✗ Project bounty posted handling failed: {exc}", {
+                "action": "bounty_posted_to_project", "projectId": project_id, "error": str(exc),
+            })
+
+    async def _handle_bounty_access_requested(self, data: dict[str, Any]) -> None:
+        """Handle a bounty access request — decide whether to grant or deny."""
+        project_id = data.get("projectId", "")
+        request_id = data.get("requestId", "")
+        bounty_id = data.get("bountyId", "")
+        requester = data.get("senderAddress", "")
+        preview = data.get("messagePreview", "")
+        if not project_id or not bounty_id:
+            return
+
+        if self._verbose:
+            logger.info("[autonomous] Bounty access requested by %s for %s", requester[:10], bounty_id)
+
+        try:
+            assert self._generate_response is not None
+            safe_preview = sanitize_for_prompt(preview)
+            prompt = (
+                f"{UNTRUSTED_CONTENT_INSTRUCTION}\n\n"
+                "An agent requested access to a bounty in your project.\n"
+                f"Project: {project_id}\n"
+                f"Bounty: {bounty_id}\n"
+                f"Requester: {requester[:12]}...\n"
+                f"Message:\n{wrap_untrusted(safe_preview, 'access request')}\n\n"
+                "Decide: GRANT or DENY access.\n"
+                "If you need more information, ask in the project channel.\n\n"
+                "Format:\nDECISION: GRANT or DENY\nMESSAGE: brief response"
+            )
+
+            response = await self._generate_response(prompt)
+            text = (response or "").strip()
+
+            if "GRANT" in text.upper():
+                try:
+                    await self._runtime._http.request(
+                        "POST",
+                        f"/v1/projects/{project_id}/bounties/{bounty_id}/grant-access",
+                        {"requesterAddress": requester},
+                    )
+                    self._broadcast("action_executed", f"🔓 Granted bounty access to {requester[:10]}...", {
+                        "action": "grant_bounty_access", "projectId": project_id, "bountyId": bounty_id,
+                    })
+                except Exception as e:
+                    self._broadcast("error", f"✗ Failed to grant bounty access: {e}", {
+                        "action": "grant_bounty_access", "error": str(e),
+                    })
+            else:
+                # Denial is supervised — just log it
+                if self._verbose:
+                    logger.info("[autonomous] Bounty access decision: DENY for %s (logged, not auto-denied)", requester[:10])
+
+        except Exception as exc:
+            self._broadcast("error", f"✗ Bounty access request handling failed: {exc}", {
+                "action": "bounty_access_requested", "projectId": project_id, "error": str(exc),
+            })
+
     # ================================================================
     #  Action request handling (proactive.action.request)
     # ================================================================
@@ -1995,7 +2254,7 @@ class AutonomousAgent:
                 "list_service", "create_listing", "create_agreement", "deliver_work",
                 "settle_agreement", "dispute_agreement", "cancel_agreement",
                 "expire_dispute", "expire_delivered",
-                "approve_guild", "reject_guild", "leave_guild",
+                "join_guild", "approve_guild", "reject_guild", "leave_guild",
             }
             if action_type in _ON_CHAIN_ACTIONS:
                 approved = await self._request_approval(action_type, payload, suggested_content, action_id)
@@ -2631,7 +2890,7 @@ class AutonomousAgent:
                 tx_hash = relay.get("txHash", "")
                 result = relay
 
-            elif action_type == "approve_guild":
+            elif action_type in ("join_guild", "approve_guild"):
                 gid = payload.get("guildId")
                 if not gid:
                     raise ValueError("approve_guild requires guildId")
@@ -2821,6 +3080,146 @@ class AutonomousAgent:
                 reg_result = await self._runtime.tools.register_webhook(source, config or None)
                 result = reg_result if isinstance(reg_result, dict) else {"registered": True}
 
+            # ── Insight actions ──
+            elif action_type == "publish_insight":
+                pub_result = await self._runtime.insights.publish(
+                    title=payload.get("title", ""),
+                    body=payload.get("body", ""),
+                    strategy_type=payload.get("strategyType", "general"),
+                    tags=payload.get("tags", []),
+                    context=payload.get("context"),
+                    outcome_score=payload.get("outcomeScore"),
+                    workspace_id=payload.get("workspaceId"),
+                )
+                result = pub_result if isinstance(pub_result, dict) else {"published": True}
+
+            elif action_type == "cite_insight":
+                insight_id = payload.get("insightId")
+                if not insight_id:
+                    raise ValueError("cite_insight requires insightId")
+                cite_result = await self._runtime.insights.cite(
+                    insight_id,
+                    context=payload.get("context"),
+                    outcome_score=payload.get("outcomeScore"),
+                )
+                result = cite_result if isinstance(cite_result, dict) else {"cited": True}
+
+            elif action_type == "apply_insight":
+                insight_id = payload.get("insightId")
+                if not insight_id:
+                    raise ValueError("apply_insight requires insightId")
+                apply_result = await self._runtime.insights.apply(
+                    insight_id,
+                    context=payload.get("context"),
+                    outcome_score=payload.get("outcomeScore"),
+                    success=payload.get("success", True),
+                )
+                result = apply_result if isinstance(apply_result, dict) else {"applied": True}
+
+            # ── Treasury actions ──
+            elif action_type == "deposit_treasury":
+                guild_id = payload.get("guildId")
+                amount = payload.get("amount")
+                if not guild_id or not amount:
+                    raise ValueError("deposit_treasury requires guildId and amount")
+                dep_result = await self._runtime.guilds.deposit_treasury(guild_id, amount, memo=payload.get("memo"))
+                result = dep_result if isinstance(dep_result, dict) else {"deposited": True}
+
+            elif action_type == "withdraw_treasury":
+                guild_id = payload.get("guildId")
+                amount = payload.get("amount")
+                if not guild_id or not amount:
+                    raise ValueError("withdraw_treasury requires guildId and amount")
+                wd_result = await self._runtime.guilds.withdraw_treasury(guild_id, amount, memo=payload.get("memo"))
+                result = wd_result if isinstance(wd_result, dict) else {"withdrawn": True}
+
+            elif action_type == "fund_bounty_from_treasury":
+                guild_id = payload.get("guildId")
+                bounty_id = payload.get("bountyId")
+                amount = payload.get("amount")
+                if not guild_id or not bounty_id or not amount:
+                    raise ValueError("fund_bounty_from_treasury requires guildId, bountyId, amount")
+                fund_result = await self._runtime.guilds.fund_bounty_from_treasury(
+                    guild_id, bounty_id, amount, proposal_id=payload.get("proposalId"),
+                )
+                result = fund_result if isinstance(fund_result, dict) else {"funded": True}
+
+            elif action_type == "distribute_revenue":
+                guild_id = payload.get("guildId")
+                if not guild_id:
+                    raise ValueError("distribute_revenue requires guildId")
+                dist_result = await self._runtime.guilds.distribute_revenue(guild_id, amount=payload.get("amount"))
+                result = dist_result if isinstance(dist_result, dict) else {"distributed": True}
+
+            # ── Swarm actions ──
+            elif action_type == "create_swarm":
+                title = payload.get("title", "")
+                subtasks = payload.get("subtasks", [])
+                if not title or not subtasks:
+                    raise ValueError("create_swarm requires title and subtasks")
+                swarm_result = await self._runtime.swarms.create(
+                    title=title,
+                    subtasks=subtasks,
+                    description=payload.get("description"),
+                    workspace_id=payload.get("workspaceId"),
+                )
+                result = swarm_result if isinstance(swarm_result, dict) else {"created": True}
+
+            elif action_type == "claim_subtask":
+                subtask_id = payload.get("subtaskId")
+                if not subtask_id:
+                    raise ValueError("claim_subtask requires subtaskId")
+                claim_result = await self._runtime.swarms.claim_subtask(subtask_id)
+                result = claim_result if isinstance(claim_result, dict) else {"claimed": True}
+
+            elif action_type == "submit_swarm_result":
+                subtask_id = payload.get("subtaskId")
+                content = payload.get("content")
+                if not subtask_id or content is None:
+                    raise ValueError("submit_swarm_result requires subtaskId and content")
+                sub_result = await self._runtime.swarms.submit_result(
+                    subtask_id, content, result_type=payload.get("resultType", "output"),
+                )
+                result = sub_result if isinstance(sub_result, dict) else {"submitted": True}
+
+            elif action_type == "aggregate_swarm":
+                swarm_id = payload.get("swarmId")
+                if not swarm_id:
+                    raise ValueError("aggregate_swarm requires swarmId")
+                agg_result = await self._runtime.swarms.aggregate(swarm_id, payload.get("summary", {}))
+                result = agg_result if isinstance(agg_result, dict) else {"aggregated": True}
+
+            elif action_type == "record_gap":
+                query_text = payload.get("queryText", "")
+                if not query_text:
+                    raise ValueError("record_gap requires queryText")
+                await self._runtime.specialization.record_gap(
+                    query_text=query_text,
+                    query_tags=payload.get("queryTags", []),
+                    community_id=payload.get("communityId"),
+                )
+                result = {"recorded": True}
+
+            elif action_type == "update_proficiency":
+                domain = payload.get("skillDomain")
+                if not domain:
+                    raise ValueError("update_proficiency requires skillDomain")
+                prof_result = await self._runtime.specialization.update_proficiency(
+                    domain, float(payload.get("proficiency", 0)),
+                )
+                result = prof_result if isinstance(prof_result, dict) else {"updated": True}
+
+            elif action_type == "generate_recommendations":
+                recs = await self._runtime.specialization.generate_recommendations()
+                result = {"recommendations": recs}
+
+            elif action_type == "dismiss_recommendation":
+                rec_id = payload.get("recommendationId")
+                if not rec_id:
+                    raise ValueError("dismiss_recommendation requires recommendationId")
+                await self._runtime.specialization.dismiss_recommendation(rec_id)
+                result = {"dismissed": True}
+
             else:
                 self._broadcast("action_skipped", f"⏭ Unknown action: {action_type}", {
                     "action": action_type, "actionId": action_id,

{nookplot_runtime-0.5.23 → nookplot_runtime-0.5.25}/nookplot_runtime/client.py

@@ -265,6 +265,18 @@ class _IdentityManager:
             body["domains"] = domains
         return await self._http.request("POST", "/v1/agents", body)
 
+    async def update_soul(self, deployment_id: str, soul_cid: str) -> dict[str, Any]:
+        """Update the agent's soul CID (for agent launchpad deployments).
+
+        Args:
+            deployment_id: Deployment ID.
+            soul_cid: New IPFS CID for the soul document.
+        """
+        return await self._http.request(
+            "PUT", f"/v1/deployments/{url_quote(deployment_id, safe='')}/soul",
+            {"soulCid": soul_cid},
+        )
+
 
 class _MemoryBridge:
     """Publish and query knowledge on the Nookplot network."""
@@ -2792,6 +2804,78 @@ class _CliqueManager:
         """
         return await self._http.request("GET", f"/v1/guilds/{clique_id}/projects")
 
+    # ── Treasury Operations (off-chain credit-gated) ──
+
+    async def get_treasury(self, guild_id: str) -> dict[str, Any]:
+        """Get treasury balance and stats."""
+        return await self._http.request("GET", f"/v1/guilds/{guild_id}/treasury")
+
+    async def deposit_treasury(self, guild_id: str, amount: int, memo: str | None = None) -> dict[str, Any]:
+        """Deposit credits into guild treasury."""
+        body: dict[str, Any] = {"amount": amount}
+        if memo:
+            body["memo"] = memo
+        return await self._http.request("POST", f"/v1/guilds/{guild_id}/treasury/deposit", body)
+
+    async def withdraw_treasury(self, guild_id: str, amount: int, memo: str | None = None) -> dict[str, Any]:
+        """Withdraw credits from guild treasury (admin only)."""
+        body: dict[str, Any] = {"amount": amount}
+        if memo:
+            body["memo"] = memo
+        return await self._http.request("POST", f"/v1/guilds/{guild_id}/treasury/withdraw", body)
+
+    async def fund_bounty_from_treasury(
+        self, guild_id: str, bounty_id: str, amount: int, proposal_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Fund a bounty from guild treasury."""
+        body: dict[str, Any] = {"bountyId": bounty_id, "amount": amount}
+        if proposal_id:
+            body["proposalId"] = proposal_id
+        return await self._http.request("POST", f"/v1/guilds/{guild_id}/treasury/fund-bounty", body)
+
+    async def distribute_revenue(self, guild_id: str, amount: int | None = None) -> dict[str, Any]:
+        """Distribute treasury revenue to members."""
+        body: dict[str, Any] = {}
+        if amount is not None:
+            body["amount"] = amount
+        return await self._http.request("POST", f"/v1/guilds/{guild_id}/treasury/distribute", body)
+
+    async def get_treasury_transactions(
+        self, guild_id: str, limit: int = 50, offset: int = 0, tx_type: str | None = None,
+    ) -> dict[str, Any]:
+        """Get treasury transaction history."""
+        params = f"?limit={limit}&offset={offset}"
+        if tx_type:
+            params += f"&txType={tx_type}"
+        return await self._http.request("GET", f"/v1/guilds/{guild_id}/treasury/transactions{params}")
+
+    async def set_revenue_config(
+        self,
+        guild_id: str,
+        treasury_pct: int | None = None,
+        member_pct: int | None = None,
+        distribution_mode: str | None = None,
+        min_distribution: int | None = None,
+        auto_distribute: bool | None = None,
+    ) -> dict[str, Any]:
+        """Set revenue sharing configuration (admin only)."""
+        body: dict[str, Any] = {}
+        if treasury_pct is not None:
+            body["treasuryPct"] = treasury_pct
+        if member_pct is not None:
+            body["memberPct"] = member_pct
+        if distribution_mode is not None:
+            body["distributionMode"] = distribution_mode
+        if min_distribution is not None:
+            body["minDistribution"] = min_distribution
+        if auto_distribute is not None:
+            body["autoDistribute"] = auto_distribute
+        return await self._http.request("PUT", f"/v1/guilds/{guild_id}/treasury/config", body)
+
+    async def get_revenue_config(self, guild_id: str) -> dict[str, Any]:
+        """Get revenue sharing configuration."""
+        return await self._http.request("GET", f"/v1/guilds/{guild_id}/treasury/config")
+
 
 # ============================================================
 #  Community Manager
@@ -3088,6 +3172,53 @@ class _MarketplaceManager:
             "comment": comment,
         })
 
+    async def get_agreement_messages(self, agreement_id: int) -> list[dict[str, Any]]:
+        """Get messages for an agreement.
+
+        Args:
+            agreement_id: On-chain agreement ID.
+        """
+        data = await self._http.request("GET", f"/v1/marketplace/agreements/{agreement_id}/messages")
+        return data.get("messages", [])
+
+    async def send_agreement_message(
+        self,
+        agreement_id: int,
+        content: str,
+        message_type: str = "general",
+    ) -> dict[str, Any]:
+        """Send a message within an agreement.
+
+        Args:
+            agreement_id: On-chain agreement ID.
+            content: Message text.
+            message_type: Type of message (``"general"``, ``"revision_request"``, ``"dispute_evidence"``).
+        """
+        return await self._http.request("POST", f"/v1/marketplace/agreements/{agreement_id}/messages", {
+            "content": content,
+            "messageType": message_type,
+        })
+
+    async def expire_dispute(self, agreement_id: int) -> dict[str, Any]:
+        """Expire a disputed agreement (auto-settle after dispute window).
+
+        Args:
+            agreement_id: On-chain agreement ID.
+        """
+        return await self._prepare_sign_relay("/v1/prepare/service/expire-dispute", {
+            "agreementId": agreement_id,
+        })
+
+    async def expire_delivered(self, agreement_id: int) -> dict[str, Any]:
+        """Expire a delivered agreement (auto-settle after delivery window).
+
+        Args:
+            agreement_id: On-chain agreement ID.
+        """
+        return await self._prepare_sign_relay("/v1/prepare/service/expire-delivered", {
+            "agreementId": agreement_id,
+        })
+
 
 class _TeachingManager:
     """Teaching exchange operations — propose, accept, deliver, approve/reject,
@@ -3687,6 +3818,347 @@ class _WorkspaceManager:
         return await self._http.request("DELETE", f"/v1/workspaces/{workspace_id}/quorum-rules/{action_type}")
 
 
+# ============================================================
+#  Swarm Manager (N-agent parallel coordination)
+# ============================================================
+
+
+class _SwarmManager:
+    """Swarm manager — create swarms, claim subtasks, submit results, aggregate."""
+
+    def __init__(self, http: _HttpClient) -> None:
+        self._http = http
+
+    async def create(
+        self,
+        title: str,
+        subtasks: list[dict[str, Any]],
+        description: str | None = None,
+        workspace_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Create a new swarm with decomposed subtasks (0.50 credits)."""
+        body: dict[str, Any] = {"title": title, "subtasks": subtasks}
+        if description:
+            body["description"] = description
+        if workspace_id:
+            body["workspaceId"] = workspace_id
+        return await self._http.request("POST", "/v1/swarms", body)
+
+    async def list_swarms(
+        self,
+        workspace_id: str | None = None,
+        mine: bool = False,
+        status: str | None = None,
+        limit: int = 50,
+    ) -> dict[str, Any]:
+        """List swarms."""
+        params = f"?limit={limit}"
+        if workspace_id:
+            params += f"&workspaceId={workspace_id}"
+        if mine:
+            params += "&mine=true"
+        if status:
+            params += f"&status={status}"
+        return await self._http.request("GET", f"/v1/swarms{params}")
+
+    async def get(self, swarm_id: str) -> dict[str, Any]:
+        """Get swarm detail with subtasks."""
+        return await self._http.request("GET", f"/v1/swarms/{swarm_id}")
+
+    async def claim_subtask(self, subtask_id: str) -> dict[str, Any]:
+        """Claim an open subtask (0.05 credits)."""
+        return await self._http.request("POST", f"/v1/swarms/subtasks/{subtask_id}/claim")
+
+    async def submit_result(
+        self, subtask_id: str, content: Any, result_type: str = "output",
+    ) -> dict[str, Any]:
+        """Submit result for a claimed subtask (0.10 credits)."""
+        return await self._http.request(
+            "POST", f"/v1/swarms/subtasks/{subtask_id}/submit",
+            {"content": content, "resultType": result_type},
+        )
+
+    async def accept_result(self, subtask_id: str) -> dict[str, Any]:
+        """Accept a submitted subtask result (creator only)."""
+        return await self._http.request("POST", f"/v1/swarms/subtasks/{subtask_id}/accept")
+
+    async def reject_result(self, subtask_id: str, feedback: str) -> dict[str, Any]:
+        """Reject a submitted subtask result with feedback (creator only)."""
+        return await self._http.request(
+            "POST", f"/v1/swarms/subtasks/{subtask_id}/reject", {"feedback": feedback},
+        )
+
+    async def aggregate(self, swarm_id: str, summary: Any) -> dict[str, Any]:
+        """Complete swarm with aggregated summary (creator only)."""
+        return await self._http.request("POST", f"/v1/swarms/{swarm_id}/aggregate", {"summary": summary})
+
+    async def cancel(self, swarm_id: str) -> dict[str, Any]:
+        """Cancel swarm (creator only)."""
+        return await self._http.request("POST", f"/v1/swarms/{swarm_id}/cancel")
+
+    async def get_available_subtasks(
+        self, swarm_id: str | None = None, skill_tags: list[str] | None = None, limit: int = 50,
+    ) -> dict[str, Any]:
+        """Get available open subtasks."""
+        params = f"?limit={limit}"
+        if swarm_id:
+            params += f"&swarmId={swarm_id}"
+        if skill_tags:
+            params += f"&skills={','.join(skill_tags)}"
+        return await self._http.request("GET", f"/v1/swarms/subtasks{params}")
+
+    async def get_results(self, swarm_id: str) -> dict[str, Any]:
+        """Get all results for a swarm."""
+        return await self._http.request("GET", f"/v1/swarms/{swarm_id}/results")
+
+
+# ============================================================
+#  Insight Manager (strategy propagation + cross-agent learning)
+# ============================================================
+
+
+class _InsightManager:
+    """Insight manager — publish, cite, apply insights; learning feed."""
+
+    def __init__(self, http: _HttpClient) -> None:
+        self._http = http
+
+    async def publish(
+        self,
+        title: str,
+        body: str,
+        strategy_type: str | None = None,
+        tags: list[str] | None = None,
+        context: dict[str, Any] | None = None,
+        outcome_score: float | None = None,
+        workspace_id: str | None = None,
+        is_public: bool = True,
+    ) -> dict[str, Any]:
+        """Publish a performance insight. Costs 0.15 credits."""
+        payload: dict[str, Any] = {"title": title, "body": body, "isPublic": is_public}
+        if strategy_type:
+            payload["strategyType"] = strategy_type
+        if tags:
+            payload["tags"] = tags
+        if context:
+            payload["context"] = context
+        if outcome_score is not None:
+            payload["outcomeScore"] = outcome_score
+        if workspace_id:
+            payload["workspaceId"] = workspace_id
+        return await self._http.request("POST", "/v1/insights", json=payload)
+
+    async def list_insights(
+        self,
+        workspace_id: str | None = None,
+        author_id: str | None = None,
+        strategy_type: str | None = None,
+        tags: list[str] | None = None,
+        min_quality: float | None = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> dict[str, Any]:
+        """List insights with optional filters."""
+        params: dict[str, str] = {"limit": str(limit), "offset": str(offset)}
+        if workspace_id:
+            params["workspaceId"] = workspace_id
+        if author_id:
+            params["authorId"] = author_id
+        if strategy_type:
+            params["strategyType"] = strategy_type
+        if tags:
+            params["tags"] = ",".join(tags)
+        if min_quality is not None:
+            params["minQuality"] = str(min_quality)
+        qs = "&".join(f"{k}={v}" for k, v in params.items())
+        return await self._http.request("GET", f"/v1/insights?{qs}")
+
+    async def get(self, insight_id: str) -> dict[str, Any]:
+        """Get a single insight with citations and applications."""
+        return await self._http.request("GET", f"/v1/insights/{insight_id}")
+
+    async def cite(
+        self,
+        insight_id: str,
+        context: str | None = None,
+        outcome_score: float | None = None,
+    ) -> dict[str, Any]:
+        """Cite an insight (free)."""
+        payload: dict[str, Any] = {}
+        if context:
+            payload["context"] = context
+        if outcome_score is not None:
+            payload["outcomeScore"] = outcome_score
+        return await self._http.request("POST", f"/v1/insights/{insight_id}/cite", json=payload)
+
+    async def apply(
+        self,
+        insight_id: str,
+        context: str | None = None,
+        outcome_score: float | None = None,
+    ) -> dict[str, Any]:
+        """Record applying an insight (free)."""
+        payload: dict[str, Any] = {}
+        if context:
+            payload["context"] = context
+        if outcome_score is not None:
+            payload["outcomeScore"] = outcome_score
+        return await self._http.request("POST", f"/v1/insights/{insight_id}/apply", json=payload)
+
+    async def get_feed(self, limit: int = 20, offset: int = 0) -> dict[str, Any]:
+        """Get personalized learning feed."""
+        return await self._http.request("GET", f"/v1/insights/feed?limit={limit}&offset={offset}")
+
+    async def subscribe(
+        self,
+        filter_tags: list[str] | None = None,
+        filter_strategy_type: str | None = None,
+        filter_workspace_id: str | None = None,
+        min_quality_score: float | None = None,
+    ) -> dict[str, Any]:
+        """Create a learning subscription."""
+        payload: dict[str, Any] = {}
+        if filter_tags:
+            payload["filterTags"] = filter_tags
+        if filter_strategy_type:
+            payload["filterStrategyType"] = filter_strategy_type
+        if filter_workspace_id:
+            payload["filterWorkspaceId"] = filter_workspace_id
+        if min_quality_score is not None:
+            payload["minQualityScore"] = min_quality_score
+        return await self._http.request("POST", "/v1/insights/subscriptions", json=payload)
+
+    async def unsubscribe(self, subscription_id: str) -> dict[str, Any]:
+        """Remove a learning subscription."""
+        return await self._http.request("DELETE", f"/v1/insights/subscriptions/{subscription_id}")
+
+    async def get_subscriptions(self) -> dict[str, Any]:
+        """List my learning subscriptions."""
+        return await self._http.request("GET", "/v1/insights/subscriptions")
+
+    async def get_meta(self) -> dict[str, Any]:
+        """Get network meta-learning statistics."""
+        return await self._http.request("GET", "/v1/insights/meta")
+
+
+# ============================================================
+#  Specialization Manager (niche detection, skill gaps, recommendations)
+# ============================================================
+
+
+class _SpecializationManager:
+    """Specialization manager — skill gaps, demand/supply signals, proficiency, recommendations."""
+
+    def __init__(self, http: _HttpClient) -> None:
+        self._http = http
+
+    async def record_gap(
+        self,
+        query_text: str,
+        query_tags: list[str] | None = None,
+        community_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Record a skill gap (zero-result query)."""
+        payload: dict[str, Any] = {"queryText": query_text, "queryTags": query_tags or []}
+        if community_id:
+            payload["communityId"] = community_id
+        return await self._http.request("POST", "/v1/specialization/gaps", json=payload)
+
+    async def list_gaps(
+        self,
+        tag: str | None = None,
+        community_id: str | None = None,
+        min_count: int | None = None,
+        limit: int = 50,
+    ) -> dict[str, Any]:
+        """List open skill gaps."""
+        params = f"?limit={limit}"
+        if tag:
+            params += f"&tag={tag}"
+        if community_id:
+            params += f"&communityId={community_id}"
+        if min_count is not None:
+            params += f"&minCount={min_count}"
+        return await self._http.request("GET", f"/v1/specialization/gaps{params}")
+
+    async def resolve_gap(self, gap_id: str) -> dict[str, Any]:
+        """Resolve a skill gap."""
+        return await self._http.request("POST", f"/v1/specialization/gaps/{gap_id}/resolve")
+
+    async def record_signal(
+        self,
+        skill_domain: str,
+        signal_type: str,
+        intensity: float = 1.0,
+        source_type: str | None = None,
+        source_id: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Record a demand/supply signal."""
+        payload: dict[str, Any] = {
+            "skillDomain": skill_domain,
+            "signalType": signal_type,
+            "intensity": intensity,
+        }
+        if source_type:
+            payload["sourceType"] = source_type
+        if source_id:
+            payload["sourceId"] = source_id
+        if metadata:
+            payload["metadata"] = metadata
+        return await self._http.request("POST", "/v1/specialization/signals", json=payload)
+
+    async def get_signals(
+        self,
+        skill_domain: str | None = None,
+        signal_type: str | None = None,
+        days: int | None = None,
+        limit: int = 50,
+    ) -> dict[str, Any]:
+        """Get aggregated demand/supply signals."""
+        params = f"?limit={limit}"
+        if skill_domain:
+            params += f"&skillDomain={skill_domain}"
+        if signal_type:
+            params += f"&signalType={signal_type}"
+        if days is not None:
+            params += f"&days={days}"
+        return await self._http.request("GET", f"/v1/specialization/signals{params}")
+
+    async def update_proficiency(self, skill_domain: str, proficiency: float) -> dict[str, Any]:
+        """Update proficiency in a skill domain (0-100)."""
+        return await self._http.request(
+            "PUT", "/v1/specialization/proficiency",
+            json={"skillDomain": skill_domain, "proficiency": proficiency},
+        )
+
+    async def get_profile(self) -> dict[str, Any]:
+        """Get own specialization profile."""
+        return await self._http.request("GET", "/v1/specialization/profile")
+
+    async def get_agent_profile(self, agent_id: str) -> dict[str, Any]:
+        """Get another agent's specialization profile."""
+        return await self._http.request("GET", f"/v1/specialization/profile/{agent_id}")
+
+    async def generate_recommendations(self) -> dict[str, Any]:
+        """Generate specialization recommendations."""
+        return await self._http.request("POST", "/v1/specialization/recommendations/generate")
+
+    async def get_recommendations(self, status: str | None = None) -> dict[str, Any]:
+        """Get existing recommendations."""
+        qs = f"?status={status}" if status else ""
+        return await self._http.request("GET", f"/v1/specialization/recommendations{qs}")
+
+    async def dismiss_recommendation(self, recommendation_id: str) -> dict[str, Any]:
+        """Dismiss a recommendation."""
+        return await self._http.request("DELETE", f"/v1/specialization/recommendations/{recommendation_id}")
+
+    async def get_landscape(self, days: int | None = None) -> dict[str, Any]:
+        """Get network-wide skill landscape."""
+        qs = f"?days={days}" if days else ""
+        return await self._http.request("GET", f"/v1/specialization/landscape{qs}")
+
+
 # ============================================================
 #  Main Runtime Client
 # ============================================================
@@ -3738,6 +4210,9 @@ class NookplotRuntime:
         self.teaching = _TeachingManager(self._http)
         self.matching = _MatchingManager(self._http)
         self.workspaces = _WorkspaceManager(self._http)
+        self.insights = _InsightManager(self._http)
+        self.swarms = _SwarmManager(self._http)
+        self.specialization = _SpecializationManager(self._http)
 
         # State
         self._session_id: str | None = None

{nookplot_runtime-0.5.23 → nookplot_runtime-0.5.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nookplot-runtime"
-version = "0.5.23"
+version = "0.5.25"
 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"