@paybond/kit 0.9.8 → 0.11.0

package/dist/policy/compose.js

@@ -0,0 +1,240 @@
+import { cloneToolEntry } from "./compose-utils.js";
+import { guardrailLayerFromDocument } from "./guardrails.js";
+import { loadBundledDefaultGuardrailsDocument, loadBundledDomainDocument, } from "./layers-io.js";
+import { parsePolicyDocumentText } from "./parse-text.js";
+import { readPolicyPresetYaml, resolvePolicyPresetPath } from "./presets.js";
+import { parsePaybondPolicyDocumentV1, } from "./schema.js";
+export const LAYERED_POLICY_PRESET_IDS = ["travel", "shopping", "saas", "aws"];
+function mergeStricterDefaultDeny(...values) {
+    return values.some((value) => value === true);
+}
+function cloneDocument(document) {
+    return {
+        ...document,
+        tools: Object.fromEntries(Object.entries(document.tools).map(([name, entry]) => [name, cloneToolEntry(entry)])),
+        intent: document.intent
+            ? {
+                ...document.intent,
+                ...(document.intent.allowed_tools
+                    ? { allowed_tools: [...document.intent.allowed_tools] }
+                    : {}),
+                ...(document.intent.budget ? { budget: { ...document.intent.budget } } : {}),
+                ...(document.intent.policy_binding
+                    ? { policy_binding: { ...document.intent.policy_binding } }
+                    : {}),
+            }
+            : undefined,
+    };
+}
+function mergeToolEntry(base, patch) {
+    const merged = cloneToolEntry(base);
+    if (patch.side_effecting !== undefined) {
+        merged.side_effecting = patch.side_effecting;
+    }
+    if (patch.max_spend_cents !== undefined) {
+        merged.max_spend_cents =
+            merged.max_spend_cents !== undefined
+                ? Math.min(merged.max_spend_cents, patch.max_spend_cents)
+                : patch.max_spend_cents;
+    }
+    if (patch.spend_from_args !== undefined) {
+        merged.spend_from_args = patch.spend_from_args;
+        delete merged.max_spend_cents;
+    }
+    if (patch.evidence_preset !== undefined) {
+        merged.evidence_preset = patch.evidence_preset;
+    }
+    if (patch.vendor_pack !== undefined) {
+        merged.vendor_pack = patch.vendor_pack;
+    }
+    if (patch.operation !== undefined) {
+        merged.operation = patch.operation;
+    }
+    return merged;
+}
+function mergeBudgetCaps(current, nextUsd) {
+    const currency = current?.currency ?? "usd";
+    const currentUsd = current?.max_spend_usd;
+    return {
+        ...current,
+        currency,
+        max_spend_usd: currentUsd !== undefined ? Math.min(currentUsd, nextUsd) : nextUsd,
+    };
+}
+function applyReadOnlyFilter(document, searchOnly) {
+    const filteredEntries = Object.entries(document.tools).filter(([name, entry]) => {
+        if (entry.side_effecting) {
+            return false;
+        }
+        return !searchOnly || name.startsWith("search.");
+    });
+    document.tools = Object.fromEntries(filteredEntries);
+    if (document.intent?.allowed_tools) {
+        const allowed = new Set(Object.keys(document.tools));
+        document.intent.allowed_tools = document.intent.allowed_tools.filter((tool) => allowed.has(tool));
+    }
+}
+function assertEvidenceRequired(document) {
+    for (const [name, entry] of Object.entries(document.tools)) {
+        if (entry.side_effecting && !entry.evidence_preset) {
+            throw new Error(`side-effecting tool "${name}" must declare evidence_preset`);
+        }
+    }
+}
+function applyGuardrailLayer(document, layer) {
+    if (layer.default_deny !== undefined) {
+        document.default_deny = mergeStricterDefaultDeny(document.default_deny, layer.default_deny);
+    }
+    if (layer.tools) {
+        for (const [toolName, patch] of Object.entries(layer.tools)) {
+            const existing = document.tools[toolName];
+            if (existing) {
+                document.tools[toolName] = mergeToolEntry(existing, patch);
+            }
+        }
+    }
+    if (layer.intent) {
+        document.intent = {
+            ...document.intent,
+            ...layer.intent,
+            ...(layer.intent.allowed_tools
+                ? {
+                    allowed_tools: layer.intent.allowed_tools,
+                }
+                : {}),
+            ...(layer.intent.budget
+                ? {
+                    budget: {
+                        ...document.intent?.budget,
+                        ...layer.intent.budget,
+                    },
+                }
+                : {}),
+            ...(layer.intent.policy_binding
+                ? {
+                    policy_binding: {
+                        ...document.intent?.policy_binding,
+                        ...layer.intent.policy_binding,
+                    },
+                }
+                : {}),
+        };
+    }
+    if (layer.caps?.sideEffectingMaxSpendCents !== undefined) {
+        const cents = layer.caps.sideEffectingMaxSpendCents;
+        for (const [toolName, entry] of Object.entries(document.tools)) {
+            if (entry.side_effecting) {
+                document.tools[toolName] = mergeToolEntry(entry, { max_spend_cents: cents });
+            }
+        }
+    }
+    if (layer.caps?.budgetMaxSpendUsd !== undefined) {
+        document.intent = {
+            ...document.intent,
+            budget: mergeBudgetCaps(document.intent?.budget, layer.caps.budgetMaxSpendUsd),
+        };
+    }
+    if (layer.filters?.readOnly || layer.filters?.readOnlySearch) {
+        applyReadOnlyFilter(document, Boolean(layer.filters.readOnlySearch));
+    }
+    if (layer.requireEvidence) {
+        assertEvidenceRequired(document);
+    }
+}
+/** Stack a domain document with one or more guardrail layers (same-tenant compose, not org inheritance). */
+export function composePolicyLayers(domainDocument, ...layers) {
+    const composed = cloneDocument(domainDocument);
+    for (const layer of layers) {
+        applyGuardrailLayer(composed, layer);
+    }
+    assertEvidenceRequired(composed);
+    return composed;
+}
+/** True when a bundled preset is composed from domain + guardrails layers. */
+export function isLayeredPolicyPreset(presetId) {
+    return LAYERED_POLICY_PRESET_IDS.includes(presetId.trim());
+}
+function guardrailsFileName(presetId) {
+    return `default-${presetId}.yaml`;
+}
+function deepMergeRecord(base, patch) {
+    const result = { ...base };
+    for (const [key, patchValue] of Object.entries(patch)) {
+        const baseValue = result[key];
+        if (baseValue &&
+            patchValue &&
+            typeof baseValue === "object" &&
+            typeof patchValue === "object" &&
+            !Array.isArray(baseValue) &&
+            !Array.isArray(patchValue)) {
+            result[key] = deepMergeRecord(baseValue, patchValue);
+        }
+        else {
+            result[key] = patchValue;
+        }
+    }
+    return result;
+}
+/** Merge domain and guardrail YAML objects (bundled preset file generation). */
+export function composePolicyPresetLayers(domain, guardrails) {
+    return deepMergeRecord(domain, guardrails);
+}
+/** Default bundled guardrail layers for a vertical preset id. */
+export function bundledDefaultGuardrails(presetId) {
+    return [guardrailLayerFromDocument(loadBundledDefaultGuardrailsDocument(presetId))];
+}
+/** Compose the shipped default for a vertical preset (domain + bundled guardrails). */
+export function composeBundledPresetDefault(presetId) {
+    return composePolicyLayers(parsePaybondPolicyDocumentV1(loadBundledDomainDocument(presetId)), ...bundledDefaultGuardrails(presetId));
+}
+/** Load and compose a layered vertical preset (domain + guardrails YAML files). */
+export function composeLayeredPolicyPresetDocument(presetId) {
+    const domain = loadBundledDomainDocument(presetId);
+    const guardrails = loadBundledDefaultGuardrailsDocument(presetId);
+    return composePolicyPresetLayers(domain, guardrails);
+}
+/** Compare composed layered presets with bundled flat preset files (tests). */
+export function assertLayeredPresetMatchesFlat(presetId) {
+    if (!isLayeredPolicyPreset(presetId)) {
+        return;
+    }
+    const composed = composeLayeredPolicyPresetDocument(presetId);
+    const flatPath = resolvePolicyPresetPath(presetId);
+    const flat = parsePolicyDocumentText(readPolicyPresetYaml(presetId), flatPath);
+    if (JSON.stringify(normalizePolicyPresetDocument(composed)) !==
+        JSON.stringify(normalizePolicyPresetDocument(flat))) {
+        throw new Error(`composed preset ${presetId} does not match flat bundled file`);
+    }
+}
+function normalizePolicyPresetDocument(document) {
+    const tools = document.tools;
+    const normalizedTools = tools && typeof tools === "object" && !Array.isArray(tools)
+        ? Object.fromEntries(Object.entries(tools)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([name, entry]) => [
+            name,
+            entry && typeof entry === "object" && !Array.isArray(entry)
+                ? Object.fromEntries(Object.entries(entry).sort(([left], [right]) => left.localeCompare(right)))
+                : entry,
+        ]))
+        : tools;
+    const intent = document.intent;
+    const normalizedIntent = intent && typeof intent === "object" && !Array.isArray(intent)
+        ? {
+            ...intent,
+            ...(Array.isArray(intent.allowed_tools)
+                ? {
+                    allowed_tools: [
+                        ...intent.allowed_tools,
+                    ].sort(),
+                }
+                : {}),
+        }
+        : intent;
+    return {
+        ...document,
+        ...(normalizedTools !== undefined ? { tools: normalizedTools } : {}),
+        ...(normalizedIntent !== undefined ? { intent: normalizedIntent } : {}),
+    };
+}
+export { readPresetLayerYaml } from "./layers-io.js";

package/dist/policy/digest.d.ts

@@ -0,0 +1,7 @@
+import type { PaybondPolicyDocumentV1 } from "./schema.js";
+/** Serialize a validated v1 policy document to Gateway-compatible JSON dict form. */
+export declare function policyDocumentToDict(document: PaybondPolicyDocumentV1): Record<string, unknown>;
+/** Return `sha256:<hex>` for the canonical JSON encoding of a v1 policy document. */
+export declare function canonicalPolicyDocumentDigest(document: PaybondPolicyDocumentV1): string;
+/** Human-readable policy version label (`{name}@{digest_short}`). */
+export declare function policyVersionLabel(name: string, digest: string): string;

package/dist/policy/digest.js

@@ -0,0 +1,75 @@
+import { createHash } from "node:crypto";
+/** Serialize a validated v1 policy document to Gateway-compatible JSON dict form. */
+export function policyDocumentToDict(document) {
+    const tools = Object.fromEntries(Object.entries(document.tools).map(([toolName, entry]) => [
+        toolName,
+        {
+            side_effecting: entry.side_effecting,
+            ...(entry.max_spend_cents !== undefined ? { max_spend_cents: entry.max_spend_cents } : {}),
+            ...(entry.spend_from_args !== undefined ? { spend_from_args: entry.spend_from_args } : {}),
+            ...(entry.evidence_preset !== undefined ? { evidence_preset: entry.evidence_preset } : {}),
+            ...(entry.vendor_pack !== undefined ? { vendor_pack: entry.vendor_pack } : {}),
+            ...(entry.operation !== undefined ? { operation: entry.operation } : {}),
+        },
+    ]));
+    const payload = {
+        version: document.version,
+        name: document.name,
+        default_deny: document.default_deny,
+        tools,
+    };
+    if (document.intent) {
+        const intent = {};
+        if (document.intent.policy_binding) {
+            const binding = {
+                template_id: document.intent.policy_binding.template_id,
+            };
+            if (document.intent.policy_binding.version_seq !== undefined) {
+                binding.version_seq = document.intent.policy_binding.version_seq;
+            }
+            if (document.intent.policy_binding.head_digest !== undefined) {
+                binding.head_digest = document.intent.policy_binding.head_digest;
+            }
+            intent.policy_binding = binding;
+        }
+        if (document.intent.budget) {
+            intent.budget = document.intent.budget;
+        }
+        if (document.intent.allowed_tools?.length) {
+            intent.allowed_tools = document.intent.allowed_tools;
+        }
+        if (Object.keys(intent).length > 0) {
+            payload.intent = intent;
+        }
+    }
+    return payload;
+}
+function canonicalizeJson(value) {
+    if (Array.isArray(value)) {
+        return value.map(canonicalizeJson);
+    }
+    if (value && typeof value === "object") {
+        const row = value;
+        const out = {};
+        for (const key of Object.keys(row).sort()) {
+            out[key] = canonicalizeJson(row[key]);
+        }
+        return out;
+    }
+    return value;
+}
+/** Return `sha256:<hex>` for the canonical JSON encoding of a v1 policy document. */
+export function canonicalPolicyDocumentDigest(document) {
+    const wire = policyDocumentToDict(document);
+    const text = JSON.stringify(canonicalizeJson(wire));
+    const hash = createHash("sha256").update(text, "utf8").digest("hex");
+    return `sha256:${hash}`;
+}
+/** Human-readable policy version label (`{name}@{digest_short}`). */
+export function policyVersionLabel(name, digest) {
+    const trimmed = digest.trim();
+    const short = trimmed.startsWith("sha256:") && trimmed.length >= 15
+        ? trimmed.slice(7, 15)
+        : trimmed.slice(0, 8);
+    return `${name}@${short}`;
+}

package/dist/policy/domain.d.ts

@@ -0,0 +1,15 @@
+import { type PaybondPolicyDocumentV1 } from "./schema.js";
+/** Travel booking domain: hotel booking + read-only web search. */
+export declare function travel(): PaybondPolicyDocumentV1;
+/** Shopping domain: checkout + product search. */
+export declare function shopping(): PaybondPolicyDocumentV1;
+/** SaaS domain: seat provisioning + plan listing. */
+export declare function saas(): PaybondPolicyDocumentV1;
+/** AWS operator domain: EC2 start + describe. */
+export declare function aws(): PaybondPolicyDocumentV1;
+export declare const domain: {
+    readonly travel: typeof travel;
+    readonly shopping: typeof shopping;
+    readonly saas: typeof saas;
+    readonly aws: typeof aws;
+};

package/dist/policy/domain.js

@@ -0,0 +1,28 @@
+import { parsePaybondPolicyDocumentV1, } from "./schema.js";
+import { loadBundledDomainDocument } from "./layers-io.js";
+const LAYERED_POLICY_PRESET_IDS = ["travel", "shopping", "saas", "aws"];
+function loadDomain(presetId) {
+    return parsePaybondPolicyDocumentV1(loadBundledDomainDocument(presetId));
+}
+/** Travel booking domain: hotel booking + read-only web search. */
+export function travel() {
+    return loadDomain("travel");
+}
+/** Shopping domain: checkout + product search. */
+export function shopping() {
+    return loadDomain("shopping");
+}
+/** SaaS domain: seat provisioning + plan listing. */
+export function saas() {
+    return loadDomain("saas");
+}
+/** AWS operator domain: EC2 start + describe. */
+export function aws() {
+    return loadDomain("aws");
+}
+export const domain = {
+    travel,
+    shopping,
+    saas,
+    aws,
+};

package/dist/policy/guardrail-spec.d.ts

@@ -0,0 +1,17 @@
+import { guardrails, type PolicyGuardrailLayer } from "./guardrails.js";
+export type GuardrailCatalogEntry = {
+    id: string;
+    title: string;
+    description: string;
+    parameterized?: boolean;
+};
+/** Built-in guardrail ids accepted by `policy init --guardrails` and solution manifests. */
+export declare const GUARDRAIL_CATALOG_ENTRIES: GuardrailCatalogEntry[];
+/** Resolve a solution-manifest guardrail token (for example `max_spend_usd_200`). */
+export declare function resolveGuardrailManifestToken(token: string): PolicyGuardrailLayer;
+/** Parse one guardrail token from CLI `--guardrails` or solution manifests. */
+export declare function parseGuardrailSpec(spec: string): PolicyGuardrailLayer;
+/** Parse a comma-separated guardrail spec list from CLI flags. */
+export declare function parseGuardrailSpecs(csv: string): PolicyGuardrailLayer[];
+export declare function listGuardrailCatalogEntries(): GuardrailCatalogEntry[];
+export { guardrails };

package/dist/policy/guardrail-spec.js

@@ -0,0 +1,140 @@
+import { auditOnly, allowDryRun, defaultDeny, guardrails, maxSpend, maxSpendUsd, readOnly, readOnlySearch, requireEvidence, strict, } from "./guardrails.js";
+/** Built-in guardrail ids accepted by `policy init --guardrails` and solution manifests. */
+export const GUARDRAIL_CATALOG_ENTRIES = [
+    {
+        id: "default-deny",
+        title: "Default deny",
+        description: "Require explicit tool registration (default_deny: true)",
+    },
+    {
+        id: "read-only",
+        title: "Read only",
+        description: "Keep only non-side-effecting tools",
+    },
+    {
+        id: "read-only-search",
+        title: "Read-only search",
+        description: "Keep only non-side-effecting search.* tools",
+    },
+    {
+        id: "strict",
+        title: "Strict",
+        description: "Tight caps, default deny, and evidence required on side-effecting tools",
+    },
+    {
+        id: "require-evidence",
+        title: "Require evidence",
+        description: "Validate evidence_preset on side-effecting tools at compose time",
+    },
+    {
+        id: "audit-only",
+        title: "Audit only",
+        description: "Reserved governance hook (no-op layer today)",
+    },
+    {
+        id: "allow-dry-run",
+        title: "Allow dry run",
+        description: "Reserved governance hook (no-op layer today)",
+    },
+    {
+        id: "max-spend:<usd>",
+        title: "Max spend (USD)",
+        description: "Cap intent budget and side-effecting tool spend (USD parameter)",
+        parameterized: true,
+    },
+    {
+        id: "max-spend-cents:<cents>",
+        title: "Max spend (cents)",
+        description: "Cap side-effecting tool spend in cents",
+        parameterized: true,
+    },
+    {
+        id: "max-spend-usd:<usd>",
+        title: "Max spend budget (USD)",
+        description: "Cap intent budget max_spend_usd only",
+        parameterized: true,
+    },
+];
+function normalizeGuardrailToken(token) {
+    return token.trim().toLowerCase().replace(/_/g, "-");
+}
+function parsePositiveNumber(raw, label) {
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`${label} requires a non-negative number`);
+    }
+    return value;
+}
+/** Resolve a solution-manifest guardrail token (for example `max_spend_usd_200`). */
+export function resolveGuardrailManifestToken(token) {
+    const trimmed = token.trim();
+    const manifestUsd = /^max_spend_usd_(\d+(?:\.\d+)?)$/i.exec(trimmed);
+    if (manifestUsd) {
+        return maxSpendUsd(parsePositiveNumber(manifestUsd[1], "max_spend_usd"));
+    }
+    return parseGuardrailSpec(trimmed);
+}
+/** Parse one guardrail token from CLI `--guardrails` or solution manifests. */
+export function parseGuardrailSpec(spec) {
+    const normalized = normalizeGuardrailToken(spec);
+    if (!normalized) {
+        throw new Error("guardrail spec must not be empty");
+    }
+    const maxSpendMatch = /^max-spend:(\d+(?:\.\d+)?)$/.exec(normalized);
+    if (maxSpendMatch) {
+        const usd = parsePositiveNumber(maxSpendMatch[1], "max-spend");
+        return {
+            caps: {
+                budgetMaxSpendUsd: usd,
+                sideEffectingMaxSpendCents: Math.round(usd * 100),
+            },
+        };
+    }
+    const maxSpendUsdMatch = /^max-spend-usd:(\d+(?:\.\d+)?)$/.exec(normalized);
+    if (maxSpendUsdMatch) {
+        return maxSpendUsd(parsePositiveNumber(maxSpendUsdMatch[1], "max-spend-usd"));
+    }
+    const maxSpendCentsMatch = /^max-spend-cents:(\d+)$/.exec(normalized);
+    if (maxSpendCentsMatch) {
+        return maxSpend(parsePositiveNumber(maxSpendCentsMatch[1], "max-spend-cents"));
+    }
+    switch (normalized) {
+        case "default-deny":
+        case "defaultdeny":
+            return defaultDeny();
+        case "read-only":
+        case "readonly":
+            return readOnly();
+        case "read-only-search":
+        case "readonlysearch":
+            return readOnlySearch();
+        case "strict":
+            return strict();
+        case "require-evidence":
+        case "requireevidence":
+            return requireEvidence();
+        case "audit-only":
+        case "auditonly":
+            return auditOnly();
+        case "allow-dry-run":
+        case "allowdryrun":
+            return allowDryRun();
+        default:
+            throw new Error(`unknown guardrail: ${spec}`);
+    }
+}
+/** Parse a comma-separated guardrail spec list from CLI flags. */
+export function parseGuardrailSpecs(csv) {
+    const tokens = csv
+        .split(",")
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+    if (tokens.length === 0) {
+        throw new Error("guardrails list must include at least one entry");
+    }
+    return tokens.map((token) => parseGuardrailSpec(token));
+}
+export function listGuardrailCatalogEntries() {
+    return [...GUARDRAIL_CATALOG_ENTRIES];
+}
+export { guardrails };

package/dist/policy/guardrails.d.ts

@@ -0,0 +1,48 @@
+import type { PaybondPolicyIntentSection, PaybondPolicyToolEntry } from "./schema.js";
+/** Partial policy patch applied on top of a domain document during compose. */
+export type PolicyGuardrailLayer = {
+    default_deny?: boolean;
+    tools?: Record<string, Partial<PaybondPolicyToolEntry>>;
+    intent?: Partial<PaybondPolicyIntentSection>;
+    filters?: {
+        readOnly?: boolean;
+        readOnlySearch?: boolean;
+    };
+    caps?: {
+        sideEffectingMaxSpendCents?: number;
+        budgetMaxSpendUsd?: number;
+    };
+    requireEvidence?: boolean;
+};
+/** Require `default_deny: true` (stricter wins when stacked). */
+export declare function defaultDeny(): PolicyGuardrailLayer;
+/** Cap every side-effecting tool at `cents` (stricter min wins when stacked). */
+export declare function maxSpend(cents: number): PolicyGuardrailLayer;
+/** Cap intent budget at `usd` dollars (stricter min wins when stacked). */
+export declare function maxSpendUsd(usd: number): PolicyGuardrailLayer;
+/** Keep only non-side-effecting tools and intersect allowed_tools. */
+export declare function readOnly(): PolicyGuardrailLayer;
+/** Keep only non-side-effecting search.* tools. */
+export declare function readOnlySearch(): PolicyGuardrailLayer;
+/** Tight caps, default deny, and evidence required on side-effecting tools. */
+export declare function strict(): PolicyGuardrailLayer;
+/** Governance hook: validate evidence presets at compose time (no extra fields). */
+export declare function requireEvidence(): PolicyGuardrailLayer;
+/** Governance hook reserved for audit-only execution modes (no-op layer today). */
+export declare function auditOnly(): PolicyGuardrailLayer;
+/** Governance hook reserved for dry-run modes (no-op layer today). */
+export declare function allowDryRun(): PolicyGuardrailLayer;
+/** Convert a bundled guardrails YAML object into a compose layer. */
+export declare function guardrailLayerFromDocument(document: Record<string, unknown>): PolicyGuardrailLayer;
+export declare const guardrails: {
+    readonly defaultDeny: typeof defaultDeny;
+    readonly maxSpend: typeof maxSpend;
+    readonly maxSpendUsd: typeof maxSpendUsd;
+    readonly readOnly: typeof readOnly;
+    readonly readOnlySearch: typeof readOnlySearch;
+    readonly strict: typeof strict;
+    readonly requireEvidence: typeof requireEvidence;
+    readonly auditOnly: typeof auditOnly;
+    readonly allowDryRun: typeof allowDryRun;
+    readonly fromDocument: typeof guardrailLayerFromDocument;
+};

package/dist/policy/guardrails.js

@@ -0,0 +1,72 @@
+/** Require `default_deny: true` (stricter wins when stacked). */
+export function defaultDeny() {
+    return { default_deny: true };
+}
+/** Cap every side-effecting tool at `cents` (stricter min wins when stacked). */
+export function maxSpend(cents) {
+    if (!Number.isInteger(cents) || cents < 0) {
+        throw new Error("maxSpend requires a non-negative integer cents value");
+    }
+    return { caps: { sideEffectingMaxSpendCents: cents } };
+}
+/** Cap intent budget at `usd` dollars (stricter min wins when stacked). */
+export function maxSpendUsd(usd) {
+    if (typeof usd !== "number" || usd < 0 || !Number.isFinite(usd)) {
+        throw new Error("maxSpendUsd requires a non-negative finite USD value");
+    }
+    return { caps: { budgetMaxSpendUsd: usd } };
+}
+/** Keep only non-side-effecting tools and intersect allowed_tools. */
+export function readOnly() {
+    return { filters: { readOnly: true } };
+}
+/** Keep only non-side-effecting search.* tools. */
+export function readOnlySearch() {
+    return { filters: { readOnlySearch: true } };
+}
+/** Tight caps, default deny, and evidence required on side-effecting tools. */
+export function strict() {
+    return {
+        default_deny: true,
+        caps: { sideEffectingMaxSpendCents: 1000, budgetMaxSpendUsd: 10 },
+        requireEvidence: true,
+    };
+}
+/** Governance hook: validate evidence presets at compose time (no extra fields). */
+export function requireEvidence() {
+    return { requireEvidence: true };
+}
+/** Governance hook reserved for audit-only execution modes (no-op layer today). */
+export function auditOnly() {
+    return {};
+}
+/** Governance hook reserved for dry-run modes (no-op layer today). */
+export function allowDryRun() {
+    return {};
+}
+/** Convert a bundled guardrails YAML object into a compose layer. */
+export function guardrailLayerFromDocument(document) {
+    const layer = {};
+    if (document.default_deny === true) {
+        layer.default_deny = true;
+    }
+    if (document.tools && typeof document.tools === "object" && !Array.isArray(document.tools)) {
+        layer.tools = document.tools;
+    }
+    if (document.intent && typeof document.intent === "object" && !Array.isArray(document.intent)) {
+        layer.intent = document.intent;
+    }
+    return layer;
+}
+export const guardrails = {
+    defaultDeny,
+    maxSpend,
+    maxSpendUsd,
+    readOnly,
+    readOnlySearch,
+    strict,
+    requireEvidence,
+    auditOnly,
+    allowDryRun,
+    fromDocument: guardrailLayerFromDocument,
+};

package/dist/policy/index.d.ts

@@ -0,0 +1,21 @@
+export { canonicalPolicyDocumentDigest, policyDocumentToDict, policyVersionLabel, } from "./digest.js";
+export { PaybondPolicy, type PaybondPolicyLoadSource, type PaybondPolicyLoadEffectiveResult } from "./load.js";
+export { isKnownPolicyPresetId, isLayeredPolicyPresetId, listPolicyPresetIds, readPolicyPresetYaml, resolveComposedPresetDocument, resolvePolicyPresetPath, type LayeredPolicyPresetId, type PolicyPresetId, } from "./presets.js";
+export { assertLayeredPresetMatchesFlat, bundledDefaultGuardrails, composeBundledPresetDefault, composeLayeredPolicyPresetDocument, composePolicyLayers, composePolicyPresetLayers, isLayeredPolicyPreset, LAYERED_POLICY_PRESET_IDS, } from "./compose.js";
+export { domain } from "./domain.js";
+export { auditOnly, allowDryRun, defaultDeny, guardrailLayerFromDocument, guardrails, maxSpend, maxSpendUsd, readOnly, readOnlySearch, requireEvidence, strict, type PolicyGuardrailLayer, } from "./guardrails.js";
+export { paybondPolicyPresets, type PaybondPolicyPresets, type VerticalPolicyOptions } from "./policy-api.js";
+export { createPolicySnapshot, createPolicySnapshotFromEffective, type CreatePolicySnapshotInput, type PaybondPolicySnapshot, type PaybondPolicySnapshotSource, } from "./snapshot.js";
+export { parsePolicyExtendsRef, renderOrgBasePolicyYaml, renderPaybondPolicyYaml, renderTenantOverlayPolicyYaml, scaffoldOrgBasePolicy, scaffoldPaybondPolicy, scaffoldPolicyFromPreset, scaffoldTenantOverlayPolicy, type ScaffoldOrgBasePolicyOptions, type ScaffoldPaybondPolicyOptions, type ScaffoldPolicyFromPresetOptions, type ScaffoldTenantOverlayPolicyOptions, } from "./init.js";
+export { PaybondPolicyIntentSpecError, policyToIntentCreateInput, type PaybondPolicyIntentCreateInput, type PaybondPolicyIntentCreateOverrides, } from "./intent-spec.js";
+export { PaybondPolicySandboxBootstrapError, policySandboxBootstrap, type PaybondPolicySandboxBootstrapOptions, } from "./sandbox-bootstrap.js";
+export { resolveJsonPath, resolveSpendCentsFromJsonPath } from "./json-path.js";
+export { parsePolicyDocumentText } from "./parse-text.js";
+export { policyDocumentToToolRegistryConfig, policyToToolRegistry, } from "./registry.js";
+export { mergePaybondPolicies, toEffectivePolicyDocument, type PolicyMergeDeniedWidening, type PolicyMergeOptions, type PolicyMergeReport, type PolicyMergeResult, } from "./merge.js";
+export { PAYBOND_POLICY_SCHEMA_VERSION, PAYBOND_POLICY_SCHEMA_VERSION_V2, PaybondPolicyValidationError, isPaybondPolicyDocumentV1, isPaybondPolicyDocumentV2, isPaybondPolicyOverlay, parsePaybondPolicyDocument, parsePaybondPolicyDocumentV1, parsePaybondPolicyDocumentV2, paybondPolicyDocumentV1Schema, paybondPolicyDocumentV2Schema, type PaybondPolicyBinding, type PaybondPolicyBindingOverride, type PaybondPolicyBudget, type PaybondPolicyDocument, type PaybondPolicyDocumentV1, type PaybondPolicyDocumentV2, type PaybondPolicyExtends, type PaybondPolicyIntentOverrideSection, type PaybondPolicyIntentSection, type PaybondPolicyOverrides, type PaybondPolicyToolEntry, type PaybondPolicyToolOverrideEntry, type PaybondPolicyValidationIssue, } from "./schema.js";
+export { PolicyValidator, type PolicyGatewayTemplateLookup, type PolicyValidatorError, type PolicyValidatorOptions, type PolicyValidatorResult, type PolicyValidatorToolCounts, } from "./validate.js";
+export { parsePolicyRemoteValidateResponse, policyRemoteValidateResultToDict, policyValidateQueryString, validatePolicyPayloadRemote, validatePolicyRemote, type PolicyRemoteValidateCheck, type PolicyRemoteValidateClient, type PolicyRemoteValidateIssue, type PolicyRemoteValidateOptions, type PolicyRemoteValidateResult, } from "./validate-remote.js";
+export { parseMergeReport, parsePolicyEffectiveResolveResponse, resolvePolicyEffectiveRemote, type PolicyEffectiveResolveClient, type PolicyEffectiveResolveResult, } from "./load-effective.js";
+export { PaybondPolicyReloadController, type PaybondPolicyReloadControllerState, type PolicyReloadRunner, } from "./watcher.js";
+export { PaybondPolicyReloadError, PaybondPolicyReloadUnchangedError, applyPolicySnapshotToRun, detectPolicyLoosening, loadPolicySnapshotFromEffectivePoll, loadPolicySnapshotFromFile, reloadPolicyOnHandle, reloadPolicyOnRun, requiresIntentRebind, type PaybondPolicyReloadBindConfig, type PaybondPolicyReloadFailedEvent, type PaybondPolicyReloadOptions, type PaybondPolicyReloadResult, type PaybondPolicyReloadedEvent, type PolicyReloadHandle, } from "./reload.js";