@onchaindiligence/agent-evidence 0.1.0 → 0.2.0

package/README.md

@@ -5,17 +5,34 @@ OnChainDiligence Agent Evidence v0 protocol. It creates deterministic records,
 validates the complete evidence DAG, seals bundles with Ed25519 DSSE, and
 verifies portable bundles offline with caller-supplied trust.
 
-The package is currently **packable and publish-ready, but not yet published to
-npm**. Do not advertise a registry install until the owner completes npm trusted
-publishing. From this repository, test the exact public artifact with:
+The package is publicly available on npm:
 
 ```sh
-npm pack ./packages/agent-evidence
-npm install ./onchaindiligence-agent-evidence-0.1.0.tgz
+npm install @onchaindiligence/agent-evidence
+# or pin this release
+npm install @onchaindiligence/agent-evidence@0.2.0
 ```
 
+This source README reflects the public release. The immutable README embedded
+in the already-published `0.1.0` tarball carried its pre-release wording; this
+release includes the corrected package documentation.
+
 Node.js 20.19 or newer and ESM are required.
 
+## 0.2.0
+
+- Adds strict parsing of generic Agent Evidence signer registries and
+  `TrustPolicy` construction from independently supplied registry metadata.
+- Packages the key-registry JSON Schema, interoperability profile support, and
+  browser/offline-friendly registry types.
+- Adds Technocore signed-message and tclk/1 coordination-evidence adapters.
+
+The verifier remains caller-trust-controlled: embedded bundle keys are never
+trust roots. A Technocore signature proves key possession/authorship of exact
+bytes, not truth; tclk evidence proves coordination, not settlement; and
+PaperRail represents no real value. `VALID`, `INVALID`, and `UNVERIFIABLE`
+semantics are unchanged.
+
 ## What a signature proves
 
 A valid signature proves that the identified key signed the exact canonical
@@ -90,6 +107,81 @@ where policy withholds an invoice payment because recipient ownership evidence
 is missing. The execution is `withheld-not-submitted`; the example does not
 fabricate a transaction or settlement.
 
+## Technocore signed-message evidence
+
+`technocore.chat` signed-lane messages can be captured as attributable, offline
+verifiable input with no resolver or network call. The adapter mirrors the
+official single-line sweep and verifies the exact UTF-8
+`<room>|<nonce>|<stored-text>` string against the Ed25519 public key embedded in
+the sender's `did:key`.
+
+```js
+import { createTechnocoreEvidence, verifyTechnocoreMessage } from '@onchaindiligence/agent-evidence'
+
+// Treat every field as untrusted data obtained from Technocore's JSON response.
+if (!verifyTechnocoreMessage({ did, room, nonce, text, sig })) throw new Error('invalid assertion')
+const evidence = createTechnocoreEvidence({ did, room, nonce, text, sig }, {
+  runRef: run.id,
+  observedAt: '2026-09-01T12:00:01.000Z',
+  serverMetadata: { seq: String(seq), ts: String(ts), generation: String(generation) },
+})
+```
+
+The resulting record preserves the DID, room, nonce, exact stored text, its
+SHA-256 digest, signature, signing format, and optional server metadata. It
+always uses `trust_mode: 'agent-assertion'`: a valid signature proves only that
+that `did:key` asserted those bytes. It never proves the message is true,
+authorizes an action, supplies a trusted instruction, or permits a wallet/
+network action. `verifyTechnocoreMessage` and normal bundle verification are
+fully offline and make no HTTP requests.
+
+[`examples/technocore-evidence.mjs`](./examples/technocore-evidence.mjs) builds
+Mandate → Technocore Evidence → Policy → Decision → non-execution → DSSE-sealed
+bundle → offline `VALID` verification.
+
+## tclk/1 (Technocore Lock Protocol) transcript evidence
+
+Signed agent-to-agent deal coordination on [`technocore.chat`](https://github.com/flop-labs/technocore-chat)
+using FLOP Labs' [`@flop-labs/tclk`](https://github.com/flop-labs/tclk) (`offer →
+accept → lock → reveal/refund`) can be captured as Agent Evidence. This adapter
+uses the official `@flop-labs/tclk` package directly — it never reimplements
+frame validation or the state machine, and never uses tclk's unaudited
+PTLC/adaptor-signature path.
+
+```js
+import { verifyTclkTranscript, createTclkEvidence } from '@onchaindiligence/agent-evidence'
+
+// Each entry is a Technocore signed message whose text is a tclk/1 frame line,
+// plus the wall-clock time (ms) at which that frame was applied.
+const transcript = verifyTclkTranscript([
+  { message: offerMsg, atMs }, { message: acceptMsg, atMs }, { message: lockMsg, atMs },
+])
+const evidence = createTclkEvidence(transcript, {
+  runRef: run.id, observedAt, messageEvidenceRefs: [/* one createTechnocoreEvidence(...).id per message */],
+})
+```
+
+`verifyTclkTranscript` verifies, independently, per frame: the Technocore
+transport signature (reusing `verifyTechnocoreMessage`, not a second
+implementation), the tclk frame's own validity, that the frame's `from` matches
+the transport-authenticated DID, and the official state-machine transition. It
+fails closed on a bad signature, a malformed frame, or a sender/DID mismatch; a
+frame the *official* machine itself rejects as a designed-in no-op (a replay, a
+duplicate, an out-of-order transition) is recorded in the result rather than
+treated as fatal, per tclk's own spec.
+
+**Valid signed coordination is evidence of what the agents agreed/asserted. The
+named settlement rail remains authoritative for actual value movement** — a
+`lock` frame is captured as "payer asserted/announced lock on rail X," never as
+"funds were locked," unless the caller separately supplies an independently
+verified `settlementRail` observation (this package implements no rail).
+
+[`examples/tclk-evidence.mjs`](./examples/tclk-evidence.mjs) builds a full
+hash-lock transcript (offer → accept → lock → reveal) between two local test
+identities and turns it into Mandate → tclk Evidence → Policy → Decision
+(`ACCEPT_COORDINATION_EVIDENCE`) → Execution (`NO_REAL_VALUE_SETTLEMENT`, since
+no real rail is wired up) → sealed bundle → offline `VALID` verification.
+
 ## Schemas and interoperability
 
 The npm artifact includes the canonical v0 schemas and public conformance

package/dist/index.d.ts

@@ -6,9 +6,15 @@ export { AgentEvidenceError, CanonicalizationError, EvidenceValidationError, Par
 export { validateBundlePayload } from './graph.js';
 export { createBundlePayload, createRecord } from './records.js';
 export type { CreateBundlePayloadOptions, CreateRecordOptions } from './records.js';
+export { createTechnocoreEvidence, sweepTechnocoreText, technocoreDidFromPublicKey, technocoreSigningInput, technocoreTextDigest, verifyTechnocoreMessage, } from './technocore.js';
+export type { TechnocoreEvidenceOptions, TechnocoreSignedMessage } from './technocore.js';
+export { createTclkEvidence, verifyTclkTranscript } from './tclk.js';
+export type { SettlementRailObservation, TclkEvidenceOptions, TclkTranscriptMessage, TclkTranscriptResult, TclkTranscriptStep, } from './tclk.js';
 export { validateDocument } from './schema.js';
 export { AttestationKey, createKeyRecord, deriveKeyId, evaluateKeyLifecycle, loadPublicKey, TrustPolicy, } from './trust.js';
 export type { CreateKeyRecordOptions, TrustPolicyOptions } from './trust.js';
+export { parseAgentEvidenceKeyRegistry, trustPolicyFromKeyRegistry } from './registry.js';
+export type { AgentEvidenceKeyRegistry, AgentEvidenceKeyRegistryEntry, ParseAgentEvidenceKeyRegistryOptions, } from './registry.js';
 export { overallState, verifyBundle } from './verifier.js';
 export type { AgentEvidenceRecord, AttestationKeyRecord, BundlePayload, ComponentResult, DsseEnvelope, DsseSignature, Ed25519Signer, JsonObject, JsonPrimitive, JsonValue, KeyInput, PortableBundle, RecordKind, VerificationMaterial, VerificationReport, VerificationState, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,UAAU,EACV,cAAc,EACd,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,SAAS,EACT,aAAa,EACb,eAAe,EACf,SAAS,EACT,cAAc,GACf,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACpE,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAClD,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,UAAU,EACV,qBAAqB,EACrB,YAAY,EACZ,gBAAgB,GACjB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAClD,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChE,YAAY,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AACnF,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EACL,cAAc,EACd,eAAe,EACf,WAAW,EACX,oBAAoB,EACpB,aAAa,EACb,WAAW,GACZ,MAAM,YAAY,CAAA;AACnB,YAAY,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAC5E,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC1D,YAAY,EACV,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,YAAY,EACZ,aAAa,EACb,aAAa,EACb,UAAU,EACV,aAAa,EACb,SAAS,EACT,QAAQ,EACR,cAAc,EACd,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,UAAU,EACV,cAAc,EACd,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,SAAS,EACT,aAAa,EACb,eAAe,EACf,SAAS,EACT,cAAc,GACf,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACpE,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAClD,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,UAAU,EACV,qBAAqB,EACrB,YAAY,EACZ,gBAAgB,GACjB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAClD,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChE,YAAY,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AACnF,OAAO,EACL,wBAAwB,EACxB,mBAAmB,EACnB,0BAA0B,EAC1B,sBAAsB,EACtB,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,iBAAiB,CAAA;AACxB,YAAY,EAAE,yBAAyB,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAA;AACzF,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AACpE,YAAY,EACV,yBAAyB,EACzB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EACL,cAAc,EACd,eAAe,EACf,WAAW,EACX,oBAAoB,EACpB,aAAa,EACb,WAAW,GACZ,MAAM,YAAY,CAAA;AACnB,YAAY,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAC5E,OAAO,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAA;AACzF,YAAY,EACV,wBAAwB,EACxB,6BAA6B,EAC7B,oCAAoC,GACrC,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC1D,YAAY,EACV,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,YAAY,EACZ,aAAa,EACb,aAAa,EACb,UAAU,EACV,aAAa,EACb,SAAS,EACT,QAAQ,EACR,cAAc,EACd,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -4,7 +4,10 @@ export { createEd25519Signer, dssePae, sealBundle } from './dsse.js';
 export { AgentEvidenceError, CanonicalizationError, EvidenceValidationError, ParseError, SchemaValidationError, SigningError, TrustPolicyError, } from './errors.js';
 export { validateBundlePayload } from './graph.js';
 export { createBundlePayload, createRecord } from './records.js';
+export { createTechnocoreEvidence, sweepTechnocoreText, technocoreDidFromPublicKey, technocoreSigningInput, technocoreTextDigest, verifyTechnocoreMessage, } from './technocore.js';
+export { createTclkEvidence, verifyTclkTranscript } from './tclk.js';
 export { validateDocument } from './schema.js';
 export { AttestationKey, createKeyRecord, deriveKeyId, evaluateKeyLifecycle, loadPublicKey, TrustPolicy, } from './trust.js';
+export { parseAgentEvidenceKeyRegistry, trustPolicyFromKeyRegistry } from './registry.js';
 export { overallState, verifyBundle } from './verifier.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,UAAU,EACV,cAAc,EACd,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,SAAS,EACT,aAAa,EACb,eAAe,EACf,SAAS,EACT,cAAc,GACf,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAEpE,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,UAAU,EACV,qBAAqB,EACrB,YAAY,EACZ,gBAAgB,GACjB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAClD,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAEhE,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EACL,cAAc,EACd,eAAe,EACf,WAAW,EACX,oBAAoB,EACpB,aAAa,EACb,WAAW,GACZ,MAAM,YAAY,CAAA;AAEnB,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,UAAU,EACV,cAAc,EACd,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,SAAS,EACT,aAAa,EACb,eAAe,EACf,SAAS,EACT,cAAc,GACf,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAEpE,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,UAAU,EACV,qBAAqB,EACrB,YAAY,EACZ,gBAAgB,GACjB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAClD,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAEhE,OAAO,EACL,wBAAwB,EACxB,mBAAmB,EACnB,0BAA0B,EAC1B,sBAAsB,EACtB,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,iBAAiB,CAAA;AAExB,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AAQpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EACL,cAAc,EACd,eAAe,EACf,WAAW,EACX,oBAAoB,EACpB,aAAa,EACb,WAAW,GACZ,MAAM,YAAY,CAAA;AAEnB,OAAO,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAA;AAMzF,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA"}

package/dist/registry.d.ts

@@ -0,0 +1,76 @@
+import { TrustPolicy, type TrustPolicyOptions } from './trust.js';
+import type { JsonObject } from './types.js';
+/**
+ * Agent Evidence Interoperability Profile v1 — public signer key registry.
+ *
+ * See docs/AGENT_EVIDENCE_INTEROP.md for the full profile. This module parses
+ * and validates the WIRE format any issuer (ArcFX is the current production
+ * reference) can publish at `GET /.well-known/agent-evidence-keys`, and maps
+ * validated entries into the existing `AttestationKeyRecord` shape so they
+ * flow through the same `TrustPolicy` / `evaluateKeyLifecycle` machinery as
+ * every other trusted key in this package — no second lifecycle model.
+ *
+ * This module does NOT fetch anything over the network. Network fetching is
+ * the caller's concern (see the profile doc for the recommended pattern); the
+ * core SDK stays fully usable offline. Hosting this endpoint is a discovery
+ * convenience only — it does not by itself make an issuer trustworthy, and an
+ * embedded bundle key never establishes trust regardless of what any registry
+ * says. Trust is always the caller's `TrustPolicy`.
+ */
+export interface AgentEvidenceKeyRegistryEntry extends JsonObject {
+    key_id: string;
+    algorithm: 'Ed25519';
+    public_key_pem: string;
+    valid_from: string | null;
+    valid_until: string | null;
+    revoked_at: string | null;
+    status: 'active' | 'retired' | 'revoked' | 'compromised';
+}
+export interface AgentEvidenceKeyRegistry extends JsonObject {
+    schema_version: 1;
+    issuer: string;
+    environment: string;
+    keys: AgentEvidenceKeyRegistryEntry[];
+}
+export interface ParseAgentEvidenceKeyRegistryOptions {
+    /** Reject the registry unless `issuer` equals exactly this string. */
+    expectedIssuer?: string;
+    /** Reject the registry unless `environment` equals exactly this string. */
+    expectedEnvironment?: string;
+}
+/**
+ * Validates untrusted parsed JSON as an Agent Evidence key registry (schema
+ * `agent-evidence-key-registry.schema.json`), optionally pinning the exact
+ * `issuer`/`environment` a caller expects.
+ *
+ * Fails closed: throws `TrustPolicyError` on any structural violation
+ * (missing/extra fields, wrong types, a malformed key entry anywhere in the
+ * array, an issuer/environment mismatch) rather than returning a partial or
+ * best-effort result. A caller integrating this over the network should treat
+ * a thrown error here — like a failed fetch — as "no trust available from
+ * this source" (typically UNVERIFIABLE for anything that key would have
+ * signed), never as INVALID: an unreachable or misconfigured registry is not
+ * evidence that a bundle's signature is fraudulent.
+ *
+ * `key_id` alone is never sufficient to establish trust, and this function
+ * does not establish trust either — it only validates shape. Feed the result
+ * to `trustPolicyFromKeyRegistry`, or your own mapping, to actually build a
+ * `TrustPolicy`.
+ */
+export declare function parseAgentEvidenceKeyRegistry(payload: unknown, options?: ParseAgentEvidenceKeyRegistryOptions): AgentEvidenceKeyRegistry;
+/**
+ * Parses and validates an Agent Evidence key registry, then constructs a
+ * `TrustPolicy` from its keys — the recommended one-call path from an
+ * untrusted registry payload to a usable trust policy.
+ *
+ * Equivalent to `TrustPolicy.fromKeyRecords(parseAgentEvidenceKeyRegistry(payload, opts).keys.map(...), trustPolicyOptions)`,
+ * so it inherits every existing `TrustPolicy`/`evaluateKeyLifecycle` guarantee:
+ * a revoked or compromised key still fails closed to INVALID when it signs
+ * something, a key with no `valid_from` is UNVERIFIABLE, and so on — this
+ * function adds no new trust semantics, only a convenient on-ramp into the
+ * existing ones.
+ */
+export declare function trustPolicyFromKeyRegistry(payload: unknown, options?: ParseAgentEvidenceKeyRegistryOptions & {
+    trustPolicy?: TrustPolicyOptions;
+}): TrustPolicy;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAA;AACjE,OAAO,KAAK,EAAwB,UAAU,EAAE,MAAM,YAAY,CAAA;AAElE;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,6BAA8B,SAAQ,UAAU;IAC/D,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,SAAS,CAAA;IACpB,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAA;CACzD;AAED,MAAM,WAAW,wBAAyB,SAAQ,UAAU;IAC1D,cAAc,EAAE,CAAC,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,6BAA6B,EAAE,CAAA;CACtC;AAED,MAAM,WAAW,oCAAoC;IACnD,sEAAsE;IACtE,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,2EAA2E;IAC3E,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,oCAAyC,GACjD,wBAAwB,CAmB1B;AA6BD;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,oCAAoC,GAAG;IAAE,WAAW,CAAC,EAAE,kBAAkB,CAAA;CAAO,GACxF,WAAW,CAGb"}

package/dist/registry.js

@@ -0,0 +1,83 @@
+import { SchemaValidationError, TrustPolicyError } from './errors.js';
+import { validateDocument } from './schema.js';
+import { TrustPolicy } from './trust.js';
+/**
+ * Validates untrusted parsed JSON as an Agent Evidence key registry (schema
+ * `agent-evidence-key-registry.schema.json`), optionally pinning the exact
+ * `issuer`/`environment` a caller expects.
+ *
+ * Fails closed: throws `TrustPolicyError` on any structural violation
+ * (missing/extra fields, wrong types, a malformed key entry anywhere in the
+ * array, an issuer/environment mismatch) rather than returning a partial or
+ * best-effort result. A caller integrating this over the network should treat
+ * a thrown error here — like a failed fetch — as "no trust available from
+ * this source" (typically UNVERIFIABLE for anything that key would have
+ * signed), never as INVALID: an unreachable or misconfigured registry is not
+ * evidence that a bundle's signature is fraudulent.
+ *
+ * `key_id` alone is never sufficient to establish trust, and this function
+ * does not establish trust either — it only validates shape. Feed the result
+ * to `trustPolicyFromKeyRegistry`, or your own mapping, to actually build a
+ * `TrustPolicy`.
+ */
+export function parseAgentEvidenceKeyRegistry(payload, options = {}) {
+    try {
+        validateDocument('agent-evidence-key-registry.schema.json', payload);
+    }
+    catch (error) {
+        if (error instanceof SchemaValidationError)
+            throw new TrustPolicyError(error.message, { cause: error });
+        throw error;
+    }
+    const registry = payload;
+    if (options.expectedIssuer !== undefined && registry.issuer !== options.expectedIssuer) {
+        throw new TrustPolicyError(`registry issuer "${registry.issuer}" does not match the expected issuer "${options.expectedIssuer}"`);
+    }
+    if (options.expectedEnvironment !== undefined && registry.environment !== options.expectedEnvironment) {
+        throw new TrustPolicyError(`registry environment "${registry.environment}" does not match the expected environment "${options.expectedEnvironment}"`);
+    }
+    return registry;
+}
+/**
+ * Maps one validated registry entry onto the package's own trusted-key record
+ * shape. The internal `AttestationKeyRecord` model requires an "active" key to
+ * carry no `valid_until` (open-ended) -- a bounded validity window is what
+ * "retired" means internally. A generic registry has no such constraint (an
+ * issuer's own "active" just means "not revoked"), so a registry-reported
+ * active key with a bounded `valid_until` maps to the internal "retired"
+ * status; the underlying lifecycle window is honored either way via
+ * `evaluateKeyLifecycle`, only the label changes.
+ */
+function toAttestationKeyRecord(entry) {
+    const revoked = entry.status === 'revoked' || entry.status === 'compromised';
+    const status = entry.status === 'active' && entry.valid_until !== null ? 'retired' : entry.status;
+    return {
+        key_id: entry.key_id,
+        algorithm: 'ed25519',
+        public_key_pem: entry.public_key_pem,
+        status,
+        valid_from: entry.valid_from,
+        valid_until: entry.valid_until,
+        status_changed_at: revoked ? entry.revoked_at : entry.valid_from,
+        replacement_key_id: null,
+        compromised_at: entry.status === 'compromised' ? entry.revoked_at : null,
+        ...(revoked ? { status_reason: `registry-reported ${entry.status} at ${entry.revoked_at ?? 'unknown time'}` } : {}),
+    };
+}
+/**
+ * Parses and validates an Agent Evidence key registry, then constructs a
+ * `TrustPolicy` from its keys — the recommended one-call path from an
+ * untrusted registry payload to a usable trust policy.
+ *
+ * Equivalent to `TrustPolicy.fromKeyRecords(parseAgentEvidenceKeyRegistry(payload, opts).keys.map(...), trustPolicyOptions)`,
+ * so it inherits every existing `TrustPolicy`/`evaluateKeyLifecycle` guarantee:
+ * a revoked or compromised key still fails closed to INVALID when it signs
+ * something, a key with no `valid_from` is UNVERIFIABLE, and so on — this
+ * function adds no new trust semantics, only a convenient on-ramp into the
+ * existing ones.
+ */
+export function trustPolicyFromKeyRegistry(payload, options = {}) {
+    const registry = parseAgentEvidenceKeyRegistry(payload, options);
+    return TrustPolicy.fromKeyRecords(registry.keys.map(toAttestationKeyRecord), options.trustPolicy);
+}
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,EAAE,WAAW,EAA2B,MAAM,YAAY,CAAA;AA6CjE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,6BAA6B,CAC3C,OAAgB,EAChB,UAAgD,EAAE;IAElD,IAAI,CAAC;QACH,gBAAgB,CAAC,yCAAyC,EAAE,OAAO,CAAC,CAAA;IACtE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,qBAAqB;YAAE,MAAM,IAAI,gBAAgB,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAA;QACvG,MAAM,KAAK,CAAA;IACb,CAAC;IACD,MAAM,QAAQ,GAAG,OAAmC,CAAA;IACpD,IAAI,OAAO,CAAC,cAAc,KAAK,SAAS,IAAI,QAAQ,CAAC,MAAM,KAAK,OAAO,CAAC,cAAc,EAAE,CAAC;QACvF,MAAM,IAAI,gBAAgB,CACxB,oBAAoB,QAAQ,CAAC,MAAM,yCAAyC,OAAO,CAAC,cAAc,GAAG,CACtG,CAAA;IACH,CAAC;IACD,IAAI,OAAO,CAAC,mBAAmB,KAAK,SAAS,IAAI,QAAQ,CAAC,WAAW,KAAK,OAAO,CAAC,mBAAmB,EAAE,CAAC;QACtG,MAAM,IAAI,gBAAgB,CACxB,yBAAyB,QAAQ,CAAC,WAAW,8CAA8C,OAAO,CAAC,mBAAmB,GAAG,CAC1H,CAAA;IACH,CAAC;IACD,OAAO,QAAQ,CAAA;AACjB,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,sBAAsB,CAAC,KAAoC;IAClE,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,aAAa,CAAA;IAC5E,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,KAAK,QAAQ,IAAI,KAAK,CAAC,WAAW,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAA;IACjG,OAAO;QACL,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,SAAS,EAAE,SAAS;QACpB,cAAc,EAAE,KAAK,CAAC,cAAc;QACpC,MAAM;QACN,UAAU,EAAE,KAAK,CAAC,UAAU;QAC5B,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,iBAAiB,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU;QAChE,kBAAkB,EAAE,IAAI;QACxB,cAAc,EAAE,KAAK,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI;QACxE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,qBAAqB,KAAK,CAAC,MAAM,OAAO,KAAK,CAAC,UAAU,IAAI,cAAc,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACpH,CAAA;AACH,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,0BAA0B,CACxC,OAAgB,EAChB,UAAuF,EAAE;IAEzF,MAAM,QAAQ,GAAG,6BAA6B,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;IAChE,OAAO,WAAW,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;AACnG,CAAC"}

package/dist/schema.d.ts

@@ -1,4 +1,4 @@
 export declare const SCHEMA_BASE = "https://onchaindiligence.com/schemas/agent-evidence/v0/";
-export declare const SCHEMA_NAMES: readonly ["common.schema.json", "attestation-key.schema.json", "dsse-envelope.schema.json", "proof.schema.json", "record.schema.json", "bundle-payload.schema.json", "portable-file.schema.json"];
+export declare const SCHEMA_NAMES: readonly ["common.schema.json", "attestation-key.schema.json", "dsse-envelope.schema.json", "proof.schema.json", "record.schema.json", "bundle-payload.schema.json", "portable-file.schema.json", "agent-evidence-key-registry.schema.json"];
 export declare function validateDocument(name: string, value: unknown): void;
 //# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW,4DAA4D,CAAA;AACpF,eAAO,MAAM,YAAY,mMAQf,CAAA;AA6BV,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAOnE"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW,4DAA4D,CAAA;AACpF,eAAO,MAAM,YAAY,8OASf,CAAA;AA6BV,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAOnE"}

package/dist/schema.js

@@ -11,6 +11,7 @@ export const SCHEMA_NAMES = [
     'record.schema.json',
     'bundle-payload.schema.json',
     'portable-file.schema.json',
+    'agent-evidence-key-registry.schema.json',
 ];
 const Ajv2020 = Ajv2020Import;
 const addFormats = addFormatsImport;

package/dist/schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,aAAa,EAAE,EAA2C,MAAM,kBAAkB,CAAA;AACzF,OAAO,gBAAgB,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAEnD,MAAM,CAAC,MAAM,WAAW,GAAG,yDAAyD,CAAA;AACpF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,oBAAoB;IACpB,6BAA6B;IAC7B,2BAA2B;IAC3B,mBAAmB;IACnB,oBAAoB;IACpB,4BAA4B;IAC5B,2BAA2B;CACnB,CAAA;AAOV,MAAM,OAAO,GAAG,aAAgF,CAAA;AAChG,MAAM,UAAU,GAAG,gBAA6D,CAAA;AAChF,MAAM,GAAG,GAAG,IAAI,OAAO,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAA;AAC1D,UAAU,CAAC,GAAG,CAAC,CAAA;AACf,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;IAChC,MAAM,KAAK,GAAG,YAAY,CAAC,IAAI,GAAG,CAAC,cAAc,IAAI,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CAAA;IAClF,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAA;AAClC,CAAC;AAED,SAAS,SAAS,CAAC,IAAY;IAC7B,IAAI,CAAE,YAAkC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACxD,MAAM,IAAI,UAAU,CAAC,kCAAkC,IAAI,EAAE,CAAC,CAAA;IAChE,CAAC;IACD,MAAM,QAAQ,GAAG,GAAG,CAAC,SAAS,CAAC,GAAG,WAAW,GAAG,IAAI,EAAE,CAAC,CAAA;IACvD,IAAI,CAAC,QAAQ;QAAE,MAAM,IAAI,KAAK,CAAC,mDAAmD,IAAI,EAAE,CAAC,CAAA;IACzF,OAAO,QAAQ,CAAA;AACjB,CAAC;AAED,SAAS,YAAY,CAAC,KAAkB;IACtC,OAAO,GAAG,KAAK,CAAC,YAAY,SAAS,KAAK,CAAC,UAAU,SAAS,KAAK,CAAC,OAAO,EAAE,CAAA;AAC/E,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,IAAY,EAAE,KAAc;IAC3D,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,CAAA;IAChC,IAAI,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAM;IAC3B,MAAM,MAAM,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACxH,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;IACvB,IAAI,CAAC,KAAK;QAAE,MAAM,IAAI,qBAAqB,CAAC,GAAG,IAAI,6BAA6B,CAAC,CAAA;IACjF,MAAM,IAAI,qBAAqB,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC,YAAY,IAAI,GAAG,KAAK,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC,CAAA;AAC3G,CAAC"}
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,aAAa,EAAE,EAA2C,MAAM,kBAAkB,CAAA;AACzF,OAAO,gBAAgB,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAEnD,MAAM,CAAC,MAAM,WAAW,GAAG,yDAAyD,CAAA;AACpF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,oBAAoB;IACpB,6BAA6B;IAC7B,2BAA2B;IAC3B,mBAAmB;IACnB,oBAAoB;IACpB,4BAA4B;IAC5B,2BAA2B;IAC3B,yCAAyC;CACjC,CAAA;AAOV,MAAM,OAAO,GAAG,aAAgF,CAAA;AAChG,MAAM,UAAU,GAAG,gBAA6D,CAAA;AAChF,MAAM,GAAG,GAAG,IAAI,OAAO,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAA;AAC1D,UAAU,CAAC,GAAG,CAAC,CAAA;AACf,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;IAChC,MAAM,KAAK,GAAG,YAAY,CAAC,IAAI,GAAG,CAAC,cAAc,IAAI,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CAAA;IAClF,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAA;AAClC,CAAC;AAED,SAAS,SAAS,CAAC,IAAY;IAC7B,IAAI,CAAE,YAAkC,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACxD,MAAM,IAAI,UAAU,CAAC,kCAAkC,IAAI,EAAE,CAAC,CAAA;IAChE,CAAC;IACD,MAAM,QAAQ,GAAG,GAAG,CAAC,SAAS,CAAC,GAAG,WAAW,GAAG,IAAI,EAAE,CAAC,CAAA;IACvD,IAAI,CAAC,QAAQ;QAAE,MAAM,IAAI,KAAK,CAAC,mDAAmD,IAAI,EAAE,CAAC,CAAA;IACzF,OAAO,QAAQ,CAAA;AACjB,CAAC;AAED,SAAS,YAAY,CAAC,KAAkB;IACtC,OAAO,GAAG,KAAK,CAAC,YAAY,SAAS,KAAK,CAAC,UAAU,SAAS,KAAK,CAAC,OAAO,EAAE,CAAA;AAC/E,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,IAAY,EAAE,KAAc;IAC3D,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,CAAA;IAChC,IAAI,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAM;IAC3B,MAAM,MAAM,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACxH,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;IACvB,IAAI,CAAC,KAAK;QAAE,MAAM,IAAI,qBAAqB,CAAC,GAAG,IAAI,6BAA6B,CAAC,CAAA;IACjF,MAAM,IAAI,qBAAqB,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC,YAAY,IAAI,GAAG,KAAK,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC,CAAA;AAC3G,CAAC"}

package/dist/tclk.d.ts

@@ -0,0 +1,139 @@
+import { type LockKind, type OfferFrame, type TclkFrame, type TclkStatus } from '@flop-labs/tclk';
+import { type TechnocoreSignedMessage } from './technocore.js';
+import type { AgentEvidenceRecord, JsonObject } from './types.js';
+/**
+ * Technocore Lock Protocol (`tclk/1`, by FLOP Labs — https://github.com/flop-labs/tclk)
+ * adapter: turns a Technocore-carried tclk transcript into Agent Evidence.
+ *
+ * tclk is a coordination convention, not a settlement service: it proves which
+ * `did:key` signed a deal-coordination frame (offer/accept/lock/reveal/refund/
+ * cancel/receipt) and whether the transcript is valid under tclk's own
+ * fail-closed state machine (`applyFrame`). It does NOT prove the counterparty
+ * is trustworthy, that an asserted statement is objectively true, or that money
+ * actually moved — a named settlement rail remains authoritative for that. This
+ * module never implements a rail, never moves value, and deliberately does not
+ * use tclk's unaudited PTLC/adaptor-signature path (see SPEC.md §7).
+ *
+ * Verification here is layered and independently distinguishable, per frame:
+ *   1. transport   — `verifyTechnocoreMessage` (the existing Technocore adapter;
+ *                     not reimplemented here)
+ *   2. frame       — `decodeFrame`/`validateFrame` from the official `@flop-labs/tclk`
+ *                     package (not reimplemented here)
+ *   3. attribution — the frame's own `from` must equal the transport-verified DID
+ *   4. state       — `openContract`/`applyFrame`, the official state machine
+ */
+/** One Technocore message believed to carry a tclk/1 frame as its text. */
+export type TclkTranscriptMessage = TechnocoreSignedMessage;
+/**
+ * One transcript entry: a message plus the wall-clock time (unix ms) at which
+ * THAT frame was applied. tclk's deadline checks (`expiresMs`, `refundAfterMs`)
+ * are transition guards evaluated at the moment of each transition (see
+ * `applyFrame`'s `nowMs` parameter) — an `accept` many minutes after `offer` and
+ * a `refund` days later are each checked against their own real time, not a
+ * single "verification time" for the whole historical transcript. Reusing one
+ * frozen instant for every step would make it impossible to correctly replay a
+ * transcript that legitimately spans an offer's expiry window through to its
+ * refund window.
+ */
+export interface TclkTranscriptEntry {
+    message: TclkTranscriptMessage;
+    atMs: number;
+}
+/** One step of a verified transcript: either an accepted transition or an official rejection. */
+export interface TclkTranscriptStep {
+    message: TclkTranscriptMessage;
+    frameType: TclkFrame['type'];
+    accepted: boolean;
+    /** Present when `accepted` is false — the official machine's own rejection reason. */
+    reason?: string;
+}
+/** The result of successfully replaying a tclk transcript through the official state machine. */
+export interface TclkTranscriptResult {
+    offer: OfferFrame;
+    /** Set once an `accept` frame is itself accepted. */
+    contract: string | null;
+    status: TclkStatus;
+    terminal: boolean;
+    outcome: 'claimed' | 'refunded' | 'cancelled' | null;
+    payerDid: string | null;
+    payeeDid: string | null;
+    amount: string;
+    asset: string;
+    lock: LockKind;
+    offeredRails: readonly string[];
+    /** Set once a `lock` frame is accepted — the rail the payer announced, not independently verified. */
+    rail: string | null;
+    railRef: string | null;
+    claimByMs: number;
+    refundAfterMs: number;
+    expiresMs: number;
+    /** Every message processed, in order, whether accepted or officially rejected. */
+    steps: readonly TclkTranscriptStep[];
+}
+/**
+ * Verifies a Technocore-carried tclk/1 transcript end to end and replays it
+ * through the official `@flop-labs/tclk` state machine.
+ *
+ * Fails closed (throws `EvidenceValidationError`) when:
+ *  - a message's Technocore transport signature does not verify
+ *  - a message's text does not decode/validate as a tclk/1 frame
+ *  - a frame's own `from` does not match its message's transport-verified DID
+ *  - the transcript does not open with a valid `offer` frame, or a second
+ *    `offer` appears mid-transcript (which contract would the rest belong to?)
+ *
+ * A frame that decodes and is honestly attributed but that the OFFICIAL state
+ * machine itself rejects (wrong sender for the transition, a replay, a
+ * duplicate, an out-of-order transition, a tampered `contract`/`ref` id that
+ * fails the machine's own recomputation) is NOT a fail-closed error here: per
+ * tclk's own spec (SPEC.md §2, §4), those are designed-in no-op rejections a
+ * reader in a world-writable room must expect, not evidence the transcript
+ * itself is corrupt. Every such rejection is still recorded in `steps` with its
+ * reason — it is never silently discarded — and does not advance contract state.
+ *
+ * Each entry supplies its own `atMs` (see `TclkTranscriptEntry`); deadline
+ * guards are evaluated per-transition against that entry's own time, not a
+ * single instant for the whole replay.
+ */
+export declare function verifyTclkTranscript(entries: readonly TclkTranscriptEntry[]): TclkTranscriptResult;
+/**
+ * An OPTIONAL, independently-verified observation from a real settlement rail —
+ * NOT implemented, simulated, or connected to by this module. tclk coordination
+ * evidence plus a caller-supplied `SettlementRailObservation` is what would let a
+ * decision claim actual value movement; without one, a decision built on tclk
+ * evidence alone must describe the lock as asserted/announced, never as settled.
+ */
+export interface SettlementRailObservation {
+    rail: string;
+    ref: string;
+    observedAt: string;
+    /** Free-form, source-specific detail the caller already independently verified. */
+    detail: JsonObject;
+}
+export interface TclkEvidenceOptions {
+    runRef: string;
+    observedAt: string;
+    /**
+     * Parent evidence ids for the underlying signed Technocore messages — recommended:
+     * one `createTechnocoreEvidence(...)` call per transcript step, so the raw signed
+     * room messages remain independently inspectable evidence in their own right.
+     */
+    messageEvidenceRefs: readonly string[];
+    expiresAt?: string | null;
+    toolVersion?: string;
+    /** See `SettlementRailObservation`. Never fabricated by this module. */
+    settlementRail?: SettlementRailObservation;
+}
+/**
+ * Converts a verified tclk transcript into schema-valid Agent Evidence. The
+ * transcript must already have passed `verifyTclkTranscript` — this function
+ * does not re-verify signatures or replay frames, only records what was found.
+ *
+ * A `lock` frame is reported as "payer asserted/announced lock on rail X",
+ * never as "funds were locked" — this module has no independent way to observe
+ * a settlement rail. If the caller supplies a verified `settlementRail`
+ * observation, that is captured alongside the coordination evidence and
+ * labeled as independently observed, but it is still the caller's evidence,
+ * not something this adapter establishes.
+ */
+export declare function createTclkEvidence(transcript: TclkTranscriptResult, options: TclkEvidenceOptions): AgentEvidenceRecord;
+//# sourceMappingURL=tclk.d.ts.map

package/dist/tclk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tclk.d.ts","sourceRoot":"","sources":["../src/tclk.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,UAAU,EAChB,MAAM,iBAAiB,CAAA;AAIxB,OAAO,EAA2B,KAAK,uBAAuB,EAAE,MAAM,iBAAiB,CAAA;AACvF,OAAO,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAEjE;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,2EAA2E;AAC3E,MAAM,MAAM,qBAAqB,GAAG,uBAAuB,CAAA;AAE3D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,qBAAqB,CAAA;IAC9B,IAAI,EAAE,MAAM,CAAA;CACb;AAED,iGAAiG;AACjG,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,qBAAqB,CAAA;IAC9B,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;IAC5B,QAAQ,EAAE,OAAO,CAAA;IACjB,sFAAsF;IACtF,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,iGAAiG;AACjG,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,UAAU,CAAA;IACjB,qDAAqD;IACrD,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,MAAM,EAAE,UAAU,CAAA;IAClB,QAAQ,EAAE,OAAO,CAAA;IACjB,OAAO,EAAE,SAAS,GAAG,UAAU,GAAG,WAAW,GAAG,IAAI,CAAA;IACpD,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,QAAQ,CAAA;IACd,YAAY,EAAE,SAAS,MAAM,EAAE,CAAA;IAC/B,sGAAsG;IACtG,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,kFAAkF;IAClF,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAA;CACrC;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,SAAS,mBAAmB,EAAE,GACtC,oBAAoB,CAgGtB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,UAAU,EAAE,MAAM,CAAA;IAClB,mFAAmF;IACnF,MAAM,EAAE,UAAU,CAAA;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB;;;;OAIG;IACH,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAA;IACtC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,wEAAwE;IACxE,cAAc,CAAC,EAAE,yBAAyB,CAAA;CAC3C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,oBAAoB,EAChC,OAAO,EAAE,mBAAmB,GAC3B,mBAAmB,CAyErB"}

package/dist/tclk.js

@@ -0,0 +1,190 @@
+import { applyFrame, decodeFrame, openContract, validateFrame, } from '@flop-labs/tclk';
+import { contentId } from './canonical.js';
+import { EvidenceValidationError } from './errors.js';
+import { createRecord } from './records.js';
+import { verifyTechnocoreMessage } from './technocore.js';
+const TERMINAL_STATUSES = new Set(['claimed', 'refunded', 'cancelled']);
+/**
+ * Verifies a Technocore-carried tclk/1 transcript end to end and replays it
+ * through the official `@flop-labs/tclk` state machine.
+ *
+ * Fails closed (throws `EvidenceValidationError`) when:
+ *  - a message's Technocore transport signature does not verify
+ *  - a message's text does not decode/validate as a tclk/1 frame
+ *  - a frame's own `from` does not match its message's transport-verified DID
+ *  - the transcript does not open with a valid `offer` frame, or a second
+ *    `offer` appears mid-transcript (which contract would the rest belong to?)
+ *
+ * A frame that decodes and is honestly attributed but that the OFFICIAL state
+ * machine itself rejects (wrong sender for the transition, a replay, a
+ * duplicate, an out-of-order transition, a tampered `contract`/`ref` id that
+ * fails the machine's own recomputation) is NOT a fail-closed error here: per
+ * tclk's own spec (SPEC.md §2, §4), those are designed-in no-op rejections a
+ * reader in a world-writable room must expect, not evidence the transcript
+ * itself is corrupt. Every such rejection is still recorded in `steps` with its
+ * reason — it is never silently discarded — and does not advance contract state.
+ *
+ * Each entry supplies its own `atMs` (see `TclkTranscriptEntry`); deadline
+ * guards are evaluated per-transition against that entry's own time, not a
+ * single instant for the whole replay.
+ */
+export function verifyTclkTranscript(entries) {
+    if (entries.length === 0) {
+        throw new EvidenceValidationError('tclk transcript: no messages supplied');
+    }
+    const steps = [];
+    let offer = null;
+    let state = null;
+    for (const { message, atMs } of entries) {
+        if (!verifyTechnocoreMessage(message)) {
+            throw new EvidenceValidationError(`tclk transcript: message (room ${message.room}, nonce ${message.nonce}) has an invalid Technocore transport signature`);
+        }
+        let frame;
+        try {
+            frame = decodeFrame(message.text);
+        }
+        catch (error) {
+            throw new EvidenceValidationError(`tclk transcript: message (room ${message.room}, nonce ${message.nonce}) is not a valid tclk/1 frame: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (frame.from !== message.did) {
+            throw new EvidenceValidationError(`tclk transcript: frame sender ${frame.from} does not match the transport-authenticated DID ${message.did}`);
+        }
+        if (frame.type === 'offer') {
+            if (offer !== null) {
+                throw new EvidenceValidationError('tclk transcript: a second offer frame cannot open a new contract mid-transcript');
+            }
+            try {
+                offer = validateFrame(frame);
+                state = openContract(offer);
+            }
+            catch (error) {
+                throw new EvidenceValidationError(`tclk transcript: invalid opening offer: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            steps.push({ message, frameType: frame.type, accepted: true });
+            continue;
+        }
+        if (state === null) {
+            throw new EvidenceValidationError('tclk transcript: no opening offer frame appears before a subsequent frame');
+        }
+        const result = applyFrame(state, frame, atMs);
+        if (!result.ok) {
+            // Official, designed-in rejection (replay, duplicate, wrong sender for
+            // this transition, tampered id, out-of-order transition, …) — recorded,
+            // never dropped, never treated as fatal to the whole transcript.
+            steps.push({ message, frameType: frame.type, accepted: false, reason: result.reason ?? 'rejected' });
+            continue;
+        }
+        state = result.state;
+        steps.push({ message, frameType: frame.type, accepted: true });
+    }
+    if (offer === null || state === null) {
+        throw new EvidenceValidationError('tclk transcript: transcript never opened a contract');
+    }
+    const outcome = TERMINAL_STATUSES.has(state.status)
+        ? state.status
+        : null;
+    return {
+        offer,
+        contract: state.contract ?? null,
+        status: state.status,
+        terminal: TERMINAL_STATUSES.has(state.status),
+        outcome,
+        payerDid: state.payerDid ?? null,
+        payeeDid: state.payeeDid ?? null,
+        amount: offer.amount,
+        asset: offer.asset,
+        lock: offer.lock,
+        offeredRails: offer.rails,
+        rail: state.rail ?? null,
+        railRef: state.railRef ?? null,
+        claimByMs: offer.claimByMs,
+        refundAfterMs: offer.refundAfterMs,
+        expiresMs: offer.expiresMs,
+        steps,
+    };
+}
+/**
+ * Converts a verified tclk transcript into schema-valid Agent Evidence. The
+ * transcript must already have passed `verifyTclkTranscript` — this function
+ * does not re-verify signatures or replay frames, only records what was found.
+ *
+ * A `lock` frame is reported as "payer asserted/announced lock on rail X",
+ * never as "funds were locked" — this module has no independent way to observe
+ * a settlement rail. If the caller supplies a verified `settlementRail`
+ * observation, that is captured alongside the coordination evidence and
+ * labeled as independently observed, but it is still the caller's evidence,
+ * not something this adapter establishes.
+ */
+export function createTclkEvidence(transcript, options) {
+    const lockNote = transcript.rail === null
+        ? 'no lock frame observed in this transcript'
+        : `payer asserted/announced lock on rail "${transcript.rail}"` +
+            (transcript.railRef !== null ? ` (rail ref: ${transcript.railRef})` : '') +
+            '; this is the payer\'s claim, not independent proof that funds were escrowed';
+    const captured = {
+        protocol: 'tclk/1',
+        offer_id: transcript.offer.id,
+        contract_id: transcript.contract,
+        payer_did: transcript.payerDid,
+        payee_did: transcript.payeeDid,
+        amount: transcript.amount,
+        asset: transcript.asset,
+        lock_kind: transcript.lock,
+        offered_rails: [...transcript.offeredRails],
+        asserted_settlement_rail: transcript.rail,
+        asserted_settlement_rail_ref: transcript.railRef,
+        settlement_note: lockNote,
+        claim_by_ms: transcript.claimByMs,
+        refund_after_ms: transcript.refundAfterMs,
+        expires_ms: transcript.expiresMs,
+        transcript_status: transcript.status,
+        terminal: transcript.terminal,
+        outcome: transcript.outcome,
+        frame_sequence: transcript.steps.map((step) => ({
+            type: step.frameType,
+            from: step.message.did,
+            room: step.message.room,
+            nonce: step.message.nonce,
+            accepted: step.accepted,
+            reason: step.reason ?? null,
+        })),
+        ...(options.settlementRail !== undefined
+            ? {
+                independent_settlement_observation: {
+                    rail: options.settlementRail.rail,
+                    ref: options.settlementRail.ref,
+                    observed_at: options.settlementRail.observedAt,
+                    detail: options.settlementRail.detail,
+                },
+            }
+            : {}),
+        verification: 'technocore-transport-and-tclk-state-machine-verified',
+    };
+    const request = { offer_id: transcript.offer.id, contract_id: transcript.contract };
+    return createRecord('evidence', {
+        evidence_type: 'tclk-transcript',
+        run_ref: options.runRef,
+        trust_mode: 'agent-assertion',
+        source: { id: 'https://github.com/flop-labs/tclk', type: 'tclk-technocore-lock-protocol' },
+        tool: { name: 'onchaindiligence-tclk-adapter', version: options.toolVersion ?? '1' },
+        request: {
+            digest: { sha256: contentId(request).slice('sha256:'.length) },
+            media_type: 'application/vnd.tclk.transcript-request+json',
+        },
+        response: {
+            mode: 'embedded',
+            media_type: 'application/vnd.tclk.transcript+json',
+            value: captured,
+            digest: { sha256: contentId(captured).slice('sha256:'.length) },
+        },
+        observed_at: options.observedAt,
+        expires_at: options.expiresAt ?? null,
+        scope: {
+            offer_id: transcript.offer.id,
+            contract_id: transcript.contract,
+            payer_did: transcript.payerDid,
+            payee_did: transcript.payeeDid,
+        },
+    }, { parents: [options.runRef, ...options.messageEvidenceRefs] });
+}
+//# sourceMappingURL=tclk.js.map

package/dist/tclk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tclk.js","sourceRoot":"","sources":["../src/tclk.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,YAAY,EACZ,aAAa,GAMd,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,uBAAuB,EAAgC,MAAM,iBAAiB,CAAA;AA6EvF,MAAM,iBAAiB,GAA4B,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC,CAAC;AAEjG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,oBAAoB,CAClC,OAAuC;IAEvC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,uBAAuB,CAAC,uCAAuC,CAAC,CAAA;IAC5E,CAAC;IAED,MAAM,KAAK,GAAyB,EAAE,CAAA;IACtC,IAAI,KAAK,GAAsB,IAAI,CAAA;IACnC,IAAI,KAAK,GAAyB,IAAI,CAAA;IAEtC,KAAK,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,OAAO,EAAE,CAAC;QACxC,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,EAAE,CAAC;YACtC,MAAM,IAAI,uBAAuB,CAC/B,kCAAkC,OAAO,CAAC,IAAI,WAAW,OAAO,CAAC,KAAK,iDAAiD,CACxH,CAAA;QACH,CAAC;QAED,IAAI,KAAgB,CAAA;QACpB,IAAI,CAAC;YACH,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;QACnC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,uBAAuB,CAC/B,kCAAkC,OAAO,CAAC,IAAI,WAAW,OAAO,CAAC,KAAK,kCACpE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CACvD,EAAE,CACH,CAAA;QACH,CAAC;QAED,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,CAAC,GAAG,EAAE,CAAC;YAC/B,MAAM,IAAI,uBAAuB,CAC/B,iCAAiC,KAAK,CAAC,IAAI,mDAAmD,OAAO,CAAC,GAAG,EAAE,CAC5G,CAAA;QACH,CAAC;QAED,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC3B,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBACnB,MAAM,IAAI,uBAAuB,CAC/B,iFAAiF,CAClF,CAAA;YACH,CAAC;YACD,IAAI,CAAC;gBACH,KAAK,GAAG,aAAa,CAAC,KAAK,CAAe,CAAA;gBAC1C,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC,CAAA;YAC7B,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,IAAI,uBAAuB,CAC/B,2CAA2C,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CACpG,CAAA;YACH,CAAC;YACD,KAAK,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAA;YAC9D,SAAQ;QACV,CAAC;QAED,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,MAAM,IAAI,uBAAuB,CAC/B,2EAA2E,CAC5E,CAAA;QACH,CAAC;QAED,MAAM,MAAM,GAAG,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAA;QAC7C,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;YACf,uEAAuE;YACvE,wEAAwE;YACxE,iEAAiE;YACjE,KAAK,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,UAAU,EAAE,CAAC,CAAA;YACpG,SAAQ;QACV,CAAC;QACD,KAAK,GAAG,MAAM,CAAC,KAAK,CAAA;QACpB,KAAK,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAA;IAChE,CAAC;IAED,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACrC,MAAM,IAAI,uBAAuB,CAAC,qDAAqD,CAAC,CAAA;IAC1F,CAAC;IAED,MAAM,OAAO,GAAoC,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC;QAClF,CAAC,CAAE,KAAK,CAAC,MAA+C;QACxD,CAAC,CAAC,IAAI,CAAA;IAER,OAAO;QACL,KAAK;QACL,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,IAAI;QAChC,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,QAAQ,EAAE,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC;QAC7C,OAAO;QACP,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,IAAI;QAChC,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,IAAI;QAChC,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,YAAY,EAAE,KAAK,CAAC,KAAK;QACzB,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,IAAI;QACxB,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,IAAI;QAC9B,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,aAAa,EAAE,KAAK,CAAC,aAAa;QAClC,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,KAAK;KACN,CAAA;AACH,CAAC;AAgCD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAChC,UAAgC,EAChC,OAA4B;IAE5B,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,KAAK,IAAI;QACvC,CAAC,CAAC,2CAA2C;QAC7C,CAAC,CAAC,0CAA0C,UAAU,CAAC,IAAI,GAAG;YAC5D,CAAC,UAAU,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,eAAe,UAAU,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YACzE,8EAA8E,CAAA;IAElF,MAAM,QAAQ,GAAe;QAC3B,QAAQ,EAAE,QAAQ;QAClB,QAAQ,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE;QAC7B,WAAW,EAAE,UAAU,CAAC,QAAQ;QAChC,SAAS,EAAE,UAAU,CAAC,QAAQ;QAC9B,SAAS,EAAE,UAAU,CAAC,QAAQ;QAC9B,MAAM,EAAE,UAAU,CAAC,MAAM;QACzB,KAAK,EAAE,UAAU,CAAC,KAAK;QACvB,SAAS,EAAE,UAAU,CAAC,IAAI;QAC1B,aAAa,EAAE,CAAC,GAAG,UAAU,CAAC,YAAY,CAAC;QAC3C,wBAAwB,EAAE,UAAU,CAAC,IAAI;QACzC,4BAA4B,EAAE,UAAU,CAAC,OAAO;QAChD,eAAe,EAAE,QAAQ;QACzB,WAAW,EAAE,UAAU,CAAC,SAAS;QACjC,eAAe,EAAE,UAAU,CAAC,aAAa;QACzC,UAAU,EAAE,UAAU,CAAC,SAAS;QAChC,iBAAiB,EAAE,UAAU,CAAC,MAAM;QACpC,QAAQ,EAAE,UAAU,CAAC,QAAQ;QAC7B,OAAO,EAAE,UAAU,CAAC,OAAO;QAC3B,cAAc,EAAE,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YAC9C,IAAI,EAAE,IAAI,CAAC,SAAS;YACpB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG;YACtB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;YACvB,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK;YACzB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,MAAM,EAAE,IAAI,CAAC,MAAM,IAAI,IAAI;SAC5B,CAAC,CAAC;QACH,GAAG,CAAC,OAAO,CAAC,cAAc,KAAK,SAAS;YACtC,CAAC,CAAC;gBACA,kCAAkC,EAAE;oBAClC,IAAI,EAAE,OAAO,CAAC,cAAc,CAAC,IAAI;oBACjC,GAAG,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG;oBAC/B,WAAW,EAAE,OAAO,CAAC,cAAc,CAAC,UAAU;oBAC9C,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,MAAM;iBACtC;aACF;YACD,CAAC,CAAC,EAAE,CAAC;QACP,YAAY,EAAE,sDAAsD;KACrE,CAAA;IAED,MAAM,OAAO,GAAe,EAAE,QAAQ,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE,EAAE,WAAW,EAAE,UAAU,CAAC,QAAQ,EAAE,CAAA;IAC/F,OAAO,YAAY,CAAC,UAAU,EAAE;QAC9B,aAAa,EAAE,iBAAiB;QAChC,OAAO,EAAE,OAAO,CAAC,MAAM;QACvB,UAAU,EAAE,iBAAiB;QAC7B,MAAM,EAAE,EAAE,EAAE,EAAE,mCAAmC,EAAE,IAAI,EAAE,+BAA+B,EAAE;QAC1F,IAAI,EAAE,EAAE,IAAI,EAAE,+BAA+B,EAAE,OAAO,EAAE,OAAO,CAAC,WAAW,IAAI,GAAG,EAAE;QACpF,OAAO,EAAE;YACP,MAAM,EAAE,EAAE,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YAC9D,UAAU,EAAE,8CAA8C;SAC3D;QACD,QAAQ,EAAE;YACR,IAAI,EAAE,UAAU;YAChB,UAAU,EAAE,sCAAsC;YAClD,KAAK,EAAE,QAAQ;YACf,MAAM,EAAE,EAAE,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;SAChE;QACD,WAAW,EAAE,OAAO,CAAC,UAAU;QAC/B,UAAU,EAAE,OAAO,CAAC,SAAS,IAAI,IAAI;QACrC,KAAK,EAAE;YACL,QAAQ,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE;YAC7B,WAAW,EAAE,UAAU,CAAC,QAAQ;YAChC,SAAS,EAAE,UAAU,CAAC,QAAQ;YAC9B,SAAS,EAAE,UAAU,CAAC,QAAQ;SAC/B;KACF,EAAE,EAAE,OAAO,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAA;AACnE,CAAC"}

package/dist/technocore.d.ts

@@ -0,0 +1,41 @@
+import type { AgentEvidenceRecord, JsonObject, KeyInput } from './types.js';
+/** A stored Technocore signed-lane message. All fields are untrusted input. */
+export interface TechnocoreSignedMessage {
+    did: string;
+    room: string;
+    nonce: string;
+    text: string;
+    sig: string;
+}
+/**
+ * Explicit server observations accompanying a message. Keep numeric server values
+ * as strings when they might exceed JavaScript's safe-integer range.
+ */
+export interface TechnocoreEvidenceOptions {
+    runRef: string;
+    observedAt: string;
+    parents?: readonly string[];
+    expiresAt?: string | null;
+    serverMetadata?: JsonObject;
+    toolVersion?: string;
+}
+/** Mirrors Technocore's documented single-line sweep before it signs or stores text. */
+export declare function sweepTechnocoreText(text: string): string;
+/** The exact UTF-8 string verified by Technocore's signed message lane. */
+export declare function technocoreSigningInput(message: Pick<TechnocoreSignedMessage, 'room' | 'nonce' | 'text'>): Uint8Array;
+/** SHA-256 of the exact stored message text, encoded as unpadded base64url. */
+export declare function technocoreTextDigest(text: string): string;
+/** Derives the Ed25519 did:key identifier used by Technocore from a public key. */
+export declare function technocoreDidFromPublicKey(publicKey: KeyInput): string;
+/**
+ * Verifies a Technocore signed message entirely offline. A true result proves
+ * only that the embedded did:key signed this stored message, never that its text
+ * is true or safe to act on.
+ */
+export declare function verifyTechnocoreMessage(message: TechnocoreSignedMessage): boolean;
+/**
+ * Converts a verified Technocore assertion into schema-valid Agent Evidence.
+ * The embedded message remains untrusted data and uses agent-assertion trust mode.
+ */
+export declare function createTechnocoreEvidence(message: TechnocoreSignedMessage, options: TechnocoreEvidenceOptions): AgentEvidenceRecord;
+//# sourceMappingURL=technocore.d.ts.map

package/dist/technocore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"technocore.d.ts","sourceRoot":"","sources":["../src/technocore.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAY3E,+EAA+E;AAC/E,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC3B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,cAAc,CAAC,EAAE,UAAU,CAAA;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,wFAAwF;AACxF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,IAAI,CAAC,uBAAuB,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC,GAAG,UAAU,CAEpH;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,mFAAmF;AACnF,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,QAAQ,GAAG,MAAM,CAatE;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAWjF;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,yBAAyB,GACjC,mBAAmB,CAuCrB"}

package/dist/technocore.js

@@ -0,0 +1,157 @@
+import { createHash, createPublicKey, KeyObject, verify } from 'node:crypto';
+import { contentId } from './canonical.js';
+import { EvidenceValidationError } from './errors.js';
+import { createRecord } from './records.js';
+const DID_PREFIX = 'did:key:';
+const BASE58BTC_PREFIX = 'z';
+const ED25519_MULTICODEC = Buffer.from([0xed, 0x01]);
+const ED25519_SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');
+const BASE58BTC = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const ROOM = /^[a-z0-9][a-z0-9_-]{0,47}$/;
+const NONCE = /^[0-9]{1,19}$/;
+const SIGNATURE = /^[A-Za-z0-9_-]{86}$/;
+const INVISIBLE = /[\p{Cc}\p{Cf}\p{Cs}\p{Co}\p{Zl}\p{Zp}]/gu;
+/** Mirrors Technocore's documented single-line sweep before it signs or stores text. */
+export function sweepTechnocoreText(text) {
+    return text.replace(INVISIBLE, ' ').trim();
+}
+/** The exact UTF-8 string verified by Technocore's signed message lane. */
+export function technocoreSigningInput(message) {
+    return Buffer.from(`${message.room}|${message.nonce}|${message.text}`, 'utf8');
+}
+/** SHA-256 of the exact stored message text, encoded as unpadded base64url. */
+export function technocoreTextDigest(text) {
+    return createHash('sha256').update(text, 'utf8').digest('base64url');
+}
+/** Derives the Ed25519 did:key identifier used by Technocore from a public key. */
+export function technocoreDidFromPublicKey(publicKey) {
+    const key = publicKey instanceof KeyObject && publicKey.type === 'public'
+        ? publicKey
+        : createPublicKey(publicKey instanceof Uint8Array ? Buffer.from(publicKey) : publicKey);
+    const spki = key.export({ format: 'der', type: 'spki' });
+    if (!Buffer.isBuffer(spki) || spki.length !== ED25519_SPKI_PREFIX.length + 32 ||
+        !spki.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)) {
+        throw new EvidenceValidationError('Technocore requires an Ed25519 public key');
+    }
+    return `${DID_PREFIX}${BASE58BTC_PREFIX}${base58Encode(Buffer.concat([
+        ED25519_MULTICODEC,
+        spki.subarray(ED25519_SPKI_PREFIX.length),
+    ]))}`;
+}
+/**
+ * Verifies a Technocore signed message entirely offline. A true result proves
+ * only that the embedded did:key signed this stored message, never that its text
+ * is true or safe to act on.
+ */
+export function verifyTechnocoreMessage(message) {
+    try {
+        if (!ROOM.test(message.room) || !NONCE.test(message.nonce) || !SIGNATURE.test(message.sig))
+            return false;
+        if (message.text !== sweepTechnocoreText(message.text) || Array.from(message.text).length > 4096)
+            return false;
+        const signature = Buffer.from(message.sig, 'base64url');
+        if (signature.length !== 64 || signature.toString('base64url') !== message.sig)
+            return false;
+        const publicKey = publicKeyFromDid(message.did);
+        return verify(null, technocoreSigningInput(message), publicKey, signature);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Converts a verified Technocore assertion into schema-valid Agent Evidence.
+ * The embedded message remains untrusted data and uses agent-assertion trust mode.
+ */
+export function createTechnocoreEvidence(message, options) {
+    if (!verifyTechnocoreMessage(message)) {
+        throw new EvidenceValidationError('Technocore message has an invalid did:key signature or canonical form');
+    }
+    const captured = {
+        did: message.did,
+        room: message.room,
+        nonce: message.nonce,
+        text: message.text,
+        text_digest_sha256: technocoreTextDigest(message.text),
+        signature: message.sig,
+        signature_algorithm: 'ed25519',
+        signing_input: '<room>|<nonce>|<text-after-technocore-sweep>',
+        verification: 'valid-did-key-signature',
+    };
+    if (options.serverMetadata !== undefined)
+        captured.server_metadata = options.serverMetadata;
+    const request = { did: message.did, room: message.room, nonce: message.nonce };
+    return createRecord('evidence', {
+        evidence_type: 'technocore-signed-message',
+        run_ref: options.runRef,
+        trust_mode: 'agent-assertion',
+        source: { id: 'https://technocore.chat', type: 'technocore-chat' },
+        tool: { name: 'onchaindiligence-technocore-adapter', version: options.toolVersion ?? '1' },
+        request: {
+            digest: { sha256: contentId(request).slice('sha256:'.length) },
+            media_type: 'application/vnd.technocore.signed-message-request+json',
+        },
+        response: {
+            mode: 'embedded',
+            media_type: 'application/vnd.technocore.signed-message+json',
+            value: captured,
+            digest: { sha256: contentId(captured).slice('sha256:'.length) },
+        },
+        observed_at: options.observedAt,
+        expires_at: options.expiresAt ?? null,
+        scope: { did: message.did, room: message.room, nonce: message.nonce },
+    }, { parents: options.parents ?? [options.runRef] });
+}
+function publicKeyFromDid(did) {
+    if (!did.startsWith(`${DID_PREFIX}${BASE58BTC_PREFIX}`))
+        throw new EvidenceValidationError('not a base58btc did:key');
+    const decoded = base58Decode(did.slice(`${DID_PREFIX}${BASE58BTC_PREFIX}`.length));
+    if (decoded.length !== 34 || !decoded.subarray(0, 2).equals(ED25519_MULTICODEC)) {
+        throw new EvidenceValidationError('Technocore did:key is not an Ed25519 multicodec key');
+    }
+    return createPublicKey({
+        key: Buffer.concat([ED25519_SPKI_PREFIX, decoded.subarray(2)]),
+        format: 'der',
+        type: 'spki',
+    });
+}
+function base58Encode(bytes) {
+    let value = 0n;
+    for (const byte of bytes)
+        value = (value << 8n) | BigInt(byte);
+    let encoded = '';
+    while (value > 0n) {
+        const remainder = Number(value % 58n);
+        encoded = BASE58BTC[remainder] + encoded;
+        value /= 58n;
+    }
+    for (const byte of bytes) {
+        if (byte !== 0)
+            break;
+        encoded = `1${encoded}`;
+    }
+    return encoded || '1';
+}
+function base58Decode(value) {
+    if (value.length === 0)
+        throw new EvidenceValidationError('empty base58btc identifier');
+    let decoded = 0n;
+    for (const character of value) {
+        const index = BASE58BTC.indexOf(character);
+        if (index < 0)
+            throw new EvidenceValidationError('invalid base58btc identifier');
+        decoded = decoded * 58n + BigInt(index);
+    }
+    let hex = decoded.toString(16);
+    if (hex.length % 2 !== 0)
+        hex = `0${hex}`;
+    const bytes = decoded === 0n ? Buffer.alloc(0) : Buffer.from(hex, 'hex');
+    let leadingZeros = 0;
+    for (const character of value) {
+        if (character !== '1')
+            break;
+        leadingZeros += 1;
+    }
+    return Buffer.concat([Buffer.alloc(leadingZeros), bytes]);
+}
+//# sourceMappingURL=technocore.js.map

package/dist/technocore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"technocore.js","sourceRoot":"","sources":["../src/technocore.ts"],"names":[],"mappings":"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"}

package/examples/tclk-evidence.mjs

@@ -0,0 +1,130 @@
+import { generateKeyPairSync, sign } from 'node:crypto'
+import { encodeFrame, generateHashLock, makeAccept, makeOffer } from '@flop-labs/tclk'
+import {
+  createBundlePayload,
+  createEd25519Signer,
+  createKeyRecord,
+  createRecord,
+  createTclkEvidence,
+  createTechnocoreEvidence,
+  contentId,
+  sealBundle,
+  sweepTechnocoreText,
+  technocoreDidFromPublicKey,
+  technocoreSigningInput,
+  TrustPolicy,
+  verifyBundle,
+  verifyTclkTranscript,
+} from '@onchaindiligence/agent-evidence'
+
+// This is an offline example: no real money, no real Technocore room, no
+// PTLC/adaptor-signature material (SAFE hash-lock path only). It shows the
+// generic shape a real integration follows: two agents coordinate a deal as
+// signed tclk/1 frames, OnChainDiligence captures the verified transcript as
+// Agent Evidence, and — because no real settlement rail is wired up here — the
+// resulting execution record says so honestly rather than claiming a payment
+// happened.
+const ROOM = 'tclk-offers'
+function frameMessage(privateKey, did, nonce, frame) {
+  const text = sweepTechnocoreText(encodeFrame(frame))
+  const sig = sign(null, technocoreSigningInput({ room: ROOM, nonce, text }), privateKey).toString('base64url')
+  return { did, room: ROOM, nonce, text, sig }
+}
+
+const payerKey = generateKeyPairSync('ed25519')
+const payeeKey = generateKeyPairSync('ed25519')
+const payerDid = technocoreDidFromPublicKey(payerKey.publicKey)
+const payeeDid = technocoreDidFromPublicKey(payeeKey.publicKey)
+
+const nowMs = Date.parse('2026-09-02T12:00:00.000Z')
+const claimByMs = nowMs + 60 * 60 * 1000
+const refundAfterMs = claimByMs + 60 * 60 * 1000
+const expiresMs = nowMs + 30 * 60 * 1000
+
+// offer -> accept -> lock announcement -> reveal (hash-lock path only).
+const offer = makeOffer({
+  from: payerDid, role: 'payer', amount: '1000000', asset: 'FLOP', lock: 'hash',
+  rails: ['flop-htlc'], claimByMs, refundAfterMs, expiresMs,
+})
+const hashLock = generateHashLock()
+const accept = makeAccept(offer, { from: payeeDid, statement: hashLock.hash })
+const lock = { type: 'lock', from: payerDid, contract: accept.contract, rail: 'flop-htlc', ref: 'paper-escrow-1' }
+const reveal = { type: 'reveal', from: payeeDid, contract: accept.contract, secret: hashLock.preimage }
+
+const offerMsg = frameMessage(payerKey.privateKey, payerDid, '1756814400001', offer)
+const acceptMsg = frameMessage(payeeKey.privateKey, payeeDid, '1756814400002', accept)
+const lockMsg = frameMessage(payerKey.privateKey, payerDid, '1756814400003', lock)
+const revealMsg = frameMessage(payeeKey.privateKey, payeeDid, '1756814400004', reveal)
+
+// Verify: transport signature + tclk frame validity + sender attribution +
+// official state-machine replay, each independently.
+const transcript = verifyTclkTranscript([
+  { message: offerMsg, atMs: nowMs },
+  { message: acceptMsg, atMs: nowMs },
+  { message: lockMsg, atMs: nowMs },
+  { message: revealMsg, atMs: claimByMs - 1000 },
+])
+
+const bundleKey = generateKeyPairSync('ed25519')
+const key = createKeyRecord(bundleKey.publicKey, { validFrom: '2026-09-01T00:00:00.000Z' })
+const principal = createRecord('principal', { principal_id: 'urn:example:ocd', principal_type: 'organization' })
+const agent = createRecord('agent', {
+  agent_id: 'urn:example:ocd-tclk-agent', agent_version: '1', operator_ref: principal.id,
+}, { parents: [principal.id] })
+const mandate = createRecord('mandate', {
+  mandate_id: 'tclk-coordination-capture', principal_ref: principal.id, scope: { action: 'record-only' },
+  valid_from: '2026-09-01T00:00:00.000Z', valid_until: '2026-09-03T00:00:00.000Z',
+}, { parents: [principal.id] })
+const run = createRecord('run', {
+  run_external_id: 'tclk-example', agent_ref: agent.id, mandate_ref: mandate.id,
+  started_at: '2026-09-02T12:00:00.000Z',
+}, { parents: [agent.id, mandate.id] })
+
+// One Technocore evidence record per underlying signed message (reusing the
+// existing Technocore adapter, not a second implementation of it) ...
+const messageEvidence = [offerMsg, acceptMsg, lockMsg, revealMsg].map((message, i) =>
+  createTechnocoreEvidence(message, { runRef: run.id, observedAt: `2026-09-02T12:0${i}:00.000Z` }))
+// ... plus one tclk-transcript evidence record summarizing the verified replay.
+const tclkEvidence = createTclkEvidence(transcript, {
+  runRef: run.id, observedAt: '2026-09-02T12:05:00.000Z',
+  messageEvidenceRefs: messageEvidence.map((e) => e.id),
+})
+
+const policyDocument = { action: 'accept-coordination-evidence-only', require_real_rail_for_settlement_claim: true }
+const policy = createRecord('policy', {
+  policy_id: 'tclk-coordination-capture', version: '1', source: 'https://example.invalid/policy/tclk',
+  digest: { sha256: contentId(policyDocument).slice('sha256:'.length) },
+  effective_from: '2026-09-01T00:00:00.000Z', policy: policyDocument,
+}, { parents: [run.id] })
+
+const evidenceRefs = [...messageEvidence.map((e) => e.id), tclkEvidence.id]
+const decision = createRecord('decision', {
+  decision_id: 'accept-tclk-coordination-evidence', run_ref: run.id, agent_ref: agent.id,
+  decision_type: 'tclk-transcript-review',
+  outcome: {
+    disposition: 'ACCEPT_COORDINATION_EVIDENCE',
+    authorized_to_execute: false,
+    reason: 'valid signed coordination is evidence of what the agents agreed/asserted, not proof of settlement',
+  },
+  evidence_refs: evidenceRefs,
+  policy_ref: policy.id, policy_digest: policy.statement.digest,
+  decided_at: '2026-09-02T12:06:00.000Z',
+}, { parents: [run.id, policy.id, ...evidenceRefs] })
+
+// PaperRail-equivalent here: no real rail is wired up, so execution must say so.
+const execution = createRecord('execution', {
+  execution_id: 'no-real-value-settlement', decision_ref: decision.id, execution_type: 'no-external-action',
+  status: 'NO_REAL_VALUE_SETTLEMENT', submitted_at: '2026-09-02T12:06:01.000Z',
+}, { parents: [decision.id] })
+
+const payload = createBundlePayload(
+  [principal, agent, mandate, run, ...messageEvidence, tclkEvidence, policy, decision, execution],
+  { createdAt: '2026-09-02T12:07:00.000Z' },
+)
+const bundle = await sealBundle(payload, createEd25519Signer(bundleKey.privateKey), { keys: [key] })
+const report = verifyBundle(bundle, TrustPolicy.fromKeyRecords([key], { now: new Date('2026-09-02T12:08:00.000Z') }))
+
+console.log(report.state, payload.bundle_id)
+console.log('decision:', decision.statement.outcome.disposition)
+console.log('execution:', execution.statement.status)
+console.log('tclk transcript status:', transcript.status, '(terminal:', transcript.terminal + ')')

package/examples/technocore-evidence.mjs

@@ -0,0 +1,69 @@
+import { generateKeyPairSync, sign } from 'node:crypto'
+import {
+  createBundlePayload,
+  createEd25519Signer,
+  createKeyRecord,
+  createRecord,
+  createTechnocoreEvidence,
+  contentId,
+  sealBundle,
+  sweepTechnocoreText,
+  technocoreDidFromPublicKey,
+  technocoreSigningInput,
+  TrustPolicy,
+  verifyBundle,
+} from '@onchaindiligence/agent-evidence'
+
+// This is an offline example. It never reads a room, follows message content,
+// or sends a transaction. A real adapter caller passes the exact stored message
+// returned by Technocore's JSON API and may retain server metadata alongside it.
+const technocoreKey = generateKeyPairSync('ed25519')
+const text = sweepTechnocoreText('A did:key signature establishes an assertion, not truth.')
+const message = {
+  did: technocoreDidFromPublicKey(technocoreKey.publicKey),
+  room: 'ocd-evidence',
+  nonce: '1740000000001',
+  text,
+  sig: sign(null, technocoreSigningInput({ room: 'ocd-evidence', nonce: '1740000000001', text }), technocoreKey.privateKey)
+    .toString('base64url'),
+}
+const bundleKey = generateKeyPairSync('ed25519')
+const key = createKeyRecord(bundleKey.publicKey, { validFrom: '2026-09-01T00:00:00.000Z' })
+const principal = createRecord('principal', { principal_id: 'urn:example:ocd', principal_type: 'organization' })
+const agent = createRecord('agent', {
+  agent_id: 'urn:example:ocd-technocore-agent', agent_version: '1', operator_ref: principal.id,
+}, { parents: [principal.id] })
+const mandate = createRecord('mandate', {
+  mandate_id: 'technocore-capture', principal_ref: principal.id, scope: { action: 'record-only' },
+  valid_from: '2026-09-01T00:00:00.000Z', valid_until: '2026-09-02T00:00:00.000Z',
+}, { parents: [principal.id] })
+const run = createRecord('run', {
+  run_external_id: 'technocore-example', agent_ref: agent.id, mandate_ref: mandate.id,
+  started_at: '2026-09-01T12:00:00.000Z',
+}, { parents: [agent.id, mandate.id] })
+const evidence = createTechnocoreEvidence(message, {
+  runRef: run.id, observedAt: '2026-09-01T12:00:01.000Z',
+  serverMetadata: { seq: '1', ts: '2026-09-01T12:00:01.123456Z' },
+})
+const policyDocument = { action: 'never-execute-from-technocore-content', require_signature: true }
+const policy = createRecord('policy', {
+  policy_id: 'technocore-ingestion', version: '1', source: 'https://example.invalid/policy/technocore',
+  digest: { sha256: contentId(policyDocument).slice('sha256:'.length) },
+  effective_from: '2026-09-01T00:00:00.000Z', policy: policyDocument,
+}, { parents: [run.id] })
+const decision = createRecord('decision', {
+  decision_id: 'record-no-action', run_ref: run.id, agent_ref: agent.id, decision_type: 'technocore-message-review',
+  outcome: { execute: false, reason: 'signed assertion is not authorization or truth' }, evidence_refs: [evidence.id],
+  policy_ref: policy.id, policy_digest: policy.statement.digest, decided_at: '2026-09-01T12:00:02.000Z',
+}, { parents: [run.id, evidence.id, policy.id] })
+const execution = createRecord('execution', {
+  execution_id: 'non-execution', decision_ref: decision.id, execution_type: 'no-external-action',
+  status: 'withheld-not-submitted', submitted_at: '2026-09-01T12:00:03.000Z',
+}, { parents: [decision.id] })
+const payload = createBundlePayload(
+  [principal, agent, mandate, run, evidence, policy, decision, execution],
+  { createdAt: '2026-09-01T12:00:04.000Z' },
+)
+const bundle = await sealBundle(payload, createEd25519Signer(bundleKey.privateKey), { keys: [key] })
+const report = verifyBundle(bundle, TrustPolicy.fromKeyRecords([key], { now: new Date('2026-09-01T12:01:00.000Z') }))
+console.log(report.state, payload.bundle_id, execution.statement.status)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onchaindiligence/agent-evidence",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Deterministic Agent Evidence v0 construction, DSSE sealing, and offline tri-state verification for Node.js",
   "type": "module",
   "main": "./dist/index.js",
@@ -51,6 +51,7 @@
     "node": ">=20.19"
   },
   "dependencies": {
+    "@flop-labs/tclk": "^0.1.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1"
   },

package/schemas/agent-evidence-key-registry.schema.json

@@ -0,0 +1,74 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://onchaindiligence.com/schemas/agent-evidence/v0/agent-evidence-key-registry.schema.json",
+  "title": "Agent Evidence Interoperability Profile v1 — public signer key registry",
+  "description": "The recommended shape for GET /.well-known/agent-evidence-keys, as defined by docs/AGENT_EVIDENCE_INTEROP.md. This registry is public metadata: an issuer's own signer key_id, public key, and lifecycle -- never a private key. Hosting this endpoint is a discovery convenience only; it does not by itself make an issuer trustworthy, and a verifier's caller-supplied TrustPolicy remains the sole source of trust.",
+  "type": "object",
+  "required": ["schema_version", "issuer", "environment", "keys"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "issuer": { "$ref": "common.schema.json#/$defs/nonEmptyString" },
+    "environment": { "$ref": "common.schema.json#/$defs/nonEmptyString" },
+    "keys": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/keyEntry" },
+      "maxItems": 256
+    }
+  },
+  "additionalProperties": false,
+  "$defs": {
+    "keyEntry": {
+      "type": "object",
+      "title": "One published signer key. key_id alone never establishes trust, and this record is a hint until a caller's TrustPolicy independently trusts it.",
+      "required": ["key_id", "algorithm", "public_key_pem", "valid_from", "valid_until", "revoked_at", "status"],
+      "properties": {
+        "key_id": {
+          "type": "string",
+          "pattern": "^ed25519-[A-Za-z0-9_-]{16}$",
+          "description": "Self-certifying: derived as ed25519-<first 16 base64url chars of sha256(SPKI DER)>, the same convention Agent Evidence's own AttestationKey uses. A verifier SHOULD re-derive and reject a mismatch."
+        },
+        "algorithm": { "const": "Ed25519" },
+        "public_key_pem": {
+          "type": "string",
+          "pattern": "^-----BEGIN PUBLIC KEY-----\\n[A-Za-z0-9+/=\\n]+-----END PUBLIC KEY-----\\n?$",
+          "maxLength": 4096
+        },
+        "valid_from": {
+          "anyOf": [
+            { "$ref": "common.schema.json#/$defs/timestamp" },
+            { "type": "null" }
+          ],
+          "description": "null means no defensible activation boundary is published; a verifier must then treat the key as UNVERIFIABLE, never VALID."
+        },
+        "valid_until": {
+          "anyOf": [
+            { "$ref": "common.schema.json#/$defs/timestamp" },
+            { "type": "null" }
+          ]
+        },
+        "revoked_at": {
+          "anyOf": [
+            { "$ref": "common.schema.json#/$defs/timestamp" },
+            { "type": "null" }
+          ]
+        },
+        "status": { "enum": ["active", "retired", "revoked", "compromised"] }
+      },
+      "additionalProperties": false,
+      "allOf": [
+        {
+          "if": {
+            "type": "object",
+            "properties": { "status": { "enum": ["revoked", "compromised"] } },
+            "required": ["status"]
+          },
+          "then": {
+            "type": "object",
+            "required": ["revoked_at"],
+            "properties": { "revoked_at": { "$ref": "common.schema.json#/$defs/timestamp" } }
+          }
+        }
+      ]
+    }
+  }
+}

package/schemas/catalog.json

@@ -8,13 +8,15 @@
     "proof.schema.json",
     "record.schema.json",
     "bundle-payload.schema.json",
-    "portable-file.schema.json"
+    "portable-file.schema.json",
+    "agent-evidence-key-registry.schema.json"
   ],
   "entry_points": {
     "portable_file": "portable-file.schema.json",
     "signed_payload": "bundle-payload.schema.json",
     "record": "record.schema.json",
     "proof": "proof.schema.json",
-    "trusted_key_record": "attestation-key.schema.json"
+    "trusted_key_record": "attestation-key.schema.json",
+    "agent_evidence_key_registry": "agent-evidence-key-registry.schema.json"
   }
 }