polyrob 0.5.0__py3-none-any.whl

agents/task/goals/escalation.py

@@ -0,0 +1,102 @@
+"""Blocker → owner escalation (§7.2).
+
+Historically a goal that tripped the circuit breaker went to ``status='blocked'`` +
+a ``gave_up`` audit event and then **died silently** — nothing surfaced it to the
+owner. This module is the missing producer: when a goal blocks, push a concrete,
+specific ask to the owner over the SAME rail an out-of-band cron report uses
+(``self_evolution.push_owner_message`` → telegram sink + ``resolve_owner_telegram_id``).
+
+Pure builders + one gated, fail-open async producer so it is trivially testable and
+can never break the dispatcher's failure path.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def build_blocker_escalation(goal: Any) -> str:
+    """A concrete owner-facing ask for a blocked goal (not just a status line)."""
+    title = getattr(goal, "title", None) or "(untitled goal)"
+    reason = (getattr(goal, "last_failure_error", None) or "repeated failures").strip()
+    fails = getattr(goal, "consecutive_failures", None)
+    tail = f" after {fails} attempts" if fails else ""
+    return (
+        f"🚧 I'm blocked and stopped retrying{tail}.\n"
+        f"Goal: {title}\n"
+        f"Why: {reason}\n"
+        f"What do you want me to do — drop it, give me what it needs, or should I "
+        f"try a different approach?"
+    )
+
+
+def build_empty_pipeline_escalation(objective_title: str | None) -> str:
+    """An owner-facing ask when the board has drained with no next goal to run."""
+    obj = objective_title or "the current objective"
+    return (
+        f"🫗 My goal pipeline is empty — I have nothing queued for {obj}.\n"
+        f"Tell me the next concrete step, or what's blocking progress, and I'll pick it up."
+    )
+
+
+async def maybe_escalate_blocked(task_agent: Any, goal: Any) -> bool:
+    """Escalate a BLOCKED goal to the owner if enabled. No-op + fail-open otherwise.
+
+    Gated ``GOAL_BLOCKER_ESCALATION`` (default OFF). Only fires for a goal whose
+    status is ``blocked`` (the circuit breaker tripped), never a transient retry.
+    """
+    try:
+        from agents.task.goals.board import STATUS_BLOCKED
+        if getattr(goal, "status", None) != STATUS_BLOCKED:
+            return False
+        from agents.task.constants import AutonomyConfig
+        if not AutonomyConfig.goal_blocker_escalation():
+            return False
+        container = getattr(task_agent, "container", None)
+        from core.self_evolution import push_owner_message
+        sent = await push_owner_message(container, build_blocker_escalation(goal))
+        if sent:
+            logger.info("goal %s blocked → owner escalation sent", getattr(goal, "id", "?"))
+        return bool(sent)
+    except Exception as e:  # never let escalation break the failure path
+        logger.debug("blocker escalation skipped (fail-open): %s", e)
+        return False
+
+
+async def maybe_escalate_empty_pipeline(task_agent: Any, *,
+                                        objective_title: str | None = None,
+                                        planner_summary: str | None = None) -> bool:
+    """Escalate a drained goal pipeline to the owner if enabled. Fail-open.
+
+    Gated ``GOAL_BLOCKER_ESCALATION`` (same flag as the blocked-goal producer —
+    both are "the board can't advance without you"). A planner run that reported
+    "queue healthy" is a legitimate non-blocker outcome and is never escalated.
+    """
+    try:
+        from agents.task.constants import AutonomyConfig
+        if not AutonomyConfig.goal_blocker_escalation():
+            return False
+        if planner_summary and "queue healthy" in planner_summary.lower():
+            return False
+        text = build_empty_pipeline_escalation(objective_title)
+        if planner_summary:
+            text += f"\nMy planner's last word: {planner_summary.strip()[:400]}"
+        container = getattr(task_agent, "container", None)
+        from core.self_evolution import push_owner_message
+        sent = await push_owner_message(container, text)
+        if sent:
+            logger.info("empty goal pipeline → owner escalation sent")
+        return bool(sent)
+    except Exception as e:  # never let escalation break the planner path
+        logger.debug("empty-pipeline escalation skipped (fail-open): %s", e)
+        return False
+
+
+__all__ = [
+    "build_blocker_escalation",
+    "build_empty_pipeline_escalation",
+    "maybe_escalate_blocked",
+    "maybe_escalate_empty_pipeline",
+]

agents/task/goals/planner.py

@@ -0,0 +1,114 @@
+"""Objective-driven goal planner (replaces scripts/seed_goal_seeder.py).
+
+The PROMPT IS BUILT BY CODE from live board + deliverables state — the agent
+never re-derives its mission from a hardcoded theme list. Pure functions here;
+the dispatcher owns triggering (flags, cooldown, quota) and session dispatch.
+"""
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+PLANNER_TOOLS = ["goal", "task"]
+PLANNER_MAX_STEPS = 8
+
+
+def list_deliverables(root: Path, max_files: int = 40) -> List[Dict[str, Any]]:
+    """name (relative), mtime iso, first markdown heading — depth <=2, dotfiles skipped."""
+    out: List[Dict[str, Any]] = []
+    if not root or not Path(root).is_dir():
+        return out
+    root = Path(root)
+    candidates = sorted(
+        (p for pattern in ("*", "*/*") for p in root.glob(pattern)
+         if p.is_file() and not any(part.startswith(".") for part in p.relative_to(root).parts)),
+        key=lambda p: p.stat().st_mtime, reverse=True,
+    )
+    for p in candidates[:max_files]:
+        heading = ""
+        try:
+            with open(p, "r", encoding="utf-8", errors="ignore") as fh:
+                for i, line in enumerate(fh):
+                    if i > 40:
+                        break
+                    if line.startswith("# "):
+                        heading = line[2:].strip()
+                        break
+        except OSError:
+            pass
+        out.append({
+            "name": str(p.relative_to(root)),
+            "mtime_iso": time.strftime("%Y-%m-%d %H:%M", time.gmtime(p.stat().st_mtime)),
+            "heading": heading,
+        })
+    return out
+
+
+def build_planner_prompt(board, user_id: str, deliverables_root: Optional[Path],
+                         *, history_n: int = 10) -> str:
+    from agents.task.goals.board import OBJ_ACTIVE
+
+    objectives = board.objectives(user_id=user_id, status=OBJ_ACTIVE)
+    done = [g for g in board.list(user_id=user_id, status="done", limit=history_n * 3)
+            if g.kind == "goal"]
+    done = sorted(done, key=lambda g: g.completed_at or 0, reverse=True)[:history_n]
+    blocked = [g for g in board.list(user_id=user_id, status="blocked", limit=20)
+               if g.kind == "goal"]
+    ready = [g for g in board.list(user_id=user_id, status="ready", limit=20)
+             if g.kind == "goal"]
+
+    sections = ["You are planning your own work queue. Create goals that genuinely "
+                "advance a standing objective below. If you create nothing, there are "
+                "TWO valid, DIFFERENT outcomes — pick the true one:\n"
+                "  (a) REAL BLOCKER: progress needs something only the owner can provide "
+                "(a credential, a decision, access) — state that specific blocker as your "
+                "summary so it reaches the owner.\n"
+                "  (b) QUEUE HEALTHY: the objective is already well-covered and there is "
+                "no non-duplicate work worth adding right now — say exactly \"queue "
+                "healthy, nothing to add\". This is NORMAL and is NOT a blocker.\n"
+                "Do NOT invent busywork, and do NOT report a routine empty/covered queue "
+                "as a blocker."]
+
+    def _obj_line(o) -> str:
+        crit = (o.payload or {}).get("success_criteria")
+        base = f"- id={o.id} [{o.title}] {o.body}".rstrip()
+        return base + (f"\n    success criteria: {crit}" if crit else "")
+
+    sections.append("STANDING OBJECTIVES (active):\n" + "\n".join(
+        _obj_line(o) for o in objectives))
+
+    if done:
+        sections.append("RECENTLY DONE (title -> outcome):\n" + "\n".join(
+            f"- {g.title} -> {(g.payload or {}).get('outcome') or '[no outcome recorded]'}"
+            for g in done))
+    if blocked:
+        sections.append("BLOCKED (do NOT recreate; fix or avoid):\n" + "\n".join(
+            f"- {g.title} (error: {(g.last_failure_error or '?')[:120]})" for g in blocked))
+    if ready:
+        sections.append("ALREADY QUEUED (ready):\n" + "\n".join(f"- {g.title}" for g in ready))
+
+    dels = list_deliverables(deliverables_root) if deliverables_root else []
+    if dels:
+        sections.append("EXISTING DELIVERABLES (extend these; do NOT create overlapping docs):\n"
+                        + "\n".join(f"- {d['name']} ({d['mtime_iso']})"
+                                    + (f": {d['heading']}" if d['heading'] else "")
+                                    for d in dels))
+
+    sections.append(
+        "INSTRUCTIONS:\n"
+        "- Create 1-3 goals with goal_create; each MUST set objective_id, tools, and "
+        "acceptance (what 'done' must prove: ids/paths/urls).\n"
+        "- Each goal must EXTEND an existing deliverable or state why none applies.\n"
+        "- Tools by shape: research -> ['web_fetch','anysite','filesystem','task']; "
+        "drafting -> ['filesystem','task','web_fetch']; posting/engagement -> "
+        "['twitter','filesystem','task']. At most ONE goal may include 'twitter'.\n"
+        "- Never exceed 5 ready goals total. A rejected duplicate means: extend the "
+        "matched goal's work instead of retrying a rename.\n"
+        "- If progress is blocked on something only the owner can provide (credentials, "
+        "a decision, access), SAY SO explicitly and specifically — a concrete ask beats "
+        "inventing busywork.\n"
+        "- Finish with a one-line summary of what you queued, or — if you queued "
+        "nothing — the specific blocker/ask standing between you and the objective."
+    )
+    return "\n\n".join(sections)

agents/task/logging_config.py

@@ -0,0 +1,155 @@
+"""
+Task Agent Logging Configuration
+
+Provides session-aware logging for the task agent system.
+Integrates with core.logging when available, with automatic fallback.
+"""
+
+import logging
+import os
+from typing import Optional
+from pathlib import Path
+
+# Try to import core logging if available
+try:
+    from core.logging import get_component_logger
+    CORE_LOGGING_AVAILABLE = True
+except ImportError:
+    CORE_LOGGING_AVAILABLE = False
+
+# Cache for created loggers
+_LOGGER_CACHE = {}
+
+def get_task_logger(component_name: str, session_id: Optional[str] = None) -> logging.Logger:
+    """
+    Get a logger for task agent components.
+
+    Integrates with core logging system when available, with automatic fallback
+    to basic logging if core system is not initialized.
+
+    Args:
+        component_name: Component name (e.g., 'agent', 'orchestrator', 'controller')
+        session_id: Optional session ID for session-aware logging
+
+    Returns:
+        Configured logger instance with appropriate handlers and formatting
+
+    Examples:
+        >>> logger = get_task_logger('agent', 'abc123')
+        >>> logger.info('Agent started')
+
+        >>> logger = get_task_logger('orchestrator')
+        >>> logger.debug('Session created')
+    """
+    # Create consistent logger name
+    if session_id:
+        # Truncate session ID to first 8 chars for readability
+        logger_name = f"task.{component_name}[{session_id[:8]}]"
+    else:
+        logger_name = f"task.{component_name}"
+
+    # Return cached logger if available
+    if logger_name in _LOGGER_CACHE:
+        return _LOGGER_CACHE[logger_name]
+
+    # Use core logging if available
+    if CORE_LOGGING_AVAILABLE:
+        try:
+            logger = get_component_logger(logger_name)
+            _LOGGER_CACHE[logger_name] = logger
+            return logger
+        except Exception:
+            # Fall through to basic logger
+            pass
+
+    # Fallback to basic logger configuration
+    logger = logging.getLogger(logger_name)
+
+    # Only configure if not already configured
+    if not logger.handlers:
+        # Set level from environment or default to INFO
+        log_level = os.getenv('LOG_LEVEL', 'INFO').upper()
+        logger.setLevel(getattr(logging, log_level, logging.INFO))
+
+        # Add console handler with simple format
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+        # Prevent propagation to avoid duplicate logs
+        logger.propagate = False
+
+    _LOGGER_CACHE[logger_name] = logger
+    return logger
+
+
+def setup_logging(log_level: str = 'INFO', log_file: Optional[str] = None) -> None:
+    """
+    Basic logging setup.
+
+    Args:
+        log_level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        log_file: Optional file path for logging
+    """
+    level = getattr(logging, log_level.upper(), logging.INFO)
+
+    # Basic configuration
+    handlers = [logging.StreamHandler()]
+
+    if log_file:
+        handlers.append(logging.FileHandler(log_file))
+
+    logging.basicConfig(
+        level=level,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S',
+        handlers=handlers,
+        force=True
+    )
+
+    # Silence noisy libraries
+    configure_library_loggers()
+
+def configure_library_loggers():
+    """Configure logging levels for third-party libraries."""
+    # Silence noisy libraries
+    noisy_loggers = [
+        'urllib3',
+        'httpx',
+        'httpcore',
+        'selenium',
+        'PIL',
+        'matplotlib',
+        'asyncio',
+        'filelock',
+        'fontTools',
+        'pinecone',
+        'google.auth',
+        'google.api_core',
+        'google.cloud',
+        'googleapiclient',
+        'openai',
+        'anthropic'
+    ]
+
+    for logger_name in noisy_loggers:
+        logging.getLogger(logger_name).setLevel(logging.WARNING)
+
+    # Special handling for very noisy loggers
+    logging.getLogger('httpx._client').setLevel(logging.ERROR)
+    logging.getLogger('httpcore._trace').setLevel(logging.ERROR)
+
+    # Disable propagation for task loggers to avoid duplicates
+    logging.getLogger('task').propagate = False
+
+# Removed compatibility no-ops - these functions are no longer needed:
+# - silence_metadata_logs()
+# - fix_httpx_logging()
+# - enable_log_deduplication()
+# - reset_log_deduplication_cache()
+# - optimize_logging_for_agent_system()
+# If you're using any of these, please remove the calls or use configure_library_loggers() directly