@parmanasystems/execution

Deterministic execution infrastructure for replay-safe governance evaluation, admissibility enforcement, runtime provenance continuity, and independently verifiable governed execution.

Overview

@parmanasystems/execution provides the deterministic execution layer for Parmana Systems.

The execution package is responsible for:

• deterministic policy evaluation
• replay-safe execution continuity
• admissibility enforcement
• execution attestation generation
• runtime provenance continuity
• deterministic execution fingerprints
• independently verifiable execution evidence
• fail-closed governance execution semantics

Execution exists to ensure governed decisions are:

• reproducible
• cryptographically accountable
• independently verifiable
• operationally defensible
• replay-safe
• deterministically reconstructable

Core Principle

Execution evaluates deterministic governed signals against immutable policy lineage.

AI systems may recommend actions.

Execution determines whether governed execution is admissible.

Execution outcomes must remain:

• deterministic
• reproducible
• replay-safe
• independently verifiable
• cryptographically attributable

What This Package Does

@parmanasystems/execution:

• evaluates deterministic governance policy
• enforces replay-safe execution semantics
• validates admissibility continuity
• generates execution fingerprints
• generates runtime provenance
• issues execution attestations
• validates deterministic compatibility continuity
• preserves immutable execution lineage
• enforces fail-closed execution behavior

What This Package Does NOT Do

@parmanasystems/execution does not:

• perform AI inference
• determine business truth
• probabilistically orchestrate execution
• mutate immutable execution lineage
• silently recover from invalid trust states
• bypass replay continuity
• override deterministic governance semantics
• permit partial admissibility validation

Installation

npm install @parmanasystems/execution

Quickstart

Evaluate Deterministic Governance Policy

import {
  evaluatePolicy
} from "@parmanasystems/execution";

const result =
  await evaluatePolicy(

    {
      policyId:
        "claims-approval",

      policyVersion:
        "1.0.0",

      signals: {

        claim_amount:
          1200,

        vip_customer:
          false
      }
    },

    "./policies"
  );

console.log(
  result
);

Example Execution Result

{
  "decision": "approved",
  "execution_id": "exec_01",
  "execution_fingerprint": "sha256:...",
  "provenance": {
    "runtimeHash": "sha256:...",
    "policyHash": "sha256:..."
  }
}

Deterministic Guarantees

@parmanasystems/execution enforces:

• deterministic evaluation semantics
• replay-safe execution continuity
• immutable execution lineage
• canonical execution hashing
• deterministic provenance continuity
• deterministic attestation continuity
• fail-closed admissibility enforcement
• independently verifiable execution evidence

Identical governed signals evaluated against identical policy lineage produce identical deterministic outcomes.

Governed Signals

Execution evaluates deterministic governed signals only.

Example:

{
  "claim_amount": 1200,
  "vip_customer": false
}

Signals are:

• deterministic
• reproducible
• independently verifiable
• replay-safe

Metadata is intentionally excluded from execution logic.

This preserves:

• deterministic replay
• reproducible admissibility
• portable verification continuity
• immutable execution semantics

Admissibility Semantics

Execution determines whether governed execution is admissible under deterministic policy.

Possible outcomes may include:

• approved
• rejected
• escalated
• pending_override

Admissibility depends on:

• immutable policy lineage
• governed signals
• replay continuity
• runtime compatibility
• deterministic evaluation continuity

Replay-Safe Execution

Execution identities represent immutable single-use governance events.

The execution layer validates:

• execution uniqueness
• replay continuity
• immutable execution lineage
• deterministic replay rejection

Replay attempts are rejected.

Example:

✖ replay invariant violation
✖ execution identity already consumed

Retries require new execution identities.

Execution Fingerprints

The execution layer generates deterministic execution fingerprints using:

• canonical execution payloads
• immutable lineage continuity
• deterministic hashing semantics
• reproducible provenance continuity

Execution fingerprints support:

• replay continuity
• provenance continuity
• independent verification
• audit reconstruction

Runtime Provenance

Execution generates deterministic provenance including:

• runtime lineage
• policy lineage
• execution continuity
• compatibility metadata
• runtime hashes
• canonical execution hashes

This enables:

• external verification
• reproducible reconstruction
• incident investigation
• portable governance continuity

Execution Attestations

Execution may issue cryptographic attestations containing:

• execution identity
• admissibility outcomes
• runtime provenance
• execution fingerprints
• policy lineage
• deterministic continuity evidence

Attestations are independently verifiable.

Fail-Closed Execution Semantics

The execution layer intentionally rejects:

• replay violations
• incompatible runtime lineage
• invalid provenance
• incompatible policy lineage
• invalid trust continuity
• malformed governed signals
• compatibility failures
• deterministic continuity divergence

Example failures:

✖ deterministic evaluation failed
✖ governance execution rejected

Silent fallback behavior is intentionally forbidden.

Compatibility Model

The execution layer validates compatibility across:

• runtime versions
• schema versions
• policy lineage
• provenance continuity
• release continuity
• execution continuity

Incompatible lineage is rejected.

Architecture Boundaries

@parmanasystems/execution:

• evaluates deterministic governance policy
• enforces admissibility continuity
• generates provenance
• preserves replay continuity
• issues execution evidence

The execution layer does not:

• perform AI inference
• determine factual correctness
• replace governance lineage validation
• probabilistically orchestrate execution

Execution preserves deterministic admissibility semantics.

Security Model

@parmanasystems/execution uses:

• canonical execution hashing
• replay-safe execution continuity
• deterministic provenance generation
• immutable execution lineage
• fail-closed validation
• independently verifiable attestations

Security continuity depends on:

• deterministic governed signals
• immutable policy lineage
• replay-safe execution continuity
• canonical payload continuity

External Verification

Execution evidence is designed for:

• external verification
• clean-room validation
• portable provenance continuity
• reproducible governance reconstruction
• regulator-side auditability
• independently verifiable admissibility

Verification does not require:

• repository access
• mutable runtime assumptions
• monorepo coupling
• hidden execution state

Portable Verification

Execution evidence supports:

• replay continuity validation
• provenance inspection
• attestation verification
• admissibility reconstruction
• runtime continuity validation

Execution continuity is reproducible across environments.

Example Use Cases

Financial Governance

Deterministically evaluate admissibility for regulated financial execution.

Enterprise AI Governance

Enforce deterministic execution boundaries around AI-recommended actions.

Healthcare Governance

Apply replay-safe deterministic execution semantics to regulated healthcare workflows.

Compliance Automation

Generate independently verifiable execution evidence for compliance systems.

Non-Goals

Parmana execution does not:

• replace AI systems
• determine business correctness
• probabilistically orchestrate execution
• mutate immutable execution lineage
• bypass deterministic governance continuity

License

Apache-2.0