@arnilo/prism 0.6.0 → 0.8.0

package/dist/evidence-grounding.js

@@ -0,0 +1,162 @@
+const MAX_EVIDENCE_FIGURES = 4096;
+const MAX_EVIDENCE_DEPTH = 16;
+const MAX_EVIDENCE_NODES = 16 * 1024;
+const MAX_EVIDENCE_TEXT_CHARS = 128 * 1024;
+const MAX_CLAIM_CHARS = 128;
+const MAX_CITATION_DISTANCE = 96;
+const EVIDENCE_CITATION = /\[evidence:([a-zA-Z0-9._:-]{1,128})\]/g;
+const NUMERIC_CLAIM = /(?<![\p{L}\p{N}_])~?[$€£¥]?[-+]?(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?[kKmMbB]?%?(?![\p{L}\p{N}_])/gu;
+/**
+ * Deterministic output guardrail for figures that must be grounded in same-run tool results
+ * or host-governed evidence. It never calls a provider, store, or extractor asynchronously.
+ */
+export function createClaimGroundingGuardrail(options) {
+    const resolved = resolveOptions(options);
+    return {
+        name: "claim-grounding",
+        stage: "output",
+        revision: "1",
+        evaluate(context) {
+            if (!resolved.requireEvidenceForNumbers)
+                return { action: "allow" };
+            const figures = evidenceFigures(resolved.evidenceSources, context);
+            const refs = new Set(figures.flatMap((figure) => (figure.ref === undefined ? [] : [figure.ref])));
+            for (const claim of outputClaims(context.value.content)) {
+                const block = context.value.content[claim.contentIndex];
+                if (matchesEvidence(claim, figures, resolved.tolerance) || (block?.type === "text" && citesEvidence(block.text, claim.end, refs)))
+                    continue;
+                const metadata = {
+                    violation: true,
+                    claim: claim.text.slice(0, MAX_CLAIM_CHARS),
+                    contentIndex: claim.contentIndex,
+                    start: claim.end - claim.text.length,
+                    end: claim.end,
+                };
+                return resolved.onViolation === "block"
+                    ? { action: "block", reason: "claim_ungrounded", metadata }
+                    : { action: "allow", reason: "claim_ungrounded", metadata };
+            }
+            return { action: "allow" };
+        },
+    };
+}
+function resolveOptions(options) {
+    if (!options || typeof options.requireEvidenceForNumbers !== "boolean")
+        throw new TypeError("Claim grounding requireEvidenceForNumbers must be boolean");
+    const evidenceSources = options.evidenceSources ?? "tool_results";
+    if (evidenceSources !== "tool_results" && typeof evidenceSources !== "function")
+        throw new TypeError('Claim grounding evidenceSources must be "tool_results" or an extractor');
+    const onViolation = options.onViolation ?? "block";
+    if (onViolation !== "block" && onViolation !== "flag")
+        throw new TypeError('Claim grounding onViolation must be "block" or "flag"');
+    const tolerance = options.tolerance ?? "exact";
+    if (tolerance !== "exact" && tolerance !== "rounded")
+        throw new TypeError('Claim grounding tolerance must be "exact" or "rounded"');
+    return { requireEvidenceForNumbers: options.requireEvidenceForNumbers, evidenceSources, onViolation, tolerance };
+}
+function evidenceFigures(source, context) {
+    if (source !== "tool_results")
+        return source({
+            sessionId: context.sessionId,
+            runId: context.runId,
+            metadata: context.metadata,
+            toolResults: context.toolResults ?? [],
+        })
+            .filter(validFigure)
+            .slice(0, MAX_EVIDENCE_FIGURES);
+    const figures = [];
+    const budget = { chars: MAX_EVIDENCE_TEXT_CHARS, nodes: MAX_EVIDENCE_NODES };
+    for (const result of context.toolResults ?? []) {
+        if (result.error)
+            continue;
+        const ref = `tool:${result.toolCallId}`;
+        collectFigures(result.value, figures, ref, new WeakSet(), 0, budget);
+        for (const block of result.content ?? [])
+            if (block.type === "text")
+                collectTextFigures(block.text, figures, ref, budget);
+    }
+    return figures;
+}
+function validFigure(value) {
+    return typeof value?.value === "number" && Number.isFinite(value.value) && (value.ref === undefined || citationRef(value.ref));
+}
+function collectFigures(value, figures, ref, seen = new WeakSet(), depth = 0, budget = { chars: MAX_EVIDENCE_TEXT_CHARS, nodes: MAX_EVIDENCE_NODES }) {
+    if (figures.length >= MAX_EVIDENCE_FIGURES || depth > MAX_EVIDENCE_DEPTH || budget.nodes-- < 1)
+        return;
+    if (typeof value === "number") {
+        if (Number.isFinite(value))
+            figures.push({ value, ref });
+        return;
+    }
+    if (typeof value === "string") {
+        collectTextFigures(value, figures, ref, budget);
+        return;
+    }
+    if (!value || typeof value !== "object" || seen.has(value))
+        return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectFigures(item, figures, ref, seen, depth + 1, budget);
+        return;
+    }
+    for (const item of Object.values(value))
+        collectFigures(item, figures, ref, seen, depth + 1, budget);
+}
+function collectTextFigures(text, figures, ref, budget) {
+    const bounded = text.slice(0, budget.chars);
+    budget.chars -= bounded.length;
+    for (const claim of claims(bounded, 0)) {
+        if (figures.length >= MAX_EVIDENCE_FIGURES)
+            return;
+        figures.push({ value: claim.value, ref });
+    }
+}
+function outputClaims(content) {
+    const out = [];
+    for (let index = 0; index < content.length; index += 1) {
+        const block = content[index];
+        if (block?.type !== "text")
+            continue;
+        out.push(...claims(block.text, index));
+    }
+    return out;
+}
+function claims(text, contentIndex) {
+    const out = [];
+    NUMERIC_CLAIM.lastIndex = 0;
+    for (let match = NUMERIC_CLAIM.exec(text); match; match = NUMERIC_CLAIM.exec(text)) {
+        const token = match[0];
+        const parsed = parseNumber(token);
+        if (parsed === undefined)
+            continue;
+        out.push({ text: token, value: parsed.value, tolerance: parsed.tolerance, end: match.index + token.length, contentIndex });
+    }
+    return out;
+}
+function parseNumber(token) {
+    const compact = token.replace(/^~?[$€£¥]?[-+]?/, "").replace(/%$/, "");
+    const suffix = compact.at(-1)?.toLowerCase();
+    const multiplier = suffix === "k" ? 1_000 : suffix === "m" ? 1_000_000 : suffix === "b" ? 1_000_000_000 : 1;
+    const numberText = (multiplier === 1 ? compact : compact.slice(0, -1)).replace(/,/g, "");
+    const value = Number(numberText) * multiplier;
+    if (!Number.isFinite(value))
+        return undefined;
+    const fraction = numberText.split(".")[1]?.length ?? 0;
+    return { value, tolerance: 0.5 * multiplier * 10 ** -fraction };
+}
+function matchesEvidence(claim, figures, tolerance) {
+    return figures.some((figure) => Math.abs(figure.value - claim.value) <= (tolerance === "rounded" ? claim.tolerance : 0));
+}
+function citesEvidence(text, end, refs) {
+    const nearby = text.slice(end, end + MAX_CITATION_DISTANCE);
+    EVIDENCE_CITATION.lastIndex = 0;
+    for (let match = EVIDENCE_CITATION.exec(nearby); match; match = EVIDENCE_CITATION.exec(nearby))
+        if (refs.has(match[1] ?? ""))
+            return true;
+    return false;
+}
+function citationRef(value) {
+    return /^[a-zA-Z0-9._:-]{1,128}$/.test(value);
+}
+//# sourceMappingURL=evidence-grounding.js.map

package/dist/host-composition.d.ts

@@ -0,0 +1,91 @@
+import type { Agent, AgentConfig, CheckpointStore, SecureAgentOptions, SessionStore } from "./contracts.js";
+import type { SecretRedactor } from "./redaction.js";
+export type HostCompositionProfile = "personal" | "local-personal" | "business" | "business-worker" | "multi-tenant-worker";
+export declare class HostCompositionError extends Error {
+    readonly code: string;
+    constructor(message: string, code?: string);
+}
+export interface HostCompositionGovernance {
+    readonly modelRouter?: unknown;
+    readonly budgetPolicy?: unknown;
+    readonly rateLimitPolicy?: unknown;
+    readonly supported?: boolean;
+    readonly [key: string]: unknown;
+}
+export interface HostCompositionOptions {
+    readonly profile?: HostCompositionProfile;
+    readonly agent?: Agent | AgentConfig | SecureAgentOptions | Partial<AgentConfig>;
+    readonly store?: SessionStore | CheckpointStore | {
+        readonly kind?: string;
+        readonly durable?: boolean;
+        [key: string]: unknown;
+    };
+    readonly checkpoints?: CheckpointStore;
+    readonly workspaceRoot?: string;
+    readonly sandboxRoots?: readonly string[];
+    readonly credentialRefs?: readonly string[];
+    readonly connectedApps?: {
+        readonly appIds: readonly string[];
+        readonly serverIds: readonly string[];
+    };
+    readonly governance?: HostCompositionGovernance;
+    readonly redactor?: SecretRedactor;
+    /** Explicit opt-in for live network checks; inert by default. */
+    readonly liveChecks?: boolean;
+}
+export interface HostCompositionToolReport {
+    readonly name: string;
+    readonly description?: string;
+    readonly hasParameters: boolean;
+}
+export interface HostCompositionReport {
+    readonly profile: "personal" | "business";
+    readonly effectiveTools: readonly HostCompositionToolReport[];
+    readonly credentialReferences: readonly string[];
+    readonly connectedApps?: {
+        readonly appIds: readonly string[];
+        readonly serverIds: readonly string[];
+    };
+    readonly ownership: {
+        readonly tenantId?: string;
+        readonly accountId?: string;
+        readonly userId?: string;
+    };
+    readonly storage: {
+        readonly kind: string;
+        readonly durable: boolean;
+    };
+    readonly sandbox: {
+        readonly workspaceRoot?: string;
+        readonly roots: readonly string[];
+        readonly isolated: boolean;
+    };
+    readonly governance: {
+        readonly permission: boolean;
+        readonly trust: boolean;
+        readonly redactor: boolean;
+        readonly validator: boolean;
+        readonly modelRouting: boolean;
+        readonly secure: boolean;
+    };
+    readonly readiness: {
+        readonly ok: boolean;
+        readonly errors: readonly string[];
+        readonly warnings: readonly string[];
+    };
+}
+/** Classifies a store by declared kind/durability and constructor name — never reads contents or connection strings (plan 084 Task 4 reuses it for run-bundle snapshots). */
+export declare function describeStorage(store: unknown, checkpoints: unknown): {
+    kind: string;
+    durable: boolean;
+};
+/**
+ * Inspects a host composition in an inert, bounded, and secret-redacting manner.
+ * Performs zero network calls by default.
+ */
+export declare function inspectHostComposition(options: HostCompositionOptions): HostCompositionReport;
+/**
+ * Asserts that a host composition meets all readiness requirements for its profile.
+ * Throws HostCompositionError on failure.
+ */
+export declare function assertHostCompositionReadiness(options: HostCompositionOptions): HostCompositionReport;

package/dist/host-composition.js

@@ -0,0 +1,279 @@
+import { isAbsolute, relative } from "node:path";
+import { assertIdentityActive, assertIdentityMatchesOwnership } from "./identity.js";
+export class HostCompositionError extends Error {
+    code;
+    constructor(message, code = "ERR_PRISM_HOST_COMPOSITION") {
+        super(message);
+        this.code = code;
+        this.name = "HostCompositionError";
+    }
+}
+function resolveAgentConfig(input) {
+    if (!input)
+        return undefined;
+    if ("config" in input && typeof input.config === "object" && input.config !== null) {
+        return input.config;
+    }
+    return input;
+}
+function normalizeProfile(profile) {
+    if (!profile)
+        return "personal";
+    if (profile === "business" || profile === "business-worker" || profile === "multi-tenant-worker") {
+        return "business";
+    }
+    return "personal";
+}
+function extractTools(toolsConfig) {
+    if (!toolsConfig)
+        return [];
+    if (Array.isArray(toolsConfig))
+        return toolsConfig;
+    if (typeof toolsConfig.list === "function") {
+        return toolsConfig.list();
+    }
+    return [];
+}
+function sanitizeCredentialRefs(refs = [], redactor) {
+    const sanitized = [];
+    for (const ref of refs) {
+        if (!ref || typeof ref !== "string")
+            continue;
+        const trimmed = ref.trim();
+        if (!trimmed)
+            continue;
+        // Credential references must be identifier names (env vars or vault keys), never raw secrets.
+        if (/^(?:sk-|ghp_|ey|Bearer\s+)/i.test(trimmed)) {
+            sanitized.push("[REDACTED_SECRET_VALUE]");
+            continue;
+        }
+        if (redactor && typeof redactor.redact === "function") {
+            sanitized.push(redactor.redact(trimmed));
+        }
+        else {
+            sanitized.push(trimmed);
+        }
+    }
+    return Object.freeze(sanitized);
+}
+const HARD_MAX_CONNECTED_APPS = 32;
+const MAX_CONNECTED_APP_IDENTIFIER_BYTES = 128;
+function copyConnectedApps(value) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== "object")
+        throw new HostCompositionError("Connected apps must provide identifier arrays");
+    return Object.freeze({
+        appIds: copyConnectedAppIdentifiers(value.appIds, "appIds"),
+        serverIds: copyConnectedAppIdentifiers(value.serverIds, "serverIds"),
+    });
+}
+function copyConnectedAppIdentifiers(value, name) {
+    if (!Array.isArray(value) || value.length > HARD_MAX_CONNECTED_APPS) {
+        throw new HostCompositionError(`Connected app ${name} must contain at most ${HARD_MAX_CONNECTED_APPS} identifiers`);
+    }
+    return Object.freeze(value.map((identifier) => {
+        if (typeof identifier !== "string" ||
+            !identifier.trim() ||
+            Buffer.byteLength(identifier, "utf8") > MAX_CONNECTED_APP_IDENTIFIER_BYTES) {
+            throw new HostCompositionError(`Connected app ${name} must contain 1..${MAX_CONNECTED_APP_IDENTIFIER_BYTES} byte identifiers`);
+        }
+        return identifier;
+    }));
+}
+function isContainedPath(parent, child) {
+    const rel = relative(parent, child);
+    return !rel.startsWith("..") && !isAbsolute(rel);
+}
+/** Classifies a store by declared kind/durability and constructor name — never reads contents or connection strings (plan 084 Task 4 reuses it for run-bundle snapshots). */
+export function describeStorage(store, checkpoints) {
+    const target = store ?? checkpoints;
+    if (!target || typeof target !== "object") {
+        return { kind: "none", durable: false };
+    }
+    const record = target;
+    const constructorName = target.constructor?.name ?? "";
+    const declaredKind = typeof record.kind === "string" ? record.kind.toLowerCase() : "";
+    // Explicit in-memory implementations are NEVER durable.
+    if (constructorName.includes("Memory") ||
+        declaredKind.includes("memory") ||
+        record.durable === false ||
+        record.durability === "ephemeral") {
+        return { kind: declaredKind || "memory", durable: false };
+    }
+    // Postgres, SQLite, or explicitly durable stores
+    if (record.durable === true ||
+        record.durability === "durable" ||
+        constructorName.includes("Postgres") ||
+        constructorName.includes("Sqlite") ||
+        declaredKind.includes("postgres") ||
+        declaredKind.includes("sqlite")) {
+        return { kind: declaredKind || constructorName.toLowerCase() || "durable", durable: true };
+    }
+    // Any store with saveCheckpoint / appendEntry / queryEntries without explicit durable: true is in-memory
+    if (typeof record.saveCheckpoint === "function" ||
+        typeof record.appendEntry === "function" ||
+        typeof record.queryEntries === "function" ||
+        typeof record.append === "function") {
+        return { kind: declaredKind || "memory", durable: false };
+    }
+    // Unknown store without explicit durable flag is treated as non-durable memory
+    return { kind: declaredKind || "memory", durable: false };
+}
+/**
+ * Inspects a host composition in an inert, bounded, and secret-redacting manner.
+ * Performs zero network calls by default.
+ */
+export function inspectHostComposition(options) {
+    const normalizedProfile = normalizeProfile(options.profile);
+    const config = resolveAgentConfig(options.agent);
+    const redactor = options.redactor ?? config?.redactor;
+    // 1. Effective tools
+    const rawTools = extractTools(config?.tools);
+    const effectiveTools = rawTools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        hasParameters: Boolean(tool.parameters && Object.keys(tool.parameters).length > 0),
+    }));
+    // 2. Credential references (identifier references only, raw values redacted)
+    const credRefs = sanitizeCredentialRefs(options.credentialRefs, redactor);
+    const connectedApps = copyConnectedApps(options.connectedApps);
+    // 3. Ownership
+    const rawOwnership = config?.ownership;
+    const ownership = {
+        tenantId: typeof rawOwnership?.tenantId === "string" ? rawOwnership.tenantId.trim() : undefined,
+        accountId: typeof rawOwnership?.accountId === "string" ? rawOwnership.accountId.trim() : undefined,
+        userId: typeof rawOwnership?.userId === "string" ? rawOwnership.userId.trim() : undefined,
+    };
+    // 4. Storage durability
+    const storage = describeStorage(options.store, options.checkpoints ?? config?.runState?.checkpoints);
+    // 5. Sandbox capabilities
+    const workspaceRoot = options.workspaceRoot;
+    const sandboxRoots = options.sandboxRoots ?? [];
+    let isolated = true;
+    if (workspaceRoot && sandboxRoots.length > 0) {
+        for (const root of sandboxRoots) {
+            if (!isContainedPath(workspaceRoot, root)) {
+                isolated = false;
+                break;
+            }
+        }
+    }
+    // 6. Governance coverage
+    const hasValidator = Boolean((config && "validator" in config && typeof config.validator === "function") ||
+        (config &&
+            "toolArgumentValidator" in config &&
+            typeof config.toolArgumentValidator?.validate === "function"));
+    const isSecure = Boolean(config?.secure);
+    const governance = {
+        permission: Boolean(config?.permission && typeof config.permission.check === "function"),
+        trust: Boolean(config?.trust && typeof config.trust.check === "function"),
+        redactor: Boolean(redactor && typeof redactor.redact === "function"),
+        validator: hasValidator,
+        modelRouting: Boolean(options.governance?.modelRouter || config?.modelRouter),
+        secure: isSecure,
+    };
+    // 7. Readiness analysis
+    const errors = [];
+    const warnings = [];
+    // Required redactor check
+    if (!governance.redactor) {
+        errors.push("Missing required secret redactor");
+    }
+    // Required provider or model configuration
+    const hasProvider = Boolean(config?.provider);
+    const hasModel = Boolean(config?.model);
+    if (!hasProvider && !hasModel) {
+        errors.push("Missing required provider or model configuration");
+    }
+    // Ownership presence
+    const hasAnyOwner = Boolean(ownership.tenantId || ownership.userId || ownership.accountId);
+    if (!hasAnyOwner) {
+        errors.push("Ownership scope is required");
+    }
+    // Profile-specific readiness
+    if (normalizedProfile === "personal") {
+        if (!ownership.userId) {
+            errors.push("Personal composition requires userId in ownership");
+        }
+        if (!isolated) {
+            errors.push("Sandbox roots must be contained within workspaceRoot");
+        }
+    }
+    else {
+        // business composition
+        if (!ownership.tenantId) {
+            errors.push("Business worker requires non-empty tenantId in ownership");
+        }
+        // Verified identity verification
+        const identity = config?.identity;
+        if (connectedApps !== undefined && identity?.verified !== true) {
+            errors.push("Business connected apps require a verified identity");
+        }
+        if (identity) {
+            if (!identity.principal?.id || !identity.tenantId) {
+                errors.push("Business worker identity cannot be empty or fabricated");
+            }
+            else {
+                try {
+                    assertIdentityActive(identity);
+                    if (rawOwnership) {
+                        assertIdentityMatchesOwnership(identity, rawOwnership);
+                    }
+                }
+                catch (error) {
+                    errors.push(error instanceof Error ? error.message : String(error));
+                }
+            }
+        }
+        // Storage durability verification (memory-only persistence is NOT permitted in business readiness)
+        if (!storage.durable) {
+            errors.push("Business composition requires durable storage; in-memory storage is not permitted in production readiness");
+        }
+        // Sandbox isolation verification
+        if (!isolated || (sandboxRoots.length > 0 && !workspaceRoot)) {
+            errors.push("Mixed sandbox workspace detected; business worker requires strict workspace containment");
+        }
+        // Governance coverage
+        if (options.governance?.supported === false) {
+            errors.push("Unsupported governance configuration");
+        }
+        if (!governance.permission) {
+            errors.push("Business composition requires a permission policy");
+        }
+        if (!governance.trust) {
+            errors.push("Business composition requires a trust policy");
+        }
+    }
+    return {
+        profile: normalizedProfile,
+        effectiveTools: Object.freeze(effectiveTools),
+        credentialReferences: credRefs,
+        ...(connectedApps === undefined ? {} : { connectedApps }),
+        ownership: Object.freeze(ownership),
+        storage: Object.freeze(storage),
+        sandbox: Object.freeze({
+            ...(workspaceRoot ? { workspaceRoot } : {}),
+            roots: Object.freeze([...sandboxRoots]),
+            isolated,
+        }),
+        governance: Object.freeze(governance),
+        readiness: Object.freeze({
+            ok: errors.length === 0,
+            errors: Object.freeze(errors),
+            warnings: Object.freeze(warnings),
+        }),
+    };
+}
+/**
+ * Asserts that a host composition meets all readiness requirements for its profile.
+ * Throws HostCompositionError on failure.
+ */
+export function assertHostCompositionReadiness(options) {
+    const report = inspectHostComposition(options);
+    if (!report.readiness.ok) {
+        throw new HostCompositionError(report.readiness.errors.join("; "));
+    }
+    return report;
+}
+//# sourceMappingURL=host-composition.js.map

package/dist/index.d.ts

@@ -7,8 +7,10 @@ export { createAgentRunLifecycle } from "./agent-run-lifecycle.js";
 export type { PendingToolCall, StoredAgentRunState } from "./agent-run-state.js";
 export { AGENT_RUN_STATE_NAMESPACE, AGENT_RUN_STATE_SCHEMA_VERSION, agentFingerprint, DEFAULT_MAX_AGENT_RUN_STATE_BYTES, HARD_MAX_AGENT_RUN_STATE_BYTES, loadAgentRunState, } from "./agent-run-state.js";
 export { createAgent, createAgentSession, resumeAgentRun, resumeAgentRunStream } from "./agents.js";
-export type { ArtifactApproval, ArtifactApprovalState, ArtifactBodyErrorCode, ArtifactBodyPresignOptions, ArtifactBodyRef, ArtifactBodyStore, ArtifactBodyTransferOptions, ArtifactCitation, ArtifactDecisionState, ArtifactDeliveryToken, ArtifactRecord, ArtifactRevision, } from "./artifacts.js";
-export { ARTIFACT_BODY_ERROR_CODES, ARTIFACT_CHECKPOINT_NAMESPACE, ArtifactBodyStoreError, ArtifactError, artifactApprovalState, artifactCheckpointKey, } from "./artifacts.js";
+export type { ArtifactApproval, ArtifactApprovalState, ArtifactBodyErrorCode, ArtifactBodyPresignOptions, ArtifactBodyRef, ArtifactBodyStore, ArtifactBodyTransferOptions, ArtifactCitation, ArtifactDecisionState, ArtifactDeliveryToken, ArtifactRecord, ArtifactRevision, CitationIntegrityReason, CitationIntegrityResult, CitationLiveSource, CitationSupport, } from "./artifacts.js";
+export { ARTIFACT_BODY_ERROR_CODES, ARTIFACT_CHECKPOINT_NAMESPACE, ArtifactBodyStoreError, ArtifactError, approvalEvidenceIntact, artifactApprovalState, artifactCheckpointKey, checkCitationIntegrity, citationBindingDigest, HARD_CITATION_EXCERPT_BYTES, } from "./artifacts.js";
+export type { AttentionTruncationTrigger, AttentionTruncationTriggerOptions, PersistedAttentionStickyFrontier, } from "./attention-compiler.js";
+export { ATTENTION_BUDGET_ERROR_CODE, AttentionBudgetError, createAttentionCompiler, createAttentionTruncationTrigger, DEFAULT_ATTENTION_COMPACT_RATIO, DEFAULT_ATTENTION_KEEP_LAST, DEFAULT_ATTENTION_RESERVE_TOKENS, DEFAULT_ATTENTION_THINKING_KEEP_TURNS, DEFAULT_ATTENTION_TRIGGER_RATIO, DEFAULT_ATTENTION_TRUNCATION_THRESHOLD, isAttentionBudgetError, resolveAttentionReserveTokens, resolveInputCap, resolveRunAttentionCompiler, } from "./attention-compiler.js";
 export type { ApplyCacheControlOptions, CacheControlledContentBlock, CacheControlledMessage, CacheControlValue, CacheUsageReport, } from "./cache-helpers.js";
 export { applyCacheControl, cacheHitRate, cacheSavings, cacheUsageReport, mapCacheRetention, resolveBreakpoint, sanitizeCacheKey, systemCacheControlField, } from "./cache-helpers.js";
 export type { CacheTelemetry, CacheTelemetryOptions, CacheTelemetryReport, CacheTelemetrySample, } from "./cache-telemetry.js";
@@ -26,8 +28,8 @@ export { assertDeclaredMediaTypeMatches, assertMediaBlocksWithinBounds, assertMe
 export type { ContextBudget, ContextBudgetMessageGroups, ContextBudgetOmission, ContextBudgetOmissionKind, ContextBudgetReport, TokenEstimator, } from "./context-budget.js";
 export { applyContextBudget, CONTEXT_BUDGET_ERROR_CODE, CONTEXT_BUDGET_REPORT_METADATA_KEY, ContextBudgetError, DEFAULT_MAX_CONTEXT_BUDGET_OMISSIONS, estimateAssemblyTokens, estimateMessageBytes, estimateMessageTokens, estimateTextBytes, estimateTextTokens, getContextBudgetReport, HARD_MAX_CONTEXT_BUDGET_BYTES, HARD_MAX_CONTEXT_BUDGET_OMISSIONS, HARD_MAX_CONTEXT_BUDGET_TOKENS, isContextBudgetError, resolveContextBudget, } from "./context-budget.js";
 export type * from "./contracts.js";
-export type { ApprovalOutcome, DecisionScope, NestedRunApproval, NestedRunOutcome, NestedRunRef, PendingDecision, PendingDecisionKind, ProviderResolver, RealtimeCaps, RealtimeEvent, RealtimeSession, RealtimeSessionFactory, RealtimeSessionOptions, ResumeNestedRun, RunDecision, RunLimitCounters, RunLimitName, SecureAgentOptions, StickyDecision, ToolCallAuthority, ToolEffectClassifier, ToolEffectDeclaration, ToolEffectIdempotency, ToolEffectKey, ToolEffectKind, ToolEffectRecord, ToolEffectStatus, ToolEffectStore, ToolEffectTransition, ToolElicitationRequest, } from "./contracts.js";
-export { AgentDecisionError, AgentDelegationSuspendedError, AgentLoopStateError, AgentRunError, AgentRunStateError, assertBatchJobsSupported, assertEmbeddingsSupported, assertImageGenerationSupported, assertModerationSupported, assertSessionMetadataKey, assertSpeechSupported, assertTranscriptionSupported, assertVideoGenerationSupported, BatchJobsError, DEFAULT_MAX_PENDING_DECISIONS, DEFAULT_MAX_PENDING_STEER_BYTES, DEFAULT_MAX_PENDING_STEERS, DEFAULT_MAX_SESSION_SEARCH_CURSOR_BYTES, DEFAULT_MAX_SESSION_SEARCH_FTS_CANDIDATES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_BYTES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_ENTRIES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_SESSIONS, DEFAULT_MAX_SESSION_SEARCH_QUERY_BYTES, DEFAULT_MAX_SESSION_SEARCH_SNIPPET_BYTES, DEFAULT_MAX_STICKY_DECISIONS, DEFAULT_SESSION_SEARCH_LIMIT, DEFAULT_SNAPSHOT_CACHE_TTL_MS, EmbeddingsError, HARD_MAX_ACTION_CONSTRAINT_BYTES, HARD_MAX_ACTION_CONSTRAINTS, HARD_MAX_DECISION_REASON_BYTES, HARD_MAX_ELICITATION_BYTES, HARD_MAX_PENDING_DECISIONS, HARD_MAX_PENDING_STEER_BYTES, HARD_MAX_PENDING_STEERS, HARD_MAX_SESSION_SEARCH_CURSOR_BYTES, HARD_MAX_SESSION_SEARCH_FTS_CANDIDATES, HARD_MAX_SESSION_SEARCH_LIMIT, HARD_MAX_SESSION_SEARCH_LINEAR_BYTES, HARD_MAX_SESSION_SEARCH_LINEAR_ENTRIES, HARD_MAX_SESSION_SEARCH_LINEAR_SESSIONS, HARD_MAX_SESSION_SEARCH_QUERY_BYTES, HARD_MAX_SESSION_SEARCH_SNIPPET_BYTES, HARD_MAX_SNAPSHOT_CACHE_TTL_MS, HARD_MAX_STICKY_DECISIONS, ImageGenerationError, isBatchJobTerminal, isSessionAppendConflict, isSessionEntryKind, isSessionMetadataConflict, isSessionSearchUnsupported, MAX_ACTION_CONSTRAINT_BYTES, MAX_ACTION_CONSTRAINTS, MAX_ATTRIBUTION_DEPTH, MAX_DECISION_REASON_BYTES, MAX_ELICITATION_BYTES, ModerationError, modelSupportsBatchJobs, modelSupportsEmbeddings, modelSupportsImageGeneration, modelSupportsModeration, modelSupportsSpeech, modelSupportsTranscription, modelSupportsVideoGeneration, pollBatch, resolveSessionSearchQuery, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_KINDS, SESSION_ENTRY_SCHEMA_VERSION, SESSION_METADATA_CONFLICT_CODE, SESSION_SEARCH_UNSUPPORTED_CODE, SESSION_SEARCH_WORKSPACE_METADATA_KEY, SessionAppendConflictError, SessionMetadataConflictError, SessionSearchUnsupportedError, SpeechError, TranscriptionError, VideoGenerationError, } from "./contracts.js";
+export type { ApprovalOutcome, AttentionCompiler, AttentionCompilerContext, AttentionCompilerOptions, AttentionCompilerSetting, AttentionInputCapOptions, AttentionReport, CompactionTrigger, CompactionTriggerContext, DecisionScope, NestedRunApproval, NestedRunOutcome, NestedRunRef, PendingDecision, PendingDecisionKind, ProviderResolver, RealtimeCaps, RealtimeEvent, RealtimeSession, RealtimeSessionFactory, RealtimeSessionOptions, ResolveShouldCompactInput, ResolveShouldCompactOptions, ResumeNestedRun, RunDecision, RunLimitCounters, RunLimitName, SecureAgentOptions, StickyDecision, ToolCallAuthority, ToolEffectClassifier, ToolEffectDeclaration, ToolEffectIdempotency, ToolEffectKey, ToolEffectKind, ToolEffectRecord, ToolEffectStatus, ToolEffectStore, ToolEffectTransition, ToolElicitationRequest, } from "./contracts.js";
+export { AgentDecisionError, AgentDelegationSuspendedError, AgentLoopStateError, AgentRunError, AgentRunStateError, assertBatchJobsSupported, assertCompactionTrigger, assertEmbeddingsSupported, assertImageGenerationSupported, assertModerationSupported, assertSessionMetadataKey, assertSpeechSupported, assertTranscriptionSupported, assertVideoGenerationSupported, BatchJobsError, DEFAULT_MAX_PENDING_DECISIONS, DEFAULT_MAX_PENDING_STEER_BYTES, DEFAULT_MAX_PENDING_STEERS, DEFAULT_MAX_SESSION_SEARCH_CURSOR_BYTES, DEFAULT_MAX_SESSION_SEARCH_FTS_CANDIDATES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_BYTES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_ENTRIES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_SESSIONS, DEFAULT_MAX_SESSION_SEARCH_QUERY_BYTES, DEFAULT_MAX_SESSION_SEARCH_SNIPPET_BYTES, DEFAULT_MAX_STICKY_DECISIONS, DEFAULT_SESSION_SEARCH_LIMIT, DEFAULT_SNAPSHOT_CACHE_TTL_MS, EmbeddingsError, HARD_MAX_ACTION_CONSTRAINT_BYTES, HARD_MAX_ACTION_CONSTRAINTS, HARD_MAX_DECISION_REASON_BYTES, HARD_MAX_ELICITATION_BYTES, HARD_MAX_PENDING_DECISIONS, HARD_MAX_PENDING_STEER_BYTES, HARD_MAX_PENDING_STEERS, HARD_MAX_SESSION_SEARCH_CURSOR_BYTES, HARD_MAX_SESSION_SEARCH_FTS_CANDIDATES, HARD_MAX_SESSION_SEARCH_LIMIT, HARD_MAX_SESSION_SEARCH_LINEAR_BYTES, HARD_MAX_SESSION_SEARCH_LINEAR_ENTRIES, HARD_MAX_SESSION_SEARCH_LINEAR_SESSIONS, HARD_MAX_SESSION_SEARCH_QUERY_BYTES, HARD_MAX_SESSION_SEARCH_SNIPPET_BYTES, HARD_MAX_SNAPSHOT_CACHE_TTL_MS, HARD_MAX_STICKY_DECISIONS, ImageGenerationError, isBatchJobTerminal, isSessionAppendConflict, isSessionEntryKind, isSessionMetadataConflict, isSessionSearchUnsupported, MAX_ACTION_CONSTRAINT_BYTES, MAX_ACTION_CONSTRAINTS, MAX_ATTRIBUTION_DEPTH, MAX_DECISION_REASON_BYTES, MAX_ELICITATION_BYTES, ModerationError, modelSupportsBatchJobs, modelSupportsEmbeddings, modelSupportsImageGeneration, modelSupportsModeration, modelSupportsSpeech, modelSupportsTranscription, modelSupportsVideoGeneration, pollBatch, resolveSessionSearchQuery, resolveShouldCompact, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_KINDS, SESSION_ENTRY_SCHEMA_VERSION, SESSION_METADATA_CONFLICT_CODE, SESSION_SEARCH_UNSUPPORTED_CODE, SESSION_SEARCH_WORKSPACE_METADATA_KEY, SessionAppendConflictError, SessionMetadataConflictError, SessionSearchUnsupportedError, SpeechError, TranscriptionError, VideoGenerationError, } from "./contracts.js";
 export { parseAgentFile, parseSkillFile } from "./contribution-parsing.js";
 export type { ContributionRegistries, ContributionRegistriesOptions, ContributionRegistry, ContributionRegistryOptions, } from "./contributions.js";
 export { createContributionRegistries, createContributionRegistry, registerDiscoveredContributions } from "./contributions.js";
@@ -41,6 +43,8 @@ export type { DeviceAdapter, DeviceAdmitRequest, DeviceChunkResult, DeviceConfor
 export { acceptDeviceChunk, assertDeviceAdmit, DEFAULT_DEVICE_MAX_CHUNK_BYTES, DEFAULT_DEVICE_MAX_CONCURRENT_SESSIONS, DevicePolicyError, HARD_DEVICE_MAX_CHUNK_BYTES, HARD_DEVICE_MAX_CONCURRENT_SESSIONS, redactDeviceTelemetry, resolveDevicePolicy, runDevicePolicyConformance, } from "./devices.js";
 export type { EventMultiplexer, EventMultiplexerOptions, EventOverflowInfo, EventOverflowPolicy } from "./event-multiplexer.js";
 export { createEventMultiplexer, EVENT_MULTIPLEXER_SINGLE_CONSUMER_CODE, EventMultiplexerError } from "./event-multiplexer.js";
+export type { ClaimGroundingEvidence, ClaimGroundingEvidenceExtractor, ClaimGroundingEvidenceExtractorContext, ClaimGroundingGuardrailOptions, } from "./evidence-grounding.js";
+export { createClaimGroundingGuardrail } from "./evidence-grounding.js";
 export type { ExecutionAction, ExecutionDecision, ExecutionPolicy, ExecutionRisk } from "./execution-policy.js";
 export { applyExecutionDecision, assertExecutionAllowed, checkExecution, ExecutionDeniedError } from "./execution-policy.js";
 export type { ActivatedKernelConfig, ExtensionErrorPolicy, ExtensionEventBus, ExtensionEventHandler, ExtensionKernel, ExtensionKernelOptions, ExtensionLoadPolicy, LoadedExtension, } from "./extensions.js";
@@ -85,11 +89,14 @@ export type { LoadBinaryResourceOptions } from "./resources.js";
 export { loadBinaryResource, loadJsonResource, loadManifestResource, loadTextResource } from "./resources.js";
 export type { DefaultRetryPolicyOptions } from "./retry.js";
 export { createDefaultRetryPolicy, isTransientErrorInfo, waitForRetry } from "./retry.js";
+export type { RunBundleSnapshot, RunBundleSnapshotInput } from "./run-bundle.js";
+export { RUN_BUNDLE_SCHEMA_VERSION, snapshotRunBundle } from "./run-bundle.js";
 export type { BatchedRunLedgerOptions } from "./run-ledger.js";
 export { createBatchedRunLedger, DEFAULT_LEDGER_BATCH_BYTES, DEFAULT_LEDGER_BATCH_DELAY_MS, DEFAULT_LEDGER_BATCH_ENTRIES, HARD_LEDGER_BATCH_BYTES, HARD_LEDGER_BATCH_DELAY_MS, HARD_LEDGER_BATCH_ENTRIES, isFlushableRunLedger, } from "./run-ledger.js";
 export type { RunLimitTrackerOptions } from "./run-limits.js";
 export { createRunLimitTracker, DEFAULT_RUN_LIMITS, HARD_RUN_LIMITS, RunLimitError, RunLimitTracker, resolveRunLimits, } from "./run-limits.js";
-export { createSecureAgent } from "./secure-agent.js";
+export type { HostCompositionGovernance, HostCompositionOptions, HostCompositionProfile, HostCompositionReport, HostCompositionToolReport, } from "./secure-agent.js";
+export { assertHostCompositionReadiness, createSecureAgent, HostCompositionError, inspectHostComposition, } from "./secure-agent.js";
 export type { PermissionDecision, PermissionPolicy, PermissionRequest, TrustDecision, TrustPolicy, TrustRequest } from "./security.js";
 export { assertPermission, assertTrusted, checkPermission, createStaticPermissionPolicy, createStaticTrustPolicy, denialToErrorInfo, isTrusted, PermissionDeniedError, TrustDeniedError, } from "./security.js";
 export type { CreateMemorySessionStoreOptions, CreateSessionEntryOptions, MemorySessionSearchMode, SessionBranch, SessionBranchOptions, SessionContextSnapshot, } from "./session-stores.js";
@@ -119,5 +126,5 @@ export { trimTrailingSlashes } from "./trim-trailing-slashes.js";
 export type { ResolvedUseCaseModel, ResolveUseCaseModelInput, UseCaseModelBinding, } from "./use-case-model.js";
 export { resolveUseCaseModel, resolveUseCaseModelBinding, useCaseCredentialProviderId, } from "./use-case-model.js";
 export declare const name = "prism";
-export declare const version = "0.6.0";
+export declare const version = "0.8.0";
 export declare const description = "Agent harness for AI providers, agents, sessions, and tools.";