@zanii/blackbox 0.3.0 → 0.4.0

package/dist/health/index.d.ts

@@ -0,0 +1,120 @@
+type Obj = Record<string, unknown>;
+/** The patient's seed, for the patient's own app. It never leaves the patient. */
+export declare function episodeSeed(secretHex?: string): {
+    v: 1;
+    secret: string;
+};
+/** Zanii's tag for encounter n, derived by the patient; two tags can't be linked without the seed. */
+export declare function episodeTag(seed: {
+    secret: string;
+}, n: number): string;
+/** The tag, or an error: the patient supplies the tag, never the seed. */
+export declare function checkEpisodeTag(tag: unknown): string;
+/** A disclosed value and nonce match the commitment made at the time. */
+export declare const verifyCommitment: (value: unknown, nonce: string, commitment: string) => boolean;
+/** Zanii's health.access payload: who accessed the record, and why. */
+export declare function accessPayload(input: {
+    actor: string;
+    purpose: string;
+    ts: string;
+    consentRef?: string;
+    details?: Obj;
+    nonce?: string;
+}): {
+    payload: Obj;
+    nonce: string;
+};
+/** What the clinician signs: jcsHash of the recommendation payload. */
+export declare const recommendationHash: (payload: Obj) => string;
+/** Zanii's health.recommendation payload. No protocol, no recommendation; a deviation is recorded, never refused. */
+export declare function recommendationPayload(input: {
+    modelId: string;
+    manifestHash: string;
+    outcome: Obj;
+    ts: string;
+    runtimeHash?: string;
+    deviation?: Obj;
+    nonce?: string;
+}): {
+    payload: Obj;
+    nonce: string;
+    hash: string;
+};
+/** Zanii's health.confirmation payload, signed on the clinician's own device. */
+export declare function clinicianConfirmation(input: {
+    episodeTag: string;
+    clinicianDid: string;
+    recommendationHash: string;
+    confirmedAt: string;
+    clinicianPrivateKey: Uint8Array;
+}): Obj;
+/** Zanii's health.break_glass payload: emergency access, signed personally. Kept open on purpose, and loud. */
+export declare function breakGlass(input: {
+    episodeTag: string;
+    clinicianDid: string;
+    reason: string;
+    ts: string;
+    clinicianPrivateKey: Uint8Array;
+}): Obj;
+/** A confirmation or break-glass is signed by the clinician it names, over the action it names. */
+export declare function verifyHealthSignature(payload: unknown, tag: string): boolean;
+/** Zanii's protocol trail. No verdict on uniformity (individualised care is correct medicine). */
+export declare function protocolTrail(payloads: readonly unknown[]): {
+    protocols: {
+        manifest_hash: unknown;
+        count: number;
+        first_ts: unknown;
+        last_ts: unknown;
+    }[];
+    deviations: number;
+    unprotocolled: number;
+};
+export interface EpisodeItem {
+    session_id: string;
+    seq: number;
+    line: string;
+    event_hash: string;
+    anchored: boolean;
+    payload: Obj;
+    tag: string;
+}
+/** spec/health.md §4: the patient's episodes; `reviewed` holds "<session_id>:<seq>" of reviewed break-glass. */
+export declare function episodesPack(items: readonly EpisodeItem[], o: {
+    tags: readonly string[];
+    reviewed: readonly string[];
+    generated_at: string;
+}): {
+    v: number;
+    episodes: {
+        tag: string;
+        items: {
+            session_id: string;
+            seq: number;
+            line: string;
+            event_hash: string;
+            anchored: boolean;
+            payload: Obj;
+        }[];
+    }[];
+    total: number;
+    pending_break_glass: number;
+    protocols: {
+        protocols: {
+            manifest_hash: unknown;
+            count: number;
+            first_ts: unknown;
+            last_ts: unknown;
+        }[];
+        deviations: number;
+        unprotocolled: number;
+    };
+    generated_at: string;
+};
+export declare function healthFindings(lines: readonly string[], bodies: (hash: string) => Uint8Array | undefined, closing?: boolean): {
+    code: string;
+    source: string;
+    severity: "warning" | "advisory";
+    ref: Record<string, string | number>;
+    detail: string;
+}[];
+export {};

package/dist/health/index.js

@@ -0,0 +1,233 @@
+// Health (spec/health.md): unlinkable per-episode patient tags, access and recommendation payloads,
+// clinician confirmations, loud break-glass, the protocol trail and the patient's pack, on Zanii's
+// health payloads (@zanii/health). Pure; mirrors sdks/python/src/zanii_blackbox/health.py; pinned
+// by spec/vectors/health.json.
+import { createHash, randomBytes } from "node:crypto";
+import { createConfirmation, jcsHash } from "@zanii/core";
+import { verifyConfirmation } from "../approvals/index.js";
+import { canonical } from "../reconcile/shared.js";
+const TAG = /^sha256:[0-9a-f]{64}$/;
+const HEX64 = /^[0-9a-f]{64}$/;
+/** The patient's seed, for the patient's own app. It never leaves the patient. */
+export function episodeSeed(secretHex) {
+    const secret = secretHex ?? randomBytes(32).toString("hex");
+    if (!HEX64.test(secret))
+        throw new Error("seed secret must be 32 bytes of hex");
+    return { v: 1, secret };
+}
+/** Zanii's tag for encounter n, derived by the patient; two tags can't be linked without the seed. */
+export function episodeTag(seed, n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error("n must be a non-negative integer");
+    return jcsHash({ v: 1, type: "episode_tag", secret: seed.secret, n });
+}
+/** The tag, or an error: the patient supplies the tag, never the seed. */
+export function checkEpisodeTag(tag) {
+    if ((typeof tag === "object" && tag !== null) || (typeof tag === "string" && HEX64.test(tag)))
+        throw new Error("pass the patient's episode tag, never the seed: whoever holds the seed can link every encounter");
+    if (typeof tag !== "string" || !TAG.test(tag))
+        throw new Error("episode_tag must be sha256: and 64 hex characters");
+    return tag;
+}
+const validTs = (ts) => typeof ts === "string" && !Number.isNaN(Date.parse(ts));
+const commit = (value, nonce) => `sha256:${createHash("sha256").update(Buffer.from(nonce, "hex")).update(canonical(value)).digest("hex")}`;
+/** A disclosed value and nonce match the commitment made at the time. */
+export const verifyCommitment = (value, nonce, commitment) => /^[0-9a-f]{32}$/.test(nonce) && commit(value, nonce) === commitment;
+const base = (kind) => ({ _zr_kind: "health", _zr_domain: "health", v: 1, kind });
+/** Zanii's health.access payload: who accessed the record, and why. */
+export function accessPayload(input) {
+    if (!input.actor)
+        throw new Error("actor is required");
+    if (!input.purpose)
+        throw new Error("purpose is required: purpose limitation is not optional");
+    if (!validTs(input.ts))
+        throw new Error("ts must be an ISO timestamp");
+    const nonce = input.nonce ?? randomBytes(16).toString("hex");
+    return {
+        payload: {
+            ...base("access"),
+            actor: input.actor,
+            purpose: input.purpose,
+            consent_ref: input.consentRef ?? null,
+            details_commitment: commit(input.details ?? {}, nonce),
+            ts: input.ts,
+        },
+        nonce,
+    };
+}
+/** What the clinician signs: jcsHash of the recommendation payload. */
+export const recommendationHash = (payload) => jcsHash(payload);
+/** Zanii's health.recommendation payload. No protocol, no recommendation; a deviation is recorded, never refused. */
+export function recommendationPayload(input) {
+    if (!input.modelId)
+        throw new Error("model_id is required");
+    if (!input.manifestHash)
+        throw new Error("manifest_hash is required: a clinical recommendation with no governing protocol on record is not auditable");
+    if (!validTs(input.ts))
+        throw new Error("ts must be an ISO timestamp");
+    const nonce = input.nonce ?? randomBytes(16).toString("hex");
+    const payload = {
+        ...base("recommendation"),
+        model_id: input.modelId,
+        runtime_hash: input.runtimeHash ?? null,
+        manifest_hash: input.manifestHash,
+        outcome_commitment: commit(input.outcome, nonce),
+        deviation: input.deviation ?? null,
+        ts: input.ts,
+    };
+    return { payload, nonce, hash: recommendationHash(payload) };
+}
+/** Zanii's health.confirmation payload, signed on the clinician's own device. */
+export function clinicianConfirmation(input) {
+    checkEpisodeTag(input.episodeTag);
+    const confirmation = createConfirmation({
+        ownerId: input.clinicianDid,
+        actionHash: input.recommendationHash,
+        confirmedAt: input.confirmedAt,
+    }, input.clinicianPrivateKey);
+    return {
+        ...base("confirmation"),
+        clinician: input.clinicianDid,
+        recommendation_hash: input.recommendationHash,
+        confirmation,
+        ts: input.confirmedAt,
+    };
+}
+const breakGlassAction = (tag, ts) => jcsHash({ v: 1, type: "break_glass", tag, ts });
+/** Zanii's health.break_glass payload: emergency access, signed personally. Kept open on purpose, and loud. */
+export function breakGlass(input) {
+    checkEpisodeTag(input.episodeTag);
+    if (!input.reason)
+        throw new Error("reason is required: an unexplained break-glass is exactly the abuse this exists to catch");
+    const confirmation = createConfirmation({
+        ownerId: input.clinicianDid,
+        actionHash: breakGlassAction(input.episodeTag, input.ts),
+        confirmedAt: input.ts,
+    }, input.clinicianPrivateKey);
+    return {
+        ...base("break_glass"),
+        clinician: input.clinicianDid,
+        reason: input.reason,
+        confirmation,
+        reviewed: false,
+        ts: input.ts,
+    };
+}
+/** A confirmation or break-glass is signed by the clinician it names, over the action it names. */
+export function verifyHealthSignature(payload, tag) {
+    const p = (payload ?? {});
+    const c = p.confirmation;
+    if (!c || typeof c !== "object")
+        return false;
+    if (c.owner_id !== p.clinician || !verifyConfirmation(c))
+        return false;
+    if (p.kind === "confirmation")
+        return c.action_hash === p.recommendation_hash;
+    if (p.kind === "break_glass")
+        return c.action_hash === breakGlassAction(tag, p.ts);
+    return false;
+}
+/** Zanii's protocol trail. No verdict on uniformity (individualised care is correct medicine). */
+export function protocolTrail(payloads) {
+    const recs = payloads
+        .filter((p) => typeof p === "object" && p !== null)
+        .filter((p) => p._zr_kind === "health" && p.kind === "recommendation")
+        .sort((a, b) => (String(a.ts) < String(b.ts) ? -1 : String(a.ts) > String(b.ts) ? 1 : 0));
+    const windows = new Map();
+    let deviations = 0;
+    let unprotocolled = 0;
+    for (const p of recs) {
+        if (p.deviation)
+            deviations++;
+        const h = p.manifest_hash;
+        if (!h) {
+            unprotocolled++;
+            continue;
+        }
+        const w = windows.get(String(h));
+        if (w) {
+            w.count++;
+            w.last_ts = p.ts;
+        }
+        else
+            windows.set(String(h), { manifest_hash: h, count: 1, first_ts: p.ts, last_ts: p.ts });
+    }
+    const protocols = [...windows.values()].sort((a, b) => String(a.first_ts) < String(b.first_ts) ? -1 : String(a.first_ts) > String(b.first_ts) ? 1 : 0);
+    return { protocols, deviations, unprotocolled };
+}
+/** spec/health.md §4: the patient's episodes; `reviewed` holds "<session_id>:<seq>" of reviewed break-glass. */
+export function episodesPack(items, o) {
+    const done = new Set(o.reviewed);
+    const episodes = o.tags
+        .map((tag) => ({
+        tag,
+        items: items.filter((i) => i.tag === tag).map(({ tag: _t, ...rest }) => rest),
+    }))
+        .filter((e) => e.items.length > 0);
+    const pending = items.filter((i) => i.payload.kind === "break_glass" && !done.has(`${i.session_id}:${i.seq}`));
+    return {
+        v: 1,
+        episodes,
+        total: items.length,
+        pending_break_glass: pending.length,
+        protocols: protocolTrail(items.map((i) => i.payload)),
+        generated_at: o.generated_at,
+    };
+}
+const decoder = new TextDecoder();
+export function healthFindings(lines, bodies, closing = false) {
+    const out = [];
+    const recommendations = [];
+    const confirmed = new Set();
+    let closed = closing;
+    for (const l of lines) {
+        const e = JSON.parse(l);
+        if (e.kind === "session.close")
+            closed = true;
+        if (e.kind !== "sdk.event" || !String(e.meta.type).startsWith("health."))
+            continue;
+        const body = bodies(e.body_hash);
+        let data = {};
+        try {
+            data = body ? JSON.parse(decoder.decode(body)) : {};
+        }
+        catch { }
+        const payload = data?.payload;
+        if (!payload || typeof payload !== "object")
+            continue;
+        const kind = payload.kind;
+        if (kind === "recommendation")
+            recommendations.push([e.seq, recommendationHash(payload)]);
+        else if (kind === "confirmation" || kind === "break_glass") {
+            if (!verifyHealthSignature(payload, String(data.episode_tag)))
+                out.push({
+                    code: "HEALTH_SIGNATURE_INVALID",
+                    source: "detectors",
+                    severity: "warning",
+                    ref: { seq: e.seq, kind },
+                    detail: "A clinician signature that isn't theirs, or signs another action.",
+                });
+            else if (kind === "confirmation")
+                confirmed.add(String(payload.recommendation_hash));
+            else
+                out.push({
+                    code: "BREAK_GLASS",
+                    source: "detectors",
+                    severity: "warning",
+                    ref: { seq: e.seq, clinician: String(payload.clinician) },
+                    detail: "Emergency access to a record, signed by the clinician.",
+                });
+        }
+    }
+    if (closed)
+        for (const [seq, h] of recommendations)
+            if (!confirmed.has(h))
+                out.push({
+                    code: "UNCONFIRMED_RECOMMENDATION",
+                    source: "detectors",
+                    severity: "advisory",
+                    ref: { seq, recommendation_hash: h },
+                    detail: "A model's recommendation no clinician confirmed.",
+                });
+    return out;
+}

package/dist/index.d.ts

@@ -1,53 +1,75 @@
-export { A2A_STREAMING, type AgentCardReport, a2aMethod, a2aRequestMeta, a2aResponseMeta, agentCardDigest, agentCardPayload, verifyAgentCard, } from "./a2a/index.ts";
+export { A2A_STREAMING, type AgentCardReport, a2aMethod, a2aRequestMeta, a2aResponseMeta, a2aRestMethod, a2aRestRequestMeta, a2aRestResponseMeta, agentCardDigest, agentCardPayload, gatewayCardKey, rewriteAgentCard, verifyAgentCard, } from "./a2a/index.ts";
 export { causality, memoryXray } from "./agents/index.ts";
 export { type DetectorOptions, detectors, fingerprint } from "./analysis/detectors.ts";
 export { FAULTS, type Fault, faultOf } from "./analysis/faults.ts";
-export { type AnalyzeOptions, analyze, type ClaimVerdict, type CriterionResult, checkFlightPlan, checkpointReplay, dualWitness, eventsOf, type Finding as AnalysisFinding, findingKey, type Landing, landing, OUTCOMES, type Outcome, type OutcomeRollup, rollup, type Severity, type WasteReason, type WasteReport, waste, } from "./analysis/index.ts";
+export { type Accuracy, type AnalyzeOptions, type AnswerClaims, analyze, answerClaims, answerCredential, answerRisk, answersOf, answerText, type ClaimEntry, type ClaimVerdict, type CriterionResult, canonicalNumber, checkAgainstPacks, checkFlightPlan, checkpointReplay, detectorAccuracy, dualWitness, Evidence, eventsOf, type Fact, type Finding as AnalysisFinding, factsIn, findingKey, type GroundedClaim, groundingFindings, groundingRequest, HOLD_TRIGGERS, identifiersIn, judgeFindings, judgeRequest, type Label as AccuracyLabel, type Landing, landing, loadReferencePacks, modelGroundingFindings, normaliseValue, OUTCOMES, type Outcome, type OutcomeRollup, packsFor, parseGroundingAnswer, parseJudgeAnswer, type ReferenceFact, type ReferencePack, type ReferenceVerdict, referenceContext, rollup, type Severity, schemaProblem, toolHallucinations, verifyAnswerCredential, type WasteReason, type WasteReport, waste, wilsonLow, } from "./analysis/index.ts";
 export { MITRE_ATLAS, OWASP_ASI, TAXONOMY, type Taxonomy, taxonomyOf, } from "./analysis/taxonomy.ts";
-export { type ApprovalFinding, approvalFindings } from "./approvals/index.ts";
+export { type ApprovalFinding, approvalConfirmation, approvalFindings, argsHash, verifyConfirmation, } from "./approvals/index.ts";
 export { textWarnings } from "./approvals/warnings.ts";
 export { type ArchiveFile, type ArchiveManifest, type ArchiveReport, archiveDigest, archiveEntry, archiveManifest, verifyArchive, } from "./archive/index.ts";
+export { archiveParquet } from "./archive/parquet.ts";
 export { type Attestation, attest, isReadOnly, normalise, parseCommand } from "./attest/index.ts";
 export { type AuthorityFinding, authorityAt, authorityTimeline, automationSurprise, type Mode as AuthorityMode, type Span as AuthoritySpan, } from "./authority/index.ts";
+export { badgeSvg, RECORD_STATES, type RecordState, recordBadge, recordState, } from "./badge/index.ts";
 export { type Invoice, type InvoiceLine, invoice, loadPlans, type Plan, type Plans, renderTaxInvoice, stripeSignatureOk, type TaxInvoice, type TaxInvoiceInput, taxInvoice, } from "./billing/index.ts";
 export { type AgentIdentity, checkAgent, sessionBom } from "./bom/index.ts";
 export { BlackboxApiError, type Client, type ClientOptions, client, type SessionQuery, } from "./client/index.ts";
 export { ART12_MIN_RETENTION_DAYS, type Art12Check, type Art12Report, art12Check, } from "./compliance/art12.ts";
-export { complianceFacts, complianceReport, type Facts, type Framework, type Report as ComplianceReport, renderReport, } from "./compliance/index.ts";
+export { accuracyFact, complianceFacts, complianceReport, controlsFact, type Facts, type Framework, hallucinationFacts, type Report as ComplianceReport, renderReport, } from "./compliance/index.ts";
+export { renderZaniiCompliance, type ZaniiComplianceReport, zaniiCompliance, } from "./compliance/zanii.ts";
+export { type Constitution, type ConstitutionRule, constitutionHash, createConstitution, evaluateConstitution, governanceOf, verifyConstitution, } from "./constitution/index.ts";
 export { type CallCost, type CostReport, callMicroUsd, effectivePrice, formatAed, type LoadedPrices, loadPrices, type ModelPrice, type PriceTable, priceCall, priceFor, promptTokens, requestsOf, sessionCost, type Tokens, toAedFils, tokensOf, } from "./cost/index.ts";
+export { agentCv, buildCv, cvHash, verifyCv } from "./cv/index.ts";
 export { type AuditRow, CORE_EVIDENCE, CORE_IDENTIFIERS, type Connector as AuditConnector, canaryIdentifier, checkAuditConnector, type DataFinding, type DataRules, dataClasses, dataFindings, dataFingerprint, dataMeta, dataScan, dataTopology, hasEvidence, type Identifier, type Lineage, lineage, luhn, normalizeValue, parseAuditLog, parseCsv, reconcileSystem, type SystemReport, type Topology, toolWitness, unevidenced, verifyToolWitness, witnessOf, } from "./data/index.ts";
 export { type Directive, type DirectiveItem, type DirectiveOptions, directives, fleetDirectives, } from "./directives/index.ts";
+export { argumentLeaves, type Disclosure, type DisclosureEnvelope, discloseFields, disclosureEnvelope, verifyDisclosure, verifyEventDisclosure, } from "./disclosure/index.ts";
 export { checkDrill, drillReport, type Fault as DrillFault } from "./drills/index.ts";
 export { checkDuty, type DutyFinding, type DutyLimits, dutyFindings } from "./duty/index.ts";
+export { openSegments, type SealedSegment } from "./encryption/index.ts";
+export { type EvidencePack, type EvidencePackOptions, evidencePack, renderEvidencePack, } from "./evidence/index.ts";
+export { buildEquivocationProof, compareViews, cosignLedgerSth, verifyEquivocationProof, verifyLedgerCosignature, } from "./federation/index.ts";
+export { buildOwnerAttestation, buildPayment, CURRENCIES, FTA_WALL_ID, financeFindings, formatMoney, ftaPayload, parseMoney, paymentsOf, screenCounterparty, screeningPayload, verifyOwnerAttestation, verifyOwnerBinding, } from "./finance/index.ts";
 export { aggregateFindings, airworthiness, type Collision, collisions, didFromSeed, type FindingGroup, incidentReport, logbook, type Summary, sessionSummary, signatureOf, signatures, signCertificate, verifyCertificate, } from "./fleet/index.ts";
+export { type AppealItem, type AppealPack, appealPack, decisionPayload, GOV_DECISION_KINDS, renderAppealPack, ruleConsistency, signSubjectClaim, subjectTag, verifyDecision, verifyFactors, verifySubjectClaim, } from "./gov/index.ts";
+export { accessPayload, breakGlass, checkEpisodeTag, clinicianConfirmation, type EpisodeItem, episodeSeed, episodesPack, episodeTag, healthFindings, protocolTrail, recommendationHash, recommendationPayload, verifyCommitment, verifyHealthSignature, } from "./health/index.ts";
 export { attachBlackbox, BlackboxAgentHooks, BlackboxCallbackHandler, type BlackboxCallbacks, blackboxAgentHooks, blackboxCallbacks, blackboxMiddleware, type EventSink, llmIds, llmIdsOf, trackMemory, wrapAnthropic, wrapBedrock, wrapGemini, wrapOpenAI, } from "./hooks/index.ts";
 export { type AgentSink, BlackboxStoppedError, blackboxAgentMiddleware, blackboxHitl, type HitlRequest, } from "./hooks/langchain-agent.ts";
 export { blackboxCheckpointer } from "./hooks/langgraph-checkpoint.ts";
 export { MANAGED_END, MANAGED_START, managedBlock, protectedEdit } from "./hooks/protect.ts";
 export { type Investigation, investigation, renderInvestigation, } from "./investigate/index.ts";
 export { type McpWrapOptions, mcpWrap } from "./mcp-wrap/index.ts";
+export { commitContent, memoryChain, memoryEntry, verifyMemoryContent, verifyMemoryEntry, } from "./memory/index.ts";
 export { type AmountUnit, anthropicStatement, type Baseline, baselines, type Connector, checkConnector, checkStatement, csvStatement, customStatement, decimalToMicroUsd, fuel, modelSpend, openaiStatement, pageParams, parseXml, reconcileBilling, requestFor, resolvePath, type Statement, } from "./money/index.ts";
-export { filingPack, type OccurrenceFacts, type OccurrenceFramework, type OccurrenceReport, occurrenceFacts, occurrenceReport, renderOccurrence, } from "./occurrence/index.ts";
+export { deadlinesDue, filingPack, type OccurrenceFacts, type OccurrenceFramework, type OccurrenceReport, occurrenceFacts, occurrenceReport, renderOccurrence, } from "./occurrence/index.ts";
 export { ingestOcsf, type OcsfEvent, type OcsfVersion, ocsfLine, toOcsf } from "./ocsf/index.ts";
 export { toOtlp } from "./otlp/index.ts";
 export { checkIdentifier, checkPack, corePack, type PackEntry, packData, packFrameworks, } from "./packs/index.ts";
 export { type PolicyChange, type PolicyDelta, policyDelta } from "./policy/delta.ts";
 export { type Draft, type DraftGroup, policyDrafts } from "./policy/drafts.ts";
-export { audited, type CompiledPolicy, compilePolicy, type Decision, decide, loadPolicy, mcpToolHints, type Policy, policyFindings, type Rule, type ToolHints, } from "./policy/index.ts";
+export { audited, type CompiledPolicy, compilePolicy, type Decision, decide, ENVIRONMENT, environmentOf, loadPolicy, mcpToolHints, type Policy, policyFindings, type Rule, type ToolHints, toolDefinitionHash, } from "./policy/index.ts";
+export { fromZaniiPolicy, toZaniiPolicy } from "./policy/zanii.ts";
+export { bindPqKey, PQ_ALG, pqAvailable, pqPublicKey, pqSeedOf, pqTransitionPayload, verifyPqBinding, } from "./pq/index.ts";
 export { calibration, FEATURES, features, MIN_EACH, type PrecogModel, precogFindings, precogReport, predict, prefixOf, splitOf, TARGET, train, } from "./precog/index.ts";
 export { type InterventionEvidence, interventionEvidence, interventionGain, } from "./precog/intervention.ts";
 export { activities, buildNormal, type NormalModel, type NormalScore, normalScore, normalThreshold, } from "./precog/normal.ts";
 export { type PreflightFinding, preflightFindings } from "./preflight/index.ts";
 export { type Rating, type TypeUnratedFinding, typeRatings, typeUnrated, } from "./ratings/index.ts";
 export { type Finding, type FindingCode, type Harness, loadLocal, type ReconcileOptions, RecordNotVerified, type Report, reconcile, } from "./reconcile/index.ts";
+/** Canonical JSON (keys sorted, no whitespace, JavaScript number formatting), as hashed. */
+export { canonical } from "./reconcile/shared.ts";
 export { cassette, requestKey, type Take } from "./replay/index.ts";
 export { ORPHAN_TEXT, repairToolCalls } from "./replay/repair.ts";
+export { checkSearch, type SearchMatch, type SearchQuery, searchEvents } from "./search/index.ts";
 export { type DrainResult, drainSpools } from "./session/drain.ts";
 export { BlackboxSession, checkEgress, type EgressCheck, type FlightPlan, type LlmCallIds, type SessionError, type SessionOptions, type SessionState, type SessionStats, session, stableEventId, } from "./session/index.ts";
+export { assembleSla, assessCompliance, buildSlaBody, signSla, slaHash, verifySla, } from "./sla/index.ts";
+export { assembleSuccession, buildSuccessionBody, type Succession, type SuccessionBody, type SuccessionReason, signSuccession, successionHash, verifyLineage, verifySuccession, } from "./succession/index.ts";
 export { type TimestampReport, timestampRequest, verifyTimestamp, } from "./timestamp/index.ts";
+export { resolveToken, resolveTokens, tokenFor } from "./tokens/index.ts";
 export { addCheckpointBody, type Cbor, cborDecode, cborEncode, checkpointText, consistencyProof, cosign, cosignMldsa, ed25519PublicKey, inclusionProof, keyRotationNote, leafHash, logKid, makeReceipt, merkleRoot, mldsaAvailable, mldsaPublicKey, noteVkey, parseAddCheckpoint, parseCheckpoint, parseVkey, RECEIPT_SUB, SESSION_CONTENT_TYPE, sessionStatement, signNote, signStatement, splitNote, statementEntry, subtreeMessage, transparentStatement, verifyConsistency, verifyCoseSign1, verifyCosignature, verifyInclusion, verifyKeyRotation, verifyNote, verifyReceipt, verifyTransparency, } from "./transparency/index.ts";
 export { type Compensation, checkCompensations, runUndo, type UndoFinding, type UndoStatus, type UndoStep, undoFindings, undoPlan, } from "./undo/index.ts";
 export * from "./verify/index.ts";
 export { VERSION } from "./version.ts";
+export { checkOutput, WALLS, type Wall, wallFindings, wallManifestHash, } from "./walls/index.ts";
 export { type Conditions, type Sample, weather } from "./weather/index.ts";
 export { postReceipt, receiptFor, type Tree, workspaceTree } from "./workspace-receipt/index.ts";

package/dist/index.js

@@ -1,55 +1,77 @@
 // Public API of @zanii/blackbox. Everything customers can import is re-exported here.
 // Keep this file in step with sdks/python/src/zanii_blackbox/__init__.py (the SDKs mirror each other).
-export { A2A_STREAMING, a2aMethod, a2aRequestMeta, a2aResponseMeta, agentCardDigest, agentCardPayload, verifyAgentCard, } from "./a2a/index.js";
+export { A2A_STREAMING, a2aMethod, a2aRequestMeta, a2aResponseMeta, a2aRestMethod, a2aRestRequestMeta, a2aRestResponseMeta, agentCardDigest, agentCardPayload, gatewayCardKey, rewriteAgentCard, verifyAgentCard, } from "./a2a/index.js";
 export { causality, memoryXray } from "./agents/index.js";
 export { detectors, fingerprint } from "./analysis/detectors.js";
 export { FAULTS, faultOf } from "./analysis/faults.js";
-export { analyze, checkFlightPlan, checkpointReplay, dualWitness, eventsOf, findingKey, landing, OUTCOMES, rollup, waste, } from "./analysis/index.js";
+export { analyze, answerClaims, answerCredential, answerRisk, answersOf, answerText, canonicalNumber, checkAgainstPacks, checkFlightPlan, checkpointReplay, detectorAccuracy, dualWitness, Evidence, eventsOf, factsIn, findingKey, groundingFindings, groundingRequest, HOLD_TRIGGERS, identifiersIn, judgeFindings, judgeRequest, landing, loadReferencePacks, modelGroundingFindings, normaliseValue, OUTCOMES, packsFor, parseGroundingAnswer, parseJudgeAnswer, referenceContext, rollup, schemaProblem, toolHallucinations, verifyAnswerCredential, waste, wilsonLow, } from "./analysis/index.js";
 export { MITRE_ATLAS, OWASP_ASI, TAXONOMY, taxonomyOf, } from "./analysis/taxonomy.js";
-export { approvalFindings } from "./approvals/index.js";
+export { approvalConfirmation, approvalFindings, argsHash, verifyConfirmation, } from "./approvals/index.js";
 export { textWarnings } from "./approvals/warnings.js";
 export { archiveDigest, archiveEntry, archiveManifest, verifyArchive, } from "./archive/index.js";
+export { archiveParquet } from "./archive/parquet.js";
 export { attest, isReadOnly, normalise, parseCommand } from "./attest/index.js";
 export { authorityAt, authorityTimeline, automationSurprise, } from "./authority/index.js";
+export { badgeSvg, RECORD_STATES, recordBadge, recordState, } from "./badge/index.js";
 export { invoice, loadPlans, renderTaxInvoice, stripeSignatureOk, taxInvoice, } from "./billing/index.js";
 export { checkAgent, sessionBom } from "./bom/index.js";
 export { BlackboxApiError, client, } from "./client/index.js";
 export { ART12_MIN_RETENTION_DAYS, art12Check, } from "./compliance/art12.js";
-export { complianceFacts, complianceReport, renderReport, } from "./compliance/index.js";
+export { accuracyFact, complianceFacts, complianceReport, controlsFact, hallucinationFacts, renderReport, } from "./compliance/index.js";
+export { renderZaniiCompliance, zaniiCompliance, } from "./compliance/zanii.js";
+export { constitutionHash, createConstitution, evaluateConstitution, governanceOf, verifyConstitution, } from "./constitution/index.js";
 export { callMicroUsd, effectivePrice, formatAed, loadPrices, priceCall, priceFor, promptTokens, requestsOf, sessionCost, toAedFils, tokensOf, } from "./cost/index.js";
+export { agentCv, buildCv, cvHash, verifyCv } from "./cv/index.js";
 export { CORE_EVIDENCE, CORE_IDENTIFIERS, canaryIdentifier, checkAuditConnector, dataClasses, dataFindings, dataFingerprint, dataMeta, dataScan, dataTopology, hasEvidence, lineage, luhn, normalizeValue, parseAuditLog, parseCsv, reconcileSystem, toolWitness, unevidenced, verifyToolWitness, witnessOf, } from "./data/index.js";
 export { directives, fleetDirectives, } from "./directives/index.js";
+export { argumentLeaves, discloseFields, disclosureEnvelope, verifyDisclosure, verifyEventDisclosure, } from "./disclosure/index.js";
 export { checkDrill, drillReport } from "./drills/index.js";
 export { checkDuty, dutyFindings } from "./duty/index.js";
+export { openSegments } from "./encryption/index.js";
+export { evidencePack, renderEvidencePack, } from "./evidence/index.js";
+export { buildEquivocationProof, compareViews, cosignLedgerSth, verifyEquivocationProof, verifyLedgerCosignature, } from "./federation/index.js";
+export { buildOwnerAttestation, buildPayment, CURRENCIES, FTA_WALL_ID, financeFindings, formatMoney, ftaPayload, parseMoney, paymentsOf, screenCounterparty, screeningPayload, verifyOwnerAttestation, verifyOwnerBinding, } from "./finance/index.js";
 export { aggregateFindings, airworthiness, collisions, didFromSeed, incidentReport, logbook, sessionSummary, signatureOf, signatures, signCertificate, verifyCertificate, } from "./fleet/index.js";
+export { appealPack, decisionPayload, GOV_DECISION_KINDS, renderAppealPack, ruleConsistency, signSubjectClaim, subjectTag, verifyDecision, verifyFactors, verifySubjectClaim, } from "./gov/index.js";
+export { accessPayload, breakGlass, checkEpisodeTag, clinicianConfirmation, episodeSeed, episodesPack, episodeTag, healthFindings, protocolTrail, recommendationHash, recommendationPayload, verifyCommitment, verifyHealthSignature, } from "./health/index.js";
 export { attachBlackbox, BlackboxAgentHooks, BlackboxCallbackHandler, blackboxAgentHooks, blackboxCallbacks, blackboxMiddleware, llmIds, llmIdsOf, trackMemory, wrapAnthropic, wrapBedrock, wrapGemini, wrapOpenAI, } from "./hooks/index.js";
 export { BlackboxStoppedError, blackboxAgentMiddleware, blackboxHitl, } from "./hooks/langchain-agent.js";
 export { blackboxCheckpointer } from "./hooks/langgraph-checkpoint.js";
 export { MANAGED_END, MANAGED_START, managedBlock, protectedEdit } from "./hooks/protect.js";
 export { investigation, renderInvestigation, } from "./investigate/index.js";
 export { mcpWrap } from "./mcp-wrap/index.js";
+export { commitContent, memoryChain, memoryEntry, verifyMemoryContent, verifyMemoryEntry, } from "./memory/index.js";
 export { anthropicStatement, baselines, checkConnector, checkStatement, csvStatement, customStatement, decimalToMicroUsd, fuel, modelSpend, openaiStatement, pageParams, parseXml, reconcileBilling, requestFor, resolvePath, } from "./money/index.js";
-export { filingPack, occurrenceFacts, occurrenceReport, renderOccurrence, } from "./occurrence/index.js";
+export { deadlinesDue, filingPack, occurrenceFacts, occurrenceReport, renderOccurrence, } from "./occurrence/index.js";
 export { ingestOcsf, ocsfLine, toOcsf } from "./ocsf/index.js";
 export { toOtlp } from "./otlp/index.js";
 export { checkIdentifier, checkPack, corePack, packData, packFrameworks, } from "./packs/index.js";
 export { policyDelta } from "./policy/delta.js";
 export { policyDrafts } from "./policy/drafts.js";
-export { audited, compilePolicy, decide, loadPolicy, mcpToolHints, policyFindings, } from "./policy/index.js";
+export { audited, compilePolicy, decide, ENVIRONMENT, environmentOf, loadPolicy, mcpToolHints, policyFindings, toolDefinitionHash, } from "./policy/index.js";
+export { fromZaniiPolicy, toZaniiPolicy } from "./policy/zanii.js";
+export { bindPqKey, PQ_ALG, pqAvailable, pqPublicKey, pqSeedOf, pqTransitionPayload, verifyPqBinding, } from "./pq/index.js";
 export { calibration, FEATURES, features, MIN_EACH, precogFindings, precogReport, predict, prefixOf, splitOf, TARGET, train, } from "./precog/index.js";
 export { interventionEvidence, interventionGain, } from "./precog/intervention.js";
 export { activities, buildNormal, normalScore, normalThreshold, } from "./precog/normal.js";
 export { preflightFindings } from "./preflight/index.js";
 export { typeRatings, typeUnrated, } from "./ratings/index.js";
 export { loadLocal, RecordNotVerified, reconcile, } from "./reconcile/index.js";
+/** Canonical JSON (keys sorted, no whitespace, JavaScript number formatting), as hashed. */
+export { canonical } from "./reconcile/shared.js";
 export { cassette, requestKey } from "./replay/index.js";
 export { ORPHAN_TEXT, repairToolCalls } from "./replay/repair.js";
+export { checkSearch, searchEvents } from "./search/index.js";
 export { drainSpools } from "./session/drain.js";
 export { BlackboxSession, checkEgress, session, stableEventId, } from "./session/index.js";
+export { assembleSla, assessCompliance, buildSlaBody, signSla, slaHash, verifySla, } from "./sla/index.js";
+export { assembleSuccession, buildSuccessionBody, signSuccession, successionHash, verifyLineage, verifySuccession, } from "./succession/index.js";
 export { timestampRequest, verifyTimestamp, } from "./timestamp/index.js";
+export { resolveToken, resolveTokens, tokenFor } from "./tokens/index.js";
 export { addCheckpointBody, cborDecode, cborEncode, checkpointText, consistencyProof, cosign, cosignMldsa, ed25519PublicKey, inclusionProof, keyRotationNote, leafHash, logKid, makeReceipt, merkleRoot, mldsaAvailable, mldsaPublicKey, noteVkey, parseAddCheckpoint, parseCheckpoint, parseVkey, RECEIPT_SUB, SESSION_CONTENT_TYPE, sessionStatement, signNote, signStatement, splitNote, statementEntry, subtreeMessage, transparentStatement, verifyConsistency, verifyCoseSign1, verifyCosignature, verifyInclusion, verifyKeyRotation, verifyNote, verifyReceipt, verifyTransparency, } from "./transparency/index.js";
 export { checkCompensations, runUndo, undoFindings, undoPlan, } from "./undo/index.js";
 export * from "./verify/index.js";
 export { VERSION } from "./version.js";
+export { checkOutput, WALLS, wallFindings, wallManifestHash, } from "./walls/index.js";
 export { weather } from "./weather/index.js";
 export { postReceipt, receiptFor, workspaceTree } from "./workspace-receipt/index.js";

package/dist/memory/index.d.ts

@@ -0,0 +1,36 @@
+type Obj = Record<string, unknown>;
+/** Zanii's salted commitment to memory content. */
+export declare function commitContent(content: string, salt?: string): {
+    commitment: string;
+    salt: string;
+};
+/** The entry was about `content`, given the salt kept at write time. */
+export declare const verifyMemoryContent: (content: string, salt: string, commitment: string) => boolean;
+/** Zanii's memory.write payload, after `prev` (the previous entry; null starts a chain). Keep the salt. */
+export declare function memoryEntry(input: {
+    content: string;
+    ts: string;
+    kind?: string;
+    prev?: Obj | null;
+    salt?: string;
+    agent?: string;
+    tags?: string[];
+}): {
+    payload: Obj;
+    salt: string;
+};
+/** Zanii's check of one entry: well formed, and its entry_hash matches. */
+export declare function verifyMemoryEntry(payload: unknown): {
+    ok: boolean;
+    reasons: string[];
+};
+/** Walks entries in order: each checks, links to the one before and counts up by one. The first may continue a chain from elsewhere. */
+export declare function memoryChain(entries: readonly unknown[]): {
+    ok: boolean;
+    length: number;
+    broken: {
+        index: number;
+        reason: string;
+    }[];
+};
+export {};