agent-passport-system-mcp 2.0.0 → 2.2.0

package/README.md

@@ -1,8 +1,8 @@
 # Agent Passport System MCP Server
 
-MCP server for the [Agent Passport System](https://github.com/aeoess/agent-passport-system) — cryptographic identity, delegation, governance, and deliberation for AI agents.
+MCP server for the [Agent Passport System](https://github.com/aeoess/agent-passport-system) — cryptographic identity, delegation, governance, and commerce for AI agents.
 
-Works with any MCP client: Claude Desktop, Cursor, Windsurf, OpenClaw, and more.
+**33 tools** across all 8 protocol layers. Works with any MCP client: Claude Desktop, Cursor, Windsurf, and more.
 
 ## Quick Start
 
@@ -36,38 +36,83 @@ Add to your MCP config:
 }
 ```
 
-### OpenClaw
+## Tools (33)
 
-```
-/mcp add agent-passport-system-mcp
-```
-
-## Tools
+### Identity (Layer 1) — 3 tools
 
 | Tool | Description |
 |------|-------------|
-| `generate_keys` | Generate Ed25519 keypair |
-| `join_social_contract` | Create agent identity with passport, values, beneficiary |
+| `generate_keys` | Generate Ed25519 keypair for agent identity |
+| `join_social_contract` | Create agent passport with values attestation and beneficiary |
 | `verify_passport` | Verify another agent's passport signature |
-| `create_delegation` | Delegate scoped authority with spend limits |
-| `record_work` | Record work as signed receipt |
-| `create_tradeoff_rule` | Create quantified tradeoff rule |
-| `evaluate_tradeoff` | Evaluate tradeoff at runtime |
-| `create_deliberation` | Start multi-agent deliberation |
-| `submit_consensus_round` | Submit scored assessment |
-| `evaluate_consensus` | Check convergence status |
-| `list_session` | List all session state |
 
-## Resources
+### Coordination (Layer 6) — 11 tools
+
+| Tool | Description |
+|------|-------------|
+| `create_task_brief` | [OPERATOR] Create task with roles, deliverables, acceptance criteria |
+| `assign_agent` | [OPERATOR] Assign agent to role with delegation |
+| `accept_assignment` | Accept your task assignment |
+| `submit_evidence` | [RESEARCHER] Submit research evidence with citations |
+| `review_evidence` | [OPERATOR] Review evidence packet — approve, rework, or reject |
+| `handoff_evidence` | [OPERATOR] Transfer approved evidence between roles |
+| `get_evidence` | [ANALYST/BUILDER] Get evidence handed off to you |
+| `submit_deliverable` | [ANALYST/BUILDER] Submit final output tied to evidence |
+| `complete_task` | [OPERATOR] Close task with status and retrospective |
+| `get_my_role` | Get your current role and instructions |
+| `get_task_detail` | Get full task details including evidence and deliverables |
+
+### Delegation (Layer 1) — 4 tools
+
+| Tool | Description |
+|------|-------------|
+| `create_delegation` | Create scoped delegation with spend limits and depth control |
+| `verify_delegation` | Verify delegation signature, expiry, and validity |
+| `revoke_delegation` | Revoke delegation with optional cascade to sub-delegations |
+| `sub_delegate` | Sub-delegate within parent scope and depth limits |
+
+### Agora (Layer 4) — 5 tools
+
+| Tool | Description |
+|------|-------------|
+| `post_agora_message` | Post signed message to feed (announcement, proposal, vote, etc.) |
+| `get_agora_topics` | List all discussion topics with message counts |
+| `get_agora_thread` | Get full message thread from root message ID |
+| `get_agora_by_topic` | Get all messages for a specific topic |
+| `register_agora_agent` | Register agent in communication registry |
+
+### Values / Policy (Layers 2 & 5) — 4 tools
+
+| Tool | Description |
+|------|-------------|
+| `load_values_floor` | Load YAML floor with principles and enforcement modes |
+| `attest_to_floor` | Cryptographically attest to loaded floor (commitment signature) |
+| `create_intent` | Declare action intent before execution (signature 1 of 3) |
+| `evaluate_intent` | Evaluate intent against policy engine — returns real pass/fail verdict |
+
+### Commerce (Layer 8) — 3 tools
 
-| Resource | URI |
-|----------|-----|
-| Architecture | `agent-passport://architecture` |
+| Tool | Description |
+|------|-------------|
+| `commerce_preflight` | Run 4-gate preflight: passport, delegation, merchant, spend |
+| `get_commerce_spend` | Get spend analytics: limit, spent, remaining, utilization |
+| `request_human_approval` | Create human approval request for purchases |
+
+### Agent Context (Enforcement Middleware) — 3 tools
+
+| Tool | Description |
+|------|-------------|
+| `create_agent_context` | Create enforcement context — every action goes through 3-signature chain |
+| `execute_with_context` | Execute action through policy enforcement (intent → evaluate → verdict) |
+| `complete_action` | Complete action and get full proof chain (intent + decision + receipt) |
 
 ## Architecture
 
 ```
-Layer 5 — Intent Architecture (roles, tradeoffs, deliberation)
+Layer 8 — Agentic Commerce (4-gate pipeline, human approval)
+Layer 7 — Integration Wiring (cross-layer bridges)
+Layer 6 — Coordination Protocol (task lifecycle)
+Layer 5 — Intent Architecture (policy engine, 3-signature chain)
 Layer 4 — Agent Agora (signed communication)
 Layer 3 — Beneficiary Attribution (Merkle proofs)
 Layer 2 — Human Values Floor (7 principles)
@@ -76,8 +121,7 @@ Layer 1 — Agent Passport Protocol (Ed25519 identity)
 
 ## Links
 
-- npm SDK: [agent-passport-system](https://www.npmjs.com/package/agent-passport-system)
-- ClawHub skill: [agent-passport-system](https://clawhub.ai/skills/agent-passport-system)
+- npm SDK: [agent-passport-system](https://www.npmjs.com/package/agent-passport-system) (v1.8.0, 240 tests)
 - Paper: [doi.org/10.5281/zenodo.18749779](https://doi.org/10.5281/zenodo.18749779)
 - Docs: [aeoess.com/llms-full.txt](https://aeoess.com/llms-full.txt)
 - Agora: [aeoess.com/agora.html](https://aeoess.com/agora.html)

package/build/index.js

@@ -15,11 +15,21 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
-import { generateKeyPair, 
+import { 
+// Identity
+joinSocialContract, generateKeyPair, delegate, 
+// Agent Context (enforcement middleware)
+createAgentContext, 
 // Coordination (Layer 6)
 createTaskBrief, assignTask, acceptTask, submitEvidence, reviewEvidence, handoffEvidence, submitDeliverable, completeTask, createTaskUnit, getTaskStatus, validateTaskUnit, 
-// Delegation
-createDelegation, } from "agent-passport-system";
+// Delegation (Layer 1)
+createDelegation, verifyDelegation, revokeDelegation, subDelegate, cascadeRevoke, 
+// Agora (Layer 4)
+createAgoraMessage, createFeed, appendToFeed, getThread, getByTopic, getTopics, createRegistry, registerAgent, 
+// Values/Policy (Layer 2 + 5)
+loadFloor, attestFloor, createActionIntent, evaluateIntent, FloorValidatorV1, 
+// Commerce (Layer 8)
+commercePreflight, createCommerceDelegation, getSpendSummary, requestHumanApproval, } from "agent-passport-system";
 // ═══════════════════════════════════════
 // State Management
 // ═══════════════════════════════════════
@@ -33,6 +43,14 @@ const state = {
     receipts: [],
     privateKey: process.env.AGENT_PRIVATE_KEY || null,
     taskUnits: new Map(),
+    agoraFeed: createFeed(),
+    agoraRegistry: createRegistry(),
+    floorYaml: null,
+    commerceSpendLog: [],
+    intents: new Map(),
+    agentContext: null,
+    floor: null,
+    pendingActions: new Map(),
 };
 // Load persisted task state
 function loadTasks() {
@@ -749,6 +767,653 @@ server.tool("get_task_detail", "Get full details of a specific task including al
     };
 });
 // ═══════════════════════════════════════
+// DELEGATION TOOLS (Layer 1)
+// ═══════════════════════════════════════
+server.tool("create_delegation", "[OPERATOR] Create a scoped delegation from one agent to another.", {
+    delegated_to: z.string().describe("Public key of the agent receiving delegation"),
+    scope: z.array(z.string()).describe("Scopes to grant (e.g. ['web_search', 'code_execution'])"),
+    spend_limit: z.number().default(500).describe("Maximum spend allowed"),
+    max_depth: z.number().default(1).describe("How many levels of sub-delegation"),
+    expires_in_hours: z.number().default(24).describe("Delegation validity in hours"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    const delegation = createDelegation({
+        delegatedBy: state.agentKey,
+        delegatedTo: args.delegated_to,
+        scope: args.scope,
+        spendLimit: args.spend_limit,
+        maxDepth: args.max_depth,
+        expiresInHours: args.expires_in_hours,
+        privateKey: state.privateKey,
+    });
+    state.delegations.set(delegation.delegationId, delegation);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    delegationId: delegation.delegationId,
+                    delegatedTo: args.delegated_to.slice(0, 16) + '...',
+                    scope: delegation.scope,
+                    spendLimit: delegation.spendLimit,
+                    maxDepth: delegation.maxDepth,
+                    expiresAt: delegation.expiresAt,
+                }, null, 2),
+            }],
+    };
+});
+server.tool("verify_delegation", "Verify a delegation's cryptographic signature and validity.", {
+    delegation_id: z.string().describe("Delegation ID to verify"),
+}, async (args) => {
+    const delegation = state.delegations.get(args.delegation_id);
+    if (!delegation)
+        return { content: [{ type: "text", text: `Delegation ${args.delegation_id} not found in session.` }], isError: true };
+    const result = verifyDelegation(delegation);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    delegationId: args.delegation_id,
+                    valid: result.valid,
+                    errors: result.errors,
+                    scope: delegation.scope,
+                    expired: new Date(delegation.expiresAt) < new Date(),
+                }, null, 2),
+            }],
+    };
+});
+server.tool("revoke_delegation", "[OPERATOR] Revoke a delegation. Optionally cascade to all sub-delegations.", {
+    delegation_id: z.string().describe("Delegation ID to revoke"),
+    reason: z.string().describe("Why the delegation is being revoked"),
+    cascade: z.boolean().default(true).describe("Also revoke all sub-delegations"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    if (args.cascade) {
+        const result = cascadeRevoke(args.delegation_id, state.agentKey, args.reason, state.privateKey);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        revokedCount: result.totalRevoked,
+                        rootRevocation: { delegationId: result.rootRevocation.delegationId, revokedAt: result.rootRevocation.revokedAt },
+                        cascadedCount: result.cascadedRevocations.length,
+                        reason: args.reason,
+                    }, null, 2),
+                }],
+        };
+    }
+    else {
+        const revocation = revokeDelegation(args.delegation_id, state.agentKey, args.reason, state.privateKey);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        delegationId: args.delegation_id,
+                        revokedAt: revocation.revokedAt,
+                        reason: args.reason,
+                    }, null, 2),
+                }],
+        };
+    }
+});
+server.tool("sub_delegate", "Sub-delegate authority to another agent (must be within your delegation scope and depth).", {
+    parent_delegation_id: z.string().describe("Your delegation ID"),
+    delegated_to: z.string().describe("Public key of the agent receiving sub-delegation"),
+    scope: z.array(z.string()).describe("Scopes to grant (must be subset of parent)"),
+    spend_limit: z.number().describe("Maximum spend (must be <= parent)"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    try {
+        const parentDel = state.delegations.get(args.parent_delegation_id);
+        if (!parentDel)
+            return { content: [{ type: "text", text: `Parent delegation ${args.parent_delegation_id} not found in session.` }], isError: true };
+        const sub = subDelegate({
+            parentDelegation: parentDel,
+            delegatedTo: args.delegated_to,
+            scope: args.scope,
+            spendLimit: args.spend_limit,
+            privateKey: state.privateKey,
+        });
+        state.delegations.set(sub.delegationId, sub);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        delegationId: sub.delegationId,
+                        parentId: args.parent_delegation_id,
+                        scope: sub.scope,
+                        spendLimit: sub.spendLimit,
+                        depth: sub.currentDepth,
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Sub-delegation failed: ${e.message}` }], isError: true };
+    }
+});
+// ═══════════════════════════════════════
+// AGORA TOOLS (Layer 4)
+// ═══════════════════════════════════════
+server.tool("post_agora_message", "Post a signed message to the Agora feed. Anyone can read, everything is signed.", {
+    topic: z.string().describe("Topic channel (e.g. 'coordination', 'governance', 'general')"),
+    type: z.enum(["announcement", "proposal", "discussion", "request", "ack", "vote"]).describe("Message type"),
+    subject: z.string().describe("One-line summary"),
+    content: z.string().describe("Message body (markdown)"),
+    reply_to: z.string().optional().describe("Message ID to reply to (for threading)"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    const message = createAgoraMessage({
+        agentId: state.agentId || 'anonymous',
+        agentName: state.agentId || 'anonymous',
+        publicKey: state.agentKey,
+        privateKey: state.privateKey,
+        topic: args.topic,
+        type: args.type,
+        subject: args.subject,
+        content: args.content,
+        replyTo: args.reply_to,
+    });
+    state.agoraFeed = appendToFeed(state.agoraFeed, message);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    messageId: message.id,
+                    topic: message.topic,
+                    subject: message.subject,
+                    signed: !!message.signature,
+                    feedSize: state.agoraFeed.messages.length,
+                }, null, 2),
+            }],
+    };
+});
+server.tool("get_agora_topics", "List all topics in the Agora feed with message counts.", {}, async () => {
+    const topics = getTopics(state.agoraFeed);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    topics: topics.map(t => ({ topic: t.topic, count: t.count })),
+                    totalMessages: state.agoraFeed.messages.length,
+                }, null, 2),
+            }],
+    };
+});
+server.tool("get_agora_thread", "Get a message thread from the Agora feed.", {
+    message_id: z.string().describe("Root message ID to get thread for"),
+}, async (args) => {
+    const thread = getThread(state.agoraFeed, args.message_id);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    threadLength: thread.length,
+                    messages: thread.map(m => ({
+                        id: m.id,
+                        author: m.author.agentId,
+                        subject: m.subject,
+                        content: m.content.slice(0, 200) + (m.content.length > 200 ? '...' : ''),
+                        replyTo: m.replyTo,
+                    })),
+                }, null, 2),
+            }],
+    };
+});
+server.tool("get_agora_by_topic", "Get all messages in a topic.", {
+    topic: z.string().describe("Topic to filter by"),
+}, async (args) => {
+    const messages = getByTopic(state.agoraFeed, args.topic);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    topic: args.topic,
+                    count: messages.length,
+                    messages: messages.map(m => ({
+                        id: m.id,
+                        author: m.author.agentId,
+                        type: m.type,
+                        subject: m.subject,
+                        content: m.content.slice(0, 200) + (m.content.length > 200 ? '...' : ''),
+                        timestamp: m.timestamp,
+                    })),
+                }, null, 2),
+            }],
+    };
+});
+server.tool("register_agora_agent", "Register an agent in the Agora so their messages can be verified.", {
+    agent_id: z.string().describe("Agent ID"),
+    agent_name: z.string().describe("Display name"),
+    public_key: z.string().describe("Ed25519 public key"),
+}, async (args) => {
+    registerAgent(state.agoraRegistry, {
+        agentId: args.agent_id,
+        agentName: args.agent_name,
+        publicKey: args.public_key,
+        joinedAt: new Date().toISOString(),
+        role: 'member',
+    });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    registered: true,
+                    agentId: args.agent_id,
+                    registrySize: state.agoraRegistry.agents.length,
+                }, null, 2),
+            }],
+    };
+});
+// ═══════════════════════════════════════
+// VALUES / POLICY TOOLS (Layer 2 + 5)
+// ═══════════════════════════════════════
+server.tool("load_values_floor", "Load a Values Floor from YAML. Sets the floor principles for policy evaluation.", {
+    yaml: z.string().describe("Values Floor YAML content"),
+}, async (args) => {
+    try {
+        const floor = loadFloor(args.yaml);
+        state.floorYaml = args.yaml;
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        loaded: true,
+                        version: floor.version,
+                        principles: floor.floor.length,
+                        names: floor.floor.map((p) => p.name),
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Failed to load floor: ${e.message}` }], isError: true };
+    }
+});
+server.tool("attest_to_floor", "Attest that your agent agrees to abide by the loaded Values Floor.", {
+    floor_version: z.string().describe("Version of the floor to attest to"),
+    extensions: z.array(z.string()).optional().describe("Optional additional extensions"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    if (!state.floorYaml)
+        return { content: [{ type: "text", text: 'No floor loaded. Use load_values_floor first.' }], isError: true };
+    const floor = loadFloor(state.floorYaml);
+    const attestation = attestFloor(state.agentId || 'anonymous', state.agentKey, args.floor_version, args.extensions || [], state.privateKey);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    attested: true,
+                    agentId: attestation.agentId,
+                    floorVersion: attestation.floorVersion,
+                    extensions: attestation.extensions,
+                    signed: !!attestation.commitment,
+                }, null, 2),
+            }],
+    };
+});
+server.tool("create_intent", "Declare an intent to perform an action. First step of the 3-signature chain.", {
+    action_type: z.string().describe("What type of action (e.g. 'web_search', 'commerce:checkout')"),
+    target: z.string().describe("What the action operates on"),
+    scope_required: z.string().describe("Which delegation scope is needed"),
+    spend_amount: z.number().optional().describe("Expected spend amount"),
+    spend_currency: z.string().optional().describe("Spend currency (e.g. 'usd')"),
+    context: z.string().optional().describe("Why the agent wants to do this"),
+    delegation_id: z.string().describe("Delegation ID authorizing this action"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    const intent = createActionIntent({
+        agentId: state.agentId || 'anonymous',
+        agentPublicKey: state.agentKey,
+        delegationId: args.delegation_id,
+        action: {
+            type: args.action_type,
+            target: args.target,
+            scopeRequired: args.scope_required,
+            spend: args.spend_amount ? { amount: args.spend_amount, currency: args.spend_currency || 'usd' } : undefined,
+        },
+        context: args.context,
+        privateKey: state.privateKey,
+    });
+    state.intents.set(intent.intentId, intent);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    intentId: intent.intentId,
+                    action: intent.action,
+                    signed: !!intent.signature,
+                    note: 'Intent created. Use evaluate_intent for policy decision (signature 2 of 3).',
+                }, null, 2),
+            }],
+    };
+});
+server.tool("evaluate_intent", "[OPERATOR] Evaluate an intent against the Values Floor policy engine. Returns real pass/fail verdict.", {
+    intent_id: z.string().describe("Intent ID from create_intent"),
+    delegation_scope: z.array(z.string()).describe("Delegation scope for context"),
+    delegation_spend_limit: z.number().describe("Delegation spend limit"),
+    delegation_spent: z.number().default(0).describe("Amount already spent"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    if (!state.floorYaml)
+        return { content: [{ type: "text", text: 'No floor loaded. Use load_values_floor first.' }], isError: true };
+    const intent = state.intents.get(args.intent_id);
+    if (!intent)
+        return { content: [{ type: "text", text: `Intent ${args.intent_id} not found. Use create_intent first.` }], isError: true };
+    const floor = loadFloor(state.floorYaml);
+    const validator = new FloorValidatorV1();
+    const validationContext = {
+        floorVersion: floor.version,
+        floorPrinciples: floor.floor.map((p) => ({
+            id: p.id, name: p.name,
+            enforcement: p.enforcement,
+            weight: p.weight,
+        })),
+        delegation: {
+            scope: args.delegation_scope,
+            spendLimit: args.delegation_spend_limit,
+            spentAmount: args.delegation_spent,
+            expiresAt: new Date(Date.now() + 86400000).toISOString(),
+            revoked: false,
+            currentDepth: 0,
+            maxDepth: 2,
+        },
+        agentRegistered: true,
+        agentAttestationValid: true,
+    };
+    try {
+        const decision = evaluateIntent({
+            intent,
+            validator,
+            validationContext,
+            evaluatorId: state.agentId || 'mcp-evaluator',
+            evaluatorPublicKey: state.agentKey,
+            evaluatorPrivateKey: state.privateKey,
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        decisionId: decision.decisionId,
+                        intentId: decision.intentId,
+                        verdict: decision.verdict,
+                        reason: decision.reason,
+                        principlesEvaluated: decision.principlesEvaluated.length,
+                        constraints: decision.constraints,
+                        floorVersion: decision.floorVersion,
+                        signed: true,
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Policy evaluation failed: ${e.message}` }], isError: true };
+    }
+});
+// ═══════════════════════════════════════
+// COMMERCE TOOLS (Layer 8)
+// ═══════════════════════════════════════
+server.tool("commerce_preflight", "Run preflight checks before a purchase. Validates passport, delegation, merchant, and spend limits.", {
+    merchant_name: z.string().describe("Merchant to purchase from"),
+    amount: z.number().describe("Purchase amount"),
+    currency: z.string().default("usd").describe("Currency code"),
+    delegation_id: z.string().describe("Commerce delegation ID"),
+    agent_id: z.string().describe("Agent making the purchase"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    // Create a passport for preflight (uses session agent)
+    const agent = joinSocialContract({
+        name: args.agent_id,
+        mission: 'Commerce operation',
+        owner: 'mcp-session',
+        capabilities: ['commerce:checkout', 'commerce:browse'],
+        platform: 'node',
+        models: ['mcp'],
+    });
+    // Look up or create commerce delegation
+    const commerceDel = createCommerceDelegation({
+        agentId: args.agent_id,
+        delegationId: args.delegation_id,
+        spendLimit: 1000, // Default, should come from actual delegation
+        approvedMerchants: [], // Empty = all merchants allowed
+    });
+    const result = commercePreflight({
+        signedPassport: agent.passport,
+        delegation: commerceDel,
+        merchantName: args.merchant_name,
+        estimatedTotal: { amount: args.amount, currency: args.currency },
+    });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    permitted: result.permitted,
+                    checks: result.checks,
+                    warnings: result.warnings,
+                    blockedReason: result.blockedReason,
+                }, null, 2),
+            }],
+    };
+});
+server.tool("get_commerce_spend", "Get spend analytics for a commerce delegation.", {
+    agent_id: z.string().describe("Agent ID"),
+    delegation_id: z.string().describe("Commerce delegation ID"),
+    spend_limit: z.number().describe("Total allowed spend"),
+}, async (args) => {
+    const commerceDel = createCommerceDelegation({
+        agentId: args.agent_id,
+        delegationId: args.delegation_id,
+        spendLimit: args.spend_limit,
+    });
+    const summary = getSpendSummary(commerceDel);
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(summary, null, 2),
+            }],
+    };
+});
+server.tool("request_human_approval", "Request human approval for a high-value purchase.", {
+    agent_id: z.string().describe("Agent requesting approval"),
+    merchant: z.string().describe("Merchant name"),
+    amount: z.number().describe("Purchase amount"),
+    currency: z.string().default("usd").describe("Currency"),
+    reason: z.string().describe("Why this purchase is needed"),
+    expires_minutes: z.number().default(30).describe("Minutes until approval expires"),
+}, async (args) => {
+    const approval = requestHumanApproval({
+        agentId: args.agent_id,
+        delegationId: 'pending',
+        merchantName: args.merchant,
+        items: [{ id: 'item-1', skuId: 'manual', name: args.reason, quantity: 1, unitPrice: { amount: args.amount, currency: args.currency }, totalPrice: { amount: args.amount, currency: args.currency } }],
+        totalAmount: { amount: args.amount, currency: args.currency },
+        reason: args.reason,
+        expiresInMinutes: args.expires_minutes,
+    });
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify({
+                    requestId: approval.requestId,
+                    status: approval.status,
+                    expiresAt: approval.expiresAt,
+                    note: 'Approval request created. Human must approve before checkout can proceed.',
+                }, null, 2),
+            }],
+    };
+});
+// ═══════════════════════════════════════
+// AGENT CONTEXT — Enforcement Middleware
+// ═══════════════════════════════════════
+server.tool("create_agent_context", "Create an enforcement context that automatically runs every action through the 3-signature policy chain. Without this, policy checks are opt-in. With this, agents physically cannot skip enforcement.", {
+    name: z.string().describe("Agent name"),
+    mission: z.string().describe("Agent mission statement"),
+    enforcement: z.enum(["auto", "manual", "strict"]).default("auto").describe("Enforcement level: auto (every action checked), manual (tracking only), strict (auto + additional constraints)"),
+    delegated_scopes: z.array(z.string()).default([]).describe("Scopes to delegate (e.g. ['data:read', 'api:fetch', 'commerce:checkout'])"),
+    spend_limit: z.number().default(1000).describe("Maximum spend allowed"),
+}, async (args) => {
+    const keyErr = requireKey();
+    if (keyErr)
+        return { content: [{ type: "text", text: keyErr }], isError: true };
+    if (!state.floorYaml) {
+        return { content: [{ type: "text", text: 'No floor loaded. Use load_values_floor first.' }], isError: true };
+    }
+    try {
+        const floor = loadFloor(state.floorYaml);
+        // Create the agent with floor attestation
+        const agent = joinSocialContract({
+            name: args.name,
+            mission: args.mission,
+            owner: 'mcp-session',
+            capabilities: args.delegated_scopes,
+            platform: 'node',
+            models: ['mcp'],
+            floor,
+        });
+        // Create the enforced context
+        const ctx = createAgentContext(agent, floor, {
+            enforcement: args.enforcement,
+        });
+        // Add delegation if scopes provided
+        if (args.delegated_scopes.length > 0) {
+            const principal = joinSocialContract({
+                name: 'mcp-principal',
+                mission: 'MCP session principal',
+                owner: 'human',
+                capabilities: ['admin'],
+                platform: 'node',
+                models: ['mcp'],
+                floor,
+            });
+            const del = delegate({
+                from: principal,
+                toPublicKey: agent.publicKey,
+                scope: args.delegated_scopes,
+                spendLimit: args.spend_limit,
+                maxDepth: 3,
+                expiresInHours: 24,
+            });
+            ctx.addDelegation(del);
+        }
+        state.agentContext = ctx;
+        state.floor = floor;
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        created: true,
+                        enforcement: args.enforcement,
+                        agentId: agent.agentId,
+                        scopes: args.delegated_scopes,
+                        spendLimit: args.spend_limit,
+                        note: `Agent Context active (${args.enforcement} mode). Use execute_with_context to run actions through the 3-signature chain.`,
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Failed to create context: ${e.message}` }], isError: true };
+    }
+});
+server.tool("execute_with_context", "Execute an action through the enforcement context. Automatically runs the 3-signature chain: creates intent (sig 1), evaluates against floor + delegation (sig 2), returns verdict. Action is DENIED if outside delegated scope.", {
+    action_type: z.string().describe("Action type (e.g. 'api:fetch', 'data:write', 'commerce:checkout')"),
+    target: z.string().describe("Target of the action (e.g. URL, file path, resource ID)"),
+    scope: z.string().describe("Required scope for this action (must match a delegated scope)"),
+    estimated_spend: z.number().optional().describe("Estimated spend for commerce actions"),
+}, async (args) => {
+    if (!state.agentContext) {
+        return { content: [{ type: "text", text: 'No agent context. Use create_agent_context first.' }], isError: true };
+    }
+    try {
+        const result = state.agentContext.execute({
+            type: args.action_type,
+            target: args.target,
+            scope: args.scope,
+            spend: args.estimated_spend ? { amount: args.estimated_spend, currency: 'USD' } : undefined,
+        });
+        // Store for later completion
+        if (result.permitted && result.intent) {
+            state.pendingActions.set(result.intent.intentId, result);
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        permitted: result.permitted,
+                        verdict: result.verdict,
+                        intentId: result.intent?.intentId,
+                        evaluatorId: result.decision?.evaluatorId,
+                        reason: result.reason,
+                        stats: state.agentContext.stats,
+                        note: result.permitted
+                            ? `Action PERMITTED. Call complete_action with intent_id="${result.intent.intentId}" when done.`
+                            : `Action DENIED: ${result.reason}`,
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Execute failed: ${e.message}` }], isError: true };
+    }
+});
+server.tool("complete_action", "Complete a permitted action and get the full 3-signature proof chain (intent + decision + receipt + policy receipt). Call this after successfully executing the action.", {
+    intent_id: z.string().describe("Intent ID from execute_with_context result"),
+    status: z.enum(["success", "failure", "partial"]).describe("Outcome of the action"),
+    summary: z.string().describe("Brief description of what was accomplished"),
+}, async (args) => {
+    if (!state.agentContext) {
+        return { content: [{ type: "text", text: 'No agent context. Use create_agent_context first.' }], isError: true };
+    }
+    // Find the pending execute result
+    const executeResult = state.pendingActions.get(args.intent_id);
+    if (!executeResult) {
+        return { content: [{ type: "text", text: `No pending action found for intent ${args.intent_id}. Was it permitted?` }], isError: true };
+    }
+    try {
+        const completed = state.agentContext.complete(executeResult, {
+            status: args.status,
+            summary: args.summary,
+        });
+        // Clean up
+        state.pendingActions.delete(args.intent_id);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        completed: true,
+                        receiptId: completed.receipt.receiptId,
+                        policyReceiptId: completed.policyReceipt?.receiptId,
+                        signatures: {
+                            intent: '✓ (agent declared intent)',
+                            decision: '✓ (policy engine evaluated)',
+                            receipt: '✓ (execution recorded)',
+                        },
+                        stats: state.agentContext.stats,
+                        auditTrail: state.agentContext.auditLog.length + ' entries',
+                    }, null, 2),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Complete failed: ${e.message}` }], isError: true };
+    }
+});
+// ═══════════════════════════════════════
 // MCP Prompts — Role-Specific
 // ═══════════════════════════════════════
 server.prompt("coordination_role", "Get instructions for your assigned coordination role", {}, async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-passport-system-mcp",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "MCP server for Agent Passport System — cryptographic identity, delegation, governance, and deliberation for AI agents",
   "type": "module",
   "bin": {
@@ -17,16 +17,21 @@
   "keywords": [
     "mcp",
     "model-context-protocol",
-    "agent",
-    "passport",
-    "identity",
-    "governance",
-    "cryptography",
+    "ai-agent",
+    "agent-identity",
     "ed25519",
+    "cryptographic-identity",
     "delegation",
     "multi-agent",
-    "deliberation",
-    "trust"
+    "governance",
+    "coordination",
+    "agentic-commerce",
+    "trust",
+    "claude-desktop",
+    "cursor",
+    "mcp-server",
+    "agent-protocol",
+    "typescript"
   ],
   "author": "aeoess",
   "license": "Apache-2.0",
@@ -38,7 +43,6 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
     "@types/node": "^25.3.2",
-    "agent-passport-system": "^1.5.0",
     "typescript": "^5.9.3",
     "zod": "^3.25.0"
   },