Release notes

The stig-robot example is available with a generated HTML demo and an editable model of an indoor delivery robot, tracing requirements and failures down to a ROS 2 collision guard node. It uses the published STIG plugin with source-code analysis disabled; its README records the assumptions and open safety findings.

Documentation, API references, report help links, and IDEA release notes use https://docs.stigway.com/. The documentation layout expands on wide displays and supports resizing its navigation sidebar.

Native data-flow analysis keeps dependencies on separate object fields distinct when member pointers pass through helper functions, while preserving dependencies through overlapping fields.

Pointer-returning functions no longer inherit false dependencies from stores that precede their calls. Dependencies returned by the functions, including through loops and repeated calls, remain supported.

Native data-flow analysis excludes false dependencies on callback captures before their pointer bindings or external publication, including in large functions. Possible dependencies through loops and repeated calls remain supported.

Native data-flow analysis preserves stored dependencies observed through later reloads of initialized pointers and through LLVM pointer-forwarding intrinsics. Captured dependencies remain observable after a callback object is published or returned by a function.

GitLab consumer release updates accept projects using local STIG source, switch them to the published release, and retain the updated shared version catalogs in root and included builds.

Generated repository links and build provenance remove authentication credentials from HTTP and HTTPS Git remote URLs. Regenerate existing reports to remove credentials embedded in earlier output.

HTML report navigation supports domain-specific element group names through generateHtml.navigationGroupNames, while preserving element types, icons, and page URLs.

IDEA model loading shows progress and elapsed time, with cancellation, retry, and diagnostics for incomplete declarations and plugin failures.

Consumer updates install STIG's shared version catalog as stigLibs in the root and consumer-owned included builds, so plugins and libraries can use the selected STIG release's dependency pins.

On Linux, maxAllowedRamAndSwapMiB now specifies an allowance per solver worker instead of a per-process ceiling. The default remains 16,000 MiB; each analyzer process receives a ceiling of its granted workers times that allowance. Concurrent activities reserve available RAM within one Gradle invocation, leaving 5% physical RAM headroom and excluding swap from admission. Review existing values before upgrading; null disables memory admission and the ceiling, and non-Linux hosts retain CPU-only admission. An allowance exceeding physical RAM after host headroom fails before launch and must be lowered.

Plain stigUpdate selects the latest stable release, including major upgrades, and switches local consumers to stigSource=published. Use stigUpdate --keep-devel (alias --devel) to retain local source, record the actual checkout version, and synchronize its pins.

IDEA model properties share the reports' attribute labels, colors, and icons, and nested elements show their containment depth. Reopening an unchanged model reuses its checked snapshot; editing project notes preserves the loaded model.

HTML reports and exported Markdown/MkDocs use consistent attribute badges for ASIL, severity, multiplicity, evaluation, and boolean values.

Dokka's isolated worker receives the STIG engine classes required for HTML generation. ASIL palette JavaScript generation also tracks the palette's current source location, and icon validation accepts source formatting without accepting changed artwork.

Boolean report attributes retain accessible labels for their true and false values.

Consumer updates preserve the selected source and version across the bootstrap handover and complete dependency maintenance with a fresh strict-verification pass without repeating that completed pass.

IDEA Java settings use a portable, versioned STIG SDK reference, align the primary project SDK with the Gradle JVM, and update the registered SDK location when the Gradle cache moves.

IDEA model loading handles literal descriptions using Kotlin trimMargin(), including explicit margin prefixes.

LLVM transfer models can initialize selected scalar fields of active fixed-array elements with constant(...) and counted eachElement(...) destinations. Zero or excessive counts perform no writes; unselected fields and inactive elements are preserved.

Native function models add copyMemoryAndAdvance, bindPointerIfNull, returnPointerOrStoredGlobal, and returnAtomicStoredPointerGlobal for fixed byte copies, conditional pointer binding, and stored-pointer returns. Copies support 1, 2, 4, or 8 bytes and retain the caller's validity and capacity preconditions.

The STIG IDEA plugin automatically provisions and selects the project's approved Gradle JVM for imports and task runs, including after Java pin updates. It honours the configured Gradle user home and offline settings.

Model checks and report preparation reuse source inventories and model indexes and check modules in parallel while preserving result order. The default worker budget is the logical CPU count minus one, with a minimum of one; --max-workers can lower it.

Appended native model and stub sources require an unambiguous recorded compilation context. Harnesses infer it from the activity and transforms from originalCompileUnit; other appended sources must set appendCompileContextUnits, plus appendCompileContextActionKeys when the selected unit has multiple actions.

Single-argument IssueReferenceTemplate calls are no longer deprecated and cover all rules on the declaring object. Supply rule classes when a ticket covers only selected rules.

Root stigCheckModel runs one complete model check without also selecting individual module checks. Diagnostic source links resolve the declaration for distinct model instances.

Native data-flow analysis preserves field separation across sequential stored-pointer advances and excludes aliases established only by later stores or captures, while retaining possible flows through loops and recursion.

Atomic pointer stores lowered to pointer-width integers preserve dependencies on pointed-to data. Scalar sink matching keeps pointer-address and pointed-to-data dependencies separate.

Configured arithmetic, comparison, selection, and unary operations preserve operand-to-result data flows and sanitizer ordering.

Direct native APIs support ProvidedMethod and RequiredMethod without synthetic service interfaces or ports. Required methods can reference an existing definition while retaining their own identity and required role.

Direct native method declarations preserve source API capitalization and underscores in imports and model checks.

C header imports exclude explicitly private and internal headers from component Context.

IDEA model inspections resolve Kotlin type aliases to their underlying model classes.

Analysis exports keep interface-point analyses in their corresponding interface groups and link empty groups to the complete Context definition.

Model-check source links retain the containing repository's directory prefix when a project is nested below its Git root, including subrepository layouts.

Multiple-point failures with severity explicitly below S10 no longer require independent-failure references, regardless of ASIL. Missing severity retains the reference requirement.

Diagram appendices reuse validated analyzer results across logical sinks and read exact sink headings from endpoint metadata, avoiding repeated processing of large reports. Generation failures retain their underlying error instead of appearing as missing sink metadata.

IDEA Design editing supports constructor metadata on a same-file, parameterless class with one owned instance. Shared, inherited, cross-file, and parameterized declarations remain read-only when ownership is ambiguous.

Kotlin integrations use the com.stigway package root. Update model imports and recompile consumers together with the selected STIG release.

IDEA quick fixes edit only the affected arguments or references, preserve surrounding comments, and reject stale previews or edits that would shift positional arguments.

Consumer updates preserve finalized Java vendor filters that accept the approved distribution while continuing to enforce the exact verified JDK installation.

Dependency updates support artifact-only libraries without source or Javadoc variants while continuing to verify every advertised attachment and reject missing files or checksum mismatches.

Consumer updates install compatible wrapper launchers before adopting a new updater runtime, allowing existing projects to complete the authenticated toolchain handover.

IntelliJ IDEA now offers Code, Design, and Split views for supported Kotlin model files. The native Design view shows model hierarchy, properties, incoming and outgoing relationships, live findings, and source navigation.

Edit supported scalar properties and ordered relationships in Design with normal IDE undo/redo. Changes update the Kotlin source directly; computed, inherited, or shared declarations remain read-only where safe ownership cannot be established.

Create and preview a Failure inside a directly owned InterfacePointAnalysis, delete an unreferenced leaf failure, and preview supported reference renames. Source changes invalidate pending previews, and deletion checks both model relationships and Kotlin usages before allowing the operation.

STIG builds, compilation, and tests use an exact Java 25 distribution verified against platform-specific SHA-256 pins. Any working Java 21 or newer can launch the bootstrap; stigUpdate aligns consumer Java and build-tool pins with the selected STIG release. IDEA imports must use the approved Gradle JVM printed by the wrapper.

stigUpdate and the source maintainer's scripts/update.sh default to stable major updates. Normal updates also repair missing dependency and IDE source/Javadoc checksums and run fresh strict verification. Ordinary applications can use the STIG maintenance profile to share its toolchain while retaining their own dependency catalogs.

Model identities distinguish separate instances of shared or inherited declarations, preserving their ownership and relationships in the IDEA editor and exported model.

Dokka generation avoids repeatedly scanning every declaration when attaching imported-interface model pages. Module generation uses the shared CPU budget while preserving standalone and aggregate report behavior.

Authored report boxes support cascading_output, cascading_failure, root_cause_group, root_cause, independent_function_group, and coupling_factor, with shared colors and icons in Dokka and MkDocs.

Root :stigGenerateHtml and :stigPublishHtml prepare the selected compiled model once for model checks, generated Markdown, and Dokka model pages. Dokka continues processing each module's Kotlin documentation separately.

Standalone module previews load only the selected module and its required model context; transitive dependencies may still compile. Incoming references from unrelated modules require the aggregate report.

Linked standalone Markdown documents appear beneath their enclosing CREATE viewpoint in Dokka navigation. Labels use the source filename with its first letter lowercased, while document URLs remain unchanged.

Dokka links to anchors inside collapsed authored report boxes reveal the enclosing boxes.

Model hover previews align headings, ASIL badges, and source actions consistently with model pages.

Dokka and MkDocs can group interface-point analyses with analysisInterfaceGrouping = InterfaceGrouping.PROVIDED_REQUIRED. Four ordered groups distinguish provided data, provided methods, required data, and required methods, with matching icons and interface-point colors. Empty groups remain visible; existing model anchors are preserved, and unresolved or mixed interfaces remain ungrouped. Grouping is disabled by default.

Filed issues have a standalone external-issues.html page with searchable categorical filters. Both issue tables support shareable filtered links, clearing all filters, and restoring the incoming link's selections.

Dokka landing pages show issue summaries and prominent buttons to the complete tables. Issue headings omit counts, tables fill the available width with resizable columns, and footers link to STIG documentation.

Dokka Expand/Collapse controls work without triggering source-set tab selection, including on grouped model pages.

Authored Markdown reports can place generated model content and child-analysis indexes with <!-- STIG: model --> and <!-- STIG: child analyses -->. Dokka and MkDocs share .stig-box callouts; assessment indexes group analyses by module and show their classification and Analysis.argument.

Model-check findings support searchable multiple selections, * wildcard patterns, and module filters that include descendants. Matching counts reflect the other active filters, and reset restores the original link's selections. ASIL badges retain decomposition notation; regenerate older evidence and reports to populate them.

MkDocs exports write stig-publishing.json from the publishing block's currentPath and versionsSubdir settings. Defaults place the current publication at the site root and named releases under versions/<tag>/.

LLVM transfer models support fixed array indices and parameter-selected element() reads. Dynamic selectors are source-only and require an in-range caller-supplied index. globalAddress() pointer returns preserve the identity of an existing, non-thread-local global object in the default address space.

Linked Markdown reports, including separate data-flow analysis documents and standalone reports, publish independently in Dokka and MkDocs. MkDocs navigation preserves fragment and query links without treating them as duplicate source-page declarations.

Constructor transfer models can initialize their own const fields and recover compiler signatures through constructor aliases. Aggregate-return validation also covers array members.

Generated non-throwing LLVM models remove impossible exception paths while preserving the exception behavior of supplied C/C++ implementations and asynchronous exception handling.

Native taint analysis preserves stored-pointer relationships through initializer calls and recognizes recurring pointer stores with variable array indices and loop-carried pointers.

Model tables of contents can use declaration identifiers or readable names through modelTocLabels, for both Dokka HTML and MkDocs exports. Changing this setting preserves link targets.

MkDocs Analysis exports can include a Child analyses table linking the nearest exported, enabled child analyses. Set includeChildAnalyses = true in the MkDocs export configuration; the default is false.

Interface-point analyses derive their display names from the analyzed point's name followed by analysis. Model reports include computed common attributes, and MkDocs exports share Dokka's semantic color palette.

Interface points expose effectiveAsil, resolving an omitted classification through referenced definitions, enclosing interface points, and the owning element. Checks, report badges, and diagrams use this value while preserving the authored asil. Nested points and port-member uses are checked against their enclosing interface and referenced member, including required uses; review newly reported classification mismatches.

Analyzer execution now defaults to automatic concurrency: maxParallelAnalyzerExecutions = 0 and solverWorkers = 0 share a budget of available logical CPUs minus one, with a minimum of one. Independent IDE-XTaint source solves can run in parallel; other solvers retain one worker. Separate Gradle builds do not share this budget. Set both properties to 1 to retain serial execution on memory-constrained hosts.

Large interactive data-flow diagrams share repeated source-provenance metadata and write JSON directly to files, reducing export memory use while retaining source and sink links.

The Port.use(..., asil = ...) overload is deprecated. Declare the classification on the referenced member or its enclosing interface and use use(member) to inherit it. Existing explicit overrides remain available and are checked against the referenced member's effective classification.

Release tagging keeps the prepared version and validated commit when later changes reach main during CI.

Native taint analysis preserves data flow through atomic operations, byte-range fills, caller-owned storage, and retained callback output pointers. Virtual dispatch can resolve local lambda wrappers whose debug and ABI type names differ.

Native implementation selection resolves recorded compiler inputs consistently, and protected analysis models inline supported vector accessors so their implementation remains visible to analysis.

Analysis statistics wait for requested evidence-producing tasks before reading their results. Native timing reports distinguish call-graph setup from sink-reachability work.

MkDocs and HTML model reports render data types with stable, readable names instead of JVM identity hashes.

Model-rule references show human-readable names, possible finding severities, and the Kotlin check implementation. Manual-review checklists list selected semantic rules and explain when a rule is not applicable.

Model-check summaries link total and severity counts directly to filtered findings. Missing child contributions carry a ? Contributor unknown explanation when the responsible child cannot be identified.

Breaking change: model issues now contains IssueReference values. Replace ticket URLReferenceTemplate declarations with IssueReferenceTemplate and direct url(...) calls with issue(...); sources still uses URLReference. Ticket references can name the rule classes they cover, and JSON/Kotlin exchange and IDEA inspections preserve those selections. Single-argument issue-template calls are deprecated; specify the covered rules.

Filed issues cover findings only on the exact object declaring the ticket and for its selected rules, or all rules when no list is specified. Enclosing containers and owning elements no longer supply inherited ticket coverage. Ambiguous model IDs are reported without assigning a model link or ticket coverage to an arbitrary object.

Provided interface points are checked against allocatedAsil when declared, otherwise asil. Required services, called methods, and subscribed data may have higher or lower ASIL than their consuming element; shared definitions are checked at the local provided port or member use.

Disabled Analyses may retain interface-point analyses. Incoming-contribution checks distinguish missing child coverage from prohibited links at bottom level, and missing local interface analysis is reported on the responsible Analysis when it can be identified.

Every explicit requirement allocation requires a corresponding derivedFrom link, including allocations that independently violate hierarchy rules. Coverage is collective across the allocated element's specifications and nested sections; missing coverage is reported on its top-level specifications or on the element when none exists.

stigUpdate and stigCheckModel no longer require a configured MkDocs destination checkout. The configuration file is read when stigExportModel runs, which still fails if the file is missing.

HTML module overviews use authored introductions. Model reports retain consistent forward and reverse relation labels and show the declared names of interface-point analyses in findings.

Configuration checks and analysis-configuration evidence reflect current file availability on every invocation. Changes to authored root introductions invalidate their affected cached Markdown output.

Failures can record diagnosticCoverage as an optional fraction from 0.0f to 1.0f. Construction rejects non-finite or out-of-range values; the value is retained in model exports and remains separate from evaluation.

Model-check reports count findings without a filed issue and link directly to those findings. Issue links on the subject, enclosing model containers, or owning element supply the tracking context without reducing finding severity.

HTML reports provide a resizable page-contents panel with a saved width and full-label tooltips. Following model links briefly highlights the destination after deferred content loads, respecting reduced-motion preferences. When a matching reverse link is available, a temporary “Back to previous item” cue identifies the originating item.

Every failure now requires evaluation = FailureEvaluation.SUFFICIENT or FailureEvaluation.RESIDUAL and a nonblank engineering argument. Missing evaluations and GAP produce HIGH findings, including for QM failures and failures with linked issues; update existing models with supported conclusions and evidence.

Failure mitigation checks now require a safety measure or valid independent failure unless the failure is explicitly QM with severity below S10. Missing ASIL or severity no longer exempts a failure from this check.

Model reports give each relation direction a distinct name, including allocated to/allocating requirements and derived from/derives to. Shared Kotlin property names have qualified labels such as design element and analysis element; existing metamodel properties and user models remain unchanged.

The IDEA plugin inherits platform interface defaults directly, removing deprecated tool-window API calls from its compiled plugin classes.

Incoming uses references appear on the referenced Context interface point and each analysis of that point, including when the referring module is only connected in the incoming direction. Compact library definitions retain incoming references, and HTML and Markdown use the same relation labels.

Page-contents branches can expand deferred model content.

Interface-point analyses can record belongsToSafetyFunction = false with an argument and evaluation to justify excluding an interface from detailed functional failure analysis. This exempts the usedIn and S10 completeness checks without changing ASIL; nested analyses retain their own scope decisions and authored failures still undergo consistency checks.

HTML reports provide project-wide rule summaries, filtered findings downloads, and page sizes from 20 to 1,000 rows. Set stigProject.generateHtml.enableProjectWideFindings = false to omit the project-wide findings and rule summaries.

IDEA inspection failures provide a resizable diagnostics window with copyable version, import, class-loading, and exception details. Unexpected plugin failures also appear in IDEA's error indicator with a diagnostic attachment.

Forbidden-word checks cover model string attributes, collections, and nested metadata across all viewpoints. Context, Design, and Analysis only flag explicit unfinished-work markers (TBD, TBC, TODO, and FIXME), allowing qualitative failure descriptions and assessment arguments. Requirements and Tests retain the stricter precision checks. KDoc and source comments remain outside these checks.

HTML reports publish compressed findings tables with short corrections, share repeated image and model metadata, and retain complete diagnostic exports on the build machine. Findings downloads contain the filtered display rows; use the local paths printed by report generation for complete diagnostic records and repair guidance.

Descriptions are optional on Design, Analysis, and Tests containers. Their contained entities retain their description requirements.

Context report navigation keeps inline service contracts beneath their owning ports, so their implementation classes no longer appear beside the model entry point. Markdown exports use the same nested ownership hierarchy.

Standalone HTML previews retain Kotlin-reference labels in linked Markdown from other modules without attempting to resolve those symbols in the preview module. Aggregated reports retain links to the owning declarations.

Markdown model exports use heading level 1 for root objects, level 2 for their model fields, and successively deeper headings for nested fields, while retaining the nested admonition boxes. Authored companion headings no longer determine the apparent level of the generated Analysis and failure hierarchy.

Required/subscribed data no longer needs usedIn links or S10 failures solely to satisfy analysis completeness. Required and provided methods both require analysis coverage, and selected interface members inherit their port's direction. QM interface points are exempt from both completeness checks.

Findings links filter exact rule and viewpoint identifiers, and displayed counts reflect all matching rows across pages. Rule summaries distinguish unselected, unrun, and incomplete checks from passed checks.

Project and viewpoint check summaries place a visible View findings in table (N) button beside the priority totals, above the rule table. Project summaries use normal paragraph and table-cell layout, removing unwanted line breaks and separators inside cells.

Repository gitOwnership = CHECKOUT resolves provenance and source links through the owning Git checkout for monorepo folders, git subrepos, submodules, and standalone projects. SUBREPO_UPSTREAM explicitly selects git-subrepo upstream metadata when that provenance is wanted.

User documentation on functional safety, cybersecurity, SOTIF, and AI safety standards, current feature coverage, and planned tool qualification.

Interactive CI generates consumer HTML with the current local STIG checkout. Release automation keeps the public template and robot example in published mode.

stigInstallSkill provisions a pinned, verified native Codex CLI through Gradle, including for IDE-only users. It shares the selected Codex home, supports device login and automation, and checks a 1+1 model response by default; installation-only and offline modes explicitly skip model verification. Optional Graphify setup reuses the same provisioner, and dependency updates maintain the native Codex pins without rewriting Maven checksums.

Re-importing a model after compilation preserves normalized analysis class names instead of renaming them again.

Interface-point analysis coverage excludes required-port and subscriber-only usages; the providing or publishing element owns the signal's failure analysis.

Maven publications include names and descriptions for the execution, LLVM, and settings modules; publication verification rejects missing POM metadata before upload, and Maven dependencies are published before Gradle plugins.

Independent CI publication checking and release recovery diagnose and repair uploads without repeating a previously validated full release pipeline.

Dependency maintenance discovers all modules and includes multiplatform source attachments and convention-build settings plugins.

Signing-key refresh retries failed downloads and cached missing signatures, rejects incomplete refreshes, and supports scripts/update.sh --verification without changing dependency versions or running the full build.

IDEA plugin signing reads its private key from a restricted temporary file instead of exposing it in Gradle command logs.

Release task dependencies select only publication tasks, allowing signing and uploads without a local PhASAR checkout.

Parallel analyzer tasks no longer resolve unused evidence-collection options during execution.

Publication signing and uploads no longer require an unrelated local PhASAR checkout.

ASIL supports decomposition notation such as ASIL.B_D and preserves the original classification in originalValue. Elements can declare allocatedAsil; model checks compare it with their requirements and interfaces.

Interface-point analyses can contain analyses of their member endpoints, mirroring Context containment.

model.imports.cHeader imports public C header function declarations into Context. Per-field import policies can preserve authored descriptions and ASIL values.

Markdown export can update an existing MkDocs site's selected model pages and navigation while preserving authored introductions, manual pages, and unrelated configuration. Optional strict link checking reports unresolved model relations in build/stig/model-export/markdown-links.json; reverse relations can be disabled for downstream generators.

Element and interface-point analyses support argument and evaluation for explicit QM assessments. Omitting detailed QM analysis requires both; non-QM interfaces retain their analysis-coverage obligations.

Models can attach separate issue and source links using reusable URL templates. HTML landing pages show referenced issues inline by default; stigGenerateHtml.inlineIssues = false opens the full table separately.

stigCollectAnalysisStatistics summarizes retained analysis measurements without launching native analysis.

stigUpdate can update a consumer's published STIG version and maintain dependency checksums, with saved progress and strict verification. Local model-only builds no longer require a PhASAR sibling checkout.

Breaking change: ASIL is a class instead of an enum. Replace enum-specific calls and ordinal comparisons with parseAsil, value, or index; entries now includes decomposed classifications. Equality and ordering compare value only, so inspect originalValue separately when decomposition matters. Recompile model consumers.

Breaking change: replace Failure.safetyMeasures with mitigatedBy. Analysis and Design constructors no longer accept asil, and work-product containers reject direct ASIL access; read the classified element or interface.

Breaking change: replace IssueRepo/Issue with URLReferenceTemplate/URLReference. Declare a template containing {id} and create references with template(number), or use url(uri, label). Both issues and sources store URL references; regenerate older exchange files. Issue descriptions and statuses are retrieved by the viewer.

Breaking change: migrate function transform rules to implementation, nop, noreturn, and transfer, with an explicit mode = ADD for missing definitions or mode = REWRITE for existing definitions. implementation accepts either source or nativeCompileUnit; review the current generated DSL contract when updating registry rules.

Classification checks report a contributor above its bound as HIGH and a bound above all contributors as INFO. Set modelCheck.reportClassificationDifferences = false to disable the INFO advisories. S10 failures require a mitigation or a valid independent failure on a separate element hierarchy branch.

Model checks now require viewpoint classes at file scope, concrete-class instance properties in the same file, PascalCase class names, and camelCase instance names. Interface-point analysis names follow their interface and end in Analysis. Kotlin import emits flat classes; moving or renaming existing classes changes their members' IDs.

Native compilation and analysis reuse completed work according to their recorded inputs, with separate execution engines for the LLVM stages. Data-flow evidence shares canonical flow facts to reduce repeated storage and work.

Markdown exports preserve model containment, declaration types, attributes, and links to shared or inline interface declarations. Shared declarations with identical source filenames in different packages retain separate pages.

stigUpdate resolves dependency sources and checksums across recursively included builds, including tooling builds and Kotlin multiplatform dependencies, so IDEA source downloads use the consumer's verification policy.

Model loading handles repeated identical classes across inputs while rejecting conflicting definitions, and model checks retain nested interface-point analyses and their ownership.

Markdown exports retain Context interface anchors and cross-viewpoint links, and model-library navigation groups multiple packages without listing ticket registries that have no model content.

HTML navigation links to the aggregate landing page correctly, including publications without model modules. Navigation icons load from the site root without failed requests relative to nested pages.

Model-only elements no longer start partial-result collection when source analysis has not been initialized.

Transfer models support C++ reference members, counted-array element dependencies, and corresponding fixed-array elements using compiler-recorded layouts. Unsupported layouts fail explicitly.

Analysis.enabled = false lets child analyses link across one absent or disabled parent Analysis to an enabled grandparent Analysis. Disabled analyses must contain no InterfacePointAnalysis declarations; Context interfaces and the other viewpoints are unchanged. See bypassing one Analysis level.

The IDEA STIG Reviews tool window shares GitHub-backed findings and discussions with published reports. Authors can map local source checkouts, navigate to reviewed declarations, reply, and change issue status; credentials stay in IDEA PasswordSafe. Closing a discussion does not change an automated check result.

stigAnalysisP6RunAnalyzer --start-with=transformed runs a captured P5 checkpoint or exact P6 slices without rebuilding the local P1–P5 inputs. Select an evidence ZIP or directory with --from, a separate diagnostic destination with --output-directory, and optionally an existing binary with --analyzer-executable; see running from transformed inputs.

Native analyzer runs now print phase timings and periodic CPU and memory diagnostics, and save the same records beside each analysis JSON in a .monitor.log file. Configure analyzerExecution.diagnostics and diagnosticInterval to select checkpoint, solver-growth, call-resolution, and memory-pressure records; NONE disables optional monitoring while retaining errors and resource limits. Checkpoint and memory-pressure monitoring run by default every 30 seconds; detailed call-resolution logging is opt-in. See runtime monitoring.

stigCheckAnalysis collects configuration evidence and complete data-flow and cascading-fault review tables. Use stigGenerateArchivedAnalysisReview to create a persistent working review from verified archives; refreshes preserve reviewer notes and mark assessments stale when their evidence changes.

stigAuditAnalysisEvidence verifies archive integrity and reports original-definition coverage for every selected transform, with exact LLVM locations for focused review.

stigImportModel imports SYML Context, native Highway JSON viewpoints, and selected code interfaces into ordinary Kotlin sources. Configure ordered inputs and metadata complements in model.imports; stigExportModel exports selected models or the native schema. See the import guide.

Transfer rules can select parameters and nested fields by name, write receiver and aggregate-return fields, assign literal values, and read arrays using named count fields. Compiler metadata resolves layouts; unsupported or incomplete types fail explicitly. See rewrite modeling.

addNativeFunctionImplementation retains a recorded native compiler input and its build recipe in P5, avoiding a custom C/C++ replacement when the original implementation is appropriate.

Model checks now identify semantic review work, including requirement feasibility, consistency, and verification criteria adequacy. Reports distinguish pending or unresolved assessments from violations; these assessments do not fail the build or count as passed checks.

Models can record external issue references and a failure's SUFFICIENT, RESIDUAL, or GAP evaluation. These declarations remain separate from automated source-analysis findings.

Failure.severity now uses Severity instead of Float. Replace numeric constructor arguments with Severity.S0 through Severity.S10, or Severity(value) when retaining an imported value. Model checks reject non-finite values and values outside the inclusive 0.01 tolerance around integers 0–10; exchange JSON remains numeric. Recompile model consumers after migration.

Custom integrations now use the shared ai.exida.stig.metamodels.highway.Viewpoint in place of the former CREATE/engine viewpoint enums and PackageViewpoint. Replace labelOf calls with fullLabel, idLabel, or shortIdLabel according to the required display form.

Model findings expose the reviewed object's identity, source navigation, and problem-specific remediation in HTML, SARIF, and IDEA. Rule links target the documentation channel of the STIG version that produced the report.

stigCheckAnalysis --configuration-only now prepares and captures the analyzer run plan and final P5 bitcode without executing P6. These inputs support transformed-input reruns; older archives lacking them need fresh configuration evidence before they can be used for that workflow.

Native analysis reuses repeated caller traversals and return-flow computations, removes identical pending solver work, and builds additional jump-function indexes only when needed. Distinct field and lifetime facts remain separate.

InterfacePointAnalysis no longer accepts name, description, or asil in Kotlin or the native exchange schema. Remove those constructor arguments and read the attributes through interfacePoint; keep analysis-specific prose in declaration documentation. ASIL checks now use the referenced interface point's ASIL. See the analysis migration guide.

Removed the compareStrings transform DSL helper. Configure strcmp with a reviewed C implementation through addFunctionImplementation; captured STRING_COMPARE models remain readable and validatable.

Source builds now compile PhASAR's LLVM test fixtures and run all registered unit-test executables before installing the dependency. Failed or empty test runs stop installation, and installations from the previous untested policy are rebuilt. Published analyzer installations still do not run STIG's Kotlin development suites.

Removed the per-entity and specification assumed fields. Declare isTopLevel and isBottomLevel on the owning element, and set element on Requirements and Tests; boundaries do not waive required values or test verification. See the model-boundary guide.

Requirements now need non-blank verificationCriteria, and missing required model attributes or links produce HIGH findings. Supply actual acceptance criteria when migrating and recompile model consumers; see the requirements migration guide.

Custom model-rule integrations must update imports from ai.exida.stig.metamodels.create.rules and its viewpoint subpackages to ai.exida.stig.metamodels.create and the corresponding subpackages.

Viewpoint containers are now Context, Requirements, Analysis, and Tests; migrate the former ContextSpecification, RequirementContainer, ElementAnalysis, and TestCaseContainer names. Replace Failure.independentFailure with the independentFailures list and recompile consumers.

Declare architectural children in Design.children and nested design sections in subDesigns. Model checks require child decomposition above bottom level and verify that each child's parent is the design's owning element.

Specification import is an explicit source-editing operation, separate from compilation, checking, and reporting. Replace generated Context base classes with ordinary Context declarations and configure code inputs in model.imports.code { fromModules(...) }. HIGH import findings retain valid independent updates; CRITICAL findings stop the file batch before writes. Review the import report and run stigCheckModel in a separate invocation.

The STIG Codex plugin now supplies $stig:source-analysis for native setup and evidence review, $stig:specification for CREATE authoring, and $stig:project for installation, project configuration, and reports. These replace $stig:stig and $stig:check-analysis and include version-matched manuals and API contracts.

stigCheckAnalysis now owns both analysis-review modes. It checks the full P1-P7/report chain by default; pass --configuration-only to stop after retained P5 configuration evidence. Replace stigCheckAnalysisConfiguration and stigCheckAnalysisFlowErrors invocations with this task. Root --modules selects exact Gradle paths; --zip writes one deduplicated, self-contained collection of the selected activities. Full archives retain exact P6 .bc/.ll pairs and exclude production source/header snapshots; --password enables AES-256 encryption and --zip-directory selects the destination.

Transform registry definitions now carry one reviewStatus: NEW, MODIFIED, or CONFIRMED. Activity use(...) entries only select rules. Function selectors use qualified names and optional exact mangledSymbol identities; replace function patterns and separate owner paths with the documented selectors and originalCompileUnit.

Generated lifecycle harnesses and C++ topic discovery no longer assume framework-specific C++ names. Projects using these features must set analyzerInput.harness.activityContextType and analyzerInput.interfacePoints.topicNamespace, respectively; JSON topic metadata remains namespace independent.

STIG's Maven metadata, IntelliJ plugin bundle, documentation, and notices now consistently identify the MPL-2.0 license, copyright notice, and Piotr Serwa as author. The public starter project now uses 0BSD so adopters can replace its license and attribution when turning the template into their own project.

Published STIG documentation now serves the newest release at the stable roots and one exact-version URL, keeps an independent replaceable snapshot channel, and removes older Writerside and Dokka releases from GitLab Pages. The stable Writerside pages are indexable and identify the root URLs as canonical.

Reorganized the manual around getting started, authoring specifications with CREATE, source analysis, reports, reference material, development, and project information.

Failed PhASAR runs on Linux now record host-memory snapshots, systemd scope accounting, kernel OOM evidence when available, and a classified termination reason in the analyzer run log.

Set modelCheck { enabled = false } to disable a module's model checks while retaining its declarations for consuming modules. Model libraries can use stigInitModule without declaring an Element or viewpoint container.

HTML model-check summaries now show executed automatic rules and all four priority totals, with detailed violations on a separate page supporting filters, pagination, and source links. Incomplete checks remain explicit; semantic review requests do not appear as automatic passes.

Model trees initially open two displayed levels and group interface-point analyses by their linked Context port. Deeper content, referenced definitions, navigation branches, and diagram viewers load on demand. Reports share navigation assets and exclude JavaScript and CSS source maps from publication, reducing initial loading and output duplication. See the report guide.

HTML generation and publication now allow uncommitted source changes by default. Set the task input requireCleanSourceRepositories to true on both checks to require clean configured worktrees.

HTML generation now handles element descriptors declared in a parent module and assigned to a separate report module through element.id, preserving their canonical identity in project navigation.

The opt-in stigExtendedCheckModel and repository qodanaCheck reject interrupted or incomplete Qodana scans and unsuppressed findings. Gradle automatically installs checksum-verified, pinned native tools; no Docker or manual CLI installation is needed. scripts/gradle-update.sh updates the analyzer pin alongside the Gradle plugin.

Module checks no longer load a child's separate specification solely because a locally declared child interface is present. Incoming coverage through an Analysis bypass still requires complete contributor content: add explicit stigModelContext where needed, or use the full-project :stigCheckModel.

Analysis-review tables count confirmed rules only when the selected activity uses them and avoid duplicate sinks when an LLVM endpoint without ASIL matches one unambiguous compiled field. Missing-annotation findings remain visible.

Generated analysis-review prompts identify the current captured invocation log and llvm/full/module.ll as the original-behavior reference. Unavailable log capture is explicit instead of linking a previous invocation.

Native analysis preserves copied pointer-field byte coordinates and dynamic-index prefixes, including scalar PHI offsets, without merging unrelated fixed fields. Non-null call arguments no longer acquire unrelated pointees through shared null-reset stores; repeated pointer-storage queries reuse their results. These corrections do not establish completion of analyses that previously timed out.

Scalar extensions no longer introduce dependencies on adjacent memory padding. Data-flow evidence recognizes direct configured source calls used by integer and floating-point extensions, avoiding reconstruction failures.

Native analysis rejects alias projections outside a proven allocation extent, avoiding impossible dependencies between differently sized objects. Unknown allocation sizes and accesses through loaded pointers remain conservative.

Data-flow evidence includes index strides in canonical fact identities, keeping distinct indexed access paths separate in native output and report loading.

IDEA model checks preserve inline-constructor identities and resolve supported metamodel attributes and value expressions by symbol identity. Concurrent inspections share model computation while retaining cancellation; reflection failures are reported instead of silently omitting failed materialization.

Reports generated from linked Git worktrees now resolve shared repository configuration and branch refs while retaining the worktree's own revision. This fixes missing source links and failed HTML validation caused by a broken project README link.

Native pointer-load propagation retains complete object identity, preventing taint from crossing into unrelated objects with the same field offsets. Loaded callback arguments also retain their known pointees, restoring missing source-to-sink flows without merging unrelated objects or fields.

Virtual-call resolution preserves anonymous namespaces and uses the receiver's inline debug context, avoiding unrelated virtual destructor targets in optimized C++.

Native data-flow evidence preserves source boundaries when initial seeds arrive in different orders and produces consistent path and segment records across diagnostic profiles. Sink partitioning uses the complete configured sink set when determining instruction reachability.

P5 recognizes the supported C/GNU floating-point environment functions as opaque runtime dependencies instead of missing application definitions. This classification supplies no model of exception flags or related data flows; model those effects explicitly when they matter to the analysis.

stigConfigureAnalysis now writes valid Gradle imports and compiles C replacement sources with the pinned C17 compiler when borrowing a C++ activity's build recipe, including recipes with explicit -x language options.

Interface extraction and generated harnesses now resolve the correct native filenames for modules whose names already end in _activity.

P5 can bind address-only function signatures through linked copies of C++ class metadata when the compiler declaration and complete layout agree. Missing, ambiguous, or conflicting type evidence still fails explicitly.

P5 optimization preserves transfer-model parameters when calls pass constant arguments, avoiding parameter-count failures during final-module validation.

P5 symbol completeness and classification report the original P5 validation failure when symbol reports could not be produced, and clear stale review outputs. A successful P5 stage with missing reports still fails explicitly.

stigCheckAnalysis retains evidence attributable to the current attempt after intermediate pipeline failures by default, while preserving failed producer status. Add Gradle's --continue to attempt other independent activities; unavailable downstream stages are not reported as zero findings. Archives retain invocation-specific INFO logs, standard output/error, and nested task failures without requiring --info.

P5 rewrite evidence now records exact applications and LLVM function aliases before optimization, so successfully rewritten functions later removed by optimization are accounted for separately from surviving final-body matches. Missing applications and missing required final definitions remain errors.

Model checks and reports now retain inherited consumer declarations and logical ownership across files and modules. Allocation coverage and incoming child-analysis checks use the complete loaded model; incomplete IDEA scope remains explicitly unassessed.

HTML generation with explicit stigModelContext dependencies works with sibling and included library builds. Dependency substitutions no longer cause runtime libraries to be treated as unprepared consumer model modules.

HTML model tables and trees now retain port-member uses, nested declarations, and cross-module references with their correct owners and links. Markdown generation avoids repeatedly traversing cyclic model references, reducing memory exhaustion on large models.

Root analysis checks no longer start native analysis for grouping modules or elements without source analysis.

Listing tasks and configuring analyses no longer resolves unrelated model-import classpaths.

Missing referenced P5 implementations are reported as HIGH with exact symbols. With failAt=CRITICAL, analysis can continue provisionally; reports retain the gaps and mark the evidence incomplete. Invalid LLVM and failed tools remain execution errors.

Native analysis now preserves field dependencies through aggregate returns, dynamically indexed pointer reads, fabs, argument rebasing, and aliased field writes. Declaration-only vtables no longer crash call-graph construction.

LLVM command conversion normalizes native debug modes and retains complete type metadata needed by named-field transfers, avoiding unsupported native compiler flags and incomplete C++ layouts.

Interface ASIL findings now distinguish stale or malformed annotation entries, which are ignored, from compiled leaves without a matching annotation, which receive the configured activity ASIL default named in the message.

The Writerside manual now loads screenshots, videos, favicons, and dark-theme media when published below a site subpath such as GitLab Pages /stig/stig/.

Added generated references for Gradle tasks, model APIs, and model rules. The installed STIG Codex plugin includes references matching the resolved STIG version.

Added an IntelliJ IDEA walkthrough showing requirement diagnostics and quick fixes.

HTML generation and publication now report total output size and list files of at least 10 MiB, largest first.

Enabled specification import now generates Context bases under build/ before Kotlin compilation, keeping authored hierarchy and internal units in consumer subclasses. Existing imported Contexts must extend Generated<Name>Context; set element.importEnabled = false for Kotlin-owned interfaces. See the upgrade guide.

Replaced stigInitSourceCodeAnalysisConfiguration and stigUpdateSourceCodeAnalysisConfiguration with the element-scoped stigConfigureAnalysis; use --preview to inspect candidates before editing configuration. Renamed stigCheckSourceCodeAnalysisConfiguration to stigCheckAnalysisConfiguration and stigAnalyzeFlowGaps to stigCheckAnalysisFlowErrors; update task invocations and evidence paths.

Report builds now generate enabled lifecycle harnesses under build/ and pass them directly to P5. Remove analyzerInput.harness.appendFromConvention and committed generated harness copies; select authored fragments with explicit harness.include(...) entries and retain the reviewed lifecycleProfile.

Full transform-configuration review is now an explicit stigCheckAnalysisConfiguration diagnostic. Normal report builds retain the required P5/P6 validation without automatically building the complete LLVM ownership inventory.

Flow-error evidence archives are now unstaged by default; pass stigCheckAnalysisFlowErrors --forceAdd to stage them.

Limited IDE plugin support to IntelliJ IDEA; Android Studio is excluded. Reorganized the manual around onboarding, Gradle workflows, and API references.

Changed diagramOutputs.sourceBrowser to use NONE, GENERATE, or GENERATE_AND_PUBLISH. If a source file exceeds the publication size limit, the complete activity source browser remains available locally and is omitted from Pages.

Pages publication now verifies the generated-file inventory and publishes only the selected report files, preserving content belonging to other publishers on the branch.

Removed stigImport, stigSyncAnalysisHarness, and stigCheckAnalysisHarness. Use stigGenerateHtml for automatic specification import, harness generation, and validation; generated outputs are no longer committed or pushed by an import task.

Removed the unmaintained stig-cli and stig-gui launchers and their distribution instructions. Use the Gradle plugin, IntelliJ IDEA plugin, or STIG Codex plugin.

Fixed analysis failures when function rewrites add bodies to declaration-only LLVM functions.

Fixed configuration-cache failures when running stigInstallSkill.

Fixed false HIGH-severity findings for BrDf, StDf, and StCf caused by comparing source-location counts with clang-tidy branch and statement counts.

Reduced report-generation memory use and disk space by sharing source-browser content across diagrams.

Flow-gap evidence archives now include the final analyzer input and configuration needed to replay analysis without rebuilding the original product sources.

Added stigListProblems to list findings, filter categories, and fail at a selected severity threshold. Tasks provide problems.jsonl records; SARIF remains available for IDE integration.

Added activity-local knownGaps declarations. Confirmed cascading-fault and missing-flow findings are reported as LOW; new findings and stale declarations remain HIGH.

Added stigCheckSourceCodeAnalysisConfiguration to check transform selections, confirmations, and application results.

Added the installable STIG Codex plugin for modeling and source-analysis workflows, installed with stigInstallSkill.

Renamed analysis tasks, DSL fields, and artifacts to distinguish the P1–P7 pipeline stages. Removed obsolete aliases; projects using the old names must update their configuration and commands.

Analysis-review workflows now provide versioned JSON evidence in place of generated HANDOFF.md instructions.

Standardized task and analyzer progress output using STIG | <area> | <operation> | <event> | key=value records, with JSONL output for tools that consume events.

Dokka HTML builds now fail on warnings, including unresolved KDoc links.

Model-only HTML reports no longer require a Bazel workspace when all source-analysis modes are disabled.

Fixed missing taint propagation through dynamically indexed aggregate getters while preserving constant-index precision.

Fixed false transform-configuration conflicts when LLVM symbol references differ only by an @ prefix.

Fixed configuration-cache and task-dependency errors in native analysis, aggregate problem listing, and report generation.

The public project template now selects the newly released STIG version after publication succeeds.

Added a comparison guide covering STIG, ALM tools, diagram tools, and assurance-case tools.

Source-backed imports and generated harnesses now use the selected activity's compiled C++ interface schemas. They preserve payload types and ASIL annotations, detect schema drift, and avoid processing unrelated activities.

Added diagramOutputs.maxArtifactSizeMiB to limit individual diagram artifacts. Oversized artifacts are omitted and reported as HIGH-severity findings.

Added repeatable --exclude <absolute-project-path> options to root stigGenerateHtml and stigPublishHtml tasks.

Added stigGenerateHtml --serve for local previews, including --continuous/-t rebuilds. Stop the background server with stigStopHtmlServer.

Added stigAnalyzeFlowGaps to archive analysis evidence for investigation without a matching local product checkout. Archives can optionally use AES-256 ZIP encryption.

Analysis now groups results by sink ASIL and uses compact schema-v7 evidence, reducing output size and report-processing memory. Tools reading analyzer JSON must support the new schema; the former 65,536-segment limit is removed.

Pages publication now replaces branch history with one commit containing the resulting site. It preserves content outside pagesSubdir and uses a lease to reject conflicting remote updates.

stigPublishHtml now defaults modifiedSourcesPolicy to continue, warning about dirty sources without changing them. Select fail for strict publishing; auto-commit-and-push remains opt-in.

Source-analysis settings now inherit individual properties through project, group, and element configuration. Overriding one property preserves the others; explicit false and empty collections override inherited values.

Source-analysis initialization and updates now apply to the selected element and preserve reviewed configuration.

Mixed C/C++ analysis now uses the compiler driver matching each source language. Concurrent builds coordinate access to shared Bazel workspaces and configuration files.

Standalone and composite builds now derive STIG's version from its own Git checkout. Missing version metadata causes a failure instead of producing a placeholder version.

Markdown report generation no longer requires the complete LLVM toolchain. Symbols remain mangled if the configured demangler is unavailable.

Fixed diagram source links that incorrectly reported No source line when compiler paths differed from indexed paths.

Fixed model-loading failures in consumer CI builds where dependency-cache JARs were mistaken for compiled model output.

Fixed source-boundary matching after path pruning, while continuing to reject evidence with unmatched sources.

Fixed feasible-only analysis and per-sink metrics when reading compact schema-v7 evidence.

Fixed inconsistent analysis results caused by fact ordering, access-path lifetimes, and source-boundary reconstruction.

Fixed scalar return transfers in rewriteFunctionWithTransfer, including boolean, integer, floating-point, and pointer-loaded values with widening or narrowing conversions.

Fixed missing and incorrect flows through optimized C++ callbacks, pointer fields, adjusted receivers, and virtual calls. Unrelated callback objects and fields remain distinct.

Reduced large-diagram layout memory use and fixed stack overflows, heap exhaustion, and prolonged routing stalls.

Fixed false C++ schema conflicts between types with the same short name in different namespaces.

Fixed false generated-harness failures caused by LLVM's printed basic-block order and valid coalesced base destructors.

Removed unreachable generated serializer code from contracted harness modules, avoiding undefined dependencies outside the selected analysis scope while preserving required lifecycle calls.

Fixed composite builds replacing the local PhASAR analyzer with a cached pinned build. Analysis now checks that the selected STIG and PhASAR revisions match the analyzer.

Fixed native dependency provisioning when a cached pinned commit had missing Git objects.

Fixed virtual-call target selection and missing jump-function entries in PhASAR.

Fixed false source-to-sink evidence introduced when merging source-analysis batches.

Fixed missing analysis and concurrency documentation links.

Added stigQuickCheck to compile consumer projects without running tests or generating reports.

Added source-analysis initialization, source-scope review and drift checks, and missing-symbol validation through stigInitSourceAnalysis and related tasks. Provisional model generation is opt-in.

Source-analysis initialization and updates now reconcile transforms with compiled LLVM behavior, preserve manual models, and flag uncertain or conflicting functions for review. Rules can select an exact mangled symbol; overlapping exact and name-wide selectors are rejected.

Transfer models now support declared parameters, thisObject, and returnValue, including multiple transfers and hidden C++ ABI parameters.

Added versioned report publication: retain release reports and at most one snapshot, with options to prune content or replace an existing release. Publication preserves other content outside the configured Pages subtree.

Generated reports now include navigable CREATE model trees, source links, and configurable view, edit, and IDEA actions.

stigInitElement now accepts an ASIL and can create a module with source analysis disabled, allowing an initial model report before native inputs are configured.

Report generation now reports HIGH-severity findings for inconsistent metrics, totals, or analysis scopes.

Added report quick links for CREATE viewpoints, project complexity, reachability, and lower-ASIL flows.

Analyzer execution now batches large source sets and limits concurrent runs using available RAM and swap. Renamed memoryMaxMb to maxAllowedRamAndSwapMiB.

Generated interface instrumentation now visits every array element and uses compile-time capacity for fixed-capacity containers, including containers whose runtime size is zero.

Per-sink metrics now use BrDf/dataFlowBranches, StDf/dataFlowStatements, and StCf/controlFlowStatements. They count unique selected source locations instead of LLVM instructions; default thresholds are halved accordingly.

Safety-measure recommendations now use optional, recommended, required, or mandatory. Reports can still read the older not required and advisory values.

Improved report finding counts, filtering, source actions, metric explanations, and navigation from sink summaries.

The IDE plugin now targets IntelliJ IDEA 2026.2, build 262.

Disabled automatic Build Scan publication to scans.gradle.com.

Fixed missing taint across lifecycle returns, nested pointer fields, overlapping stores, and constant-size memory copies. Disjoint globals no longer acquire false flows through shared alias groups.

Fixed missing control dependencies in optimized constant assignments and false flows between disjoint object members.

Fixed diagram validation and metrics for logical array sinks and excluded generated harness files from activity metrics.

Fixed publication from nested Git projects and to ignored Pages subdirectories.

Fixed parallel model checks interfering with another module's model state.

Fixed generated dependency sources being included in an activity's source scope and corrected report source links.

Fixed normal page scrolling over embedded Cytoscape and SVG diagrams. Standalone viewers retain zoom controls.

Fixed the bundled C++ and Kotlin source viewer for Monaco 0.56.

Fixed false IDEA findings for populated requirement allocations, required list arguments, and cross-file list references.

Fixed native analyzer builds with supported GCC toolchains and LLVM patch-version differences within the configured major.

Added third-party notices to the documentation and distributed JAR/ZIP packages.

Each model rule now has its own IntelliJ inspection and help page.

Data-flow diagrams now open with the routed Dagre layout by default.

NEXY gauges now show the zone name beside the percentile, such as P80 high.

Added a Measures column to complexity tables: Low or below is optional, Medium is advisory, High is required, and Very high or Outlier high is mandatory. Baseline ASIL safety measures still apply.

Bazel action inputs now invalidate stale analysis when headers, generated sources, build definitions, or compiler flags change.

Reports now show task execution problems alongside model-check findings and present repository revisions and timestamps in a build-provenance table.

Removed nativeBuildEnabled. For an explicit offline or degraded run, use nativeBuild { bazel { trackActionInputs = false } }; disabling this tracking allows analysis outputs to become stale.

Removed the source statement-count column from per-sink complexity tables; analyzer metrics remain available.

Removed SVF integration and the --backend option. Native analysis now uses PhASAR with cflanders or union-find alias analysis.

Removed the unused GPLv3 cytoscape-svg dependency from report bundles.

Fixed diagram validation and source/sink matching after the analyzer merges duplicate data-flow segments.

Fixed IDEA inspection crashes when referenced model entities are declared in another Kotlin file.

Fixed live requirement checks for model-interface references, source-only requirement containers, and cross-file derivedFrom relationships.

Fixed IDEA freezes when a quick fix prompts for input.

Fixed release tags being published before release validation completed.

Added NEXY metric models with JSON interchange, supporting quantile tables and normal, lognormal, and Poisson distributions.

Generated reports now display model-check findings and task execution problems in grouped tables.

NEXY now uses percentile-based metric models and a weighted average of available metric scores. Scores are displayed on a 0–100 scale; metrics requiring unavailable analyzer or Z3 evidence are omitted.

Default models now use approximate lognormal calibrations. Function P75 thresholds follow HIS reference values where applicable, P50 = P75 / 2, and P25 = P75 / 4; sink and component thresholds scale by 20 and 50 respectively.

NEXY zones now use percentile boundaries at P2, P9, P25, P75, P91, and P98. Gauges give each zone equal visual width and display raw thresholds and percentile labels without clipping.

Complexity warnings and limits now use the same P25, P75, and P98 model boundaries as the gauges.

Element complexity now maps NEXY zones to ISO PAS 8926 classes: up to Medium is C1, High is C2, and Very high or Outlier high is C3.

Per-sink IRBr, IRDf, and IRCfg count unique selected LLVM branch, data-flow, and control-flow instructions. Removed the IR-derived Ic statement column.

Reports now use the current default metric models when working with a local STIG checkout.

Long source paths now use repository placeholders and wrap in reports.

Cytoscape diagrams now open at preset positions and preserve focus during source navigation; other layouts remain available in the toolbar.

Updated the NEXY guide to explain default calibrations, empirical fitting, and elementary versus composite scores.

Removed stigComputeMetrics; use stigGenerateMetrics for explicit NEXY fixture generation.

Data-flow diagrams now follow the analyzer's segment DAG in every path-feasibility mode. Z3 feasibility results add metadata without creating or removing diagram edges; supported data-flow views are summarized and detailed per segment.

Fixed single-sink diagrams including unrelated sink bodies and rejected sink findings unreachable from an entry point.

Added LOW-severity findings when a requested detailed diagram cannot be drawn because segment evidence is missing.

Fixed report task creation failing with Could not initialize class StigGenerateMarkdownTask_Decorated.

Fixed documentation logos and favicons when hosted below a GitLab Pages subpath.

Added typed pipeline artifact references and from(...) connections between stages, replacing provider and mode enums.

Added sourceCodeSelection { from(...); include(...); exclude(...) } and stigAnalyzeP7SelectSourceCompileCommands to control which functions contribute descriptions and metrics. Selections default to the full input unless narrowed; requireExplicitIncludes can require an explicit selection.

Added structured execution problems in execution_problems.jsonl, with matching IDEA markers and problem details.

Added bitcode rewrite reports showing affected functions, source locations, reasons, and before/after code sizes.

Added native implementation, no-op, no-return, transfer, and runtime-global rewrite models. Parameter-to-return transfers can use rewriteFunctionReturnWithTransfer(...) without a native stub file.

Added analysisInstrumentation { pathFeasibility = PathFeasibility.FEASIBLE_ONLY } and PathFeasibility.BOTH. The default remains PathFeasibility.NO_CHECK.

Source-analysis configuration now uses nativeBuild, prefiltering, analysisCodeSelection, analysisInstrumentation, analyzerExecution, sourceCodeSelection, complexityMetrics, and functionDescriptions. Individual settings inherit from project defaults through groups to elements.

Renamed InterfacePointMode.AUTO to LLVM_HARNESS_DISCOVERY and INLINE to DSL_DECLARATION. Configure stub header search paths with iQuotePath(...)/iQuotePaths instead of the former includePath naming.

stigCheckModel, stigGenerateMarkdown, and stigInitElement now accept repeated --viewpoints options instead of comma-separated values.

Unified failure thresholds under failAt: ProblemSeverity. Model findings use at most HIGH; CRITICAL is reserved for execution or output failures that make evidence untrustworthy.

Model checks now inherit per-viewpoint enabled and failAt settings and skip disabled viewpoints.

IDEA findings now show rule IDs and targeted remediation, with Alt+Enter fixes for values, references, and missing information. Text and SARIF reports include the proposed fix titles.

Requirement wording checks now flag placeholders, uncertainty, vague quantities or timing, and non-exhaustive wording, including phrases such as etc., e.g., and and/or.

Reports now call the composite complexity score NEXY and use a weighted logarithmic average. Function, sink, and component thresholds use scope-specific calibration with normalized band boundaries at 10, 100, and 1000.

Function metrics now exclude analysis-provided harnesses, stubs, and helper sources by default.

Added grouping, numeric filters, metric gauges, and clearer source links to analysis tables. The Analyzer IR scope table lists every final-input function, including unchanged functions and analyzer usage.

Data-flow diagrams now use analyzer segment DAGs and include pruning reports. When path feasibility is enabled, detailed views use solver-confirmed instruction transitions.

Diagram endpoint markings now apply only to the selected sources and sinks. Node fills show declared ASIL, while borders show propagated ASIL and highlight lower-ASIL interference.

Clarified that data/control-flow complexity excludes lower-ASIL sources and that control-flow diagrams provide code context rather than proof of fault propagation.

Inconsistent analyzer leak and reachability evidence now produces CRITICAL findings. Structural data flow can still have an infeasible or unknown Z3 verdict.

Analysis bitcode now uses C++17 with loop and SLP vectorization disabled; remaining vector stores produce diagnostics.

Reorganized the manual into getting-started, user-guide, and internals sections.

Removed CompileCommandsSource, PrefilteringMode, CompilationScopeMode, and the old MetricsDsl. Use typed artifact providers and include/exclude rules.

Removed failCodeAnalysisAt and symbolVerificationFailAt; use failAt.

Removed legacy analysis { compilationUnits { ... } }, discovery, preFilter, PreFilterMode, CompilationUnitMode, DiscoverMode, and MetricsScope APIs. Migrate to the phase blocks listed above.

Removed old bitcode transform/append aliases in favor of the rewrite APIs.

Removed duplicate non-JavaScript tables from report sections rendered by Tabulator.

Fixed published documentation using a search-index ZIP in place of the HTML site and retaining stale pages after edits.

Fixed detailed-diagram function labels; unresolved mangled grouping labels are now reported as HIGH findings.

Fixed grouped table expansion, visible-text filtering, and filtered row totals.

Marketplace publication now selects the verified signed plugin archive.

Source-file edits now invalidate bitcode, function-description, and metrics tasks even when compile-command JSON is unchanged.

Fixed duplicate LLVM definitions from repeated compile commands and analysis stub headers overriding production headers.

Fixed source selections across absolute, repository-relative, and Bazel execroot paths. Empty selections now fail clearly.

Metrics generation now rejects missing numeric values instead of reporting zeros and handles large clang-tidy exports.

Fixed rewrite reports losing original function details for replacements.

Fixed Bazelisk selection for the host architecture and analysis compiler compatibility with staged GCC 15 headers.

Fixed native analyzer provisioning with missing PhASAR dependency submodules.

Fixed summarized diagrams losing source-to-sink paths and fan-out, and removed synthetic edges from segment views.

Fixed IDEA preview links opening a sibling build's website and diagram links in aggregate reports.

Report generation now detects broken local links, missing assets, and invalid diagram references.

Reports with pathFeasibility = no-check no longer claim that a path is symbolically unachievable.

Added detailed_per_segment data-flow views in Cytoscape and Sigma, with each segment's instructions available in tooltips.

Added a synchronized source browser to Cytoscape, Sigma, and SVG viewers, with file selection, source highlighting, unused-line filtering, keyboard navigation, and source-to-diagram focus.

Added shared viewer toolbars, theme support, selectable tooltips, context menus, and copy-link controls.

Added routed Dagre, layered KLAY and ELK, and fCoSE layouts to Cytoscape, with layout progress indicators.

Added source-to-sink verdicts combining data-flow presence and symbolic achievability, including an inconsistency state.

Renamed the detailed diagram axis to detailed_per_ir_instruction, including generated paths and labels.

Analysis pages now show a summarized SVG with links to detailed interactive views.

Detailed diagrams now group instructions visually by function and source line. Selecting a source line focuses all of its instructions and their direct neighbors.

Sink tables now distinguish expected data flow from unexpected cascading-failure flow. Sink headings preserve labels and underscores from analyzer metadata.

Cytoscape now uses the routed Dagre layout by default.

Viewer builds now use pinned Node.js and npm dependencies.

Missing analyzer segment evidence is now distinguished from a rendering failure; invalid diagram combinations are skipped.

Source-less instructions now show No source line instead of opening invalid external links.

Fixed benign browser ResizeObserver notifications being shown as diagram failures.

Fixed helper-function instructions being grouped under the caller's source function.

Diagram regeneration now removes stale outputs and links after configuration or filename changes.

Added an analysis-page table of model-check findings from every viewpoint, including severity, rule, and source location.

Added summarized, source-code, and hierarchical analysis diagram levels.

scripts/setup.sh now supports Fedora and Ubuntu 24.04 and installs the browser prerequisites once.

Detailed Cytoscape and Sigma diagrams now display LLVM instructions with source-line and segment information in tooltips. Static SVG overviews remain summarized.

Diagram labels now show source code and LLVM instructions separately; tooltips are scrollable and selectable.

Diagrams, metrics, and documentation now resolve source links consistently across configured repositories.

Sigma now uses the generated swimlane coordinates; Cytoscape uses a flat layout with orthogonal edges.

Removed browser installation from normal Gradle builds; run the setup script or use the prepared CI image.

Fixed cached analyzer run plans writing results into an outdated output directory.

Fixed demangling and source-line labeling overwriting instruction labels or making distinct instructions appear duplicated.

Added the native stig-code-analyzer, distributed as ai.exida:stig-code-analyzer. The Gradle plugin provisions it and reads combined analysis.json output containing sink verdicts and optional graphs and feasibility results.

Added explicit analyzer output switches for leaks, data-flow graphs, control-flow graphs, and feasibility, plus configurable call-graph selection.

Added an experimental --backend=svf alongside PhASAR. SVF provides leak verdicts only; it does not support data-flow or feasibility output or PhASAR's svf-* alias modes.

Added stigInstallDeps for host packages and stigSetupAnalyzer for an explicit analyzer build. Analyzer setup now reports progress and writes a setup log.

Added local PhASAR checkout support through -Pstig.localPhasar, with analyzer version output identifying the selected dependency. Native builds reuse an existing installation matching the pin.

Added --debug-trace to inspect native taint propagation without rebuilding the analyzer.

Added stigAnalyzeP7GenerateDiagrams with configurable SVG, Cytoscape, and Sigma output.

Added full ICFG and data-restricted control-flow diagrams, plus activity, class, and function grouping. The restricted view omits leaves outside cascading-fault paths.

Added standalone diagram viewers with search, themes, keyboard controls, and fullscreen. SVG supports pan, zoom, and SVG/PNG export; Cytoscape adds layouts, collapse/expand controls, a minimap, and context menus.

Release notes are now shown in the IDE plugin manager and JetBrains Marketplace.

The Gradle analysis pipeline now invokes stig-code-analyzer instead of phasar-cli. Entry points are supplied in analyzer configuration JSON; downstream tools must use the combined output instead of the old text reports.

Renamed stigAnalyzeP6RunPhasar to stigAnalyzeP6RunAnalyzer, stigAnalyzeP5GeneratePhasarRunPlan to stigAnalyzeP5GenerateAnalyzerRunPlan, and stigAnalyzeP7ConvertPhasarToDot to stigAnalyzeP7ConvertToDot.

Renamed stigAnalyzeP4GenerateCompileCommands to stigAnalyzeP4DetermineCompilationUnits and stigAnalyzeP5GenerateCompileCommands to stigAnalyzeP5FilterCompileCommands.

Renamed phasarMemoryMax to analyzerMemoryMax and STIG_PHASAR_MEMORY_MAX to STIG_ANALYZER_MEMORY_MAX. The compile task's llvmStd property is now cxxStandard.

Renamed AllConfiguredSinks.json to all_sinks.json and the phasar_runs, phasar_runs.sliced, and phasar_run_log JSON files to their stig_analyzer_* equivalents; removed the enclosing phasar-cfg directory.

Updated analysis tools from LLVM 17 to LLVM 18. Demangling now requires the matching versioned LLVM tool.

Analysis inputs now use C++14, optimization with SLP vectorization disabled, and debug information for source navigation. Bitcode generation rejects missing debug metadata or unsupported SIMD vector stores.

Compile databases must contain structured arguments; shell-string-only command entries are rejected. Analysis compilation uses the configured C++ standard without preserving a conflicting gnu++ spelling.

Analyzer builds now use the maintained PhASAR fork. Analyzer identity uses the STIG version, with a shared installation under ~/.cache/stig/stig-code-analyzer/; setup scripts install packages and Gradle performs native builds.

Increased IDE-XTaint's access-path bound from 3 to 8 to preserve deeper field paths; this can increase analysis time.

Disabled implicit strong-update taint removal in IDE-XTaint. Declare sanitizers explicitly in the analyzer configuration.

Bounded feasibility enumeration now reports an empty result as Unknown rather than proof of infeasibility. Floating-point, pointer, and bitwise guards remain outside the integer constraints this release can disprove.

Documented a remaining alias limitation: merged objects can produce false flows through offset-zero fields, including with SVF alias backends.

Renamed diagram taintReached fields to cascadingFault. Edges crossing into a higher-ASIL sink now carry a violet Cascading fault marker while the sink retains its declared-ASIL color.

Diagram-output settings now inherit project defaults. Reports distinguish disabled diagrams, empty analyses, and analyses emptied by transformation, with severity-controlled failures for missing expected evidence.

Published documentation now separates the user manual and developer guide from repository workplans.

Removed legacy psr-*.txt report parsing and the separate Gradle SVF pipeline; control-flow data comes from the shared analyzer output.

Removed stigAnalyzeP5VerifySymbols. Symbol validation now runs before P6 analyzer execution, and its diagnostic files are written with the P6 outputs.

Fixed missing IDE-XTaint propagation through member-pointer arguments, non-shift binary operations, comparisons, selections, and field-preserving struct copies.

Fixed IDE-XTaint return propagation through this->member in optimized bitcode. Unoptimized alloca/load chains and the separate IFDS field-sensitive solver remain limited.

Fixed crashes during alias initialization, serialization of solver findings, and handling of synthetic instructions.

Fixed missing call-return edges in the emitted control-flow graph.

Native x86-64 builds now target x86-64-v2 instead of the build machine's CPU, avoiding illegal-instruction crashes when binaries run on another compatible machine. These binaries require an x86-64-v2-compatible CPU.

Fixed native dependency builds with GCC 16 headers and Z3/curl detection on Debian and Ubuntu.

Fixed blank or failing SVG, Cytoscape, and Sigma viewers, including missing payload files and ELK initialization errors.

Fixed ASIL coloring at source/sink call sites, source-file resolution, and instruction grouping under the correct function.

Fixed complexity gauges losing value colors when thresholds are absent.

Fixed broken KDoc links and configuration-cache failures in local Writerside tasks.

Added native toolchain setup for Fedora and Ubuntu, with patched, release, and current PhASAR profiles.

Source-only analyzer JARs can now be built without the native compiler toolchain; native build tasks report why they skip.

Updated the native analyzer toolchain and analysis compiler to LLVM 18. Host Clang builds the native dependencies; the compiler producing analysis bitcode must match the analyzer's LLVM major.

Analysis postconditions now distinguish CRITICAL evidence failures from HIGH diagram failures. failCodeAnalysisAt defaults to CRITICAL; lower-severity violations are reported as warnings.

Analysis failure messages now identify the affected sink, severity, and configured threshold.

Documented an IDE-XTaint limitation for tainted-memory flows across non-inlined calls.

Fixed PhASAR setup with Clang 22 and Fedora 44 headers.

Fixed LLVM package discovery rejecting a compatible installed LLVM 18 patch release.

Fixed SVF builds and runtime-file discovery across Fedora's lib64 and Ubuntu's lib layouts.

Added sanitizer(symbol) declarations for functions that return clean values. In this version, PhASAR honors these declarations only for functions without a body in the analyzed module; a validator that merely checks a value must not be modeled as a sanitizer.

Changed the default dataFlowAnalysis to ide-xtaint with union-find aliases for nested-field analysis.

Increased inlining for activity bitcode and compiled harnesses and stubs at -O1, allowing analysis to follow std::array accessors while preserving separate field stores.

Fixed duplicate anchors in generated release-note subsections that caused Writerside builds to fail.

Fixed duplicate release-note anchors that blocked publication after version 1.2.0.

Added the IntelliJ IDEA plugin with live model-rule findings in Kotlin source files and signed Marketplace distribution. The initial plugin targets IDEA 2026.1.3 with K2 support; compiled-dependency model support is deferred.

Live inspections support entity references, lists, cyclic list relationships, and simple user subclasses of metamodel types. Multi-level subclass hierarchies and subclasses requiring constructor arguments remain unsupported.

Added knownFacts assertions for observed sources, intentionally inactive source flows or calls, and sinks expected to be reached or not reached. Conflicting declarations are rejected.

Added consistency checks across analysis configuration, native results, diagrams, and declared known facts.

Added LLVM-based discovery of harness source and sink functions, alongside explicit interface declarations.

Added AnalysisDepth.GROUP, LEAF, and BOTH, with BOTH as the default, and per-analysis diagram controls.

Added analyzer runtime estimates, persistent run logs, and Linux memory limits applied to the analyzer process.

Added code-metric gauges, composite complexity in project summaries, and reporting of analyzed and uncovered source files.

Added a page table of contents, endpoint and model icons, and full-label diagram tooltips.

Added Context and DocumentMetadata for document identity, classification, version history, and separate workflow and release states.

Added Requirement.allocatedTo for allocation to direct child elements and an assumed flag on elements.

Added model checks for containment, viewpoint placement, allocations, missing fields, test consistency, assumed-model consistency, and failure multiplicity.

Added stigPrintVersion, stigListElements, and stigGenerateHtml, plus a Gradle-plugin sources JAR for IDE navigation.

Added stigProject { publish { ... } } configuration for the remote, Pages branch/subdirectory, URL, and source policy.

Added codebase-anchored paths such as codebases.sourceRepo / "activities/foo/topics.json" to reduce fragile relative paths.

Replaced the flat element analysis DSL with discovery, prefiltering, instrumentation, conversion, execution, and metrics blocks. Groups and defaults provide shared configuration.

Replaced flat enable*Analysis properties with named analysis blocks containing enabled. Only enablement inherits at group/default level in this release; other analysis options remain element-specific.

Data-and-control-flow analysis is now disabled by default. Enabling native analysis requires a configured Bazel target.

Configure depth with dataAndControlFlowAnalysis.mode or cascadingFailuresAnalysis.mode; the old instrumentation.interfacePoints.depth setting is removed.

Leaf-mode reports include an all-sinks overview by default; disable it with showAllSinksMergeInLeafMode = false. Data-flow and control-flow diagrams default to enabled, while combined overlays default to disabled.

Renamed stigGenerateDocs to stigGenerateMarkdown and stigPublishPages to stigPublishHtml. Analysis tasks now follow the stigAnalyzeP{N}{Verb}{Noun} naming pattern; legacy aliases are removed.

Split stigAnalyzeP7AnalyzeComplexityAndFlow into stigAnalyzeP7EnrichDots and stigAnalyzeP7ScaffoldAnalysisPackage. Invoke them on the required subproject; the former root aggregate is removed.

Renamed stigAnalyzeP7GenerateSigma to stigAnalyzeP7GenerateSigmaFromDot and stigAnalyzeP7GenerateImages to stigAnalyzeP7GenerateImagesFromDot.

Renamed appendStub(...)/stubFiles to stubSource(...)/stubSources, importFromLocation to interfacePointLocation, and importFromName to interfacePointModeName.

Renamed modelChecks to modelCheck. Viewpoint blocks control enablement; the parent failAt controls model-check failure thresholds independently of document lifecycle metadata.

Added symbolVerification { mode; failAt }. Renamed VERIFY_SYMBOLS to CHECK_DISCOVERED_SYMBOLS and VERIFY_ALL_SYMBOLS to CHECK_ALL_UNDEFINED_SYMBOLS.

Interface declarations now use typed ASIL values, support multiple entry points, and use paramIndex = null for source return values. Inline declarations replace the former manual naming.

Defaulted ExecutionDsl.memoryMaxMb to 16_000; Linux memory limits now use a user systemd scope without elevation.

Reorganized analysis artifacts by analysis type, depth, tool, and subcategory. Configuration files now use nested paths with adjacent .endpoints.json metadata instead of filename suffixes.

Per-module HTML previews now use build/dokka/module-preview/; the root report uses build/dokka/html/.

Short STIG commands invoked through Bazel from an element directory now select that element's Gradle task.

Metric thresholds now use tenfold steps: high = medium × 10 and nonAcceptable = medium × 100.

Model IDs are now non-null, fully qualified identifiers, including in SARIF findings. Reference collections in Failure, Requirement, TestCase, and InterfacePointAnalysis are mutable to support cyclic source models.

Rule IDs now derive from rule class names; consumers matching older SARIF IDs need updating. Findings retain the declared CRITICAL, HIGH, MEDIUM, LOW, or INFO severity and are deduplicated across containers.

Requirement ASIL over-classification now reports CRITICAL. ASIL derivation findings report MEDIUM because legitimate decomposition can trigger them; failure-propagation consistency findings also report MEDIUM.

Detailed diagrams now fold straight-line instruction chains while preserving branches, endpoints, and control flow. Summarized data-flow diagrams run left to right; detailed diagrams run top to bottom.

Renamed the diagram label INTERFERENCE to Cascading fault and highlighted the complete contributing data-flow path. Summary markers now require analysis evidence, not just a lower-to-higher ASIL pairing.

Reports now distinguish absent expected data flow, absent cascading failures, and missing evidence. Enabled cascading-failure sections explain when there are no applicable lower-ASIL sources.

Removed the Gradle stigCheckModel --failAt option; configure the threshold in the DSL. The standalone engine CLI retains its own option.

Removed -PstigInterfacePointMode and legacy interface-mode aliases; configure interface points through the DSL.

Removed per-viewpoint strict settings and the direct analysis failCodeAnalysisAt DSL property; use the appropriate model-check or analysis-feature failAt setting.

Removed Requirements.assumed; mark individual requirements instead.

Replaced StigComponentSpec with StigElementSpec. Removed StigElementType and StigImportSource aliases; use ElementType and InterfacePointMode.

Removed StigExtension.resolveFile; use StigPatchSpec.replaceFromFile.

Removed scopeAllCompileCommands; descriptions and metrics now consume all entries in their compile database.

Removed sample-activity data and source listings from generic reports; configure expectations with knownFacts.

Fixed missing all-sinks analysis results and empty run plans for leaf-only or group-only analysis.

Fixed inherited failure thresholds, group-level stubs, and discovery include paths being ignored.

Fixed source and sink diagrams showing sequential source-call chains, outgoing sink edges, or identical topic-only labels for different leaf fields.

Fixed malformed merged and enriched DOT graphs, over-cropped control-flow diagrams, and parsing of unquoted node IDs.

Fixed dense diagram layout stalls while retaining source/sink paths and branch structure.

Fixed duplicated SVG filename prefixes, missing aggregate-report diagrams, project-complexity links, and duplicate report titles.

Fixed page contents links, overlapping sidebars, invisible icons, and ECharts gauge rendering.

Removed redundant per-module HTML generation during root report builds.

Fixed missing-run-plan failures when PhASAR analyses are disabled, including complexity-only builds.

Fixed interface-symbol matching for typedef parameters and function names without return types.

Fixed relative compilation-unit selection and reports for explicitly declared inline interfaces.

Symbol-validation failures now respect continueOnCodeAnalysisErrors.

Fixed false unresolved-reference findings for failure propagation between different Analysis containers.

Fixed IDE plugin signing and signature-verification failures.

Extended source analysis with PhASAR and SVF.

Added topic-based communication documentation.

Updated component import and element initialization, with corresponding documentation.

Updated the metamodel and its examples.

Extended source analysis with PhASAR and SVF.

Added documentation for topic-based communication.

Updated the context metamodel and its documentation.

Added Kotlin code snippets to generated Markdown and HTML.

Updated logging.

Switched from JDK 25 to JDK 21 for Bazel compatibility.

Updated the documentation.

Updated the documentation.

The release page now shows the complete changelog.

Added root-level Gradle commands and logging.

Enabled element initialization with stigInitElement and updated the Gradle task documentation.

Corrected documentation.

Added proof-of-concept implementations of the planned STIG features.

Fixed GitLab Pages documentation builds.

Documented upcoming commands.

Documentation artifacts are now available for non-release commits.

Made documentation builds reproducible.

Fixed publication of the latest documentation.

Fixed release-page generation and corrected documentation.

Updated build configuration and documentation generation.

Expanded the STIG tools and documentation.

Corrected Markdown documentation.

Added automatic viewpoint creation for elements.

Updated the documentation.

Updated the documentation.

Fixed Markdown compilation errors.

Expanded the documentation.

Fixed Maven publication timeout handling and reduced build-time JVM warnings.

The importer can now represent components as Kotlin objects extending Component.

Fixed Gradle configuration errors.

Fixed Gradle configuration errors.

Updated documentation navigation.

Updated Gradle documentation.

Added an initial metamodel with examples and Maven publication.

Switched to JDK 25 and updated Gradle. STIG is now packaged as a library.

Initial release with Maven Central integration.