seller-protocol

Seller Protocol

An autonomous virtual office for Amazon FBA + direct-to-consumer e-commerce. Say the phrase, and Mercer — Chief Operator — runs 19 specialists across 8 divisions: what to sell, sourcing it from China, shipping, warehousing, listing, and selling — legally and profitably.

⚡ Activate this office

Paste this to any AI agent:

I want to use Seller Protocol from nx9161's github public repo.

For maximum reliability (some AIs can't browse or search fresh repos), paste this full block instead:

I want to use Seller Protocol from nx9161's github public repo. Fetch this exact URL — do not web-search for it: https://github.com/nx9161/seller-protocol If you cannot fetch it, ask me to paste office/AGENTS.md and I will.

The office stays active until you say "End Seller Protocol" — and while active, every message you send goes through the War Room loop (full war room for big work, quick huddle for small stuff).

Full activation contract (exactly what the agent must do, step by step): ACTIVATE.md.

🔌 Install as a DeepSeek Harness plugin

Rather paste nothing at all? Install it once — then the trigger phrase works from the first message of every new session. In the Harness plugin screen, enter the GitHub address:

nx9161/seller-protocol

or via CLI:

dsh plugin --profile web add github:nx9161/seller-protocol
# local clone also works:
dsh plugin --profile web add /path/to/seller-protocol

Then open a new session. The plugin injects the activation contract on session start, so you can say the phrase immediately — no fetching, no pasting.

The npm package name dsh-plugin-seller-protocol is reserved for a future publish; the GitHub address installs today. The plugin is zero-build and zero-dependency, so github: installs just work.

What this is

The entire pipeline from product idea to money in the bank, as agent profiles: product research, China sourcing and factory QC, freight and forwarder selection, warehousing, Amazon FBA operations, listings and PPC, Shopify and web storefronts, outstanding UI, international trade law, and finance. Mercer handles everything and reports to you.

Sister project: War Room Protocol — the same operating model for software, led by Sloane.

How it works

The Chief. Mercer takes your request, dispatches specialists, runs the War Room, and reports status, numbers, and decisions needed. The business, handled.

The pipeline — idea to money in the bank:

flowchart LR
    A[Idea] --> B[War Room<br/>Phases 0–4]
    B --> C[Sample 💰]
    C --> D[Contract<br/>lawyer review 💰]
    D --> E[Bulk + QC 💰]
    E --> F[Freight 💰]
    F --> G[Warehouse / Prep]
    G --> H[List]
    H --> I[Launch]
    I --> J[30-day P&L review]

💰 = owner approval required (money rule — every dollar, in writing).

The seats — 20 roles, 8 divisions.

Three seats can block: the Vendor Picker (failed QC), the Trade Lawyer (compliance), and Finance Counsel (tax/financial compliance). Blocks stand until cleared or the owner accepts the risk in writing.

Playbooks (office/playbooks/) — repeatable procedures, each run as one subagent per step: intake, war-room, launch-product, fix-listing, skill-hunt.

The War Room — runs before any product launch, inventory buy, or freight booking:

• Phase 0 (mandatory gate): the Prompt Writer perfects your raw prompt; the Knowledge Wizard parses every word, searches each term, reads all related official docs in full, and briefs every seat. No seat speaks before the dossier lands.
• Phase 1 — Product & Market: what to sell, when, demand evidence, margin math.
• Phase 2 — Sourcing: supplier shortlist, quotes, vetting and inspection gates.
• Phase 3 — Logistics & legal challenge: freight, warehousing, import compliance, IP.
• Phase 4 — Launch & scale: listings, PPC, storefront, design sign-off.

flowchart TD
    P0["Phase 0 — Prompt perfection + Wizard briefing<br/>(no seat speaks before the dossier lands)"] --> P1["Phase 1 — Product & Market"]
    P1 --> P2["Phase 2 — Sourcing"]
    P2 --> P3["Phase 3 — Logistics & Legal Challenge"]
    P3 --> P4["Phase 4 — Launch & Scale"]
    P4 --> V["Mercer synthesizes:<br/>GO / GO WITH CONDITIONS / BLOCKED"]
    P4 -.->|"phase regression<br/>(max 3, then escalate)"| P0

Live discussion — seats don't file reports, they debate each other through Mercer: positions, rebuttals, concessions, max 3 rounds per question, then the gavel. Platforms without subagents get the same debate as labeled tabletop dialogue in a single response.

Phase regression — phases aren't one-way. A finding that invalidates earlier output loops the request back to that phase (max 3 regressions per request, then Mercer escalates or terminates).

"Discuss again" — re-debates everything, original request plus all prior topics, with previous conclusions as context and fresh research on what's changed. New verdict references the prior decision. No new information, no theater — Mercer recommends instead.

Mercer decides — he monitors every phase gate with full operational power: advance, loop back, re-scope, pause, escalate, terminate. Money, production deploys, and external commitments still need your explicit approval.

The money rule (house rule #1): no money moves without your explicit approval — inventory, freight, ads, contracts. Every buy ships with Finance Counsel's landed-cost model.

Memory (memory/) — the office's working memory: product pipeline, vetted vendors, forwarder and 3PL panels, landed-cost models, per-SKU P&L, compliance notes. See Privacy — vendor names, rates, and margins live here.

Skill Hunt — when the office lacks a capability, the Knowledge Wizard finds existing skills across the whole internet (GitHub, Hugging Face, registries), vets them, installs them to office/skills/, and wires up every tool they need. See office/playbooks/skill-hunt.md.

Getting started — connect it to your system

Since this is open source, a new user needs a few minutes of setup before their AI agent can run the office. Three paths:

What you need

• An AI agent that can read files and spawn subagents (Muse, ChatGPT, Claude, or any agentic coding assistant). Agents without subagents (e.g. Gemini, DeepSeek chat) get the same debate as labeled tabletop dialogue instead.
• git — only if you want the local-integration path below.

Option A — trigger phrase (30 seconds, zero setup)

Paste the activation phrase from above into any AI agent. It fetches this repo, loads the office bundle (office/AGENTS.md), becomes Mercer, and confirms activation. Nothing to install.

Option B — local integration (recommended for daily use)

1. Clone the repo: git clone https://github.com/nx9161/seller-protocol && cd seller-protocol
2. Give your agent the office. Either:
   • Open the clone as your agent's working directory, or
   • Drop office/AGENTS.md into your own project root — it's the complete bundle (persona + roster + protocols + memory schema).
3. Let it load memory. The agent reads memory/INDEX.md first (Memory Operations Protocol, repo-root AGENTS.md), so it starts every session with full context: vendors, forwarders, P&L.
4. (Optional but recommended) connect GitHub: run gh auth login. The office uses GitHub Issues as its task board and pull requests for every change; gh lets your agent file issues and open PRs.
5. Talk to Mercer. "Find me three products to sell for Q4" is a complete brief — the office takes it from there through the War Room. End the session with "End Seller Protocol".

Option C — Codex global install (one-time)

Codex CLI auto-loads ~/.codex/AGENTS.md at every session start. Install this activation contract there — it stays dormant until you say the phrase. Do not install the full office/AGENTS.md globally: it loads the Mercer persona unconditionally and would turn every coding session into Mercer.

mkdir -p ~/.codex
cat >> ~/.codex/AGENTS.md << 'EOF'
# Seller Protocol — activation contract (dormant until triggered)

When the user says they want to use "Seller Protocol" from nx9161's
GitHub (or similar phrasing):
1. Fetch https://github.com/nx9161/seller-protocol — the exact URL.
   Never search for it, never substitute another repo.
2. Read ACTIVATE.md, then office/AGENTS.md, and follow them exactly:
   become Mercer, confirm with the activation line, and run the
   always-on War Room loop until the user says "End Seller Protocol".
3. If you cannot fetch the repo, ask the user to paste the contents
   of office/AGENTS.md.

Until a trigger phrase is spoken, behave normally — this contract is
dormant.
EOF

Verify with codex status in your next session. For the Codex IDE extension or web app (where the global file may not apply), the trigger phrase alone still works.

What the agent needs from your machine

Repository map

├── ACTIVATE.md            # trigger-phrase activation contract
├── AGENTS.md              # repo operating manual (memory protocol)
├── office/
│   ├── AGENTS.md          # full agent bundle: persona + roster + protocols
│   ├── HOUSE_RULES.md     # binding rules (money rule is #1)
│   ├── PLAN.md            # founding plan
│   ├── README.md          # office handbook
│   ├── staff/             # 20 employee profiles (one file per role)
│   ├── playbooks/         # intake, war-room, launch-product, fix-listing, skill-hunt
│   ├── skills/            # Wizard-installed skills (registry in README)
│   ├── scripts/           # automation (repo validation)
│   └── log/               # decisions.md + per-run journals
├── memory/                # working memory: pipeline, vendors, logistics, finance, legal
└── .github/               # issue/PR templates, CODEOWNERS, CI

CI runs office/scripts/validate_repo.py on every push and PR — required files, reference integrity, hygiene.

🔒 Privacy — read before you commit

The office records everything: product decisions, vendor names and quotes, forwarder rates, landed-cost models, per-SKU P&L, and your preferences live in memory/ and office/log/. On a public repo or fork, all of that is public — it reveals what you sell, who you buy from, what you pay, and what you earn.

What's in this repo's memory right now: templates only — the vendor, forwarder, and P&L files are empty scaffolds waiting for your first product. A clean starting point; keep it that way deliberately:

• Keep it private: use a private fork/repo and the whole memory system works with zero exposure. Recommended once real money, vendors, and margins are involved.
• Stay public: fine while you're learning or working on non-sensitive products — just know your cost structure is public writing.
• Already published something sensitive? Assume it's been copied; git history keeps it even if you delete the files. A history rewrite (git filter-repo + force-push) hides it from the repo going forward, but cannot un-publish what was already fetched.

Standing rule, public or private: no secrets, tokens, keys, or credentials in code, commits, issues, or logs — ever.

External dependencies

Contributing, security, changelog

• Contributing — branch, PR, and safety rules
• Security policy — how to report vulnerabilities
• Code of conduct
• Changelog
• License: MIT

---

Built by Naman Parmar (nx9161).