@agenticprimitives/audit 0.1.0-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Agentic Trust Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @agenticprimitives/audit
+
+Append-only audit-event schema + sink interface for the agentic primitives stack. Transport-agnostic primitive — consumers wire concrete persistent sinks (D1, Postgres, Cloud Logging, SIEM) behind a single interface.
+
+Closes system-audit finding **C3** (forensic trail) from `docs/architecture/product-readiness-audit.md`.
+
+See [`spec.md`](./spec.md) → [`specs/206-audit.md`](../../specs/206-audit.md).
+
+## Quick start
+
+```ts
+import {
+  buildEvent,
+  createConsoleAuditSink,
+  composeSinks,
+  type AuditSink,
+} from '@agenticprimitives/audit';
+
+const sink: AuditSink = composeSinks(
+  createConsoleAuditSink({ prefix: '[AUDIT]' }),
+  // ...add a persistent sink from your app layer (D1, Postgres, etc.)
+);
+
+await sink.write(
+  buildEvent({
+    action: 'delegation.verify.accept',
+    outcome: 'success',
+    actor:   { type: 'agent', id: 'demo-a2a' },
+    subject: { type: 'jti', id: claims.jti },
+    audience: claims.aud,
+    correlationId,
+  }),
+);
+```
+
+## Boundaries
+
+- Ships **in-band sinks only** (console + memory + composeSinks). Concrete persistent sinks (D1, Postgres, Cloud Logging) live in consumer apps.
+- Sits at the **base of the dep graph** alongside `@agenticprimitives/types`. Forbidden from importing connect-auth / agent-account / delegation / key-custody / tool-policy / mcp-runtime — those import us.
+
+## Invariants
+
+- **No secret material in events.** Emitters hash sessionIds, omit raw keys / tokens. `createPiiGuardrailSink` (v0.1) is defense-in-depth.
+- **Append-only by interface.** `AuditSink` has `write` only — no `delete` / `update`. Persistent sinks must enforce at the schema level.
+- **Fail-soft for the trail.** Emit failures never throw to the caller. The decision (verify, sign) is the security boundary.
+
+## Status
+
+Pre-alpha. Schema versioned (`schemaVersion: 1`); bumps are major.

package/dist/index.d.ts

@@ -0,0 +1,347 @@
+/**
+ * @agenticprimitives/audit — append-only audit/forensics primitives.
+ *
+ * Owns:
+ *  - The canonical `AuditEvent` schema every other package emits.
+ *  - The `AuditSink` interface a consumer implements (or composes from
+ *    one of the provided sinks).
+ *  - In-band sinks: `createConsoleAuditSink`, `createMemoryAuditSink`.
+ *
+ * Does NOT own:
+ *  - Concrete persistence backends (D1 / Cloud Logging / Splunk / etc.).
+ *    Those live with the consumer that needs them.
+ *  - Domain semantics — `action` is a free-string the emitter chooses
+ *    (e.g. `<package>.<surface>.<outcome>`).
+ *
+ * Doctrine (per CLAUDE.md): zero domain knowledge. The schema is
+ * deliberately structural — every package's emitter knows what to put
+ * in `subject` / `context`; this package only stamps the shape.
+ *
+ * Closes system audit finding C3.
+ */
+import type { Hex } from '@agenticprimitives/types';
+/**
+ * One audit event. Designed to be JSON-serialisable for sinks that
+ * persist or forward over HTTP. All fields are strings or numbers so
+ * the on-wire shape matches the in-memory shape with no codec needed.
+ *
+ * `id` is per-event (UUID-ish); `correlationId` ties multiple events
+ * to a single request / flow / session.
+ */
+/**
+ * H7-F.2 / PKG-audit-002 / EXT-037 closure — canonical action registry.
+ *
+ * Free-string `action` previously let each emitter pick its own name
+ * with no central catalog — drift hazard the moment more than one
+ * package emits the same conceptual event. The registry below is the
+ * canonical list. `action: AuditAction` keeps the string convention
+ * (still indexes cleanly in structured-log backends) but type-checks
+ * the caller against the registry.
+ *
+ * Convention: `<package>.<surface>.<outcome?>`.
+ *
+ * Each emitting package documents WHICH of these names IT emits in
+ * its `AUDIT.md` "Audit events emitted" section.
+ *
+ * To add a new action:
+ *   1. Add the string to `AUDIT_ACTION_REGISTRY` (below).
+ *   2. Add it to the owning package's `AUDIT.md` list.
+ *   3. The TypeScript union `AuditAction` is derived automatically.
+ *
+ * `action` STILL accepts a raw `string` (the legacy escape hatch) so a
+ * package can ship a one-off event without churn. Production paths
+ * should use the typed name + extend the registry.
+ */
+export declare const AUDIT_ACTION_REGISTRY: readonly ["delegation.mint", "delegation.verify.accept", "delegation.verify.reject", "delegation.revoke", "key-custody.sign", "key-custody.rotate", "key-custody.envelope.encrypt", "key-custody.envelope.decrypt", "key-custody.session-data-key.generate", "account-custody.schedule", "account-custody.apply", "account-custody.cancel", "account-custody.credential.add", "account-custody.credential.remove", "account-custody.credential.replace", "agent-account.admin.propose", "agent-account.admin.execute", "agent-account.admin.cancel", "connect-auth.session.mint", "connect-auth.session.verify.accept", "connect-auth.session.verify.reject", "connect.issue.accept", "connect.issue.reject", "mcp-runtime.with-delegation.accept", "mcp-runtime.with-delegation.reject", "mcp-runtime.service-mac.issue", "mcp-runtime.service-mac.accept", "mcp-runtime.service-mac.reject", "agent-naming.resolve", "agent-naming.register", "agent-naming.records.update", "agent-naming.primary-name.update", "agent-naming.subregistry.update"];
+export type AuditAction = (typeof AUDIT_ACTION_REGISTRY)[number];
+/** Type guard for callers that need to validate an arbitrary string. */
+export declare function isCanonicalAuditAction(s: string): s is AuditAction;
+export interface AuditEvent {
+    /** Per-event unique ID. UUID v4 (or v7 if you have it) recommended. */
+    id: string;
+    /** Ties events from the same browser request / job / pipeline. */
+    correlationId?: string;
+    /** ISO-8601 timestamp (UTC). */
+    timestamp: string;
+    /**
+     * Dotted action name. Prefer {@link AuditAction} from the canonical
+     * {@link AUDIT_ACTION_REGISTRY}; raw `string` remains accepted for
+     * legacy callers + one-off events. Convention:
+     * `<package>.<surface>.<outcome?>`. Each emitting package documents
+     * its actions in its `AUDIT.md` under "Audit events emitted".
+     */
+    action: AuditAction | (string & {});
+    /**
+     * Outcome class. `success` for normal operations, `denied` for
+     * authority/policy rejects (NOT errors — denial IS a security
+     * outcome that must be auditable), `error` for unexpected failures.
+     */
+    outcome: 'success' | 'denied' | 'error';
+    /**
+     * Who initiated. Use stable identifiers — smart-account address,
+     * service identity (`a2a-to-mcp`), system label (`bundler`, etc.).
+     */
+    actor?: {
+        type: 'user' | 'service' | 'system' | 'unknown';
+        /** Smart-account address, service name, or system label. */
+        id?: string;
+    };
+    /**
+     * What was acted on. Free-form `type` discriminator + opaque `id` —
+     * consumers choose conventions like `tool`/`session`/`tx`/etc. The
+     * audit package deliberately does not enumerate types because that
+     * would couple it to domain vocabulary.
+     */
+    subject?: {
+        type: string;
+        id: string;
+    };
+    /** Human-readable + structured reason for non-success outcomes. */
+    reason?: string;
+    /**
+     * Free-form additional structured context. Keep keys flat (no nested
+     * objects) so structured-log backends (Cloud Logging, Datadog) index
+     * cleanly.
+     */
+    context?: Record<string, string | number | boolean | null>;
+    /** Audience / route for service-to-service events. */
+    audience?: string;
+    /** Chain ID for on-chain events. */
+    chainId?: number;
+    /** On-chain tx / digest, when relevant. */
+    digest?: Hex;
+}
+/**
+ * The minimal contract every audit sink implements. `write` is async
+ * because the most useful sinks are persistent (D1, HTTP, etc.); even
+ * in-memory sinks return a resolved promise for shape symmetry.
+ *
+ * Sinks MUST be append-only — events never edited or deleted. The
+ * sink's persistence backend (D1 schema, log retention, etc.) should
+ * enforce this, but the interface assumes it.
+ *
+ * Sinks SHOULD be fail-soft: an audit-emission failure should NOT
+ * propagate as a request failure. Instead, log the failure to a
+ * fallback channel (the in-band console). Implementations decide
+ * how to handle the rare double-failure.
+ */
+export interface AuditSink {
+    /** Emit one event. Resolves on durable acceptance; rejects only on
+     *  programmer error (malformed event), never on transient backend
+     *  failure (those are absorbed inside the sink). */
+    write(event: AuditEvent): Promise<void>;
+}
+/**
+ * Emit events as one-line JSON to `console.log`. Suitable for
+ * Cloudflare Workers (where `wrangler tail` surfaces console output)
+ * and for local dev. Production deploys typically PAIR this with a
+ * durable sink — see `composeSinks` below.
+ */
+export declare function createConsoleAuditSink(opts?: {
+    /** Prefix used to filter the audit events out of regular logs.
+     *  Default: `'[AUDIT]'`. */
+    prefix?: string;
+}): AuditSink;
+/**
+ * In-memory ring buffer. **Test-only.** Production sinks must be
+ * durable; this is for unit tests + the demo's recent-events UI.
+ */
+export interface MemoryAuditSink extends AuditSink {
+    /** Read out the captured events (oldest first). */
+    events(): AuditEvent[];
+    /** Clear the buffer. */
+    reset(): void;
+}
+export declare function createMemoryAuditSink(opts?: {
+    /** Maximum events retained; older events discarded FIFO. Default 1024. */
+    capacity?: number;
+}): MemoryAuditSink;
+/**
+ * Combine multiple sinks into one with **fail-soft** semantics — each
+ * emit fans out to all sinks sequentially; a failure in one sink does NOT
+ * short-circuit the others, AND does NOT propagate to the caller. The
+ * caller's `await write(event)` always resolves successfully, even if every
+ * sink failed. Best for telemetry / metrics-grade events where dropping
+ * one event is acceptable.
+ *
+ * **H7-B.7 / PKG-AUDIT-001 closure** — security-critical events (authority
+ * changes, custody operations, signing-side actions) need durable-before-
+ * commit semantics; use {@link composeFailHardSinks} for those. The
+ * audit package stays domain-agnostic — emitting packages document which
+ * of their action names belong to the fail-hard class in their own docs.
+ *
+ * Production wiring is typically `composeSinks(d1Sink, consoleSink)` for
+ * non-critical events, and `composeFailHardSinks(d1Sink)` for events that
+ * MUST be persisted before the action commits.
+ */
+export declare function composeSinks(...sinks: AuditSink[]): AuditSink;
+/** Explicit alias of {@link composeSinks} — fail-soft, no propagation. */
+export declare function composeFailSoftSinks(...sinks: AuditSink[]): AuditSink;
+/**
+ * H7-B.7 — Combine multiple sinks with **fail-hard** semantics for
+ * security-critical events. The first sink failure THROWS the original
+ * error (after the remaining sinks have been attempted — every sink still
+ * gets a chance to record, but the caller's `await write(event)` rejects
+ * if any failed).
+ *
+ * Use for events whose absence from durable storage would be a security
+ * regression — the precise action vocabulary is each emitting package's
+ * responsibility to document. The caller's flow MUST treat a thrown audit
+ * as the action FAILING — do not commit the on-chain or off-chain effect
+ * if the audit didn't persist.
+ *
+ * Closure: PKG-AUDIT-001 / EXT-022 / CT-11.
+ */
+export declare function composeFailHardSinks(...sinks: AuditSink[]): AuditSink;
+export interface MetricsSink {
+    /**
+     * Increment a monotonic counter. `value` defaults to 1.
+     * Typical use: request count, error count, retry count.
+     */
+    increment(name: string, value?: number, tags?: Record<string, string>): void;
+    /**
+     * Record a single observation in a histogram / distribution.
+     * Typical use: latency, payload size, response bytes.
+     */
+    observe(name: string, value: number, tags?: Record<string, string>): void;
+    /**
+     * Set a gauge — a value that can go up or down. The latest value wins.
+     * Typical use: queue depth, in-flight session count, active connections.
+     */
+    gauge(name: string, value: number, tags?: Record<string, string>): void;
+}
+/**
+ * No-op sink. The default when consumers haven't wired metrics yet —
+ * runtime always succeeds, never observably affects throughput.
+ */
+export declare const noopMetricsSink: MetricsSink;
+/**
+ * Console-out metrics sink for local dev. NOT a production sink — the
+ * volume in production overwhelms console output and provides no
+ * aggregation. Production wires `composeMetricsSinks(prometheusSink, …)`.
+ */
+export declare function createConsoleMetricsSink(opts?: {
+    prefix?: string;
+}): MetricsSink;
+/**
+ * Fan-out to multiple metrics sinks. Same fail-soft semantics as
+ * `composeSinks` for audit: a failure in one sink doesn't short-circuit
+ * the others. Metrics emissions are synchronous + must never block
+ * the request path; sinks that need async work MUST queue internally.
+ */
+export declare function composeMetricsSinks(...sinks: MetricsSink[]): MetricsSink;
+/**
+ * In-memory metrics sink for test assertions. Counts + histograms +
+ * gauges are captured in plain Maps; `.snapshot()` returns the
+ * accumulated state for assertions. NOT a production sink.
+ */
+export interface MemoryMetricsSink extends MetricsSink {
+    snapshot(): {
+        counts: Map<string, number>;
+        observations: Map<string, number[]>;
+        gauges: Map<string, number>;
+    };
+    reset(): void;
+}
+export declare function createMemoryMetricsSink(): MemoryMetricsSink;
+/**
+ * One detected probable-leak. Reported to `onDetect` and embedded in
+ * the redacted event's `_pii` context field so reviewers can trace
+ * where the leak came from without seeing the value.
+ */
+export interface PiiFinding {
+    /** Dotted path within the event (e.g. `context.token`, `subject.id`, `reason`). */
+    path: string;
+    /** Why we flagged it (`long-hex`, `jwt-shape`, `pem-block`, `secret-substring`). */
+    reason: string;
+    /** Safe descriptor of the original value (e.g. `hex-130`, `jwt-3-seg`). */
+    preview: string;
+}
+export interface PiiGuardrailOpts {
+    /**
+     * What to do on detection.
+     * - `'redact'` (default): replace the offending value in-place with a
+     *   safe descriptor (`<redacted:<reason>:<preview>>`); forward the
+     *   sanitized event to the inner sink. Preserves forensics minus the
+     *   leaked field.
+     * - `'drop'`: do NOT forward the event at all. Strictest setting;
+     *   loses the row from the trail entirely.
+     * - `'warn'`: forward unchanged, just notify via `onDetect`. Useful
+     *   during initial roll-out so reviewers see what would be flagged
+     *   before enforcement kicks in.
+     */
+    mode?: 'redact' | 'drop' | 'warn';
+    /**
+     * Maximum hex string length (chars, including any `0x` prefix) tolerated
+     * in non-allowlisted positions. Default 80 — leaves Ethereum addresses
+     * (42), keccak/sha256 digests (66), and tx hashes (66) all comfortably
+     * below the threshold while catching raw private keys (130) and longer
+     * session secrets.
+     */
+    maxHexLength?: number;
+    /**
+     * `context` keys (and well-known top-level fields) where long hex is
+     * legitimately expected. Merged with the built-in safe set
+     * (`signerAddress`, `address`, `paymaster`, `entryPoint`, `keyId`,
+     * `nonceHash`, `sessionHash`, `digest`, `txHash`, `blockHash`, `jti`,
+     * `eventId`).
+     */
+    allowKeys?: string[];
+    /**
+     * `subject.type` values whose `subject.id` is allowed to be any length
+     * of hex (e.g. `sign-digest` carries a 32-byte digest). Merged with
+     * the built-in safe set (`jti`, `sign-digest`, `tx-hash`, `address`,
+     * `event-id`).
+     */
+    allowSubjectTypes?: string[];
+    /**
+     * Callback invoked on every detection, regardless of `mode`. The
+     * sanitized event (or original, in `warn` mode) is passed alongside
+     * the findings. Useful for routing a "guardrail caught a leak" signal
+     * to a separate alerting channel.
+     */
+    onDetect?: (info: {
+        event: AuditEvent;
+        findings: PiiFinding[];
+    }) => void;
+}
+/**
+ * Wrapper sink that scans event payloads for likely-secret material and
+ * either redacts / drops / warns before forwarding to `inner`. **This is
+ * defense-in-depth**, not a substitute for the emitter discipline rule
+ * "MUST hash or omit raw secrets" (per the audit package CLAUDE.md
+ * invariant). It catches accidental leaks at the sink boundary.
+ *
+ * Production wiring example:
+ * ```ts
+ * const sink = composeSinks(
+ *   createConsoleAuditSink({ prefix: '[AUDIT]' }),
+ *   createPiiGuardrailSink(createD1AuditSink(env.DB), { mode: 'redact' }),
+ * );
+ * ```
+ *
+ * The guardrail's own decisions are not themselves audit events — they
+ * surface through `onDetect`. Use that to wire alerts ("found a leak in
+ * action=X") if you want them in your own metrics pipeline.
+ */
+export declare function createPiiGuardrailSink(inner: AuditSink, opts?: PiiGuardrailOpts): AuditSink;
+/**
+ * Generate a UUID-shaped event ID. Uses Web Crypto when available
+ * (Workers, modern Node); falls back to a deterministic ordering for
+ * legacy Node (warning: NOT cryptographically random — tests + dev only).
+ */
+export declare function generateEventId(): string;
+/** Convenience: produce an ISO-8601 UTC timestamp. */
+export declare function nowIso(): string;
+/**
+ * Build an `AuditEvent` with sane defaults. Saves callers from
+ * repeatedly writing `id: generateEventId(), timestamp: nowIso()`.
+ *
+ * Required: `action`, `outcome`. Everything else optional + spreads
+ * through.
+ */
+export declare function buildEvent(partial: Omit<AuditEvent, 'id' | 'timestamp'> & {
+    id?: string;
+    timestamp?: string;
+}): AuditEvent;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -0,0 +1,496 @@
+/**
+ * @agenticprimitives/audit — append-only audit/forensics primitives.
+ *
+ * Owns:
+ *  - The canonical `AuditEvent` schema every other package emits.
+ *  - The `AuditSink` interface a consumer implements (or composes from
+ *    one of the provided sinks).
+ *  - In-band sinks: `createConsoleAuditSink`, `createMemoryAuditSink`.
+ *
+ * Does NOT own:
+ *  - Concrete persistence backends (D1 / Cloud Logging / Splunk / etc.).
+ *    Those live with the consumer that needs them.
+ *  - Domain semantics — `action` is a free-string the emitter chooses
+ *    (e.g. `<package>.<surface>.<outcome>`).
+ *
+ * Doctrine (per CLAUDE.md): zero domain knowledge. The schema is
+ * deliberately structural — every package's emitter knows what to put
+ * in `subject` / `context`; this package only stamps the shape.
+ *
+ * Closes system audit finding C3.
+ */
+// ─── Event schema ─────────────────────────────────────────────────────
+/**
+ * One audit event. Designed to be JSON-serialisable for sinks that
+ * persist or forward over HTTP. All fields are strings or numbers so
+ * the on-wire shape matches the in-memory shape with no codec needed.
+ *
+ * `id` is per-event (UUID-ish); `correlationId` ties multiple events
+ * to a single request / flow / session.
+ */
+/**
+ * H7-F.2 / PKG-audit-002 / EXT-037 closure — canonical action registry.
+ *
+ * Free-string `action` previously let each emitter pick its own name
+ * with no central catalog — drift hazard the moment more than one
+ * package emits the same conceptual event. The registry below is the
+ * canonical list. `action: AuditAction` keeps the string convention
+ * (still indexes cleanly in structured-log backends) but type-checks
+ * the caller against the registry.
+ *
+ * Convention: `<package>.<surface>.<outcome?>`.
+ *
+ * Each emitting package documents WHICH of these names IT emits in
+ * its `AUDIT.md` "Audit events emitted" section.
+ *
+ * To add a new action:
+ *   1. Add the string to `AUDIT_ACTION_REGISTRY` (below).
+ *   2. Add it to the owning package's `AUDIT.md` list.
+ *   3. The TypeScript union `AuditAction` is derived automatically.
+ *
+ * `action` STILL accepts a raw `string` (the legacy escape hatch) so a
+ * package can ship a one-off event without churn. Production paths
+ * should use the typed name + extend the registry.
+ */
+export const AUDIT_ACTION_REGISTRY = [
+    // ─── delegation (spec 202)
+    'delegation.mint',
+    'delegation.verify.accept',
+    'delegation.verify.reject',
+    'delegation.revoke',
+    // ─── key-custody (spec 203)
+    'key-custody.sign',
+    'key-custody.rotate',
+    'key-custody.envelope.encrypt',
+    'key-custody.envelope.decrypt',
+    'key-custody.session-data-key.generate',
+    // ─── account-custody (spec 213)
+    'account-custody.schedule',
+    'account-custody.apply',
+    'account-custody.cancel',
+    'account-custody.credential.add',
+    'account-custody.credential.remove',
+    'account-custody.credential.replace',
+    // ─── agent-account (spec 201)
+    'agent-account.admin.propose',
+    'agent-account.admin.execute',
+    'agent-account.admin.cancel',
+    // ─── connect-auth (spec 200)
+    'connect-auth.session.mint',
+    'connect-auth.session.verify.accept',
+    'connect-auth.session.verify.reject',
+    // ─── connect (spec 224)
+    'connect.issue.accept',
+    'connect.issue.reject',
+    // ─── mcp-runtime (spec 205)
+    'mcp-runtime.with-delegation.accept',
+    'mcp-runtime.with-delegation.reject',
+    'mcp-runtime.service-mac.issue',
+    'mcp-runtime.service-mac.accept',
+    'mcp-runtime.service-mac.reject',
+    // ─── agent-naming (spec 215)
+    'agent-naming.resolve',
+    'agent-naming.register',
+    'agent-naming.records.update',
+    'agent-naming.primary-name.update',
+    'agent-naming.subregistry.update',
+];
+/** Type guard for callers that need to validate an arbitrary string. */
+export function isCanonicalAuditAction(s) {
+    return AUDIT_ACTION_REGISTRY.includes(s);
+}
+// ─── Provided sinks ───────────────────────────────────────────────────
+/**
+ * Emit events as one-line JSON to `console.log`. Suitable for
+ * Cloudflare Workers (where `wrangler tail` surfaces console output)
+ * and for local dev. Production deploys typically PAIR this with a
+ * durable sink — see `composeSinks` below.
+ */
+export function createConsoleAuditSink(opts) {
+    const prefix = opts?.prefix ?? '[AUDIT]';
+    return {
+        async write(event) {
+            // One-line JSON; Cloudflare's log line limit is 1KB so we stay
+            // compact. If `context` overflows, the line gets clipped — that's
+            // the sink's responsibility to handle (e.g. by pre-truncating).
+            const line = `${prefix} ${JSON.stringify(event)}`;
+            // eslint-disable-next-line no-console
+            console.log(line);
+        },
+    };
+}
+export function createMemoryAuditSink(opts) {
+    const capacity = opts?.capacity ?? 1024;
+    const buf = [];
+    return {
+        async write(event) {
+            buf.push(event);
+            if (buf.length > capacity)
+                buf.shift();
+        },
+        events() {
+            return buf.slice();
+        },
+        reset() {
+            buf.length = 0;
+        },
+    };
+}
+/**
+ * Combine multiple sinks into one with **fail-soft** semantics — each
+ * emit fans out to all sinks sequentially; a failure in one sink does NOT
+ * short-circuit the others, AND does NOT propagate to the caller. The
+ * caller's `await write(event)` always resolves successfully, even if every
+ * sink failed. Best for telemetry / metrics-grade events where dropping
+ * one event is acceptable.
+ *
+ * **H7-B.7 / PKG-AUDIT-001 closure** — security-critical events (authority
+ * changes, custody operations, signing-side actions) need durable-before-
+ * commit semantics; use {@link composeFailHardSinks} for those. The
+ * audit package stays domain-agnostic — emitting packages document which
+ * of their action names belong to the fail-hard class in their own docs.
+ *
+ * Production wiring is typically `composeSinks(d1Sink, consoleSink)` for
+ * non-critical events, and `composeFailHardSinks(d1Sink)` for events that
+ * MUST be persisted before the action commits.
+ */
+export function composeSinks(...sinks) {
+    return composeFailSoftSinks(...sinks);
+}
+/** Explicit alias of {@link composeSinks} — fail-soft, no propagation. */
+export function composeFailSoftSinks(...sinks) {
+    return {
+        async write(event) {
+            const errors = [];
+            for (const sink of sinks) {
+                try {
+                    await sink.write(event);
+                }
+                catch (e) {
+                    errors.push(e);
+                }
+            }
+            if (errors.length > 0) {
+                // Surface to console as a last resort — the audit event itself
+                // may have been written to some sinks but not others.
+                // eslint-disable-next-line no-console
+                console.error(`[audit] ${errors.length} sink(s) failed for event ${event.id}:`, errors);
+            }
+        },
+    };
+}
+/**
+ * H7-B.7 — Combine multiple sinks with **fail-hard** semantics for
+ * security-critical events. The first sink failure THROWS the original
+ * error (after the remaining sinks have been attempted — every sink still
+ * gets a chance to record, but the caller's `await write(event)` rejects
+ * if any failed).
+ *
+ * Use for events whose absence from durable storage would be a security
+ * regression — the precise action vocabulary is each emitting package's
+ * responsibility to document. The caller's flow MUST treat a thrown audit
+ * as the action FAILING — do not commit the on-chain or off-chain effect
+ * if the audit didn't persist.
+ *
+ * Closure: PKG-AUDIT-001 / EXT-022 / CT-11.
+ */
+export function composeFailHardSinks(...sinks) {
+    return {
+        async write(event) {
+            const errors = [];
+            for (const sink of sinks) {
+                try {
+                    await sink.write(event);
+                }
+                catch (e) {
+                    errors.push(e);
+                }
+            }
+            if (errors.length > 0) {
+                // eslint-disable-next-line no-console
+                console.error(`[audit:fail-hard] ${errors.length} sink(s) failed for event ${event.id}:`, errors);
+                const err = errors[0];
+                if (err instanceof Error)
+                    throw err;
+                throw new Error(`[audit:fail-hard] sink failure for event ${event.id}: ${String(err)}`);
+            }
+        },
+    };
+}
+/**
+ * No-op sink. The default when consumers haven't wired metrics yet —
+ * runtime always succeeds, never observably affects throughput.
+ */
+export const noopMetricsSink = {
+    increment: () => undefined,
+    observe: () => undefined,
+    gauge: () => undefined,
+};
+/**
+ * Console-out metrics sink for local dev. NOT a production sink — the
+ * volume in production overwhelms console output and provides no
+ * aggregation. Production wires `composeMetricsSinks(prometheusSink, …)`.
+ */
+export function createConsoleMetricsSink(opts) {
+    const prefix = opts?.prefix ?? '[METRIC]';
+    const fmt = (kind, name, value, tags) => `${prefix} ${kind} ${name}=${value}${tags ? ' ' + JSON.stringify(tags) : ''}`;
+    return {
+        increment: (name, value = 1, tags) => {
+            // eslint-disable-next-line no-console
+            console.log(fmt('count', name, value, tags));
+        },
+        observe: (name, value, tags) => {
+            // eslint-disable-next-line no-console
+            console.log(fmt('hist', name, value, tags));
+        },
+        gauge: (name, value, tags) => {
+            // eslint-disable-next-line no-console
+            console.log(fmt('gauge', name, value, tags));
+        },
+    };
+}
+/**
+ * Fan-out to multiple metrics sinks. Same fail-soft semantics as
+ * `composeSinks` for audit: a failure in one sink doesn't short-circuit
+ * the others. Metrics emissions are synchronous + must never block
+ * the request path; sinks that need async work MUST queue internally.
+ */
+export function composeMetricsSinks(...sinks) {
+    const safely = (fn) => {
+        try {
+            fn();
+        }
+        catch { /* fail-soft */ }
+    };
+    return {
+        increment: (name, value, tags) => {
+            for (const s of sinks)
+                safely(() => s.increment(name, value, tags));
+        },
+        observe: (name, value, tags) => {
+            for (const s of sinks)
+                safely(() => s.observe(name, value, tags));
+        },
+        gauge: (name, value, tags) => {
+            for (const s of sinks)
+                safely(() => s.gauge(name, value, tags));
+        },
+    };
+}
+export function createMemoryMetricsSink() {
+    const counts = new Map();
+    const observations = new Map();
+    const gauges = new Map();
+    const key = (name, tags) => tags && Object.keys(tags).length > 0
+        ? `${name}|${Object.keys(tags).sort().map((k) => `${k}=${tags[k]}`).join(',')}`
+        : name;
+    return {
+        increment(name, value = 1, tags) {
+            const k = key(name, tags);
+            counts.set(k, (counts.get(k) ?? 0) + value);
+        },
+        observe(name, value, tags) {
+            const k = key(name, tags);
+            const arr = observations.get(k) ?? [];
+            arr.push(value);
+            observations.set(k, arr);
+        },
+        gauge(name, value, tags) {
+            gauges.set(key(name, tags), value);
+        },
+        snapshot() {
+            return { counts: new Map(counts), observations: new Map(observations), gauges: new Map(gauges) };
+        },
+        reset() {
+            counts.clear();
+            observations.clear();
+            gauges.clear();
+        },
+    };
+}
+const DEFAULT_ALLOW_KEYS = new Set([
+    'signerAddress',
+    'address',
+    'paymaster',
+    'entryPoint',
+    'keyId',
+    'nonceHash',
+    'sessionHash',
+    'digest',
+    'txHash',
+    'blockHash',
+    'jti',
+    'eventId',
+]);
+const DEFAULT_ALLOW_SUBJECT_TYPES = new Set([
+    'jti',
+    'sign-digest',
+    'tx-hash',
+    'address',
+    'event-id',
+]);
+const JWT_SHAPE = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+const PEM_BLOCK = /-----BEGIN /;
+const SECRET_SUBSTRING = /(private[_-]?key|client[_-]?secret|api[_-]?key|access[_-]?token|refresh[_-]?token)/i;
+/**
+ * Wrapper sink that scans event payloads for likely-secret material and
+ * either redacts / drops / warns before forwarding to `inner`. **This is
+ * defense-in-depth**, not a substitute for the emitter discipline rule
+ * "MUST hash or omit raw secrets" (per the audit package CLAUDE.md
+ * invariant). It catches accidental leaks at the sink boundary.
+ *
+ * Production wiring example:
+ * ```ts
+ * const sink = composeSinks(
+ *   createConsoleAuditSink({ prefix: '[AUDIT]' }),
+ *   createPiiGuardrailSink(createD1AuditSink(env.DB), { mode: 'redact' }),
+ * );
+ * ```
+ *
+ * The guardrail's own decisions are not themselves audit events — they
+ * surface through `onDetect`. Use that to wire alerts ("found a leak in
+ * action=X") if you want them in your own metrics pipeline.
+ */
+export function createPiiGuardrailSink(inner, opts) {
+    const mode = opts?.mode ?? 'redact';
+    const maxHexLength = opts?.maxHexLength ?? 80;
+    const allowKeys = new Set([...DEFAULT_ALLOW_KEYS, ...(opts?.allowKeys ?? [])]);
+    const allowSubjectTypes = new Set([
+        ...DEFAULT_ALLOW_SUBJECT_TYPES,
+        ...(opts?.allowSubjectTypes ?? []),
+    ]);
+    const longHex = new RegExp(`^0x[0-9a-fA-F]{${maxHexLength - 2},}$`);
+    function classify(value) {
+        if (longHex.test(value)) {
+            return { reason: 'long-hex', preview: `hex-${value.length}` };
+        }
+        if (value.length > 100 && JWT_SHAPE.test(value)) {
+            const segs = value.split('.').length;
+            return { reason: 'jwt-shape', preview: `jwt-${segs}-seg-len-${value.length}` };
+        }
+        if (PEM_BLOCK.test(value)) {
+            return { reason: 'pem-block', preview: 'pem' };
+        }
+        if (SECRET_SUBSTRING.test(value)) {
+            return { reason: 'secret-substring', preview: `match-len-${value.length}` };
+        }
+        return null;
+    }
+    function redactToken(reason, preview) {
+        return `<redacted:${reason}:${preview}>`;
+    }
+    return {
+        async write(event) {
+            const findings = [];
+            // Deep-ish copy of the event so we can mutate fields without
+            // affecting the caller's reference.
+            const sanitized = {
+                ...event,
+                context: event.context ? { ...event.context } : undefined,
+                subject: event.subject ? { ...event.subject } : undefined,
+                actor: event.actor ? { ...event.actor } : undefined,
+            };
+            const scan = (path, value, redactInPlace) => {
+                if (typeof value !== 'string')
+                    return;
+                const hit = classify(value);
+                if (!hit)
+                    return;
+                findings.push({ path, reason: hit.reason, preview: hit.preview });
+                if (mode === 'redact')
+                    redactInPlace(redactToken(hit.reason, hit.preview));
+            };
+            // context.* — skip allowlisted keys (legitimate hex carriers).
+            if (sanitized.context) {
+                for (const [k, v] of Object.entries(sanitized.context)) {
+                    if (allowKeys.has(k))
+                        continue;
+                    scan(`context.${k}`, v, (token) => {
+                        sanitized.context[k] = token;
+                    });
+                }
+            }
+            // subject.id — skip when subject.type is a known hex-carrier.
+            if (sanitized.subject && !allowSubjectTypes.has(sanitized.subject.type)) {
+                scan('subject.id', sanitized.subject.id, (token) => {
+                    sanitized.subject.id = token;
+                });
+            }
+            // actor.id — same rules; addresses + service names are typically short.
+            if (sanitized.actor?.id) {
+                scan('actor.id', sanitized.actor.id, (token) => {
+                    sanitized.actor.id = token;
+                });
+            }
+            // reason / audience — free-string fields that could carry stack traces.
+            if (sanitized.reason) {
+                scan('reason', sanitized.reason, (token) => {
+                    sanitized.reason = token;
+                });
+            }
+            if (sanitized.audience) {
+                scan('audience', sanitized.audience, (token) => {
+                    sanitized.audience = token;
+                });
+            }
+            if (findings.length > 0) {
+                opts?.onDetect?.({ event: sanitized, findings });
+            }
+            if (findings.length > 0 && mode === 'drop') {
+                // Don't forward at all. The onDetect callback above is the
+                // only signal that a row was dropped.
+                return;
+            }
+            if (findings.length > 0 && mode === 'warn') {
+                // Forward unchanged.
+                await inner.write(event);
+                return;
+            }
+            await inner.write(sanitized);
+        },
+    };
+}
+// ─── Helpers ──────────────────────────────────────────────────────────
+/**
+ * Generate a UUID-shaped event ID. Uses Web Crypto when available
+ * (Workers, modern Node); falls back to a deterministic ordering for
+ * legacy Node (warning: NOT cryptographically random — tests + dev only).
+ */
+export function generateEventId() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const g = globalThis;
+    if (g.crypto?.randomUUID)
+        return g.crypto.randomUUID();
+    // Fallback: 16 random-ish bytes formatted as a UUID v4.
+    const bytes = new Uint8Array(16);
+    if (g.crypto?.getRandomValues) {
+        g.crypto.getRandomValues(bytes);
+    }
+    else {
+        for (let i = 0; i < 16; i++)
+            bytes[i] = Math.floor(Math.random() * 256);
+    }
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+/** Convenience: produce an ISO-8601 UTC timestamp. */
+export function nowIso() {
+    return new Date().toISOString();
+}
+/**
+ * Build an `AuditEvent` with sane defaults. Saves callers from
+ * repeatedly writing `id: generateEventId(), timestamp: nowIso()`.
+ *
+ * Required: `action`, `outcome`. Everything else optional + spreads
+ * through.
+ */
+export function buildEvent(partial) {
+    return {
+        id: partial.id ?? generateEventId(),
+        timestamp: partial.timestamp ?? nowIso(),
+        ...partial,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@agenticprimitives/audit",
+  "version": "0.1.0-alpha.2",
+  "description": "Append-only audit event schema + sink interface. Transport-agnostic; consumers wire concrete sinks (console / D1 / Cloud Logging / etc.).",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentictrustlabs/agenticprimitives.git",
+    "directory": "packages/audit"
+  },
+  "homepage": "https://github.com/agentictrustlabs/agenticprimitives/tree/master/packages/audit",
+  "bugs": {
+    "url": "https://github.com/agentictrustlabs/agenticprimitives/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "LICENSE",
+    "dist",
+    "spec.md",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:unit": "vitest run test/unit",
+    "test:integration": "vitest run test/integration --passWithNoTests",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@agenticprimitives/types": "workspace:*"
+  },
+  "devDependencies": {
+    "vitest": "^2.1.0"
+  },
+  "keywords": [
+    "audit",
+    "forensics",
+    "observability",
+    "agentic"
+  ]
+}

package/spec.md

@@ -0,0 +1,6 @@
+# @agenticprimitives/audit — spec
+
+The authoritative specification lives at:
+**[`../../specs/206-audit.md`](../../specs/206-audit.md)**
+
+Do not edit a divergent copy here.