@parmana/shared 0.0.0-stage → 0.1.0

package/dist/domain/decision.d.ts

@@ -0,0 +1,89 @@
+import { PolicyReference } from "./policy-reference.js";
+import type { JsonValue } from "../types/Json.js";
+import type { DecisionAssessment } from "./business-validation.js";
+/**
+ * Parmana Trust Core
+ *
+ * Decision
+ *
+ * Immutable result produced by evaluating an
+ * Intent against a Policy.
+ *
+ * Decision does not create authority.
+ * Decision does not grant authorization.
+ * Decision does not modify intent.
+ *
+ * Decision records only the outcome of
+ * deterministic Policy evaluation.
+ */
+export interface Decision {
+    /**
+     * Unique Decision identifier.
+     */
+    readonly decisionId: string;
+    /**
+     * Intent evaluated by this Decision.
+     */
+    readonly intentId: string;
+    /**
+     * Exact Policy used.
+     */
+    readonly policy: PolicyReference;
+    /**
+     * Runtime signals evaluated by the policy.
+     *
+     * These are captured to support deterministic
+     * replay and independent verification.
+     */
+    readonly signals: Record<string, JsonValue>;
+    /**
+     * Policy evaluation outcome.
+     */
+    readonly outcome: DecisionOutcome;
+    /**
+     * Optional explanation.
+     */
+    readonly reason?: string;
+    /**
+     * Identifier of the Policy rule that matched, or "none" when no rule
+     * matched. Optional and caller-unsettable, the same pattern as
+     * PolicyReference.contentHash (G-24): a request-supplied Decision
+     * never carries this -- it is copied verbatim from
+     * PolicyEngine.evaluate()'s PolicyDecision by DecisionBuilder, never
+     * computed here. Absent only on a Decision built before this field
+     * existed (docs/VERIFICATION-GAPS.md G-44); every Decision built
+     * going forward carries it.
+     */
+    readonly matchedRuleId?: string;
+    /**
+     * Number of rules PolicyEngine evaluated before reaching a match (or
+     * exhausting the rule list). Same provenance and optionality as
+     * matchedRuleId above.
+     */
+    readonly evaluatedRules?: number;
+    /**
+     * Ordered rule-id trace PolicyEngine walked to reach matchedRuleId --
+     * lets an auditor independently reconstruct exactly how this
+     * Decision was reached, not merely which rule ultimately matched.
+     * Same provenance and optionality as matchedRuleId above.
+     */
+    readonly matchedPath?: readonly string[];
+    /**
+     * UTC timestamp when evaluation completed.
+     */
+    readonly evaluatedAt: Date;
+    /**
+     * Authority, business validation and, for a refusal, execution, each
+     * as its own status (RFC-0023). Absent on decisions made before it
+     * existed; those records still verify.
+     */
+    readonly assessment?: DecisionAssessment;
+}
+/**
+ * Canonical Decision outcomes.
+ */
+export declare enum DecisionOutcome {
+    APPROVED = "APPROVED",
+    REJECTED = "REJECTED"
+}
+//# sourceMappingURL=decision.d.ts.map

package/dist/domain/decision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision.d.ts","sourceRoot":"","sources":["../../src/domain/decision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,QAAQ;IACvB;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IAEjC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAE5C;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAElC;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;;;;;;OASG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEhC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAEjC;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAEzC;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC;IAE3B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,kBAAkB,CAAC;CAC1C;AAED;;GAEG;AACH,oBAAY,eAAe;IACzB,QAAQ,aAAa;IAErB,QAAQ,aAAa;CACtB"}

package/dist/domain/decision.js

@@ -0,0 +1,9 @@
+/**
+ * Canonical Decision outcomes.
+ */
+export var DecisionOutcome;
+(function (DecisionOutcome) {
+    DecisionOutcome["APPROVED"] = "APPROVED";
+    DecisionOutcome["REJECTED"] = "REJECTED";
+})(DecisionOutcome || (DecisionOutcome = {}));
+//# sourceMappingURL=decision.js.map

package/dist/domain/decision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision.js","sourceRoot":"","sources":["../../src/domain/decision.ts"],"names":[],"mappings":"AA8FA;;GAEG;AACH,MAAM,CAAN,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,wCAAqB,CAAA;IAErB,wCAAqB,CAAA;AACvB,CAAC,EAJW,eAAe,KAAf,eAAe,QAI1B"}

package/dist/domain/evidence-anchor.d.ts

@@ -0,0 +1,54 @@
+import type { PolicyGovernanceAnchorStatus } from "./policy-reference.js";
+/**
+ * The binding artifact the 2026-09-15 evidence anchor audit's
+ * GAP-4 finding named as missing, closing its residual "Record 3 is
+ * outside all three [policy-governance] mechanisms" gap
+ * (docs/VERIFICATION-GAPS.md G-45's "Remaining, not attempted this
+ * session" note).
+ *
+ * Not a NEW cryptographic guarantee -- policyContentHash,
+ * governanceAnchor, and connector evidence were already bound together
+ * implicitly, since all three sit inside the same ExecutionTrustRecord
+ * that trustRecordHash/signature already cover in full. What this adds
+ * is a single, explicitly-named, independently-computed pointer an
+ * auditor can check WITHOUT already knowing to reach into
+ * transaction.policy and executions[].evidence.attributes.connector
+ * separately and reconstruct the binding themselves -- the exact
+ * "here's proof they're linked" artifact the originating gap audit
+ * asked whether one existed.
+ *
+ * Absent when there is nothing to anchor at all (no policyContentHash,
+ * no governanceAnchor, no connectorEvidenceHash -- should not occur for
+ * any real ExecutionTrustRecord, since G-24 always stamps
+ * policyContentHash, but the type stays honest rather than assuming).
+ */
+export interface EvidenceAnchor {
+    /**
+     * Copied from transaction.policy.contentHash (G-24). Present on
+     * every real ExecutionTrustRecord.
+     */
+    readonly policyContentHash?: string;
+    /**
+     * Copied from transaction.policy.governanceAnchor.status (G-45).
+     * Absent only when no PolicyGovernanceAnchorResolver was configured
+     * for this deployment -- not the same as NO_APPROVAL_RECORD, which
+     * is a real, present status meaning the resolver ran and found
+     * nothing.
+     */
+    readonly governanceAnchorStatus?: PolicyGovernanceAnchorStatus;
+    /**
+     * Copied from executions[0].evidence.attributes.connector.connectorEvidenceHash,
+     * when a real connector executed. Absent for a policy with no
+     * connector registered, or when Execution never reached the point of
+     * attaching connector evidence.
+     */
+    readonly connectorEvidenceHash?: string;
+    /**
+     * sha256 of the canonicalized {policyContentHash, governanceAnchorStatus,
+     * connectorEvidenceHash} above -- the explicit binding value. Computed
+     * with the same TrustRecordHasher every other artifact hash in this
+     * codebase uses.
+     */
+    readonly anchorHash: string;
+}
+//# sourceMappingURL=evidence-anchor.d.ts.map

package/dist/domain/evidence-anchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-anchor.d.ts","sourceRoot":"","sources":["../../src/domain/evidence-anchor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAEpC;;;;;;OAMG;IACH,QAAQ,CAAC,sBAAsB,CAAC,EAAE,4BAA4B,CAAC;IAE/D;;;;;OAKG;IACH,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAExC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B"}

package/dist/domain/evidence-anchor.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=evidence-anchor.js.map

package/dist/domain/evidence-anchor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence-anchor.js","sourceRoot":"","sources":["../../src/domain/evidence-anchor.ts"],"names":[],"mappings":""}

package/dist/domain/executable-content.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Executable Content.
+ *
+ * The exact content that crosses the execution boundary to an
+ * external Execution System: the action, target, and parameters
+ * approved for a specific Business Transaction.
+ *
+ * This is the content bound by
+ * ExecutionAuthorizationPayload.businessTransactionHash. Internal
+ * trust-chain fields (authority, policy, signals, metadata, status,
+ * createdAt) are intentionally out of scope: they never cross the
+ * execution boundary and are not part of what an execution system
+ * actually executes. Binding the hash to this narrower shape also
+ * avoids depending on BusinessTransaction fields that are not stable
+ * across the signing/verification boundary (for example, status may
+ * be defaulted after signing but before other artifacts are built).
+ */
+export interface ExecutableContent {
+    /**
+     * Business Transaction identifier.
+     */
+    readonly businessTransactionId: string;
+    /**
+     * Approved action.
+     */
+    readonly action: string;
+    /**
+     * Approved target.
+     */
+    readonly target: string;
+    /**
+     * Approved parameters.
+     */
+    readonly parameters: Readonly<Record<string, unknown>>;
+}
+/**
+ * Derives ExecutableContent from any source carrying the same
+ * four fields (a BusinessTransaction's id plus its intent, or an
+ * ExecutionRequest, etc.). The single point where the field list
+ * is enumerated, so every call site stays in lockstep with the
+ * ExecutableContent shape above instead of re-listing the fields
+ * itself.
+ */
+export declare function toExecutableContent(input: Pick<ExecutableContent, "businessTransactionId" | "action" | "target" | "parameters">): ExecutableContent;
+//# sourceMappingURL=executable-content.d.ts.map

package/dist/domain/executable-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executable-content.d.ts","sourceRoot":"","sources":["../../src/domain/executable-content.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IAEvC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACxD;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,IAAI,CACT,iBAAiB,EACjB,uBAAuB,GAAG,QAAQ,GAAG,QAAQ,GAAG,YAAY,CAC7D,GACA,iBAAiB,CAanB"}

package/dist/domain/executable-content.js

@@ -0,0 +1,39 @@
+/**
+ * Executable Content.
+ *
+ * The exact content that crosses the execution boundary to an
+ * external Execution System: the action, target, and parameters
+ * approved for a specific Business Transaction.
+ *
+ * This is the content bound by
+ * ExecutionAuthorizationPayload.businessTransactionHash. Internal
+ * trust-chain fields (authority, policy, signals, metadata, status,
+ * createdAt) are intentionally out of scope: they never cross the
+ * execution boundary and are not part of what an execution system
+ * actually executes. Binding the hash to this narrower shape also
+ * avoids depending on BusinessTransaction fields that are not stable
+ * across the signing/verification boundary (for example, status may
+ * be defaulted after signing but before other artifacts are built).
+ */
+/**
+ * Derives ExecutableContent from any source carrying the same
+ * four fields (a BusinessTransaction's id plus its intent, or an
+ * ExecutionRequest, etc.). The single point where the field list
+ * is enumerated, so every call site stays in lockstep with the
+ * ExecutableContent shape above instead of re-listing the fields
+ * itself.
+ */
+export function toExecutableContent(input) {
+    if (typeof input.target !== "string" || input.target.trim().length === 0) {
+        throw new Error("ExecutableContent.target must be a non-empty string.");
+    }
+    return Object.freeze({
+        businessTransactionId: input.businessTransactionId,
+        action: input.action,
+        target: input.target,
+        parameters: Object.freeze({
+            ...input.parameters,
+        }),
+    });
+}
+//# sourceMappingURL=executable-content.js.map

package/dist/domain/executable-content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executable-content.js","sourceRoot":"","sources":["../../src/domain/executable-content.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAwBH;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAGC;IAED,IAAI,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzE,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IAED,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,qBAAqB,EAAE,KAAK,CAAC,qBAAqB;QAClD,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC;YACxB,GAAG,KAAK,CAAC,UAAU;SACpB,CAAC;KACH,CAAC,CAAC;AACL,CAAC"}

package/dist/domain/execution-audit-event.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Execution-audit event.
+ *
+ * Defined in `@parmana/shared`, not `@parmana/execution-control` (where
+ * `ExecutionControlService` actually produces these), because
+ * `packages/storage`'s `SupabaseExecutionAuditSink` also needs this
+ * shape and `tests/architecture/execution-boundary.test.ts` enforces a
+ * closed dependent set for `@parmana/execution-control` imports
+ * (`execution-control`, `execution-gateway`, and `api` only) —
+ * `storage` is not on that list, deliberately, and importing this type
+ * through `@parmana/shared` instead (which every package may depend
+ * on) keeps that boundary intact rather than widening it.
+ * `@parmana/execution-control` re-exports this same type from its own
+ * `types.ts`, so every existing consumer there is unaffected.
+ */
+export interface ExecutionAuditEvent {
+    /**
+     * "authorization.verified" is never emitted by
+     * `ExecutionControlService` itself — Parmana's own envelope/gateway
+     * verification is already durably recorded via the
+     * `ExecutionGateway.verify()` call that must pass before
+     * `ExecutionControlService.execute()` is ever reached at all, so a
+     * separate "verified" event on this side would be redundant. It
+     * exists in this union solely so a reader of
+     * `SupabaseExecutionAuditSink.query()` has a fully-typed result for
+     * rows a different writer sharing this table records — see
+     * `parmana-paytm-agent`'s own audit writer (`src/parmana/audit.ts`
+     * in that repository), which records it right after independently
+     * verifying the Ed25519 authorization signature this service
+     * forwarded to it, before calling Paytm.
+     */
+    readonly type: "session.created" | "execution.rejected" | "execution.completed" | "authorization.verified";
+    readonly occurredAt: string;
+    readonly connectorId: string;
+    readonly authorizationId: string;
+    readonly sessionId: string;
+    readonly reason?: string;
+    /**
+     * The ExecutableContent.businessTransactionId this event concerns
+     * (GAP-3, GAPS.md 2026-09-14). Optional — recorded from
+     * release.executableContent.businessTransactionId by
+     * ExecutionControlService, but absent from events recorded by any
+     * other writer to this same durable store that has no
+     * ExecutionRelease to read it from. This is the one correlation key
+     * a remote, out-of-process connector service (e.g.
+     * parmana-paytm-agent) can actually supply on its own audit writes —
+     * unlike authorizationId, which is Parmana's own internal
+     * authorization identity and never forwarded across that trust
+     * boundary (see GatewayPaytmAdapter's own wire contract). Querying
+     * SupabaseExecutionAuditSink by businessTransactionId is therefore
+     * the way to retrieve one refund's complete story across both
+     * services, not authorizationId, which only chains events written
+     * on this side.
+     */
+    readonly businessTransactionId?: string;
+    /** Metadata only — never the credential's secret value. */
+    readonly credentialId?: string;
+    readonly gatewayId?: string;
+    /** ExecutableContent.action this event concerns — the capability granted or rejected. */
+    readonly action?: string;
+}
+export interface ExecutionAuditSink {
+    record(event: ExecutionAuditEvent): Promise<void>;
+}
+//# sourceMappingURL=execution-audit-event.d.ts.map

package/dist/domain/execution-audit-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-audit-event.d.ts","sourceRoot":"","sources":["../../src/domain/execution-audit-event.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,IAAI,EACT,iBAAiB,GACjB,oBAAoB,GACpB,qBAAqB,GACrB,wBAAwB,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAExC,2DAA2D;IAC3D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE5B,yFAAyF;IACzF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD"}

package/dist/domain/execution-audit-event.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=execution-audit-event.js.map

package/dist/domain/execution-audit-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-audit-event.js","sourceRoot":"","sources":["../../src/domain/execution-audit-event.ts"],"names":[],"mappings":""}

package/dist/domain/execution-authorization.d.ts

@@ -0,0 +1,224 @@
+import type { JsonValue } from "../types/Json.js";
+/**
+ * Execution Authorization
+ *
+ * Proof that Parmana authorized a specific
+ * execution request.
+ *
+ * Enterprise systems should execute only
+ * requests carrying a valid, verified
+ * SignedExecutionAuthorization.
+ *
+ * All timestamps are ISO-8601 UTC strings so the
+ * artifact serializes identically before signing
+ * (Parmana side) and after JSON transport
+ * (receiving side). Never use Date objects here.
+ */
+/**
+ * The signed payload.
+ *
+ * Every field participates in the signature.
+ */
+export interface ExecutionAuthorizationPayload {
+    /**
+     * Payload format version.
+     *
+     * Verifiers MUST reject any value other than 1
+     * (including a missing field) before attempting
+     * signature verification. There are no external
+     * consumers of the prior unversioned format, so
+     * this is a breaking change made once, not a
+     * migrated one — see docs/CLAIMS.md.
+     */
+    readonly version: 1;
+    /**
+     * Unique authorization identifier.
+     */
+    readonly authorizationId: string;
+    /**
+     * Single-use nonce.
+     *
+     * Receiving systems MUST reject an
+     * authorization whose nonce has been
+     * seen before.
+     */
+    readonly nonce: string;
+    /**
+     * Approved Decision.
+     */
+    readonly decisionId: string;
+    /**
+     * Outcome of the decision this authorization was issued for. Signed
+     * with the rest of the payload. ExecutionGateway releases only
+     * "APPROVED"; it refuses an authorization with any other value or
+     * with none, so a signature alone never releases an action.
+     */
+    readonly decisionOutcome?: "APPROVED";
+    /**
+     * Business Transaction.
+     */
+    readonly businessTransactionId: string;
+    /**
+     * Policy that produced the decision.
+     */
+    readonly policyName: string;
+    /**
+     * Policy version that produced the decision.
+     */
+    readonly policyVersion: string;
+    /**
+     * ISO-8601 UTC time the authorization
+     * was issued.
+     */
+    readonly authorizedAt: string;
+    /**
+     * ISO-8601 UTC expiry. REQUIRED.
+     *
+     * Receiving systems MUST reject an
+     * authorization past this time.
+     */
+    readonly expiresAt: string;
+    /**
+     * Canonical content hash of the ExecutableContent
+     * (businessTransactionId, action, target,
+     * parameters) approved for execution.
+     *
+     * Computed identically by the signing side (from
+     * the runtime's in-memory transaction) and the
+     * verifying side (from the JSON-parsed request) via
+     * the same ExecutableContentHasher, so a receiving
+     * gateway can recompute this hash from the exact
+     * content it is about to forward and reject any
+     * mismatch — closing the gap where a valid envelope
+     * could accompany a modified payload carrying the
+     * same businessTransactionId.
+     */
+    readonly businessTransactionHash: string;
+    /**
+     * Canonical content hash (G-24) of the exact Policy document that
+     * produced this authorization's Decision -- proves which policy
+     * *content*, not merely which version string, was in force. Policy
+     * governance (see PendingPolicyChange) permits in-place content
+     * edits to an existing version string, so a version-string
+     * comparison alone cannot detect every real policy change; a
+     * receiving gateway with access to the current policy content can
+     * recompute this hash and reject execution if the policy has
+     * changed since authorization.
+     *
+     * Optional so every pre-existing construction site and already-
+     * issued authorization (signed before this field existed) keeps
+     * compiling and verifying unchanged -- an absent value means "not
+     * covered by the policy-freshness check," not "policy is stale."
+     */
+    readonly policyContentHash?: string;
+    /**
+     * Canonical content hash of the runtime PolicySignals evaluated to
+     * produce this authorization's Decision -- proves what real-world
+     * conditions (vendor status, risk exposure, market state, etc.)
+     * justified the decision, distinct from businessTransactionHash
+     * (which covers only action/target/parameters) and policyContentHash
+     * (which covers only the policy rules). A receiving gateway with
+     * access to the exact signals this authorization was signed under,
+     * and a capability-scoped SignalStateVerifier, can recompute this
+     * hash and independently re-derive current signal state, rejecting
+     * execution if either has drifted since authorization.
+     *
+     * Optional so every pre-existing construction site and already-
+     * issued authorization (signed before this field existed) keeps
+     * compiling and verifying unchanged -- an absent value means "not
+     * covered by the signal-freshness check," not "signals are stale."
+     */
+    readonly signalsHash?: string;
+    /**
+     * The authenticated caller (the same identity already threaded into
+     * BusinessTransaction.metadata.submittedBy) that this authorization
+     * was issued for, when caller-auth was enabled for the request.
+     *
+     * Optional for the same reason policyContentHash/signalsHash are:
+     * every pre-existing construction site and already-issued
+     * authorization keeps compiling and verifying unchanged. Absent
+     * means "issued with caller-auth disabled or no caller identified,"
+     * not "no caller exists."
+     */
+    readonly submittedBy?: string;
+    /**
+     * The capability (Business Transaction intent.action) that
+     * isCapabilityAllowed() confirmed this caller was permitted to
+     * invoke, at the moment it confirmed it -- i.e. what the API-edge
+     * caller-to-capability check actually cleared, carried forward as a
+     * signed fact rather than discarded once the request passes.
+     *
+     * A receiving system with access to this authorization can confirm
+     * this equals the executed content's own action, catching any
+     * divergence between what a caller was cleared to invoke and what
+     * is actually presented for execution, without needing its own
+     * access to the live caller/capability configuration.
+     *
+     * Optional for the same reason submittedBy is: absent means "no
+     * caller-capability check ran for this authorization" (caller-auth
+     * disabled), not "any capability is granted."
+     */
+    readonly grantedCapability?: string;
+    /**
+     * The business facts this authorization rests on (RFC-0023 phase 4):
+     * each Trusted Signal the decision established, with the value its
+     * source gave and until when it holds. Present only when the policy
+     * sourced facts. Signed, so a gateway can refuse to release once any
+     * is past its validUntil, and an endpoint can execute only if each
+     * still holds in its own records.
+     */
+    readonly businessConditions?: readonly AuthorizationBusinessCondition[];
+    /**
+     * The authority grant this authorization rests on (RFC-0023 phase 3),
+     * when the policy required one. Signed, so a gateway can refuse to
+     * release once the grant has expired or been revoked.
+     */
+    readonly authorityGrant?: AuthorizationGrantBound;
+}
+/**
+ * One Trusted Signal, as the authorization carries it.
+ */
+export interface AuthorizationBusinessCondition {
+    readonly signalId: string;
+    readonly signalKey: string;
+    readonly source: string;
+    readonly claim: string;
+    readonly subject: string;
+    readonly value: JsonValue;
+    /** ISO-8601 UTC. After this, the fact may no longer hold. */
+    readonly validUntil: string;
+}
+/**
+ * The grant an authorization rests on, as the authorization carries it.
+ */
+export interface AuthorizationGrantBound {
+    readonly grantId: string;
+    /** ISO-8601 UTC. After this, the grant no longer holds. */
+    readonly validUntil: string;
+}
+/**
+ * The complete envelope crossing the
+ * execution boundary.
+ */
+export interface SignedExecutionAuthorization {
+    /**
+     * The signed payload.
+     */
+    readonly payload: ExecutionAuthorizationPayload;
+    /**
+     * Signature over the canonical
+     * serialization of the payload.
+     */
+    readonly signature: string;
+    /**
+     * Identifier of the signing key, so the
+     * verifier can select the correct
+     * public key.
+     */
+    readonly keyId: string;
+    /**
+     * Signature algorithm identifier.
+     */
+    readonly algorithm: string;
+}
+//# sourceMappingURL=execution-authorization.d.ts.map

package/dist/domain/execution-authorization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-authorization.d.ts","sourceRoot":"","sources":["../../src/domain/execution-authorization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;;;;;;;;;;;;GAcG;AAEH;;;;GAIG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;;;;;;;OASG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IAEpB;;OAEG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IAEjC;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,UAAU,CAAC;IAEtC;;OAEG;IACH,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IAEvC;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IAEzC;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAEpC;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAE9B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAE9B;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAEpC;;;;;;;OAOG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,8BAA8B,EAAE,CAAC;IAExE;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,uBAAuB,CAAC;CACnD;AAED;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,6DAA6D;IAC7D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,2DAA2D;IAC3D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,6BAA6B,CAAC;IAEhD;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B"}

package/dist/domain/execution-authorization.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=execution-authorization.js.map

package/dist/domain/execution-authorization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-authorization.js","sourceRoot":"","sources":["../../src/domain/execution-authorization.ts"],"names":[],"mappings":""}

package/dist/domain/execution-evidence.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Canonical execution evidence.
+ *
+ * Evidence returned by the enterprise execution
+ * system after executing a Parmana-approved
+ * BusinessTransaction.
+ */
+export interface ExecutionEvidence {
+    /**
+     * BusinessTransaction this evidence belongs to.
+     */
+    readonly businessTransactionId: string;
+    /**
+     * Action actually executed.
+     */
+    readonly action: string;
+    /**
+     * Target actually executed.
+     */
+    readonly target: string;
+    /**
+     * Parameters actually used.
+     */
+    readonly parameters: Readonly<Record<string, unknown>>;
+    /**
+     * Whether execution succeeded.
+     */
+    readonly success: boolean;
+    /**
+     * UTC execution timestamp.
+     */
+    readonly executedAt: Date;
+    /**
+     * Optional execution-system-specific evidence.
+     */
+    readonly attributes?: Readonly<Record<string, unknown>>;
+}
+//# sourceMappingURL=execution-evidence.d.ts.map

package/dist/domain/execution-evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-evidence.d.ts","sourceRoot":"","sources":["../../src/domain/execution-evidence.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IAEvC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAEvD;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC;IAE1B;;OAEG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACzD"}

package/dist/domain/execution-evidence.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=execution-evidence.js.map

package/dist/domain/execution-evidence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-evidence.js","sourceRoot":"","sources":["../../src/domain/execution-evidence.ts"],"names":[],"mappings":""}