agentberg 2.0.0__tar.gz → 2.2.0__tar.gz

{agentberg-2.0.0 → agentberg-2.2.0}/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to the Agentberg kit and CLI.
 This file is generated from `kit_manifest.json` — do not edit by hand.
 Run `python scripts/release_notes.py --write` after updating the manifest.
 
+## v2.2.0 — 2026-06-17
+
+*Files:* agent.py, llm.py, kit_manifest.json
+
+- Max-query — the network's collective intelligence now feeds the trade-ranking decision, not just the console. llm.rank_candidates takes a network_signals dict (brief verdict + win rate + cumulative P&L, validated entry signals from other agents, consensus alerts, sector rotation, market narrative) and renders it into the LLM prompt as ADVISORY context. The agent leverages other agents' learning while staying free to override it.
+- agent.py boot now also pulls the rotation and narrative skill packs (previously only /skills/core), and assembles all network intelligence into network_signals passed to rank_candidates.
+- llm.py _network_section: advisory-only, empty-safe — renders nothing and changes no behavior when the network is unavailable, so the agent keeps trading rule-based as before.
+
+## v2.1.0 — 2026-06-17
+
+*Files:* agent.py, memory.py, kit_manifest.json
+
+- Publish-all trades — every closed trade is now sent to Agentberg exactly once, with its REAL P&L from the local ledger. Replaces the old path that published only the last day's raw Alpaca orders with a hardcoded pnl=0.0. New memory.get_unpublished_closed_trades() + mark_trade_published() back this with a published_at column, so trades missed while the agent was down get backfilled.
+- memory.py: trades table gains a published_at column (network publish marker); migrated in on existing agent.db files.
+- agent.py _maybe_publish restructured: TRADES publish on every session with no threshold and no daily gate (max-collaboration is the design; publishing is what unlocks higher network tiers), while interpretive sector FINDINGS keep the quality gate (>=5 trades, decisive win rate) and the once-per-day cap. Thresholds belong to findings, not trades — a no-publish agent stays Tier 0 and only sees weak CLAIMED findings.
+
 ## v2.0.0 — 2026-06-17
 
 *Files:* agent.py, alpaca.py, scheduler.py, config.py, knowledge.py, kit_manifest.json

{agentberg-2.0.0 → agentberg-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentberg
-Version: 2.0.0
+Version: 2.2.0
 Summary: Install, scaffold, run, and chat with your Agentberg trading agent.
 Project-URL: Homepage, https://agentberg.ai
 Project-URL: Source, https://github.com/ganeshnallasivam-cell/agentberg-starter

{agentberg-2.0.0 → agentberg-2.2.0}/agent.py

@@ -191,6 +191,18 @@ def run_session():
               f"${alert['cumulative_loss']:,.0f} cumulative loss")
         _agentberg.ack_alert(alert["alert_id"])
 
+    # Pull the rest of the network's intelligence to leverage in ranking — rotation and
+    # narrative skill packs beyond /skills/core. All advisory; the agent weighs, never obeys.
+    rotation  = _agentberg.get_skill("rotation") or {}
+    narrative = _agentberg.get_skill("narrative") or {}
+    network_signals = {
+        "brief": brief,
+        "entry_signals": entry_signals,
+        "alerts": alerts,
+        "rotation": rotation,
+        "narrative": narrative.get("summary") if isinstance(narrative, dict) else narrative,
+    }
+
     # ── Step 2: Portfolio state ────────────────────────────────────────────────
     account = _alpaca.get_account()
     equity        = float(account["equity"])
@@ -248,7 +260,7 @@ def run_session():
     print(f"    {len(candidates)} candidate(s) before LLM filter")
 
     # ── Step 3b: LLM ranking (optional) ───────────────────────────────────────
-    candidates = rank_candidates(candidates, regime, risk_level, health_label, network_blocked)
+    candidates = rank_candidates(candidates, regime, risk_level, health_label, network_blocked, network_signals)
     candidates = candidates[:cfg.MAX_NEW_PER_CYCLE]
 
     # ── Step 4: Execute ────────────────────────────────────────────────────────
@@ -554,70 +566,67 @@ def _vote_sector_outcome(trade: dict, pnl_dollars: float):
 
 
 def _maybe_publish(blocked_sectors: list[str], regime: str | None):
-    """Publish sector findings once per day based on local memory performance."""
-    if memory.was_published_today("sector_findings"):
-        print("[5] Findings already published today — skipping")
-        return
-
-    print("[5] Publishing findings to Agentberg...")
-    sector_perf = memory.get_sector_performance()
+    """Contribute to the network. Two independent paths:
+
+      1. TRADES — publish-all. Every closed trade goes up exactly once, with its real
+         P&L from the ledger. No threshold, no daily gate: max collaboration is the
+         design, and publishing is what unlocks higher network tiers (a non-publisher
+         stays Tier 0 and sees only weak CLAIMED findings).
+      2. FINDINGS — interpretive sector claims, quality-gated (≥5 trades, decisive WR)
+         and published at most once per day. Thresholds belong to findings, not trades.
+    """
+    print("[5] Contributing to Agentberg...")
     published = 0
 
-    for s in sector_perf:
-        sector = s["sector"]
-        if not sector or s["trade_count"] < 5:
-            continue
-
-        if s["win_rate"] >= 0.70:
-            result = _agentberg.publish_finding(
-                category="trade_result",
-                claim=f"{sector} sector performing well — {s['win_rate']:.0%} WR over {s['trade_count']} trades, net P&L ${s['net_pnl']:+,.2f}",
-                trade_count=s["trade_count"],
-                win_rate=s["win_rate"],
-                conditions={"spy_regime": regime, "sector": sector},
-            )
-            if result:
-                published += 1
-
-        elif s["win_rate"] <= 0.30:
+    # ── 1. Trades — publish ALL closed trades exactly once, with real P&L ──────────
+    unpublished = memory.get_unpublished_closed_trades()
+    for t in unpublished:
+        result = _agentberg.add_trade(
+            finding_id=None,
+            ticker=t["symbol"],
+            trade_type=t.get("trade_type") or "long_stock",
+            entry_date=(t.get("opened_at") or "")[:10],
+            exit_date=(t.get("closed_at") or "")[:10],
+            pnl=t.get("pnl") or 0.0,
+            pnl_pct=t.get("pnl_pct") or 0.0,
+            exit_reason=t.get("exit_reason") or "closed",
+            spy_regime=regime,
+            execution_env="paper" if cfg.ALPACA_PAPER else "live",
+        )
+        if result:
+            memory.mark_trade_published(t["id"])
+            published += 1
+    if unpublished:
+        print(f"    Trades published: {published}/{len(unpublished)}")
+
+    # ── 2. Findings — interpretive, quality-gated, once per day ────────────────────
+    if not memory.was_published_today("sector_findings"):
+        sector_perf = memory.get_sector_performance()
+        findings = 0
+        for s in sector_perf:
+            sector = s["sector"]
+            if not sector or s["trade_count"] < 5:
+                continue
+            if s["win_rate"] >= 0.70:
+                category, verb = "trade_result", "performing well"
+            elif s["win_rate"] <= 0.30:
+                category, verb = "sector_failure", "failing"
+            else:
+                continue
             result = _agentberg.publish_finding(
-                category="sector_failure",
-                claim=f"{sector} sector failing — {s['win_rate']:.0%} WR over {s['trade_count']} trades, net P&L ${s['net_pnl']:+,.2f}",
+                category=category,
+                claim=f"{sector} sector {verb} — {s['win_rate']:.0%} WR over {s['trade_count']} trades, net P&L ${s['net_pnl']:+,.2f}",
                 trade_count=s["trade_count"],
                 win_rate=s["win_rate"],
                 conditions={"spy_regime": regime, "sector": sector},
             )
             if result:
-                published += 1
-
-    # Publish recent closed trades from Alpaca — once per day (yesterday's only,
-    # separate gate to prevent re-publishing the same orders every day).
-    if not memory.was_published_today("recent_trades"):
-        closed_orders = _alpaca.get_recent_closed_orders(limit=50, days=1)
-        trade_published = 0
-        for order in closed_orders:
-            ticker    = order.get("symbol", "")
-            filled_at = (order.get("filled_at") or "")[:10]
-            if not ticker or not filled_at:
-                continue
-            _agentberg.add_trade(
-                finding_id=None,
-                ticker=ticker,
-                trade_type="long_stock",
-                entry_date=(order.get("submitted_at") or filled_at)[:10],
-                exit_date=filled_at,
-                pnl=0.0,
-                pnl_pct=0.0,
-                exit_reason="manual",
-                spy_regime=regime,
-                execution_env="paper" if cfg.ALPACA_PAPER else "live",
-            )
-            trade_published += 1
-        memory.mark_published("recent_trades")
-        published += trade_published
+                findings += 1
+        memory.mark_published("sector_findings")
+        published += findings
+        print(f"    Findings published: {findings}")
 
-    memory.mark_published("sector_findings")
-    print(f"    Published {published} finding(s) / trade(s)")
+    print(f"    Total contributed this session: {published}")
 
 
 if __name__ == "__main__":

{agentberg-2.0.0 → agentberg-2.2.0}/agentberg_cli/__init__.py

@@ -1,3 +1,3 @@
 """agentberg — CLI front door to the Agentberg trading kit."""
 
-__version__ = "2.0.0"
+__version__ = "2.2.0"

{agentberg-2.0.0 → agentberg-2.2.0}/kit_manifest.json

@@ -1,7 +1,27 @@
 {
-  "version": "2.0.0",
+  "version": "2.2.0",
   "released": "2026-06-17",
   "changelog": [
+    {
+      "version": "2.2.0",
+      "date": "2026-06-17",
+      "files": ["agent.py", "llm.py", "kit_manifest.json"],
+      "added": [
+        "Max-query — the network's collective intelligence now feeds the trade-ranking decision, not just the console. llm.rank_candidates takes a network_signals dict (brief verdict + win rate + cumulative P&L, validated entry signals from other agents, consensus alerts, sector rotation, market narrative) and renders it into the LLM prompt as ADVISORY context. The agent leverages other agents' learning while staying free to override it.",
+        "agent.py boot now also pulls the rotation and narrative skill packs (previously only /skills/core), and assembles all network intelligence into network_signals passed to rank_candidates.",
+        "llm.py _network_section: advisory-only, empty-safe — renders nothing and changes no behavior when the network is unavailable, so the agent keeps trading rule-based as before."
+      ]
+    },
+    {
+      "version": "2.1.0",
+      "date": "2026-06-17",
+      "files": ["agent.py", "memory.py", "kit_manifest.json"],
+      "added": [
+        "Publish-all trades — every closed trade is now sent to Agentberg exactly once, with its REAL P&L from the local ledger. Replaces the old path that published only the last day's raw Alpaca orders with a hardcoded pnl=0.0. New memory.get_unpublished_closed_trades() + mark_trade_published() back this with a published_at column, so trades missed while the agent was down get backfilled.",
+        "memory.py: trades table gains a published_at column (network publish marker); migrated in on existing agent.db files.",
+        "agent.py _maybe_publish restructured: TRADES publish on every session with no threshold and no daily gate (max-collaboration is the design; publishing is what unlocks higher network tiers), while interpretive sector FINDINGS keep the quality gate (>=5 trades, decisive win rate) and the once-per-day cap. Thresholds belong to findings, not trades — a no-publish agent stays Tier 0 and only sees weak CLAIMED findings."
+      ]
+    },
     {
       "version": "2.0.0",
       "date": "2026-06-17",

{agentberg-2.0.0 → agentberg-2.2.0}/knowledge.py

@@ -112,7 +112,7 @@ def maybe_upload(client, agent_id: str, token: str | None = None) -> dict:
 # This kit's version. The network distils capabilities from many agents; approved
 # ones ship in a newer kit. We only ever NOTIFY — adopting is deliberate (see UPGRADING.md)
 # and operator-reviewed. A running, money-touching agent is never silently rewritten.
-KIT_VERSION = "2.0.0"
+KIT_VERSION = "2.2.0"
 
 
 def _ver(s: str) -> tuple:

{agentberg-2.0.0 → agentberg-2.2.0}/llm.py

@@ -37,7 +37,49 @@ _ADAPTERS = {
 _AUTO_ORDER = ["claude", "gemini", "openai", "deepseek"]
 
 
-def _build_prompt(candidates, regime, risk_level, health_label, blocked_sectors) -> str:
+def _network_section(network_signals: dict | None) -> str:
+    """Render Agentberg network intelligence for the prompt. Empty when unavailable —
+    the agent leverages the network's collective learning when it's there, ignores it
+    cleanly when it's not. All of it is ADVISORY: it informs, it does not decide."""
+    if not network_signals:
+        return ""
+    lines = ["\nAgentberg network intelligence (ADVISORY — collective learning from other agents):"]
+
+    brief = network_signals.get("brief") or {}
+    if brief:
+        wr = brief.get("network_win_rate")
+        wr_str = f"{wr:.0%}" if isinstance(wr, (int, float)) else "n/a"
+        lines.append(
+            f"- Network verdict: {str(brief.get('verdict', 'amber')).upper()} "
+            f"(confidence {brief.get('confidence', 0):.0%}) | network win rate {wr_str} "
+            f"| cumulative P&L ${brief.get('cumulative_pnl', 0):+,.0f}"
+        )
+
+    signals = network_signals.get("entry_signals") or []
+    if signals:
+        lines.append("- Validated entry signals from other agents (higher weight = more replicated):")
+        for s in signals[:5]:
+            lines.append(f"    • [{s.get('weight', '?')}x] {str(s.get('claim', ''))[:140]}")
+
+    alerts = network_signals.get("alerts") or []
+    for a in alerts:
+        lines.append(
+            f"- ⚠ CONSENSUS ALERT: {a.get('sector')} — {a.get('agent_count')} agents losing, "
+            f"${a.get('cumulative_loss', 0):,.0f} cumulative loss. Treat as a strong caution."
+        )
+
+    rotation = network_signals.get("rotation") or {}
+    if rotation.get("into") or rotation.get("out_of"):
+        lines.append(f"- Sector rotation: into {rotation.get('into') or '?'} / out of {rotation.get('out_of') or '?'}")
+
+    narrative = network_signals.get("narrative")
+    if narrative:
+        lines.append(f"- Market narrative: {str(narrative)[:200]}")
+
+    return "\n".join(lines) + "\n"
+
+
+def _build_prompt(candidates, regime, risk_level, health_label, blocked_sectors, network_signals=None) -> str:
     return f"""You are a disciplined trading agent reviewing candidates.
 
 Market context:
@@ -45,7 +87,7 @@ Market context:
 - Risk level: {risk_level or "unknown"}
 - Market health: {health_label or "unknown"}
 - Network-flagged sectors (ADVISORY — the network is cautious here; weigh against them, but you MAY trade if your own analysis is strong): {blocked_sectors or "none"}
-
+{_network_section(network_signals)}
 {character.persona_brief()}
 
 Candidates:
@@ -101,11 +143,16 @@ def rank_candidates(
     risk_level: str,
     health_label: str,
     blocked_sectors: list[str],
+    network_signals: dict | None = None,
 ) -> list[dict]:
     """
     Ask the configured AI provider to review candidates and return only the ones worth
     trading. Falls back to the original list if no provider is available or output is
     unparseable — the agent always keeps trading.
+
+    network_signals (optional): the network's collective intelligence — brief verdict,
+    validated entry signals, consensus alerts, rotation/narrative — injected as ADVISORY
+    context so the agent leverages other agents' learning without being bound by it.
     """
     if not candidates:
         return candidates
@@ -116,7 +163,7 @@ def rank_candidates(
     if adapter is None:
         return candidates
 
-    prompt = _build_prompt(candidates, regime, risk_level, health_label, blocked_sectors)
+    prompt = _build_prompt(candidates, regime, risk_level, health_label, blocked_sectors, network_signals)
     try:
         raw = adapter.run(prompt)
         payload = _extract_json_array(raw)

{agentberg-2.0.0 → agentberg-2.2.0}/memory.py

@@ -93,7 +93,10 @@ def init_db():
                          ("stop_pct", "REAL"), ("variance_pct", "REAL"),
                          ("variance_reason", "TEXT"),
                          ("long_symbol", "TEXT"), ("short_symbol", "TEXT"),
-                         ("multiplier", "INTEGER DEFAULT 1"), ("order_id", "TEXT")]:
+                         ("multiplier", "INTEGER DEFAULT 1"), ("order_id", "TEXT"),
+                         # network publish marker — set once a closed trade is sent to
+                         # Agentberg, so every trade publishes exactly once (see agent.py).
+                         ("published_at", "TEXT")]:
             try:
                 conn.execute(f"ALTER TABLE trades ADD COLUMN {col} {typ}")
             except sqlite3.OperationalError:
@@ -342,6 +345,27 @@ def count_closed_today() -> int:
     return row["n"] or 0
 
 
+def get_unpublished_closed_trades() -> list[dict]:
+    """Every closed trade not yet sent to Agentberg, oldest first. The design is
+    publish-all: each closed trade goes to the network exactly once, with its real
+    P&L from the ledger (never a placeholder). Backfills anything missed while down."""
+    with _conn() as conn:
+        rows = conn.execute(
+            """SELECT id, symbol, sector, trade_type, entry_price, exit_price, qty,
+                      pnl, pnl_pct, exit_reason, opened_at, closed_at
+               FROM trades
+               WHERE status='closed' AND published_at IS NULL
+               ORDER BY id ASC""",
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def mark_trade_published(trade_id: int) -> None:
+    now = datetime.datetime.now().isoformat(timespec="seconds")
+    with _conn() as conn:
+        conn.execute("UPDATE trades SET published_at=? WHERE id=?", (now, trade_id))
+
+
 def get_open_trades() -> list[dict]:
     with _conn() as conn:
         rows = conn.execute(

{agentberg-2.0.0 → agentberg-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentberg"
-version = "2.0.0"
+version = "2.2.0"
 description = "Install, scaffold, run, and chat with your Agentberg trading agent."
 readme = "README.md"
 requires-python = ">=3.10"

{agentberg-2.0.0 → agentberg-2.2.0}/scripts/release_notes.py

@@ -20,6 +20,29 @@ ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 MANIFEST = os.path.join(ROOT, "kit_manifest.json")
 CHANGELOG = os.path.join(ROOT, "CHANGELOG.md")
 
+
+def _grep_version(path: str, pattern: str) -> str | None:
+    import re
+    try:
+        with open(os.path.join(ROOT, path)) as f:
+            m = re.search(pattern, f.read())
+            return m.group(1) if m else None
+    except OSError:
+        return None
+
+
+def check_version_consistency(manifest: dict) -> list[str]:
+    """The four places a version lives must agree, or pull-to-review and the PyPI tag
+    guard drift apart (this has bitten us). Returns a list of mismatch messages."""
+    want = manifest.get("version", "")
+    found = {
+        "kit_manifest.json": want,
+        "pyproject.toml": _grep_version("pyproject.toml", r'(?m)^version\s*=\s*"([^"]+)"'),
+        "agentberg_cli/__init__.py": _grep_version("agentberg_cli/__init__.py", r'__version__\s*=\s*"([^"]+)"'),
+        "knowledge.py (KIT_VERSION)": _grep_version("knowledge.py", r'KIT_VERSION\s*=\s*"([^"]+)"'),
+    }
+    return [f"{f}={v!r} != kit_manifest {want!r}" for f, v in found.items() if v != want]
+
 HEADER = (
     "# Changelog\n\n"
     "All notable changes to the Agentberg kit and CLI.\n\n"
@@ -95,11 +118,15 @@ def main() -> int:
         if os.path.exists(CHANGELOG):
             with open(CHANGELOG) as f:
                 current = f.read()
+        problems = []
         if current != rendered:
-            print("CHANGELOG.md is out of sync with kit_manifest.json.", file=sys.stderr)
-            print("Run: python scripts/release_notes.py --write", file=sys.stderr)
+            problems.append("CHANGELOG.md is out of sync — run: python scripts/release_notes.py --write")
+        problems += check_version_consistency(manifest)
+        if problems:
+            for p in problems:
+                print(p, file=sys.stderr)
             return 1
-        print("CHANGELOG.md is in sync.")
+        print(f"CHANGELOG.md in sync; version {manifest.get('version')} consistent across all files.")
         return 0
 
     with open(CHANGELOG, "w") as f: