mandateclaw 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8cfb305a7b88ab0dfda330d81c15d38efaa5c85a86f98aef71b45b894a268edb
+  data.tar.gz: 798ea557d19afbb122a3b32b57a0e9aa99481f486a84f08c5e7adbb3433c1566
+SHA512:
+  metadata.gz: 0aa4cf6c878a5d379cbb07da2464939b69261978275d75b7f093be6cb1593a447e7a75ca1e76830029561e42abdde70dbe4dc654c4bf62ca7379687d6b59b079
+  data.tar.gz: 5622779131e0c3372d7e8332cbddeca676e8977f6a956cc480259d66c89dce578a37d7e80db707cb4903a0f5a0417da127be5b84a8afdf800ab9318dcba89f6e

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to MandateClaw-DSL are documented here.
+Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [0.0.1] - 2026-05-21
+
+### Added
+- `MandateClaw::DSL::Contract` — base class for contract definitions
+- `party` DSL: declare human, organisation, and autonomous agent parties
+- `obligation` DSL: positive duties with temporal constraints and breach consequences
+- `permission` DSL: rights a party may exercise
+- `prohibition` DSL: explicit denials; attempts are breach events
+- `agent_bounds` DSL: capability envelope for autonomous agent parties (`may`, `must_not`, `must_log_to`)
+- `attestation` DSL: signing requirements (Ed25519, HMAC-SHA256)
+- `rule` DSL: named decision rules with ternary truth (true / false / `:unknown`)
+- `MandateClaw::Validators::ContractValidator` — validates contract structure at definition time
+- `MandateClaw::Renderers::MarkdownRenderer` — renders contract as human-readable Markdown
+- `MandateClaw.define` convenience method for inline contract definition

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abhishek Parolkar
+
+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.

data/README.md

@@ -0,0 +1,262 @@
+# MandateClaw-DSL
+
+> **The Employment Contract Between You and Your Agent.**
+
+MandateClaw-DSL is a Ruby gem for defining programmatic, human-readable contracts that govern what an AI agent is — and is not — allowed to do on behalf of a human or organisation.
+
+It gives your agent a signed scope. Not a system prompt. A contract.
+
+[![Gem Version](https://badge.fury.io/rb/mandateclaw-dsl.svg)](https://rubygems.org/gems/mandateclaw-dsl)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+---
+
+## The Problem
+
+Every serious deployment of an AI agent in a consequential workflow — financial, legal, medical, regulatory — hits the same wall:
+
+- **System prompts are unenforceable.** The model may ignore them.
+- **Tool allowlists are opaque.** They are deployer-side, invisible to counterparties and regulators.
+- **Audit logs are held by the deployer.** Exactly the wrong party.
+- **Smart contracts are unreadable** to the lawyers and compliance officers who need to sign off.
+
+What is missing is a layer that is:
+- Signed **before** work begins
+- Deterministic in what it permits
+- Readable by humans
+- Enforceable at runtime
+- Auditable by regulators
+
+That is MandateClaw.
+
+---
+
+## Installation
+
+```ruby
+# Gemfile
+gem "mandateclaw-dsl"
+```
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install mandateclaw-dsl
+```
+
+---
+
+## Quick Start
+
+```ruby
+require "mandate_claw"
+
+class InvoiceContract < MandateClaw::DSL::Contract
+  contract :invoice do
+    # ── Parties ──────────────────────────────────────────────────────────
+    party :buyer,    identifies_by: :customer_id
+    party :seller,   identifies_by: :merchant_id
+    party :ai_agent, identifies_by: :agent_did, kind: :autonomous
+
+    # ── Obligations: what a party MUST do ────────────────────────────────
+    obligation :pay_invoice,
+               on:     :buyer,
+               within: 30.days,
+               breach: :late_payment_penalty
+
+    # ── Permissions: what a party MAY do ─────────────────────────────────
+    permission :dispute,
+               on:    :buyer,
+               within: 7.days,
+               event: :raise_dispute
+
+    # ── Prohibitions: what a party MUST NOT do ───────────────────────────
+    prohibition :unilateral_amend,
+                on:     :ai_agent,
+                breach: :void_transition
+
+    # ── Agent capability envelope ─────────────────────────────────────────
+    agent_bounds :ai_agent do
+      may       :issue_invoice, :send_reminder
+      must_not  :modify_amount, :waive_penalty
+      must_log_to :contract_registry
+    end
+
+    # ── Decision rules (ternary: true / false / :unknown) ─────────────────
+    rule :payment_overdue do
+      decide :overdue,
+             when:         ->(ctx) { ctx.days_since_issued > 30 },
+             unknown_when: ->(ctx) { ctx.issued_at.nil? }
+    end
+
+    # ── Attestation: who must sign before the contract is in force ────────
+    attestation do
+      require_signature_from :buyer, :seller, :ai_agent
+      sign_with :ed25519
+    end
+  end
+end
+```
+
+### Validate the contract definition
+
+```ruby
+InvoiceContract.validate!
+# => true (raises MandateClaw::ValidationError if malformed)
+```
+
+### Render as human-readable Markdown
+
+```ruby
+puts InvoiceContract.to_markdown
+```
+
+Output:
+
+```markdown
+# Contract: Invoice
+
+> Generated by MandateClaw-DSL v0.0.1
+
+## Parties
+
+| Name     | Kind         | Identified By |
+|----------|--------------|---------------|
+| buyer    | Human        | customer_id   |
+| seller   | Human        | merchant_id   |
+| ai_agent | Autonomous   | agent_did     |
+
+## Obligations
+
+- **Buyer** MUST `pay_invoice` within **30 days**. Breach: `late_payment_penalty`.
+
+## Permissions
+
+- **Buyer** MAY `dispute` within **7 days**.
+
+## Prohibitions
+
+- **Ai_agent** MUST NOT `unilateral_amend`. Breach: `void_transition`.
+
+## Agent Capability Bounds
+
+### Agent: `ai_agent`
+
+- **May do:** `issue_invoice`, `send_reminder`
+- **Must not do:** `modify_amount`, `waive_penalty`
+- **Must log to:** `contract_registry`
+
+## Attestation
+
+This contract comes into force only when all required parties have signed.
+
+**Required signatories:**
+- `buyer`
+- `seller`
+- `ai_agent`
+
+**Signing algorithm:** `ed25519`
+```
+
+---
+
+## Core Concepts
+
+### Parties
+
+```ruby
+party :buyer,    identifies_by: :customer_id                   # human (default)
+party :seller,   identifies_by: :merchant_id, kind: :organisation
+party :ai_agent, identifies_by: :agent_did,   kind: :autonomous
+```
+
+Party kinds: `:human`, `:organisation`, `:autonomous`.
+
+### Obligations, Permissions, Prohibitions
+
+The three deontic modalities of contract law:
+
+| DSL method    | Meaning              | Breach on failure? |
+|---------------|----------------------|--------------------|
+| `obligation`  | Party MUST do this   | Yes                |
+| `permission`  | Party MAY do this    | No                 |
+| `prohibition` | Party MUST NOT do this | Yes (on attempt) |
+
+### Agent Bounds
+
+The `agent_bounds` block is the contract clause that directly constrains an autonomous agent. The agent is given a capability envelope it cannot exceed:
+
+```ruby
+agent_bounds :ai_agent do
+  may       :read_invoice, :send_reminder   # explicit allowlist
+  must_not  :delete_invoice, :modify_amount # explicit denylist
+  must_log_to :contract_registry            # mandatory audit targets
+end
+```
+
+### Decision Rules (Ternary Truth)
+
+Borrowed from [SMU's L4 language](https://l4-documentation.readthedocs.io/): a rule evaluates to `true`, `false`, or `:unknown` — never silently collapses an unknown value to false:
+
+```ruby
+rule :payment_overdue do
+  decide :overdue,
+         when:         ->(ctx) { ctx.days_since_issued > 30 },
+         unknown_when: ->(ctx) { ctx.issued_at.nil? }
+end
+
+result = InvoiceContract._rules.first.evaluate(my_context)
+# => true | false | :unknown
+```
+
+### Inline Definition
+
+```ruby
+PaymentContract = MandateClaw.define(:payment) do
+  party :payer, identifies_by: :user_id
+  party :payee, identifies_by: :merchant_id
+
+  obligation :transfer_funds, on: :payer, within: 1.day, breach: :payment_failed
+end
+```
+
+---
+
+## Architecture
+
+MandateClaw is intentionally split into focused components:
+
+| Gem | Role | License |
+|-----|------|---------|
+| **mandateclaw-dsl** (this gem) | Contract definition DSL + Markdown renderer | MIT |
+| [mandateclaw-registry](https://github.com/parolkar/MandateClaw-Registry) | Signing, storage, audit ledger | FSL-1.1-Apache-2.0 |
+| [MandateClaw Cloud](https://mandateclaw.com) | Hosted registry, regulator webhooks, compliance dashboards | Commercial |
+
+The DSL has no runtime enforcement — that is the registry's job. The DSL's output is a validated, human-readable contract definition that the registry stores, signs, and monitors.
+
+---
+
+## Roadmap
+
+- [x] `0.0.1` — Core DSL: parties, obligations, permissions, prohibitions, agent bounds, attestation, decision rules, Markdown renderer
+- [ ] `0.1.0` — `fosm-rails` integration: lifecycle events validated against contract definitions
+- [ ] `0.2.0` — JSON Schema renderer for machine-readable contract exchange
+- [ ] `0.3.0` — Contract diffing: show what changed between two versions of a contract
+
+---
+
+## Contributing
+
+Bug reports and pull requests are welcome at [github.com/parolkar/MandateClaw-DSL](https://github.com/parolkar/MandateClaw-DSL).
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) before opening a PR. All contributions are expected to have specs.
+
+---
+
+## License
+
+[MIT](LICENSE) — Copyright (c) 2026 Abhishek Parolkar

data/lib/mandate_claw/dsl/agent_bounds.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module MandateClaw
+  module DSL
+    # Defines the capability envelope for an autonomous agent party.
+    # The agent is constrained to only the actions listed under +may+
+    # and is explicitly barred from those under +must_not+.
+    #
+    #   agent_bounds :ai_agent do
+    #     may       :issue_invoice, :send_reminder
+    #     must_not  :modify_amount, :waive_penalty
+    #     must_log_to :contract_registry
+    #   end
+    #
+    class AgentBounds
+      attr_reader :party, :permitted_actions, :prohibited_actions, :log_targets
+
+      def initialize(party)
+        @party             = party
+        @permitted_actions = []
+        @prohibited_actions = []
+        @log_targets       = []
+      end
+
+      def may(*actions)
+        @permitted_actions.concat(actions.flatten)
+      end
+
+      def must_not(*actions)
+        @prohibited_actions.concat(actions.flatten)
+      end
+
+      def must_log_to(*targets)
+        @log_targets.concat(targets.flatten)
+      end
+    end
+  end
+end

data/lib/mandate_claw/dsl/attestation.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module MandateClaw
+  module DSL
+    # Defines signing requirements for the contract.
+    # A contract is not in force until all required parties have signed.
+    #
+    #   attestation do
+    #     require_signature_from :buyer, :seller, :ai_agent
+    #     sign_with :ed25519
+    #   end
+    #
+    class Attestation
+      SUPPORTED_ALGORITHMS = %i[ed25519 hmac_sha256].freeze
+
+      attr_reader :required_signatories, :algorithm
+
+      def initialize
+        @required_signatories = []
+        @algorithm = :ed25519
+      end
+
+      def require_signature_from(*parties)
+        @required_signatories.concat(parties.flatten)
+      end
+
+      def sign_with(algorithm)
+        unless SUPPORTED_ALGORITHMS.include?(algorithm)
+          raise ArgumentError, "Unsupported signing algorithm: #{algorithm}. " \
+                               "Supported: #{SUPPORTED_ALGORITHMS.join(', ')}"
+        end
+        @algorithm = algorithm
+      end
+    end
+  end
+end

data/lib/mandate_claw/dsl/contract.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module MandateClaw
+  module DSL
+    # Base class for all MandateClaw contracts.
+    #
+    # Usage:
+    #
+    #   class InvoiceContract < MandateClaw::DSL::Contract
+    #     contract do
+    #       party :buyer,    identifies_by: :customer_id
+    #       party :seller,   identifies_by: :merchant_id
+    #       party :ai_agent, identifies_by: :agent_did, kind: :autonomous
+    #
+    #       obligation :pay_invoice, on: :buyer, within: 30.days, breach: :late_payment_penalty
+    #       permission :dispute,     on: :buyer, within: 7.days,  event: :raise_dispute
+    #       prohibition :unilateral_amend, on: :ai_agent, breach: :void_transition
+    #
+    #       agent_bounds :ai_agent do
+    #         may        :issue_invoice, :send_reminder
+    #         must_not   :modify_amount, :waive_penalty
+    #         must_log_to :contract_registry
+    #       end
+    #
+    #       attestation do
+    #         require_signature_from :buyer, :seller, :ai_agent
+    #         sign_with :ed25519
+    #       end
+    #     end
+    #   end
+    #
+    class Contract
+      class << self
+        attr_reader :_parties, :_obligations, :_permissions,
+                    :_prohibitions, :_agent_bounds, :_attestation,
+                    :_rules, :_contract_name
+
+        def contract(name = nil, &block)
+          @_contract_name  = name || self.name&.underscore&.to_sym || :unnamed
+          @_parties        = {}
+          @_obligations    = []
+          @_permissions    = []
+          @_prohibitions   = []
+          @_agent_bounds   = {}
+          @_attestation    = nil
+          @_rules          = []
+
+          DSL::ContractBuilder.new(self).instance_eval(&block) if block_given?
+          self
+        end
+
+        def validate!
+          MandateClaw::Validators::ContractValidator.new(self).validate!
+        end
+
+        def to_markdown
+          MandateClaw::Renderers::MarkdownRenderer.new(self).render
+        end
+
+        def autonomous_parties
+          _parties.select { |_, p| p.kind == :autonomous }.keys
+        end
+      end
+    end
+
+    # Internal builder — keeps the Contract class clean
+    class ContractBuilder
+      def initialize(target)
+        @target = target
+      end
+
+      def party(name, identifies_by:, kind: :human)
+        @target._parties[name] = DSL::Party.new(name, identifies_by: identifies_by, kind: kind)
+      end
+
+      def obligation(name, on:, within: nil, breach: nil)
+        @target._obligations << DSL::Obligation.new(name, on: on, within: within, breach: breach)
+      end
+
+      def permission(name, on:, within: nil, event: nil)
+        @target._permissions << DSL::Permission.new(name, on: on, within: within, event: event)
+      end
+
+      def prohibition(name, on:, breach: nil)
+        @target._prohibitions << DSL::Prohibition.new(name, on: on, breach: breach)
+      end
+
+      def agent_bounds(party_name, &block)
+        bounds = DSL::AgentBounds.new(party_name)
+        bounds.instance_eval(&block) if block_given?
+        @target._agent_bounds[party_name] = bounds
+      end
+
+      def rule(name, &block)
+        dr = DSL::DecisionRule.new(name)
+        dr.instance_eval(&block) if block_given?
+        @target._rules << dr
+      end
+
+      def attestation(&block)
+        att = DSL::Attestation.new
+        att.instance_eval(&block) if block_given?
+        @target._attestation = att
+      end
+    end
+  end
+end

data/lib/mandate_claw/dsl/decision_rule.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module MandateClaw
+  module DSL
+    # A named decision rule with ternary truth: true / false / :unknown.
+    # Borrowed from L4's model: an unknown value propagates uncertainty
+    # rather than defaulting to false.
+    #
+    #   rule :payment_due_today do
+    #     decide :due, when: ->(ctx) { ctx.issued_at + ctx.net_terms <= Date.today }
+    #     unknown_when: ->(ctx) { ctx.issued_at.nil? }
+    #   end
+    #
+    class DecisionRule
+      TRUTH_VALUES = [true, false, :unknown].freeze
+
+      attr_reader :name, :outcome, :condition, :unknown_condition
+
+      def initialize(name)
+        @name = name
+      end
+
+      def decide(outcome, when: nil, unknown_when: nil)
+        @outcome           = outcome
+        @condition         = binding.local_variable_get(:when)
+        @unknown_condition = unknown_when
+      end
+
+      # Evaluate against a context object.
+      # Returns true, false, or :unknown — never nil.
+      def evaluate(context)
+        return :unknown if @unknown_condition&.call(context)
+        return @condition.call(context) if @condition
+
+        :unknown
+      end
+    end
+  end
+end

data/lib/mandate_claw/dsl/obligation.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module MandateClaw
+  module DSL
+    # A positive duty: the named party MUST perform this action.
+    # Failure to perform within +within+ triggers the +breach+ consequence.
+    #
+    #   obligation :pay_invoice, on: :buyer, within: 30.days, breach: :late_payment_penalty
+    #
+    Obligation = Struct.new(:name, :on, :within, :breach, keyword_init: true)
+  end
+end

data/lib/mandate_claw/dsl/party.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MandateClaw
+  module DSL
+    Party = Struct.new(:name, :identifies_by, :kind, keyword_init: true) do
+      KINDS = %i[human organisation autonomous].freeze
+
+      def autonomous?
+        kind == :autonomous
+      end
+
+      def valid?
+        KINDS.include?(kind) && name.is_a?(Symbol) && identifies_by.is_a?(Symbol)
+      end
+    end
+  end
+end

data/lib/mandate_claw/dsl/permission.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module MandateClaw
+  module DSL
+    # A right: the named party MAY perform this action.
+    # Not performing is not a breach.
+    #
+    #   permission :dispute, on: :buyer, within: 7.days, event: :raise_dispute
+    #
+    Permission = Struct.new(:name, :on, :within, :event, keyword_init: true)
+  end
+end

data/lib/mandate_claw/dsl/prohibition.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module MandateClaw
+  module DSL
+    # An explicit denial: the named party MUST NOT perform this action.
+    # The attempt itself is a breach event, even if the action is blocked.
+    #
+    #   prohibition :unilateral_amend, on: :ai_agent, breach: :void_transition
+    #
+    Prohibition = Struct.new(:name, :on, :breach, keyword_init: true)
+  end
+end

data/lib/mandate_claw/dsl/temporal.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MandateClaw
+  module DSL
+    # Represents a temporal constraint on an obligation or permission.
+    # Anchored to a named event or an absolute duration.
+    #
+    # Used internally; surface API is:
+    #   obligation :pay, on: :buyer, within: 30.days
+    #
+    TemporalConstraint = Struct.new(:duration, :anchor, keyword_init: true) do
+      def deadline_from(base_time)
+        base_time + duration
+      end
+
+      def breached?(base_time, now = Time.current)
+        now > deadline_from(base_time)
+      end
+    end
+  end
+end

data/lib/mandate_claw/renderers/markdown_renderer.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module MandateClaw
+  module Renderers
+    # Renders a contract class as a human-readable Markdown document.
+    # This is the "bidirectional transpilation" — the same DSL that
+    # the Ruby runtime enforces can be read by lawyers and regulators.
+    class MarkdownRenderer
+      def initialize(contract_class)
+        @c = contract_class
+      end
+
+      def render
+        sections = []
+        sections << header
+        sections << parties_section
+        sections << obligations_section   if @c._obligations.any?
+        sections << permissions_section   if @c._permissions.any?
+        sections << prohibitions_section  if @c._prohibitions.any?
+        sections << agent_bounds_section  if @c._agent_bounds.any?
+        sections << rules_section         if @c._rules.any?
+        sections << attestation_section   if @c._attestation
+        sections << footer
+        sections.compact.join("\n\n")
+      end
+
+      private
+
+      def header
+        <<~MD
+          # Contract: #{contract_title}
+
+          > Generated by [MandateClaw-DSL](https://mandateclaw.com) v#{MandateClaw::VERSION}
+          > This document is the human-readable rendering of a programmatic contract.
+          > The Ruby definition is the authoritative source of enforcement.
+        MD
+      end
+
+      def contract_title
+        @c._contract_name.to_s.humanize.titleize
+      rescue StandardError
+        @c._contract_name.to_s
+      end
+
+      def parties_section
+        rows = @c._parties.map do |name, party|
+          "| `#{name}` | #{party.kind.to_s.capitalize} | `#{party.identifies_by}` |"
+        end
+
+        <<~MD
+          ## Parties
+
+          | Name | Kind | Identified By |
+          |------|------|---------------|
+          #{rows.join("\n")}
+        MD
+      end
+
+      def obligations_section
+        items = @c._obligations.map do |ob|
+          deadline = ob.within ? " within **#{humanize_duration(ob.within)}**" : ""
+          breach   = ob.breach ? " Breach: `#{ob.breach}`." : ""
+          "- **#{ob.on.to_s.capitalize}** MUST `#{ob.name}`#{deadline}.#{breach}"
+        end
+
+        "## Obligations\n\n#{items.join("\n")}"
+      end
+
+      def permissions_section
+        items = @c._permissions.map do |pr|
+          deadline = pr.within ? " within **#{humanize_duration(pr.within)}**" : ""
+          "- **#{pr.on.to_s.capitalize}** MAY `#{pr.name}`#{deadline}."
+        end
+
+        "## Permissions\n\n#{items.join("\n")}"
+      end
+
+      def prohibitions_section
+        items = @c._prohibitions.map do |pr|
+          breach = pr.breach ? " Breach: `#{pr.breach}`." : ""
+          "- **#{pr.on.to_s.capitalize}** MUST NOT `#{pr.name}`.#{breach}"
+        end
+
+        "## Prohibitions\n\n#{items.join("\n")}"
+      end
+
+      def agent_bounds_section
+        sections = @c._agent_bounds.map do |name, bounds|
+          permitted  = bounds.permitted_actions.map { |a| "`#{a}`" }.join(", ")
+          prohibited = bounds.prohibited_actions.map { |a| "`#{a}`" }.join(", ")
+          log_targets = bounds.log_targets.map { |t| "`#{t}`" }.join(", ")
+
+          <<~MD
+            ### Agent: `#{name}`
+
+            - **May do:** #{permitted.empty? ? "_none specified_" : permitted}
+            - **Must not do:** #{prohibited.empty? ? "_none specified_" : prohibited}
+            - **Must log to:** #{log_targets.empty? ? "_none specified_" : log_targets}
+          MD
+        end
+
+        "## Agent Capability Bounds\n\n#{sections.join("\n")}"
+      end
+
+      def rules_section
+        items = @c._rules.map do |rule|
+          "- **#{rule.name}**: evaluates to `true`, `false`, or `:unknown` (ternary)"
+        end
+
+        "## Decision Rules\n\n#{items.join("\n")}"
+      end
+
+      def attestation_section
+        att  = @c._attestation
+        sigs = att.required_signatories.map { |s| "- `#{s}`" }.join("\n")
+
+        <<~MD
+          ## Attestation
+
+          This contract comes into force only when all required parties have signed.
+
+          **Required signatories:**
+          #{sigs}
+
+          **Signing algorithm:** `#{att.algorithm}`
+        MD
+      end
+
+      def footer
+        "---\n_MandateClaw — mandateclaw.com_"
+      end
+
+      def humanize_duration(duration)
+        return duration.inspect unless duration.respond_to?(:to_i)
+
+        seconds = duration.to_i
+        if seconds >= 86_400
+          "#{seconds / 86_400} days"
+        elsif seconds >= 3_600
+          "#{seconds / 3_600} hours"
+        else
+          "#{seconds} seconds"
+        end
+      end
+    end
+  end
+end

data/lib/mandate_claw/validators/contract_validator.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module MandateClaw
+  module Validators
+    class ContractValidator
+      def initialize(contract_class)
+        @contract = contract_class
+        @errors   = []
+      end
+
+      def validate!
+        validate_parties
+        validate_obligations
+        validate_prohibitions
+        validate_agent_bounds
+        validate_attestation
+
+        raise MandateClaw::ValidationError, @errors.join("; ") if @errors.any?
+
+        true
+      end
+
+      private
+
+      def validate_parties
+        if @contract._parties.empty?
+          @errors << "Contract must define at least one party"
+          return
+        end
+
+        @contract._parties.each do |name, party|
+          @errors << "Party #{name} has invalid kind: #{party.kind}" unless party.valid?
+        end
+      end
+
+      def validate_obligations
+        @contract._obligations.each do |ob|
+          unless @contract._parties.key?(ob.on)
+            @errors << "Obligation #{ob.name}: unknown party #{ob.on}"
+          end
+        end
+      end
+
+      def validate_prohibitions
+        @contract._prohibitions.each do |pr|
+          unless @contract._parties.key?(pr.on)
+            @errors << "Prohibition #{pr.name}: unknown party #{pr.on}"
+          end
+        end
+      end
+
+      def validate_agent_bounds
+        @contract._agent_bounds.each do |party_name, bounds|
+          unless @contract._parties.key?(party_name)
+            @errors << "agent_bounds references unknown party: #{party_name}"
+          end
+
+          party = @contract._parties[party_name]
+          unless party&.autonomous?
+            @errors << "agent_bounds can only be applied to autonomous parties; " \
+                       "#{party_name} has kind: #{party&.kind}"
+          end
+
+          overlap = bounds.permitted_actions & bounds.prohibited_actions
+          if overlap.any?
+            @errors << "agent_bounds for #{party_name}: actions #{overlap.join(', ')} " \
+                       "appear in both may and must_not"
+          end
+        end
+      end
+
+      def validate_attestation
+        return unless @contract._attestation
+
+        @contract._attestation.required_signatories.each do |sig|
+          unless @contract._parties.key?(sig)
+            @errors << "Attestation requires signature from unknown party: #{sig}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mandate_claw/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MandateClaw
+  VERSION = "0.0.1"
+end

data/lib/mandate_claw.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext"
+
+require "mandate_claw/version"
+require "mandate_claw/dsl/contract"
+require "mandate_claw/dsl/party"
+require "mandate_claw/dsl/obligation"
+require "mandate_claw/dsl/permission"
+require "mandate_claw/dsl/prohibition"
+require "mandate_claw/dsl/agent_bounds"
+require "mandate_claw/dsl/attestation"
+require "mandate_claw/dsl/temporal"
+require "mandate_claw/dsl/decision_rule"
+require "mandate_claw/validators/contract_validator"
+require "mandate_claw/renderers/markdown_renderer"
+
+module MandateClaw
+  class Error < StandardError; end
+  class ValidationError < Error; end
+  class BreachError < Error; end
+
+  # Convenience: define a contract class inline
+  #
+  #   MandateClaw.define(:invoice_contract) do
+  #     party :buyer,  identifies_by: :customer_id
+  #     ...
+  #   end
+  #
+  def self.define(name, &block)
+    contract = Class.new(MandateClaw::DSL::Contract)
+    contract.contract(&block)
+    contract
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: mandateclaw
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Abhishek Parolkar
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-05-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.60'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.25'
+description: MandateClaw-DSL is a Ruby DSL for defining programmatic, signed, and
+  auditable contracts that govern what an AI agent is and isn't allowed to do on behalf
+  of a human or organisation.
+email:
+- abhishek@parolkar.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/mandate_claw.rb
+- lib/mandate_claw/dsl/agent_bounds.rb
+- lib/mandate_claw/dsl/attestation.rb
+- lib/mandate_claw/dsl/contract.rb
+- lib/mandate_claw/dsl/decision_rule.rb
+- lib/mandate_claw/dsl/obligation.rb
+- lib/mandate_claw/dsl/party.rb
+- lib/mandate_claw/dsl/permission.rb
+- lib/mandate_claw/dsl/prohibition.rb
+- lib/mandate_claw/dsl/temporal.rb
+- lib/mandate_claw/renderers/markdown_renderer.rb
+- lib/mandate_claw/validators/contract_validator.rb
+- lib/mandate_claw/version.rb
+homepage: https://mandateclaw.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://mandateclaw.com
+  source_code_uri: https://github.com/parolkar/MandateClaw-DSL
+  changelog_uri: https://github.com/parolkar/MandateClaw-DSL/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: The Employment Contract Between You and Your Agent
+test_files: []