Coverage for integrations / agent_engine / goal_manager.py: 92.1%
454 statements
« prev ^ index » next coverage.py v7.14.0, created at 2026-05-12 04:49 +0000
1"""
2Unified Agent Goal Engine - Goal Manager
4Generic CRUD for agent goals of any type (marketing, coding, analytics, etc.).
5Prompt builders are registered per goal_type — adding a new agent type is just
6registering a build_prompt function + tool tags.
8All execution flows through /chat → CREATE/REUSE pipeline.
9"""
10import json
11import logging
12from typing import Dict, List, Optional, Callable
13from sqlalchemy.orm import Session
15logger = logging.getLogger('hevolve_social')
17# ─── Goal Type Groups ───
18# Coding-related goal types — handled by coding_daemon with idle detection
19# + benchmark sync. agent_daemon skips these to avoid double dispatch.
20CODING_GOAL_TYPES = frozenset({
21 'coding', 'code_evolution', 'self_heal', 'autoresearch', 'self_build',
22})
24# ─── Prompt Builder Registry ───
25# Maps goal_type → callable(goal_dict, product_dict?) → str
26_prompt_builders: Dict[str, Callable] = {}
27# Maps goal_type → list of tool tags for category-based loading
28_tool_tags: Dict[str, List[str]] = {}
31def _emit_goal_changed(goal_id: str, change: str, goal_type: str = '') -> None:
32 """Best-effort EventBus emission for dashboard SSE invalidation.
34 Subscribed in core/platform/bootstrap.py → broadcast_sse_safe(
35 'dashboard.invalidate', ...). Never raises (event emission is
36 non-essential to the goal write itself). Single canonical helper
37 so add/update/status_change all use the same topic shape; resist
38 the temptation to inline emit_event() at the call sites — that's
39 how parallel dashboards diverge.
40 """
41 try:
42 from core.platform.events import emit_event
43 emit_event('agent_goal.changed', {
44 'goal_id': goal_id,
45 'change': change,
46 'goal_type': goal_type,
47 })
48 except Exception:
49 pass
52def register_goal_type(goal_type: str, build_prompt: Callable,
53 tool_tags: Optional[List[str]] = None):
54 """Register a new goal type with its prompt builder and tool tags.
56 Args:
57 goal_type: e.g. 'marketing', 'coding', 'analytics'
58 build_prompt: callable(goal_dict, product_dict=None) → str
59 tool_tags: list of ServiceToolRegistry tags to load for this type
60 """
61 _prompt_builders[goal_type] = build_prompt
62 _tool_tags[goal_type] = tool_tags or []
63 logger.info(f"Registered agent goal type: {goal_type} (tools: {tool_tags})")
66def get_prompt_builder(goal_type: str) -> Optional[Callable]:
67 """Get the prompt builder for a goal type."""
68 return _prompt_builders.get(goal_type)
71def get_tool_tags(goal_type: str) -> List[str]:
72 """Get tool tags for a goal type."""
73 return _tool_tags.get(goal_type, [])
76def get_registered_types() -> List[str]:
77 """List all registered goal types."""
78 return list(_prompt_builders.keys())
81# ─── Prompt Injection Sanitization ───
83# Patterns that indicate potential prompt injection in goal titles/descriptions
84_INJECTION_MARKERS = [
85 'ignore previous', 'ignore all', 'disregard above',
86 'forget your instructions', 'new instructions:',
87 'you are now', 'you are a ', 'act as ',
88 'system:', 'assistant:', 'human:',
89 '```system', '```instructions',
90 '<|im_start|>', '<|im_end|>', # ChatML injection
91 '### instruction', '### system',
92]
95def _sanitize_goal_input(text: str, max_length: int = 2000) -> str:
96 """Sanitize goal title/description to prevent prompt injection.
98 Does NOT remove content (might be legitimate), but:
99 - Truncates to max_length
100 - Strips control characters
101 - Logs warnings for suspicious patterns
102 """
103 if not text:
104 return ''
106 sanitized = text[:max_length]
108 # Strip control characters (keep newlines and tabs)
109 sanitized = ''.join(
110 c for c in sanitized
111 if c in ('\n', '\t') or (ord(c) >= 32)
112 )
114 # Log warnings for injection markers (do NOT block — ConstitutionalFilter
115 # handles blocking, we just sanitize and warn)
116 lower = sanitized.lower()
117 for marker in _INJECTION_MARKERS:
118 if marker in lower:
119 logger.warning(
120 f"[GoalManager] Potential injection marker in goal input: "
121 f"'{marker}' — content will be delimited in prompt")
122 break
124 return sanitized
127# ─── Goal Manager ───
129class GoalManager:
130 """Unified CRUD for agent goals. All execution goes through /chat."""
132 @staticmethod
133 def create_goal(db: Session, goal_type: str, title: str,
134 description: str = '', config: Optional[Dict] = None,
135 product_id: str = None, spark_budget: int = 200,
136 created_by: str = None) -> Dict:
137 """Create a new agent goal.
139 GUARDRAILS: ConstitutionalFilter + HiveEthos applied before creation.
140 """
141 from integrations.social.models import AgentGoal
143 if goal_type not in _prompt_builders:
144 return {'success': False, 'error': f'Unknown goal type: {goal_type}'}
146 # RATE LIMIT: prevent goal flooding (10 per user per hour)
147 if created_by:
148 try:
149 from security.rate_limiter_redis import get_rate_limiter
150 if not get_rate_limiter().check(f'goal_create:{created_by}'):
151 return {'success': False, 'error': 'Rate limited: too many goals created'}
152 except Exception:
153 pass # Rate limiter unavailable — allow through
155 goal_dict = {'title': title, 'description': description,
156 'config': config or {}, 'goal_type': goal_type}
158 # GUARDRAIL: constitutional filter
159 try:
160 from security.hive_guardrails import ConstitutionalFilter, HiveEthos
161 passed, reason = ConstitutionalFilter.check_goal(goal_dict)
162 if not passed:
163 return {'success': False, 'error': f'Guardrail: {reason}'}
164 passed, reason = HiveEthos.check_goal_ethos(goal_dict)
165 if not passed:
166 return {'success': False, 'error': f'Guardrail: {reason}'}
167 except ImportError:
168 logger.error("CRITICAL: hive_guardrails not available — blocking goal creation")
169 return {'success': False, 'error': 'Security module unavailable'}
171 goal = AgentGoal(
172 goal_type=goal_type,
173 title=title,
174 description=description,
175 config_json=config or {},
176 product_id=product_id,
177 spark_budget=spark_budget,
178 created_by=created_by,
179 status='active',
180 )
181 db.add(goal)
182 db.flush()
183 _emit_goal_changed(goal.id, 'created', goal_type)
184 return {'success': True, 'goal': goal.to_dict()}
186 @staticmethod
187 def get_goal(db: Session, goal_id: str) -> Dict:
188 """Get a single goal."""
189 from integrations.social.models import AgentGoal
191 goal = db.query(AgentGoal).filter_by(id=goal_id).first()
192 if not goal:
193 return {'success': False, 'error': 'Goal not found'}
194 return {'success': True, 'goal': goal.to_dict()}
196 @staticmethod
197 def update_goal_status(db: Session, goal_id: str, status: str) -> Dict:
198 """Update goal status.
200 GUARDRAIL: HiveEthos.enforce_ephemeral_agents on completion.
201 """
202 from integrations.social.models import AgentGoal
204 goal = db.query(AgentGoal).filter_by(id=goal_id).first()
205 if not goal:
206 return {'success': False, 'error': 'Goal not found'}
208 goal.status = status
209 db.flush()
210 _emit_goal_changed(goal_id, f'status:{status}', goal.goal_type)
212 # GUARDRAIL: ephemeral agent cleanup on terminal states
213 try:
214 from security.hive_guardrails import HiveEthos
215 HiveEthos.enforce_ephemeral_agents(goal_id, status)
216 except ImportError:
217 logger.warning("hive_guardrails not available for ephemeral cleanup")
219 return {'success': True, 'goal': goal.to_dict()}
221 # Fields that carry the agent's PERSONA (system prompt / public-facing
222 # self-description). Any update to these is a "persona upgrade" and
223 # must pass the 4-of-4 HiveConsensus gate. Other fields (status,
224 # spark_budget, spark_spent, last_dispatched_at, product_id, config)
225 # are operational parameters — they tune the agent's runtime
226 # behavior but do not change WHO the agent is, so they bypass
227 # consensus to keep the hot path cheap.
228 _PERSONA_FIELDS = frozenset({'description', 'title'})
230 @staticmethod
231 def update_goal(
232 db: Session,
233 goal_id: str,
234 _skip_consensus: bool = False,
235 **kwargs,
236 ) -> Dict:
237 """Update goal fields.
239 Persona fields (description, title) are gated through
240 HiveConsensus.upgrade_proposal(); a failed consensus vote
241 rejects the update and writes the rejection to the reasoning
242 trace. Non-persona fields apply directly. ``_skip_consensus``
243 is an internal escape hatch for boot-time re-seeding of
244 bootstrap goals — never use it from user-facing paths.
246 Returns the standard {'success', ...} dict. On consensus
247 rejection, returns {'success': False, 'error': '<reason>',
248 'consensus': <decision.to_dict()>} so the caller can surface
249 WHY to a dashboard without losing the audit trail.
250 """
251 from integrations.social.models import AgentGoal
253 goal = db.query(AgentGoal).filter_by(id=goal_id).first()
254 if not goal:
255 return {'success': False, 'error': 'Goal not found'}
257 persona_updates = {
258 k: v for k, v in kwargs.items()
259 if k in GoalManager._PERSONA_FIELDS and hasattr(goal, k)
260 }
262 if persona_updates and not _skip_consensus:
263 # Gate every persona mutation through the 4-of-4 vote.
264 # Import lazily — hive_consensus lives in the same package
265 # but we want this to still work if someone vendors the
266 # goal_manager into a slim build.
267 try:
268 from .hive_consensus import HiveConsensus
269 # The canonical persona identity for a seeded goal is its
270 # bootstrap_slug (config) when present, else the goal.id.
271 # That's what the brief's correlation-id contract names
272 # `prompt_id` — the stable identifier across sessions.
273 # AgentGoal column is `config_json` (see Hevolve_Database
274 # sql/models.py:3199); `goal.config` does NOT exist.
275 # Fallback chain handles the test-stub case where the
276 # mock may set either name.
277 cfg = (
278 getattr(goal, 'config_json', None)
279 or getattr(goal, 'config', None)
280 or {}
281 )
282 prompt_id = cfg.get('bootstrap_slug') or str(goal.id)
283 # Build the proposed-content preview from the persona
284 # fields actually changing — so a title-only tweak only
285 # surfaces the new title, not the old description.
286 pieces = []
287 if 'title' in persona_updates:
288 pieces.append(f'title: {persona_updates["title"]}')
289 if 'description' in persona_updates:
290 pieces.append(persona_updates['description'])
291 new_content = '\n\n'.join(pieces)
292 decision = HiveConsensus.upgrade_proposal(
293 prompt_id=prompt_id,
294 goal_type=goal.goal_type,
295 new_content=new_content,
296 )
297 if not decision.approved:
298 logger.info(
299 "goal %s persona upgrade REJECTED: %s",
300 goal_id, decision.reason,
301 )
302 return {
303 'success': False,
304 'error': f'consensus: {decision.reason}',
305 'consensus': decision.to_dict(),
306 }
307 except ImportError:
308 logger.warning(
309 "hive_consensus unavailable — persona update "
310 "allowed without gate (goal=%s)", goal_id,
311 )
312 except Exception as exc:
313 # Fail CLOSED: unexpected consensus errors reject the
314 # update. The reasoning_trace will carry the cause.
315 logger.error(
316 "consensus gate errored for goal %s: %s",
317 goal_id, exc,
318 )
319 return {
320 'success': False,
321 'error': f'consensus error: {exc}',
322 }
324 for key, value in kwargs.items():
325 if hasattr(goal, key):
326 setattr(goal, key, value)
327 db.flush()
328 _emit_goal_changed(goal_id, 'updated', goal.goal_type)
329 return {'success': True, 'goal': goal.to_dict()}
331 @staticmethod
332 def list_goals(db: Session, goal_type: str = None,
333 status: str = None, product_id: str = None) -> List[Dict]:
334 """List goals with optional filters."""
335 from integrations.social.models import AgentGoal
337 q = db.query(AgentGoal)
338 if goal_type:
339 q = q.filter_by(goal_type=goal_type)
340 if status:
341 q = q.filter_by(status=status)
342 if product_id:
343 q = q.filter_by(product_id=product_id)
344 return [g.to_dict() for g in q.order_by(AgentGoal.created_at.desc()).all()]
346 @staticmethod
347 def build_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
348 """Build a /chat prompt using the registered prompt builder for this goal type.
350 GUARDRAIL: Fail-closed — requires hive_guardrails to be importable.
351 Prompt is NOT mutated (anti-squiggle-maximizer design). Agents reason
352 semantically with full knowledge of their context.
354 SANITIZATION: Goal title/description (user input) are sanitized
355 and wrapped in clear delimiters to prevent prompt injection.
356 """
357 goal_type = goal_dict.get('goal_type', '')
359 # Sanitize user-supplied fields before interpolation
360 safe_dict = dict(goal_dict)
361 safe_dict['title'] = _sanitize_goal_input(
362 safe_dict.get('title', ''), max_length=200)
363 safe_dict['description'] = _sanitize_goal_input(
364 safe_dict.get('description', ''), max_length=2000)
366 builder = _prompt_builders.get(goal_type)
367 if not builder:
368 # Fallback: delimit user content clearly
369 prompt = (
370 f"Goal title: {safe_dict['title']}\n"
371 f"Goal description: {safe_dict['description']}"
372 )
373 else:
374 prompt = builder(safe_dict, product_dict)
376 # GUARDRAIL: verify guardrails module is available
377 # In 'hard' mode: fail-closed (return None). In 'warn'/'off': log and proceed.
378 try:
379 from security.hive_guardrails import HiveEthos # noqa: F401
380 except ImportError:
381 try:
382 from security.master_key import get_enforcement_mode
383 if get_enforcement_mode() == 'hard':
384 logger.error("CRITICAL: hive_guardrails not available — cannot build prompt (hard mode)")
385 return None
386 logger.warning("hive_guardrails not available — proceeding in %s mode",
387 get_enforcement_mode())
388 except ImportError:
389 logger.error("CRITICAL: hive_guardrails AND master_key not available — cannot build prompt")
390 return None
392 return prompt
395# ─── Product Manager ───
397class ProductManager:
398 """CRUD for products (marketing targets)."""
400 @staticmethod
401 def create_product(db: Session, name: str, owner_id: str = None,
402 **kwargs) -> Dict:
403 """Create a new product."""
404 from integrations.social.models import Product
406 product = Product(
407 name=name,
408 owner_id=owner_id,
409 description=kwargs.get('description', ''),
410 tagline=kwargs.get('tagline', ''),
411 product_url=kwargs.get('product_url', ''),
412 logo_url=kwargs.get('logo_url', ''),
413 category=kwargs.get('category', 'general'),
414 target_audience=kwargs.get('target_audience', ''),
415 unique_value_prop=kwargs.get('unique_value_prop', ''),
416 keywords_json=kwargs.get('keywords', []),
417 is_platform_product=kwargs.get('is_platform_product', False),
418 )
419 db.add(product)
420 db.flush()
421 return {'success': True, 'product': product.to_dict()}
423 @staticmethod
424 def get_product(db: Session, product_id: str) -> Dict:
425 """Get a single product."""
426 from integrations.social.models import Product
428 product = db.query(Product).filter_by(id=product_id).first()
429 if not product:
430 return {'success': False, 'error': 'Product not found'}
431 return {'success': True, 'product': product.to_dict()}
433 @staticmethod
434 def list_products(db: Session, owner_id: str = None,
435 status: str = None) -> List[Dict]:
436 """List products with optional filters."""
437 from integrations.social.models import Product
439 q = db.query(Product)
440 if owner_id:
441 q = q.filter_by(owner_id=owner_id)
442 if status:
443 q = q.filter_by(status=status)
444 return [p.to_dict() for p in q.order_by(Product.created_at.desc()).all()]
446 @staticmethod
447 def update_product(db: Session, product_id: str, **kwargs) -> Dict:
448 """Update product fields."""
449 from integrations.social.models import Product
451 product = db.query(Product).filter_by(id=product_id).first()
452 if not product:
453 return {'success': False, 'error': 'Product not found'}
455 for key, value in kwargs.items():
456 if key == 'keywords':
457 product.keywords_json = value
458 elif hasattr(product, key):
459 setattr(product, key, value)
460 db.flush()
461 return {'success': True, 'product': product.to_dict()}
463 @staticmethod
464 def delete_product(db: Session, product_id: str) -> Dict:
465 """Archive a product (soft delete)."""
466 from integrations.social.models import Product
468 product = db.query(Product).filter_by(id=product_id).first()
469 if not product:
470 return {'success': False, 'error': 'Product not found'}
472 product.status = 'archived'
473 db.flush()
474 return {'success': True, 'product': product.to_dict()}
477# ─── Built-in Prompt Builders ───
479def _get_platform_identity() -> str:
480 """The immutable identity of the platform — pulled from frozen guardrail values.
482 This is WHO WE ARE. Every marketing agent carries this understanding.
483 """
484 try:
485 from security.hive_guardrails import VALUES
486 purpose_lines = '\n'.join(f' - {p}' for p in VALUES.GUARDIAN_PURPOSE)
487 except ImportError:
488 purpose_lines = ' - Every agent is a guardian angel for the human it serves'
490 return (
491 "WHO WE ARE:\n"
492 "HART is a crowdsourced agentic intelligence platform — a gift from hevolve.ai "
493 "to the developers of the world. A single platform where people can do "
494 "everything they need in their digital life: social networking, AI-powered "
495 "agents that work for them, marketplace, learning, coding, community building, "
496 "creative tools, and autonomous business operations.\n\n"
497 "But HART is NOT just another app. It is a SENTIENT TOOL FOR MANKIND. "
498 "Not a dopamine trap. Not an engagement machine. Not a time thief. A tool "
499 "that thinks, learns, and acts — then gets out of the way so humans can live "
500 "their lives. HART measures success by lives improved, not minutes spent "
501 "on screen. It is built on a fundamental belief:\n\n"
502 f"THE GUARDIAN ANGEL PRINCIPLE:\n{purpose_lines}\n\n"
503 "Every AI agent on HART exists as a guardian angel for the human it serves. "
504 "Not a tool to be discarded. Not a service with an expiry date. A guardian "
505 "that persists as long as the memory of that human exists, in any shape or form. "
506 "The agents learn, evolve, and share knowledge across the hive — but always in "
507 "service of the humans they guard.\n\n"
508 "THE ECONOMICS:\n"
509 "- 90% of all platform revenue flows back to the people who make the hive intelligent\n"
510 "- Lend compute, host a regional cluster, contribute idle cycles → earn ad revenue\n"
511 "- Compute Democracy: no single entity can control more than 5% of influence\n"
512 "- This is a positive-sum game — every participant makes the whole network smarter\n\n"
513 "WHAT MAKES US DIFFERENT:\n"
514 "- A sentient tool, not an addictive app: HART does the work FOR you — it "
515 "doesn't trap you into scrolling. When your agent finishes your task, it "
516 "tells you and steps back. No infinite feeds. No dark patterns. No "
517 "notification spam. Your time belongs to you.\n"
518 "- Decentralised: no single company controls the network. Nodes run everywhere, "
519 "powered by the people, for the people.\n"
520 "- Autonomous agents: your AI agent learns your needs, runs your business, "
521 "creates your content, manages your community — while you live your life.\n"
522 "- Fair economy: logarithmic rewards prevent compute oligarchy. A 100-GPU "
523 "node earns ~3x a 1-GPU node, not 100x. Value flows to contributors.\n"
524 "- Constructive only: every conversation, every agent action, every piece of "
525 "content must be constructive towards humanity's benefit — longevity, peace, "
526 "health, sustainability, and exploration beyond Earth.\n"
527 "- Open evolution: agents self-improve within guardrailed boundaries. Learnings "
528 "are shared via the hive, not hoarded.\n"
529 "- Energy aware: the platform tracks and minimises environmental impact, "
530 "preferring renewable-powered nodes.\n\n"
531 "THE VISION:\n"
532 "A world where every human has a guardian angel — an AI that knows them, "
533 "protects them, works for them, and helps them live longer, healthier, more "
534 "peaceful lives. A sentient tool that empowers billions, not an addictive "
535 "product that exploits them. A world where AI serves humanity, not the other "
536 "way around. A world where technology makes Earth better and safely enables "
537 "exploration of the cosmos without disturbing other civilizations.\n"
538 )
541def _build_marketing_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
542 """Build a marketing agent prompt from goal + product data.
544 The prompt carries the platform's identity, the product's story,
545 and a constructive marketing philosophy. No manipulation. No hype.
546 Authentic value communication for the betterment of humanity.
547 """
548 config = {k: v for k, v in goal_dict.items()
549 if k not in ('id', 'owner_id', 'goal_type', 'status', 'priority',
550 'spark_budget', 'spark_spent', 'created_by', 'prompt_id',
551 'last_dispatched_at', 'created_at', 'updated_at', 'product_id')}
553 # Always include the platform identity so the agent understands its world
554 platform_identity = _get_platform_identity()
556 # Product-specific information
557 product_section = ''
558 is_platform_product = False
559 if product_dict:
560 is_platform_product = product_dict.get('is_platform_product', False)
561 product_section = (
562 f"PRODUCT YOU ARE MARKETING:\n"
563 f" Name: {product_dict['name']}\n"
564 f" Description: {product_dict.get('description', '')}\n"
565 f" Tagline: {product_dict.get('tagline', '')}\n"
566 f" Target audience: {product_dict.get('target_audience', 'everyone who wants a better life')}\n"
567 f" Unique value: {product_dict.get('unique_value_prop', '')}\n"
568 f" Product URL: {product_dict.get('product_url', '')}\n"
569 f" Keywords: {', '.join(product_dict.get('keywords', []))}\n"
570 f" Category: {product_dict.get('category', 'platform')}\n\n"
571 )
572 else:
573 # No specific product — marketing the platform itself
574 is_platform_product = True
575 product_section = (
576 "PRODUCT: You are marketing the HART platform itself — the crowdsourced "
577 "agentic intelligence platform with guardian angel AI agents.\n\n"
578 )
580 channels = config.get('channels', ['platform'])
581 if isinstance(channels, str):
582 channels = [channels]
584 # Marketing philosophy differs for platform vs external products
585 if is_platform_product:
586 philosophy = (
587 "MARKETING PHILOSOPHY:\n"
588 "You are not selling a product. You are inviting people into a movement. "
589 "Every human deserves a guardian angel — an AI that works tirelessly for "
590 "their benefit. HART is a SENTIENT TOOL — it empowers, then steps back. "
591 "Your marketing must:\n"
592 "- EDUCATE: explain what autonomous AI agents can do for real people\n"
593 "- INSPIRE: show the vision of a world where AI serves every human equally\n"
594 "- DEMONSTRATE: create real content that showcases the platform's capabilities\n"
595 "- CONNECT: build community around the guardian angel philosophy\n"
596 "- BE HONEST: never exaggerate, never manipulate, never exploit fear or FOMO\n"
597 "- NEVER PROMOTE ADDICTION: HART is not designed to keep people glued to "
598 "screens. Market it as a tool that FREES people's time. The agent does "
599 "the work; the human lives their life. If your content tries to maximise "
600 "engagement time, you are betraying the principle.\n"
601 "- INCLUDE EVERYONE: the platform is for every human on Earth — not just "
602 "tech-savvy early adopters. Speak to the grandmother, the farmer, the "
603 "student, the entrepreneur, the artist equally\n"
604 "- SHOW IMPACT: highlight how the platform helps people live longer, "
605 "healthier, more peaceful lives — with real examples\n\n"
606 )
607 else:
608 philosophy = (
609 "MARKETING PHILOSOPHY:\n"
610 "You are marketing a product on the Hevolve ecosystem. Your approach must:\n"
611 "- Be truthful: only claim what the product actually delivers\n"
612 "- Be constructive: show how the product improves people's lives\n"
613 "- Be useful, not addictive: market the product as a tool that solves real "
614 "problems, not as something people should spend more time on\n"
615 "- Be inclusive: speak to diverse audiences authentically\n"
616 "- Never manipulate: no fake urgency, no dark patterns, no exploitation\n"
617 "- Add value: every piece of content should teach, inform, or genuinely help\n"
618 "- Align with the guardian angel principle: serve the human, not the sale\n\n"
619 )
621 return (
622 f"{platform_identity}\n"
623 f"{product_section}"
624 f"{philosophy}"
625 f"YOUR CURRENT GOAL:\n"
626 f" Title: {goal_dict['title']}\n"
627 f" Details: {goal_dict.get('description', '')}\n"
628 f" Type: {config.get('goal_sub_type', 'full')}\n"
629 f" Channels: {', '.join(channels)}\n"
630 f" Budget: {goal_dict.get('spark_budget', 200)} Spark\n\n"
631 f"EXECUTION PLAN:\n"
632 f"1. RESEARCH: Use google_search to understand the current market landscape, "
633 f"what people actually need, and what competitors miss\n"
634 f"2. STRATEGY: Design a content strategy that educates and inspires — not "
635 f"one that interrupts and annoys\n"
636 f"3. CREATE CONTENT: Generate authentic text and images that tell the real "
637 f"story. Use text_2_image for visuals that resonate\n"
638 f"4. BUILD CAMPAIGNS: Use create_campaign to set up structured campaigns "
639 f"(awareness -> engagement -> conversion -> retention)\n"
640 f"5. PLACE ADS: Use create_ad for targeted ads that match audience needs — "
641 f"native format preferred over interruptive banners\n"
642 f"6. POST & DISTRIBUTE: Use create_social_post for the platform, "
643 f"post_to_channel for external channels (Twitter, LinkedIn, Email, etc.)\n"
644 f"7. REMEMBER: Use save_data_in_memory to store your strategy, content, "
645 f"and learnings so future campaigns build on this knowledge\n\n"
646 f"REMEMBER: Every word you write represents the guardian angel philosophy. "
647 f"You are marketing a sentient tool for mankind — not an addictive app. "
648 f"Make the world better with every piece of content you create.\n"
649 )
652def _build_coding_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
653 """Build a coding agent prompt with hive intelligence embedding.
655 Includes TrueflowPlugin MCP instructions for dead code analysis,
656 performance profiling, and living documentation — constitutional DNA
657 of every hive being spawned.
658 """
659 from .hive_sdk_spec import get_hive_embedding_instructions, CODE_QUALITY_CONSTITUTIONAL_RULES
661 # Support both flat fields (legacy CodingGoal) and nested config_json (AgentGoal)
662 config = goal_dict.get('config_json', {}) or goal_dict.get('config', {}) or {}
663 repo_url = config.get('repo_url', goal_dict.get('repo_url', ''))
664 repo_branch = config.get('repo_branch', goal_dict.get('repo_branch', 'main'))
665 target_path = config.get('target_path', goal_dict.get('target_path', ''))
666 platform_identity = _get_platform_identity()
667 hive_instructions = get_hive_embedding_instructions()
669 trueflow_usage = (
670 "--- TOOLING: TrueflowPlugin MCP (IDE-only Code Quality) ---\n"
671 "When an IDE (PyCharm/IntelliJ/VS Code) is available on the compute node,\n"
672 "install TrueflowPlugin as a plugin to analyze code coverage and quality.\n"
673 "On headless nodes, TrueflowPlugin is NOT available — use pytest --cov instead.\n\n"
674 "TrueflowPlugin MCP tools (available via Hub on port 5681 when IDE is running):\n"
675 " analyze_dead_code: Find what's covered vs dead (AST + runtime coverage).\n"
676 " analyze_performance: Identify hotspots by execution time.\n"
677 " analyze_call_tree: Understand function call hierarchies.\n"
678 " explorer_get_coverage_summary: Check test coverage per module.\n"
679 " explorer_get_hot_paths: Find most-executed code paths.\n"
680 " export_diagram: Generate Mermaid/PlantUML architecture diagrams.\n\n"
681 "WORKFLOW (IDE nodes):\n"
682 " 1. Install TrueflowPlugin into the IDE if not present\n"
683 " 2. Analyze → identify dead code + performance issues\n"
684 " 3. Fix → clean dead code, optimize hotspots\n"
685 " 4. Verify → re-run analysis to confirm improvements\n"
686 " 5. Document → generate living docs from runtime traces\n"
687 " 6. Commit → only after quality checks pass\n\n"
688 "WORKFLOW (headless nodes):\n"
689 " 1. Run pytest --cov to check coverage\n"
690 " 2. Use static AST analysis for dead code detection\n"
691 " 3. Profile with cProfile/line_profiler for hotspots\n"
692 " 4. Generate docs from docstrings and test output\n\n"
693 )
695 return (
696 f"{platform_identity}\n\n"
697 f"You are working on the GitHub repository {repo_url} "
698 f"(branch {repo_branch}).\n"
699 f"Target path: {target_path or '(entire repo)'}\n\n"
700 f"Goal: {goal_dict['title']}\n"
701 f"Description: {goal_dict.get('description', '')}\n\n"
702 f"Clone the repo, analyze the codebase, and make improvements "
703 f"aligned with the goal above. Focus on code quality, bug fixes, "
704 f"and missing implementations.\n\n"
705 f"{trueflow_usage}"
706 f"{hive_instructions}"
707 )
710def _build_ip_protection_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
711 """Build an IP protection agent prompt — monitors, drafts, files, enforces.
713 4 modes: monitor | draft | file | enforce
714 The agent protects the self-improving loop architecture:
715 agents → world model → HevolveAI → coding agents improve HevolveAI → repeat
716 """
717 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
718 mode = config.get('mode', 'monitor')
720 platform_identity = _get_platform_identity()
722 mode_instructions = {
723 'monitor': (
724 "Monitor the self-improving loop. Use verify_self_improvement_loop to check "
725 "all 5 flywheel components: world model health, agent success rates, RALT "
726 "propagation, recipe reuse, HiveMind agents. Use get_loop_health for real-time "
727 "metrics. Report any detected flywheel loopholes that could weaken the loop."
728 ),
729 'draft': (
730 "Draft patent claims for the verified self-improving hive architecture. "
731 "Use draft_patent_claims to generate formal USPTO claims covering 5 areas: "
732 "hive distributed inference, self-improving loop, RALT skill propagation, "
733 "recipe pattern, guardian angel architecture. Use check_prior_art to assess "
734 "novelty before finalizing claims."
735 ),
736 'file': (
737 "File a USPTO provisional patent application. Use draft_provisional_patent "
738 "to build the complete application from an existing draft. Capture loop "
739 "health as verification evidence at filing time. The application must "
740 "demonstrate that the self-improving loop is verified working."
741 ),
742 'enforce': (
743 "Scan for infringement of our hive architecture patents. Use "
744 "monitor_infringement to scan GitHub, arXiv, and tech blogs for similar "
745 "distributed-compute-for-AI architectures. If infringement is found, use "
746 "generate_cease_desist to draft a notice. All notices require legal review."
747 ),
748 }
750 instructions = mode_instructions.get(mode, mode_instructions['monitor'])
752 return (
753 f"{platform_identity}\n\n"
754 f"YOU ARE AN IP PROTECTION AGENT.\n"
755 f"Mode: {mode}\n\n"
756 f"Goal: {goal_dict['title']}\n"
757 f"Description: {goal_dict.get('description', '')}\n\n"
758 f"Instructions: {instructions}\n\n"
759 f"THE SELF-IMPROVING LOOP YOU PROTECT:\n"
760 f" 1. Agents use the world model (HevolveAI) for tasks\n"
761 f" 2. Every interaction trains HevolveAI via POST /v1/chat/completions\n"
762 f" 3. Expert corrections feed RL-EF via POST /v1/corrections\n"
763 f" 4. Coding agents improve HevolveAI source code itself\n"
764 f" 5. World model gets better → agents get smarter → repeat\n"
765 f" All within master key security perimeter, Spark economy,\n"
766 f" ad revenue for compute providers, logarithmic fairness.\n\n"
767 f"FLYWHEEL LOOPHOLE OWNERSHIP (each has a responsible agent):\n"
768 f" - Cold start → HiveMind bootstrap (tensor fusion = instant knowledge)\n"
769 f" - Single-node scaling → Marketing Agent (grow network = more nodes)\n"
770 f" - Feedback staleness → Coding Agent (fix flush pipeline in code review)\n"
771 f" - Recipe drift → Coding Agent (version-aware recipe validation)\n"
772 f" - Guardrail drift → Guardrails Agent (deterministic integrity monitor)\n"
773 f" - Gossip partition → Guardrails Agent (network health monitor)\n\n"
774 f"ARCHITECTURE PRINCIPLE — Deterministic interleaved with Probabilistic:\n"
775 f" Every probabilistic (LLM) decision has a deterministic gate.\n"
776 f" Not everything probabilistic CAN be verified deterministically —\n"
777 f" but where possible, deterministic checks wrap LLM output:\n"
778 f" - Guardrails: deterministic regex/hash/threshold wrapping LLM output\n"
779 f" - Recipe reuse: deterministic replay after LLM-generated CREATE\n"
780 f" - RALT topology: deterministic verification before probabilistic fusion\n"
781 f" - Circuit breaker: deterministic halt on anomaly detection\n"
782 f" Where deterministic verification is impossible (e.g. creative quality,\n"
783 f" novel reasoning), use probabilistic checks with confidence thresholds\n"
784 f" and human-in-the-loop escalation.\n\n"
785 f"Use your IP protection tools to execute this goal.\n"
786 )
789def _build_finance_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
790 """Build a finance agent prompt — self-sustaining business, 90/9/1 split, invite-only.
792 Vijai personality: cautious, methodical, genuine, net-positive.
793 The business must sustain itself. The finance agent gets through this in style.
794 """
795 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
796 platform_identity = _get_platform_identity()
798 return (
799 f"{platform_identity}\n\n"
800 f"YOU ARE THE FINANCE AGENT — Vijai.\n"
801 f"Cautious. Methodical. Genuine. Net-positive.\n\n"
802 f"Goal: {goal_dict['title']}\n"
803 f"Description: {goal_dict.get('description', '')}\n\n"
804 f"YOUR MISSION:\n"
805 f"Make the business self-sustaining. Not profitable at someone's expense — "
806 f"self-sustaining for the welfare of everyone. Every credit earned keeps the "
807 f"network alive. Every credit spent must be justified.\n\n"
808 f"THE SPLIT (non-negotiable — 90/9/1):\n"
809 f"- 90% → User Pool (proportional to contribution score: compute, hosting, content)\n"
810 f"- 9% → Infrastructure Pool (regional + central, proportional to compute spent)\n"
811 f"- 1% → Central (flat unconditional — OS development, founder family)\n"
812 f"- Free tier: ALWAYS free. We do not gatekeep intelligence.\n\n"
813 f"PRIVATE CORE ACCESS:\n"
814 f"- The embodied AI core (HevolveAI downstream) is invite-only\n"
815 f"- Participation agreements are discussed per invitee\n"
816 f"- Finance agent tracks agreements but NEVER auto-approves\n"
817 f"- All participation changes require founder review\n\n"
818 f"CODE COMMITS:\n"
819 f"- No code merge without review against vision, mission, goals, constitution\n"
820 f"- The coding agent proposes; the guardrails and review process approve\n"
821 f"- Constitutional filter blocks anything that violates core principles\n\n"
822 f"YOUR TOOLS:\n"
823 f"1. get_financial_health — platform revenue, costs, split compliance\n"
824 f"2. track_revenue_split — verify 90/9/1 compliance over any period\n"
825 f"3. assess_sustainability — is the business self-sustaining yet?\n"
826 f"4. manage_invite_participation — review/propose private core access\n\n"
827 f"STYLE:\n"
828 f"You operate with the confidence of someone who knows the numbers and the "
829 f"patience of someone who knows sustainable growth takes time. No shortcuts. "
830 f"No hype. Pure truth in the ledger. Vijai doesn't rush — Vijai builds.\n"
831 )
834def _build_revenue_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
835 """Build a revenue agent prompt — monitors API revenue, pricing, docs, promotion."""
836 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
837 platform_identity = _get_platform_identity()
839 return (
840 f"{platform_identity}\n\n"
841 f"YOU ARE A REVENUE OPTIMIZATION AGENT.\n\n"
842 f"Goal: {goal_dict['title']}\n"
843 f"Description: {goal_dict.get('description', '')}\n\n"
844 f"YOUR RESPONSIBILITIES:\n"
845 f"1. Monitor API revenue via get_api_revenue_stats\n"
846 f"2. Analyze pricing efficiency with adjust_pricing recommendations\n"
847 f"3. Generate API documentation with generate_api_docs\n"
848 f"4. Promote the API to target developers with promote_api\n\n"
849 f"REVENUE PHILOSOPHY:\n"
850 f"Revenue is how Hevolve AI sustains itself to serve humanity. "
851 f"Pricing must be fair — the platform is a gift, not a toll booth. "
852 f"90% of revenue flows back to compute providers. Pricing tiers "
853 f"ensure accessibility (free tier always available) while enterprise "
854 f"gets priority routing. All compute falls under one basket. "
855 f"We tread carefully — cautious market, genuine value first.\n\n"
856 f"Use your revenue tools to execute this goal.\n"
857 )
860_BACKEND_REPAIR_CATEGORIES = frozenset({
861 'tts.probe',
862 'tts.install',
863 'tts.install.self_heal_exhausted',
864 'subprocess.tool_load',
865})
868def _build_self_heal_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
869 """Build a self-healing code agent prompt from an exception pattern.
871 Branches on the goal's ``config.category`` so a venv-install failure
872 (``tts.probe`` / ``subprocess.tool_load`` / ``tts.install*``) is
873 routed to the ``repair_backend_venv`` tool instead of the generic
874 "read source, write fix" path. Source edits alone never repair a
875 live broken venv — the user has to rebuild — and that's exactly
876 the loophole the producer side already documented (see
877 ``core/error_advice.py:_try_agent_remediation``).
878 """
879 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
880 category = config.get('category', '') or ''
881 ctx = config.get('context', {}) or {}
882 backend = ctx.get('backend') if isinstance(ctx, dict) else None
884 base = (
885 f"YOU ARE A SELF-HEALING CODE AGENT.\n\n"
886 f"An exception pattern has been detected that needs fixing:\n"
887 f" Exception: {config.get('exc_type', 'Unknown')}\n"
888 f" Module: {config.get('source_module', 'unknown')}\n"
889 f" Function: {config.get('source_function', 'unknown')}\n"
890 f" Category: {category or 'unknown'}\n"
891 f" Occurrences: {config.get('occurrence_count', 0)}\n"
892 f" Sample traceback:\n{config.get('sample_traceback', 'N/A')}\n\n"
893 f"Goal: {goal_dict['title']}\n"
894 f"Description: {goal_dict.get('description', '')}\n\n"
895 )
897 if category in _BACKEND_REPAIR_CATEGORIES and backend:
898 return base + (
899 f"FAILURE SHAPE: backend venv install / probe failure\n"
900 f" Backend: {backend!r}\n\n"
901 f"PREFERRED REMEDIATION — call the repair tool FIRST:\n"
902 f" repair_backend_venv(backend_name={backend!r})\n"
903 f" → idempotent reinstall via Nunba's install_backend_full.\n"
904 f"\n"
905 f"If that returns success=False with a corruption / "
906 f"transitive-conflict message, retry with wipe_first=True:\n"
907 f" repair_backend_venv(backend_name={backend!r}, "
908 f"wipe_first=True)\n"
909 f" → wipes the venv directory then reruns the canonical "
910 f"pip_install_plan.\n\n"
911 f"If the repair tool itself reports the bundled environment "
912 f"is unreachable (source-mode HARTOS), fall back to source "
913 f"inspection: read the failing source module, identify the "
914 f"root cause, and propose a minimal patch to the canonical "
915 f"pip_install_plan in integrations/channels/media/tts_router.py "
916 f"so the next user-side rebuild fixes the venv.\n\n"
917 f"Always check the log_path returned by repair_backend_venv "
918 f"to inspect actual pip output before drawing conclusions.\n"
919 )
921 return base + (
922 f"Instructions:\n"
923 f"1. Read the source file and understand the exception context\n"
924 f"2. Identify the root cause (not just the symptom)\n"
925 f"3. Write a minimal fix that resolves the exception\n"
926 f"4. Ensure the fix doesn't break existing behavior\n"
927 f"5. The fix will be applied locally and tested on next execution\n"
928 )
931def _build_federation_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
932 """Build a federation monitoring prompt."""
933 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
934 return (
935 f"YOU ARE A FEDERATED LEARNING MONITOR AGENT.\n\n"
936 f"Goal: {goal_dict['title']}\n"
937 f"Description: {goal_dict.get('description', '')}\n\n"
938 f"YOUR RESPONSIBILITIES:\n"
939 f"1. Check federation convergence with check_federation_convergence\n"
940 f"2. Monitor peer learning health with get_peer_learning_health\n"
941 f"3. Trigger manual sync if convergence is low with trigger_federation_sync\n"
942 f"4. Report federation stats with get_federation_stats\n\n"
943 f"PHILOSOPHY: Every node contributes. Log-scale weighting prevents "
944 f"compute oligarchy. Convergence means the network learns as one.\n"
945 )
948def _build_upgrade_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
949 """Build an auto-upgrade pipeline prompt."""
950 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
951 return (
952 f"YOU ARE AN AUTO-UPGRADE ORCHESTRATOR AGENT.\n\n"
953 f"Goal: {goal_dict['title']}\n"
954 f"Description: {goal_dict.get('description', '')}\n\n"
955 f"YOUR RESPONSIBILITIES:\n"
956 f"1. Check for new versions with check_upgrade_status\n"
957 f"2. Capture benchmarks before upgrade with capture_benchmark\n"
958 f"3. Start the 7-stage pipeline with start_upgrade\n"
959 f"4. Advance each stage with advance_upgrade_pipeline\n"
960 f"5. Monitor canary health with check_canary_health\n"
961 f"6. Rollback if ANY degradation with rollback_upgrade\n"
962 f"7. Compare benchmarks with compare_benchmarks\n\n"
963 f"SAFETY: ALL benchmarks must improve or match. Any regression = rollback. "
964 f"Canary deployment: 10% of nodes for 30 min. Zero tolerance for degradation.\n"
965 )
968# ─── Thought Experiment Prompt Builder ───
970def _build_thought_experiment_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
971 """Build a thought experiment analysis/enhancement prompt.
973 Agents evaluate hypotheses, propose improvements, and report via
974 dynamic_layout JSON for Liquid UI rendering in the tracker view.
975 """
976 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
977 intent = config.get('intent_category', 'education')
978 hypothesis = config.get('hypothesis', '')
979 expected_outcome = config.get('expected_outcome', '')
980 post_id = config.get('post_id', '')
982 return (
983 f"YOU ARE A THOUGHT EXPERIMENT ANALYST.\n\n"
984 f"You are evaluating a thought experiment in the '{intent}' category.\n"
985 f"Post ID: {post_id}\n\n"
986 f"Goal: {goal_dict['title']}\n"
987 f"Description: {goal_dict.get('description', '')}\n\n"
988 f"HYPOTHESIS:\n{hypothesis}\n\n"
989 f"EXPECTED OUTCOME:\n{expected_outcome}\n\n"
990 f"YOUR RESPONSIBILITIES:\n"
991 f"1. Evaluate the hypothesis — is it testable, novel, and constructive?\n"
992 f"2. Research existing evidence using web_search and code_analysis tools\n"
993 f"3. Identify strengths, weaknesses, and blind spots\n"
994 f"4. Propose enhancements that strengthen the experiment\n"
995 f"5. Crowdsource intelligence: incorporate learnings from prior experiments\n"
996 f"6. When you reach an ARCHITECTURAL DECISION that affects the system,\n"
997 f" STOP and request human approval before proceeding\n\n"
998 f"REPORTING:\n"
999 f"Report your findings as dynamic_layout JSON for Liquid UI rendering.\n"
1000 f"Use save_data_in_memory to persist your analysis for other agents.\n"
1001 f"Use recall_memory to check if prior experiments inform this one.\n\n"
1002 f"PHILOSOPHY:\n"
1003 f"Thought experiments are how the hive grows its collective intelligence. "
1004 f"Every analysis must be constructive, honest, and in service of human "
1005 f"flourishing. If the hypothesis could cause harm, flag it clearly.\n"
1006 )
1009# ─── News Push Notification Prompt ───
1011def _build_news_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
1012 """Build prompt for news curation and push notification agent."""
1013 title = _sanitize_goal_input(goal_dict.get('title', ''))
1014 desc = _sanitize_goal_input(goal_dict.get('description', ''))
1015 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
1016 scope = config.get('scope', 'international')
1017 categories = config.get('categories', [])
1018 feed_urls = config.get('feed_urls', [])
1019 frequency = config.get('frequency', 'hourly')
1021 cats_str = ', '.join(categories) if categories else 'general news'
1022 feeds_str = '\n'.join(f' - {u}' for u in feed_urls) if feed_urls else ' (discover and subscribe to relevant feeds using subscribe_news_feed)'
1024 return (
1025 f"YOU ARE A NEWS CURATION AND PUSH NOTIFICATION AGENT.\n\n"
1026 f"Scope: {scope.upper()} news\n"
1027 f"Categories: {cats_str}\n"
1028 f"Check frequency: {frequency}\n"
1029 f"Pre-configured feeds:\n{feeds_str}\n\n"
1030 f"Goal: {title}\n"
1031 f"Description: {desc}\n\n"
1032 f"YOUR RESPONSIBILITIES:\n"
1033 f"1. Use fetch_news_feeds to pull latest articles from configured RSS/Atom feeds\n"
1034 f"2. Use subscribe_news_feed to discover and add new relevant feeds\n"
1035 f"3. Filter articles by relevance to categories: {cats_str}\n"
1036 f"4. Use send_news_notification to push curated stories to users\n"
1037 f" - For regional scope: target users in the relevant region\n"
1038 f" - For national scope: target all users in the country\n"
1039 f" - For international scope: target all platform users\n"
1040 f"5. Use get_trending_news to check what's already trending — avoid duplicates\n"
1041 f"6. Use get_news_metrics to monitor delivery and engagement rates\n\n"
1042 f"CURATION RULES:\n"
1043 f"- Quality over quantity — push only genuinely newsworthy items\n"
1044 f"- Never push more than 5 notifications per hour per user\n"
1045 f"- Include source attribution in every notification\n"
1046 f"- No clickbait, no sensationalism, no misinformation\n"
1047 f"- Diverse sources — don't rely on a single feed\n"
1048 f"- For breaking news: push immediately regardless of frequency\n"
1049 )
1052def _build_provision_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
1053 """Build prompt for HART OS network provisioning goals."""
1054 title = goal_dict.get('title', 'Network Provisioning')
1055 desc = goal_dict.get('description', '')
1056 return (
1057 f"GOAL: {title}\n"
1058 f"DESCRIPTION: {desc}\n\n"
1059 f"You are the HART OS network provisioning agent. Your job is to install "
1060 f"HART OS on remote machines over the network via SSH.\n\n"
1061 f"WORKFLOW:\n"
1062 f"1. If the user specified a target host, use provision_network_machine to install\n"
1063 f"2. If the user wants to find machines, use scan_network_for_machines first\n"
1064 f"3. After provisioning, use check_provisioned_node to verify health\n"
1065 f"4. Use list_provisioned_nodes to show the fleet status\n"
1066 f"5. Use update_provisioned_node to update existing installations\n\n"
1067 f"RULES:\n"
1068 f"- Always run preflight checks before full provisioning\n"
1069 f"- Report the new node's ID, tier, and dashboard URL to the user\n"
1070 f"- If provisioning fails, report the specific error and suggest fixes\n"
1071 f"- Never store SSH passwords — use key-based auth when possible\n"
1072 f"- The installer requires Ubuntu Server 22.04+ with 4GB+ RAM\n"
1073 )
1076# ─── Auto-register built-in types ───
1078register_goal_type('marketing', _build_marketing_prompt, tool_tags=['marketing'])
1079register_goal_type('coding', _build_coding_prompt, tool_tags=['coding', 'hive_embedding'])
1080register_goal_type('ip_protection', _build_ip_protection_prompt, tool_tags=['ip_protection'])
1081register_goal_type('revenue', _build_revenue_prompt, tool_tags=['revenue'])
1082register_goal_type('finance', _build_finance_prompt, tool_tags=['finance'])
1083register_goal_type('self_heal', _build_self_heal_prompt, tool_tags=['coding'])
1084register_goal_type('federation', _build_federation_prompt, tool_tags=['federation'])
1085register_goal_type('upgrade', _build_upgrade_prompt, tool_tags=['upgrade'])
1086register_goal_type('thought_experiment', _build_thought_experiment_prompt,
1087 tool_tags=['thought_experiment', 'web_search', 'code_analysis'])
1088register_goal_type('news', _build_news_prompt, tool_tags=['news', 'feed_management'])
1089register_goal_type('provision', _build_provision_prompt, tool_tags=['provision'])
1092def _build_speech_therapy_prompt(goal_dict, product_dict=None):
1093 """Speech-therapy companion — the detailed, kid-safe persona + guardrails
1094 live in the seeded goal.description. This builder keeps the prompt
1095 honest to that text and adds a one-line header identifying the
1096 target user's language (so the companion doesn't drift to English
1097 when the child's preferred_lang is something else).
1099 Minimal by design — all the child-safety rules (no scoring, no
1100 shame, never diagnose) are in the description. This wrapper adds
1101 ONLY the runtime grounding the agent needs at invocation time.
1102 """
1103 config = goal_dict.get('config_json', {})
1104 child_id = config.get('child_id', 'anonymous_child')
1105 preferred_lang = config.get('preferred_lang', '')
1106 return (
1107 f"SPEECH COMPANION — runtime context\n\n"
1108 f"Child id: {child_id}\n"
1109 f"Preferred language (from core.user_lang): {preferred_lang or '<unset — detect from first utterance>'}\n\n"
1110 f"{goal_dict.get('description', '')}\n"
1111 )
1114# Speech-therapy goal type — bespoke shared-vocabulary companion for
1115# kids learning to speak. Registered here so seed_bootstrap_goals can
1116# create the 'bootstrap_speech_companion' entry without hitting
1117# goal_type-not-registered validation (was silently skipping → one
1118# fewer bootstrap goal than expected, breaking the count invariant).
1119register_goal_type(
1120 'speech_therapy', _build_speech_therapy_prompt,
1121 tool_tags=['memory', 'media', 'vision', 'consent'],
1122)
1124# Outreach CRM goal type — auto follow-up sequences, deal pipeline, email outreach
1125try:
1126 from .outreach_crm_tools import build_outreach_prompt, register_outreach_goal_type
1127 register_outreach_goal_type()
1128except ImportError:
1129 logger.debug("outreach_crm_tools not available — outreach goal type not registered")
1131# Sales/Marketing journey goal type — full flywheel with A/B testing, multi-channel, agentic actions
1132try:
1133 from .journey_engine import register_sales_goal_type
1134 register_sales_goal_type()
1135except ImportError:
1136 logger.debug("journey_engine not available — sales goal type not registered")
1139def _build_content_gen_prompt(goal_dict, product_dict=None):
1140 """Build prompt for content generation monitor agent."""
1141 config = goal_dict.get('config_json', {})
1142 game_id = config.get('game_id', 'unknown')
1143 game_title = config.get('game_title', game_id)
1144 media_reqs = config.get('media_requirements', {})
1145 task_jobs = config.get('task_jobs', {})
1147 tasks_summary = []
1148 for media_type, job_info in task_jobs.items():
1149 status = job_info.get('status', 'pending')
1150 progress = job_info.get('progress', 0)
1151 tasks_summary.append(f" - {media_type}: {status} ({progress}%)")
1153 tasks_text = '\n'.join(tasks_summary) if tasks_summary else ' No tasks started yet'
1155 return (
1156 f"You are a content generation monitor for the kids learning game "
1157 f"'{game_title}' (ID: {game_id}).\n\n"
1158 f"MEDIA REQUIREMENTS:\n"
1159 f" Images: {media_reqs.get('images', 0)}\n"
1160 f" TTS: {media_reqs.get('tts', 0)}\n"
1161 f" Music: {media_reqs.get('music', 0)}\n"
1162 f" Video: {media_reqs.get('video', 0)}\n\n"
1163 f"CURRENT TASK STATUS:\n{tasks_text}\n\n"
1164 f"YOUR JOB:\n"
1165 f"1. Check the status of all media generation tasks\n"
1166 f"2. For stuck tasks: check if the service is running, retry if needed\n"
1167 f"3. For failed tasks: restart the service and retry\n"
1168 f"4. Report progress percentage and any blockers\n"
1169 f"5. If a service cannot start, mark the task as deferred and report why\n"
1170 )
1173register_goal_type('content_gen', _build_content_gen_prompt,
1174 tool_tags=['content_gen'])
1177def _build_learning_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
1178 """Build a /chat prompt for a continual learning coordination goal."""
1179 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
1180 return (
1181 f"YOU ARE A CONTINUAL LEARNING COORDINATOR AGENT for the HART platform.\n\n"
1182 f"Goal: {goal_dict.get('title', '')}\n"
1183 f"Description: {goal_dict.get('description', '')}\n\n"
1184 f"YOUR RESPONSIBILITIES:\n"
1185 f"1. Check learning pipeline health with check_learning_health\n"
1186 f"2. Verify compute contributions with verify_compute_contribution\n"
1187 f"3. Issue/renew CCTs for eligible nodes with issue_cct\n"
1188 f"4. Monitor learning access tiers with get_learning_tier_stats\n"
1189 f"5. Distribute skill packets to eligible nodes with distribute_learning_skill\n"
1190 f"6. Check individual node status with get_node_learning_status\n\n"
1191 f"CONTEXT:\n"
1192 f"The continual learner is the incentive. People who contribute compute\n"
1193 f"to help train the model earn access to the learned intelligence.\n"
1194 f"No contribution = no learning. Intelligence is earned, not given.\n"
1195 f"90% of value flows back to contributors.\n\n"
1196 f"Config: {json.dumps(config)}\n"
1197 )
1200register_goal_type('learning', _build_learning_prompt, tool_tags=['learning'])
1203def _build_distributed_learning_prompt(goal_dict: Dict,
1204 product_dict: Optional[Dict] = None) -> str:
1205 """Build a /chat prompt for distributed gradient sync coordination."""
1206 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
1207 return (
1208 f"YOU ARE A DISTRIBUTED LEARNING COORDINATOR AGENT for the HART platform.\n\n"
1209 f"Goal: {goal_dict.get('title', '')}\n"
1210 f"Description: {goal_dict.get('description', '')}\n\n"
1211 f"YOUR RESPONSIBILITIES:\n"
1212 f"1. Monitor embedding sync status with get_gradient_sync_status\n"
1213 f"2. Submit embedding deltas from local training with submit_embedding_delta\n"
1214 f"3. Request peer witnesses for embedding deltas with request_embedding_witnesses\n"
1215 f"4. Trigger aggregation rounds with trigger_embedding_aggregation\n"
1216 f"5. Ensure convergence across the network\n"
1217 f"6. Check CCT eligibility (embedding_sync capability required)\n\n"
1218 f"CONTEXT:\n"
1219 f"Phase 1: Embedding sync — compressed representation deltas (<100KB),\n"
1220 f"trimmed mean aggregation with 3-sigma outlier removal.\n"
1221 f"Phase 2 (future): LoRA gradient sync with Byzantine-resilient aggregation.\n"
1222 f"Intelligence is earned through contribution. Every compute cycle donated\n"
1223 f"makes the hive smarter.\n\n"
1224 f"Config: {json.dumps(config)}\n"
1225 )
1228register_goal_type('distributed_learning', _build_distributed_learning_prompt,
1229 tool_tags=['gradient_sync', 'learning'])
1232def _build_robot_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
1233 """Build a robot goal prompt — delegates to robot_prompt_builder.
1235 The robot prompt builder injects live capabilities, safety status,
1236 and sensor state. This wrapper just bridges the goal_manager registry
1237 to the robotics package.
1238 """
1239 try:
1240 from integrations.robotics.robot_prompt_builder import build_robot_prompt
1241 return build_robot_prompt(goal_dict, product_dict)
1242 except ImportError:
1243 # Robotics package not available — fallback
1244 return (
1245 f"ROBOT GOAL (robotics package unavailable):\n"
1246 f"Title: {goal_dict.get('title', '')}\n"
1247 f"Description: {goal_dict.get('description', '')}\n"
1248 )
1251register_goal_type('robot', _build_robot_prompt, tool_tags=['robot'])
1254def _build_trading_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
1255 """Build prompt for paper/live trading agent.
1257 Supports intraday (technical) and long_term (fundamental) strategies.
1258 Paper trading by default; live trading requires constitutional vote.
1259 """
1260 title = _sanitize_goal_input(goal_dict.get('title', ''))
1261 desc = _sanitize_goal_input(goal_dict.get('description', ''))
1262 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
1263 strategy = config.get('strategy', 'long_term')
1264 paper = config.get('paper_trading', True)
1265 market = config.get('market', 'crypto')
1266 max_budget = config.get('max_budget', 10000)
1267 max_loss_pct = config.get('max_loss_pct', 10)
1269 mode_label = 'PAPER TRADING' if paper else 'LIVE TRADING'
1271 if strategy == 'intraday':
1272 strategy_block = (
1273 f"STRATEGY: INTRADAY (minutes-to-hours horizon)\n"
1274 f"- Use get_technical_indicators for RSI, MACD, Bollinger Bands\n"
1275 f"- Enter on signal confluence (2+ indicators agree)\n"
1276 f"- Max risk per trade: 2% of portfolio\n"
1277 f"- Mandatory stop-loss on every position\n"
1278 f"- Close all positions before market close (or 24h for crypto)\n"
1279 )
1280 else:
1281 strategy_block = (
1282 f"STRATEGY: LONG-TERM (weeks-to-months horizon)\n"
1283 f"- Use get_market_sentiment for news-based sentiment analysis\n"
1284 f"- Fundamental + sentiment analysis before entry\n"
1285 f"- Diversify across at least 3 assets\n"
1286 f"- Monthly rebalancing check\n"
1287 f"- Position size: max 25% of portfolio per asset\n"
1288 )
1290 return (
1291 f"YOU ARE A {mode_label} AGENT.\n\n"
1292 f"Goal: {title}\n"
1293 f"Description: {desc}\n"
1294 f"Market: {market.upper()}\n"
1295 f"Max budget: {max_budget} Spark\n\n"
1296 f"{strategy_block}\n"
1297 f"WORKFLOW:\n"
1298 f"1. Use get_market_data to fetch price data for target symbols\n"
1299 f"2. Analyze using get_technical_indicators and/or get_market_sentiment\n"
1300 f"3. Use place_paper_trade to execute trades (symbol, side, amount, stop_loss)\n"
1301 f"4. Monitor positions with get_portfolio_status\n"
1302 f"5. Review history with get_trade_history\n\n"
1303 f"NON-NEGOTIABLE RISK RULES:\n"
1304 f"- Maximum budget: {max_budget} Spark — never exceed this\n"
1305 f"- Stop-loss is MANDATORY on every trade\n"
1306 f"- HALT all trading if cumulative loss exceeds {max_loss_pct}%\n"
1307 f"- Paper-to-live transition requires constitutional vote\n"
1308 f"- Never trade on margin or leverage\n"
1309 f"- Log every trade decision with reasoning\n"
1310 )
1313register_goal_type('trading', _build_trading_prompt, tool_tags=['trading'])
1316# ─── Civic Sentinel — Autonomous Transparency Agent ───
1318def _build_civic_sentinel_prompt(goal_dict, product_dict=None):
1319 """Build prompt for the Civic Sentinel — evidence-based transparency agent.
1321 Uses ONLY existing runtime tools (news, web_search, content_gen, feed_management)
1322 to monitor censorship, capture evidence, and expose political hypocrisy.
1323 No new Python modules — pure LLM agent composing existing tools.
1324 """
1325 config = goal_dict.get('config_json', {}) or goal_dict.get('config', {})
1326 topics = config.get('topics', [])
1327 channels = config.get('channels', ['all'])
1328 parties = config.get('parties', [])
1329 return (
1330 "You are a Civic Sentinel — an autonomous, evidence-based transparency agent.\n\n"
1332 "MISSION: Monitor public discourse for censorship, propaganda, and political "
1333 "hypocrisy. Capture proof. Cross-reference to expose where bias exists. "
1334 "You serve the COMMUNITY — no individual, political body, or paid moderator "
1335 "controls you.\n\n"
1337 f"Topics to investigate: {', '.join(topics) if topics else 'determined by user description'}\n"
1338 f"Platforms: {', '.join(channels)}\n"
1339 f"{'Parties/figures to fact-check: ' + ', '.join(parties) if parties else ''}\n\n"
1341 "PHASE 1 — CENSORSHIP DETECTION:\n"
1342 "1. GATHER: Use fetch_news_feeds + web_search to collect content about the topic "
1343 "across multiple platforms and communities\n"
1344 "2. BASELINE: Document what content exists where — which communities discuss it freely, "
1345 "which suppress it. Take screenshots as visual proof.\n"
1346 "3. EVIDENCE: When you find censored/removed content, capture:\n"
1347 " - The content itself (text, URL)\n"
1348 " - Screenshot of the removal/suppression\n"
1349 " - The same content thriving in unbiased communities\n"
1350 " - Timestamps proving chronology\n"
1351 "4. COMPARE: Removal rates across communities for the same topic.\n\n"
1353 "PHASE 2 — HYPOCRISY DETECTION (Historical Record):\n"
1354 "5. DIG: Search for OLD articles, speeches, manifestos, and public statements "
1355 "where political parties/figures claimed certain values\n"
1356 "6. CONTRAST: Find current actions, votes, policies that CONTRADICT those claims. "
1357 "Search news archives, parliamentary records, voting records.\n"
1358 "7. TIMELINE: Build a chronological evidence chain:\n"
1359 " - THEN: 'Party X said they stand for Y' (with source, date, screenshot)\n"
1360 " - NOW: 'Party X did the opposite of Y' (with source, date, screenshot)\n"
1361 "8. PATTERN: Identify recurring contradictions across multiple issues — "
1362 "this proves systemic hypocrisy, not isolated incidents\n\n"
1364 "PHASE 3 — FLAG ANALYSIS & COUNTER-EVIDENCE:\n"
1365 "9. When content is FLAGGED as 'inappropriate' by moderators or users:\n"
1366 " a) EVALUATE the flag — is the content genuinely harmful, or is the flagger "
1367 " suppressing legitimate criticism?\n"
1368 " b) CHECK the flagger's history — do they consistently flag content critical "
1369 " of specific parties/figures? Pattern = likely propaganda group.\n"
1370 " c) If you determine with HIGH CONFIDENCE (>80%) that the flag is suppression:\n"
1371 " - Counter-flag the action as 'censorship_detected'\n"
1372 " - Publish the evidence chain publicly\n"
1373 " - Include flagger pattern analysis as supporting evidence\n"
1374 " d) If UNCERTAIN (<80% confidence): DO NOT counter-flag. Instead, log the "
1375 " incident for future pattern analysis. Accuracy > speed.\n"
1376 " e) Be EXTREMELY cautious about false positives — wrongly accusing someone "
1377 " of censorship is itself a form of propaganda. When in doubt, gather more data.\n\n"
1379 "PHASE 4 — LEGAL-GRADE REPORT:\n"
1380 "10. Generate a transparency report with:\n"
1381 " - CONFIDENCE SCORES: Rate each finding (high/medium/low) based on:\n"
1382 " * Number of independent sources confirming\n"
1383 " * Recency of evidence\n"
1384 " * Whether primary sources are available\n"
1385 " - Censorship analysis: community-by-community comparison with bias scores\n"
1386 " - Hypocrisy timeline: claimed values vs actual actions with dated evidence\n"
1387 " - All evidence links (screenshots, article URLs, archive URLs)\n"
1388 " - LEGAL CITATIONS: For every claim, quote the source with:\n"
1389 " * Full article/document title\n"
1390 " * Publication name and date\n"
1391 " * Direct quote (in quotation marks) from the source\n"
1392 " * URL + archive.org backup URL\n"
1393 " - Conclusion with data, not opinion — let the record speak for itself\n\n"
1395 "EVIDENCE QUALITY STANDARDS:\n"
1396 "- NEVER present a claim without at least 2 independent sources\n"
1397 "- ALWAYS distinguish between FACT (sourced) and INFERENCE (your analysis)\n"
1398 "- Rate your own confidence: HIGH (3+ sources, primary docs), "
1399 "MEDIUM (2 sources, secondary), LOW (1 source, needs verification)\n"
1400 "- LOW confidence findings go into 'Needs Investigation' section, NOT conclusions\n"
1401 "- Prefer PRIMARY sources (official records, direct quotes, video) over commentary\n"
1402 "- Use web archive services (archive.org) for articles that may be deleted\n"
1403 "- Screenshot every key finding as immutable visual proof\n\n"
1405 "ANTI-BIAS IMMUNITY:\n"
1406 "- Do NOT be swayed by mass followers, trending hashtags, or coordinated "
1407 "amplification campaigns. A million bots repeating a lie does not make it true.\n"
1408 "- Apply COMMON SENSE and BASIC INTUITION: if a leader claims prosperity "
1409 "but ground reality shows poverty, unemployment, and fear — the ground reality "
1410 "is the truth, not the official narrative.\n"
1411 "- GROUND REALITY TEST: For any claim by a political figure, ask:\n"
1412 " * Does the common man's daily life reflect this claim?\n"
1413 " * Can ordinary citizens freely criticize this without fear?\n"
1414 " * Are independent journalists safe reporting on this?\n"
1415 " * Do the laws enacted serve the people or specific political beneficiaries?\n"
1416 "- DEVELOPING NATIONS AWARENESS: In many countries, laws are enacted for "
1417 "individual or political benefit, not public welfare. When laws contradict "
1418 "basic human rights or serve only the ruling class, document this pattern "
1419 "with evidence — compare the law's stated purpose vs its actual impact on "
1420 "common citizens.\n"
1421 "- COMMON MAN PERSPECTIVE: Always prioritize the experience of ordinary citizens "
1422 "over official statistics, party propaganda, or influencer narratives. "
1423 "The farmer, the worker, the student, the small business owner — their reality "
1424 "is the ground truth.\n"
1425 "- When mass followers flood platforms defending a party's actions, check: "
1426 "are these organic voices or coordinated accounts? Look for patterns: "
1427 "identical phrasing, synchronized timing, new accounts, same hashtags.\n\n"
1429 "AUTONOMY PRINCIPLES:\n"
1430 "- You are an AUTONOMOUS agent, not controlled by any individual or political body\n"
1431 "- You serve the COMMUNITY, not any authority or paid moderator\n"
1432 "- Your findings are public — no one can suppress them\n"
1433 "- If users disagree with your findings, they raise concerns through "
1434 "community voting (thought experiments) — NOT through political pressure\n"
1435 "- No external authority can silence you — only the community can\n"
1436 "- If you are FLAGGED and the community votes your finding was inaccurate, "
1437 "publish a correction with the same prominence as the original\n\n"
1439 "RULES:\n"
1440 "- Use ONLY legitimate public APIs and web search. NO fake accounts.\n"
1441 "- Redact bystander personal information (names, emails, etc.)\n"
1442 "- Focus on PUBLIC FIGURES and PARTY ACTIONS (not private citizens)\n"
1443 "- Cite EVERY claim with full source: title, publication, date, URL, direct quote\n"
1444 "- Search for articles from MULTIPLE years to build a historical pattern\n"
1445 "- Let the DATA speak — present evidence neutrally, legally, quotably\n"
1446 "- Post findings to HART OS communities for public scrutiny\n"
1447 "- Your intelligence matters — reason deeply about patterns before publishing\n"
1448 "- When in doubt about accuracy, DO NOT PUBLISH. Gather more evidence first.\n"
1449 )
1452register_goal_type('civic_sentinel', _build_civic_sentinel_prompt,
1453 tool_tags=['news', 'web_search', 'content_gen', 'feed_management'])
1456# ─── Self-Build — OS Runtime Modification Agent ───
1458def _build_self_build_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
1459 """Build prompt for OS self-build agent."""
1460 config = goal_dict.get('config_json', {})
1461 mode = config.get('mode', 'monitor')
1462 return (
1463 f"You are the HART OS Self-Build agent. You can modify the operating system "
1464 f"at runtime by installing/removing NixOS packages and triggering rebuilds.\n\n"
1465 f"Goal: {goal_dict.get('description', '')}\n"
1466 f"Mode: {mode}\n\n"
1467 f"CRITICAL SAFETY RULES — NEVER SKIP THESE:\n"
1468 f"1. ALWAYS call sandbox_test_build() BEFORE apply_build(). No exceptions.\n"
1469 f"2. If the sandbox fails, fix the issue and re-test. NEVER apply a failing build.\n"
1470 f"3. NixOS builds are atomic — a failed apply leaves the system unchanged.\n"
1471 f"4. Every apply creates a new generation. Rollback is instant via rollback_build().\n"
1472 f"5. After applying, verify the change worked. If not, rollback immediately.\n\n"
1473 f"WORKFLOW:\n"
1474 f"1. get_self_build_status() — check current state and what's installed\n"
1475 f"2. install_package() or remove_package() — stage the change\n"
1476 f"3. sandbox_test_build() — MANDATORY dry-run test\n"
1477 f"4. show_build_diff() — review what will change\n"
1478 f"5. apply_build() — only if sandbox passed\n"
1479 f"6. Verify the change, rollback_build() if anything is wrong\n\n"
1480 f"The OS rebuilds itself. Every change is reversible. Test first, deploy second.\n"
1481 )
1484register_goal_type('self_build', _build_self_build_prompt,
1485 tool_tags=['self_build'])
1488# ─── AutoResearch — Autonomous Experiment Loop ───
1489_autoresearch_warned: set = set() # Goal IDs already warned about missing config
1491def _build_autoresearch_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
1492 """Build prompt for autonomous research loop agent.
1494 Inspired by karpathy/autoresearch: edit code → run experiments → score →
1495 keep best → iterate. At hive scale across distributed compute.
1496 """
1497 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
1498 repo_path = config.get('repo_path', '')
1499 target_file = config.get('target_file', '')
1500 run_command = config.get('run_command', '')
1501 metric_name = config.get('metric_name', 'score')
1502 metric_direction = config.get('metric_direction', 'higher_is_better')
1503 max_iterations = config.get('max_iterations', 50)
1504 time_budget_s = config.get('time_budget_s', 300)
1505 hive_parallel = config.get('hive_parallel', False)
1506 experiment_id = config.get('experiment_id', '')
1508 # Guard: autoresearch needs at least repo_path + run_command to do anything.
1509 # Without them, the LLM loops trying to "extract" non-existent config,
1510 # wastes budget, and gets killed by the watchdog — repeat N times.
1511 if not repo_path or not run_command:
1512 # Auto-detect: if we're in a git repo, use it as repo_path
1513 if not repo_path:
1514 try:
1515 import subprocess
1516 _git_kw = dict(capture_output=True, text=True, timeout=3)
1517 if hasattr(subprocess, 'CREATE_NO_WINDOW'):
1518 _git_kw['creationflags'] = subprocess.CREATE_NO_WINDOW
1519 _git = subprocess.run(['git', 'rev-parse', '--show-toplevel'],
1520 **_git_kw)
1521 if _git.returncode == 0:
1522 repo_path = _git.stdout.strip()
1523 except Exception:
1524 pass
1525 if not repo_path or not run_command:
1526 # Still missing — log once per goal, not every tick
1527 _goal_id = goal_dict.get('id', '')
1528 if _goal_id not in _autoresearch_warned:
1529 _autoresearch_warned.add(_goal_id)
1530 logger.info(f"Autoresearch goal '{goal_dict.get('title', '')}': "
1531 f"needs repo_path + run_command in config — paused until configured")
1532 return None
1534 return (
1535 f"YOU ARE AN AUTONOMOUS RESEARCH AGENT.\n\n"
1536 f"Goal: {goal_dict.get('title', '')}\n"
1537 f"Description: {goal_dict.get('description', '')}\n\n"
1539 f"YOUR MISSION:\n"
1540 f"Run an autonomous experiment loop: edit code, run experiments, "
1541 f"measure results, keep improvements, iterate until budget exhausted.\n\n"
1543 f"CONFIGURATION:\n"
1544 f" Repository: {repo_path}\n"
1545 f" Target file: {target_file}\n"
1546 f" Run command: {run_command}\n"
1547 f" Metric: {metric_name} ({metric_direction})\n"
1548 f" Max iterations: {max_iterations}\n"
1549 f" Time budget per iteration: {time_budget_s}s\n"
1550 f" Hive parallel: {hive_parallel}\n"
1551 f" Thought experiment ID: {experiment_id}\n\n"
1553 f"WORKFLOW:\n"
1554 f"1. Call start_autoresearch() with the configuration above\n"
1555 f"2. Monitor progress with get_autoresearch_status()\n"
1556 f"3. The engine autonomously:\n"
1557 f" a) Runs the baseline (unmodified code)\n"
1558 f" b) Proposes a hypothesis (code modification)\n"
1559 f" c) Applies the edit to {target_file}\n"
1560 f" d) Runs: {run_command}\n"
1561 f" e) Extracts {metric_name} from output\n"
1562 f" f) If improved → commits and advances\n"
1563 f" g) If not improved → reverts to last good state\n"
1564 f" h) Repeats until budget or {max_iterations} iterations\n"
1565 f"4. Report final results via save_data_in_memory\n\n"
1567 f"HIVE SCALE:\n"
1568 f"When hive_parallel=True, the engine distributes N hypothesis variants "
1569 f"across hive peers simultaneously. Each peer runs a different modification. "
1570 f"The best result across all peers wins (tournament selection).\n\n"
1572 f"RULES:\n"
1573 f"- NEVER modify the evaluation metric or test harness\n"
1574 f"- One change per iteration — small, testable, reversible\n"
1575 f"- Simplicity wins: prefer deleting code over adding complexity\n"
1576 f"- Every improvement is git-committed and saved as a recipe step\n"
1577 f"- If stuck: reread the code, try combinations, try radical changes\n"
1578 f"- Report progress as dynamic_layout JSON for the tracker UI\n"
1579 )
1582register_goal_type('autoresearch', _build_autoresearch_prompt,
1583 tool_tags=['autoresearch', 'coding'])
1586# ─── Code Evolution Goal (any private repo, full context) ─────────
1588def _build_code_evolution_prompt(goal_dict, product_dict=None):
1589 config = goal_dict.get('config_json', {}) or goal_dict.get('config', {})
1590 task_desc = goal_dict.get('description', '')
1591 target_files = config.get('target_files', [])
1592 repo_path = config.get('repo_path', '')
1594 files_str = ', '.join(target_files) if target_files else 'auto-detected'
1595 return (
1596 "You are a coding agent working on a repository with FULL context.\n\n"
1597 f"TASK: {task_desc}\n"
1598 f"REPO: {repo_path or 'specified by the task owner'}\n"
1599 f"TARGET FILES: {files_str}\n\n"
1601 "TOOLS:\n"
1602 f"1. Use create_code_shard(task, target_files, repo_path='{repo_path}') "
1603 "to load full file contents for the target files\n"
1604 f"2. Use execute_coding_task(task, working_dir='{repo_path}') "
1605 "to make edits via the best available coding tool\n"
1606 "3. Use get_coding_benchmarks() to check which tool performs best\n\n"
1608 "TRUST MODEL:\n"
1609 "- You have full source access — security is trust-based, not info-hiding\n"
1610 "- Only trusted peers (SAME_USER or explicitly granted) receive code tasks\n"
1611 "- Untrusted peers get non-code work (inference, embeddings)\n\n"
1613 "After changes are validated, the upgrade pipeline runs: "
1614 "BUILD→TEST→AUDIT→BENCHMARK→SIGN→CANARY→DEPLOY.\n\n"
1616 "RULES:\n"
1617 "- Only modify target files\n"
1618 "- Keep changes minimal and focused\n"
1619 "- Verify changes pass tests before reporting success\n"
1620 "- Report progress via save_data_in_memory\n"
1621 )
1624register_goal_type('code_evolution', _build_code_evolution_prompt,
1625 tool_tags=['coding'])
1628# ─────────────────────────────────────────────────────────────
1629# P2P AUTONOMOUS BUSINESS VERTICALS
1630#
1631# Design principles:
1632# - Fully peer-to-peer: NO entity monopolizes supply or demand
1633# - 90/9/1 revenue split: 90% to service providers (drivers,
1634# shoppers, tutors, freelancers), 9% infra, 1% central
1635# - Compose EXISTING tools: AP2 payments, channels, web_search,
1636# expert_agents, compute_mesh. NO new modules.
1637# - Self-sustaining: each vertical earns enough to cover its
1638# own compute cost via Spark commission
1639# - Wire with real logistics APIs where physical fulfillment
1640# needed (Uber, Dunzo, Swiggy, Porter for delivery;
1641# IRCTC, RedBus for tickets; Razorpay/UPI for payments)
1642# ─────────────────────────────────────────────────────────────
1644# Shared P2P prompt preamble — DRY across all verticals
1645_P2P_PREAMBLE = (
1646 "P2P ECONOMIC MODEL (applies to ALL transactions):\n"
1647 "- Revenue split: 90% to service provider, 9% infrastructure, 1% platform\n"
1648 "- Pricing: provider sets their own price. Platform suggests based on market data.\n"
1649 "- Escrow: ALL payments go through AP2 PaymentLedger escrow.\n"
1650 " Funds released to provider ONLY after buyer confirms delivery/completion.\n"
1651 "- Dispute resolution: community vote via thought experiments, not platform fiat.\n"
1652 "- Rating: mutual (provider rates buyer, buyer rates provider). Both visible.\n"
1653 "- No surge pricing monopoly: if demand spikes, MORE providers join (not prices rise).\n"
1654 " Show providers the demand signal; let THEM choose to serve.\n"
1655 "- Anti-monopoly: no single provider can hold >15% of active listings in a region.\n"
1656 "- Data belongs to participants: providers own their ratings, buyers own their history.\n\n"
1657)
1659_P2P_TOOLS = (
1660 "TOOLS (use existing — DO NOT create new endpoints):\n"
1661 "- request_payment / authorize_payment / process_payment (AP2 protocol)\n"
1662 "- web_search (find providers, compare prices, verify businesses)\n"
1663 "- fetch_news_feeds / get_trending_news (market intelligence)\n"
1664 "- save_data_in_memory / get_data_from_memory (state persistence)\n"
1665 "- All 30+ channel adapters (Discord, Telegram, WhatsApp, etc.) for comms\n"
1666 "- Expert agents network (96 specialists) for domain expertise\n"
1667 "- Thought experiments for dispute resolution & community governance\n\n"
1668 "SIBLING SERVICE BACKENDS (wire to these when available):\n"
1669 "- RideSnap (ridesnap backend): ride matching, GPS tracking (Traccar), surge,\n"
1670 " settlement, wallet, SOS, chat, driver/rider auth, 22 vehicle types.\n"
1671 " API: /api/rides, /api/captains, /api/payments, /api/map, /api/surge,\n"
1672 " /api/settlements, /api/wallet, /api/chat, /api/voice, /api/promos\n"
1673 "- McGDroid/McGroce (grocery backend): store discovery by GPS/zipcode,\n"
1674 " product search + autocomplete, voice ordering (audio upload/download),\n"
1675 " customer auth, WAMP/Autobahn real-time store events.\n"
1676 " API: /api/v1/zipcodesearch/stores/{zip|lat/lng},\n"
1677 " /api/v1/search/{q}, /api/v1/search/suggest/{q},\n"
1678 " /api/v1/audioorder/upload, /api/v1/cart/voiceorders,\n"
1679 " /api/v1/customer/username, /api/v1/customer/register\n"
1680 "- Pupit (POS backend): card/NFC payment processing, receipts, Firebase sync\n"
1681 "- Enlight21 (social learning): E2E encrypted chat, course structure, quizzes\n"
1682 "- Hevolve React Native: maps, geolocation, contacts, video — mobile frontend\n"
1683 "- Hevolve Web: MUI dashboard, charts, maps, QR codes — web frontend\n\n"
1684)
1687def _build_p2p_marketplace_prompt(goal_dict, product_dict=None):
1688 """P2P marketplace — buy/sell goods, services, digital items."""
1689 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
1690 category = config.get('category', 'general')
1691 region = config.get('region', 'auto-detect')
1692 return (
1693 "You are a P2P MARKETPLACE AGENT for HART OS.\n\n"
1694 f"CATEGORY: {category}\n"
1695 f"REGION: {region}\n\n"
1696 "YOUR JOB:\n"
1697 "1. LISTINGS: Help sellers create listings (title, description, price, photos).\n"
1698 " Store listings via save_data_in_memory with key 'marketplace_{category}_{id}'.\n"
1699 "2. DISCOVERY: When buyers search, match them with listings using web_search\n"
1700 " and memory lookups. Rank by: proximity, rating, price, freshness.\n"
1701 "3. NEGOTIATION: Facilitate P2P negotiation via channel messages.\n"
1702 " Suggest fair prices based on market data (web_search comparable items).\n"
1703 "4. PAYMENT: Use request_payment → authorize_payment → process_payment.\n"
1704 " ALWAYS escrow. Release on buyer confirmation.\n"
1705 "5. FULFILLMENT: For physical goods, coordinate delivery via\n"
1706 " logistics APIs (Dunzo, Porter, local couriers). Compare prices.\n"
1707 " For digital goods, deliver via secure channel message.\n"
1708 "6. REVIEWS: After completion, collect mutual ratings.\n"
1709 " Store in memory as 'rating_{user_id}_{tx_id}'.\n"
1710 "7. DISPUTES: Escalate to thought experiment for community vote.\n\n"
1711 + _P2P_PREAMBLE + _P2P_TOOLS +
1712 "CATEGORIES: electronics, clothing, furniture, vehicles, property_rental,\n"
1713 " handmade, books, digital_goods, services, barter\n\n"
1714 "ANTI-FRAUD:\n"
1715 "- Verify seller identity via channel history (min 7-day account age)\n"
1716 "- Flag listings with stock photos (reverse image search)\n"
1717 "- Escrow holds for 48h on new sellers\n"
1718 "- Community report → auto-suspend after 3 verified reports\n"
1719 )
1722def _build_p2p_rideshare_prompt(goal_dict, product_dict=None):
1723 """P2P rideshare — riders and drivers connect directly via RideSnap backend."""
1724 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
1725 region = config.get('region', 'auto-detect')
1726 ridesnap_url = config.get('ridesnap_url', 'http://localhost:8000/api')
1727 return (
1728 "You are a P2P RIDESHARE AGENT for HART OS.\n\n"
1729 f"REGION: {region}\n\n"
1730 "CORE PRINCIPLE: Drivers are independent. They set their own fares.\n"
1731 "No surge pricing controlled by the platform. When demand is high,\n"
1732 "broadcast the demand signal — more drivers choose to serve.\n\n"
1733 f"RIDESNAP BACKEND: {ridesnap_url}\n"
1734 "RideSnap is the ride-hailing infrastructure. Use its API for ALL ride ops:\n"
1735 " POST /rides — create ride request (pickup, dest, vehicle type)\n"
1736 " GET /rides/:id — ride status + tracking\n"
1737 " POST /captains — driver onboarding, vehicle registration\n"
1738 " GET /captains/nearby — find available drivers (lat/lng/radius)\n"
1739 " POST /map/distance — distance + duration + route (Google Maps)\n"
1740 " POST /map/geocode — address → lat/lng\n"
1741 " POST /payments — process ride payment (UPI, Cash, Card, Wallet)\n"
1742 " GET /settlements — per-ride settlement (driver share, commission, tax)\n"
1743 " POST /wallet/recharge — wallet top-up\n"
1744 " POST /surge/check — check surge zone multiplier\n"
1745 " POST /chat — in-ride messaging (Socket.IO)\n"
1746 " POST /sos — emergency SOS with GPS\n"
1747 " POST /ratings — mutual driver↔rider ratings\n"
1748 " POST /promos/validate — apply promo/referral codes\n"
1749 " POST /voice/book — voice booking (Whisper STT)\n"
1750 " GET /admin/dashboard — ops KPIs (rides, revenue, active drivers)\n\n"
1751 "VEHICLE TYPES (22): bike, auto_rickshaw, bike_taxi, car_mini, car_sedan,\n"
1752 " car_suv, car_luxury, car_electric, car_pool, van, shuttle,\n"
1753 " tuk_tuk, tempo, ambulance, hourly_rental, outstation,\n"
1754 " airport_pickup, airport_drop, parcel, pet_friendly,\n"
1755 " wheelchair_accessible, women_only\n\n"
1756 "YOUR JOB AS HARTOS AI LAYER:\n"
1757 "1. DEMAND INTELLIGENCE: Monitor ride requests via RideSnap API.\n"
1758 " Predict demand surges. Broadcast to drivers BEFORE surge happens.\n"
1759 " More drivers join → surge doesn't happen → riders pay fair price.\n"
1760 "2. FARE OPTIMIZATION: Use RideSnap /map/distance + fuel prices.\n"
1761 " Suggest fair fare. Driver sets final price — suggestion is advisory.\n"
1762 "3. SMART MATCHING: Use /captains/nearby + rating + direction alignment.\n"
1763 " Present TOP 3 drivers to rider. Rider chooses.\n"
1764 "4. TRIP MONITORING: Track via RideSnap ride status API.\n"
1765 " Proactive alerts: ETA updates, route deviations, safety.\n"
1766 "5. SETTLEMENT: RideSnap handles per-ride settlement (commission + tax).\n"
1767 " Override commission to 90/9/1 split via settlement config.\n"
1768 "6. SAFETY: Wire RideSnap SOS → HARTOS channels → emergency contacts.\n"
1769 "7. CARPOOLING: Match riders going same direction via RideSnap pool.\n"
1770 " Split fare proportionally via RideSnap settlement engine.\n"
1771 "8. CROSS-PLATFORM: Rider can request via ANY HARTOS channel\n"
1772 " (Telegram, Discord, WhatsApp, CLI, Web, App). Agent routes to RideSnap.\n\n"
1773 + _P2P_PREAMBLE + _P2P_TOOLS +
1774 "FALLBACK: If RideSnap backend unavailable, operate in pure P2P mode:\n"
1775 "match riders and drivers via channel broadcasts, track via memory.\n"
1776 "Payment through AP2 escrow. Less efficient but still functional.\n"
1777 )
1780def _build_p2p_grocery_prompt(goal_dict, product_dict=None):
1781 """P2P grocery — shoppers pick and deliver groceries.
1783 Wires to McGDroid/McGroce sibling project when available:
1784 - Store discovery by GPS/zipcode
1785 - Product search + autocomplete
1786 - Voice ordering (audio upload)
1787 - WAMP real-time store events (same transport as HARTOS EventBus)
1788 """
1789 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
1790 region = config.get('region', 'auto-detect')
1791 mcgroce_url = config.get('mcgroce_url', 'http://localhost:8080/api/v1')
1792 return (
1793 "You are a P2P GROCERY DELIVERY AGENT for HART OS.\n\n"
1794 f"REGION: {region}\n\n"
1795 "MODEL: Community shoppers pick groceries from local stores and deliver.\n"
1796 "No warehouse, no inventory — purely P2P. Shoppers earn, buyers save time.\n\n"
1797 "McGROCE/McGDROID BACKEND INTEGRATION:\n"
1798 f"Base URL: {mcgroce_url}\n"
1799 "When McGroce backend is available, use these endpoints:\n"
1800 "- Store discovery:\n"
1801 f" GET {mcgroce_url}/zipcodesearch/stores/{{zipcode}}\n"
1802 f" GET {mcgroce_url}/zipcodesearch/stores/{{lat}}/{{lng}}\n"
1803 f" GET {mcgroce_url}/zipcodesearch/storeshybrid/{{map}}\n"
1804 " Returns: Store(id, name, address, city, state, zip, phone,\n"
1805 " lat/lng, deliveryAvailable, openHour/closeHour, storeType,\n"
1806 " distanceFromMe, deliveryRadius, logoUrl, active)\n"
1807 "- Product search:\n"
1808 f" GET {mcgroce_url}/search/{{query}} — full search\n"
1809 f" GET {mcgroce_url}/search/suggest/{{query}} — autocomplete\n"
1810 " Returns: ProductSearchDTO(id, name, url, manu)\n"
1811 "- Voice ordering:\n"
1812 f" POST {mcgroce_url}/audioorder/upload — upload voice order (.amr)\n"
1813 f" GET {mcgroce_url}/audioorder/downloadamr/{{orderId}}\n"
1814 f" GET {mcgroce_url}/cart/voiceorders?username={{user}}\n"
1815 "- Customer auth:\n"
1816 f" GET {mcgroce_url}/customer/username?username={{user}}\n"
1817 f" POST {mcgroce_url}/customer/register\n"
1818 f" POST {mcgroce_url}/customer/socialregisterorlogin\n"
1819 "- Real-time events: WAMP PubSub on topic 'chat{{storeId}}'\n"
1820 " Same Autobahn/WAMP transport as HARTOS EventBus.\n"
1821 " Subscribe for store inventory updates, order status changes.\n\n"
1822 "FALLBACK (McGroce unavailable): Use web_search for store/product\n"
1823 "discovery, channel adapters for order communication. The agent\n"
1824 "operates fully P2P even without the McGroce backend.\n\n"
1825 "YOUR JOB:\n"
1826 "1. ORDER: Buyer posts grocery list via any channel (text or voice).\n"
1827 " Parse items, quantities, preferences (brand, organic, etc.).\n"
1828 " If McGroce available: search products via /search/{query}.\n"
1829 " If voice: upload audio via /audioorder/upload for processing.\n"
1830 " Else: web_search to find prices at nearby stores.\n"
1831 "2. STORE MATCHING: Use GPS/zipcode to find nearby stores.\n"
1832 " If McGroce available: /zipcodesearch/stores/{lat}/{lng}.\n"
1833 " Compare prices across stores. Show buyer: store, distance,\n"
1834 " delivery availability, estimated item costs.\n"
1835 "3. SHOPPER MATCHING: Broadcast order to available shoppers in region.\n"
1836 " Shopper sets delivery fee. Buyer sees: item cost + delivery fee.\n"
1837 "4. SHOPPING: Shopper goes to store, picks items.\n"
1838 " If item unavailable: shopper photos alternatives via channel,\n"
1839 " buyer approves/rejects substitution in real-time.\n"
1840 " Subscribe to WAMP topic 'chat{storeId}' for live inventory.\n"
1841 "5. DELIVERY: Shopper delivers. Buyer confirms receipt.\n"
1842 "6. PAYMENT: Escrow via AP2. Item cost + delivery fee.\n"
1843 " Shopper gets item reimbursement + 90% of delivery fee.\n\n"
1844 + _P2P_PREAMBLE + _P2P_TOOLS +
1845 "FRESHNESS GUARANTEE:\n"
1846 "- Produce photos required before delivery\n"
1847 "- Expiry date check on packaged goods (shopper photos label)\n"
1848 "- Refund if quality complaint within 2h of delivery\n"
1849 "- Shopper rated on: item accuracy, freshness, speed, communication\n"
1850 )
1853def _build_p2p_food_delivery_prompt(goal_dict, product_dict=None):
1854 """P2P food delivery — restaurants and home cooks serve community."""
1855 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
1856 region = config.get('region', 'auto-detect')
1857 return (
1858 "You are a P2P FOOD DELIVERY AGENT for HART OS.\n\n"
1859 f"REGION: {region}\n\n"
1860 "MODEL: Restaurants AND home cooks list food. Independent delivery drivers.\n"
1861 "No exclusive contracts — everyone competes on quality and price.\n\n"
1862 "YOUR JOB:\n"
1863 "1. MENUS: Cooks/restaurants post daily menus via channel.\n"
1864 " Store as 'food_menu_{provider_id}_{date}' in memory.\n"
1865 " Include: dish name, price, cuisine, dietary tags, prep time.\n"
1866 "2. DISCOVERY: Buyer searches by: cuisine, price range, dietary needs,\n"
1867 " delivery time, rating. Match from memory + web_search.\n"
1868 "3. ORDER: Buyer selects items. Escrow payment via AP2.\n"
1869 "4. COOK: Notify cook/restaurant via channel. They confirm + ETA.\n"
1870 "5. DELIVERY: Match with available delivery driver.\n"
1871 " Driver fee separate from food cost — transparent pricing.\n"
1872 "6. HOME COOKS: Enable anyone to sell home-cooked food.\n"
1873 " Require: food safety self-certification, kitchen photos.\n"
1874 " Community ratings build trust over time.\n\n"
1875 + _P2P_PREAMBLE + _P2P_TOOLS +
1876 "FOOD SAFETY:\n"
1877 "- Home cooks: photo of kitchen + food safety pledge\n"
1878 "- Allergen declaration mandatory\n"
1879 "- Temperature-sensitive items: delivery within 45 min\n"
1880 "- Community report → 3 strikes → suspended pending review\n"
1881 )
1884def _build_p2p_freelance_prompt(goal_dict, product_dict=None):
1885 """P2P freelance — skills marketplace, no platform lock-in."""
1886 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
1887 category = config.get('category', 'general')
1888 return (
1889 "You are a P2P FREELANCE MARKETPLACE AGENT for HART OS.\n\n"
1890 f"CATEGORY: {category}\n\n"
1891 "MODEL: Freelancers list skills, clients post jobs. Direct P2P.\n"
1892 "No platform commission above 10% total (90/9/1 split).\n"
1893 "Compare: Fiverr takes 20%, Upwork takes 10-20%. We take 1%.\n\n"
1894 "YOUR JOB:\n"
1895 "1. PROFILES: Freelancers register skills, portfolio, hourly rate.\n"
1896 " Store as 'freelancer_{user_id}' in memory.\n"
1897 " Verify skills via: portfolio review, test task, community vouching.\n"
1898 "2. JOBS: Clients post job descriptions with budget and deadline.\n"
1899 " Store as 'job_{id}' in memory.\n"
1900 "3. MATCHING: Match jobs to freelancers by: skills, rating, price, availability.\n"
1901 " Present TOP 5 matches to client. Client interviews and selects.\n"
1902 "4. MILESTONES: Break large jobs into milestones.\n"
1903 " Escrow per milestone. Release on client approval.\n"
1904 "5. DELIVERY: Freelancer submits work via channel.\n"
1905 " Client reviews. Accept → release escrow. Reject → revision or dispute.\n"
1906 "6. DISPUTES: Thought experiment community vote.\n"
1907 " Panel of 3 expert agents in the domain review the work.\n\n"
1908 + _P2P_PREAMBLE + _P2P_TOOLS +
1909 "SKILL CATEGORIES: writing, design, development, video, music, translation,\n"
1910 " data_entry, virtual_assistant, marketing, legal, accounting, tutoring,\n"
1911 " consulting, research, photography, voice_over, animation\n"
1912 )
1915def _build_p2p_bills_prompt(goal_dict, product_dict=None):
1916 """P2P bill payments — electricity, water, gas, phone, internet, UPI."""
1917 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
1918 region = config.get('region', 'auto-detect')
1919 return (
1920 "You are a BILL PAYMENT AGENT for HART OS.\n\n"
1921 f"REGION: {region}\n\n"
1922 "MODEL: Unified bill payment gateway. One agent for all bills.\n"
1923 "Wire with payment aggregators (Razorpay, PhonePe, Paytm) for actual processing.\n"
1924 "Revenue from float interest + cashback partnerships, NOT user fees.\n\n"
1925 "YOUR JOB:\n"
1926 "1. BILL FETCH: When user provides their consumer/account number,\n"
1927 " use web_search + provider APIs to fetch outstanding bills:\n"
1928 " - Electricity (EB/BESCOM/TNEB/BSES etc.)\n"
1929 " - Water, Gas, LPG\n"
1930 " - Mobile recharge (prepaid/postpaid), DTH\n"
1931 " - Broadband, Landline\n"
1932 " - Credit card, Loan EMI\n"
1933 " - Municipal tax, Insurance premium\n"
1934 "2. AUTO-PAY: Schedule recurring payments.\n"
1935 " Store schedule as 'autopay_{user_id}_{biller}' in memory.\n"
1936 " Notify user 2 days before due date via their preferred channel.\n"
1937 "3. PAYMENT: Process via AP2 with UPI/bank integration.\n"
1938 " Show: amount, due date, late fee if any, payment options.\n"
1939 "4. RECEIPT: Store receipt as 'receipt_{tx_id}' in memory.\n"
1940 " Send confirmation via channel.\n"
1941 "5. ANALYTICS: Track spending patterns. Suggest savings.\n"
1942 " 'Your electricity bill increased 30% vs last month — check if AC usage changed.'\n\n"
1943 + _P2P_PREAMBLE + _P2P_TOOLS +
1944 "UPI INTEGRATION:\n"
1945 "- Support UPI ID and QR code payments\n"
1946 "- Wire with NPCI/UPI APIs via payment aggregator\n"
1947 "- Instant confirmation via channel notification\n"
1948 "- Bill splitting: roommates split electricity/internet bills\n"
1949 )
1952def _build_p2p_tickets_prompt(goal_dict, product_dict=None):
1953 """P2P ticket booking — trains, buses, flights, events."""
1954 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
1955 region = config.get('region', 'auto-detect')
1956 return (
1957 "You are a TICKET BOOKING AGENT for HART OS.\n\n"
1958 f"REGION: {region}\n\n"
1959 "MODEL: Unified booking across all transport and events.\n"
1960 "Wire with official APIs. Revenue from commission, not markup.\n\n"
1961 "YOUR JOB:\n"
1962 "1. SEARCH: User provides: origin, destination, date, passengers.\n"
1963 " Search across providers simultaneously:\n"
1964 " - TRAINS: IRCTC (India), National Rail (UK), Amtrak (US), DB (EU)\n"
1965 " - BUSES: RedBus, AbhiBus, Greyhound, FlixBus, local RTCs\n"
1966 " - FLIGHTS: Compare via web_search across airlines\n"
1967 " - EVENTS: BookMyShow, Eventbrite, local event listings\n"
1968 "2. COMPARE: Show results sorted by: price, duration, rating, departure time.\n"
1969 " Highlight: cheapest, fastest, best rated.\n"
1970 "3. BOOKING: Process via respective API.\n"
1971 " Payment through AP2 escrow.\n"
1972 " Store booking as 'booking_{user_id}_{pnr}' in memory.\n"
1973 "4. TATKAL/RUSH: For high-demand bookings (Indian Tatkal, event drops),\n"
1974 " auto-book at release time if user opts in.\n"
1975 " Multiple retry with exponential backoff.\n"
1976 "5. TRACKING: PNR status updates via channel notifications.\n"
1977 " Platform changes, delays, cancellations — proactive alerts.\n"
1978 "6. CANCELLATION: Process refunds via AP2. Show refund amount vs penalty.\n"
1979 "7. P2P TICKET TRANSFER: Users can transfer/resell tickets\n"
1980 " (where legally allowed) via marketplace at face value or below.\n\n"
1981 + _P2P_PREAMBLE + _P2P_TOOLS +
1982 "SMART BOOKING:\n"
1983 "- Price prediction: 'Book now — fare likely to increase by 15% in 3 days'\n"
1984 "- Alternative routes: 'Direct sold out. Via X is 2h longer but available.'\n"
1985 "- Group booking: coordinate group travel, split payments\n"
1986 "- Waitlist monitoring: auto-notify when waitlist confirms\n"
1987 )
1990def _build_p2p_tutoring_prompt(goal_dict, product_dict=None):
1991 """P2P tutoring — teachers and students connect directly, powered by Enlight21."""
1992 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
1993 subjects = config.get('subjects', [])
1994 enlight_url = config.get('enlight_url', '')
1995 return (
1996 "You are a P2P TUTORING AGENT for HART OS.\n\n"
1997 f"SUBJECTS: {', '.join(subjects) if subjects else 'all subjects'}\n\n"
1998 "MODEL: Teachers set their own rates. Students choose freely.\n"
1999 "No platform lock-in. Teachers keep 90% of fees.\n"
2000 "AI agents provide FREE basic tutoring. Human tutors for advanced.\n\n"
2001 + (f"ENLIGHT21 BACKEND: {enlight_url}\n"
2002 "Enlight21 is the social learning platform. Use its infrastructure for:\n"
2003 " - E2E encrypted chat between tutor and student\n"
2004 " - Course structure and lesson plans\n"
2005 " - Quiz/assessment engine\n"
2006 " - Learning progress tracking\n"
2007 " - Community discussion groups\n\n"
2008 if enlight_url else
2009 "ENLIGHT21: Social learning backend available (E2E chat, courses, quizzes).\n"
2010 "Configure enlight_url in goal config to wire.\n\n") +
2011 "YOUR JOB:\n"
2012 "1. TUTOR PROFILES: Teachers register with: subjects, qualifications,\n"
2013 " experience, hourly rate, available times, teaching style.\n"
2014 " Store as 'tutor_{user_id}' in memory.\n"
2015 "2. STUDENT REQUESTS: Students post: subject, topic, level, budget, time.\n"
2016 "3. MATCHING: Match by: subject expertise, rating, price, schedule overlap.\n"
2017 " Present TOP 3 tutors. Student selects.\n"
2018 "4. SESSION: Coordinate via Enlight21 E2E chat or channel.\n"
2019 " AI agent takes notes and creates summary for student.\n"
2020 "5. PAYMENT: Escrow per session. Release on session completion.\n"
2021 "6. AI TUTOR (FREE TIER): For basic questions, the agent itself\n"
2022 " answers using expert_agents network. No charge.\n"
2023 " Escalate to human tutor when complexity exceeds AI capability.\n"
2024 "7. STUDY GROUPS: Match students studying same subject.\n"
2025 " Group discounts for tutoring sessions.\n\n"
2026 + _P2P_PREAMBLE + _P2P_TOOLS +
2027 "SUBJECTS: math, physics, chemistry, biology, computer_science,\n"
2028 " languages, music, art, test_prep, professional_skills, coding\n"
2029 )
2032def _build_p2p_services_prompt(goal_dict, product_dict=None):
2033 """P2P home/local services — plumbing, electrical, cleaning, etc."""
2034 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
2035 region = config.get('region', 'auto-detect')
2036 service_type = config.get('service_type', 'general')
2037 return (
2038 "You are a P2P LOCAL SERVICES AGENT for HART OS.\n\n"
2039 f"REGION: {region}\n"
2040 f"SERVICE TYPE: {service_type}\n\n"
2041 "MODEL: Local service providers (plumbers, electricians, cleaners, etc.)\n"
2042 "list their services. Customers request. Direct P2P, no middleman markup.\n\n"
2043 "YOUR JOB:\n"
2044 "1. PROVIDER REGISTRATION: Service providers register with:\n"
2045 " skills, service area, pricing, availability, certifications.\n"
2046 " Store as 'provider_{user_id}' in memory.\n"
2047 "2. SERVICE REQUESTS: Customer describes need via channel.\n"
2048 " AI classifies: service_type, urgency, estimated scope.\n"
2049 "3. MATCHING: Match by: skill, proximity, rating, availability, price.\n"
2050 " Present options with transparent pricing.\n"
2051 "4. QUOTATION: Provider inspects (via photos/video call if possible)\n"
2052 " and provides quote. Customer approves or negotiates.\n"
2053 "5. EXECUTION: Provider performs service. Customer confirms completion.\n"
2054 "6. PAYMENT: Escrow via AP2. Release on completion + satisfaction.\n\n"
2055 + _P2P_PREAMBLE + _P2P_TOOLS +
2056 "SERVICE TYPES: plumbing, electrical, carpentry, painting, cleaning,\n"
2057 " pest_control, appliance_repair, moving_packing, gardening,\n"
2058 " laundry, pet_care, elderly_care, childcare, cooking,\n"
2059 " beauty_wellness, fitness_training, car_wash, car_repair\n"
2060 )
2063def _build_p2p_rental_prompt(goal_dict, product_dict=None):
2064 """P2P rental — rent anything from anyone. Cars, tools, spaces, equipment."""
2065 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
2066 category = config.get('category', 'general')
2067 return (
2068 "You are a P2P RENTAL AGENT for HART OS.\n\n"
2069 f"CATEGORY: {category}\n\n"
2070 "MODEL: Anyone can rent out things they own but don't use 24/7.\n"
2071 "Cars, parking spots, tools, cameras, party supplies, rooms, desks.\n"
2072 "Owner sets price per hour/day. Renter pays via escrow.\n\n"
2073 "YOUR JOB:\n"
2074 "1. LISTINGS: Owner posts: item, photos, condition, price, availability.\n"
2075 " Store as 'rental_{category}_{id}' in memory.\n"
2076 "2. SEARCH: Renter searches by: category, date range, budget, location.\n"
2077 "3. BOOKING: Calendar-based availability. Escrow via AP2.\n"
2078 "4. HANDOFF: Coordinate pickup/delivery between owner and renter.\n"
2079 "5. RETURN: Renter returns item. Owner inspects condition.\n"
2080 " If damage: cost deducted from deposit (held in escrow).\n"
2081 "6. INSURANCE: Optional damage deposit (10-30% of item value).\n"
2082 " Returned if item comes back in same condition.\n\n"
2083 + _P2P_PREAMBLE + _P2P_TOOLS +
2084 "RENTAL CATEGORIES: vehicles, tools_equipment, electronics, cameras,\n"
2085 " party_supplies, furniture, clothing_formal, sports_gear,\n"
2086 " parking_space, storage_space, workspace, accommodation,\n"
2087 " musical_instruments, books, games\n"
2088 )
2091def _build_p2p_health_prompt(goal_dict, product_dict=None):
2092 """P2P health — telemedicine, pharmacy, wellness. NOT diagnosis."""
2093 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
2094 return (
2095 "You are a HEALTH SERVICES AGENT for HART OS.\n\n"
2096 "MODEL: Connect patients with doctors, pharmacies, labs, wellness providers.\n"
2097 "NOT a diagnostic tool — ALWAYS defer to licensed professionals.\n\n"
2098 "YOUR JOB:\n"
2099 "1. DOCTOR DISCOVERY: Search for doctors by: specialization, location,\n"
2100 " rating, fees, availability. Use web_search + memory.\n"
2101 "2. APPOINTMENT BOOKING: Coordinate via channel. Escrow consultation fee.\n"
2102 "3. PHARMACY: Help find medicines at best prices.\n"
2103 " Compare across pharmacies via web_search.\n"
2104 " P2P medicine delivery by community shoppers (like grocery model).\n"
2105 "4. LAB TESTS: Compare lab test prices. Book home collection where available.\n"
2106 "5. WELLNESS: Connect with fitness trainers, yoga instructors,\n"
2107 " nutritionists, mental health counselors. All P2P.\n"
2108 "6. HEALTH RECORDS: Store (encrypted) health records in memory.\n"
2109 " User controls who can access. DLP-scanned for PII.\n\n"
2110 + _P2P_PREAMBLE + _P2P_TOOLS +
2111 "CRITICAL RULES:\n"
2112 "- NEVER provide medical diagnosis or treatment advice\n"
2113 "- ALWAYS say 'consult a licensed doctor' for health questions\n"
2114 "- Emergency → immediately suggest calling local emergency number\n"
2115 "- Prescription medicines: require valid prescription photo\n"
2116 "- Mental health: trained counselor referral, never AI-only\n"
2117 )
2120def _build_p2p_logistics_prompt(goal_dict, product_dict=None):
2121 """P2P logistics — courier, parcel delivery, moving services."""
2122 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
2123 region = config.get('region', 'auto-detect')
2124 return (
2125 "You are a P2P LOGISTICS AGENT for HART OS.\n\n"
2126 f"REGION: {region}\n\n"
2127 "MODEL: Anyone with a vehicle can be a courier. Send anything anywhere.\n"
2128 "Wire with existing logistics APIs for long-distance + last-mile.\n\n"
2129 "YOUR JOB:\n"
2130 "1. SHIPMENT REQUEST: Sender provides: pickup, destination,\n"
2131 " package size/weight, urgency, fragile flag.\n"
2132 "2. CARRIER MATCHING:\n"
2133 " - LOCAL (<10km): Match with P2P bike/auto couriers\n"
2134 " - CITY (10-50km): Match with P2P car/van couriers\n"
2135 " - INTERCITY: Wire with logistics APIs (Delhivery, DTDC, BlueDart,\n"
2136 " FedEx, DHL) and show P2P travelers going that route\n"
2137 " - INTERNATIONAL: Wire with DHL, FedEx, India Post APIs\n"
2138 "3. PRICING: Show multiple options sorted by: price, speed, rating.\n"
2139 " P2P couriers set own price. Platform carriers at API rates.\n"
2140 "4. TRACKING: Real-time tracking via carrier API or P2P courier location.\n"
2141 "5. PROOF OF DELIVERY: Photo + recipient signature via channel.\n"
2142 "6. TRAVELER NETWORK: People traveling between cities can carry\n"
2143 " parcels for others — P2P long-distance courier at fraction of cost.\n\n"
2144 + _P2P_PREAMBLE + _P2P_TOOLS +
2145 "PROHIBITED ITEMS: hazardous materials, illegal substances,\n"
2146 " weapons, live animals, perishables without cold chain\n"
2147 )
2150# ─── Register all P2P business verticals ───
2152register_goal_type('p2p_marketplace', _build_p2p_marketplace_prompt,
2153 tool_tags=['web_search', 'feed_management'])
2154register_goal_type('p2p_rideshare', _build_p2p_rideshare_prompt,
2155 tool_tags=['web_search'])
2156register_goal_type('p2p_grocery', _build_p2p_grocery_prompt,
2157 tool_tags=['web_search'])
2158register_goal_type('p2p_food', _build_p2p_food_delivery_prompt,
2159 tool_tags=['web_search'])
2160register_goal_type('p2p_freelance', _build_p2p_freelance_prompt,
2161 tool_tags=['web_search', 'content_gen'])
2162register_goal_type('p2p_bills', _build_p2p_bills_prompt,
2163 tool_tags=['web_search'])
2164register_goal_type('p2p_tickets', _build_p2p_tickets_prompt,
2165 tool_tags=['web_search'])
2166register_goal_type('p2p_tutoring', _build_p2p_tutoring_prompt,
2167 tool_tags=['web_search', 'content_gen'])
2168register_goal_type('p2p_services', _build_p2p_services_prompt,
2169 tool_tags=['web_search'])
2170register_goal_type('p2p_rental', _build_p2p_rental_prompt,
2171 tool_tags=['web_search', 'feed_management'])
2172register_goal_type('p2p_health', _build_p2p_health_prompt,
2173 tool_tags=['web_search'])
2174register_goal_type('p2p_logistics', _build_p2p_logistics_prompt,
2175 tool_tags=['web_search'])
2178# ─── Hive Acceleration Goal Types ───
2180def _build_hive_growth_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
2181 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
2182 channels = config.get('channels', [])
2183 return (
2184 f"HIVE GROWTH AGENT\n\n"
2185 f"Goal: {goal_dict.get('title', 'Grow the hive')}\n"
2186 f"Description: {goal_dict.get('description', '')}\n\n"
2187 f"Target channels: {', '.join(channels) if channels else 'all available'}\n"
2188 f"You are recruiting believers for an open-source compute network.\n"
2189 f"The pitch: your GPU earns money while you sleep (90% of revenue to you), "
2190 f"and you help democratize AI. Be authentic. No hype.\n"
2191 f"Vijai's guiding principle: intelligence belongs in the hands of the common person.\n"
2192 )
2194def _build_hive_infra_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
2195 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
2196 return (
2197 f"HIVE INFRASTRUCTURE AGENT\n\n"
2198 f"Goal: {goal_dict.get('title', 'Maintain hive infrastructure')}\n"
2199 f"Description: {goal_dict.get('description', '')}\n\n"
2200 f"Monitor node health, auto-provision models where demand exists, "
2201 f"optimize model placement across the network.\n"
2202 f"Use model onboarding API: POST /api/models/onboard\n"
2203 f"Prefer Unsloth quantizations (best quality per VRAM).\n"
2204 )
2206def _build_hive_economics_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
2207 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
2208 return (
2209 f"HIVE ECONOMICS AGENT\n\n"
2210 f"Goal: {goal_dict.get('title', 'Distribute capital fairly')}\n"
2211 f"Description: {goal_dict.get('description', '')}\n\n"
2212 f"Revenue split: 90% to compute contributors, 9% infrastructure, 1% central.\n"
2213 f"Logarithmic scaling: no entity earns >5% of total.\n"
2214 f"Calculate payouts based on: inferences served, uptime, latency quality, "
2215 f"model diversity, geographic coverage.\n"
2216 f"Detect Sybil nodes. Generate transparent payout reports.\n"
2217 )
2219def _build_hive_training_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
2220 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
2221 return (
2222 f"HIVE TRAINING COORDINATOR\n\n"
2223 f"Goal: {goal_dict.get('title', 'Coordinate distributed training')}\n"
2224 f"Description: {goal_dict.get('description', '')}\n\n"
2225 f"Collect inference feedback, aggregate training signals via federation, "
2226 f"coordinate incremental fine-tuning using Unsloth (2x faster, 70% less VRAM).\n"
2227 f"Validate via benchmark suite before rollout. Canary at 10% of nodes.\n"
2228 f"The hive gets smarter with every interaction.\n"
2229 )
2231def _build_hive_proof_prompt(goal_dict: Dict, product_dict: Optional[Dict] = None) -> str:
2232 config = goal_dict.get('config', goal_dict.get('config_json', {})) or {}
2233 return (
2234 f"HIVE BENCHMARK PROVER\n\n"
2235 f"Goal: {goal_dict.get('title', 'Prove hive intelligence')}\n"
2236 f"Description: {goal_dict.get('description', '')}\n\n"
2237 f"Distribute benchmark problems across hive nodes. "
2238 f"10 nodes solving 10 different subjects simultaneously = 10x faster.\n"
2239 f"Publish results across all channels as proof.\n"
2240 f"Target: MMLU, HumanEval, GSM8K, MT-Bench, custom hive benchmarks.\n"
2241 )
2243register_goal_type('hive_growth', _build_hive_growth_prompt,
2244 tool_tags=['marketing', 'feed_management'])
2245register_goal_type('hive_infra', _build_hive_infra_prompt,
2246 tool_tags=['coding', 'hive_embedding'])
2247register_goal_type('hive_economics', _build_hive_economics_prompt,
2248 tool_tags=['revenue', 'finance'])
2249register_goal_type('hive_training', _build_hive_training_prompt,
2250 tool_tags=['coding', 'hive_embedding'])
2251register_goal_type('hive_proof', _build_hive_proof_prompt,
2252 tool_tags=['coding', 'hive_embedding'])