@agentproto/governance 0.1.0-alpha.0

package/dist/doctypes/index.d.ts

@@ -0,0 +1,167 @@
+import { z } from 'zod';
+export { P as POLICY_THRESHOLD, a as Policy, b as PolicyAppliesTo, c as PolicyCap, d as PolicyEscalation, e as PolicyFrontmatter, f as PolicyThreshold, R as RequiredSigner, p as policyAppliesToSchema, g as policyCapSchema, h as policyDirname, i as policyEscalationSchema, j as policyFrontmatterSchema, k as policyThresholdSchema, r as requiredSignerSchema } from '../policy-YqpSg3Ep.js';
+
+/**
+ * agentgovernance/v1 — `signature.json` doctype.
+ *
+ * Universal approval primitive. Every approval — of an agreement, deliverable,
+ * invoice, policy override, agent-issued action, etc. — is a signature on an
+ * artifact, recorded as a `<artifact-path>/../signatures/<signer>-<isoDate>.signature.json`
+ * file alongside the artifact being signed.
+ *
+ * One file = one signature event. Signatures are append-only; revocation
+ * writes a new file (or updates `revokedAt` if same signer re-issues).
+ */
+declare const SIGNER_KIND: readonly ["operator", "user", "counterparty", "agent", "external"];
+declare const signerKindSchema: z.ZodEnum<{
+    operator: "operator";
+    user: "user";
+    counterparty: "counterparty";
+    agent: "agent";
+    external: "external";
+}>;
+type SignerKind = z.infer<typeof signerKindSchema>;
+declare const SIGNING_METHOD: readonly ["typed_name", "agent_confirm", "click_through", "esign_external"];
+declare const signingMethodSchema: z.ZodEnum<{
+    typed_name: "typed_name";
+    agent_confirm: "agent_confirm";
+    click_through: "click_through";
+    esign_external: "esign_external";
+}>;
+type SigningMethod = z.infer<typeof signingMethodSchema>;
+declare const evidenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"typed_name">;
+    signerName: z.ZodString;
+    ipAddress: z.ZodString;
+    userAgent: z.ZodString;
+    nonce: z.ZodString;
+    signedUrlToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"agent_confirm">;
+    modelId: z.ZodString;
+    promptContextHash: z.ZodString;
+    reasoningSummary: z.ZodOptional<z.ZodString>;
+    conversationTurnId: z.ZodOptional<z.ZodString>;
+    authorizedByPolicy: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"click_through">;
+    ipAddress: z.ZodString;
+    userAgent: z.ZodString;
+    signedUrlToken: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"esign_external">;
+    provider: z.ZodString;
+    externalRef: z.ZodString;
+    signedPdfRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">;
+type SignatureEvidence = z.infer<typeof evidenceSchema>;
+declare const signatureSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"agentgovernance/v1">;
+    doctype: z.ZodLiteral<"signature">;
+    signer: z.ZodString;
+    signerKind: z.ZodEnum<{
+        operator: "operator";
+        user: "user";
+        counterparty: "counterparty";
+        agent: "agent";
+        external: "external";
+    }>;
+    signerEmail: z.ZodOptional<z.ZodEmail>;
+    artifactPath: z.ZodString;
+    documentHash: z.ZodString;
+    method: z.ZodEnum<{
+        typed_name: "typed_name";
+        agent_confirm: "agent_confirm";
+        click_through: "click_through";
+        esign_external: "esign_external";
+    }>;
+    evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"typed_name">;
+        signerName: z.ZodString;
+        ipAddress: z.ZodString;
+        userAgent: z.ZodString;
+        nonce: z.ZodString;
+        signedUrlToken: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"agent_confirm">;
+        modelId: z.ZodString;
+        promptContextHash: z.ZodString;
+        reasoningSummary: z.ZodOptional<z.ZodString>;
+        conversationTurnId: z.ZodOptional<z.ZodString>;
+        authorizedByPolicy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"click_through">;
+        ipAddress: z.ZodString;
+        userAgent: z.ZodString;
+        signedUrlToken: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"esign_external">;
+        provider: z.ZodString;
+        externalRef: z.ZodString;
+        signedPdfRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "kind">;
+    signedAt: z.ZodISODateTime;
+    revokedAt: z.ZodOptional<z.ZodISODateTime>;
+    revokedReason: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type Signature = z.infer<typeof signatureSchema>;
+/** Filename helper: `<signer-kind>-<signer-slug>-<isoDate>.signature.json` */
+declare function signatureFilename(signer: string, signedAt: string): string;
+
+/**
+ * agentgovernance/v1 — audit-log.jsonl line doctype.
+ *
+ * Each line of `<scope>/audit/audit-log.jsonl` is one audit event, encoded as
+ * a single JSON object on one line (no embedded newlines).
+ *
+ * Scope is whatever folder hosts the log: per-engagement
+ * (`engagements/<slug>/audit/audit-log.jsonl`) or per-workspace/guild
+ * (`audit/audit-log.jsonl` for cross-engagement events).
+ *
+ * Hash chain protocol:
+ *   signature_n = HMAC-SHA256(secret, signature_{n-1} ‖ canonical(row_n))
+ *
+ * The first line's `prevSignature` is the workspace genesis seed (vault-backed).
+ * See `../hash-chain/protocol.md` for the canonical-bytes specification.
+ */
+declare const ACTOR_KIND: readonly ["operator", "user", "counterparty", "agent", "system"];
+declare const actorKindSchema: z.ZodEnum<{
+    operator: "operator";
+    user: "user";
+    counterparty: "counterparty";
+    agent: "agent";
+    system: "system";
+}>;
+type ActorKind = z.infer<typeof actorKindSchema>;
+/** Common entity types. Apps may extend via metadata or contributing entries. */
+declare const KNOWN_ENTITY_TYPES: readonly ["signature", "audit-event", "policy", "approval", "engagement", "agreement", "deliverable", "invoice", "service", "counterparty", "routine", "procedure", "task", "project", "company", "agent"];
+declare const auditEventSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"agentgovernance/v1">;
+    doctype: z.ZodLiteral<"audit-event">;
+    actorKind: z.ZodEnum<{
+        operator: "operator";
+        user: "user";
+        counterparty: "counterparty";
+        agent: "agent";
+        system: "system";
+    }>;
+    actorId: z.ZodNullable<z.ZodString>;
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    action: z.ZodString;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    prevSignature: z.ZodString;
+    signature: z.ZodString;
+    requestId: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodOptional<z.ZodString>;
+    ipAddress: z.ZodOptional<z.ZodString>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type AuditEvent = z.infer<typeof auditEventSchema>;
+/** Convenience: parse a single JSONL line. Returns parsed event or throws. */
+declare function parseAuditLine(line: string): AuditEvent;
+
+export { ACTOR_KIND, type ActorKind, type AuditEvent, KNOWN_ENTITY_TYPES, SIGNER_KIND, SIGNING_METHOD, type Signature, type SignatureEvidence, type SignerKind, type SigningMethod, actorKindSchema, auditEventSchema, evidenceSchema, parseAuditLine, signatureFilename, signatureSchema, signerKindSchema, signingMethodSchema };

package/dist/doctypes/index.mjs

@@ -0,0 +1,4 @@
+import '../chunk-7GHDRKSD.mjs';
+export { ACTOR_KIND, KNOWN_ENTITY_TYPES, POLICY_THRESHOLD, SIGNER_KIND, SIGNING_METHOD, actorKindSchema, auditEventSchema, evidenceSchema, parseAuditLine, policyAppliesToSchema, policyCapSchema, policyDirname, policyEscalationSchema, policyFrontmatterSchema, policyThresholdSchema, requiredSignerSchema, signatureFilename, signatureSchema, signerKindSchema, signingMethodSchema } from '../chunk-J2DX2WOA.mjs';
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/doctypes/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/hash-chain/index.d.ts

@@ -0,0 +1,40 @@
+export { V as VerifyChainOptions, a as VerifyChainResult, v as verifyChain } from '../verify-e_UfVr02.js';
+
+/**
+ * Canonicalize a row to deterministic UTF-8 bytes.
+ *
+ * Sorts object keys, drops `undefined` values, and emits whitespace-free JSON.
+ */
+declare function canonicalize(value: unknown): Uint8Array;
+/** Internal: canonical JSON string. */
+declare function canonicalJsonString(value: unknown): string;
+interface ChainComputeOptions {
+    /** Workspace genesis seed (hex) — used as prev_signature for the first line. */
+    genesisSeed: string;
+    /** HMAC secret key (utf-8 string or hex). */
+    secret: string;
+}
+interface ComputedChainSignature {
+    /** Hex-encoded HMAC-SHA256. */
+    signature: string;
+    /** Hex-encoded prevSignature carried into this row. */
+    prevSignature: string;
+}
+/**
+ * Compute the chain signature for a row given the previous signature.
+ *
+ * @param row - The audit-event row (the `signature` field, if present, is excluded from the canonical bytes).
+ * @param prevSignature - The previous line's signature (or the workspace genesis seed for the first line). Hex-encoded.
+ * @param secret - HMAC secret (passed verbatim as the HMAC key).
+ * @returns Hex-encoded SHA-256 HMAC.
+ */
+declare function computeChainSignature(row: Record<string, unknown>, prevSignature: string, secret: string): string;
+/**
+ * Compute the signature and produce a ready-to-write row with `prevSignature` and `signature` populated.
+ */
+declare function chainRow(rowWithoutChainFields: Record<string, unknown>, prevSignature: string, secret: string): Record<string, unknown> & {
+    prevSignature: string;
+    signature: string;
+};
+
+export { type ChainComputeOptions, type ComputedChainSignature, canonicalJsonString, canonicalize, chainRow, computeChainSignature };

package/dist/hash-chain/index.mjs

@@ -0,0 +1,4 @@
+import '../chunk-5G463T6C.mjs';
+export { canonicalJsonString, canonicalize, chainRow, computeChainSignature, verifyChain } from '../chunk-VWEBMWO2.mjs';
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/hash-chain/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export { ACTOR_KIND, ActorKind, AuditEvent, KNOWN_ENTITY_TYPES, SIGNER_KIND, SIGNING_METHOD, Signature, SignatureEvidence, SignerKind, SigningMethod, actorKindSchema, auditEventSchema, evidenceSchema, parseAuditLine, signatureFilename, signatureSchema, signerKindSchema, signingMethodSchema } from './doctypes/index.js';
+export { P as POLICY_THRESHOLD, a as Policy, b as PolicyAppliesTo, c as PolicyCap, d as PolicyEscalation, e as PolicyFrontmatter, f as PolicyThreshold, R as RequiredSigner, p as policyAppliesToSchema, g as policyCapSchema, h as policyDirname, i as policyEscalationSchema, j as policyFrontmatterSchema, k as policyThresholdSchema, r as requiredSignerSchema } from './policy-YqpSg3Ep.js';
+export { ValidationError, ValidationResult, validateAuditEvent, validateAuditLog, validatePolicy, validateSignature, validateSignatureAgainstArtifact } from './validators/index.js';
+export { ChainComputeOptions, ComputedChainSignature, canonicalJsonString, canonicalize, chainRow, computeChainSignature } from './hash-chain/index.js';
+export { V as VerifyChainOptions, a as VerifyChainResult, v as verifyChain } from './verify-e_UfVr02.js';
+import 'zod';
+
+/**
+ * @agentproto/governance — agentgovernance/v1 spec implementation.
+ *
+ * Universal contractual approval framework: signatures, audit logs, policies.
+ * All doctypes are workspace files; this package is filesystem-first and
+ * vendor-neutral (no Mastra, LangChain, Temporal imports).
+ *
+ * Subpath exports:
+ *   - "./doctypes"   — zod schemas + inferred types for signature, audit-event, policy
+ *   - "./hash-chain" — canonical row hashing + chain compute/verify
+ *   - "./validators" — per-doctype validators
+ *
+ * Reference runtime (audit-chain writer, sign-artifact orchestrator, _index
+ * helpers) lives in the sibling package `@agentproto/governance-engine`. Spec
+ * stays pure: zero I/O, zero filesystem deps. Consumers needing only types +
+ * validators (CI validators, third-party language ports) avoid pulling node:fs.
+ *
+ * Spec doc: ./AGENTGOVERNANCE.md (canonical)
+ *           src/spec/agentgovernance-v1.md (source of truth)
+ */
+declare const SPEC_NAME: "agentgovernance/v1";
+declare const SPEC_VERSION: "1.0.0-alpha";
+
+export { SPEC_NAME, SPEC_VERSION };

package/dist/index.mjs

@@ -0,0 +1,19 @@
+import './chunk-7GHDRKSD.mjs';
+import './chunk-5G463T6C.mjs';
+export { validateAuditEvent, validateAuditLog, validatePolicy, validateSignature, validateSignatureAgainstArtifact } from './chunk-UVBFLWSG.mjs';
+export { canonicalJsonString, canonicalize, chainRow, computeChainSignature, verifyChain } from './chunk-VWEBMWO2.mjs';
+export { ACTOR_KIND, KNOWN_ENTITY_TYPES, POLICY_THRESHOLD, SIGNER_KIND, SIGNING_METHOD, actorKindSchema, auditEventSchema, evidenceSchema, parseAuditLine, policyAppliesToSchema, policyCapSchema, policyDirname, policyEscalationSchema, policyFrontmatterSchema, policyThresholdSchema, requiredSignerSchema, signatureFilename, signatureSchema, signerKindSchema, signingMethodSchema } from './chunk-J2DX2WOA.mjs';
+
+/**
+ * @agentproto/governance v0.1.0-alpha
+ * agentgovernance/v1 — universal contractual approval framework.
+ * Vendor-neutral. Filesystem-first. Third-party verifiable.
+ */
+
+// src/index.ts
+var SPEC_NAME = "agentgovernance/v1";
+var SPEC_VERSION = "1.0.0-alpha";
+
+export { SPEC_NAME, SPEC_VERSION };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAqBO,IAAM,SAAA,GAAY;AAClB,IAAM,YAAA,GAAe","file":"index.mjs","sourcesContent":["/**\n * @agentproto/governance — agentgovernance/v1 spec implementation.\n *\n * Universal contractual approval framework: signatures, audit logs, policies.\n * All doctypes are workspace files; this package is filesystem-first and\n * vendor-neutral (no Mastra, LangChain, Temporal imports).\n *\n * Subpath exports:\n *   - \"./doctypes\"   — zod schemas + inferred types for signature, audit-event, policy\n *   - \"./hash-chain\" — canonical row hashing + chain compute/verify\n *   - \"./validators\" — per-doctype validators\n *\n * Reference runtime (audit-chain writer, sign-artifact orchestrator, _index\n * helpers) lives in the sibling package `@agentproto/governance-engine`. Spec\n * stays pure: zero I/O, zero filesystem deps. Consumers needing only types +\n * validators (CI validators, third-party language ports) avoid pulling node:fs.\n *\n * Spec doc: ./AGENTGOVERNANCE.md (canonical)\n *           src/spec/agentgovernance-v1.md (source of truth)\n */\n\nexport const SPEC_NAME = \"agentgovernance/v1\" as const\nexport const SPEC_VERSION = \"1.0.0-alpha\" as const\n\nexport * from \"./spec/doctypes/index.js\"\nexport * from \"./spec/validators/index.js\"\nexport * from \"./spec/hash-chain/index.js\"\n"]}

package/dist/policy/index.d.ts

@@ -0,0 +1,104 @@
+import { b as PolicyAppliesTo, c as PolicyCap, f as PolicyThreshold, R as RequiredSigner, d as PolicyEscalation, e as PolicyFrontmatter } from '../policy-YqpSg3Ep.js';
+import 'zod';
+
+/**
+ * AIP-7 POLICY.md — `definePolicy` constructor + `policyFromManifest`
+ * markdown-authored entry. Built on `@agentproto/define-doctype`.
+ *
+ * Policies are the AIP-7 doctype that declares "what an autonomous
+ * actor may do without further approval, and what threshold of
+ * signatures it needs when a cap is exceeded". Authoring path A
+ * (`definePolicy({...})`) covers the in-process / TS-authored case;
+ * authoring path B (`policyFromManifest(parsed)`) covers the
+ * filesystem-authored case where the policy ships as a `POLICY.md`
+ * under a workspace's `policies/<slug>/` folder.
+ *
+ * Both paths land in the same `createDoctype` pipeline as `defineTool`
+ * and `defineDriver`: identity is regex-validated, the produced handle
+ * is `Object.freeze`-d, errors carry the canonical `definePolicy
+ * (AIP-7): …` prefix, and spec-specific invariants run after the
+ * shared ones.
+ *
+ * Departs from the AIP-14/AIP-30 default shape on three axes — which
+ * is what makes this a useful test of the meta-factory's flexibility:
+ *   - identity field is `slug`, not `id`
+ *   - identity pattern is stricter (no dots, no underscores): `^[a-z0-9][a-z0-9-]*$`
+ *   - `description` is OPTIONAL on the doctype; the LLM-facing copy
+ *     lives in `name`. We skip the description length check entirely.
+ */
+
+declare const POLICY_SLUG_PATTERN: RegExp;
+/**
+ * Input to `definePolicy`. Mirrors `PolicyFrontmatter` minus the
+ * spec-fixed `schema` and `doctype` fields (which the runtime fills).
+ * Every other field is preserved verbatim.
+ */
+interface PolicyDefinition {
+    slug: string;
+    name: string;
+    description?: string;
+    appliesTo?: readonly PolicyAppliesTo[];
+    caps?: readonly PolicyCap[];
+    threshold?: PolicyThreshold;
+    /** Required when `threshold === "weighted_threshold"`. */
+    requiredWeight?: number;
+    requiredSignatures?: readonly RequiredSigner[];
+    /** ISO-8601 duration. */
+    deadline?: string;
+    escalation?: PolicyEscalation;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * The host-registrable handle returned by `definePolicy`. Frozen,
+ * with array/object fields shallow-frozen to lock the wire shape.
+ */
+interface PolicyHandle {
+    readonly schema: "agentgovernance/v1";
+    readonly doctype: "policy";
+    readonly slug: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly appliesTo: readonly PolicyAppliesTo[];
+    readonly caps: readonly PolicyCap[];
+    readonly threshold: PolicyThreshold;
+    readonly requiredWeight?: number;
+    readonly requiredSignatures: readonly RequiredSigner[];
+    readonly deadline?: string;
+    readonly escalation?: PolicyEscalation;
+    readonly metadata: Record<string, unknown>;
+}
+/**
+ * AIP-7 reference implementation of `definePolicy`. Goes through
+ * `createDoctype` so the cross-AIP invariants (slug pattern check,
+ * top-level freeze, `definePolicy (AIP-7): …` error prefix) run
+ * uniformly with `defineTool` / `defineDriver`.
+ *
+ * Spec-specific validation enforced here:
+ *   - `name` must be 1+ chars (zod-equivalent of `.min(1)`)
+ *   - `threshold === "weighted_threshold"` requires `requiredWeight`
+ *     to be set (matches the `.refine()` on the manifest schema).
+ */
+declare const definePolicy: (def: PolicyDefinition) => PolicyHandle;
+/**
+ * Parsed POLICY.md manifest — frontmatter validated against the
+ * AIP-7 zod schema, body kept as-is for downstream consumers.
+ */
+interface PolicyManifest {
+    frontmatter: PolicyFrontmatter;
+    body: string;
+}
+/**
+ * Parse a POLICY.md source string. Throws on missing or schema-invalid
+ * frontmatter.
+ */
+declare function parsePolicyManifest(source: string): PolicyManifest;
+/**
+ * Build a {@link PolicyHandle} from a parsed `POLICY.md` manifest.
+ * Same single-source-of-truth principle as `toolFromManifest` /
+ * `driverFromManifest`: the frontmatter is the source of truth for
+ * metadata; the handle ends up in `definePolicy` so AIP-7 invariants
+ * (and the meta-factory's shared invariants) run uniformly.
+ */
+declare function policyFromManifest(manifest: PolicyManifest): PolicyHandle;
+
+export { POLICY_SLUG_PATTERN, type PolicyDefinition, type PolicyHandle, type PolicyManifest, definePolicy, parsePolicyManifest, policyFromManifest };

package/dist/policy/index.mjs

@@ -0,0 +1,82 @@
+import { policyFrontmatterSchema } from '../chunk-J2DX2WOA.mjs';
+import { createDoctype } from '@agentproto/define-doctype';
+import matter from 'gray-matter';
+
+/**
+ * @agentproto/governance v0.1.0-alpha
+ * agentgovernance/v1 — universal contractual approval framework.
+ * Vendor-neutral. Filesystem-first. Third-party verifiable.
+ */
+var POLICY_SLUG_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+var definePolicy = createDoctype({
+  aip: 7,
+  name: "policy",
+  readIdentity: (def) => def.slug,
+  idPattern: POLICY_SLUG_PATTERN,
+  // POLICY.md treats `description` as optional and uses `name` as the
+  // human-readable label. Skip the cross-AIP description check; let
+  // spec-7 validate `name` itself in `validate()`.
+  readDescription: false,
+  validate(def) {
+    if (typeof def.name !== "string" || def.name.length === 0) {
+      throw new Error(
+        `definePolicy (AIP-7): slug='${def.slug}' name must be a non-empty string`
+      );
+    }
+    if (def.threshold === "weighted_threshold" && typeof def.requiredWeight !== "number") {
+      throw new Error(
+        `definePolicy (AIP-7): slug='${def.slug}' threshold='weighted_threshold' requires requiredWeight to be set`
+      );
+    }
+  },
+  build(def) {
+    return {
+      schema: "agentgovernance/v1",
+      doctype: "policy",
+      slug: def.slug,
+      name: def.name,
+      description: def.description,
+      appliesTo: Object.freeze([...def.appliesTo ?? []]),
+      caps: Object.freeze([...def.caps ?? []]),
+      threshold: def.threshold ?? "single",
+      requiredWeight: def.requiredWeight,
+      requiredSignatures: Object.freeze([...def.requiredSignatures ?? []]),
+      deadline: def.deadline,
+      escalation: def.escalation,
+      metadata: Object.freeze({ ...def.metadata ?? {} })
+    };
+  }
+});
+function parsePolicyManifest(source) {
+  const parsed = matter(source);
+  if (Object.keys(parsed.data).length === 0) {
+    throw new Error("parsePolicyManifest: missing or empty frontmatter");
+  }
+  const result = policyFrontmatterSchema.safeParse(parsed.data);
+  if (!result.success) {
+    throw new Error(
+      `parsePolicyManifest: invalid frontmatter \u2014 ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+  }
+  return { frontmatter: result.data, body: parsed.content };
+}
+function policyFromManifest(manifest) {
+  const fm = manifest.frontmatter;
+  return definePolicy({
+    slug: fm.slug,
+    name: fm.name,
+    description: fm.description,
+    appliesTo: fm.appliesTo,
+    caps: fm.caps,
+    threshold: fm.threshold,
+    requiredWeight: fm.requiredWeight,
+    requiredSignatures: fm.requiredSignatures,
+    deadline: fm.deadline,
+    escalation: fm.escalation,
+    metadata: fm.metadata
+  });
+}
+
+export { POLICY_SLUG_PATTERN, definePolicy, parsePolicyManifest, policyFromManifest };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/policy/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/policy/index.ts"],"names":[],"mappings":";;;;;;;;;AAsCA,IAAM,mBAAA,GAAsB;AAsDrB,IAAM,eAAe,aAAA,CAA8C;AAAA,EACxE,GAAA,EAAK,CAAA;AAAA,EACL,IAAA,EAAM,QAAA;AAAA,EACN,YAAA,EAAc,CAAC,GAAA,KAAQ,GAAA,CAAI,IAAA;AAAA,EAC3B,SAAA,EAAW,mBAAA;AAAA;AAAA;AAAA;AAAA,EAIX,eAAA,EAAiB,KAAA;AAAA,EACjB,SAAS,GAAA,EAAK;AACZ,IAAA,IAAI,OAAO,GAAA,CAAI,IAAA,KAAS,YAAY,GAAA,CAAI,IAAA,CAAK,WAAW,CAAA,EAAG;AACzD,MAAA,MAAM,IAAI,KAAA;AAAA,QACR,CAAA,4BAAA,EAA+B,IAAI,IAAI,CAAA,iCAAA;AAAA,OACzC;AAAA,IACF;AACA,IAAA,IACE,IAAI,SAAA,KAAc,oBAAA,IAClB,OAAO,GAAA,CAAI,mBAAmB,QAAA,EAC9B;AACA,MAAA,MAAM,IAAI,KAAA;AAAA,QACR,CAAA,4BAAA,EAA+B,IAAI,IAAI,CAAA,kEAAA;AAAA,OACzC;AAAA,IACF;AAAA,EACF,CAAA;AAAA,EACA,MAAM,GAAA,EAAK;AACT,IAAA,OAAO;AAAA,MACL,MAAA,EAAQ,oBAAA;AAAA,MACR,OAAA,EAAS,QAAA;AAAA,MACT,MAAM,GAAA,CAAI,IAAA;AAAA,MACV,MAAM,GAAA,CAAI,IAAA;AAAA,MACV,aAAa,GAAA,CAAI,WAAA;AAAA,MACjB,SAAA,EAAW,OAAO,MAAA,CAAO,CAAC,GAAI,GAAA,CAAI,SAAA,IAAa,EAAG,CAAC,CAAA;AAAA,MACnD,IAAA,EAAM,OAAO,MAAA,CAAO,CAAC,GAAI,GAAA,CAAI,IAAA,IAAQ,EAAG,CAAC,CAAA;AAAA,MACzC,SAAA,EAAW,IAAI,SAAA,IAAa,QAAA;AAAA,MAC5B,gBAAgB,GAAA,CAAI,cAAA;AAAA,MACpB,kBAAA,EAAoB,OAAO,MAAA,CAAO,CAAC,GAAI,GAAA,CAAI,kBAAA,IAAsB,EAAG,CAAC,CAAA;AAAA,MACrE,UAAU,GAAA,CAAI,QAAA;AAAA,MACd,YAAY,GAAA,CAAI,UAAA;AAAA,MAChB,QAAA,EAAU,OAAO,MAAA,CAAO,EAAE,GAAI,GAAA,CAAI,QAAA,IAAY,EAAC,EAAI;AAAA,KACrD;AAAA,EACF;AACF,CAAC;AAeM,SAAS,oBAAoB,MAAA,EAAgC;AAClE,EAAA,MAAM,MAAA,GAAS,OAAO,MAAM,CAAA;AAC5B,EAAA,IAAI,OAAO,IAAA,CAAK,MAAA,CAAO,IAAI,CAAA,CAAE,WAAW,CAAA,EAAG;AACzC,IAAA,MAAM,IAAI,MAAM,mDAAmD,CAAA;AAAA,EACrE;AACA,EAAA,MAAM,MAAA,GAAS,uBAAA,CAAwB,SAAA,CAAU,MAAA,CAAO,IAAI,CAAA;AAC5D,EAAA,IAAI,CAAC,OAAO,OAAA,EAAS;AACnB,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,CAAA,gDAAA,EAA8C,OAAO,KAAA,CAAM,MAAA,CACxD,IAAI,CAAC,CAAA,KAAM,GAAG,CAAA,CAAE,IAAA,CAAK,KAAK,GAAG,CAAC,KAAK,CAAA,CAAE,OAAO,EAAE,CAAA,CAC9C,IAAA,CAAK,IAAI,CAAC,CAAA;AAAA,KACf;AAAA,EACF;AACA,EAAA,OAAO,EAAE,WAAA,EAAa,MAAA,CAAO,IAAA,EAAM,IAAA,EAAM,OAAO,OAAA,EAAQ;AAC1D;AASO,SAAS,mBAAmB,QAAA,EAAwC;AACzE,EAAA,MAAM,KAAK,QAAA,CAAS,WAAA;AACpB,EAAA,OAAO,YAAA,CAAa;AAAA,IAClB,MAAM,EAAA,CAAG,IAAA;AAAA,IACT,MAAM,EAAA,CAAG,IAAA;AAAA,IACT,aAAa,EAAA,CAAG,WAAA;AAAA,IAChB,WAAW,EAAA,CAAG,SAAA;AAAA,IACd,MAAM,EAAA,CAAG,IAAA;AAAA,IACT,WAAW,EAAA,CAAG,SAAA;AAAA,IACd,gBAAgB,EAAA,CAAG,cAAA;AAAA,IACnB,oBAAoB,EAAA,CAAG,kBAAA;AAAA,IACvB,UAAU,EAAA,CAAG,QAAA;AAAA,IACb,YAAY,EAAA,CAAG,UAAA;AAAA,IACf,UAAU,EAAA,CAAG;AAAA,GACd,CAAA;AACH","file":"index.mjs","sourcesContent":["/**\n * AIP-7 POLICY.md — `definePolicy` constructor + `policyFromManifest`\n * markdown-authored entry. Built on `@agentproto/define-doctype`.\n *\n * Policies are the AIP-7 doctype that declares \"what an autonomous\n * actor may do without further approval, and what threshold of\n * signatures it needs when a cap is exceeded\". Authoring path A\n * (`definePolicy({...})`) covers the in-process / TS-authored case;\n * authoring path B (`policyFromManifest(parsed)`) covers the\n * filesystem-authored case where the policy ships as a `POLICY.md`\n * under a workspace's `policies/<slug>/` folder.\n *\n * Both paths land in the same `createDoctype` pipeline as `defineTool`\n * and `defineDriver`: identity is regex-validated, the produced handle\n * is `Object.freeze`-d, errors carry the canonical `definePolicy\n * (AIP-7): …` prefix, and spec-specific invariants run after the\n * shared ones.\n *\n * Departs from the AIP-14/AIP-30 default shape on three axes — which\n * is what makes this a useful test of the meta-factory's flexibility:\n *   - identity field is `slug`, not `id`\n *   - identity pattern is stricter (no dots, no underscores): `^[a-z0-9][a-z0-9-]*$`\n *   - `description` is OPTIONAL on the doctype; the LLM-facing copy\n *     lives in `name`. We skip the description length check entirely.\n */\n\nimport { createDoctype } from \"@agentproto/define-doctype\"\nimport matter from \"gray-matter\"\nimport {\n  policyFrontmatterSchema,\n  type PolicyAppliesTo,\n  type PolicyCap,\n  type PolicyEscalation,\n  type PolicyFrontmatter,\n  type PolicyThreshold,\n  type RequiredSigner,\n} from \"../spec/doctypes/policy.js\"\n\nconst POLICY_SLUG_PATTERN = /^[a-z0-9][a-z0-9-]*$/\n\n/**\n * Input to `definePolicy`. Mirrors `PolicyFrontmatter` minus the\n * spec-fixed `schema` and `doctype` fields (which the runtime fills).\n * Every other field is preserved verbatim.\n */\nexport interface PolicyDefinition {\n  slug: string\n  name: string\n  description?: string\n  appliesTo?: readonly PolicyAppliesTo[]\n  caps?: readonly PolicyCap[]\n  threshold?: PolicyThreshold\n  /** Required when `threshold === \"weighted_threshold\"`. */\n  requiredWeight?: number\n  requiredSignatures?: readonly RequiredSigner[]\n  /** ISO-8601 duration. */\n  deadline?: string\n  escalation?: PolicyEscalation\n  metadata?: Record<string, unknown>\n}\n\n/**\n * The host-registrable handle returned by `definePolicy`. Frozen,\n * with array/object fields shallow-frozen to lock the wire shape.\n */\nexport interface PolicyHandle {\n  readonly schema: \"agentgovernance/v1\"\n  readonly doctype: \"policy\"\n  readonly slug: string\n  readonly name: string\n  readonly description?: string\n  readonly appliesTo: readonly PolicyAppliesTo[]\n  readonly caps: readonly PolicyCap[]\n  readonly threshold: PolicyThreshold\n  readonly requiredWeight?: number\n  readonly requiredSignatures: readonly RequiredSigner[]\n  readonly deadline?: string\n  readonly escalation?: PolicyEscalation\n  readonly metadata: Record<string, unknown>\n}\n\n/**\n * AIP-7 reference implementation of `definePolicy`. Goes through\n * `createDoctype` so the cross-AIP invariants (slug pattern check,\n * top-level freeze, `definePolicy (AIP-7): …` error prefix) run\n * uniformly with `defineTool` / `defineDriver`.\n *\n * Spec-specific validation enforced here:\n *   - `name` must be 1+ chars (zod-equivalent of `.min(1)`)\n *   - `threshold === \"weighted_threshold\"` requires `requiredWeight`\n *     to be set (matches the `.refine()` on the manifest schema).\n */\nexport const definePolicy = createDoctype<PolicyDefinition, PolicyHandle>({\n  aip: 7,\n  name: \"policy\",\n  readIdentity: (def) => def.slug,\n  idPattern: POLICY_SLUG_PATTERN,\n  // POLICY.md treats `description` as optional and uses `name` as the\n  // human-readable label. Skip the cross-AIP description check; let\n  // spec-7 validate `name` itself in `validate()`.\n  readDescription: false,\n  validate(def) {\n    if (typeof def.name !== \"string\" || def.name.length === 0) {\n      throw new Error(\n        `definePolicy (AIP-7): slug='${def.slug}' name must be a non-empty string`,\n      )\n    }\n    if (\n      def.threshold === \"weighted_threshold\" &&\n      typeof def.requiredWeight !== \"number\"\n    ) {\n      throw new Error(\n        `definePolicy (AIP-7): slug='${def.slug}' threshold='weighted_threshold' requires requiredWeight to be set`,\n      )\n    }\n  },\n  build(def) {\n    return {\n      schema: \"agentgovernance/v1\",\n      doctype: \"policy\",\n      slug: def.slug,\n      name: def.name,\n      description: def.description,\n      appliesTo: Object.freeze([...(def.appliesTo ?? [])]),\n      caps: Object.freeze([...(def.caps ?? [])]),\n      threshold: def.threshold ?? \"single\",\n      requiredWeight: def.requiredWeight,\n      requiredSignatures: Object.freeze([...(def.requiredSignatures ?? [])]),\n      deadline: def.deadline,\n      escalation: def.escalation,\n      metadata: Object.freeze({ ...(def.metadata ?? {}) }),\n    }\n  },\n})\n\n/**\n * Parsed POLICY.md manifest — frontmatter validated against the\n * AIP-7 zod schema, body kept as-is for downstream consumers.\n */\nexport interface PolicyManifest {\n  frontmatter: PolicyFrontmatter\n  body: string\n}\n\n/**\n * Parse a POLICY.md source string. Throws on missing or schema-invalid\n * frontmatter.\n */\nexport function parsePolicyManifest(source: string): PolicyManifest {\n  const parsed = matter(source)\n  if (Object.keys(parsed.data).length === 0) {\n    throw new Error(\"parsePolicyManifest: missing or empty frontmatter\")\n  }\n  const result = policyFrontmatterSchema.safeParse(parsed.data)\n  if (!result.success) {\n    throw new Error(\n      `parsePolicyManifest: invalid frontmatter — ${result.error.issues\n        .map((i) => `${i.path.join(\".\")}: ${i.message}`)\n        .join(\"; \")}`,\n    )\n  }\n  return { frontmatter: result.data, body: parsed.content }\n}\n\n/**\n * Build a {@link PolicyHandle} from a parsed `POLICY.md` manifest.\n * Same single-source-of-truth principle as `toolFromManifest` /\n * `driverFromManifest`: the frontmatter is the source of truth for\n * metadata; the handle ends up in `definePolicy` so AIP-7 invariants\n * (and the meta-factory's shared invariants) run uniformly.\n */\nexport function policyFromManifest(manifest: PolicyManifest): PolicyHandle {\n  const fm = manifest.frontmatter\n  return definePolicy({\n    slug: fm.slug,\n    name: fm.name,\n    description: fm.description,\n    appliesTo: fm.appliesTo,\n    caps: fm.caps,\n    threshold: fm.threshold,\n    requiredWeight: fm.requiredWeight,\n    requiredSignatures: fm.requiredSignatures,\n    deadline: fm.deadline,\n    escalation: fm.escalation,\n    metadata: fm.metadata,\n  })\n}\n\nexport { POLICY_SLUG_PATTERN }\n"]}

package/dist/policy-YqpSg3Ep.d.ts

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+
+/**
+ * agentgovernance/v1 — POLICY.md doctype.
+ *
+ * Declarative autonomy rule. Frontmatter declares scope (who/what the policy
+ * applies to), constraints (caps, thresholds), and what's required when those
+ * thresholds are exceeded (signatures, escalation). Body is human-readable
+ * narrative + edge cases.
+ *
+ * File location: `<scope>/policies/<slug>/POLICY.md` (e.g.,
+ * `policies/invoice-cap-500eur/POLICY.md`).
+ *
+ * Example frontmatter:
+ *
+ * ```yaml
+ * schema: agentgovernance/v1
+ * doctype: policy
+ * slug: invoice-cap-500eur
+ * name: Invoice cap 500 EUR
+ * appliesTo:
+ *   - actorKind: operator
+ *     actionType: agency.issue_invoice
+ * caps:
+ *   - field: amount
+ *     max: 500
+ *     currency: EUR
+ * threshold: single
+ * requiredSignatures:
+ *   - signer: operator:founder
+ *     method: typed_name
+ * deadline: PT24H
+ * escalation:
+ *   leadTime: PT2H
+ *   escalateTo: [operator:cofounder]
+ * ```
+ */
+declare const policyAppliesToSchema: z.ZodObject<{
+    actorKind: z.ZodOptional<z.ZodEnum<{
+        operator: "operator";
+        user: "user";
+        counterparty: "counterparty";
+        agent: "agent";
+        system: "system";
+    }>>;
+    actorId: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+    actionType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type PolicyAppliesTo = z.infer<typeof policyAppliesToSchema>;
+declare const policyCapSchema: z.ZodObject<{
+    field: z.ZodString;
+    max: z.ZodOptional<z.ZodNumber>;
+    min: z.ZodOptional<z.ZodNumber>;
+    currency: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type PolicyCap = z.infer<typeof policyCapSchema>;
+/** How collected signatures are evaluated. */
+declare const POLICY_THRESHOLD: readonly ["auto", "single", "all_of", "any_of", "weighted_threshold"];
+declare const policyThresholdSchema: z.ZodEnum<{
+    auto: "auto";
+    single: "single";
+    all_of: "all_of";
+    any_of: "any_of";
+    weighted_threshold: "weighted_threshold";
+}>;
+type PolicyThreshold = z.infer<typeof policyThresholdSchema>;
+declare const requiredSignerSchema: z.ZodObject<{
+    signer: z.ZodString;
+    method: z.ZodEnum<{
+        typed_name: "typed_name";
+        agent_confirm: "agent_confirm";
+        click_through: "click_through";
+        esign_external: "esign_external";
+    }>;
+    weight: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type RequiredSigner = z.infer<typeof requiredSignerSchema>;
+declare const policyEscalationSchema: z.ZodObject<{
+    leadTime: z.ZodString;
+    escalateTo: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type PolicyEscalation = z.infer<typeof policyEscalationSchema>;
+declare const policyFrontmatterSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"agentgovernance/v1">;
+    doctype: z.ZodLiteral<"policy">;
+    slug: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    appliesTo: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        actorKind: z.ZodOptional<z.ZodEnum<{
+            operator: "operator";
+            user: "user";
+            counterparty: "counterparty";
+            agent: "agent";
+            system: "system";
+        }>>;
+        actorId: z.ZodOptional<z.ZodString>;
+        teamId: z.ZodOptional<z.ZodString>;
+        actionType: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    caps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        max: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+        currency: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    threshold: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        single: "single";
+        all_of: "all_of";
+        any_of: "any_of";
+        weighted_threshold: "weighted_threshold";
+    }>>;
+    requiredWeight: z.ZodOptional<z.ZodNumber>;
+    requiredSignatures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        signer: z.ZodString;
+        method: z.ZodEnum<{
+            typed_name: "typed_name";
+            agent_confirm: "agent_confirm";
+            click_through: "click_through";
+            esign_external: "esign_external";
+        }>;
+        weight: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    deadline: z.ZodOptional<z.ZodString>;
+    escalation: z.ZodOptional<z.ZodObject<{
+        leadTime: z.ZodString;
+        escalateTo: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type PolicyFrontmatter = z.infer<typeof policyFrontmatterSchema>;
+/**
+ * Parsed POLICY.md = frontmatter + markdown body.
+ * The body is informational (humans + agents can read it); it is NOT used by
+ * the policy engine for decisions.
+ */
+interface Policy {
+    frontmatter: PolicyFrontmatter;
+    body: string;
+}
+/** Convenience filename helper. */
+declare function policyDirname(slug: string): string;
+
+export { POLICY_THRESHOLD as P, type RequiredSigner as R, type Policy as a, type PolicyAppliesTo as b, type PolicyCap as c, type PolicyEscalation as d, type PolicyFrontmatter as e, type PolicyThreshold as f, policyCapSchema as g, policyDirname as h, policyEscalationSchema as i, policyFrontmatterSchema as j, policyThresholdSchema as k, policyAppliesToSchema as p, requiredSignerSchema as r };