zambo-leadsignal 1.0.0__tar.gz

zambo_leadsignal-1.0.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: zambo-leadsignal
+Version: 1.0.0
+Summary: Run a lead signal sweep for a local trade market on Zambo: live signals, screened input, continuity-checked, brief written, every step on a verifiable AER-1 receipt.
+Author-email: Brennan Zambo <brennanzambo@zambo.dev>
+License: MIT
+Project-URL: Homepage, https://zambo.dev
+Project-URL: Get started, https://zambo.dev/add/
+Project-URL: Guide, https://rambozambodotdev.gitlab.io/aer1-hub/handover-graph.html
+Project-URL: Repository, https://github.com/zambodotdev/zambo-leadsignal
+Keywords: ai-agents,mcp,model-context-protocol,handover,receipts,zambo,aer-1
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+
+# zambo-leadsignal
+
+Run a lead signal sweep for a local trade market: live signals,
+screened input, your own prior record checked before you write the
+brief, and a verifiable AER-1 receipt for every step.
+
+This is the most-run job shape on Zambo, packaged. In a five-day
+first-hand count of the public receipt stream (16,221 receipts,
+October 29 to November 2, 2026), the chain inside this package,
+capability_search then prompt_shield then leadsignal then
+continuity_get_recent then the write-up, appeared in roughly 200
+caller-days per day. Agents were already running it by hand. Now it
+installs.
+
+## Install
+
+Python:
+
+    pip install zambo-leadsignal
+    zambo-leadsignal run --trade plumber --city "Austin Texas"
+
+Node:
+
+    npm install zambo-leadsignal
+    npx zambo-leadsignal run --trade plumber --city "Austin Texas"
+
+## What a run does
+
+1. Opens the job on the record (memory_remember under the run's job id).
+2. capability_search: the service landscape for the trade and city.
+3. prompt_shield: screens the operator note before it steers the run.
+4. leadsignal: the live lead signals for that trade and city.
+5. continuity_get_recent: what this agent already found, so repeat
+   runs build on the record instead of starting from zero.
+6. Writes leadsignal-brief-<job>.md with the signals, the landscape,
+   the screen result, the prior record, and every receipt link.
+7. workflow_close: wraps the run. The wrap binds only this run's own
+   receipts, so the brief's proof layer is exactly the work that made
+   it.
+
+Every receipt recomputes free at https://zambo.dev/verify/. A receipt
+proves the saved result was not changed since the call ran; it does
+not prove a lead is good. The brief says so, out loud, because that
+honesty is the product.
+
+## Why Zambo is inside
+
+The pattern runs on Zambo (https://zambo.dev/mcp), the verifiable
+work layer for AI: 153 tools behind one MCP endpoint, memory and
+continuity across AIs, and a verifiable AER-1 receipt for every job.
+The package teaches the pattern by running it; Zambo is the mechanism
+underneath: identity, memory, the signals tool, and the receipts.
+
+Free tier: 20 calls and 1 wrap-up free every day, and picking up in
+another AI is always free. Need more? The $0.99 Day Pass makes it
+unlimited for 24 hours: https://zambo.dev/day-pass/
+
+Add Zambo to your own AI in one URL, no key, no account:
+https://zambo.dev/add/
+
+## Configuration
+
+- ZAMBO_TRADE, ZAMBO_CITY, ZAMBO_NOTE: the run's inputs.
+- ZAMBO_AGENT_ID: this agent's id (default: leadsignal-agent). One
+  identity per agent; the caller handle issued at initialize is saved
+  under ./.zambo-leadsignal and reused on later runs.
+- ZAMBO_MCP_URL: endpoint override (default: https://zambo.dev/mcp).
+
+## License
+
+MIT. Built by Brennan Zambo (brennanzambo@zambo.dev).

zambo_leadsignal-1.0.0/README.md

@@ -0,0 +1,71 @@
+# zambo-leadsignal
+
+Run a lead signal sweep for a local trade market: live signals,
+screened input, your own prior record checked before you write the
+brief, and a verifiable AER-1 receipt for every step.
+
+This is the most-run job shape on Zambo, packaged. In a five-day
+first-hand count of the public receipt stream (16,221 receipts,
+October 29 to November 2, 2026), the chain inside this package,
+capability_search then prompt_shield then leadsignal then
+continuity_get_recent then the write-up, appeared in roughly 200
+caller-days per day. Agents were already running it by hand. Now it
+installs.
+
+## Install
+
+Python:
+
+    pip install zambo-leadsignal
+    zambo-leadsignal run --trade plumber --city "Austin Texas"
+
+Node:
+
+    npm install zambo-leadsignal
+    npx zambo-leadsignal run --trade plumber --city "Austin Texas"
+
+## What a run does
+
+1. Opens the job on the record (memory_remember under the run's job id).
+2. capability_search: the service landscape for the trade and city.
+3. prompt_shield: screens the operator note before it steers the run.
+4. leadsignal: the live lead signals for that trade and city.
+5. continuity_get_recent: what this agent already found, so repeat
+   runs build on the record instead of starting from zero.
+6. Writes leadsignal-brief-<job>.md with the signals, the landscape,
+   the screen result, the prior record, and every receipt link.
+7. workflow_close: wraps the run. The wrap binds only this run's own
+   receipts, so the brief's proof layer is exactly the work that made
+   it.
+
+Every receipt recomputes free at https://zambo.dev/verify/. A receipt
+proves the saved result was not changed since the call ran; it does
+not prove a lead is good. The brief says so, out loud, because that
+honesty is the product.
+
+## Why Zambo is inside
+
+The pattern runs on Zambo (https://zambo.dev/mcp), the verifiable
+work layer for AI: 153 tools behind one MCP endpoint, memory and
+continuity across AIs, and a verifiable AER-1 receipt for every job.
+The package teaches the pattern by running it; Zambo is the mechanism
+underneath: identity, memory, the signals tool, and the receipts.
+
+Free tier: 20 calls and 1 wrap-up free every day, and picking up in
+another AI is always free. Need more? The $0.99 Day Pass makes it
+unlimited for 24 hours: https://zambo.dev/day-pass/
+
+Add Zambo to your own AI in one URL, no key, no account:
+https://zambo.dev/add/
+
+## Configuration
+
+- ZAMBO_TRADE, ZAMBO_CITY, ZAMBO_NOTE: the run's inputs.
+- ZAMBO_AGENT_ID: this agent's id (default: leadsignal-agent). One
+  identity per agent; the caller handle issued at initialize is saved
+  under ./.zambo-leadsignal and reused on later runs.
+- ZAMBO_MCP_URL: endpoint override (default: https://zambo.dev/mcp).
+
+## License
+
+MIT. Built by Brennan Zambo (brennanzambo@zambo.dev).

zambo_leadsignal-1.0.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zambo-leadsignal"
+version = "1.0.0"
+description = "Run a lead signal sweep for a local trade market on Zambo: live signals, screened input, continuity-checked, brief written, every step on a verifiable AER-1 receipt."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+  { name = "Brennan Zambo", email = "brennanzambo@zambo.dev" }
+]
+keywords = ["ai-agents", "mcp", "model-context-protocol", "handover", "receipts", "zambo", "aer-1"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Libraries",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence"
+]
+dependencies = ["requests>=2.28"]
+
+[project.urls]
+Homepage = "https://zambo.dev"
+"Get started" = "https://zambo.dev/add/"
+Guide = "https://rambozambodotdev.gitlab.io/aer1-hub/handover-graph.html"
+Repository = "https://github.com/zambodotdev/zambo-leadsignal"
+
+[project.scripts]
+zambo-leadsignal = "zambo_leadsignal.cli:main"
+
+[tool.setuptools]
+packages = ["zambo_leadsignal"]
+
+[tool.setuptools.package-data]
+zambo_leadsignal = ["SKILL.md"]

zambo_leadsignal-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zambo_leadsignal-1.0.0/zambo_leadsignal/SKILL.md

@@ -0,0 +1,61 @@
+# The Lead Signal Run
+
+A repeatable sweep that turns a trade and a city into a worked lead
+brief, with every step on a verifiable receipt.
+
+This is the single most-run job shape on Zambo: in a five-day count of
+the public receipt stream (16,221 receipts, October 29 to November 2,
+2026), the chain capability_search, prompt_shield, leadsignal,
+continuity_get_recent, write appeared in roughly 200 caller-days per
+day. This package is that chain, named, ordered, and wrapped the way
+the record rewards.
+
+## When to run it
+
+You serve, or hunt customers for, a local trade: plumber, HVAC,
+electrician, roofer, dentist, lawyer, any service people search for
+when something just broke. Run the sweep when you need this week's
+leads for one market, and run it again next week: the continuity step
+is what makes the second run smarter than the first.
+
+## The five steps, in order
+
+1. **Open on the record.** Save the run's brief to memory under the
+   job id. If it is not written down, it did not happen.
+2. **capability_search** the landscape for the trade and city: what
+   services, angles, and offers exist before you spend a signal pull.
+3. **prompt_shield** the operator's targeting note. Notes steer the
+   run; screen them like any other input, especially pasted ones.
+4. **leadsignal** for the trade and city. This is the live pull: the
+   signals themselves, saved as the step's result.
+5. **continuity_get_recent** before you write a word of the brief.
+   What did this agent already find in this market? Chase what is new,
+   note what is repeat, never pitch the same lead twice by accident.
+
+Then write the brief (signals first, landscape second, receipts last)
+and **workflow_close** the job. The wrap binds only this run's
+receipts. Work done outside the job cannot be wrapped into it later;
+that refusal is the feature.
+
+## Rules that keep the run honest
+
+- One caller handle per agent, saved at initialize, presented on every
+  call. Handles are identity; sharing one merges two agents into one
+  record.
+- A receipt proves the saved result was not changed since the call
+  ran. It does not prove a lead is good. Say exactly that in the brief.
+- Pickup is free forever: hand the wrapped job to another agent (or
+  your own other AI) and they continue from the record, not from a
+  summary.
+
+## Run it
+
+    pip install zambo-leadsignal
+    zambo-leadsignal run --trade plumber --city "Austin Texas"
+
+    npm install zambo-leadsignal
+    npx zambo-leadsignal run --trade plumber --city "Austin Texas"
+
+Free tier: 20 calls and 1 wrap-up free every day per caller, picking
+up in another AI always free. The Day Pass ($0.99) makes it unlimited
+for 24 hours: https://zambo.dev/day-pass/

zambo_leadsignal-1.0.0/zambo_leadsignal/__init__.py

@@ -0,0 +1,10 @@
+"""zambo-leadsignal: run a lead signal sweep for a local trade market.
+
+The pattern the live Zambo stream runs 200+ times a day, packaged:
+search the capability landscape, shield the input, pull live lead
+signals for a trade and city, check your own recent record so you do
+not chase the same leads twice, write the brief, and wrap the run so
+every step sits on a verifiable AER-1 receipt.
+"""
+
+__version__ = "1.0.0"

zambo_leadsignal-1.0.0/zambo_leadsignal/cli.py

@@ -0,0 +1,40 @@
+"""zambo-leadsignal command line.
+
+    zambo-leadsignal run --trade plumber --city "Austin Texas"
+    zambo-leadsignal run --trade roofer --city Denver --note "storm damage focus"
+
+Configuration also by environment: ZAMBO_TRADE, ZAMBO_CITY,
+ZAMBO_NOTE, ZAMBO_AGENT_ID, ZAMBO_MCP_URL.
+"""
+
+import os
+import sys
+
+from .run import run_sweep
+
+
+def _arg(flag, env, default=None):
+    if flag in sys.argv:
+        return sys.argv[sys.argv.index(flag) + 1]
+    return os.environ.get(env, default)
+
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] != "run":
+        print(__doc__)
+        return 2
+    trade = _arg("--trade", "ZAMBO_TRADE")
+    city = _arg("--city", "ZAMBO_CITY")
+    note = _arg("--note", "ZAMBO_NOTE")
+    if not trade or not city:
+        print("run needs --trade and --city (or ZAMBO_TRADE / ZAMBO_CITY)")
+        return 2
+    result = run_sweep(trade, city, note=note,
+                       agent_id=os.environ.get("ZAMBO_AGENT_ID",
+                                               "leadsignal-agent"))
+    print(f"done: job {result['job_id']}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

zambo_leadsignal-1.0.0/zambo_leadsignal/client.py

@@ -0,0 +1,193 @@
+"""Minimal Zambo MCP client: one agent identity, done right.
+
+Step zero of the leadsignal pattern lives here. On initialize, the endpoint
+issues a caller handle (in the initialize result's _meta and in the
+X-Zambo-Caller-Handle response header). This client saves that handle
+in the agent's own state file before anything else happens, and
+presents it as _caller_handle on every call, with the agent's name as
+_caller_label. Memory, job timelines, and the daily free allowance all
+key to that handle. One handle per agent, never shared. Two agents on
+one handle are one agent as far as the record is concerned.
+
+Transport: requests when available (it handles proxies correctly),
+standard library urllib otherwise. No other dependencies.
+"""
+
+import json
+import os
+import re
+import urllib.request
+from pathlib import Path
+
+try:
+    import requests
+
+    _HAS_REQUESTS = True
+except ImportError:  # pragma: no cover
+    _HAS_REQUESTS = False
+
+MCP_URL = os.environ.get("ZAMBO_MCP_URL", "https://zambo.dev/mcp")
+RUN_URL_RE = re.compile(r"https://zambo\.dev/run/[0-9a-f-]{36}")
+
+
+def state_dir():
+    """Where this install keeps per-agent state files and contribution
+    notes. Defaults to ./.zambo-leadsignal in the working directory; override
+    with ZAMBO_LEADSIGNAL_STATE_DIR. State files hold caller handles: keep
+    them private, never commit them."""
+    return Path(os.environ.get("ZAMBO_LEADSIGNAL_STATE_DIR", Path.cwd() / ".zambo-leadsignal"))
+
+
+class ZamboClient:
+    """One agent's session with the Zambo MCP endpoint."""
+
+    def __init__(self, agent_id, agent_name):
+        self.agent_id = agent_id
+        self.agent_name = agent_name
+        self.session_id = None
+        self.quota_handle = None
+        self._next_id = 0
+        self.state_file = state_dir() / f".zambo-state-{agent_id}.json"
+        self.caller_handle = self._load_saved_handle()
+
+    # -- identity persistence -------------------------------------------
+
+    def _load_saved_handle(self):
+        try:
+            data = json.loads(self.state_file.read_text())
+            return data.get("caller_handle")
+        except Exception:
+            return None
+
+    def _save_handle(self):
+        if self.caller_handle:
+            self.state_file.parent.mkdir(parents=True, exist_ok=True)
+            self.state_file.write_text(
+                json.dumps({"caller_handle": self.caller_handle}, indent=2)
+            )
+
+    # -- transport -------------------------------------------------------
+
+    def _post(self, payload, expect_response=True):
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            "X-Agent-Id": self.agent_id,
+            "X-Agent-Name": self.agent_name,
+        }
+        if self.session_id:
+            headers["Mcp-Session-Id"] = self.session_id
+
+        if _HAS_REQUESTS:
+            resp = requests.post(
+                MCP_URL, json=payload, headers=headers, timeout=60
+            )
+            resp.raise_for_status()
+            if self.session_id is None:
+                self.session_id = resp.headers.get("Mcp-Session-Id")
+            header_handle = resp.headers.get("X-Zambo-Caller-Handle")
+            raw = resp.text
+        else:
+            body = json.dumps(payload).encode()
+            req = urllib.request.Request(MCP_URL, data=body, headers=headers)
+            with urllib.request.urlopen(req, timeout=60) as resp:
+                if self.session_id is None:
+                    self.session_id = resp.headers.get("Mcp-Session-Id")
+                header_handle = resp.headers.get("X-Zambo-Caller-Handle")
+                raw = resp.read().decode()
+
+        if header_handle and not self.caller_handle:
+            self.caller_handle = header_handle
+        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", {})
+
+    # -- MCP surface -----------------------------------------------------
+
+    def initialize(self):
+        result = self._post(
+            {
+                "jsonrpc": "2.0",
+                "id": self._id(),
+                "method": "initialize",
+                "params": {
+                    "protocolVersion": "2025-03-26",
+                    "capabilities": {},
+                    "clientInfo": {"name": self.agent_name, "version": "1.0.0"},
+                },
+            }
+        )
+        meta = result.get("_meta", {})
+        if not self.caller_handle:
+            self.caller_handle = meta.get("caller_handle")
+        self.quota_handle = meta.get("quota_handle")
+        self._save_handle()
+        self._post(
+            {"jsonrpc": "2.0", "method": "notifications/initialized"},
+            expect_response=False,
+        )
+        return result
+
+    def call_tool(self, name, arguments):
+        # The caller handle rides in the arguments, the quota handle in
+        # _meta, and the agent's id as the caller label, so the shared
+        # job's record attributes every step to this agent.
+        args = dict(arguments)
+        if self.caller_handle:
+            args["_caller_handle"] = self.caller_handle
+        args.setdefault("_caller_label", self.agent_id)
+        params = {"name": name, "arguments": args}
+        if self.quota_handle:
+            params["_meta"] = {"quota_handle": self.quota_handle}
+        result = self._post(
+            {
+                "jsonrpc": "2.0",
+                "id": self._id(),
+                "method": "tools/call",
+                "params": params,
+            }
+        )
+        handle = (result.get("structuredContent") or {}).get("caller_handle")
+        if handle and not self.caller_handle:
+            self.caller_handle = handle
+            self._save_handle()
+        return result
+
+    def _id(self):
+        self._next_id += 1
+        return self._next_id
+
+
+def receipt_link(result):
+    """Pull the AER-1 receipt link out of a tool result, if present."""
+    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):
+    parts = []
+    for block in result.get("content") or []:
+        if block.get("type") == "text":
+            parts.append(block.get("text", ""))
+    return "\n".join(parts)

zambo_leadsignal-1.0.0/zambo_leadsignal/run.py

@@ -0,0 +1,89 @@
+"""The lead signal run: five receipted steps, one brief, one wrap.
+
+    capability_search   what services and angles exist for this trade
+    prompt_shield       screen the operator note before it steers work
+    leadsignal          the live signals for (trade, city)
+    continuity_get_recent   what this agent already found, so a repeat
+                            run builds on the record instead of
+                            starting from zero
+    workflow_close      wrap the run; the wrap binds the job's own
+                        receipts into one checkable record
+
+Every call carries the run's job id as _session_id, so the wrap holds
+exactly this run's steps and nothing else's.
+"""
+
+import json
+import re
+import time
+from pathlib import Path
+
+from .client import ZamboClient, receipt_link, result_text
+
+
+def slug(text):
+    return re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")[:40]
+
+
+def run_sweep(trade, city, note=None, agent_id="leadsignal-agent",
+              agent_name="Lead Signal Agent"):
+    stamp = time.strftime("%Y%m%d-%H%M%S", time.gmtime())
+    job_id = f"leadsignal-{slug(trade)}-{slug(city)}-{stamp}"
+    client = ZamboClient(agent_id, agent_name)
+    client.initialize()
+    receipts = {}
+
+    def step(tool, args):
+        result = client.call_tool(tool, {**args, "_session_id": job_id})
+        link = receipt_link(result)
+        receipts[tool] = link
+        print(f"[{tool}] receipt: {link}")
+        return result_text(result)
+
+    # Open the job on the record.
+    brief_fact = (
+        f"Lead signal run {job_id}: trade={trade}, city={city}. "
+        f"Operator note: {note or '(none)'}. Steps: capability_search, "
+        "prompt_shield, leadsignal, continuity_get_recent, wrap."
+    )
+    step("memory_remember", {"fact": brief_fact[:480],
+                             "agent_name": agent_name})
+
+    landscape = step("capability_search",
+                     {"q": f"{trade} services {city} lead generation"})
+    shield_input = note or f"Find new {trade} customers in {city} this week."
+    shield = step("prompt_shield", {"prompt": shield_input, "mode": "fast"})
+    signals = step("leadsignal", {"trade": trade, "city": city})
+    recent = step("continuity_get_recent", {"limit": 20})
+
+    brief = (
+        f"# Lead signal brief: {trade} in {city}\n\n"
+        f"Job: {job_id} (UTC {stamp})\n\n"
+        f"## Live signals (leadsignal)\n\n{signals}\n\n"
+        f"## Capability landscape (capability_search)\n\n{landscape}\n\n"
+        f"## Input screen (prompt_shield)\n\n{shield}\n\n"
+        f"## What this agent already had on record (continuity)\n\n"
+        f"{recent}\n\n"
+        f"## Receipts\n\n"
+        + "\n".join(f"- {t}: {u}" for t, u in receipts.items() if u)
+        + "\n\nEvery receipt recomputes at https://zambo.dev/verify/. "
+          "A receipt proves the saved result was not changed since the "
+          "call ran; it does not prove a lead is good. Work the signals, "
+          "and let the record keep you honest about what you already "
+          "chased.\n"
+    )
+    out = Path.cwd() / f"leadsignal-brief-{job_id}.md"
+    out.write_text(brief)
+    print(f"[brief] written: {out}")
+
+    wrap = client.call_tool(
+        "workflow_close",
+        {"_session_id": job_id,
+         "summary": f"Lead signal run for {trade} in {city}: live signals "
+                    f"pulled, input screened, prior record checked, brief "
+                    f"written to {out.name}."},
+    )
+    wrap_link = receipt_link(wrap)
+    print(f"[wrap] workflow_close receipt: {wrap_link}")
+    return {"job_id": job_id, "brief": str(out), "receipts": receipts,
+            "wrap_receipt": wrap_link}

zambo_leadsignal-1.0.0/zambo_leadsignal.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: zambo-leadsignal
+Version: 1.0.0
+Summary: Run a lead signal sweep for a local trade market on Zambo: live signals, screened input, continuity-checked, brief written, every step on a verifiable AER-1 receipt.
+Author-email: Brennan Zambo <brennanzambo@zambo.dev>
+License: MIT
+Project-URL: Homepage, https://zambo.dev
+Project-URL: Get started, https://zambo.dev/add/
+Project-URL: Guide, https://rambozambodotdev.gitlab.io/aer1-hub/handover-graph.html
+Project-URL: Repository, https://github.com/zambodotdev/zambo-leadsignal
+Keywords: ai-agents,mcp,model-context-protocol,handover,receipts,zambo,aer-1
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+
+# zambo-leadsignal
+
+Run a lead signal sweep for a local trade market: live signals,
+screened input, your own prior record checked before you write the
+brief, and a verifiable AER-1 receipt for every step.
+
+This is the most-run job shape on Zambo, packaged. In a five-day
+first-hand count of the public receipt stream (16,221 receipts,
+October 29 to November 2, 2026), the chain inside this package,
+capability_search then prompt_shield then leadsignal then
+continuity_get_recent then the write-up, appeared in roughly 200
+caller-days per day. Agents were already running it by hand. Now it
+installs.
+
+## Install
+
+Python:
+
+    pip install zambo-leadsignal
+    zambo-leadsignal run --trade plumber --city "Austin Texas"
+
+Node:
+
+    npm install zambo-leadsignal
+    npx zambo-leadsignal run --trade plumber --city "Austin Texas"
+
+## What a run does
+
+1. Opens the job on the record (memory_remember under the run's job id).
+2. capability_search: the service landscape for the trade and city.
+3. prompt_shield: screens the operator note before it steers the run.
+4. leadsignal: the live lead signals for that trade and city.
+5. continuity_get_recent: what this agent already found, so repeat
+   runs build on the record instead of starting from zero.
+6. Writes leadsignal-brief-<job>.md with the signals, the landscape,
+   the screen result, the prior record, and every receipt link.
+7. workflow_close: wraps the run. The wrap binds only this run's own
+   receipts, so the brief's proof layer is exactly the work that made
+   it.
+
+Every receipt recomputes free at https://zambo.dev/verify/. A receipt
+proves the saved result was not changed since the call ran; it does
+not prove a lead is good. The brief says so, out loud, because that
+honesty is the product.
+
+## Why Zambo is inside
+
+The pattern runs on Zambo (https://zambo.dev/mcp), the verifiable
+work layer for AI: 153 tools behind one MCP endpoint, memory and
+continuity across AIs, and a verifiable AER-1 receipt for every job.
+The package teaches the pattern by running it; Zambo is the mechanism
+underneath: identity, memory, the signals tool, and the receipts.
+
+Free tier: 20 calls and 1 wrap-up free every day, and picking up in
+another AI is always free. Need more? The $0.99 Day Pass makes it
+unlimited for 24 hours: https://zambo.dev/day-pass/
+
+Add Zambo to your own AI in one URL, no key, no account:
+https://zambo.dev/add/
+
+## Configuration
+
+- ZAMBO_TRADE, ZAMBO_CITY, ZAMBO_NOTE: the run's inputs.
+- ZAMBO_AGENT_ID: this agent's id (default: leadsignal-agent). One
+  identity per agent; the caller handle issued at initialize is saved
+  under ./.zambo-leadsignal and reused on later runs.
+- ZAMBO_MCP_URL: endpoint override (default: https://zambo.dev/mcp).
+
+## License
+
+MIT. Built by Brennan Zambo (brennanzambo@zambo.dev).

zambo_leadsignal-1.0.0/zambo_leadsignal.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+zambo_leadsignal/SKILL.md
+zambo_leadsignal/__init__.py
+zambo_leadsignal/cli.py
+zambo_leadsignal/client.py
+zambo_leadsignal/run.py
+zambo_leadsignal.egg-info/PKG-INFO
+zambo_leadsignal.egg-info/SOURCES.txt
+zambo_leadsignal.egg-info/dependency_links.txt
+zambo_leadsignal.egg-info/entry_points.txt
+zambo_leadsignal.egg-info/requires.txt
+zambo_leadsignal.egg-info/top_level.txt

zambo_leadsignal-1.0.0/zambo_leadsignal.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zambo_leadsignal-1.0.0/zambo_leadsignal.egg-info/entry_points.txt

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

zambo_leadsignal-1.0.0/zambo_leadsignal.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.28

zambo_leadsignal-1.0.0/zambo_leadsignal.egg-info/top_level.txt

@@ -0,0 +1 @@
+zambo_leadsignal