@verax-ai/proxy 0.1.0

package/dist/reconcile.js

@@ -0,0 +1,420 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+function asChannelRow(raw, line) {
+    if (raw === null || typeof raw !== "object") {
+        throw new Error(`channel-row-invalid:${line}`);
+    }
+    const o = raw;
+    if (typeof o.channel !== "string" || o.channel === "") {
+        throw new Error(`channel-row-invalid:${line}:channel`);
+    }
+    if (typeof o.externalId !== "string" || o.externalId === "") {
+        throw new Error(`channel-row-invalid:${line}:externalId`);
+    }
+    if (typeof o.occurredAtMs !== "number" || !Number.isFinite(o.occurredAtMs)) {
+        throw new Error(`channel-row-invalid:${line}:occurredAtMs`);
+    }
+    if (typeof o.subject !== "string" || o.subject === "") {
+        throw new Error(`channel-row-invalid:${line}:subject`);
+    }
+    const row = {
+        channel: o.channel,
+        externalId: o.externalId,
+        occurredAtMs: o.occurredAtMs,
+        subject: o.subject,
+    };
+    if (typeof o.actor === "string")
+        row.actor = o.actor;
+    if (typeof o.ref === "string")
+        row.ref = o.ref;
+    if (typeof o.amountMinor === "number")
+        row.amountMinor = o.amountMinor;
+    if (typeof o.currency === "string")
+        row.currency = o.currency;
+    if (o.credit === true)
+        row.credit = true;
+    if (typeof o.descriptor === "string")
+        row.descriptor = o.descriptor;
+    if (o.datePrecision === "day" || o.datePrecision === "minute")
+        row.datePrecision = o.datePrecision;
+    return row;
+}
+const VERAX_REF = /verax:([A-Za-z0-9][A-Za-z0-9._-]{0,63})/;
+const CARD_MINUTE_TOLERANCE_MS = 120_000;
+function parseCardDate(raw, format, tzOffsetMinutes) {
+    const t = raw.trim();
+    const offset = Number.isFinite(tzOffsetMinutes) ? tzOffsetMinutes : null;
+    const pattern = format === "YYYY-MM-DD"
+        ? /^(\d{4})-(\d{2})-(\d{2})(?:\s+(\d{2}):(\d{2})(?::(\d{2}))?)?$/
+        : /^(\d{2})\.(\d{2})\.(\d{4})(?:\s+(\d{2}):(\d{2})(?::(\d{2}))?)?$/;
+    const m = pattern.exec(t);
+    if (!m)
+        throw new Error(`card-csv-date:${raw}`);
+    const year = Number(format === "YYYY-MM-DD" ? m[1] : m[3]);
+    const month = Number(m[2]) - 1;
+    const day = Number(format === "YYYY-MM-DD" ? m[3] : m[1]);
+    if (m[4] !== undefined && offset !== null) {
+        const local = Date.UTC(year, month, day, Number(m[4]), Number(m[5]), Number(m[6] ?? 0));
+        return { ms: local - offset * 60_000, precision: "minute" };
+    }
+    return { ms: Date.UTC(year, month, day, 12, 0, 0), precision: "day" };
+}
+function rowToleranceMs(row, fallback) {
+    return row.datePrecision === "minute" ? CARD_MINUTE_TOLERANCE_MS : fallback;
+}
+function descriptorHits(text, stamps) {
+    const hay = text.toUpperCase();
+    return stamps.some((s) => hay.includes(s.toUpperCase()));
+}
+function parseCardAmount(raw, decimal) {
+    const thousand = decimal === "," ? "." : ",";
+    const cleaned = raw.trim().replaceAll(thousand, "").replace(decimal, ".");
+    const n = Number(cleaned);
+    if (!Number.isFinite(n))
+        throw new Error(`card-csv-amount:${raw}`);
+    return Math.round(n * 100);
+}
+/** RFC 4180 cells: delimiter inside quotes, `""` escape, CRLF in a quoted field. */
+function parseCsvRecords(text, delimiter) {
+    const src = text.replace(/^\uFEFF/, "");
+    const records = [];
+    let cells = [];
+    let cur = "";
+    let inQuotes = false;
+    let line = 1;
+    let recordStartLine = 1;
+    const flushRecord = () => {
+        cells.push(cur);
+        if (cells.some((c) => c !== "")) {
+            records.push({ line: recordStartLine, cells });
+        }
+        cells = [];
+        cur = "";
+        recordStartLine = line;
+    };
+    for (let i = 0; i < src.length; i += 1) {
+        const ch = src[i];
+        if (inQuotes) {
+            if (ch === '"') {
+                if (src[i + 1] === '"') {
+                    cur += '"';
+                    i += 1;
+                    continue;
+                }
+                inQuotes = false;
+                continue;
+            }
+            if (ch === "\n")
+                line += 1;
+            cur += ch;
+            continue;
+        }
+        if (ch === '"') {
+            inQuotes = true;
+            continue;
+        }
+        if (ch === delimiter) {
+            cells.push(cur);
+            cur = "";
+            continue;
+        }
+        if (ch === "\r" && src[i + 1] === "\n") {
+            line += 1;
+            flushRecord();
+            i += 1;
+            continue;
+        }
+        if (ch === "\n") {
+            line += 1;
+            flushRecord();
+            continue;
+        }
+        cur += ch;
+    }
+    if (inQuotes) {
+        throw new Error("card-csv-unclosed-quote");
+    }
+    if (cur !== "" || cells.length > 0)
+        flushRecord();
+    return records;
+}
+export function parseCardCsv(text, opts) {
+    const delimiter = opts.delimiter ?? ";";
+    const decimal = opts.decimal ?? ",";
+    const dateFormat = opts.dateFormat ?? "DD.MM.YYYY";
+    const columns = opts.columns ?? { date: "Tarih", amount: "Tutar", description: "Açıklama" };
+    const records = parseCsvRecords(text, delimiter);
+    if (records.length === 0)
+        return Object.assign([], { skipped: [] });
+    const header = records[0].cells.map((h) => h.trim());
+    const dateIdx = header.indexOf(columns.date);
+    const amountIdx = header.indexOf(columns.amount);
+    const descIdx = header.indexOf(columns.description);
+    const idIdx = columns.id ? header.indexOf(columns.id) : -1;
+    if (dateIdx < 0 || amountIdx < 0 || descIdx < 0) {
+        throw new Error("card-csv-columns");
+    }
+    const rows = [];
+    const skipped = [];
+    for (const rec of records.slice(1)) {
+        try {
+            const cells = rec.cells;
+            const date = cells[dateIdx] ?? "";
+            const amountRaw = cells[amountIdx] ?? "";
+            const description = cells[descIdx] ?? "";
+            const signed = parseCardAmount(amountRaw, decimal);
+            const amountMinor = Math.abs(signed);
+            const parsedDate = parseCardDate(date, dateFormat, opts.tzOffsetMinutes);
+            const refHit = VERAX_REF.exec(description);
+            const idCell = idIdx >= 0 ? (cells[idIdx] ?? "").trim() : "";
+            const externalId = idCell !== ""
+                ? idCell
+                : createHash("sha256").update(`${date}|${amountRaw}|${description}`, "utf8").digest("hex");
+            const row = {
+                channel: "card",
+                externalId,
+                occurredAtMs: parsedDate.ms,
+                subject: "spend",
+                amountMinor,
+                currency: opts.currency,
+                descriptor: description,
+                datePrecision: parsedDate.precision,
+            };
+            if (refHit)
+                row.ref = refHit[1];
+            if (signed > 0)
+                row.credit = true;
+            rows.push(row);
+        }
+        catch (err) {
+            skipped.push({
+                line: rec.line,
+                reason: err instanceof Error ? err.message : "card-csv-row",
+            });
+        }
+    }
+    return Object.assign(rows, { skipped });
+}
+export function parseChannelJsonl(text) {
+    const rows = [];
+    let n = 0;
+    for (const line of text.split("\n")) {
+        if (line === "")
+            continue;
+        n += 1;
+        rows.push(asChannelRow(JSON.parse(line), n));
+    }
+    return rows;
+}
+/** Read-only: does not take ledger.lock. */
+export function loadEffectsFromDir(stateDir) {
+    try {
+        const text = readFileSync(join(stateDir, "effects.jsonl"), "utf8");
+        const rows = [];
+        for (const line of text.split("\n")) {
+            if (line === "")
+                continue;
+            rows.push(JSON.parse(line));
+        }
+        return rows;
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+}
+/**
+ * Match a Sent-style channel export to ledger effects. Cedulon audit()
+ * is not called; buckets use that vocabulary (ghost / unsent / outOfScope
+ * are the unreconciled classes).
+ */
+function nearestEffectDtMs(row, effects) {
+    let best;
+    for (const effect of effects) {
+        const dt = Math.abs(row.occurredAtMs - effect.row.timestampMs);
+        if (best === undefined || dt < best)
+            best = dt;
+    }
+    return best;
+}
+function asGhost(row, effects, reason) {
+    const dt = nearestEffectDtMs(row, effects);
+    const ghost = { ...row };
+    if (dt !== undefined)
+        ghost.nearestEffectDtMs = dt;
+    if (reason !== undefined)
+        ghost.reason = reason;
+    return ghost;
+}
+function approvalForEffect(approvals, effectRef) {
+    if (!approvals)
+        return undefined;
+    return approvals.find((r) => r.allowRef === effectRef || r.ref === effectRef);
+}
+function effectAmount(effect, approvals) {
+    const snap = approvalForEffect(approvals, effect.row.ref);
+    const amountMinor = snap && typeof snap.args.amountMinor === "number" ? snap.args.amountMinor : undefined;
+    const currency = snap && typeof snap.args.currency === "string" ? snap.args.currency : undefined;
+    return { amountMinor, currency };
+}
+function amountsClose(a, b) {
+    if (typeof a !== "number" || typeof b !== "number")
+        return false;
+    return Math.abs(a - b) <= 1;
+}
+/** One side priced and the other not is not a match. Both unpriced (sent) still is. */
+function amountGate(row, fromSnap) {
+    const rowPriced = row.amountMinor !== undefined;
+    const snapPriced = fromSnap.amountMinor !== undefined;
+    if (rowPriced !== snapPriced)
+        return "unknown";
+    if (!rowPriced)
+        return "unpriced";
+    if (!amountsClose(row.amountMinor, fromSnap.amountMinor))
+        return "mismatch";
+    if (row.currency !== undefined && fromSnap.currency !== undefined && row.currency !== fromSnap.currency) {
+        return "mismatch";
+    }
+    return "match";
+}
+function descriptorsFor(effect, approvals, byPayee) {
+    if (!byPayee)
+        return undefined;
+    const snap = approvalForEffect(approvals, effect.row.ref);
+    const payee = snap && typeof snap.args.payee === "string" ? snap.args.payee : undefined;
+    if (!payee)
+        return undefined;
+    const stamps = byPayee[payee];
+    return stamps && stamps.length > 0 ? stamps : undefined;
+}
+export function reconcile(channelRows, effects, opts) {
+    const toleranceMs = opts?.toleranceMs ?? 60_000;
+    if (channelRows.length === 0) {
+        return {
+            scope: { channel: "", windowStartMs: 0, windowEndMs: 0, rowCount: 0 },
+            matched: [],
+            ghost: [],
+            unsent: effects.filter((e) => e.row.effectClass !== "spend").map((e) => e.row),
+            authorizedUnpaid: effects.filter((e) => e.row.effectClass === "spend").map((e) => e.row),
+            outOfScope: [],
+        };
+    }
+    const channel = channelRows[0].channel;
+    const times = channelRows.map((r) => r.occurredAtMs);
+    const explicit = opts?.window;
+    const windowStartMs = explicit ? explicit.startMs : Math.min(...times);
+    const windowEndMs = explicit ? explicit.endMs : Math.max(...times);
+    const used = new Set();
+    const matched = [];
+    const ghost = [];
+    const outOfScope = [];
+    for (const row of channelRows) {
+        if (row.channel !== channel) {
+            throw new Error(`channel-mixed:${row.channel}`);
+        }
+        if (row.credit === true) {
+            outOfScope.push(row);
+            continue;
+        }
+        if (explicit && (row.occurredAtMs < windowStartMs || row.occurredAtMs > windowEndMs)) {
+            outOfScope.push(row);
+            continue;
+        }
+        const rowTol = rowToleranceMs(row, toleranceMs);
+        const marked = { ...row, toleranceMs: rowTol };
+        if (typeof row.ref === "string" && row.ref !== "") {
+            const idx = effects.findIndex((e, i) => !used.has(i) &&
+                (e.row.ref === row.ref ||
+                    opts?.approvals?.some((a) => a.ref === row.ref && a.allowRef === e.row.ref)));
+            if (idx === -1) {
+                ghost.push(asGhost(marked, effects));
+                continue;
+            }
+            const dt = Math.abs(row.occurredAtMs - effects[idx].row.timestampMs);
+            if (dt > rowTol) {
+                ghost.push(asGhost(marked, effects));
+                continue;
+            }
+            const fromSnap = effectAmount(effects[idx], opts?.approvals);
+            const gate = amountGate(row, fromSnap);
+            if (gate === "unknown") {
+                ghost.push(asGhost(marked, effects, "amount-unknown"));
+                continue;
+            }
+            if (gate === "mismatch") {
+                ghost.push(asGhost(marked, effects, "amount-mismatch"));
+                continue;
+            }
+            used.add(idx);
+            matched.push({
+                channel: marked,
+                effect: effects[idx].row,
+                datePrecision: row.datePrecision,
+                toleranceMs: rowTol,
+            });
+            continue;
+        }
+        let unknownNear = false;
+        let descriptorMiss = false;
+        const near = effects.findIndex((e, i) => {
+            if (used.has(i) || e.row.effectClass !== row.subject)
+                return false;
+            if (Math.abs(row.occurredAtMs - e.row.timestampMs) > rowTol)
+                return false;
+            const stamps = descriptorsFor(e, opts?.approvals, opts?.descriptorsByPayee);
+            if (stamps) {
+                const text = row.descriptor ?? "";
+                if (!descriptorHits(text, stamps)) {
+                    descriptorMiss = true;
+                    return false;
+                }
+            }
+            const fromSnap = effectAmount(e, opts?.approvals);
+            const gate = amountGate(row, fromSnap);
+            if (gate === "unknown") {
+                unknownNear = true;
+                return false;
+            }
+            if (gate === "mismatch")
+                return false;
+            return true;
+        });
+        if (near !== -1) {
+            used.add(near);
+            matched.push({
+                channel: marked,
+                effect: effects[near].row,
+                datePrecision: row.datePrecision,
+                toleranceMs: rowTol,
+            });
+            continue;
+        }
+        const reason = descriptorMiss
+            ? "descriptor-mismatch"
+            : unknownNear
+                ? "amount-unknown"
+                : undefined;
+        ghost.push(asGhost(marked, effects, reason));
+    }
+    const lo = windowStartMs - toleranceMs;
+    const hi = windowEndMs + toleranceMs;
+    const leftover = effects.filter((e, i) => !used.has(i) && e.row.timestampMs >= lo && e.row.timestampMs <= hi);
+    const authorizedUnpaid = leftover.filter((e) => e.row.effectClass === "spend").map((e) => e.row);
+    const unsent = leftover.filter((e) => e.row.effectClass !== "spend").map((e) => e.row);
+    return {
+        scope: {
+            channel,
+            windowStartMs,
+            windowEndMs,
+            rowCount: channelRows.length,
+            ...(opts?.skipped ? { skipped: opts.skipped } : {}),
+        },
+        matched,
+        ghost,
+        unsent,
+        authorizedUnpaid,
+        outOfScope,
+    };
+}

package/dist/spoken-reason.d.ts

@@ -0,0 +1 @@
+export declare function spokenReason(reasonCode: string): string;

package/dist/spoken-reason.js

@@ -0,0 +1,9 @@
+/** Codes the brain is told, when that string is not the recorded reason.
+ *  The ledger row always keeps the recorded code. An unmapped code is
+ *  spoken as itself. */
+const SPOKEN_REASON = {
+    "tenant-mismatch": "not-found",
+};
+export function spokenReason(reasonCode) {
+    return SPOKEN_REASON[reasonCode] ?? reasonCode;
+}

package/dist/tenant.d.ts

@@ -0,0 +1,12 @@
+/** Fields that enter the tenant key. `aud` is intentionally absent. */
+export type TenantPrincipal = {
+    brain: string;
+    iss?: string;
+    tenant?: string;
+    org?: string;
+};
+/**
+ * SHA-256 of `{ iss, sub }` plus `tenant` or `org` when present.
+ * `aud` is not a field and must not be added: it names the body.
+ */
+export declare function tenantKey(principal: TenantPrincipal): string;

package/dist/tenant.js

@@ -0,0 +1,18 @@
+import { sha256Canonical } from "./hash.js";
+/**
+ * SHA-256 of `{ iss, sub }` plus `tenant` or `org` when present.
+ * `aud` is not a field and must not be added: it names the body.
+ */
+export function tenantKey(principal) {
+    const material = {
+        iss: principal.iss ?? "",
+        sub: principal.brain,
+    };
+    if (typeof principal.tenant === "string" && principal.tenant !== "") {
+        material.tenant = principal.tenant;
+    }
+    else if (typeof principal.org === "string" && principal.org !== "") {
+        material.org = principal.org;
+    }
+    return sha256Canonical(material);
+}

package/dist/types.d.ts

@@ -0,0 +1,189 @@
+import type { DecisionKind, SignedDecisionRecord } from "@cedulon/core";
+import type { EffectRow, SignedEffectExtract } from "@cedulon/effect-extract";
+/** Who asked. G2 fills `brain` from JWT `sub` and `scopes` from `scope`. */
+export type Principal = {
+    brain: string;
+    scopes: ReadonlySet<string>;
+    /** JWT `iss`. Optional so existing fixtures stay `{ brain, scopes }`. */
+    iss?: string;
+    /** Explicit JWT `tenant` claim, when the issuer sends one. */
+    tenant?: string;
+    /** Explicit JWT `org` claim, when the issuer sends one and `tenant` is absent. */
+    org?: string;
+};
+/** Same shape as `@cedulon/mcp-guard` so a later wrap can sit on this type. */
+export type ToolCall = {
+    name: string;
+    arguments: Record<string, unknown>;
+};
+/** Same shape as `@cedulon/mcp-guard`. claimedHash is a side field; it does not enter the ledger or audit. */
+export type ToolResult = {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+    claimedHash?: string;
+};
+export type PolicyDecision = {
+    decision: DecisionKind;
+    reasonCode: string;
+    rule: string | null;
+};
+export type PolicyEvalCtx = {
+    spentTodayMinor?: (currency: string) => number;
+};
+export type PolicyLimits = {
+    ratePerMinute?: number;
+    dailyMax?: number;
+    diskFreeBytes: number;
+};
+export type Policy = {
+    hash: string;
+    approvalTtlMs: number;
+    limits: PolicyLimits;
+    /** Document-root posture. Absent keeps today's optional `_inputs`. */
+    requireInputs?: boolean;
+    evaluate(call: ToolCall, principal: Principal, ctx?: PolicyEvalCtx): PolicyDecision;
+    rule(id: string | null): {
+        id: string;
+        text: string;
+    } | null;
+};
+export type WitnessClass = "self" | "same-org" | "third-party" | "regulated";
+export type EffectAttestation = {
+    coseHex: string;
+};
+export type LedgerEffect = {
+    row: EffectRow;
+    witnessClass: WitnessClass;
+    /** Hash of the ToolResult (or thrown payload). Not an EffectRow field. */
+    resultHash?: string;
+    /** One-row extract signed at call time. */
+    receipt?: SignedEffectExtract;
+    /** Signed { ref, effectHash, witnessClass, resultHash } via COSE Sign1. */
+    attestation?: EffectAttestation;
+};
+export type RecordSigner = {
+    privateKeyPem: string;
+    publicKeyPem: string;
+};
+export type EffectSigner = {
+    privateKeyPem: string;
+    publicKeyPem: string;
+};
+export type ExtractWindow = {
+    startMs: number;
+    endMs: number;
+};
+/**
+ * Third implementations (a later obsigna daemon) must be able to sit here.
+ * Append is async on purpose: no synchronous-file assumption.
+ */
+export type Ledger = {
+    appendDecision(signed: SignedDecisionRecord): Promise<void>;
+    appendDecisionChained(build: (prevRecordHash: string | null) => SignedDecisionRecord): Promise<void>;
+    appendEffect(row: EffectRow, witnessClass?: WitnessClass, resultHash?: string): Promise<void>;
+    decisions(): Promise<SignedDecisionRecord[]>;
+    effects(): Promise<LedgerEffect[]>;
+    lastDecisionHash(): Promise<string | null>;
+    exportExtract(window: ExtractWindow, signer: EffectSigner): Promise<SignedEffectExtract>;
+};
+export type DecisionInputRow = {
+    id: string;
+    versionHash: string;
+    validFromMs: number;
+    validUntilMs: number;
+    /** Optional provenance. Same idea as memory.put `source`; additive. */
+    source?: Record<string, unknown>;
+};
+export type DecisionInputs = {
+    principal: {
+        brain: string;
+        scopes: string[];
+        iss?: string;
+        tenant?: string;
+        org?: string;
+    };
+    inputs: DecisionInputRow[];
+    approver?: {
+        id: string;
+        via: ApprovalChannel | "proxy";
+        resolves: string;
+    };
+};
+/** How an operator's approval reached the ledger: `verax approve` on the machine, or the body's `/api/approve`. */
+export type ApprovalChannel = "cli" | "http";
+export type InputsLog = {
+    append(ref: string, inputs: DecisionInputs): Promise<void>;
+    get(ref: string): Promise<DecisionInputs | null>;
+};
+export type ResolvedInput = {
+    versionHash: string;
+    validFromMs: number;
+    validUntilMs: number;
+};
+export type ProxyDeps = {
+    policy: Policy;
+    recordSigner: RecordSigner;
+    effectSigner: EffectSigner;
+    ledger: Ledger;
+    now: () => number;
+    nonce: () => string;
+    inner: (call: ToolCall, principal: Principal, ref?: string) => Promise<ToolResult>;
+    inputsLog?: InputsLog;
+    resolveInput?: (id: string, principal?: Principal) => Promise<ResolvedInput | null>;
+    /** True when the call names another tenant's memory id or decision ref. */
+    checkTenantMismatch?: (call: ToolCall, principal: Principal) => Promise<boolean>;
+};
+export type ExplainFinding = {
+    code: string | null;
+    label: "conditional" | null;
+    detail: string | null;
+    summary: string;
+    notApplicable?: string[];
+};
+export type ExplainChain = {
+    intact: boolean;
+    breakAt: string | null;
+};
+export type ExplainWarning = {
+    id: string;
+    code: string;
+    detail: string;
+};
+export type ExplainOpts = {
+    issuerTrust?: {
+        publicKeyPem: string | readonly string[];
+        source?: "env" | "own-key";
+    };
+    extract?: import("@cedulon/effect-extract").SignedEffectExtract | import("@cedulon/x402-adapter").SignedRailExtract;
+    inputsLog?: InputsLog;
+};
+export type ExplainTrustRoot = {
+    pinned: boolean;
+    issuerMatches: boolean | null;
+    source: "env" | "own-key" | null;
+};
+export type ExplainPair = {
+    defer: SignedDecisionRecord | null;
+    resolution: SignedDecisionRecord | null;
+};
+export type ExplainResult = {
+    record: SignedDecisionRecord;
+    effect: LedgerEffect | null;
+    pair?: ExplainPair;
+    finding: ExplainFinding;
+    witnessClass: WitnessClass | null;
+    balanced: boolean;
+    chain: ExplainChain;
+    guarantee: "unconditional" | "conditional";
+    warnings: ExplainWarning[];
+    trustRoot: ExplainTrustRoot;
+    scope?: {
+        accountId: string;
+        railId: string;
+        windowStartMs: number;
+        windowEndMs: number;
+    };
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@verax-ai/proxy",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "type": "module",
+  "engines": {
+    "node": ">=22.6"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "policy"
+  ],
+  "dependencies": {
+    "@cedulon/audit": "0.13.1",
+    "@cedulon/core": "0.13.1",
+    "@cedulon/effect-extract": "0.13.1",
+    "@cedulon/x402-adapter": "0.13.1"
+  },
+  "description": "The decision proxy behind VERAX: policy, signed decision records, and the ledger they live in.",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/verax-ai/verax.git",
+    "directory": "packages/proxy"
+  }
+}