@weave_protocol/domere 1.0.0

package/PLANNING.md

@@ -0,0 +1,231 @@
+# Dōmere: The Judge Protocol
+
+## Executive Summary
+
+**Dōmere** (Old English for "judge, arbiter") is the verification and anchoring layer for AI agent security. While Mund watches and Hord contains, Dōmere verifies the weave of intent through agent chains and anchors proof immutably to blockchain.
+
+## Core Philosophy: Weave-First Security
+
+Traditional identity systems ask "who is this agent?" - a point-in-time question.
+
+Dōmere asks "what is the thread of intent, how does it weave through agents, and does that pattern comply?" - a continuous verification question.
+
+**The weave matters more than the identity.**
+
+## Core Concepts
+
+### Thread Identity
+
+A thread represents the complete lifecycle of a human intent as it propagates through multiple AI agents:
+
+```
+Human Intent → Agent A → Agent B → Agent C → Result
+     ↓            ↓          ↓          ↓        ↓
+  [origin]    [hop 1]    [hop 2]    [hop 3]  [complete]
+     └────────────────────┬────────────────────┘
+                    Thread Identity
+```
+
+Each thread has:
+- **Origin**: Where did this start? (human, system, scheduled)
+- **Intent**: What was requested? What constraints apply?
+- **Hops**: Each agent interaction with full context
+- **Weave Signature**: Rolling cryptographic proof of the entire chain
+
+### Intent Drift
+
+As intent passes through agents, it can "drift" - each agent may reinterpret slightly. Dōmere detects when drift exceeds acceptable bounds:
+
+- Semantic similarity (embedding comparison)
+- Action alignment (are actions consistent with original intent)
+- Scope creep (has scope expanded beyond original request)
+- Constraint violations (explicit constraints broken)
+
+### Language Analysis
+
+Understanding what agents are processing is critical:
+
+- **Language Detection**: Is this English? Python? SQL? JSON?
+- **Semantic Analysis**: What does this content mean? What entities are referenced?
+- **Code Analysis**: What does this code do? Is it dangerous?
+- **NL Analysis**: Is there manipulation? Hidden instructions?
+
+### Blockchain Anchoring
+
+Local proofs are useful but can be modified. Blockchain anchoring provides:
+
+- **Immutability**: Cannot be changed by anyone
+- **Third-party Verification**: Anyone can verify
+- **Legal Standing**: Timestamped, cryptographic proof
+- **Audit Trail**: Permanent record
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                              DŌMERE                                         │
+│                                                                             │
+│  ┌─────────────────────────────────────────────────────────────────────┐   │
+│  │                         THREAD MANAGER                               │   │
+│  │                                                                       │   │
+│  │  • Create/manage thread lifecycle                                    │   │
+│  │  • Track hops through agent chain                                    │   │
+│  │  • Compute weave signatures                                          │   │
+│  │  • Detect intent drift                                               │   │
+│  └─────────────────────────────────────────────────────────────────────┘   │
+│                                    │                                        │
+│         ┌──────────────────────────┼──────────────────────────┐            │
+│         ▼                          ▼                          ▼            │
+│  ┌─────────────────┐      ┌─────────────────┐      ┌─────────────────┐    │
+│  │    LANGUAGE     │      │   COMPLIANCE    │      │   ARBITRATION   │    │
+│  │    ANALYZER     │      │     ENGINE      │      │     ENGINE      │    │
+│  │                 │      │                 │      │                 │    │
+│  │ • Detection     │      │ • Policy eval   │      │ • Case mgmt     │    │
+│  │ • Semantics     │      │ • ZK proofs     │      │ • Resolution    │    │
+│  │ • Code analysis │      │ • Violations    │      │ • Precedent     │    │
+│  │ • NL analysis   │      │                 │      │                 │    │
+│  └─────────────────┘      └─────────────────┘      └─────────────────┘    │
+│                                    │                                        │
+│                                    ▼                                        │
+│  ┌─────────────────────────────────────────────────────────────────────┐   │
+│  │                       ANCHORING CLIENT                               │   │
+│  │                                                                       │   │
+│  │  • Solana (real-time, cheap)                                         │   │
+│  │  • Ethereum (settlement, authoritative)                              │   │
+│  │  • Merkle tree generation                                            │   │
+│  │  • Verification                                                       │   │
+│  └─────────────────────────────────────────────────────────────────────┘   │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+## MCP Tools
+
+### Thread Management
+| Tool | Description |
+|------|-------------|
+| `domere_create_thread` | Initialize thread from human intent |
+| `domere_add_hop` | Record agent hop in thread |
+| `domere_verify_thread` | Verify thread integrity |
+| `domere_get_thread` | Retrieve thread details |
+| `domere_close_thread` | Mark thread complete |
+| `domere_list_threads` | List active/recent threads |
+
+### Language Analysis
+| Tool | Description |
+|------|-------------|
+| `domere_detect_language` | Detect language/code type |
+| `domere_analyze_content` | Full semantic analysis |
+| `domere_analyze_code` | Code-specific analysis |
+| `domere_check_injection` | Detect prompt injection |
+| `domere_extract_entities` | Extract entities from content |
+
+### Intent & Drift
+| Tool | Description |
+|------|-------------|
+| `domere_analyze_intent` | Deep analysis of stated intent |
+| `domere_check_drift` | Check intent drift at current hop |
+| `domere_compare_intents` | Compare two intent statements |
+
+### Compliance
+| Tool | Description |
+|------|-------------|
+| `domere_check_policy` | Check thread against policy |
+| `domere_generate_proof` | Generate compliance proof |
+| `domere_list_violations` | List policy violations |
+
+### Anchoring
+| Tool | Description |
+|------|-------------|
+| `domere_anchor_solana` | Anchor to Solana |
+| `domere_anchor_ethereum` | Anchor to Ethereum |
+| `domere_verify_anchor` | Verify on-chain anchor |
+| `domere_get_anchor_status` | Check anchoring status |
+
+### Arbitration
+| Tool | Description |
+|------|-------------|
+| `domere_open_dispute` | Open arbitration case |
+| `domere_submit_evidence` | Add evidence to case |
+| `domere_resolve_dispute` | Resolve dispute |
+
+## Pricing Model
+
+### Free (100% Open Source)
+- All language analysis
+- All thread management
+- All compliance checking
+- All proof generation
+- All MCP tools
+- All local operations
+
+### Paid (Blockchain Network Fees + Protocol Fee)
+- Solana anchoring: ~$0.001 per anchor
+- Ethereum anchoring: ~$2-10 per anchor
+- Protocol fee: 5% of gas cost
+
+## Technology Stack
+
+- **Runtime**: Node.js 20+
+- **Language**: TypeScript
+- **Protocol**: MCP (Model Context Protocol)
+- **Blockchain**: Solana (Anchor framework), Ethereum (Solidity)
+- **Crypto**: Native Node.js crypto, ethers.js, @solana/web3.js
+
+## Directory Structure
+
+```
+domere/
+├── src/
+│   ├── index.ts              # MCP server entry
+│   ├── types.ts              # Type definitions
+│   ├── constants.ts          # Configuration
+│   │
+│   ├── thread/               # Thread identity
+│   │   ├── index.ts
+│   │   ├── manager.ts
+│   │   ├── intent.ts
+│   │   ├── drift.ts
+│   │   └── weave.ts
+│   │
+│   ├── language/             # Language analysis
+│   │   ├── index.ts
+│   │   ├── detector.ts
+│   │   ├── semantic.ts
+│   │   ├── code-analyzer.ts
+│   │   └── nl-analyzer.ts
+│   │
+│   ├── compliance/           # Compliance engine
+│   │   ├── index.ts
+│   │   ├── engine.ts
+│   │   ├── proof.ts
+│   │   └── policies/
+│   │
+│   ├── arbitration/          # Arbitration
+│   │   ├── index.ts
+│   │   ├── case-manager.ts
+│   │   └── resolution.ts
+│   │
+│   ├── anchoring/            # Blockchain
+│   │   ├── index.ts
+│   │   ├── merkle.ts
+│   │   ├── solana.ts
+│   │   └── ethereum.ts
+│   │
+│   ├── tools/                # MCP tools
+│   │   └── index.ts
+│   │
+│   └── storage/              # Persistence
+│       ├── index.ts
+│       └── memory.ts
+│
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+## License
+
+MIT - Free to use, modify, distribute. Forever.
+
+Blockchain anchoring uses deployed contracts with protocol fees that fund development.

package/README.md

@@ -0,0 +1,50 @@
+# Dōmere - The Judge Protocol
+
+**Thread Identity, Intent Verification & Blockchain Anchoring for AI Agents**
+
+Part of the [Weave Security Suite](../README.md) (Mund + Hord + Dōmere)
+
+## The Problem
+
+When AI agents chain together—Agent A calls Agent B calls Agent C—how do you know the final action matches the human's original intent? Protocols like MCP and A2A standardize how agents **communicate**. Dōmere ensures they **execute honestly**.
+
+## Core Concepts
+
+### Thread Identity
+Track intent from origin through every hop with cryptographic signatures.
+
+### Intent Drift Detection  
+Detect when agents reinterpret, expand, or violate the original intent.
+
+### Blockchain Anchoring
+Immutable proof on Solana (~$0.001) or Ethereum (~$2-10).
+
+## Quick Start
+
+```typescript
+// Create thread
+const thread = await domere.createThread({
+  origin: { type: 'human', identity: 'user_jane' },
+  intent: 'Get Q3 sales summary',
+  constraints: ['read-only']
+});
+
+// Add hop
+const hop = await domere.addHop({
+  thread_id: thread.id,
+  agent: { id: 'data_agent', type: 'claude' },
+  received_intent: 'Query Q3 sales data',
+  actions: [{ type: 'query', target: 'sales_db' }]
+});
+
+// Check: hop.intent_drift.verdict === 'aligned'
+```
+
+## Business Model
+
+**Free:** All analysis, threading, drift detection, MCP tools  
+**Paid:** Blockchain anchoring only (you bring your wallet)
+
+## License
+
+MIT

package/dist/anchoring/ethereum.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Dōmere - The Judge Protocol
+ * Ethereum Anchoring Client
+ *
+ * Note: This is the client interface. The actual Ethereum contract
+ * should be deployed separately.
+ */
+import type { AnchorRequest, AnchorResult, AnchorVerification } from '../types.js';
+export interface EthereumConfig {
+    rpc_url: string;
+    contract_address: string;
+    chain_id?: number;
+}
+export interface EthereumAnchorData {
+    threadId: string;
+    merkleRoot: string;
+    hopCount: number;
+    intentHash: string;
+    compliant: boolean;
+}
+export declare class EthereumAnchorClient {
+    private config;
+    private isTestnet;
+    constructor(config?: Partial<EthereumConfig>);
+    /**
+     * Prepare anchor data for Ethereum
+     */
+    prepareAnchorData(request: AnchorRequest): EthereumAnchorData;
+    /**
+     * Estimate gas cost
+     */
+    estimateGas(): Promise<{
+        gas_limit: number;
+        gas_price_gwei: number;
+        estimated_eth: string;
+        protocol_fee_eth: string;
+        total_eth: string;
+        usd_estimate?: string;
+    }>;
+    /**
+     * Create anchor transaction
+     *
+     * Returns unsigned transaction data for client-side signing.
+     */
+    createAnchorTransaction(request: AnchorRequest): Promise<{
+        to: string;
+        data: string;
+        value: string;
+        gas_limit: number;
+        chain_id: number;
+        estimated_cost: any;
+    }>;
+    /**
+     * Submit signed transaction
+     */
+    submitSignedTransaction(signedTransaction: string): Promise<AnchorResult>;
+    /**
+     * Verify anchor on-chain
+     */
+    verifyAnchor(threadId: string, expectedMerkleRoot: string): Promise<AnchorVerification>;
+    /**
+     * Create batch certification transaction
+     */
+    createCertificationTransaction(config: {
+        period_id: string;
+        merkle_root: string;
+        attestation_count: number;
+        violation_count: number;
+        period_start: Date;
+        period_end: Date;
+    }): Promise<{
+        to: string;
+        data: string;
+        estimated_cost: any;
+    }>;
+    /**
+     * Get explorer URL
+     */
+    getExplorerUrl(txHash: string): string;
+    /**
+     * Get contract address
+     */
+    getContractAddress(): string;
+    /**
+     * Convert string to bytes32 hex
+     */
+    private stringToBytes32;
+    /**
+     * Ensure value is bytes32 format
+     */
+    private ensureBytes32;
+    /**
+     * Encode bytes32 for ABI
+     */
+    private encodeBytes32;
+    /**
+     * Encode uint256 for ABI
+     */
+    private encodeUint256;
+    /**
+     * Encode bool for ABI
+     */
+    private encodeBool;
+    /**
+     * Simple keccak256 (placeholder - use ethers.js in production)
+     */
+    private keccak256;
+}
+export declare const ETHEREUM_CONTRACT_ABI: ({
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    outputs?: undefined;
+    stateMutability?: undefined;
+})[];
+export declare const ETHEREUM_CONTRACT_SOURCE = "\n// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\n/**\n * @title DomereProtocol\n * @dev Thread anchoring and compliance certification for AI agent security\n */\ncontract DomereProtocol {\n    \n    // Protocol fee (5% of gas, calculated off-chain and sent as msg.value)\n    uint256 public protocolFeeBps = 500;\n    address public treasury;\n    address public owner;\n    \n    struct ThreadAnchor {\n        bytes32 merkleRoot;\n        uint256 hopCount;\n        bytes32 intentHash;\n        bool compliant;\n        uint256 timestamp;\n        address anchorer;\n    }\n    \n    struct CompliancePeriod {\n        bytes32 merkleRoot;\n        uint256 attestationCount;\n        uint256 violationCount;\n        uint256 periodStart;\n        uint256 periodEnd;\n        uint256 timestamp;\n        bool certified;\n    }\n    \n    mapping(bytes32 => ThreadAnchor) public anchors;\n    mapping(bytes32 => CompliancePeriod) public periods;\n    mapping(address => bool) public authorizedAnchors;\n    \n    event ThreadAnchored(\n        bytes32 indexed threadId,\n        bytes32 merkleRoot,\n        address anchorer,\n        uint256 timestamp\n    );\n    \n    event PeriodCertified(\n        bytes32 indexed periodId,\n        bytes32 merkleRoot,\n        uint256 attestationCount,\n        uint256 timestamp\n    );\n    \n    modifier onlyOwner() {\n        require(msg.sender == owner, \"Not owner\");\n        _;\n    }\n    \n    constructor(address _treasury) {\n        owner = msg.sender;\n        treasury = _treasury;\n        authorizedAnchors[msg.sender] = true;\n    }\n    \n    /**\n     * @dev Anchor a thread to the blockchain\n     */\n    function anchorThread(\n        bytes32 threadId,\n        bytes32 merkleRoot,\n        uint256 hopCount,\n        bytes32 intentHash,\n        bool compliant\n    ) external payable {\n        require(anchors[threadId].timestamp == 0, \"Thread already anchored\");\n        \n        // Store anchor\n        anchors[threadId] = ThreadAnchor({\n            merkleRoot: merkleRoot,\n            hopCount: hopCount,\n            intentHash: intentHash,\n            compliant: compliant,\n            timestamp: block.timestamp,\n            anchorer: msg.sender\n        });\n        \n        // Transfer protocol fee to treasury\n        if (msg.value > 0) {\n            payable(treasury).transfer(msg.value);\n        }\n        \n        emit ThreadAnchored(threadId, merkleRoot, msg.sender, block.timestamp);\n    }\n    \n    /**\n     * @dev Certify a compliance period\n     */\n    function certifyPeriod(\n        bytes32 periodId,\n        bytes32 merkleRoot,\n        uint256 attestationCount,\n        uint256 violationCount,\n        uint256 periodStart,\n        uint256 periodEnd\n    ) external payable {\n        require(authorizedAnchors[msg.sender], \"Not authorized\");\n        \n        periods[periodId] = CompliancePeriod({\n            merkleRoot: merkleRoot,\n            attestationCount: attestationCount,\n            violationCount: violationCount,\n            periodStart: periodStart,\n            periodEnd: periodEnd,\n            timestamp: block.timestamp,\n            certified: true\n        });\n        \n        if (msg.value > 0) {\n            payable(treasury).transfer(msg.value);\n        }\n        \n        emit PeriodCertified(periodId, merkleRoot, attestationCount, block.timestamp);\n    }\n    \n    /**\n     * @dev Verify a thread anchor\n     */\n    function verifyAnchor(\n        bytes32 threadId,\n        bytes32 expectedMerkleRoot\n    ) external view returns (bool valid, uint256 timestamp) {\n        ThreadAnchor memory anchor = anchors[threadId];\n        return (\n            anchor.merkleRoot == expectedMerkleRoot && anchor.timestamp > 0,\n            anchor.timestamp\n        );\n    }\n    \n    /**\n     * @dev Verify an attestation using Merkle proof\n     */\n    function verifyAttestation(\n        bytes32 threadId,\n        bytes32 attestationHash,\n        bytes32[] calldata merkleProof\n    ) external view returns (bool) {\n        ThreadAnchor memory anchor = anchors[threadId];\n        require(anchor.timestamp > 0, \"Thread not anchored\");\n        \n        bytes32 computedHash = attestationHash;\n        for (uint256 i = 0; i < merkleProof.length; i++) {\n            bytes32 proofElement = merkleProof[i];\n            if (computedHash <= proofElement) {\n                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\n            } else {\n                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\n            }\n        }\n        \n        return computedHash == anchor.merkleRoot;\n    }\n    \n    /**\n     * @dev Authorize an address to certify periods\n     */\n    function authorizeAnchor(address addr) external onlyOwner {\n        authorizedAnchors[addr] = true;\n    }\n    \n    /**\n     * @dev Revoke authorization\n     */\n    function revokeAuthorization(address addr) external onlyOwner {\n        authorizedAnchors[addr] = false;\n    }\n    \n    /**\n     * @dev Update treasury address\n     */\n    function setTreasury(address _treasury) external onlyOwner {\n        treasury = _treasury;\n    }\n}\n";
+//# sourceMappingURL=ethereum.d.ts.map

package/dist/anchoring/ethereum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ethereum.d.ts","sourceRoot":"","sources":["../../src/anchoring/ethereum.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,kBAAkB,EAEnB,MAAM,aAAa,CAAC;AAQrB,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB;AAMD,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,SAAS,CAAU;gBAEf,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC;IAW5C;;OAEG;IACH,iBAAiB,CAAC,OAAO,EAAE,aAAa,GAAG,kBAAkB;IAU7D;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC;QAC3B,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,MAAM,CAAC;QACvB,aAAa,EAAE,MAAM,CAAC;QACtB,gBAAgB,EAAE,MAAM,CAAC;QACzB,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;IAyBF;;;;OAIG;IACG,uBAAuB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC;QAC7D,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,cAAc,EAAE,GAAG,CAAC;KACrB,CAAC;IAwBF;;OAEG;IACG,uBAAuB,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IA4B/E;;OAEG;IACG,YAAY,CAChB,QAAQ,EAAE,MAAM,EAChB,kBAAkB,EAAE,MAAM,GACzB,OAAO,CAAC,kBAAkB,CAAC;IAmB9B;;OAEG;IACG,8BAA8B,CAAC,MAAM,EAAE;QAC3C,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,eAAe,EAAE,MAAM,CAAC;QACxB,YAAY,EAAE,IAAI,CAAC;QACnB,UAAU,EAAE,IAAI,CAAC;KAClB,GAAG,OAAO,CAAC;QACV,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,cAAc,EAAE,GAAG,CAAC;KACrB,CAAC;IAqBF;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAOtC;;OAEG;IACH,kBAAkB,IAAI,MAAM;IAQ5B;;OAEG;IACH,OAAO,CAAC,eAAe;IAMvB;;OAEG;IACH,OAAO,CAAC,aAAa;IAMrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAKrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAIrB;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACH,OAAO,CAAC,SAAS;CAMlB;AAMD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;IA0EjC,CAAC;AAMF,eAAO,MAAM,wBAAwB,upKAsLpC,CAAC"}