@atrib/verify-mcp 0.2.21 → 1.0.0

package/README.md

@@ -1,5 +1,17 @@
 # @atrib/verify-mcp
 
+**Legacy home.** The read-verb implementation moved to
+[`@atrib/recall`](../atrib-recall/README.md) per the attest/recall rename
+([D164](../../DECISIONS.md#d164-attestrecall-verb-rename-and-primitive-surface-collapse)).
+`atrib-verify` folds into `recall` through its `verification` parameter.
+This package re-exports the same surface and forwards the `atrib-verify`
+binary to `@atrib/recall`'s handlers. Results are JSON-identical. The
+`atrib-verify` tool name stays mounted as a permanent alias during the
+alias window, alongside the new `recall` tool. `@atrib/verify` (the
+verifier library) is NOT renamed. This package keeps a hard dependency on
+`@atrib/verify` so the verifier always resolves, independent of
+`@atrib/recall`'s optional-peer posture toward it.
+
 MCP server exposing the `atrib-verify` cognitive primitive for atrib's verifiable action layer. It verifies counterparty handoff evidence before a receiving agent signs follow-up work that cites those records through `informed_by`.
 
 The package is read-only. It accepts caller-supplied evidence, returns accepted and rejected hashes, and leaves the follow-up signing step to `atrib-emit` or normal wrapped tool calls.

package/dist/index.d.ts

@@ -1,54 +1,2 @@
-/**
- * atrib-verify MCP server.
- *
- * Exposes the seventh atrib cognitive primitive: verify counterparty handoff
- * evidence before the receiving agent signs a follow-up that cites it through
- * informed_by. The server is deliberately thin. @atrib/verify owns the actual
- * cryptographic checks, packet extraction, and rejection reasons.
- */
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import { type HandoffClaimVerification } from '@atrib/verify';
-declare const VerifyInput: z.ZodObject<{
-    packet: z.ZodOptional<z.ZodUnknown>;
-    records: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
-    claims: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
-    required_record_hashes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    trusted_creator_keys: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    allowed_context_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    require_body: z.ZodOptional<z.ZodBoolean>;
-    require_body_commitment: z.ZodOptional<z.ZodBoolean>;
-    require_log_inclusion: z.ZodOptional<z.ZodBoolean>;
-    log_public_key_b64: z.ZodOptional<z.ZodString>;
-    now_ms: z.ZodOptional<z.ZodNumber>;
-    max_age_ms: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type AtribVerifyInput = z.infer<typeof VerifyInput>;
-export interface AtribVerifyServer {
-    mcp: McpServer;
-}
-export interface AtribVerifyOutput {
-    primitive: 'atrib-verify';
-    all_accepted: boolean;
-    accepted_record_hashes: string[];
-    accepted: CompactHandoffClaim[];
-    rejected: CompactHandoffClaim[];
-}
-interface CompactHandoffClaim {
-    record_hash: string;
-    accepted: boolean;
-    rejection_reasons: string[];
-    warnings: string[];
-    signature_ok: boolean | null;
-    computed_record_hash: string | null;
-    signer_trusted: boolean | null;
-    context_allowed: boolean | null;
-    record_context_id?: string;
-    record_creator_key?: string;
-    record_timestamp?: number;
-    body?: HandoffClaimVerification['body'];
-    proof?: HandoffClaimVerification['proof'];
-}
-export declare function handleAtribVerify(input: AtribVerifyInput): Promise<AtribVerifyOutput>;
-export declare function createAtribVerifyServer(): Promise<AtribVerifyServer>;
-export {};
+export { createAtribVerifyServer, handleAtribVerify, registerVerifyTool, tryHandleAtribVerify, VerifyInput, } from '@atrib/recall';
+export type { AtribVerifyInput, AtribVerifyOutput, AtribVerifyServer, RecallVerificationBlock, } from '@atrib/recall';

package/dist/index.js

@@ -1,151 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
-/**
- * atrib-verify MCP server.
- *
- * Exposes the seventh atrib cognitive primitive: verify counterparty handoff
- * evidence before the receiving agent signs a follow-up that cites it through
- * informed_by. The server is deliberately thin. @atrib/verify owns the actual
- * cryptographic checks, packet extraction, and rejection reasons.
- */
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import { extractRecordHashesFromMcpResult, logReadPrimitiveCall, SHA256_REF_PATTERN, } from '@atrib/mcp';
-import { handoffClaimsFromEvidencePacket, verifyHandoffClaims, } from '@atrib/verify';
-const HEX_32_PATTERN = /^[0-9a-f]{32}$/;
-const VerifyInput = z.object({
-    packet: z
-        .unknown()
-        .optional()
-        .describe('Private continuation or handoff packet carrying records, proof bundles, local mirror sidecars, and optional trust policy.'),
-    records: z
-        .array(z.unknown())
-        .optional()
-        .describe('Evidence entries, usually parsed D062 local mirror envelopes or packet records. Used when packet is omitted.'),
-    claims: z
-        .array(z.unknown())
-        .optional()
-        .describe('Alias for records. Each entry can be a bare AtribRecord or an envelope with record, proof, and _local sidecar.'),
-    required_record_hashes: z
-        .array(z.string().regex(SHA256_REF_PATTERN))
-        .optional()
-        .describe('Record hashes the receiving agent expected. Missing entries are preserved as verifier rejections.'),
-    trusted_creator_keys: z
-        .array(z.string().min(1))
-        .optional()
-        .describe('Allowed creator_key values for upstream records. When set, records from other signers are rejected.'),
-    allowed_context_ids: z
-        .array(z.string().regex(HEX_32_PATTERN))
-        .optional()
-        .describe('Allowed upstream context_id values. When set, records from other contexts are rejected.'),
-    require_body: z
-        .boolean()
-        .optional()
-        .describe('Require private body material from body, args/result, or D062 _local content.'),
-    require_body_commitment: z
-        .boolean()
-        .optional()
-        .describe('Require args_hash or result_hash on the signed record so private body material can be checked.'),
-    require_log_inclusion: z
-        .boolean()
-        .optional()
-        .describe('Require a supplied proof bundle whose inclusion path verifies against the checkpoint root.'),
-    log_public_key_b64: z
-        .string()
-        .optional()
-        .describe('Optional trusted log Ed25519 public key, base64 or base64url encoded. When supplied, checkpoint signatures are verified.'),
-    now_ms: z
-        .number()
-        .optional()
-        .describe('Verifier wall-clock override in milliseconds. Mostly for deterministic tests.'),
-    max_age_ms: z
-        .number()
-        .optional()
-        .describe('Freshness window. Records older than this, or dated in the future, are rejected as stale.'),
-});
-function decodeLogPublicKey(value) {
-    if (!value)
-        return undefined;
-    const normalized = value.replace(/-/g, '+').replace(/_/g, '/');
-    const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, '=');
-    const decoded = new Uint8Array(Buffer.from(padded, 'base64'));
-    if (decoded.length !== 32) {
-        throw new Error(`log_public_key_b64 must decode to 32 bytes, got ${decoded.length}`);
-    }
-    return decoded;
-}
-function packetFromInput(input) {
-    if (input.packet !== undefined)
-        return input.packet;
-    return {
-        records: (input.records ?? input.claims ?? []),
-        required_record_hashes: input.required_record_hashes,
-        trusted_creator_keys: input.trusted_creator_keys,
-        allowed_context_ids: input.allowed_context_ids,
-        max_age_ms: input.max_age_ms,
-    };
-}
-function compactClaim(claim) {
-    const out = {
-        record_hash: claim.record_hash,
-        accepted: claim.accepted,
-        rejection_reasons: claim.rejection_reasons,
-        warnings: claim.warnings,
-        signature_ok: claim.signature_ok,
-        computed_record_hash: claim.computed_record_hash,
-        signer_trusted: claim.signer_trusted,
-        context_allowed: claim.context_allowed,
-    };
-    if (claim.record) {
-        out.record_context_id = claim.record.context_id;
-        out.record_creator_key = claim.record.creator_key;
-        out.record_timestamp = claim.record.timestamp;
-    }
-    if (claim.body)
-        out.body = claim.body;
-    if (claim.proof)
-        out.proof = claim.proof;
-    return out;
-}
-function compactResult(result) {
-    return {
-        primitive: 'atrib-verify',
-        all_accepted: result.all_accepted,
-        accepted_record_hashes: result.accepted_record_hashes,
-        accepted: result.accepted.map(compactClaim),
-        rejected: result.rejected.map(compactClaim),
-    };
-}
-export async function handleAtribVerify(input) {
-    const packet = packetFromInput(input);
-    const claims = handoffClaimsFromEvidencePacket(packet, {
-        required_record_hashes: input.required_record_hashes,
-        trusted_creator_keys: input.trusted_creator_keys,
-        allowed_context_ids: input.allowed_context_ids,
-        max_age_ms: input.max_age_ms,
-    });
-    const result = await verifyHandoffClaims(claims, {
-        trusted_creator_keys: input.trusted_creator_keys,
-        allowed_context_ids: input.allowed_context_ids,
-        require_body: input.require_body === true,
-        require_body_commitment: input.require_body_commitment === true,
-        require_log_inclusion: input.require_log_inclusion === true,
-        log_public_key: decodeLogPublicKey(input.log_public_key_b64),
-        now_ms: input.now_ms,
-        max_age_ms: input.max_age_ms,
-    });
-    return compactResult(result);
-}
-export async function createAtribVerifyServer() {
-    const mcp = new McpServer({ name: 'atrib-verify', version: '0.1.0' });
-    mcp.registerTool('atrib-verify', {
-        description: 'Verify counterparty handoff evidence before linking follow-up work through informed_by.',
-        inputSchema: VerifyInput.shape,
-    }, async (rawInput) => logReadPrimitiveCall('atrib-verify', rawInput, async () => {
-        const input = VerifyInput.parse(rawInput);
-        const result = await handleAtribVerify(input);
-        return {
-            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-        };
-    }, extractRecordHashesFromMcpResult));
-    return { mcp };
-}
+// @atrib/verify-mcp is the legacy home of the atrib-verify read primitive
+// (cognitive primitive #7 of D079/D106). The implementation lives in
+// @atrib/recall per the attest/recall rename: handoff verification folds
+// into the `recall` verb's `verification` parameter, and the atrib-verify
+// tool name stays mounted as a permanent alias over the same handler. This
+// package re-exports the surface so existing imports keep working, and its
+// hard dependency on @atrib/verify guarantees the verifier peer resolves
+// for every consumer of this package (@atrib/recall alone treats it as an
+// optional peer).
+export { createAtribVerifyServer, handleAtribVerify, registerVerifyTool, tryHandleAtribVerify, VerifyInput, } from '@atrib/recall';

package/dist/main.js

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
-// SPDX-License-Identifier: Apache-2.0
+// atrib-verify standalone binary (forwarding shim). Serves the legacy
+// atrib-verify server, which mounts `atrib-verify` plus the `recall` verb
+// per the alias-window rule W1.
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { createAtribVerifyServer } from './index.js';
+import { createAtribVerifyServer } from '@atrib/recall';
 async function main() {
     const { mcp } = await createAtribVerifyServer();
     const transport = new StdioServerTransport();
     await mcp.connect(transport);
 }
 main().catch((e) => {
-    console.error('atrib-verify: fatal', e instanceof Error ? (e.stack ?? e.message) : String(e));
+    console.error('atrib-verify: fatal', e instanceof Error ? e.stack ?? e.message : String(e));
     process.exit(1);
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atrib/verify-mcp",
-  "version": "0.2.21",
-  "description": "MCP server for atrib's verifiable action layer. Verifies handoff evidence before agents link follow-up work.",
+  "version": "1.0.0",
+  "description": "Legacy home of atrib's handoff-verification read primitive. Superseded by @atrib/recall (the read verb, verification parameter); this package re-exports the same surface, forwards the atrib-verify binary, and keeps a hard dependency on the @atrib/verify library so the verifier always resolves.",
   "author": "atrib <hello@atrib.dev>",
   "keywords": [
     "atrib",
@@ -24,9 +24,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "zod": "^4.4.3",
-    "@atrib/mcp": "0.20.0",
-    "@atrib/verify": "0.8.3"
+    "@atrib/recall": "1.0.0",
+    "@atrib/verify": "0.9.0"
   },
   "devDependencies": {
     "@noble/ed25519": "^3.1.0",