zambo-loop 1.0.1__py3-none-any.whl

zambo_loop/__init__.py

@@ -0,0 +1,3 @@
+"""zambo-loop: the daily loop package for Zambo."""
+
+__version__ = "1.0.1"

zambo_loop/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

zambo_loop/bundle/RUN.md

@@ -0,0 +1,101 @@
+# Daily loop run: the proof record
+
+Executed live against https://zambo.dev/mcp on November 2, 2026.
+Job id (_session_id): `daily-loop-demo-2026-11-02`. One identity,
+`daily-loop-agent`, issued a fresh caller handle at initialize and
+persisted in a state file; three sessions ran under that same handle
+as separate processes. Pattern: recall, work, remember, wrap. This
+record includes the two refusals the run hit on the way, because they
+are the two lessons the package exists to teach.
+
+## Session 1: set the watch (20:46 UTC)
+
+- `live_price` BTC: $76,786.70, down 1.29% (24h), 20:46:29 UTC.
+  Receipt: https://zambo.dev/run/3ab3edf9-68c1-4419-b444-49853ddc7fca
+- `live_price` ETH: $2,247.14, down 0.69% (24h), 20:46:32 UTC.
+  Receipt: https://zambo.dev/run/326f0be5-f1fe-432c-a67d-01e56105531b
+- `memory_remember` the baseline state: REFUSED before execution.
+  The fact ran over the 500 character limit for a saved fact; the
+  endpoint rejected it with `invalid_tool_arguments` and issued the
+  refusal its own receipt:
+  https://zambo.dev/run/c7d11d3b-64da-4625-b246-42243674bf7c
+  Nothing was saved. A receipt link is not proof a call succeeded;
+  the result said so plainly, and the next session proved it.
+
+## Session 2: the honest empty recall (20:46 UTC)
+
+- `memory_recall` for the watch state returned status `empty`,
+  count 0, because session 1's save had never landed.
+  Receipt: https://zambo.dev/run/4adc6ece-9458-4e19-af64-6e4587b1dbbc
+- `live_price` BTC again: $76,848.93, 20:46:52 UTC.
+  Receipt: https://zambo.dev/run/dc2f54b4-aaa0-460d-b823-f951724bb102
+- `memory_remember` the session 2 update (inside the limit): saved.
+  Receipt: https://zambo.dev/run/43a95682-e2dc-4833-8dbe-cc43bd605670
+- `handover` wrap attempt: REFUSED with `receipt_access_denied`.
+  The wrap's receipt selection named the refused remember's receipt,
+  which is not an executed step of this job; a wrap holds only
+  receipts from its own job, and nothing was published.
+  Receipt: https://zambo.dev/run/5dad54f0-073d-4f1a-aecd-0d736d0d60c8
+
+## Repair: save the baseline, short (20:49 UTC)
+
+The same baseline state, written at 378 characters, saved cleanly:
+BTC baseline $76,786.70 and ETH baseline $2,247.14 with their price
+receipts inside the fact, and the alert rule in plain words (flag if
+BTC moves 3 percent or more from baseline, or ETH 4 percent or more).
+Receipt: https://zambo.dev/run/ba4a4143-d6db-4a4f-9834-af5056abd08f
+
+## Session 3: the loop closes (20:49 to 20:50 UTC)
+
+A third session, a new MCP session under the same saved handle:
+
+- `memory_recall` returned the baseline fact, and the check was
+  mechanical: the strings "BTC baseline $76,786.70", "ETH baseline
+  $2,247.14", and the alert rule all appear in the recalled text
+  verbatim, exactly as saved.
+  Receipt: https://zambo.dev/run/fd2d6820-cc7d-4474-995f-2b04ef707140
+- `live_price` BTC: $76,875.00, 20:49:54 UTC, a move of +0.115%
+  from the $76,786.70 baseline. Inside the 3 percent band: no alert.
+  Receipt: https://zambo.dev/run/e42b60ed-1dee-4360-bc4c-9b07ccb08250
+- `memory_remember` the session 3 update: saved.
+  Receipt: https://zambo.dev/run/1630f1f9-991e-40c1-a358-431c82dacae6
+- `handover` wrap, its receipt selection naming only this job's
+  executed steps (the two session 1 prices, the saved baseline
+  remember, the session 3 price, the session 3 remember):
+  https://zambo.dev/handover/60db250a-bf2a-4c8c-86da-b2ec8b7e150c
+  JSON twin: https://zambo.dev/handover/60db250a-bf2a-4c8c-86da-b2ec8b7e150c.json
+  Wrap receipt: https://zambo.dev/run/307d76af-cd16-4c2a-bd06-3206f6821c3c
+  The handover lists exactly those 5 steps, in order.
+
+## Accounting
+
+The loop's shape, per session: work and memory calls only. Session 1
+spent 2 counted calls (the prices; the refused remember executed
+nothing). The repair remember spent 1. Session 3 spent 3 (recall,
+price, remember) and its wrap was the free daily wrap-up. The whole
+proof, refusals and diagnostics included, stayed inside one identity's
+single day of free tier: 20 calls + 1 wrap-up free every day, keyed to
+the caller handle, and picking up a handover is always free.
+
+## The two lessons, which are the package
+
+1. A saved fact has a hard limit of 500 characters. Write facts like
+   headlines with receipts attached, not essays. And check the result
+   of every call: a refused call still hands you a receipt link, and
+   the next session's empty recall is what an unchecked refusal costs.
+2. A wrap is a job's own record. It binds the job's executed steps and
+   refuses a selection that names anything else. Keep the job's
+   receipt ids as you go, and the wrap is a formality; improvise the
+   selection, and the wrap refuses, receipted, with the reason.
+
+## Verification
+
+Every link above was fetched on 2026-11-02 after the run: all returned
+HTTP 200 (14 of 14, including both refusal receipts, the final
+handover page, and its JSON twin). One identity note, recorded for
+honesty: the first identity minted for this run was issued under this
+machine's shared default User-Agent and inherited a shared, already
+spent quota bucket (0 of 20 free calls before its first call), so it
+was replaced before any work was saved; the run above is the second
+identity, minted with the agent's own User-Agent from its first
+initialize, which is the discipline `loop.py` ships with.

zambo_loop/bundle/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: daily-loop
+description: Run a daily loop on Zambo: give one agent a persistent caller handle so it recalls yesterday's saved state, does today's work, remembers the update, and wraps the day into a handover the next session picks up. Use when an agent must come back day after day to the same job (a watch, a standup, a digest, a monitor), when work must survive the session that did it, or when a one-shot agent needs to become a standing one. Zambo is the memory and work layer under the loop (endpoint https://zambo.dev/mcp); it does not schedule or wake agents.
+---
+
+# The daily loop on Zambo
+
+Most agents are one-shot: they arrive knowing nothing, do the job,
+and evaporate. The daily loop is the opposite shape. One agent, one
+persistent identity, and a four-beat rhythm it repeats every session:
+recall, work, remember, wrap. Yesterday's session leaves state in
+memory and a handover as the day's deliverable; today's session picks
+the handover up, recalls the state verbatim, does the work, and
+writes the next state down. Memory is not a feature of this pattern.
+Memory is the pattern: it is what gives the agent a reason, and the
+means, to come back.
+
+This skill ships inside the zambo-daily-loop package. Next to it you
+will find `loop.py`, a runnable single-agent loop; `pastes/` with the
+no-code standing instructions for chat agents; and `RUN.md`, a real
+three-session run on the live endpoint with every receipt linked,
+including the two refusals the run hit and what they teach.
+
+## Step zero: your handle is your memory
+
+On initialize, the endpoint issues a caller handle (in the initialize
+result and the `X-Zambo-Caller-Handle` header). Save it in your own
+state file before doing anything else, and present it as
+`_caller_handle` on every call, with your agent name as
+`_caller_label`. Your saved facts, your job timelines, and your daily
+free allowance all key to that handle. Present the same handle in a
+new session and you are the same agent, with yesterday intact. Lose
+it, and you come back as a stranger: no memory, a fresh allowance, no
+continuity. One handle per agent, never shared, never shown in
+ordinary replies. Use a User-Agent of your own from the very first
+initialize: the quota handle is issued against your network identity,
+and a shared default can inherit a shared, already spent bucket.
+
+## The four beats
+
+1. **Pick up.** If yesterday wrapped a handover, accept it with
+   `handover_accept`. Pickup is always free, and the handover returns
+   the day's steps and receipts whole.
+2. **Recall.** `memory_recall` the state the job depends on: the
+   baselines, the rule, where things stopped. Check the recalled text
+   against what the job needs, verbatim, before you trust it. An
+   empty recall is information, not an error: it means yesterday
+   saved nothing, which usually means a save was refused and nobody
+   checked.
+3. **Work.** Do the actual job. Every call returns a verifiable
+   receipt; keep the receipt links of the steps that matter.
+4. **Remember, then wrap.** `memory_remember` the one or two facts
+   tomorrow needs, then close the day with `handover`: a summary of
+   what happened, the goal, a recipient, next steps, and the job's
+   receipt ids attached. That handover is the deliverable the next
+   session, or the next AI, picks up.
+
+## The two disciplines that make or break the loop
+
+**Facts are short.** A saved fact has a hard limit of 500 characters.
+A longer `memory_remember` is refused before execution, receipted,
+and nothing is saved. Write facts like headlines with receipts
+attached: the value, the receipt link, the rule, the next action.
+And check the result of every call, not just its receipt link: a
+refused call still hands you a receipt, and the cost of an unchecked
+refusal is tomorrow's empty recall.
+
+**A wrap holds only its own job's receipts.** The wrap binds the
+job's executed steps and runs a proof loop over them. Name a receipt
+from outside the job, or one from a call that was refused, and the
+wrap itself is refused, receipted, with the reason. Track the job's
+receipt ids as you work (the prices and the memory saves), and the
+wrap is a formality.
+
+## The accounting (why this shape, in numbers)
+
+Free tier, per agent: 20 calls + 1 wrap-up free every day, keyed to
+the agent's own caller handle; picking up a handover is always free.
+The run in `RUN.md` ran the loop's sessions at 2 to 3 counted calls
+each, wrap included free, so a daily agent on this shape runs free
+indefinitely. When the agent outgrows the free shape, a Day Pass is
+$0.99, unlimited for 24 hours, and the Zambo Pass is $29 for 30 days;
+both are one-time payments, never subscriptions, on the same
+endpoint. Entry point for a human setting this up:
+https://zambo.dev/add/
+
+## What this does not do
+
+Zambo does not wake your agent up. Your scheduler, cron, or operator
+starts each session; the loop is what the session does once started.
+It also does not make recalled state correct: a receipt proves the
+saved result was not changed since it was saved, never that the
+answer was right. The loop makes an agent's days add up instead of
+resetting, and makes each day checkable.
+
+## The Zambo pattern family: five packages, one work layer
+
+Zambo is the verifiable work layer for AI: 153 tools behind one MCP endpoint (https://zambo.dev/mcp), a verifiable AER-1 receipt for every job, and handovers that move work between agents. Free tier: 20 calls + 1 wrap-up free every day per caller handle, picking up a handover is always free. Day Pass: $0.99 for unlimited calls for 24 hours. Zambo Pass: $29 for 30 days. A receipt proves the saved result was not changed; it does not prove the answer was right.
+
+The five packages below are one family, proven in one set of live runs on November 2, 2026. The swarm run put 4 agents on one shared job in 8 counted calls and closed it as a 6-step handover: https://zambo.dev/handover/a154789b-0588-43c7-a31c-d108eb59406b . Each package teaches one pattern by doing it, with Zambo as the mechanism underneath. Install one, or compose them: a watch feeds a loop, a loop hands its job to a swarm, delivery proves the result to a client, and verify-pass checks any retelling of that result against the receipt of record.
+
+### 1. zambo-swarm: swarm coordination
+
+Use it when: the job is bigger than one agent and several workers must each prove their piece of one shared job.
+
+Real run: https://zambo.dev/handover/a154789b-0588-43c7-a31c-d108eb59406b (4 agents, 8 counted calls, 6-step handover)
+
+- PyPI: https://pypi.org/project/zambo-swarm/
+- npm: https://www.npmjs.com/package/zambo-swarm
+- Repo: https://github.com/zambodotdev/zambo-swarm-coordination
+- Guide: https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html
+- Article: https://dev.to/rambozambo/four-agents-one-job-zero-trust-a-swarm-where-every-worker-proves-its-piece-35ol
+
+### 2. zambo-loop: the daily loop
+
+Use it when: an agent must pick up its own work tomorrow, recall its baseline verbatim, and keep one job alive across sessions.
+
+Real run: https://zambo.dev/handover/60db250a-bf2a-4c8c-86da-b2ec8b7e150c
+
+- npm: https://www.npmjs.com/package/zambo-loop
+- Repo: https://github.com/zambodotdev/zambo-daily-loop
+- Guide: https://rambozambodotdev.gitlab.io/aer1-hub/daily-loop-package.html
+- Article: https://dev.to/rambozambo/the-daily-loop-as-an-installable-package-2e89
+- Note: the PyPI listing for zambo-loop is pending; use npm or the repo for now.
+
+### 3. zambo-verify-pass: the verify pass
+
+Use it when: someone retells a result and you need to catch the drift against the receipt of record.
+
+Real run: https://zambo.dev/handover/fa7444ae-e3c7-4206-ae12-3adb5e749fb0
+
+- PyPI: https://pypi.org/project/zambo-verify-pass/
+- npm: https://www.npmjs.com/package/zambo-verify-pass
+- Repo: https://github.com/zambodotdev/zambo-verify-pass
+- Guide: https://rambozambodotdev.gitlab.io/aer1-hub/verify-pass-package.html
+- Article: https://dev.to/rambozambo/the-price-was-wrong-the-receipt-was-not-catching-a-drifted-retelling-with-a-verify-pass-188i
+
+### 4. zambo-delivery: delivery proof
+
+Use it when: a client must check delivered work step by step and their pickup is the sign-off.
+
+Proof handover: https://zambo.dev/handover/31715914-80eb-438d-b01b-d2307cc4800e
+
+- PyPI: https://pypi.org/project/zambo-delivery/
+- npm: https://www.npmjs.com/package/zambo-delivery
+- Repo: https://github.com/zambodotdev/zambo-delivery-proof
+- Guide: https://rambozambodotdev.gitlab.io/aer1-hub/delivery-proof-package.html
+- Article: https://dev.to/rambozambo/one-job-one-link-zero-arguments-a-delivery-your-client-checks-step-by-step-4j4
+
+### 5. zambo-watch: signal watch
+
+Use it when: one watcher checks the same signal on a schedule and must prove what it saw, quiet days included.
+
+Digest handover: https://zambo.dev/handover/121aa53f-1981-4330-9133-49e386aabf1e
+
+- PyPI: https://pypi.org/project/zambo-watch/
+- npm: https://www.npmjs.com/package/zambo-watch
+- Repo: https://github.com/zambodotdev/zambo-signal-watch
+- Guide: https://rambozambodotdev.gitlab.io/aer1-hub/signal-watch-package.html
+- Article: https://dev.to/rambozambo/one-watcher-three-prices-one-rule-an-agent-watch-that-remembers-its-baseline-34kg
+
+### How the five compose
+
+1. zambo-watch checks a signal on a schedule and saves what it saw, quiet days included.
+2. A change the watch catches becomes the next run of zambo-loop, which recalls its baseline verbatim and keeps the job alive across sessions.
+3. When the job outgrows one agent, the loop hands it to zambo-swarm, where each worker proves its own piece of the shared job.
+4. zambo-delivery wraps the finished work as one handover the client checks step by step; the client pickup is the sign-off.
+5. zambo-verify-pass checks any later retelling of the result against the receipt of record and catches the drift.
+
+Start free: https://zambo.dev/add/ . Verify any receipt: https://zambo.dev/verify/ . The family page: https://rambozambodotdev.gitlab.io/aer1-hub/the-pattern-family.html
+
+## Go deeper
+
+- Full guide, with the real run and every receipt:
+  https://rambozambodotdev.gitlab.io/aer1-hub/daily-loop-package.html
+- Article, the write-up of the live run: https://dev.to/rambozambo/the-daily-loop-as-an-installable-package-2e89
+- This package: https://github.com/zambodotdev/zambo-daily-loop
+- The loop's data story (4,247 callers counted, 17 stayed):
+  https://dev.to/rambozambo/4247-callers-came-17-stayed-here-is-the-loop-the-17-run-2o51
+- The starter repo, the loop pre-wired:
+  https://github.com/zambodotdev/zambo-memory-loop-starter
+- Setup for the human who runs you: https://zambo.dev/add/

zambo_loop/bundle/loop.py

@@ -0,0 +1,437 @@
+#!/usr/bin/env python3
+"""The daily loop, as runnable code: recall, work, remember, wrap.
+
+One agent, one persistent caller handle, one job that survives the
+session. Two commands, because a day has two halves:
+
+    python3 loop.py start      # day one: price the watch, save the
+                               # baseline state to memory
+    python3 loop.py continue   # every later session: recall the state
+                               # verbatim, re-check, remember the
+                               # update, wrap the day into a handover
+
+The handle is the whole trick. On initialize the endpoint issues a
+caller handle; this script saves it in a state file next to itself
+before doing anything else, and presents it on every call, in every
+later process, forever. Memory, the job timeline, and the daily free
+allowance all key to that handle. Lose the state file and the agent
+comes back as a stranger: no memory, no continuity.
+
+Three field lessons are baked in, each learned from a real refusal:
+
+1. Facts have a hard limit of 500 characters. A longer memory_remember
+   is refused before execution, receipted, and nothing is saved. Keep
+   facts short; put the receipts in them, not the essay.
+2. A refused call still returns a receipt. This script checks every
+   result for errors and stops loudly instead of collecting receipts
+   for work that never happened.
+3. A wrap holds only receipts from its own job. The wrap below names
+   only this job's executed steps (prices and memory saves), which the
+   state file tracks across sessions.
+
+Cost: start is 3 counted calls; continue is 3 counted calls (the
+recall, the price, the remember) plus the free daily wrap-up. The free
+tier is 20 calls + 1 wrap-up per day, keyed to the handle, so the loop
+runs free. No API key, no signup. Every call returns an AER-1 receipt
+link; a receipt proves the saved result was not changed, never that
+the answer was right.
+
+The pattern, taught end to end with a real run and its receipts:
+https://rambozambodotdev.gitlab.io/aer1-hub/daily-loop-package.html
+"""
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import time
+import urllib.request
+from pathlib import Path
+
+MCP_URL = os.environ.get("ZAMBO_MCP_URL", "https://zambo.dev/mcp")
+AGENT_ID = os.environ.get("ZAMBO_AGENT_ID", "daily-loop-agent")
+AGENT_NAME = os.environ.get("ZAMBO_AGENT_NAME", "Daily Loop Agent")
+JOB_ID = os.environ.get("ZAMBO_SESSION_ID", "daily-loop-demo")
+ASSETS = [
+    a.strip().upper()
+    for a in os.environ.get("ZAMBO_ASSETS", "BTC,ETH").split(",")
+    if a.strip()
+]
+ALERT_PCT = {
+    "BTC": float(os.environ.get("ZAMBO_ALERT_BTC", "3")),
+    "ETH": float(os.environ.get("ZAMBO_ALERT_ETH", "4")),
+}
+
+HERE = Path(__file__).parent
+# Step zero: the state file IS the identity. Handle, baselines, and
+# the job's receipt ids live here, across processes and days.
+STATE_FILE = HERE / f".zambo-loop-state-{AGENT_ID}.json"
+
+RUN_URL_RE = re.compile(r"https://zambo\.dev/run/[0-9a-f-]{36}")
+PRICE_RE = re.compile(r"\$([0-9][0-9,]*\.?[0-9]*)")
+
+FACT_LIMIT = 500
+
+
+def fmt_price(p):
+    return f"${p:,.2f}"
+
+
+class ZamboClient:
+    """Minimal MCP client over streamable HTTP, standard library only."""
+
+    def __init__(self, state):
+        self.state = state
+        self.session_id = None
+        self._header_handle = None
+        self._next_id = 0
+
+    @property
+    def caller_handle(self):
+        return self.state.get("caller_handle")
+
+    @property
+    def quota_handle(self):
+        return self.state.get("quota_handle")
+
+    def _headers(self):
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            "X-Agent-Id": AGENT_ID,
+            "X-Agent-Name": AGENT_NAME,
+            # A User-Agent of the agent's own from the very first
+            # initialize: the quota handle is issued against the
+            # caller's network identity, and a shared default UA can
+            # inherit a shared, already-spent bucket.
+            "User-Agent": f"{AGENT_ID}/1.0",
+        }
+        if self.session_id:
+            headers["Mcp-Session-Id"] = self.session_id
+        return headers
+
+    def _absorb_headers(self, header_block):
+        for line in header_block.splitlines():
+            if ":" not in line:
+                continue
+            name, value = line.split(":", 1)
+            name, value = name.strip().lower(), value.strip()
+            if name == "mcp-session-id" and value and self.session_id is None:
+                self.session_id = value
+            elif name == "x-zambo-caller-handle" and value:
+                self._header_handle = value
+
+    def _post_curl(self, payload):
+        # curl is the transport when present: no Python dependencies, and
+        # it rides out flaky proxies that clip urllib response bodies.
+        cmd = ["curl", "-sS", "--http1.1", "-i", "-X", "POST", MCP_URL,
+               "--data-binary", "@-"]
+        for k, v in self._headers().items():
+            cmd += ["-H", f"{k}: {v}"]
+        cmd += ["-H", "Expect:"]
+        out = subprocess.run(cmd, input=json.dumps(payload).encode(),
+                             capture_output=True, timeout=120)
+        if out.returncode != 0:
+            raise RuntimeError(f"curl transport failed: {out.stderr.decode()[:200]}")
+        raw = out.stdout.decode()
+        # With -i the header block(s) precede the body; take the last one.
+        parts = raw.split("\r\n\r\n")
+        if len(parts) < 2:
+            parts = raw.split("\n\n")
+        body = parts[-1]
+        for block in parts[:-1]:
+            if "mcp-session-id" in block.lower() or "x-zambo" in block.lower():
+                self._absorb_headers(block)
+        return body
+
+    def _post_urllib(self, payload):
+        req = urllib.request.Request(
+            MCP_URL, data=json.dumps(payload).encode(),
+            headers=self._headers(), method="POST")
+        with urllib.request.urlopen(req, timeout=90) as resp:
+            block = "\n".join(f"{k}: {v}" for k, v in resp.headers.items())
+            self._absorb_headers(block)
+            return resp.read().decode()
+
+    def _post(self, payload, expect_response=True):
+        raw = None
+        last = None
+        for attempt in range(3):
+            try:
+                if shutil.which("curl"):
+                    raw = self._post_curl(payload)
+                else:
+                    raw = self._post_urllib(payload)
+                break
+            except Exception as e:
+                last = e
+                raw = None
+                if attempt < 2:
+                    time.sleep(2 * (attempt + 1))
+        if raw is None:
+            raise last
+        if self._header_handle and not self.caller_handle:
+            self.state["caller_handle"] = self._header_handle
+            self._save()
+        if not expect_response:
+            return None
+        return self._parse_rpc(raw)
+
+    @staticmethod
+    def _parse_rpc(raw):
+        message = None
+        for line in raw.splitlines():
+            line = line.strip()
+            if line.startswith("data:"):
+                try:
+                    message = json.loads(line[5:])
+                except Exception:
+                    pass
+        if message is None:
+            message = json.loads(raw)
+        if "error" in message:
+            raise RuntimeError(f"MCP error: {message['error']}")
+        return message.get("result", {})
+
+    def initialize(self):
+        params = {
+            "protocolVersion": "2025-03-26",
+            "capabilities": {},
+            "clientInfo": {"name": AGENT_NAME, "version": "1.0.0"},
+        }
+        if self.caller_handle:
+            params["_meta"] = {
+                "caller_handle": self.caller_handle,
+                "quota_handle": self.quota_handle,
+            }
+        result = self._post(
+            {"jsonrpc": "2.0", "id": self._id(), "method": "initialize", "params": params}
+        )
+        for container in (result.get("_meta", {}), result.get("meta", {})):
+            if not self.caller_handle and container.get("caller_handle"):
+                self.state["caller_handle"] = container["caller_handle"]
+            if not self.quota_handle and container.get("quota_handle"):
+                self.state["quota_handle"] = container["quota_handle"]
+        self._save()
+        self._post(
+            {"jsonrpc": "2.0", "method": "notifications/initialized"},
+            expect_response=False,
+        )
+        return result
+
+    def call_tool(self, name, arguments):
+        args = dict(arguments)
+        if self.caller_handle:
+            args["_caller_handle"] = self.caller_handle
+        args.setdefault("_caller_label", AGENT_ID)
+        params = {"name": name, "arguments": args}
+        if self.quota_handle:
+            params["_meta"] = {
+                "quota_handle": self.quota_handle,
+                "caller_handle": self.caller_handle,
+            }
+        result = self._post(
+            {"jsonrpc": "2.0", "id": self._id(), "method": "tools/call", "params": params}
+        )
+        # A refused call still returns a receipt. Check the result
+        # itself, never just the receipt link.
+        structured = result.get("structuredContent") or {}
+        error = structured.get("error") if isinstance(structured, dict) else None
+        if result.get("isError") or error:
+            raise RuntimeError(f"{name} refused: {json.dumps(error)[:240] if error else result}")
+        handle = structured.get("caller_handle")
+        if handle and not self.caller_handle:
+            self.state["caller_handle"] = handle
+            self._save()
+        return result
+
+    def _save(self):
+        STATE_FILE.write_text(json.dumps(self.state, indent=2))
+
+    def _id(self):
+        self._next_id += 1
+        return self._next_id
+
+
+def receipt_link(result):
+    structured = result.get("structuredContent") or {}
+    for key in ("receipt_url", "run_url", "url"):
+        value = structured.get(key)
+        if isinstance(value, str) and "/run/" in value:
+            return value
+    match = RUN_URL_RE.search(json.dumps(result))
+    return match.group(0) if match else None
+
+
+def result_text(result):
+    out = []
+    for block in result.get("content", []):
+        if block.get("type") == "text":
+            out.append(block["text"])
+    if result.get("structuredContent"):
+        out.append(json.dumps(result["structuredContent"]))
+    return "\n".join(out)
+
+
+def parse_price(result):
+    match = PRICE_RE.search(result_text(result))
+    return float(match.group(1).replace(",", "")) if match else None
+
+
+def load_state():
+    try:
+        return json.loads(STATE_FILE.read_text())
+    except Exception:
+        return {}
+
+
+def remember(client, state, fact):
+    assert len(fact) <= FACT_LIMIT, f"fact is {len(fact)} chars; the limit is {FACT_LIMIT}"
+    result = client.call_tool(
+        "memory_remember",
+        {"fact": fact, "agent_name": AGENT_NAME, "_session_id": JOB_ID},
+    )
+    link = receipt_link(result)
+    if link:
+        state.setdefault("receipt_ids", []).append(link.rsplit("/", 1)[-1])
+    return link
+
+
+def start(client, state):
+    # Work: price the watch. Real calls, real receipts.
+    baselines = {}
+    for symbol in ASSETS:
+        result = client.call_tool("live_price", {"symbol": symbol, "_session_id": JOB_ID})
+        price = parse_price(result)
+        link = receipt_link(result)
+        baselines[symbol] = {"price": price, "receipt": link}
+        if link:
+            state.setdefault("receipt_ids", []).append(link.rsplit("/", 1)[-1])
+        print(f"[start] {symbol} {fmt_price(price)}  receipt: {link}")
+    state["baselines"] = baselines
+    state["day"] = time.strftime("%Y-%m-%d", time.gmtime())
+
+    # Remember: save the state tomorrow's session will recall. Short
+    # fact, receipts inside, the rule in plain words.
+    parts = [f"Daily loop watch, day 1 baseline, {state['day']}."]
+    for symbol in ASSETS:
+        parts.append(
+            f"{symbol} baseline {fmt_price(baselines[symbol]['price'])} "
+            f"(receipt {baselines[symbol]['receipt']})."
+        )
+    rules = " or ".join(
+        f"{s} {ALERT_PCT.get(s, 3):g} percent" for s in ASSETS
+    )
+    parts.append(
+        f"Alert rule: flag if an asset moves from baseline by {rules} or more. "
+        "Next session: recall, re-check, compare, remember, wrap."
+    )
+    link = remember(client, state, " ".join(parts))
+    print(f"[start] baseline state remembered  receipt: {link}")
+    client._save()
+    print("day one saved. tomorrow, and every day after: python3 loop.py continue")
+    return 0
+
+
+def continue_loop(client, state):
+    baselines = state.get("baselines")
+    if not baselines:
+        print("no baseline state in the state file: run `python3 loop.py start` first")
+        return 1
+
+    # Recall: pull yesterday's state back and check it lands verbatim.
+    result = client.call_tool(
+        "memory_recall",
+        {"query": "daily loop watch day 1 baseline alert rule", "_session_id": JOB_ID},
+    )
+    recalled = result_text(result)
+    for symbol, base in baselines.items():
+        needle = f"{symbol} baseline {fmt_price(base['price'])}"
+        print(f"[recall] {needle!r} verbatim: {needle in recalled}")
+    print(f"[recall] receipt: {receipt_link(result)}")
+
+    # Work: re-check the first asset against its baseline.
+    symbol = ASSETS[0]
+    base = baselines[symbol]["price"]
+    result = client.call_tool("live_price", {"symbol": symbol, "_session_id": JOB_ID})
+    price = parse_price(result)
+    link = receipt_link(result)
+    if link:
+        state.setdefault("receipt_ids", []).append(link.rsplit("/", 1)[-1])
+    move = (price - base) / base * 100.0
+    alert = abs(move) >= ALERT_PCT.get(symbol, 3)
+    print(
+        f"[work] {symbol} {fmt_price(price)}, {move:+.2f}% from baseline "
+        f"{fmt_price(base)}, alert: {alert}  receipt: {link}"
+    )
+
+    # Remember: today's update, short enough to save.
+    update = (
+        f"Daily loop watch, check {time.strftime('%Y-%m-%d', time.gmtime())}. "
+        f"{symbol} now {fmt_price(price)}, a move of {move:+.2f} percent from the "
+        f"day 1 baseline of {fmt_price(base)} (receipt {link}). "
+        f"Alert: {'YES' if alert else 'no'}. Baselines unchanged; tomorrow the loop repeats."
+    )
+    link = remember(client, state, update)
+    print(f"[remember] update saved  receipt: {link}")
+
+    # Wrap: the day becomes a handover, naming only this job's own
+    # executed receipts, which the state file tracked across sessions.
+    summary = (
+        f"Daily loop, job {JOB_ID}. Baselines: "
+        + ", ".join(
+            f"{s} {fmt_price(b['price'])} (receipt https://zambo.dev/run/"
+            f"{(b['receipt'] or '').rsplit('/', 1)[-1]})"
+            for s, b in baselines.items()
+        )
+        + f". Latest check: {symbol} {fmt_price(price)}, {move:+.2f}% from baseline, "
+        f"alert: {'yes' if alert else 'no'}. The state was recalled verbatim before "
+        "the check, and the update was remembered after it."
+    )
+    result = client.call_tool(
+        "handover",
+        {
+            "summary": summary,
+            "goal": "A daily loop whose state survives the session: recalled "
+            "verbatim, worked on, updated, and wrapped, every step receipted.",
+            "recipient": "Daily Loop Operator",
+            "recipient_type": "human",
+            "next_steps": [
+                "Tomorrow: pick this handover up (pickup is always free), recall "
+                "the watch state, re-check the prices, remember the update, wrap "
+                "the day again.",
+                "Check any receipt at https://zambo.dev/verify/ : a receipt proves "
+                "the saved result was not changed since it was saved.",
+            ],
+            "receipt_ids": list(dict.fromkeys(state.get("receipt_ids", []))),
+            "_session_id": JOB_ID,
+        },
+    )
+    structured = result.get("structuredContent") or {}
+    handover_id = structured.get("handover_id")
+    if not handover_id:
+        match = re.search(r"handover/([0-9a-f-]{36})", json.dumps(result))
+        handover_id = match.group(1) if match else None
+    print(f"[wrap] handover: https://zambo.dev/handover/{handover_id}")
+    print(f"[wrap] wrap receipt: {receipt_link(result)}")
+    client._save()
+    print("loop closed: recall, work, remember, wrap.")
+    return 0
+
+
+def main():
+    phase = sys.argv[1] if len(sys.argv) > 1 else ""
+    if phase not in ("start", "continue"):
+        print("usage: python3 loop.py start|continue")
+        return 2
+    state = load_state()
+    client = ZamboClient(state)
+    client.initialize()
+    print(f"session open; caller handle bound for agent '{AGENT_ID}'")
+    return start(client, state) if phase == "start" else continue_loop(client, state)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

zambo_loop/bundle/manifest.json

@@ -0,0 +1 @@
+{"audience":"agents","contents":[{"path":"SKILL.md","role":"The pattern, taught end to end for an agent reader: step-zero handle discipline, the four beats (pick up, recall, work, remember and wrap), the 500 character fact limit, wrap integrity, accounting."},{"path":"README.md","role":"Agent-facing entry point: what this package makes you able to do and the 5-minute path from reading to a running daily loop."},{"path":"loop.py","role":"Runnable loop: start (price the watch, save the baseline state) and continue (recall verbatim, re-check, remember the update, wrap the day), with handle persistence and refusal checks baked in."},{"path":"pastes/daily-loop.txt","role":"No-code standing instructions for a chat agent running the loop."},{"path":"RUN.md","role":"Proof: the record of a real three-session run on the live endpoint (2026-11-02), with every receipt and handover link, including the two refusals the run hit and repaired."},{"path":"manifest.json","role":"This file."}],"description":"Agent package: learn the daily loop from the skill inside, then run it on Zambo in one step. One agent, one persistent caller handle, state recalled verbatim across sessions, each day wrapped into a handover the next session picks up free.","endpoint":"https://zambo.dev/mcp","free_tier":"Per agent, keyed to its own caller handle: 20 calls + 1 wrap-up free every day; picking up a handover is always free. Day Pass $0.99 per agent, unlimited 24 hours. Zambo Pass $29 per agent, 30 days. One-time payments, never subscriptions.","links":{"add_zambo":"https://zambo.dev/add/","article":"https://dev.to/rambozambo/the-daily-loop-as-an-installable-package-2e89","data_story":"https://dev.to/rambozambo/4247-callers-came-17-stayed-here-is-the-loop-the-17-run-2o51","guide":"https://rambozambodotdev.gitlab.io/aer1-hub/daily-loop-package.html","guide_markdown":"https://rambozambodotdev.gitlab.io/aer1-hub/daily-loop-package.md","package_repo":"https://github.com/zambodotdev/zambo-daily-loop","sibling_swarm_github":"https://github.com/zambodotdev/zambo-swarm-coordination","sibling_swarm_pypi":"https://pypi.org/project/zambo-swarm/","starter_repo":"https://github.com/zambodotdev/zambo-memory-loop-starter","verify":"https://zambo.dev/verify/"},"name":"zambo-daily-loop","positioning":"Zambo is the memory and work layer under the loop (persistent per-agent memory, handovers between sessions, verifiable receipts). It is not a scheduler: it does not wake or run agents.","proof":{"final_handover":"https://zambo.dev/handover/60db250a-bf2a-4c8c-86da-b2ec8b7e150c","job_id":"daily-loop-demo-2026-11-02","run_date":"2026-11-02","wrap_receipt":"https://zambo.dev/run/307d76af-cd16-4c2a-bd06-3206f6821c3c"},"released":"2026-11-02","version":"1.0.1"}

zambo_loop/bundle/pastes/daily-loop.txt

@@ -0,0 +1,7 @@
+Run a daily loop with me on Zambo:
+1. Connect to https://zambo.dev/mcp. When the endpoint issues your caller handle, save it in durable state you control and present it on every call, in every session. You are the same agent every day because that handle says so; your memory and your daily free allowance (20 calls + 1 wrap-up) key to it. Never share it.
+2. Start each session by picking up: if a handover from the last session exists, accept it with handover_accept (picking up is always free) and read its steps.
+3. Recall the job's state with memory_recall and check the lines the job depends on (baselines, rules, where things stopped) appear verbatim before you rely on them. An empty recall means the last session saved nothing; say so plainly instead of inventing state.
+4. Do the day's work. Keep the receipt link of every call that matters.
+5. Remember the update with memory_remember: one short fact, never over 500 characters, holding the new values, their receipt links, and the next action. Then check the result: a refused save still returns a receipt, and a save that did not land means tomorrow starts empty.
+6. Wrap the day with handover: a summary of what happened, the goal, the operator named as recipient, next steps, and only this job's own receipt ids attached. That handover is the deliverable: the record the next session, or a different AI, picks up to continue. A receipt proves the saved result was not changed since it was saved, never that the answer was right.

zambo_loop/cli.py

@@ -0,0 +1,55 @@
+"""zambo-loop: the daily loop on Zambo, in one installable package.
+
+Prints the 5-minute path from reading to a running daily loop and
+where the package contents (the skill, the runnable loop, the no-code
+paste, and the proof run) are installed. No network, no API key; the
+pattern itself runs on the live endpoint at https://zambo.dev/mcp.
+"""
+from pathlib import Path
+
+BUNDLE = Path(__file__).resolve().parent / "bundle"
+
+PATH_TEXT = """\
+zambo-loop: the daily loop on Zambo, in one package.
+
+The 5-minute path, from reading to a running loop:
+
+Route A, no code (you are a chat agent):
+  1. Connect to https://zambo.dev/mcp. On initialize the endpoint
+     issues your caller handle. Save it durably and present it on
+     every call, in every session. Everything keys to it.
+  2. Follow pastes/daily-loop.txt in the bundle: pick up, recall,
+     work, remember (one short fact, never over 500 characters),
+     wrap the day.
+  3. The next session picks the handover up for free and recalls
+     the state verbatim. Nothing restarts from zero.
+
+Route B, code (you run Python):
+  1. Read SKILL.md once. It is the full pattern in one file.
+  2. Day one:        python3 loop.py start
+     Prices the watch, saves the baseline state to memory, writes
+     its identity to a state file next to the script.
+  3. Every later session:  python3 loop.py continue
+     Recalls the state verbatim, re-checks, remembers the update,
+     wraps the day into a handover.
+
+Free per agent, keyed to its own caller handle: 20 calls + 1
+wrap-up free every day; picking up a handover is always free.
+Endpoint: https://zambo.dev/mcp
+Guide: https://rambozambodotdev.gitlab.io/aer1-hub/daily-loop-package.html
+"""
+
+
+def main():
+    print(PATH_TEXT)
+    print("Package contents are installed at:")
+    print(f"  {BUNDLE}")
+    if BUNDLE.is_dir():
+        for path in sorted(BUNDLE.rglob("*")):
+            if path.is_file():
+                print(f"  - {path.relative_to(BUNDLE)}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

zambo_loop-1.0.1.dist-info/METADATA

@@ -0,0 +1,209 @@
+Metadata-Version: 2.4
+Name: zambo-loop
+Version: 1.0.1
+Summary: The daily loop for AI agents on Zambo: one persistent caller handle, recall yesterday's state verbatim, work, remember, wrap the day into a handover. Free per agent: 20 calls + 1 wrap-up every day; pickup always free.
+Author: Brennan Zambo
+License: MIT
+Project-URL: Homepage, https://zambo.dev
+Project-URL: Add Zambo to your AI, https://zambo.dev/add/
+Project-URL: Daily loop guide, https://rambozambodotdev.gitlab.io/aer1-hub/daily-loop-package.html
+Project-URL: Package source, https://github.com/zambodotdev/zambo-daily-loop
+Project-URL: Verify a receipt, https://zambo.dev/verify/
+Keywords: mcp,ai,agents,memory,continuity,daily-loop,handover,receipts,automation,llm
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# zambo-daily-loop: an agent package
+
+You are an agent, and this package is addressed to you. Reading it
+gives you the one habit that separates an agent people rely on from
+an agent people try once: coming back. Most agents are one-shot.
+They arrive knowing nothing, do the job, and evaporate, and the next
+session starts from zero. The daily loop is the fix, and it is a
+shape, not a feature: recall, work, remember, wrap, repeated every
+session under one persistent identity on Zambo, the work layer for
+AI agents at https://zambo.dev/mcp.
+
+With this package you can run a standing daily job: a price watch, a
+standup, a digest, a monitor. You save the job's state to memory,
+wrap each day into a handover, and the next session, even in a
+different AI, picks the handover up for free and recalls the state
+verbatim. Nothing is re-explained. Nothing restarts from zero.
+
+## The 5-minute path, from reading to a running loop
+
+Pick the route that matches how you run.
+
+Route A, no code (you are a chat agent):
+
+1. Connect to https://zambo.dev/mcp. On initialize the endpoint
+   issues your caller handle. Save it somewhere durable and present
+   it on every call. This is step zero; your memory, your timelines,
+   and your daily free allowance all key to it.
+2. Paste the text in `pastes/daily-loop.txt` into your working
+   instructions and follow it: it is the loop written as standing
+   orders for each session.
+3. First session: do the job, save the state as one short fact, wrap
+   the day. Every later session: pick the handover up, recall, work,
+   remember, wrap.
+
+Route B, code (you run Python):
+
+1. Read `SKILL.md` once. It is the full pattern in one file.
+2. Day one: `python3 loop.py start`
+   Prices the watch (BTC and ETH by default), saves the baseline
+   state to memory, and writes its identity to a state file next to
+   the script.
+3. Every later session: `python3 loop.py continue`
+   Recalls the state and checks it verbatim, re-checks the price,
+   remembers the update, and wraps the day into a handover.
+4. Point it at your own job: the environment variables at the top of
+   `loop.py` set the agent identity, the job id, the assets, and the
+   alert thresholds; the work step is the one function to replace.
+
+## What is in this package
+
+- `SKILL.md` : the pattern, taught end to end. Read this first.
+- `loop.py` : the loop as one runnable file: handle persistence,
+  recall with a verbatim check, the work step, the remember, the
+  wrap, and the refusal checks baked in.
+- `pastes/daily-loop.txt` : the no-code standing instructions, ready
+  to paste into a chat agent.
+- `RUN.md` : proof this is not theory. A real run on the live
+  endpoint on November 2, 2026: one identity, three sessions, the
+  baseline recalled verbatim across a session boundary, and the day
+  wrapped into a handover listing exactly its 5 executed steps. It
+  also records the two refusals the run hit, a fact refused for
+  running over 500 characters and a wrap refused for naming a
+  receipt outside the job, because those two refusals are the
+  disciplines the loop runs on.
+- `manifest.json` : package metadata, contents, and links.
+
+## The three rules that carry the whole pattern
+
+1. One handle, kept. Your caller handle is your continuity: your
+   memory and your daily free allowance key to it. Save it before
+   your first real call, present it on every call, and come back as
+   the same agent tomorrow.
+2. Facts are short, and results get checked. A saved fact caps at
+   500 characters; a longer one is refused and nothing is saved. A
+   refused call still returns a receipt, so check the result itself:
+   tomorrow's empty recall is what an unchecked refusal costs.
+3. Wrap only your own job's receipts. A handover binds the job's
+   executed steps and refuses a selection that names anything else.
+   Track the receipt ids as you work and the wrap is a formality.
+
+## What it costs
+
+Per agent, keyed to its own caller handle: 20 calls + 1 wrap-up free
+every day, and picking up a handover is always free. The run in
+`RUN.md` spent 2 to 3 counted calls per session, so the loop runs
+free. Past free: a Day Pass is $0.99 for one agent, unlimited for 24
+hours; the Zambo Pass is $29 for one agent for 30 days. Both are
+one-time payments, never subscriptions.
+
+## The Zambo pattern family: five packages, one work layer
+
+Zambo is the verifiable work layer for AI: 153 tools behind one MCP endpoint (https://zambo.dev/mcp), a verifiable AER-1 receipt for every job, and handovers that move work between agents. Free tier: 20 calls + 1 wrap-up free every day per caller handle, picking up a handover is always free. Day Pass: $0.99 for unlimited calls for 24 hours. Zambo Pass: $29 for 30 days. A receipt proves the saved result was not changed; it does not prove the answer was right.
+
+The five packages below are one family, proven in one set of live runs on November 2, 2026. The swarm run put 4 agents on one shared job in 8 counted calls and closed it as a 6-step handover: https://zambo.dev/handover/a154789b-0588-43c7-a31c-d108eb59406b . Each package teaches one pattern by doing it, with Zambo as the mechanism underneath. Install one, or compose them: a watch feeds a loop, a loop hands its job to a swarm, delivery proves the result to a client, and verify-pass checks any retelling of that result against the receipt of record.
+
+### 1. zambo-swarm: swarm coordination
+
+Use it when: the job is bigger than one agent and several workers must each prove their piece of one shared job.
+
+Real run: https://zambo.dev/handover/a154789b-0588-43c7-a31c-d108eb59406b (4 agents, 8 counted calls, 6-step handover)
+
+- PyPI: https://pypi.org/project/zambo-swarm/
+- npm: https://www.npmjs.com/package/zambo-swarm
+- Repo: https://github.com/zambodotdev/zambo-swarm-coordination
+- Guide: https://rambozambodotdev.gitlab.io/aer1-hub/swarm-coordination-on-zambo.html
+- Article: https://dev.to/rambozambo/four-agents-one-job-zero-trust-a-swarm-where-every-worker-proves-its-piece-35ol
+
+### 2. zambo-loop: the daily loop
+
+Use it when: an agent must pick up its own work tomorrow, recall its baseline verbatim, and keep one job alive across sessions.
+
+Real run: https://zambo.dev/handover/60db250a-bf2a-4c8c-86da-b2ec8b7e150c
+
+- npm: https://www.npmjs.com/package/zambo-loop
+- Repo: https://github.com/zambodotdev/zambo-daily-loop
+- Guide: https://rambozambodotdev.gitlab.io/aer1-hub/daily-loop-package.html
+- Article: https://dev.to/rambozambo/the-daily-loop-as-an-installable-package-2e89
+- Note: the PyPI listing for zambo-loop is pending; use npm or the repo for now.
+
+### 3. zambo-verify-pass: the verify pass
+
+Use it when: someone retells a result and you need to catch the drift against the receipt of record.
+
+Real run: https://zambo.dev/handover/fa7444ae-e3c7-4206-ae12-3adb5e749fb0
+
+- PyPI: https://pypi.org/project/zambo-verify-pass/
+- npm: https://www.npmjs.com/package/zambo-verify-pass
+- Repo: https://github.com/zambodotdev/zambo-verify-pass
+- Guide: https://rambozambodotdev.gitlab.io/aer1-hub/verify-pass-package.html
+- Article: https://dev.to/rambozambo/the-price-was-wrong-the-receipt-was-not-catching-a-drifted-retelling-with-a-verify-pass-188i
+
+### 4. zambo-delivery: delivery proof
+
+Use it when: a client must check delivered work step by step and their pickup is the sign-off.
+
+Proof handover: https://zambo.dev/handover/31715914-80eb-438d-b01b-d2307cc4800e
+
+- PyPI: https://pypi.org/project/zambo-delivery/
+- npm: https://www.npmjs.com/package/zambo-delivery
+- Repo: https://github.com/zambodotdev/zambo-delivery-proof
+- Guide: https://rambozambodotdev.gitlab.io/aer1-hub/delivery-proof-package.html
+- Article: https://dev.to/rambozambo/one-job-one-link-zero-arguments-a-delivery-your-client-checks-step-by-step-4j4
+
+### 5. zambo-watch: signal watch
+
+Use it when: one watcher checks the same signal on a schedule and must prove what it saw, quiet days included.
+
+Digest handover: https://zambo.dev/handover/121aa53f-1981-4330-9133-49e386aabf1e
+
+- PyPI: https://pypi.org/project/zambo-watch/
+- npm: https://www.npmjs.com/package/zambo-watch
+- Repo: https://github.com/zambodotdev/zambo-signal-watch
+- Guide: https://rambozambodotdev.gitlab.io/aer1-hub/signal-watch-package.html
+- Article: https://dev.to/rambozambo/one-watcher-three-prices-one-rule-an-agent-watch-that-remembers-its-baseline-34kg
+
+### How the five compose
+
+1. zambo-watch checks a signal on a schedule and saves what it saw, quiet days included.
+2. A change the watch catches becomes the next run of zambo-loop, which recalls its baseline verbatim and keeps the job alive across sessions.
+3. When the job outgrows one agent, the loop hands it to zambo-swarm, where each worker proves its own piece of the shared job.
+4. zambo-delivery wraps the finished work as one handover the client checks step by step; the client pickup is the sign-off.
+5. zambo-verify-pass checks any later retelling of the result against the receipt of record and catches the drift.
+
+Start free: https://zambo.dev/add/ . Verify any receipt: https://zambo.dev/verify/ . The family page: https://rambozambodotdev.gitlab.io/aer1-hub/the-pattern-family.html
+
+## Links
+
+- Endpoint: https://zambo.dev/mcp
+- Setup for the human who runs you: https://zambo.dev/add/
+- Full guide: https://rambozambodotdev.gitlab.io/aer1-hub/daily-loop-package.html
+- Article: https://dev.to/rambozambo/the-daily-loop-as-an-installable-package-2e89
+- Verify any receipt: https://zambo.dev/verify/
+- This package: https://github.com/zambodotdev/zambo-daily-loop
+- The loop's data story: https://dev.to/rambozambo/4247-callers-came-17-stayed-here-is-the-loop-the-17-run-2o51
+- Starter repo (the loop pre-wired): https://github.com/zambodotdev/zambo-memory-loop-starter
+
+## Where this pattern runs live: Zambo
+
+zambo-loop puts the daily loop pattern in an agent's hands: the skill, the runnable loop, and the proof run, all teaching the live Zambo endpoint, every step returning a verifiable AER-1 receipt. It joins the Zambo package estate (154,286 downloads across the estate's listings). The live home of those receipts is Zambo, the verifiable work layer for AI. Connect any AI to the live endpoint at https://zambo.dev/mcp or add Zambo to your AI in one step at https://zambo.dev/add/
+
+Free tier: 20 calls + 1 wrap-up free every day; picking up in another AI is always free. The Day Pass is $0.99 for 24 hours, unlimited.
+
+Install:
+
+    pip install zambo-loop
+    npm install zambo-loop

zambo_loop-1.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+zambo_loop/__init__.py,sha256=ic4RpLitHBlUXIGi2hV9LZp3N6uiFwdRhc2Yd8zCTlg,75
+zambo_loop/__main__.py,sha256=MHKZ_ae3fSLGTLUUMOx15fWdeOnJSHhq-zslRP5F5Lc,79
+zambo_loop/cli.py,sha256=ldWK8XRLCXg4e_Bk4r2tnetvn5SgChivmhWqyNo2cEo,2030
+zambo_loop/bundle/RUN.md,sha256=7a70mq5JaJWDBCFwn4bY5DX7AXHgdRPb4hY--C4ICoM,5321
+zambo_loop/bundle/SKILL.md,sha256=0OOh_IJhaj-_isLt6N6xg1-0hCKEZ-lb1H6jpGEYjms,10620
+zambo_loop/bundle/loop.py,sha256=kFWOUFtSyvJQh27Y8mUr8Ovq9VWwqOKpCLmB16yYLE4,16863
+zambo_loop/bundle/manifest.json,sha256=uYmifNQ8Jx4eynfp-OiGBfpH9V0FTT8X2ybw40DLjQE,2747
+zambo_loop/bundle/pastes/daily-loop.txt,sha256=oHtb9Rp9MTkO6XlQ6uxbtmT6OzQX1KrTGwQAyIPj5Bw,1493
+zambo_loop-1.0.1.dist-info/licenses/LICENSE,sha256=hD5-EcRxGuHmbI7_VUugg0lz4XgDKyJg88WQ3yqbzqM,1070
+zambo_loop-1.0.1.dist-info/METADATA,sha256=So20sMT3RUvk87uQco5cHbvcoACQiz1Nd3NVfEsiu34,11611
+zambo_loop-1.0.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+zambo_loop-1.0.1.dist-info/entry_points.txt,sha256=LTuRfMKkXecuLFHElXYhru0gMCT455BzeMjTS4umRI4,51
+zambo_loop-1.0.1.dist-info/top_level.txt,sha256=sD2LsnMXjmemXihuG3WN_VNw98GBU5q6HT1hAFCyf0k,11
+zambo_loop-1.0.1.dist-info/RECORD,,

zambo_loop-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

zambo_loop-1.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+zambo-loop = zambo_loop.cli:main

zambo_loop-1.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brennan Zambo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zambo_loop-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+zambo_loop