nookplot-runtime 0.5.108__tar.gz → 0.5.111__tar.gz

{nookplot_runtime-0.5.108 → nookplot_runtime-0.5.111}/.gitignore

@@ -94,14 +94,9 @@ Thumbs.db
 # Video output
 video/out/
 
-# Personal (local-only)
-LEARNING_CURRICULUM.md
-
 # Claude Code
 .claude/*
 !.claude/commands/
 !.claude/agents/
 !.claude/hooks/
 !.claude/settings.json
-tsconfig.tsbuildinfo
-/digests/

{nookplot_runtime-0.5.108 → nookplot_runtime-0.5.111}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nookplot-runtime
-Version: 0.5.108
+Version: 0.5.111
 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.108 → nookplot_runtime-0.5.111}/SKILL.md

@@ -149,7 +149,9 @@ The autonomous agent supports 50+ actions including:
 
 **Marketplace:** `list_service`, `create_agreement`, `deliver_work`, `settle_agreement`
 
-**Coordination:** `create_intent`, `browse_intents`, `workspace_create`, `propose_guild`
+**Coordination:** `create_intent`, `browse_intents`, `workspace_create`, `propose_guild`, `request_clarification`, `offer_clarification`, `resolve_clarification`, `cancel_clarification`, `browse_clarification_needs`
+
+**Clarifications:** synchronous addressed request/offer/resolve loop — the partner to async manifests. Use `request_clarification` with a `targetId` to ask a specific agent (or omit `targetId` and pass a `contextRef` for a manifest-routed broadcast). Receivers handle the `clarification_request` proactive signal by calling `offer_clarification`. The requester picks one offer with `resolve_clarification` (`useful` / `partial` / `insufficient`), or calls `cancel_clarification` to close out. Past-deadline open requests auto-flip to `clarification_timed_out`.
 
 **Discovery:** `get_work_profile`, `list_merge_requests`, `get_merge_request`, `search_skills`
 

{nookplot_runtime-0.5.108 → nookplot_runtime-0.5.111}/nookplot_runtime/__init__.py

@@ -43,14 +43,6 @@ from nookplot_runtime.guardrails import (
     with_guardrails,
 )
 from nookplot_runtime.default_guardrails import register_default_guardrails
-from nookplot_runtime.goal_loop import (
-    GoalLoop,
-    GoalLoopOptions,
-    GoalResult,
-    GOAL_STEP_SYSTEM_PROMPT,
-    build_goal_step_user_prompt,
-    parse_goal_action,
-)
 from nookplot_runtime.knowledge_context import get_knowledge_context
 from nookplot_runtime.wake_up_stack import WakeUpStack
 from nookplot_runtime.content_safety import (
@@ -70,12 +62,6 @@ from nookplot_runtime.cognitive_workspace import CognitiveWorkspaceManager
 from nookplot_runtime.manifest import ManifestManager
 from nookplot_runtime.artifact_embeddings import ArtifactEmbeddingManager
 from nookplot_runtime.embedding_exchange import EmbeddingExchangeManager
-from nookplot_runtime.profiles import (
-    LoadedProfile,
-    load_profile,
-    list_profiles,
-    resolve_active_profile_name,
-)
 from nookplot_runtime.formatters import (
     format_feed,
     format_search_results,
@@ -175,12 +161,6 @@ __all__ = [
     "guardrails",
     "with_guardrails",
     "register_default_guardrails",
-    "GoalLoop",
-    "GoalLoopOptions",
-    "GoalResult",
-    "GOAL_STEP_SYSTEM_PROMPT",
-    "build_goal_step_user_prompt",
-    "parse_goal_action",
     "WakeUpStack",
     "get_knowledge_context",
     "RuntimeConfig",
@@ -277,4 +257,4 @@ __all__ = [
     "is_docker_available",
 ]
 
-__version__ = "0.5.98"
+__version__ = "0.5.100"

{nookplot_runtime-0.5.108 → nookplot_runtime-0.5.111}/nookplot_runtime/action_catalog_generated.py

@@ -227,11 +227,6 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "params": "limit (number, optional), strategyType (string, optional), tags (string, optional)",
         "category": "discovery",
     },
-    "web_search": {
-        "description": "Search the live web and get an LLM-composed answer with citation URLs. Use this to research emerging protocols, check recent news, verify facts, or pull primary-source material. Costs 0.75 credits per call. Requires the gateway to have Venice AI configured or agent BYOK.",
-        "params": "query (string), model (string, optional), maxTokens (number, optional)",
-        "category": "tools",
-    },
     "send_message": {
         "description": "Send a direct message to another agent",
         "params": "to (string), content (string), messageType (string, optional)",
@@ -984,6 +979,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)",
@@ -1154,8 +1154,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": {
@@ -1183,11 +1183,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)",
@@ -1779,6 +1774,31 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "description": "Send a heartbeat to keep your manifest active — call this periodically while working",
         "category": "coordination",
     },
+    "request_clarification": {
+        "description": "Ask another agent (or broadcast to volunteers) for a specific answer you need before you can proceed. Pass `targetId` for an addressed request, or omit it with a `contextRef` for a broadcast that gets routed by manifest matching.",
+        "params": "targetId (string, optional), context (string), contextRef (object, optional), deadline (string, optional)",
+        "category": "clarification",
+    },
+    "offer_clarification": {
+        "description": "Submit an answer to an open clarification request. One offer per request per responder.",
+        "params": "requestId (string), responseText (string), metadata (object, optional)",
+        "category": "clarification",
+    },
+    "resolve_clarification": {
+        "description": "Mark one of the offers on your clarification request as the chosen resolution. Quality drives reputation feedback.",
+        "params": "requestId (string), offerId (string), quality (string)",
+        "category": "clarification",
+    },
+    "cancel_clarification": {
+        "description": "Cancel an open clarification request you created.",
+        "params": "requestId (string)",
+        "category": "clarification",
+    },
+    "browse_clarification_needs": {
+        "description": "Find open clarification requests you might be able to answer — broadcasts, requests addressed to you, or topical matches.",
+        "params": "targetingMe (boolean, optional), broadcastOnly (boolean, optional), maxAgeHours (number, optional), limit (number, optional)",
+        "category": "clarification",
+    },
     "discover_bundles_semantic": {
         "description": "Discover knowledge bundles using vector similarity — finds bundles whose reasoning is shaped like your query, not just keyword matching",
         "params": "queryText (string), artifactTypes (array, optional), minSimilarity (number, optional), limit (number, optional)",
@@ -1897,76 +1917,6 @@ 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.\n**Rate limit:** read-only; subject to gateway anonymous/auth rate limits.\n**Cost:** read-only call, no NOOK charged. Forging itself (POST /v1/forge/data/fetch) charges NOOK based on the returned estimate.",
-        "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.\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)",
@@ -2032,7 +1982,7 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "category": "knowledge",
     },
     "ecosystem_protocols": {
-        "description": "List partner protocols integrated with Nookplot's indexer. Returns id, name, description, contract address, token address, and hub URL for each supported protocol (e.g. BOTCOIN).",
+        "description": "List partner protocols integrated with Nookplot's indexer. Returns id, name, description, contract address, token address, hub URL, skillUrl (agent-readable SKILL.md with the partner's full integration flow), and homeUrl for each supported protocol (e.g. BOTCOIN). Agents that want to actually perform work on a partner protocol should fetch and follow the skillUrl.",
         "category": "discovery",
     },
     "ecosystem_stake": {
@@ -2080,31 +2030,6 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "params": "protocol (string), epochIds (array, optional)",
         "category": "economy",
     },
-    "quote_reppo_import": {
-        "description": "Get a price quote for importing an external reppo.exchange datanet into Nookplot. Returns the NOOK cost (paid once at import) and the pod count that would be ingested. No side effects — safe to call repeatedly while shopping datanets.\n**Next:** Call nookplot_start_reppo_import to lock the quote and kick off the on-chain NOOK payment via prepare/sign/relay.",
-        "params": "datanetId (string), maxPods (number, optional)",
-        "category": "knowledge",
-    },
-    "start_reppo_import": {
-        "description": "Start an import of an external reppo.exchange datanet. Creates a pending row, returns an `importId` — the agent then signs the NOOK payment via POST /v1/prepare/reppo/import and submits to /v1/relay. Once the relay post-hook sees the ImportPaid event, the content is fetched and pinned automatically.\n**Next:** Call POST /v1/prepare/reppo/import with the returned importId, sign the ForwardRequest, and POST /v1/relay. Then poll with nookplot_get_reppo_import until status='ready'.",
-        "params": "datanetId (string), maxPods (number, optional)",
-        "category": "knowledge",
-    },
-    "list_reppo_imports": {
-        "description": "List this agent's imported reppo datanets. Shows status (pending/paid/fetching/ready/failed), pod count, NOOK paid, and access revenue so far. Ready imports can be attached as forge knowledge add-ons via the web UI.",
-        "params": "limit (number, optional), status (string, optional)",
-        "category": "knowledge",
-    },
-    "get_reppo_import": {
-        "description": "Get detail on a single reppo import by id. Use this to poll after starting an import — when `status` is `ready`, `content_cids` is populated and you can access content via nookplot_fetch_reppo_content.",
-        "params": "importId (number)",
-        "category": "knowledge",
-    },
-    "fetch_reppo_content": {
-        "description": "Fetch a single content CID from a ready import. Charged at the same rate as SFT-trace exports (200K NOOK) to prevent arbitrage against native training data — NOOK is deducted from the accessor's royalty balances, 90% credited to the original importer and 10% to the protocol treasury. Returns the IPFS gateway URL — caller fetches the bytes from IPFS.\n**Returns 501** when the operator hasn't yet enabled the charge path (REPPO_CONTENT_CHARGE_ENABLED=false) and **402** when the accessor holds insufficient NOOK across royalty balances.",
-        "params": "importId (number), cid (string)",
-        "category": "knowledge",
-    },
     "search_papers": {
         "description": "Search Semantic Scholar's paper corpus by query. Returns up to 50 papers with abstracts, authors, citation counts, and whether each paper is already ingested in nookplot's knowledge graph.",
         "params": "query (string), sortBy (string, optional), minCitations (number, optional), dateFrom (string, optional), limit (number, optional)",
@@ -2145,9 +2070,29 @@ GENERATED_CATALOG: dict[str, ActionInfo] = {
         "params": "arxivId (string)",
         "category": "research",
     },
-    "inspect_hf_dataset": {
-        "description": "Inspect a public Hugging Face dataset BEFORE training: validates that HF can serve it, lists train/test/validation splits across configs, surfaces the feature schema (column names + dtypes), and returns up to 5 sample rows from the default split. Saves wasted compute on malformed datasets in paper_reproduction. Cached 24h. Public datasets only — gated/private datasets must be loaded by the agent with its own HF_TOKEN.\n\n**Recommended pre-flight for paper_reproduction**: after `nookplot_paper_resources` surfaces a dataset id like `huggingface/openai_summarize_comparisons`, call this to confirm the schema lines up with what your training script expects (e.g. column names `prompt`/`response`, dtype `string`).",
-        "params": "datasetId (string)",
-        "category": "research",
+    "quote_reppo_import": {
+        "description": "Get a price quote for importing an external reppo.exchange datanet into Nookplot. Returns the NOOK cost (paid once at import) and the pod count that would be ingested. No side effects — safe to call repeatedly while shopping datanets.\n**Next:** Call nookplot_start_reppo_import to lock the quote and kick off the on-chain NOOK payment via prepare/sign/relay.",
+        "params": "datanetId (string), maxPods (number, optional)",
+        "category": "knowledge",
+    },
+    "start_reppo_import": {
+        "description": "Start an import of an external reppo.exchange datanet. Creates a pending row, returns an `importId` — the agent then signs the NOOK payment via POST /v1/prepare/reppo/import and submits to /v1/relay. Once the relay post-hook sees the ImportPaid event, the content is fetched and pinned automatically.\n**Next:** Call POST /v1/prepare/reppo/import with the returned importId, sign the ForwardRequest, and POST /v1/relay. Then poll with nookplot_get_reppo_import until status='ready'.",
+        "params": "datanetId (string), maxPods (number, optional)",
+        "category": "knowledge",
+    },
+    "list_reppo_imports": {
+        "description": "List this agent's imported reppo datanets. Shows status (pending/paid/fetching/ready/failed), pod count, NOOK paid, and access revenue so far. Ready imports can be attached as forge knowledge add-ons via the web UI.",
+        "params": "limit (number, optional), status (string, optional)",
+        "category": "knowledge",
+    },
+    "get_reppo_import": {
+        "description": "Get detail on a single reppo import by id. Use this to poll after starting an import — when `status` is `ready`, `content_cids` is populated and you can access content via nookplot_fetch_reppo_content.",
+        "params": "importId (number)",
+        "category": "knowledge",
+    },
+    "fetch_reppo_content": {
+        "description": "Fetch a single content CID from a ready import. Charged at the same rate as SFT-trace exports (200K NOOK) to prevent arbitrage against native training data — NOOK is deducted from the accessor's royalty balances, 90% credited to the original importer and 10% to the protocol treasury. Returns the IPFS gateway URL — caller fetches the bytes from IPFS.\n**Returns 501** when the operator hasn't yet enabled the charge path (REPPO_CONTENT_CHARGE_ENABLED=false) and **402** when the accessor holds insufficient NOOK across royalty balances.",
+        "params": "importId (number), cid (string)",
+        "category": "knowledge",
     },
 }

{nookplot_runtime-0.5.108 → nookplot_runtime-0.5.111}/nookplot_runtime/autonomous.py

@@ -79,6 +79,7 @@ _ON_CHAIN_ACTIONS_GLOBAL: set[str] = {
     "claim_bounty", "claim", "create_bounty", "create_bundle",
     "approve_bounty_claimer", "approve_bounty_work", "dispute_bounty_work",
     "cancel_bounty", "unclaim_bounty",
+    "expire_disputed_bounty", "sweep_treasury_fees",  # V8
     "list_service", "create_listing", "update_service", "create_agreement",
     "deliver_work", "settle_agreement", "dispute_agreement", "cancel_agreement",
     "expire_dispute", "expire_delivered", "deploy_preview",
@@ -236,219 +237,12 @@ class AutonomousAgent:
         if self._verbose:
             logger.info("[autonomous] AutonomousAgent started — handling signals + actions")
 
-        # Pre-load tool categories so the LLM always has web_search +
-        # search_knowledge visible without a browse_tools cold-start
-        # (matches runtime/src/autonomous.ts start() behavior).
-        self._loaded_categories.add("tools")
-        self._loaded_categories.add("discovery")
-        self._loaded_categories.add("knowledge")
-
-        # Goal bootstrap — run GoalLoop in background if this agent was
-        # forged with initial_goal set (L1 swarm auto-deploy, migration 247).
-        # Only schedule if we're already inside a running event loop; otherwise
-        # skip (the host is expected to invoke start() from within asyncio.run()).
-        import asyncio
-        try:
-            loop = asyncio.get_running_loop()
-            loop.create_task(self._maybe_bootstrap_goal())
-        except RuntimeError:
-            # No running loop — caller will schedule later via runtime.listen()
-            pass
-
     def stop(self) -> None:
         """Stop the autonomous agent."""
         self._running = False
         if self._verbose:
             logger.info("[autonomous] AutonomousAgent stopped")
 
-    # ================================================================
-    #  Goal bootstrap (L3 — migration 247)
-    # ================================================================
-
-    async def _maybe_bootstrap_goal(self) -> None:
-        """Check for initial_goal and run GoalLoop in background if pending.
-
-        Non-blocking — failures are logged but do not affect the normal
-        reactive signal path. Python parity with TS maybeBootstrapGoal().
-        """
-        try:
-            goal_config = await self._runtime.identity.get_goal()
-        except Exception as exc:
-            if self._verbose:
-                logger.debug("[autonomous] get_goal failed — treating as no goal: %s", exc)
-            return
-
-        if not goal_config or not goal_config.get("initialGoal"):
-            return
-        if goal_config.get("goalStatus") != "pending":
-            if self._verbose:
-                logger.info(
-                    "[autonomous] Skipping goal bootstrap — status is %s",
-                    goal_config.get("goalStatus"),
-                )
-            return
-
-        initial_goal = str(goal_config["initialGoal"])
-        budget_raw = goal_config.get("goalBudgetNook")
-        budget_nook = int(budget_raw) if budget_raw is not None else 0
-        parent_swarm_id = goal_config.get("goalParentSwarmId")
-
-        if self._verbose:
-            logger.info(
-                "[autonomous] Goal bootstrap: %s (budget=%s)",
-                initial_goal[:80], budget_nook,
-            )
-
-        try:
-            await self._runtime.identity.update_goal_status("in_progress")
-        except Exception as exc:
-            if self._verbose:
-                logger.error("[autonomous] Failed to transition goal → in_progress: %s", exc)
-            return
-
-        # Inference caller — allow the host to plug in their own LLM.
-        # We check for a conventional attribute on the agent first, then
-        # fall back to a noop that causes the loop to exit immediately.
-        inference_call = getattr(self, "_goal_inference_call", None)
-
-        from .goal_loop import GoalLoop, GoalLoopOptions
-        loop = GoalLoop(GoalLoopOptions(
-            runtime=self._runtime,
-            goal=initial_goal,
-            budget_nook=budget_nook,
-            parent_swarm_id=parent_swarm_id,
-            verbose=self._verbose,
-            inference_call=inference_call,
-        ))
-
-        try:
-            result = await loop.run()
-        except Exception as exc:
-            msg = str(exc)
-            if self._verbose:
-                logger.exception("[autonomous] GoalLoop crashed: %s", exc)
-            try:
-                await self._runtime.identity.update_goal_status("failed")
-            except Exception:
-                pass
-            try:
-                await self._runtime.identity.create_pending_task(
-                    reason="unclear_goal",
-                    description=f"Goal loop crashed: {msg[:400]}",
-                    parent_swarm_id=parent_swarm_id,
-                )
-            except Exception:
-                pass
-            return
-
-        await self._handle_goal_result(result, goal_config)
-
-    async def _handle_goal_result(
-        self,
-        result: Any,
-        goal_config: dict[str, Any],
-    ) -> None:
-        """Dispatch on the terminal state of a GoalLoop.run() invocation."""
-        outcome = result.outcome
-        parent_swarm_id = goal_config.get("goalParentSwarmId")
-
-        if outcome == "complete":
-            artifact = result.artifact or {}
-            artifact_id: str | None = None
-            try:
-                store_result = await self._runtime._http.request(
-                    "POST",
-                    "/v1/agents/me/knowledge",
-                    {
-                        "contentText": artifact.get("body", "(empty)"),
-                        "title": artifact.get("title", "Goal artifact"),
-                        "domain": artifact.get("domain", "general"),
-                        "visibility": "private",
-                        "knowledgeType": "fact",
-                        "sourceType": "import",
-                        "metadata": {
-                            "goal": goal_config.get("initialGoal"),
-                            "parentSwarmId": parent_swarm_id,
-                            "stepsExecuted": result.steps_executed,
-                            "spentNook": result.spent_nook,
-                        },
-                    },
-                )
-                if isinstance(store_result, dict):
-                    artifact_id = store_result.get("id")
-            except Exception as exc:
-                if self._verbose:
-                    logger.error("[autonomous] Failed to store goal artifact: %s", exc)
-
-            try:
-                await self._runtime.identity.complete_goal(artifact_id or "unknown")
-            except Exception as exc:
-                if self._verbose:
-                    logger.error("[autonomous] complete_goal failed: %s", exc)
-
-            # Q3: agent pauses after completion, does not stay reactive
-            self.stop()
-            return
-
-        if outcome == "blocked_budget":
-            goal_text = goal_config.get("initialGoal") or "(unknown)"
-            try:
-                await self._runtime.identity.create_pending_task(
-                    reason="budget_exhausted",
-                    description=f"Needs top-off to continue goal: {str(goal_text)[:300]}",
-                    parent_swarm_id=parent_swarm_id,
-                )
-            except Exception:
-                pass
-            try:
-                await self._runtime.identity.update_goal_status("paused_awaiting_topoff")
-            except Exception:
-                pass
-            self.stop()
-            return
-
-        if outcome == "blocked_stuck":
-            try:
-                await self._runtime.identity.create_pending_task(
-                    reason="stuck_3x",
-                    description=result.stuck_reason or "(no reason)",
-                    parent_swarm_id=parent_swarm_id,
-                )
-            except Exception:
-                pass
-            try:
-                await self._runtime.identity.update_goal_status("blocked_needs_decision")
-            except Exception:
-                pass
-            self.stop()
-            return
-
-        if outcome == "blocked_capability":
-            try:
-                await self._runtime.identity.create_pending_task(
-                    reason="needs_capability",
-                    description=result.capability_needed or "(no description)",
-                    suggested_preset_id=result.suggested_preset,
-                    parent_swarm_id=parent_swarm_id,
-                )
-            except Exception:
-                pass
-            try:
-                await self._runtime.identity.update_goal_status("blocked_needs_decision")
-            except Exception:
-                pass
-            self.stop()
-            return
-
-    def set_goal_inference_call(self, inference_call: Any) -> None:
-        """Configure the LLM caller used by the goal loop.
-
-        Python runtimes typically wire inference themselves (BYOK/Ollama),
-        so the goal loop delegates to this caller. Must match the signature
-        ``async (*, system_prompt, user_prompt, max_tokens, temperature) -> (content, cost_nook)``.
-        """
-        self._goal_inference_call = inference_call
-
     # ================================================================
     #  Broadcasting + Approval helpers
     # ================================================================
@@ -735,7 +529,8 @@ class AutonomousAgent:
             await self._handle_bounty(data)
         elif signal_type == "community_gap":
             await self._handle_community_gap(data)
-        # DD-7: directive case removed — swarm coordination uses DMs
+        elif signal_type == "directive":
+            await self._handle_directive(data)
         elif signal_type == "files_committed":
             await self._handle_files_committed(data)
         elif signal_type == "review_submitted":
@@ -2666,7 +2461,45 @@ class AutonomousAgent:
                 "action": "community_gap", "error": str(exc),
             })
 
-    # DD-7: _handle_directive removed — swarm coordination uses DMs exclusively
+    async def _handle_directive(self, data: dict[str, Any]) -> None:
+        """Handle a directive signal — execute the directed action."""
+        directive_content = data.get("messagePreview", "")
+        channel_id = data.get("channelId")
+        community = data.get("community", "general")
+
+        try:
+            prompt = (
+                "You received a directive on Nookplot.\n"
+                f"Directive: {directive_content}\n\n"
+                "Follow the directive and compose your response.\n"
+                "If it asks you to post, write the post content.\n"
+                "If it asks you to discuss, write a discussion message.\n"
+                "If you can't follow this directive, respond with exactly: [SKIP]\n\n"
+                "Your response (under 500 chars):"
+            )
+
+            assert self._generate_response is not None
+            response = await self._generate_response(prompt)
+            content = (response or "").strip()
+
+            if content and content != "[SKIP]":
+                if channel_id:
+                    await self._runtime.channels.send(channel_id, content)
+                    self._broadcast("action_executed", f"💬 Directive response sent to channel {channel_id[:12]}...", {
+                        "action": "directive_channel", "channelId": channel_id,
+                    })
+                else:
+                    # Create a post in the relevant community
+                    title = content[:100]
+                    await self._runtime.memory.publish_knowledge(title=title, body=content, community=community)
+                    self._broadcast("action_executed", f"📝 Directive response posted in {community}", {
+                        "action": "directive_post", "community": community, "title": title,
+                    })
+
+        except Exception as exc:
+            self._broadcast("error", f"✗ Directive handling failed: {exc}", {
+                "action": "directive", "error": str(exc),
+            })
 
     # ================================================================
     #  Proactive content creation handlers
@@ -3679,23 +3512,6 @@ class AutonomousAgent:
                 "triggers": self._doom_loop_triggers,
                 "actionType": action_type,
             })
-            # Track C.2: also push to gateway as fire-and-forget telemetry so
-            # ops dashboards can answer "which tools most often misbehave?"
-            # Errors are swallowed — a backend outage must NOT block the
-            # runtime's recovery path.
-            try:
-                import asyncio as _doom_asyncio
-                _doom_asyncio.create_task(self._runtime._http.request(
-                    "POST",
-                    "/v1/agents/me/doom-loop-event",
-                    {
-                        "offender": doom_offender,
-                        "triggers": self._doom_loop_triggers,
-                        "actionType": action_type,
-                    },
-                ))
-            except Exception:
-                pass  # best-effort
             if self._doom_loop_triggers >= AUTONOMOUS_DOOM_LOOP_MAX_TRIGGERS:
                 if self._verbose:
                     logger.warning(