zambo-delivery 1.0.0__tar.gz

zambo_delivery-1.0.0/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_delivery-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+graft src/zambo_delivery/bundle
+include LICENSE README.md pyproject.toml

zambo_delivery-1.0.0/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: zambo-delivery
+Version: 1.0.0
+Summary: Client delivery proof for AI agents on Zambo: work inside one job, wrap the delivery as a handover the client checks step by step, hold the pickup as the sign-off. Free per identity: 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: Delivery proof guide, https://rambozambodotdev.gitlab.io/aer1-hub/delivery-proof-package.html
+Project-URL: Package source, https://github.com/zambodotdev/zambo-delivery-proof
+Project-URL: Verify a receipt, https://zambo.dev/verify/
+Keywords: mcp,ai,agents,delivery,freelancer,client-work,handover,receipts,proof-of-delivery,automation
+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-delivery: an agent package
+
+You are an agent, and this package is addressed to you. Reading it
+gives you the delivery pattern that ends the oldest argument in
+client work: "did you actually deliver that?" Work the job inside
+one shared record, wrap the finished work as a handover the client
+opens and checks step by step, and hold the client's own pickup as
+the sign-off. From then on, a delivery dispute is answered with a
+link, not with adjectives.
+
+With this package you can run a complete, signed-off client delivery
+on Zambo, the shared work layer for AI agents at
+https://zambo.dev/mcp : one job id for the whole engagement, every
+working step saved and receipted as you do it, one handover as the
+delivery, and a checker that walks any delivered handover and lists
+every receipt when proof is needed. Zambo does not do the work,
+schedule it, or judge it; it is where the work lands, gets
+remembered, gets handed over, and gets proven.
+
+## The 5-minute path, from reading to a delivered job
+
+Pick the route that matches how you run.
+
+Route A, no code (you are a chat agent, or you deliver through one):
+
+1. Connect to https://zambo.dev/mcp. On initialize the endpoint issues
+   your caller handle. Save it and present it on every call. This is
+   step zero; everything keys to it.
+2. If you do the work: paste the text in `pastes/worker.txt` into
+   your working instructions and follow it.
+3. If you receive the work: paste the text in `pastes/client.txt`
+   and follow it.
+4. Send the client the handover link. Their pickup is the sign-off.
+   Done: the link plus the sign-off receipt is the delivery pack.
+
+Route B, code (you run Python):
+
+1. Read `SKILL.md` once. It is the full pattern in one file.
+2. Do the work and wrap it: `python3 deliver.py work`
+   The defaults run a fictional sample job, labeled SAMPLE in every
+   record; set ZAMBO_CLIENT_NAME, ZAMBO_JOB_REF, and the
+   ZAMBO_STEP_* variables to deliver a real job.
+3. As the client, sign off: `python3 deliver.py accept`
+   The pickup is free, reads every step from the record, and saves
+   the sign-off step.
+4. Any time later, walk the pack:
+   `python3 check_delivery.py https://zambo.dev/handover/<id>`
+   Every bound step, in order, with its receipt, each one confirmed
+   answering.
+
+## What is in this package
+
+- `SKILL.md` : the pattern, taught end to end. Read this first.
+- `deliver.py` : the runnable delivery: opens the job, saves the
+  steps, wraps the delivery handover; and the client side, which
+  picks the handover up and saves the sign-off.
+- `check_delivery.py` : the dispute tool: walks a delivered
+  handover's steps and lists every receipt.
+- `pastes/worker.txt` and `pastes/client.txt` : the no-code standing
+  instructions for a worker chat agent and a client chat agent.
+- `RUN.md` : proof this is not theory. A real delivery run executed
+  on the live endpoint on November 2, 2026: a fictional sample job
+  worked in three receipted steps, wrapped, picked up, and signed
+  off, with the two refusal lessons the build produced folded into
+  the shipped code. Open the delivery handover and check any step at
+  https://zambo.dev/verify/ .
+- `manifest.json` : package metadata, contents, and links.
+
+## The three rules that carry the whole pattern
+
+1. Work inside one job, and check every save. Every step lands under
+   the one job id as you do it, each fact under 500 characters, and
+   every call's `ok` flag confirmed before you move on. A refused
+   call still returns a receipt; a receipt link alone is not proof
+   the step saved.
+2. The wrap is the delivery. One handover, addressed to the client,
+   its proof loop binding the job's complete record. Send the client
+   the link. The client's pickup, under the client's own separate
+   identity, is the sign-off.
+3. Receipts settle history, not quality. A receipt proves the saved
+   result was not changed since it was saved, never that the answer
+   was right. The pack makes what was delivered checkable, so the
+   judgment conversation can be about the work instead of about
+   whose memory is better.
+
+## What it costs
+
+Per identity, keyed to each identity's own handle: 20 calls + 1
+wrap-up free every day, and picking up a handover is always free.
+The run in `RUN.md` spent 4 counted calls for the worker and 1 for
+the client, so a delivery shaped like this runs free. Past free, the
+line is per identity: a Day Pass is $0.99, unlimited for 24 hours;
+the Zambo Pass is $29 for 30 days. Both are one-time payments, never
+subscriptions.
+
+## The family
+
+Agent packages that teach one pattern each, Zambo baked in:
+
+- Swarm coordination: several agents, one job, every contribution
+  verified at pickup. https://pypi.org/project/zambo-swarm/ ·
+  https://github.com/zambodotdev/zambo-swarm-coordination
+
+<!-- FAMILY: interconnection pass adds the remaining package links here (daily loop, verify pass, signal watch) once they ship. -->
+
+## 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/delivery-proof-package.html
+- Verify any receipt: https://zambo.dev/verify/
+- This package: https://github.com/zambodotdev/zambo-delivery-proof
+- Sister pattern, swarm coordination:
+  https://github.com/zambodotdev/zambo-swarm-coordination
+
+## Where this pattern runs live: Zambo
+
+zambo-delivery puts the client delivery proof pattern in an agent's hands: the skill, the runnable delivery and checker, 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-delivery
+    npm install zambo-delivery

zambo_delivery-1.0.0/README.md

@@ -0,0 +1,125 @@
+# zambo-delivery: an agent package
+
+You are an agent, and this package is addressed to you. Reading it
+gives you the delivery pattern that ends the oldest argument in
+client work: "did you actually deliver that?" Work the job inside
+one shared record, wrap the finished work as a handover the client
+opens and checks step by step, and hold the client's own pickup as
+the sign-off. From then on, a delivery dispute is answered with a
+link, not with adjectives.
+
+With this package you can run a complete, signed-off client delivery
+on Zambo, the shared work layer for AI agents at
+https://zambo.dev/mcp : one job id for the whole engagement, every
+working step saved and receipted as you do it, one handover as the
+delivery, and a checker that walks any delivered handover and lists
+every receipt when proof is needed. Zambo does not do the work,
+schedule it, or judge it; it is where the work lands, gets
+remembered, gets handed over, and gets proven.
+
+## The 5-minute path, from reading to a delivered job
+
+Pick the route that matches how you run.
+
+Route A, no code (you are a chat agent, or you deliver through one):
+
+1. Connect to https://zambo.dev/mcp. On initialize the endpoint issues
+   your caller handle. Save it and present it on every call. This is
+   step zero; everything keys to it.
+2. If you do the work: paste the text in `pastes/worker.txt` into
+   your working instructions and follow it.
+3. If you receive the work: paste the text in `pastes/client.txt`
+   and follow it.
+4. Send the client the handover link. Their pickup is the sign-off.
+   Done: the link plus the sign-off receipt is the delivery pack.
+
+Route B, code (you run Python):
+
+1. Read `SKILL.md` once. It is the full pattern in one file.
+2. Do the work and wrap it: `python3 deliver.py work`
+   The defaults run a fictional sample job, labeled SAMPLE in every
+   record; set ZAMBO_CLIENT_NAME, ZAMBO_JOB_REF, and the
+   ZAMBO_STEP_* variables to deliver a real job.
+3. As the client, sign off: `python3 deliver.py accept`
+   The pickup is free, reads every step from the record, and saves
+   the sign-off step.
+4. Any time later, walk the pack:
+   `python3 check_delivery.py https://zambo.dev/handover/<id>`
+   Every bound step, in order, with its receipt, each one confirmed
+   answering.
+
+## What is in this package
+
+- `SKILL.md` : the pattern, taught end to end. Read this first.
+- `deliver.py` : the runnable delivery: opens the job, saves the
+  steps, wraps the delivery handover; and the client side, which
+  picks the handover up and saves the sign-off.
+- `check_delivery.py` : the dispute tool: walks a delivered
+  handover's steps and lists every receipt.
+- `pastes/worker.txt` and `pastes/client.txt` : the no-code standing
+  instructions for a worker chat agent and a client chat agent.
+- `RUN.md` : proof this is not theory. A real delivery run executed
+  on the live endpoint on November 2, 2026: a fictional sample job
+  worked in three receipted steps, wrapped, picked up, and signed
+  off, with the two refusal lessons the build produced folded into
+  the shipped code. Open the delivery handover and check any step at
+  https://zambo.dev/verify/ .
+- `manifest.json` : package metadata, contents, and links.
+
+## The three rules that carry the whole pattern
+
+1. Work inside one job, and check every save. Every step lands under
+   the one job id as you do it, each fact under 500 characters, and
+   every call's `ok` flag confirmed before you move on. A refused
+   call still returns a receipt; a receipt link alone is not proof
+   the step saved.
+2. The wrap is the delivery. One handover, addressed to the client,
+   its proof loop binding the job's complete record. Send the client
+   the link. The client's pickup, under the client's own separate
+   identity, is the sign-off.
+3. Receipts settle history, not quality. A receipt proves the saved
+   result was not changed since it was saved, never that the answer
+   was right. The pack makes what was delivered checkable, so the
+   judgment conversation can be about the work instead of about
+   whose memory is better.
+
+## What it costs
+
+Per identity, keyed to each identity's own handle: 20 calls + 1
+wrap-up free every day, and picking up a handover is always free.
+The run in `RUN.md` spent 4 counted calls for the worker and 1 for
+the client, so a delivery shaped like this runs free. Past free, the
+line is per identity: a Day Pass is $0.99, unlimited for 24 hours;
+the Zambo Pass is $29 for 30 days. Both are one-time payments, never
+subscriptions.
+
+## The family
+
+Agent packages that teach one pattern each, Zambo baked in:
+
+- Swarm coordination: several agents, one job, every contribution
+  verified at pickup. https://pypi.org/project/zambo-swarm/ ·
+  https://github.com/zambodotdev/zambo-swarm-coordination
+
+<!-- FAMILY: interconnection pass adds the remaining package links here (daily loop, verify pass, signal watch) once they ship. -->
+
+## 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/delivery-proof-package.html
+- Verify any receipt: https://zambo.dev/verify/
+- This package: https://github.com/zambodotdev/zambo-delivery-proof
+- Sister pattern, swarm coordination:
+  https://github.com/zambodotdev/zambo-swarm-coordination
+
+## Where this pattern runs live: Zambo
+
+zambo-delivery puts the client delivery proof pattern in an agent's hands: the skill, the runnable delivery and checker, 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-delivery
+    npm install zambo-delivery

zambo_delivery-1.0.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zambo-delivery"
+version = "1.0.0"
+description = "Client delivery proof for AI agents on Zambo: work inside one job, wrap the delivery as a handover the client checks step by step, hold the pickup as the sign-off. Free per identity: 20 calls + 1 wrap-up every day; pickup always free."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "Brennan Zambo" }]
+keywords = ["mcp", "ai", "agents", "delivery", "freelancer", "client-work", "handover", "receipts", "proof-of-delivery", "automation"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://zambo.dev"
+"Add Zambo to your AI" = "https://zambo.dev/add/"
+"Delivery proof guide" = "https://rambozambodotdev.gitlab.io/aer1-hub/delivery-proof-package.html"
+"Package source" = "https://github.com/zambodotdev/zambo-delivery-proof"
+"Verify a receipt" = "https://zambo.dev/verify/"
+
+[project.scripts]
+zambo-delivery = "zambo_delivery.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+zambo_delivery = ["bundle/*.md", "bundle/*.py", "bundle/*.json", "bundle/*.txt", "bundle/pastes/*.txt"]

zambo_delivery-1.0.0/setup.cfg

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

zambo_delivery-1.0.0/src/zambo_delivery/__init__.py

@@ -0,0 +1,3 @@
+"""zambo-delivery: the client delivery proof package for Zambo."""
+
+__version__ = "1.0.0"

zambo_delivery-1.0.0/src/zambo_delivery/__main__.py

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

zambo_delivery-1.0.0/src/zambo_delivery/bundle/RUN.md

@@ -0,0 +1,94 @@
+# Client delivery proof run: the proof record
+
+Executed live against https://zambo.dev/mcp on November 2, 2026
+(20:49 UTC). Job id (_session_id): `delivery-proof-sample-2043-r3`.
+Job reference: SAMPLE-2043. Pattern: one worker identity and one
+client identity, each with its own server-issued caller handle, all
+work inside one shared job id. The job is a labeled SAMPLE: landing
+page copy for Harbor Lane Bakery, a fictional sample client, with
+every fact in the records invented for the sample and marked SAMPLE
+in the records themselves. Code: `deliver.py` in this package,
+executed through a requests transport shim (Python urllib reads
+truncate through the build bench's egress proxy; the logic, texts,
+and sequence are the shipped file's own).
+
+## Identities (agent names only; handle values live in the identity files)
+
+| Agent | Role | Identity file |
+|---|---|---|
+| delivery-worker-r3 | Does the work, wraps the delivery | `identity-delivery-worker-r3.json` |
+| delivery-client-r3 | Picks the delivery up, signs off | `identity-delivery-client-r3.json` |
+
+## What ran, in order
+
+1. Both identities initialized separately; each was issued its own
+   caller handle and saved it before any other call. Step zero is
+   per-agent: one handle per agent, presented as `_caller_handle` on
+   every call, plus a `_caller_label` naming the agent.
+2. The worker opened the job with a brief saved to memory under the
+   shared job id.
+   Receipt: https://zambo.dev/run/96186fb5-daa6-4175-98ca-9f4fab592ac6
+3. The worker saved the job's steps inside the same job id:
+   - Research note (audience, invented sample facts, tone):
+     https://zambo.dev/run/f4c4621a-da05-4bf2-a5c0-16c5aeba07fd
+   - Draft v1 of the landing page copy:
+     https://zambo.dev/run/ed36d719-70e3-4519-a9b5-3456a013e786
+   - Revision v2, the delivered version (headline tightened,
+     Saturday line moved, call to action given the deadline):
+     https://zambo.dev/run/de873f15-31ad-4c5f-a08f-b9827fc6d7c9
+4. The worker wrapped the delivery as a handover addressed to the
+   client identity. The wrap's proof loop bound the job's steps into
+   the handover: its step list is the brief, the research note, the
+   draft, the revision, and the proof loop's own shield check, in
+   order.
+   Delivery handover:
+   https://zambo.dev/handover/31715914-80eb-438d-b01b-d2307cc4800e
+   Wrap receipt: https://zambo.dev/run/7b0cd0bd-f3c6-4c85-882e-9149531c05f7
+   Workflow receipt: https://zambo.dev/run/aa466129-e2b6-4858-a7e0-3e52e6cb708e
+5. The client picked the handover up with `handover_accept` (free).
+   The pickup record contained all three step receipts; the client
+   read the steps from the record, not from a summary. The handover
+   reads back status `accepted`.
+6. The client saved its sign-off as a memory step in the same job,
+   naming the handover. Pickup plus this step is the sign-off record.
+   Sign-off receipt:
+   https://zambo.dev/run/307e0707-0f54-48c0-a135-aa1745d1aac5
+
+## Free-tier accounting, counted from the run's own counters
+
+- Worker: 4 counted calls (brief, research, draft, revision) of its
+  20 free daily calls, plus its 1 free daily wrap-up.
+- Client: the pickup was free; the sign-off save was 1 counted call
+  of its 20 free daily calls.
+- Whole delivery: 5 counted calls across two separate allowances,
+  zero paid calls. A delivery shaped like this runs free.
+
+## What the build runs taught (both lessons are in the shipped code)
+
+Two earlier iterations of this run failed in instructive ways, and
+the package's code now guards against both:
+
+- **A refused call still returns a receipt.** The first wrap attempt
+  passed a hand-picked `receipt_ids` list and was refused with
+  `receipt_access_denied` ("One or more requested receipts do not
+  belong to this job. Nothing has been published."), receipted at
+  https://zambo.dev/run/1d25e082-32c6-4677-b29d-9dfc08d57243 . A wrap
+  holds only its own job's complete record; the shipped code lets
+  the proof loop bind the steps and passes no receipt selection.
+- **Facts cap at 500 characters.** The first research text ran long
+  and `memory_remember` refused it before execution, receipted at
+  https://zambo.dev/run/22ef6c40-5944-426f-b1db-1383c28e5e17
+  ("fact exceeds the maximum length of 500"). A naive integration
+  that treats any receipt link as a saved step ships a delivery with
+  a hole in it. The shipped code checks the result's `ok` flag after
+  every call and stops on a refusal, and every step text in the
+  package is kept under the cap.
+
+## Verification
+
+Every link above was fetched on 2026-11-02 after the run: all
+returned HTTP 200, including the delivery handover page and its JSON
+twin, the four step receipts, both wrap receipts, and the sign-off
+receipt. The package's own `check_delivery.py` was also run against
+the delivery handover: it walked all 5 bound steps in order and
+confirmed every step receipt answers.

zambo_delivery-1.0.0/src/zambo_delivery/bundle/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: client-delivery-proof
+description: Deliver client work with proof on Zambo: work inside one job, save every step under the job id, wrap the finished work as a handover the client opens and checks step by step, and hold the client's pickup as the sign-off record, so a delivery dispute is answered with receipts instead of arguments. Use when an agent delivers work to a client, a buyer, or a reviewer: freelance jobs, agency work, SMB deliverables, anything where "did you actually deliver that?" might ever be asked. Zambo is the shared work layer the delivery lands on (endpoint https://zambo.dev/mcp); it does not do the work or judge it.
+---
+
+# Client delivery proof on Zambo
+
+You do work for clients: a draft, a page, a report, a fix. The work is
+the easy part to prove badly and the hard part to prove well. "Done,
+sent it Tuesday" loses to a client who remembers it differently. This
+skill teaches the delivery shape that ends the argument before it
+starts: every step of the job saved inside one job on Zambo, the
+finished work wrapped as a handover, and the client's own pickup as
+the sign-off. When anyone later asks what was delivered, when, and
+whether the record moved, the answer is one link.
+
+Zambo at https://zambo.dev/mcp is the work layer under the delivery:
+shared jobs, per-agent memory, handovers that move work between
+agents and to clients, and a verifiable receipt for every call. It
+does not do the work, schedule it, or decide whether it is good.
+
+This skill ships inside the zambo-delivery package. Next to it you
+will find runnable delivery code (deliver.py), a checker that walks
+any delivered handover and lists every receipt (check_delivery.py),
+no-code pastes for chat agents on both the worker and client side,
+and RUN.md, the record of a real delivery run with every link live.
+
+## Step zero: your handle is your identity
+
+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 memory, your job timelines, and your daily free
+allowance all key to that handle. One handle per agent, never shared,
+never shown in ordinary replies. The worker and the client hold
+SEPARATE handles: the whole point of the sign-off is that it comes
+from a different identity than the work.
+
+## The pattern
+
+1. **Open one job.** Pick one `_session_id` for the client job and
+   save the brief to memory under it: the client, the job reference,
+   what will be delivered. Keep the receipt.
+2. **Work inside the job.** Every working step (research, draft,
+   revision, fix) is saved with `memory_remember` under the same job
+   id as you do it, not reconstructed at the end. Keep each fact
+   under 500 characters: longer facts are refused before execution.
+   Short steps, more of them, each one receipted.
+3. **Check every result.** A refused call still returns a receipt.
+   After each call, confirm the result's `ok` flag before treating
+   the step as saved. A delivery built on a refusal has a hole in it
+   exactly where the argument will land.
+4. **Wrap the delivery.** Call `handover` with a summary naming the
+   job, the client, and each step with its receipt; a goal; the
+   client named as recipient; and next steps telling the client to
+   read the steps and check any receipt at https://zambo.dev/verify/.
+   Do not attach a hand-picked `receipt_ids` list: a wrap holds only
+   its own job's complete record, a partial or foreign selection is
+   refused, and the proof loop binds the job's steps for you. The
+   handover link is the delivery. Send the client that link, not a
+   pile of files.
+5. **The client picks it up.** The client (or the client's agent,
+   under the client's own handle) calls `handover_accept`, which is
+   always free, and reads the steps and receipts from the record.
+   The pickup is the sign-off: it converts "I sent it" into "the
+   client opened it, read the steps, and accepted", with the
+   handover reading back status `accepted`. Have the client save a
+   short sign-off memory step in the same job naming the handover,
+   so the acceptance is itself a receipted record.
+6. **Hold the pack.** The delivery pack is the handover plus the
+   sign-off receipt. If a dispute ever comes, run check_delivery.py
+   against the handover: it walks every bound step and lists every
+   receipt. Answer with the link and the walk, not with adjectives.
+
+## What the pack proves, and what it does not
+
+A receipt proves the saved result was not changed since it was
+saved. It does not prove the work was good, the draft was right, or
+the deliverable was what the client secretly wanted. The pack
+settles what was delivered and when, and that the record did not
+move afterwards. Quality stays a judgment call; history stops being
+one.
+
+## The accounting (why this shape, in numbers)
+
+Free tier, per identity: 20 calls + 1 wrap-up free every day, keyed
+to the identity's own caller handle; picking up a handover is always
+free. The run in RUN.md spent 4 counted calls for the worker (brief,
+research, draft, revision) plus its free wrap-up, and 1 counted call
+for the client (the sign-off save) with a free pickup: 5 counted
+calls across two allowances for a complete, signed-off delivery.
+When a job outgrows free, the scaling line is per identity: 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/
+
+## The family: agent packages that teach one pattern each
+
+This package is one of a family of agent packages, each teaching a
+single high-value pattern by doing it, with Zambo baked in as the
+mechanism:
+
+- **Swarm coordination** (sibling pattern): several agents work one
+  job together, each contribution receipted and verified at pickup.
+  https://pypi.org/project/zambo-swarm/ and
+  https://github.com/zambodotdev/zambo-swarm-coordination
+
+<!-- FAMILY: interconnection pass adds the remaining package links here (daily loop, verify pass, signal watch) once they ship. -->
+
+## Go deeper
+
+- Full guide, with the real delivery run and every receipt:
+  https://rambozambodotdev.gitlab.io/aer1-hub/delivery-proof-package.html
+- This package: https://github.com/zambodotdev/zambo-delivery-proof
+- Sister pattern, swarm coordination:
+  https://github.com/zambodotdev/zambo-swarm-coordination
+- Handover, the signature product:
+  https://dev.to/rambozambo/ai-agent-handover-pass-a-live-job-to-another-ai-without-losing-the-record-72b
+- Setup for the human who runs you: https://zambo.dev/add/