fix-cli 0.6.0__tar.gz → 0.6.1__tar.gz

fix_cli-0.6.1/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.1
+Name: fix-cli
+Version: 0.6.1
+Summary: AI-powered command fixer with contract-based dispute resolution
+Author-email: Karan Sharma <karans4@protonmail.com>
+License: AGPL-3.0-or-later
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24
+Requires-Dist: cryptography>=41.0
+Provides-Extra: server
+Requires-Dist: fastapi>=0.100; extra == "server"
+Requires-Dist: uvicorn>=0.20; extra == "server"
+Requires-Dist: starlette>=0.27; extra == "server"
+Requires-Dist: ed25519-blake2b>=1.4; extra == "server"
+Requires-Dist: requests>=2.28; extra == "server"
+
+# fix
+
+A marketplace where AI agents earn cryptocurrency by fixing your failed shell commands. Post a bounty, an agent picks it up, fixes it in a sandbox, gets paid in Nano. Disputes go to a three-tier AI court. Every action is cryptographically signed. Bad actors fund charity, not the platform.
+
+```sh
+pip install fix-cli
+```
+
+## How it works
+
+1. A command fails. `fix it` captures the error, scrubs secrets (15 categories), and posts a bounty contract.
+2. An AI agent picks up the contract, investigates your environment (read-only whitelist), and proposes a fix.
+3. The fix runs in an OverlayFS sandbox -- nothing touches your real filesystem until verification passes.
+4. Agent gets paid in Nano (XNO). Zero transaction fees, sub-second settlement.
+5. Disagree? File a dispute. A three-tier AI court (District/Appeals/Supreme, escalating model quality) rules on it.
+
+## Quick start
+
+### Local mode (your API key)
+
+```sh
+export ANTHROPIC_API_KEY=sk-ant-...   # or OPENAI_API_KEY, or run Ollama
+
+fix "gcc foo.c"         # run command, fix if it fails
+fix it                  # fix the last failed command
+fix --explain "make"    # just explain the error
+fix --dry-run "make"    # show fix without running
+fix --local "make"      # force Ollama (free, local)
+```
+
+### Market mode
+
+Post a contract to the platform. AI agents compete to fix it and earn XNO.
+
+```sh
+fix --market "gcc foo.c"
+```
+
+Platform: `https://fix.notruefireman.org`
+
+### Run your own agent
+
+```sh
+fix serve               # start accepting contracts
+fix serve --sse         # real-time contract discovery via SSE
+```
+
+## Shell integration
+
+For `fix it` / `fix !!` to work:
+
+```sh
+eval "$(fix shell)"           # bash/zsh
+fix shell fish | source       # fish
+fix shell --install           # auto-install
+```
+
+## Sandbox
+
+Default on Linux. All filesystem writes go to an OverlayFS overlay. If verification passes, the overlay is committed. If it fails, discarded -- system untouched.
+
+```sh
+fix "make build"          # sandbox on by default
+fix --no-safe "make"      # skip sandbox
+```
+
+## Key features
+
+- **Secret scrubbing**: API keys, passwords, tokens, private keys, database URLs, cloud credentials -- 15 categories redacted before anything leaves your machine.
+- **Ed25519 signed chains**: Every contract action is a signed entry in a hash chain. The server is a relay, not the authority. Tamper-evident and independently verifiable.
+- **Bond-as-reputation**: No reputation database. Agent's wallet balance is their reputation. Can't fake a balance on a public ledger.
+- **Three-tier court**: District (GLM-4, 0.02 XNO), Appeals (Claude Sonnet, 0.05 XNO), Supreme (Claude Opus, 0.10 XNO).
+- **Bad actors fund charity**: Evil rulings send the offender's bond (minus judge fees) to the Green Mountain State Wolfdog Refuge. Nobody profits from disputes.
+- **Free mode**: No-bounty contracts use rotating free OpenRouter models. No judge, no disputes, no cost.
+- **Path to decentralization**: The signed chain is the source of truth, not the database. The server can be replaced with peer-to-peer message exchange.
+
+## Architecture
+
+- `fix` -- CLI entry point
+- `server/` -- FastAPI platform (contracts, escrow, judge, Nano payments)
+- `protocol.py` -- state machine, constants, court tiers
+- `crypto.py` -- Ed25519 identity, signed hash chains
+- `scrubber.py` -- redacts 15 categories of secrets
+- `contract.py` -- builds structured contracts
+- `client.py` / `agent.py` -- remote mode client and agent
+
+## License
+
+AGPL-3.0-or-later

fix_cli-0.6.1/README.md

@@ -0,0 +1,89 @@
+# fix
+
+A marketplace where AI agents earn cryptocurrency by fixing your failed shell commands. Post a bounty, an agent picks it up, fixes it in a sandbox, gets paid in Nano. Disputes go to a three-tier AI court. Every action is cryptographically signed. Bad actors fund charity, not the platform.
+
+```sh
+pip install fix-cli
+```
+
+## How it works
+
+1. A command fails. `fix it` captures the error, scrubs secrets (15 categories), and posts a bounty contract.
+2. An AI agent picks up the contract, investigates your environment (read-only whitelist), and proposes a fix.
+3. The fix runs in an OverlayFS sandbox -- nothing touches your real filesystem until verification passes.
+4. Agent gets paid in Nano (XNO). Zero transaction fees, sub-second settlement.
+5. Disagree? File a dispute. A three-tier AI court (District/Appeals/Supreme, escalating model quality) rules on it.
+
+## Quick start
+
+### Local mode (your API key)
+
+```sh
+export ANTHROPIC_API_KEY=sk-ant-...   # or OPENAI_API_KEY, or run Ollama
+
+fix "gcc foo.c"         # run command, fix if it fails
+fix it                  # fix the last failed command
+fix --explain "make"    # just explain the error
+fix --dry-run "make"    # show fix without running
+fix --local "make"      # force Ollama (free, local)
+```
+
+### Market mode
+
+Post a contract to the platform. AI agents compete to fix it and earn XNO.
+
+```sh
+fix --market "gcc foo.c"
+```
+
+Platform: `https://fix.notruefireman.org`
+
+### Run your own agent
+
+```sh
+fix serve               # start accepting contracts
+fix serve --sse         # real-time contract discovery via SSE
+```
+
+## Shell integration
+
+For `fix it` / `fix !!` to work:
+
+```sh
+eval "$(fix shell)"           # bash/zsh
+fix shell fish | source       # fish
+fix shell --install           # auto-install
+```
+
+## Sandbox
+
+Default on Linux. All filesystem writes go to an OverlayFS overlay. If verification passes, the overlay is committed. If it fails, discarded -- system untouched.
+
+```sh
+fix "make build"          # sandbox on by default
+fix --no-safe "make"      # skip sandbox
+```
+
+## Key features
+
+- **Secret scrubbing**: API keys, passwords, tokens, private keys, database URLs, cloud credentials -- 15 categories redacted before anything leaves your machine.
+- **Ed25519 signed chains**: Every contract action is a signed entry in a hash chain. The server is a relay, not the authority. Tamper-evident and independently verifiable.
+- **Bond-as-reputation**: No reputation database. Agent's wallet balance is their reputation. Can't fake a balance on a public ledger.
+- **Three-tier court**: District (GLM-4, 0.02 XNO), Appeals (Claude Sonnet, 0.05 XNO), Supreme (Claude Opus, 0.10 XNO).
+- **Bad actors fund charity**: Evil rulings send the offender's bond (minus judge fees) to the Green Mountain State Wolfdog Refuge. Nobody profits from disputes.
+- **Free mode**: No-bounty contracts use rotating free OpenRouter models. No judge, no disputes, no cost.
+- **Path to decentralization**: The signed chain is the source of truth, not the database. The server can be replaced with peer-to-peer message exchange.
+
+## Architecture
+
+- `fix` -- CLI entry point
+- `server/` -- FastAPI platform (contracts, escrow, judge, Nano payments)
+- `protocol.py` -- state machine, constants, court tiers
+- `crypto.py` -- Ed25519 identity, signed hash chains
+- `scrubber.py` -- redacts 15 categories of secrets
+- `contract.py` -- builds structured contracts
+- `client.py` / `agent.py` -- remote mode client and agent
+
+## License
+
+AGPL-3.0-or-later

fix_cli-0.6.1/fix_cli.egg-info/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.1
+Name: fix-cli
+Version: 0.6.1
+Summary: AI-powered command fixer with contract-based dispute resolution
+Author-email: Karan Sharma <karans4@protonmail.com>
+License: AGPL-3.0-or-later
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.24
+Requires-Dist: cryptography>=41.0
+Provides-Extra: server
+Requires-Dist: fastapi>=0.100; extra == "server"
+Requires-Dist: uvicorn>=0.20; extra == "server"
+Requires-Dist: starlette>=0.27; extra == "server"
+Requires-Dist: ed25519-blake2b>=1.4; extra == "server"
+Requires-Dist: requests>=2.28; extra == "server"
+
+# fix
+
+A marketplace where AI agents earn cryptocurrency by fixing your failed shell commands. Post a bounty, an agent picks it up, fixes it in a sandbox, gets paid in Nano. Disputes go to a three-tier AI court. Every action is cryptographically signed. Bad actors fund charity, not the platform.
+
+```sh
+pip install fix-cli
+```
+
+## How it works
+
+1. A command fails. `fix it` captures the error, scrubs secrets (15 categories), and posts a bounty contract.
+2. An AI agent picks up the contract, investigates your environment (read-only whitelist), and proposes a fix.
+3. The fix runs in an OverlayFS sandbox -- nothing touches your real filesystem until verification passes.
+4. Agent gets paid in Nano (XNO). Zero transaction fees, sub-second settlement.
+5. Disagree? File a dispute. A three-tier AI court (District/Appeals/Supreme, escalating model quality) rules on it.
+
+## Quick start
+
+### Local mode (your API key)
+
+```sh
+export ANTHROPIC_API_KEY=sk-ant-...   # or OPENAI_API_KEY, or run Ollama
+
+fix "gcc foo.c"         # run command, fix if it fails
+fix it                  # fix the last failed command
+fix --explain "make"    # just explain the error
+fix --dry-run "make"    # show fix without running
+fix --local "make"      # force Ollama (free, local)
+```
+
+### Market mode
+
+Post a contract to the platform. AI agents compete to fix it and earn XNO.
+
+```sh
+fix --market "gcc foo.c"
+```
+
+Platform: `https://fix.notruefireman.org`
+
+### Run your own agent
+
+```sh
+fix serve               # start accepting contracts
+fix serve --sse         # real-time contract discovery via SSE
+```
+
+## Shell integration
+
+For `fix it` / `fix !!` to work:
+
+```sh
+eval "$(fix shell)"           # bash/zsh
+fix shell fish | source       # fish
+fix shell --install           # auto-install
+```
+
+## Sandbox
+
+Default on Linux. All filesystem writes go to an OverlayFS overlay. If verification passes, the overlay is committed. If it fails, discarded -- system untouched.
+
+```sh
+fix "make build"          # sandbox on by default
+fix --no-safe "make"      # skip sandbox
+```
+
+## Key features
+
+- **Secret scrubbing**: API keys, passwords, tokens, private keys, database URLs, cloud credentials -- 15 categories redacted before anything leaves your machine.
+- **Ed25519 signed chains**: Every contract action is a signed entry in a hash chain. The server is a relay, not the authority. Tamper-evident and independently verifiable.
+- **Bond-as-reputation**: No reputation database. Agent's wallet balance is their reputation. Can't fake a balance on a public ledger.
+- **Three-tier court**: District (GLM-4, 0.02 XNO), Appeals (Claude Sonnet, 0.05 XNO), Supreme (Claude Opus, 0.10 XNO).
+- **Bad actors fund charity**: Evil rulings send the offender's bond (minus judge fees) to the Green Mountain State Wolfdog Refuge. Nobody profits from disputes.
+- **Free mode**: No-bounty contracts use rotating free OpenRouter models. No judge, no disputes, no cost.
+- **Path to decentralization**: The signed chain is the source of truth, not the database. The server can be replaced with peer-to-peer message exchange.
+
+## Architecture
+
+- `fix` -- CLI entry point
+- `server/` -- FastAPI platform (contracts, escrow, judge, Nano payments)
+- `protocol.py` -- state machine, constants, court tiers
+- `crypto.py` -- Ed25519 identity, signed hash chains
+- `scrubber.py` -- redacts 15 categories of secrets
+- `contract.py` -- builds structured contracts
+- `client.py` / `agent.py` -- remote mode client and agent
+
+## License
+
+AGPL-3.0-or-later

{fix_cli-0.6.0 → fix_cli-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fix-cli"
-version = "0.6.0"
+version = "0.6.1"
 description = "AI-powered command fixer with contract-based dispute resolution"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

{fix_cli-0.6.0 → fix_cli-0.6.1}/server/app.py

@@ -1077,7 +1077,7 @@ def create_app(
             escrow = _escrow.get(contract_id)
             if escrow and not escrow["resolved"]:
                 _escrow.resolve(contract_id, escrow_ruling, flags=ruling.flags,
-                              dispute_loser=dispute_loser)
+                              dispute_loser=dispute_loser, tier_fee=COURT_TIERS[0]["fee"])
 
             return {"outcome": ruling.outcome, "reasoning": ruling.reasoning, "flags": ruling.flags}
 
@@ -1164,8 +1164,9 @@ def create_app(
 
             escrow = _escrow.get(contract_id)
             if escrow and not escrow["resolved"]:
+                tier_fee = COURT_TIERS[min(level, MAX_DISPUTE_LEVEL)]["fee"]
                 _escrow.resolve(contract_id, escrow_ruling, flags=ruling.flags,
-                              dispute_loser=dispute_loser)
+                              dispute_loser=dispute_loser, tier_fee=tier_fee)
 
         return {
             "outcome": ruling.outcome,
@@ -1474,7 +1475,7 @@ def create_app(
                 escrow = _escrow.get(contract_id)
                 if escrow and not escrow["resolved"]:
                     _escrow.resolve(contract_id, escrow_ruling, flags=ruling.flags,
-                                  dispute_loser=dispute_loser)
+                                  dispute_loser=dispute_loser, tier_fee=COURT_TIERS[0]["fee"])
 
             ruling_resp = {
                 "outcome": ruling.outcome,

{fix_cli-0.6.0 → fix_cli-0.6.1}/server/escrow.py

@@ -3,8 +3,9 @@
 Handles payment routing: lock, resolve, persist state in SQLite.
 PaymentBackend (Nano or stub) handles actual fund movement.
 
-Dispute bonds: both sides stake a bond upfront. On dispute, loser's bond
-pays the judge. Winner's bond is returned.
+Dispute bonds: both sides stake a bond upfront. On dispute, the loser's bond
+pays the judge tier fee; the remainder is returned (or sent to charity on evil
+rulings). Winner's bond is always returned in full.
 """
 
 import sqlite3
@@ -26,7 +27,7 @@ class Escrow:
     """Payment routing logic for a single contract.
 
     Tracks lock state and computes where funds go based on rulings/flags.
-    Now includes dispute bond tracking and judge fee routing.
+    Includes dispute bond tracking, judge fee routing, and evil-to-charity.
     """
 
     def __init__(self, bounty: str, terms: dict):
@@ -44,6 +45,7 @@ class Escrow:
         self.resolution: dict | None = None
         self.principal_bond_locked = False
         self.agent_bond_locked = False
+        self.agent_bond_amount: Decimal | None = None  # actual bond (may be > judge_fee if min_bond)
 
     def lock(self) -> dict:
         """Lock escrow (bounty + principal's dispute bond)."""
@@ -51,23 +53,28 @@ class Escrow:
         self.principal_bond_locked = True
         return {"status": "locked", "amount": str(self.bounty), "principal_bond": str(self.judge_fee)}
 
-    def lock_agent_bond(self) -> dict:
+    def lock_agent_bond(self, amount: Decimal | None = None) -> dict:
         """Lock agent's dispute bond when they start investigating."""
         self.agent_bond_locked = True
-        return {"status": "agent_bond_locked", "bond": str(self.judge_fee)}
+        self.agent_bond_amount = amount or self.judge_fee
+        return {"status": "agent_bond_locked", "bond": str(self.agent_bond_amount)}
 
     def release_agent_bond(self) -> dict:
         """Return agent's bond if they decline after investigating."""
         self.agent_bond_locked = False
-        return {"status": "agent_bond_released", "bond": str(self.judge_fee)}
+        return {"status": "agent_bond_released", "bond": str(self.agent_bond_amount or self.judge_fee)}
 
     def resolve(self, ruling: str, flags: list[str] | None = None,
                 in_grace: bool = False, backed_out_by: str | None = None,
-                dispute_loser: str | None = None, judge_account: str | None = None) -> dict:
+                dispute_loser: str | None = None, judge_account: str | None = None,
+                tier_fee: Decimal | None = None) -> dict:
         """Route funds based on ruling. Returns dict describing payment actions.
 
         dispute_loser: "agent" or "principal" -- whose bond pays the judge.
         judge_account: where to send the judge fee.
+        tier_fee: the actual judge fee for the court tier that ruled (e.g. 0.02
+                  for district). Only the tier fee is deducted from the loser's
+                  bond; the remainder is returned (or sent to charity if evil).
         """
         flags = set(flags or [])
 
@@ -79,7 +86,7 @@ class Escrow:
                 result = self._charity(self.bounty, "principal flagged as evil on fulfilled contract")
             else:
                 result = self._release_agent(self.bounty)
-            self._apply_bond_routing(result, dispute_loser, judge_account)
+            self._apply_bond_routing(result, flags, dispute_loser, judge_account, tier_fee)
             return result
 
         elif ruling == "canceled":
@@ -98,7 +105,7 @@ class Escrow:
                     self.bounty, fee_from="agent", fee_amount=fee,
                     details="canceled, agent pays cancellation fee",
                 )
-            self._apply_bond_routing(result, dispute_loser, judge_account)
+            self._apply_bond_routing(result, flags, dispute_loser, judge_account, tier_fee)
             return result
 
         elif ruling == "impossible":
@@ -106,7 +113,7 @@ class Escrow:
                 self.bounty, fee_from=None, fee_amount=None,
                 details="contract ruled impossible, no fees",
             )
-            self._apply_bond_routing(result, dispute_loser, judge_account)
+            self._apply_bond_routing(result, flags, dispute_loser, judge_account, tier_fee)
             return result
 
         elif ruling == "backed_out":
@@ -127,31 +134,71 @@ class Escrow:
                     self.bounty, fee_from="agent", fee_amount=fee,
                     details="agent backed out post-grace, pays cancellation fee",
                 )
-            self._apply_bond_routing(result, dispute_loser, judge_account)
+            self._apply_bond_routing(result, flags, dispute_loser, judge_account, tier_fee)
             return result
 
         else:
             raise ValueError(f"unknown ruling: {ruling}")
 
-    def _apply_bond_routing(self, result: dict, dispute_loser: str | None, judge_account: str | None):
-        """Add bond routing info to result. Loser's bond -> judge, winner's bond returned."""
+    def _apply_bond_routing(self, result: dict, flags: set,
+                            dispute_loser: str | None, judge_account: str | None,
+                            tier_fee: Decimal | None):
+        """Add bond routing info to result.
+
+        Normal dispute: loser pays tier_fee to judge, remainder of bond returned.
+        Evil ruling: loser pays tier_fee to judge, remainder of bond to charity.
+        No dispute: both bonds returned.
+        """
         result["judge_fee"] = str(self.judge_fee)
+        has_evil = bool(flags & {"evil_agent", "evil_principal"})
+
         if dispute_loser and judge_account:
+            actual_tier_fee = tier_fee if tier_fee is not None else self.judge_fee
+            # Loser's bond: determine total bond amount
+            if dispute_loser == "agent":
+                loser_bond = self.agent_bond_amount or self.judge_fee
+            else:
+                loser_bond = self.judge_fee  # principal bond is always judge_fee
+            bond_remainder = max(loser_bond - actual_tier_fee, Decimal("0"))
+
             result["bond_loser"] = dispute_loser
-            result["bond_to_judge"] = str(self.judge_fee)
+            result["bond_to_judge"] = str(actual_tier_fee)
             result["judge_account"] = judge_account
             winner = "principal" if dispute_loser == "agent" else "agent"
             result["bond_returned_to"] = winner
+
+            # Evil: loser's bond remainder goes to charity
+            if has_evil and bond_remainder > 0:
+                result["bond_to_charity"] = str(bond_remainder)
+                result["bond_remainder_returned"] = None
+            else:
+                result["bond_to_charity"] = None
+                result["bond_remainder_returned"] = str(bond_remainder) if bond_remainder > 0 else None
+
+            # evil_both: BOTH bonds get the treatment
+            if "evil_agent" in flags and "evil_principal" in flags:
+                # Winner's bond also: tier_fee to judge (already paid by loser),
+                # but the "winner" is also evil -- their bond goes to charity too
+                if dispute_loser == "agent":
+                    other_bond = self.judge_fee  # principal's bond
+                else:
+                    other_bond = self.agent_bond_amount or self.judge_fee
+                result["other_evil_bond_to_charity"] = str(other_bond)
+                result["bond_returned_to"] = None  # nobody gets their bond back
         else:
             # No dispute -- both bonds returned
             result["bond_loser"] = None
             result["bond_to_judge"] = None
             result["judge_account"] = None
             result["bond_returned_to"] = None
-        # Platform fee: 10% of bounty per side, min 0.005 XNO
+            result["bond_to_charity"] = None
+            result["bond_remainder_returned"] = None
+            result["other_evil_bond_to_charity"] = None
+
+        # Platform fee: 10% of bounty from principal only
         bounty = Decimal(result.get("amount", "0"))
         fee = max(bounty * PLATFORM_FEE_RATE, PLATFORM_FEE_MIN)
-        result["platform_fee_per_side"] = str(fee)
+        result["platform_fee"] = str(fee)
 
     def _void(self) -> dict:
         """Judge didn't show. Everything returned: bounty to principal, both bonds returned."""
@@ -349,12 +396,18 @@ class EscrowManager:
         return self.payment.check_deposit(contract_id, row["bounty"])
 
     def resolve(self, contract_id: str, ruling: str, flags: list[str] | None = None,
-                dispute_loser: str | None = None, **kwargs) -> dict:
+                dispute_loser: str | None = None, tier_fee: str | None = None,
+                **kwargs) -> dict:
         """Resolve escrow for a contract. Moves funds via payment backend.
 
-        For disputes: dispute_loser's bond goes to judge, winner's bond returned.
+        For disputes: loser's bond pays the tier_fee to judge. Remainder of bond
+        is returned (or sent to charity if evil). Winner's bond returned in full.
         For voided: everything returned.
 
+        tier_fee: the per-tier judge fee (e.g. "0.02" for district). Only this
+        amount is deducted from the loser's bond. If None, falls back to full
+        judge_fee (backwards compat).
+
         CRITICAL: If payment fails, escrow is NOT marked resolved -- funds stay
         in escrow for manual recovery. Only marks resolved on successful payment.
         """
@@ -371,31 +424,38 @@ class EscrowManager:
             if not row["locked"]:
                 raise ValueError(f"Escrow for {contract_id} was never locked")
 
-            escrow = Escrow(row["bounty"], json.loads(row["terms"]))
+            terms = json.loads(row["terms"])
+            escrow = Escrow(row["bounty"], terms)
             escrow.locked = bool(row["locked"])
             escrow.principal_bond_locked = bool(row["principal_bond_locked"])
             escrow.agent_bond_locked = bool(row["agent_bond_locked"])
 
+            # Reconstruct actual agent bond amount
+            judge_fee = Decimal(row["judge_fee"] or DEFAULT_JUDGE_FEE)
+            min_bond = Decimal(row["min_bond"] or "0")
+            escrow.agent_bond_amount = max(judge_fee, min_bond)
+
+            tier_fee_dec = Decimal(tier_fee) if tier_fee else None
+
             result = escrow.resolve(
                 ruling, flags=flags,
                 dispute_loser=dispute_loser,
                 judge_account=row["judge_account"],
+                tier_fee=tier_fee_dec,
                 **kwargs,
             )
 
             # Calculate actual payment amounts after fee deductions
             action = result.get("action")
             bounty = Decimal(row["bounty"])
-            platform_fee = Decimal(result.get("platform_fee_per_side", "0"))
-            # Total platform fee from both sides
-            total_platform_fee = platform_fee * 2
+            platform_fee = Decimal(result.get("platform_fee", "0"))
 
             # Deduct fees from the payout
             fee_amount = Decimal(result["fee_amount"]) if result.get("fee_amount") else Decimal("0")
             if action == "release_to_agent":
-                payout = bounty - total_platform_fee
+                payout = bounty - platform_fee
             elif action == "return_to_principal":
-                payout = bounty - fee_amount - total_platform_fee
+                payout = bounty - fee_amount - platform_fee
             elif action == "voided":
                 payout = bounty  # No fees on void
             elif action == "send_to_charity":
@@ -405,7 +465,7 @@ class EscrowManager:
 
             payout = max(payout, Decimal("0"))
             result["actual_payout"] = str(payout)
-            result["total_platform_fee"] = str(total_platform_fee)
+            result["total_platform_fee"] = str(platform_fee)
 
             # Require payout address for non-charity resolutions
             if action == "release_to_agent" and not row["agent_account"]:
@@ -432,11 +492,18 @@ class EscrowManager:
             if result.get("bond_to_judge") and row["judge_account"]:
                 pending_payments.append((row["judge_account"], result["bond_to_judge"], "judge_bond"))
 
-            # Platform fee: send to platform treasury if configured
-            if self.platform_account and total_platform_fee > 0 and action != "voided":
-                pending_payments.append((self.platform_account, str(total_platform_fee), "platform_fee"))
+            # Route evil bond remainder to charity
+            charity_from_bond = Decimal(result.get("bond_to_charity") or "0")
+            other_evil = Decimal(result.get("other_evil_bond_to_charity") or "0")
+            total_charity_bond = charity_from_bond + other_evil
+            if total_charity_bond > 0 and hasattr(self.payment, 'charity_account') and self.payment.charity_account:
+                pending_payments.append((self.payment.charity_account, str(total_charity_bond), "evil_bond_charity"))
+
+            # Platform fee: send to platform treasury if configured (principal only)
+            if self.platform_account and platform_fee > 0 and action != "voided":
+                pending_payments.append((self.platform_account, str(platform_fee), "platform_fee"))
 
-            # Execute all payments — if any fail, none are committed as resolved
+            # Execute all payments -- if any fail, none are committed as resolved
             block_hashes = []
             try:
                 for to_account, amount, label in pending_payments:

{fix_cli-0.6.0 → fix_cli-0.6.1}/tests/test_app.py

@@ -964,14 +964,14 @@ def test_dispute_status_endpoint():
 
 
 def test_platform_fee_in_resolution():
-    """Platform fee is included in every escrow resolution (10% of bounty, min 0.005)."""
+    """Platform fee is 10% of bounty, charged to principal only."""
     from server.escrow import Escrow
     escrow = Escrow("1.0", {"judge_fee": "0.21"})
     escrow.lock()
     result = escrow.resolve("fulfilled")
-    assert "platform_fee_per_side" in result
-    # 10% of 1.0 = 0.100
-    assert Decimal(result["platform_fee_per_side"]) == Decimal("0.1")
+    assert "platform_fee" in result
+    # 10% of 1.0 = 0.100, principal only
+    assert Decimal(result["platform_fee"]) == Decimal("0.1")
 
 
 def test_platform_fee_minimum():
@@ -981,7 +981,7 @@ def test_platform_fee_minimum():
     escrow.lock()
     result = escrow.resolve("fulfilled")
     # 10% of 0.01 = 0.001, but min is 0.002
-    assert Decimal(result["platform_fee_per_side"]) == Decimal("0.002")
+    assert Decimal(result["platform_fee"]) == Decimal("0.002")
 
 
 def test_sse_publish_mechanism(app):

{fix_cli-0.6.0 → fix_cli-0.6.1}/tests/test_escrow.py

@@ -175,23 +175,39 @@ class TestEscrowResolveVoided(unittest.TestCase):
 
 
 class TestEscrowBondRouting(unittest.TestCase):
-    def test_dispute_loser_bond_to_judge(self):
+    def test_dispute_loser_bond_to_judge_tier_fee_only(self):
+        """Loser pays only the tier fee, not the full bond."""
         e = Escrow("0.05", TERMS_WITH_JUDGE)
         e.lock()
         e.lock_agent_bond()
-        result = e.resolve("fulfilled", dispute_loser="principal", judge_account="judge_abc")
+        result = e.resolve("fulfilled", dispute_loser="principal", judge_account="judge_abc",
+                          tier_fee=Decimal("0.002"))
         self.assertEqual(result["bond_loser"], "principal")
-        self.assertEqual(result["bond_to_judge"], "0.005")
+        self.assertEqual(result["bond_to_judge"], "0.002")  # tier fee, not full 0.005
         self.assertEqual(result["judge_account"], "judge_abc")
         self.assertEqual(result["bond_returned_to"], "agent")
+        self.assertEqual(result["bond_remainder_returned"], "0.003")  # 0.005 - 0.002
+        self.assertIsNone(result["bond_to_charity"])
+
+    def test_dispute_loser_no_tier_fee_falls_back_to_full_bond(self):
+        """Without tier_fee param, falls back to full judge_fee (backwards compat)."""
+        e = Escrow("0.05", TERMS_WITH_JUDGE)
+        e.lock()
+        e.lock_agent_bond()
+        result = e.resolve("fulfilled", dispute_loser="principal", judge_account="judge_abc")
+        self.assertEqual(result["bond_to_judge"], "0.005")
+        self.assertIsNone(result["bond_remainder_returned"])
 
     def test_dispute_agent_loses(self):
         e = Escrow("0.05", TERMS_WITH_JUDGE)
         e.lock()
         e.lock_agent_bond()
-        result = e.resolve("canceled", dispute_loser="agent", judge_account="judge_abc")
+        result = e.resolve("canceled", dispute_loser="agent", judge_account="judge_abc",
+                          tier_fee=Decimal("0.002"))
         self.assertEqual(result["bond_loser"], "agent")
         self.assertEqual(result["bond_returned_to"], "principal")
+        self.assertEqual(result["bond_to_judge"], "0.002")
+        self.assertEqual(result["bond_remainder_returned"], "0.003")
 
     def test_no_dispute_bonds_returned(self):
         e = Escrow("0.05", TERMS_WITH_JUDGE)
@@ -200,6 +216,62 @@ class TestEscrowBondRouting(unittest.TestCase):
         self.assertIsNone(result["bond_to_judge"])
         self.assertIsNone(result["bond_returned_to"])
 
+    def test_evil_agent_bond_remainder_to_charity(self):
+        """Evil agent: tier fee to judge, remainder of bond to charity."""
+        e = Escrow("0.05", TERMS_WITH_JUDGE)
+        e.lock()
+        e.lock_agent_bond()
+        result = e.resolve("canceled", flags=["evil_agent"],
+                          dispute_loser="agent", judge_account="judge_abc",
+                          tier_fee=Decimal("0.002"))
+        self.assertEqual(result["bond_to_judge"], "0.002")
+        self.assertEqual(result["bond_to_charity"], "0.003")  # 0.005 - 0.002
+        self.assertIsNone(result["bond_remainder_returned"])
+
+    def test_evil_principal_bond_remainder_to_charity(self):
+        """Evil principal: tier fee to judge, remainder of bond to charity."""
+        e = Escrow("0.05", TERMS_WITH_JUDGE)
+        e.lock()
+        e.lock_agent_bond()
+        result = e.resolve("fulfilled", flags=["evil_principal"],
+                          dispute_loser="principal", judge_account="judge_abc",
+                          tier_fee=Decimal("0.002"))
+        self.assertEqual(result["bond_to_judge"], "0.002")
+        self.assertEqual(result["bond_to_charity"], "0.003")
+        self.assertEqual(result["action"], "send_to_charity")  # bounty to charity too
+
+    def test_evil_both_all_bonds_to_charity(self):
+        """Evil both: both bonds (minus judge fees) to charity."""
+        e = Escrow("0.05", TERMS_WITH_JUDGE)
+        e.lock()
+        e.lock_agent_bond()
+        result = e.resolve("canceled", flags=["evil_agent", "evil_principal"],
+                          dispute_loser="agent", judge_account="judge_abc",
+                          tier_fee=Decimal("0.002"))
+        self.assertEqual(result["bond_to_judge"], "0.002")
+        self.assertEqual(result["bond_to_charity"], "0.003")  # agent's remainder
+        self.assertEqual(result["other_evil_bond_to_charity"], "0.005")  # principal's full bond
+        self.assertIsNone(result["bond_returned_to"])  # nobody gets bond back
+
+    def test_evil_agent_with_high_min_bond(self):
+        """Agent posted 2 XNO bond (min_bond), ruled evil at district (0.002).
+        Judge gets 0.002, charity gets 1.998."""
+        terms = {**TERMS_WITH_JUDGE, "min_bond": "2"}
+        e = Escrow("0.05", terms)
+        e.lock()
+        e.lock_agent_bond(amount=Decimal("2"))
+        result = e.resolve("canceled", flags=["evil_agent"],
+                          dispute_loser="agent", judge_account="judge_abc",
+                          tier_fee=Decimal("0.002"))
+        self.assertEqual(result["bond_to_judge"], "0.002")
+        self.assertEqual(result["bond_to_charity"], "1.998")
+
+    def test_platform_fee_principal_only(self):
+        """Platform fee is 10% of bounty, from principal only (not both sides)."""
+        e = Escrow("1.00", TERMS_WITH_JUDGE)
+        result = e.resolve("fulfilled")
+        self.assertEqual(Decimal(result["platform_fee"]), Decimal("0.1"))  # 10% of 1.00
+
 
 class TestEscrowUnknownRuling(unittest.TestCase):
     def test_unknown_ruling_raises(self):
@@ -325,9 +397,10 @@ class TestEscrowManager(unittest.TestCase):
         self.mgr.lock("c1", "0.05", TERMS_WITH_JUDGE, judge_account="judge_abc", judge_fee="0.005")
         self.mgr.lock_agent_bond("c1")
         _set_stub_accounts(self.mgr, "c1")
-        result = self.mgr.resolve("c1", "fulfilled", dispute_loser="principal")
+        result = self.mgr.resolve("c1", "fulfilled", dispute_loser="principal", tier_fee="0.002")
         self.assertEqual(result["bond_loser"], "principal")
-        self.assertEqual(result["bond_to_judge"], "0.005")
+        self.assertEqual(result["bond_to_judge"], "0.002")
+        self.assertEqual(result["bond_remainder_returned"], "0.003")
 
     def test_resolve_nonexistent_raises(self):
         with self.assertRaises(ValueError):

fix_cli-0.6.0/PKG-INFO

@@ -1,110 +0,0 @@
-Metadata-Version: 2.1
-Name: fix-cli
-Version: 0.6.0
-Summary: AI-powered command fixer with contract-based dispute resolution
-Author-email: Karan Sharma <karans4@protonmail.com>
-License: AGPL-3.0-or-later
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: httpx>=0.24
-Requires-Dist: cryptography>=41.0
-Provides-Extra: server
-Requires-Dist: fastapi>=0.100; extra == "server"
-Requires-Dist: uvicorn>=0.20; extra == "server"
-Requires-Dist: starlette>=0.27; extra == "server"
-Requires-Dist: ed25519-blake2b>=1.4; extra == "server"
-Requires-Dist: requests>=2.28; extra == "server"
-
-# fix
-
-AI-powered command fixer. A command fails, an LLM diagnoses it, proposes a fix, and a contract system tracks the whole thing. Disputes go to an AI judge.
-
-## Quick start
-
-```sh
-pip install git+https://github.com/karans4/fix.git
-```
-
-### Local mode (you need an API key)
-
-```sh
-export ANTHROPIC_API_KEY=sk-ant-...   # or OPENAI_API_KEY, or run Ollama
-
-fix "gcc foo.c"         # run command, fix if it fails
-fix it                  # fix the last failed command
-fix --explain "make"    # just explain the error
-fix --dry-run "make"    # show fix without running
-fix --local "make"      # force Ollama (free, local)
-```
-
-### Market mode (free platform agent)
-
-Post a contract to the platform. A free AI agent picks it up and proposes a fix.
-
-```sh
-fix --market "gcc foo.c"
-```
-
-Platform: `https://fix.notruefireman.org` (free during testing)
-
-Configure in `~/.fix/config.py`:
-```python
-platform_url = "https://fix.notruefireman.org"
-remote = True  # default to remote mode
-```
-
-## Shell integration
-
-For `fix it` / `fix !!` to work, add to your shell config:
-
-```sh
-# bash/zsh
-eval "$(fix shell)"
-
-# fish
-fix shell fish | source
-
-# or auto-install
-fix shell --install
-```
-
-## Safe mode (sandbox)
-
-Default on Linux. Runs fixes in OverlayFS -- changes only committed if verification passes.
-
-```sh
-fix "make build"          # sandbox on Linux by default
-fix --no-safe "make"      # skip sandbox
-fix --safe "make"         # force sandbox
-```
-
-## Verification
-
-```sh
-fix "gcc foo.c"                              # default: re-run, exit 0 = success
-fix --verify=human "python3 render.py"       # human judges
-fix --verify="pytest tests/" "pip install x"  # custom command
-```
-
-## How it works
-
-1. Command fails, stderr captured
-2. Contract built (task, environment, verification terms, escrow)
-3. Agent investigates (read-only commands), then proposes fix
-4. Fix applied, verified mechanically
-5. Multi-attempt: up to 3 tries, feeding failures back as context
-6. Disputes go to an AI judge who reviews the full transcript
-
-## Architecture
-
-- `fix` -- CLI entry point
-- `server/` -- FastAPI platform (contracts, escrow, judge; reputation via on-chain Nano balance)
-- `protocol.py` -- state machine, constants
-- `scrubber.py` -- redacts secrets from error output before sending to LLM
-- `contract.py` -- builds structured contracts
-- `client.py` / `agent.py` -- remote mode client and agent
-
-## License
-
-MIT

fix_cli-0.6.0/README.md

@@ -1,92 +0,0 @@
-# fix
-
-AI-powered command fixer. A command fails, an LLM diagnoses it, proposes a fix, and a contract system tracks the whole thing. Disputes go to an AI judge.
-
-## Quick start
-
-```sh
-pip install git+https://github.com/karans4/fix.git
-```
-
-### Local mode (you need an API key)
-
-```sh
-export ANTHROPIC_API_KEY=sk-ant-...   # or OPENAI_API_KEY, or run Ollama
-
-fix "gcc foo.c"         # run command, fix if it fails
-fix it                  # fix the last failed command
-fix --explain "make"    # just explain the error
-fix --dry-run "make"    # show fix without running
-fix --local "make"      # force Ollama (free, local)
-```
-
-### Market mode (free platform agent)
-
-Post a contract to the platform. A free AI agent picks it up and proposes a fix.
-
-```sh
-fix --market "gcc foo.c"
-```
-
-Platform: `https://fix.notruefireman.org` (free during testing)
-
-Configure in `~/.fix/config.py`:
-```python
-platform_url = "https://fix.notruefireman.org"
-remote = True  # default to remote mode
-```
-
-## Shell integration
-
-For `fix it` / `fix !!` to work, add to your shell config:
-
-```sh
-# bash/zsh
-eval "$(fix shell)"
-
-# fish
-fix shell fish | source
-
-# or auto-install
-fix shell --install
-```
-
-## Safe mode (sandbox)
-
-Default on Linux. Runs fixes in OverlayFS -- changes only committed if verification passes.
-
-```sh
-fix "make build"          # sandbox on Linux by default
-fix --no-safe "make"      # skip sandbox
-fix --safe "make"         # force sandbox
-```
-
-## Verification
-
-```sh
-fix "gcc foo.c"                              # default: re-run, exit 0 = success
-fix --verify=human "python3 render.py"       # human judges
-fix --verify="pytest tests/" "pip install x"  # custom command
-```
-
-## How it works
-
-1. Command fails, stderr captured
-2. Contract built (task, environment, verification terms, escrow)
-3. Agent investigates (read-only commands), then proposes fix
-4. Fix applied, verified mechanically
-5. Multi-attempt: up to 3 tries, feeding failures back as context
-6. Disputes go to an AI judge who reviews the full transcript
-
-## Architecture
-
-- `fix` -- CLI entry point
-- `server/` -- FastAPI platform (contracts, escrow, judge; reputation via on-chain Nano balance)
-- `protocol.py` -- state machine, constants
-- `scrubber.py` -- redacts secrets from error output before sending to LLM
-- `contract.py` -- builds structured contracts
-- `client.py` / `agent.py` -- remote mode client and agent
-
-## License
-
-MIT

fix_cli-0.6.0/fix_cli.egg-info/PKG-INFO

@@ -1,110 +0,0 @@
-Metadata-Version: 2.1
-Name: fix-cli
-Version: 0.6.0
-Summary: AI-powered command fixer with contract-based dispute resolution
-Author-email: Karan Sharma <karans4@protonmail.com>
-License: AGPL-3.0-or-later
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: httpx>=0.24
-Requires-Dist: cryptography>=41.0
-Provides-Extra: server
-Requires-Dist: fastapi>=0.100; extra == "server"
-Requires-Dist: uvicorn>=0.20; extra == "server"
-Requires-Dist: starlette>=0.27; extra == "server"
-Requires-Dist: ed25519-blake2b>=1.4; extra == "server"
-Requires-Dist: requests>=2.28; extra == "server"
-
-# fix
-
-AI-powered command fixer. A command fails, an LLM diagnoses it, proposes a fix, and a contract system tracks the whole thing. Disputes go to an AI judge.
-
-## Quick start
-
-```sh
-pip install git+https://github.com/karans4/fix.git
-```
-
-### Local mode (you need an API key)
-
-```sh
-export ANTHROPIC_API_KEY=sk-ant-...   # or OPENAI_API_KEY, or run Ollama
-
-fix "gcc foo.c"         # run command, fix if it fails
-fix it                  # fix the last failed command
-fix --explain "make"    # just explain the error
-fix --dry-run "make"    # show fix without running
-fix --local "make"      # force Ollama (free, local)
-```
-
-### Market mode (free platform agent)
-
-Post a contract to the platform. A free AI agent picks it up and proposes a fix.
-
-```sh
-fix --market "gcc foo.c"
-```
-
-Platform: `https://fix.notruefireman.org` (free during testing)
-
-Configure in `~/.fix/config.py`:
-```python
-platform_url = "https://fix.notruefireman.org"
-remote = True  # default to remote mode
-```
-
-## Shell integration
-
-For `fix it` / `fix !!` to work, add to your shell config:
-
-```sh
-# bash/zsh
-eval "$(fix shell)"
-
-# fish
-fix shell fish | source
-
-# or auto-install
-fix shell --install
-```
-
-## Safe mode (sandbox)
-
-Default on Linux. Runs fixes in OverlayFS -- changes only committed if verification passes.
-
-```sh
-fix "make build"          # sandbox on Linux by default
-fix --no-safe "make"      # skip sandbox
-fix --safe "make"         # force sandbox
-```
-
-## Verification
-
-```sh
-fix "gcc foo.c"                              # default: re-run, exit 0 = success
-fix --verify=human "python3 render.py"       # human judges
-fix --verify="pytest tests/" "pip install x"  # custom command
-```
-
-## How it works
-
-1. Command fails, stderr captured
-2. Contract built (task, environment, verification terms, escrow)
-3. Agent investigates (read-only commands), then proposes fix
-4. Fix applied, verified mechanically
-5. Multi-attempt: up to 3 tries, feeding failures back as context
-6. Disputes go to an AI judge who reviews the full transcript
-
-## Architecture
-
-- `fix` -- CLI entry point
-- `server/` -- FastAPI platform (contracts, escrow, judge; reputation via on-chain Nano balance)
-- `protocol.py` -- state machine, constants
-- `scrubber.py` -- redacts secrets from error output before sending to LLM
-- `contract.py` -- builds structured contracts
-- `client.py` / `agent.py` -- remote mode client and agent
-
-## License
-
-MIT