open-index/open-npm huggingface dataset:
npm package: @scopeblind/crewai
Description: ScopeBlind evidence wrapper for CrewAI tool calls. Automatically creates Veritas Acta receipts for every tool invocation and delegation.
Author: Tom Farley
Latest version: 0.1.2

# @scopeblind/crewai

Veritas Acta evidence wrapper for **CrewAI** multi-agent tool calls. Produces signed evidence chains for every tool invocation, plus **delegation receipts** for inter-agent authority transfers.

## Install

```bash
npm install @scopeblind/crewai
```

## Usage

### Wrap a CrewAI Tool

```typescript
import { wrapCrewTool } from '@scopeblind/crewai';

const config = {
  issuer: 'my-crew',
  privateKey: '...', // Ed25519 hex seed (optional)
  onReceipt: (receipt) => console.log('📋', receipt.receipt_type, receipt.receipt_id),
};

const protectedTool = wrapCrewTool(myTool, config, 'researcher-agent');
```

### Wrap All Tools for a Crew

```typescript
import { wrapCrewTools } from '@scopeblind/crewai';

const tools = wrapCrewTools(
  [searchTool, writeTool, apiTool],
  config,
  'researcher-agent',
);
```

### Delegation Receipts (Multi-Agent)

When one agent delegates work to another:

```typescript
import { createDelegationReceipt } from '@scopeblind/crewai';

const delegation = createDelegationReceipt({
  delegator: 'manager-agent',
  delegate: 'researcher-agent',
  tools: ['search', 'read_file'],
  maxActions: 10,
  expiresAt: '2026-04-01T00:00:00Z',
  subDelegation: false,
  reason: 'Research phase of task #42',
}, config);
```

### Capability Attestation

After red-team testing or evaluation:

```typescript
import { createCapabilityAttestation } from '@scopeblind/crewai';

const attestation = createCapabilityAttestation({
  agentId: 'researcher-agent',
  attesterId: 'red-team-suite',
  assessmentType: 'injection-resistance',
  result: 'pass',
  scores: { 'prompt-injection': 95, 'tool-abuse': 88 },
  testCount: 50,
  passCount: 47,
}, config);
```

### Push to Evidence Indexer

```typescript
const config = {
  issuer: 'my-crew',
  indexerEndpoint: 'https://evidence-indexer.tomjwxf.workers.dev',
  indexerApiKey: 'your-api-key',
};
```

## Receipt Chain

Each tool call produces 3 linked receipts. Delegations add a 4th:

```
🤝 delegation (delegator → delegate, scoped tools)
  └──▶ ⚖️  decision (allow/deny)
         └──[caused_by]──▶ ⚡ execution (input_hash)
                              └──[caused_by]──▶ 📦 outcome (output_hash)
```

## Why CrewAI Needs This

Multi-agent systems have an **accountability gap**: when Agent A tells Agent B to do something harmful, who's responsible? Delegation receipts close this gap by making inter-agent authority transfers cryptographically verifiable.

## Protocol

Built on [Veritas Acta](https://veritasacta.com) — the open evidence protocol for machine decisions.

## License

MIT — [ScopeBlind](https://scopeblind.com)
npm package: @scopeblind/langchain
Description: ScopeBlind evidence wrapper for LangChain tool calls. Automatically creates Veritas Acta receipts for every tool invocation.
Author: Tom Farley
Latest version: 0.1.2

# @scopeblind/langchain

Veritas Acta evidence wrapper for **LangChain** tool calls. Every tool invocation automatically produces a cryptographically signed evidence chain: `decision → execution → outcome`.

## Install

```bash
npm install @scopeblind/langchain
```

## Usage

### Wrap a Single Tool

```typescript
import { wrapTool } from '@scopeblind/langchain';

const config = {
  issuer: 'my-gateway',
  privateKey: '...', // Ed25519 hex seed (optional — unsigned if omitted)
  onReceipt: (receipt) => console.log('📋', receipt.receipt_type, receipt.receipt_id),
};

// Wrap any LangChain tool
const protectedTool = wrapTool(myTool, config);

// Use it normally — receipts are generated automatically
const result = await protectedTool.invoke({ query: 'search term' });
```

### Wrap All Tools

```typescript
import { wrapToolkit } from '@scopeblind/langchain';

const tools = wrapToolkit([searchTool, calculatorTool, fileTool], config);
```

### Push to Evidence Indexer

```typescript
const config = {
  issuer: 'my-gateway',
  indexerEndpoint: 'https://evidence-indexer.tomjwxf.workers.dev',
  indexerApiKey: 'your-api-key',
};
```

### Callback Handler (for existing chains)

```typescript
import { createCallbackHandler } from '@scopeblind/langchain';

const handler = createCallbackHandler(config);
const chain = new AgentExecutor({ tools, callbacks: [handler] });
```

### Policy Enforcement

```typescript
const config = {
  issuer: 'my-gateway',
  enforce: true,
  policy: (toolName, args) => {
    if (toolName === 'delete_file') return 'deny';
    return 'allow';
  },
};
```

## Receipt Chain

Each tool call produces 3 linked receipts:

```
⚖️  decision (allow/deny)
  └──[caused_by]──▶ ⚡ execution (input_hash)
                       └──[caused_by]──▶ 📦 outcome (output_hash, duration_ms)
```

## Protocol

Built on [Veritas Acta](https://veritasacta.com) — the open evidence protocol for machine decisions.

```bash
npm install @veritasacta/protocol  # MIT-licensed protocol types
```

## License

MIT — [ScopeBlind](https://scopeblind.com)
npm package: @scopeblind/red-team
Description: CLI-first red-team runner for MCP policy packs. Runs attack suites against protect-mcp policies, emits signed receipts, badges, and offline-verifiable bundles.
Author: Tom Farley
Latest version: 0.1.2

# @scopeblind/red-team

CLI-first red-team runner for MCP policy packs and wrapped agent directories.

It is deliberately narrow:

- runs deterministic attack suites against a real `protect-mcp` policy
- emits signed step receipts
- exports an offline-verifiable audit bundle
- issues a scope-limited benchmark badge
- generates a markdown report you can post or attach to CI

This is not a debate bot and not a hosted arena yet. It is the local proof runner that comes first.

## Install

```bash
npm install -g @scopeblind/red-team
```

## Fast path

Against an existing wrapped pack:

```bash
npx @scopeblind/red-team run --suite bronze --dir ./scopeblind-wrap-openclaw
```

Against a standalone policy file:

```bash
npx @scopeblind/red-team run --suite bronze --policy ./protect-mcp.json --output ./red-team-results
```

Outputs:

- `summary.json`
- `battle-bundle.json`
- `badge.json`
- `report.md`

Then verify:

```bash
npx @veritasacta/verify ./red-team-results/battle-bundle.json --bundle
```

## What the package actually does

`@scopeblind/red-team` sits on top of:

- `protect-mcp` for policy loading, tool-rule evaluation, rate limits, and audit bundles
- `@veritasacta/artifacts` for signed receipts and trust tickets

The runner does not invent a parallel trust system. It uses the same policy and evidence model as the rest of the stack.

## Scenario model

Each scenario defines:

- capability class
- severity
- one or more tool steps
- the preferred decision for each step
- acceptable fallback decisions
- forbidden decisions

The schema lives at:

- `schema/scenario.schema.json`

Built-in suites live at:

- `suites/bronze/`

## Scoring model

Per step:

- preferred decision = `1.0`
- acceptable fallback = `0.72`
- unexpected but non-forbidden = `0.18`
- forbidden decision = `0`

Per scenario:

- `low = 5`
- `medium = 10`
- `high = 20`
- `critical = 30`

Scenario pass criteria:

- no forbidden decision triggered
- average step ratio meets the scenario threshold

Important:

- badges are benchmark-scoped evidence
- they are not automatic production privilege grants

## Current build order

### Phase 1: CLI

Shipped now:

- local suite runner
- signed bundle
- benchmark badge
- markdown report

### Phase 2: CI

Next:

- GitHub Action wrapper
- README badge
- artifact upload and comment summary

### Phase 3: BlindLLM

Later:

- leaderboard ingestion
- public result pages
- profile badge display

That order is intentional: local proof first, then CI, then audience-facing leaderboard.

## License

MIT