Release 1.0.0

AsiBackbone Learning 1.0.0 is the first production documentation baseline for the AsiBackbone ecosystem. It is the educational companion to the AsiBackbone 6.0.0 implementation release.

The version advances from 0.15.0 to 1.0.0 because the foundational curriculum, public navigation, compatibility boundary, validation gates, and release evidence are now established as a stable documentation contract. Published page URLs are treated as durable; future moves should retain redirects from their previous addresses.

Highlights

• Aligns current terminology with the finalized AsiBackbone 6.0 vocabulary, including decision receipts, acknowledgment, capability grants, host-owned execution, and familiar outbox terminology.
• Adds a Learning 1.0 / AsiBackbone 6.0 compatibility guide for interpreting historical 5.x material.
• Adds an API boundary guide covering current 6.0 names, namespaces, evaluator construction, endpoint markers, renamed types, and removed compatibility members.
• Distinguishes Learning-owned framework-neutral teaching models from exact released package APIs.
• Refreshes Getting Started, navigation, tutorials, diagrams, samples, and cross-repository links around the production baseline.
• Validates all executable samples through locked restore, build, formatting, and 300 invariant tests.
• Adds durable release evidence: a samples SPDX SBOM, exact release notes, a SHA-256 evidence manifest, and GitHub provenance attestations.
• Strengthens documentation, link, workflow-security, dependency, code-scanning, publication, support, and maintainer gates.

Compatibility

Learning 1.0 documents and teaches the AsiBackbone 6.0 production surface. Earlier Learning releases remain historical educational records and may reference APIs or terminology that were valid in earlier AsiBackbone release lines.

Use the Learning 1.0 and AsiBackbone 6.0 Compatibility Guide to translate older material. Use the AsiBackbone 6.0 API Boundary for current high-frequency names and examples. The AsiBackbone 5.x-to-6.0 migration guide remains authoritative for complete implementation migration details.

Stable Architectural Boundaries

The 6.0 vocabulary and API refinements do not change Learning's central architecture:

• policy decides before protected execution begins;
• acknowledgment does not silently become authorization;
• capability grants remain narrow, explicit, and independently validated;
• the host retains ownership of side effects and execution;
• decision, acknowledgment, authority, delivery, and execution evidence remain distinct.

Renamed Pages and Sample

Learning 1.0 adopts the finalized 6.0 terminology while preserving the previously published documentation URLs as redirects:

• architecture/accountable-systems-infrastructure-and-governed-execution → architecture/asibackbone-and-governed-execution;
• tutorials/acknowledgment-and-audit-residue → tutorials/decision-receipts-and-acknowledgment;
• labs/acknowledgment-and-audit-residue → labs/decision-receipts-and-acknowledgment.

The companion sample moved from samples/acknowledgment-and-audit-residue to samples/decision-receipts-and-acknowledgment. The old sample directory retains a pointer README for repository links and historical references.

Known Limitations

• Learning is educational documentation, not a package or runtime support line, compliance certification, or security guarantee.
• Executable samples use framework-neutral teaching types and do not reference AsiBackbone.* packages.
• Experimental material remains explicitly labeled and is not presented as a standardized protocol or production-ready implementation.
• Exact package signatures, runtime behavior, configuration, compatibility, and security semantics remain authoritative in the AsiBackbone 6.0 implementation repository.

Release Evidence

The GitHub Release includes an SPDX 2.3 inventory of sample source and locked dependencies, these exact release notes, and a SHA-256 evidence manifest. GitHub provenance attestations bind each evidence asset to the release workflow. See the Stable Release Evidence Runbook for scope and verification commands.

Release 0.15.0

ASI Backbone Learning 0.15.0 is a repository-security, reproducibility, and sample-quality release. It strengthens the trustworthiness of the educational material while adding new guidance about audit evidence and repository-host controls.

Highlights

• Published “Your Audit Log Is Not Evidence”, covering durable, verifiable decision evidence.
• Added guidance for configuring and validating repository-host security controls.
• Introduced CodeQL, OWASP Dependency-Check, OpenSSF Scorecard, and workflow-security analysis.
• Documented and automated protected main branch controls.
• Centralized sample package versions and added locked NuGet restores.
• Pinned the .NET SDK used by local development and CI.
• Made the VSTest runner explicit for the existing xunit.v3.mtp-off configuration.
• Added repository-wide C# formatting rules and CI enforcement.
• Added property-based replay-protection tests with FsCheck.
• Standardized sample project layouts as Sample/ and Tests/.
• Removed obsolete dependency-check suppressions for packages not used by Learning.
• Added merged-branch retention and cleanup guidance.

Sample Reliability

The sample suite now has a more reproducible dependency and validation model:

• Package versions are managed centrally.
• Every sample project has a committed lock file.
• CI restores packages using locked mode.
• Formatting is validated before tests.
• The SDK and test runner are explicitly selected.
• Replay-protection invariants include property-based coverage.

Repository Security

This release adds layered repository-security validation:

• CodeQL analysis for C#.
• OWASP dependency analysis.
• OpenSSF Scorecard monitoring.
• GitHub Actions validation with actionlint and zizmor.
• Pinned workflow dependencies.
• Documented branch rules, review requirements, and administrative tooling.

Documentation and Publication

• Added repository-host security documentation.
• Clarified illustrative capability-validation examples.
• Refreshed the roadmap and ongoing maintenance priorities.
• Preserved strict DocFX, sitemap, RSS, link, and metadata validation.

Validation

Sample tests:          266 passed
Sample build:          0 warnings, 0 errors
DocFX pages:           110
DocFX validation:      0 warnings, 0 errors
Sitemap URLs:          110
RSS items:             17

Formatting, locked restore, CodeQL, dependency scanning, workflow-security, link, IndexNow, citation metadata, and publication-integrity checks passed.

Citation and Archival Metadata

Release metadata is synchronized as:

CITATION.cff
version: 0.15.0
date-released: 2026-09-11

.zenodo.json
version: 0.15.0

The stable concept DOI remains:

10.5281/zenodo.21938556

The version-specific 0.15.0 DOI should be recorded after Zenodo creates the archived snapshot.

Release Scope

Version 0.15.0 is a citable educational and architectural snapshot. It does not establish a runtime compatibility contract or introduce a production governance engine, compliance certification, legal standard, autonomous-agent runtime, or AI model.

Full changelog

Release 0.14.0

ASI Backbone Learning 0.14.0 is an educational quality and publication-reliability release. It improves documentation structure, accessibility, discoverability, citation metadata, link validation, and DocFX maintenance boundaries.

Highlights

• Standardized heading hierarchy across labs, roadmap, and community documents.
• Enforced one H1 per page and prevented skipped heading levels.
• Added and standardized page-orientation metadata.
• Enforced concise page descriptions of no more than 160 characters.
• Standardized pattern-classification vocabulary.
• Restored missing sample and Advanced-content catalog entries.
• Improved DOI, citation, anchor, and repository-directory link validation.
• Cleaned up DocFX resource and custom-template layout.
• Improved RSS and documentation-publication behavior.
• Clarified fictional ADR lifecycle examples.
• Added a confidential Code of Conduct reporting route.
• Corrected licensing and package-naming documentation.

Documentation Validation

The metadata validator now covers both published documentation and repository planning material. It checks:

• Heading hierarchy
• Publication-date formatting
• Page descriptions
• Pattern classifications
• Canonical metadata
• Generated-page publication metadata

The DocFX baseline validator now protects resource, theme-asset, and authoring-content boundaries.

Link and Publication Reliability

Link validation now:

• Checks DOI and Zenodo links.
• Validates Markdown anchors.
• Resolves both blob/main and tree/main links against the revision under test.
• Preserves consistent behavior between local validation and CI.

RSS links now resolve correctly under both the GitHub Pages path and local documentation previews. Changes to the metadata validator also trigger documentation publication.

The IndexNow self-test now cleans up its synthetic Git repository correctly on Windows.

Citation and Archival Metadata

Release metadata is synchronized as:

CITATION.cff
version: 0.14.0
date-released: 2026-09-06

.zenodo.json
version: 0.14.0

The stable concept DOI remains:

10.5281/zenodo.21938556

The version-specific 0.14.0 DOI should be recorded after Zenodo creates the archived release snapshot.

Validation

Sample tests:          264 passed
Sample build:          0 warnings, 0 errors
DocFX pages:           108
DocFX validation:      0 warnings, 0 errors
Sitemap URLs:          108
RSS items:             16

DocFX template-baseline, sitemap, IndexNow, RSS, documentation metadata, and Git diff validation all passed.

Release Scope

Version 0.14.0 remains an educational and architectural snapshot. It does not introduce a production governance engine, compliance certification, legal standard, autonomous-agent runtime, AI model, or runtime compatibility contract.

[Full changelog](v0.13.0...v0.14.0)

Release 0.13.0

ASI Backbone Learning v0.13.0 is an educational architecture release focused on design choice, critique, adoption boundaries, and authority selection.

Earlier releases established and expanded the governed-execution model. Version 0.13.0 goes further by asking a more mature set of questions:

When should a pattern be used, when should a simpler architecture win, and how can unsafe authority paths be recognized before they become production behavior?

This release adds new architecture guidance, completes the currently defined advanced hands-on lab scope, publishes a substantial practitioner article on roles, claims, and capability authority, expands regional and regulated-system material, and migrates the executable sample test projects to xUnit 4.

Highlights

Advanced Hands-On Lab Path Completed

Version 0.13.0 completes the currently defined Milestone 5 hands-on lab scope with three new advanced exercises.

Design a Regional and Tenant Policy Layer

Learners design an explicit multi-authority policy overlay for a conventional enterprise data-export scenario.

The exercise explores:

• global, regional, tenant, application, and operation policy layers;
• explicit authority and precedence;
• mandatory narrowing;
• delegated overrides;
• composite provenance;
• missing-policy behavior;
• deterministic composition;
• policy and resource drift;
• execution-time freshness;
• host-owned execution invariants.

The lab reinforces:

Registration order must not silently become policy authority.

---

Analyze a Deliberately Flawed High-Consequence Workflow

This synthesis-oriented lab begins with a plausible but intentionally unsafe account-disable workflow.

Learners must discover defects rather than being handed a predetermined checklist.

The exercise examines:

• caller-controlled versus authoritative context;
• AI recommendation versus policy authority;
• acknowledgment and escalation;
• stale approval caching;
• broad standing credentials;
• replay and concurrency;
• fail-open dependency behavior;
• alternate execution paths;
• resource drift;
• incomplete evidence;
• decision versus execution semantics.

The core review question is:

What authority paths still work when the system's assumptions fail?

---

Critique AI-Owned Proposal and Execution Authority

This lab deliberately starts from an architecture where an AI agent owns:

Interpretation
      +
Tool proposal
      +
Policy-relevant context
      +
Safety judgment
      +
Credentials
      +
Execution
      +
Retries

Learners separate useful model autonomy from execution authority and redesign the workflow around host-owned enforcement.

Topics include:

• host-owned tool registries;
• typed proposal contracts;
• schema and semantic validation;
• authoritative context reconstruction;
• credential isolation;
• explicit governance outcomes;
• acknowledgment and escalation;
• scoped continuation authority;
• retry boundaries;
• execution evidence.

The recurring invariant remains:

AI proposes execution
        ≠
Authority to execute

The lab also explicitly examines lower-consequence scenarios where greater AI autonomy may be reasonable.

New Practitioner Article

Do You Need a Capability Token, or Are Roles and Claims Enough?

Version 0.13.0 publishes a substantial standalone architecture guide for .NET and ASP.NET Core developers.

The article rejects the common maturity-ladder assumption:

Roles
  ↓
Claims
  ↓
Capabilities

and replaces it with:

Choose the authority model that matches the lifecycle and trust boundary you actually have.

Three scenarios demonstrate where each model clearly fits.

Roles

Roles are appropriate when authority is stable, organizational, and consumed immediately within the same trusted host.

Claims and Resource Authorization

Claims and resource-based authorization become a better fit when trusted actor attributes and current resource state determine permission.

Capability Authority

A separately issued capability becomes useful when an allowed decision must become narrow continuation authority for a later or different executor.

The article also covers:

• standing versus continuation authority;
• identity claims versus caller assertions;
• operation/resource/audience binding;
• issuer trust;
• capability provenance;
• expiration versus freshness;
• replay and atomic bounded use;
• revocation and cancellation;
• queue custody;
• sender constraining versus audience binding;
• capability validation patterns in ASP.NET Core;
• threat modeling;
• failure behavior;
• when capability infrastructure is overengineering.

A central clarification is:

A capability is an authority-lifecycle concept, not simply a JWT with different claims.

Related standards are discussed where useful, including OAuth 2.0 Token Exchange, Rich Authorization Requests, DPoP, certificate-bound access tokens, and GNAP, without presenting those standards as interchangeable with the generic capability model.

Expanded Architecture Guidance

Version 0.13.0 adds several substantial architecture documents that broaden Learning beyond isolated governed-execution mechanics.

Growing Beyond a Simple Application Structure

Provides guidance for recognizing when a small application structure is still sufficient and when architectural decomposition begins to earn its cost.

The emphasis remains on deliberate evolution rather than premature abstraction.

---

Accountable Systems Infrastructure and Governed Execution

Connects the broader Accountable Systems Infrastructure framing to concrete governed-execution architecture.

The material focuses on observable responsibility boundaries rather than branding or framework adoption.

---

Intent-to-Execution Accountability Pattern

Explores the accountable path from proposed intent through authoritative context, decision, execution, and evidence.

The pattern makes responsibility explicit at each transition.

---

Constraint-Conditioned Decision Model

Adds a deeper architectural treatment of decisions conditioned by explicit constraints rather than hidden evaluator behavior.

This extends Learning's existing work on constraint composition, precedence, and policy evidence.

---

Governance Tool Selection and Composition

Examines how governance mechanisms should be selected and combined based on the problem they solve rather than accumulated as architectural ceremony.

The guidance reinforces an established principle:

Use the smallest architecture that preserves the required boundary.

Regional and Regulated-System Guidance

Two additional advanced documents deepen the application of governed execution to organizational and jurisdictional contexts.

Regional Policy and Operational Gateways

Explores how regional policy requirements interact with operational enforcement boundaries.

Topics include:

• regional authority;
• resource location;
• policy overlays;
• gateways;
• execution-time validation;
• provenance;
• drift.

---

Governed Execution in Regulated Systems

Provides a careful architectural treatment of governed execution in systems subject to stronger oversight and evidence expectations.

The material remains explicitly technical and does not claim:

• legal compliance;
• regulatory certification;
• automatic conformance;
• jurisdiction-specific legal correctness.

The purpose is to improve system structure and evidence, not to replace legal or compliance review.

Adoption and Entry-Point Guidance

A new Adoption Personas and Entry Points document helps readers identify the parts of Learning most relevant to their situation.

This supports developers and architects approaching the repository from different starting points, including:

• ordinary ASP.NET Core applications;
• policy-driven systems;
• distributed workflows;
• AI-assisted applications;
• higher-consequence operations;
• architecture review and education.

The goal is to make Learning easier to enter without requiring readers to adopt the entire vocabulary or curriculum first.

xUnit 4 Migration

The executable Learning sample test projects have been migrated to xUnit 4.

Representative package changes include:

xunit.v3 3.2.2
        ↓
xunit.v3.mtp-off 4.0.0

xunit.runner.visualstudio 3.1.5
        ↓
xunit.runner.visualstudio 4.0.0

Microsoft.NET.Test.Sdk 18.8.1
        ↓
Microsoft.NET.Test.Sdk 18.9.0

The migration updates the repository's sample-testing foundation while preserving the architectural purpose of the tests:

Important boundary
      ↓
Observable invariant
      ↓
Executable verification

The sample suite remains teaching infrastructure rather than a production framework.

Roadmap Progress

Version 0.13.0 substantially advances the hands-on and architecture portions of the Learning roadmap.

The currently listed advanced lab objectives are now complete, including:

• competing policy architecture comparison;
• regional and tenant policy design;
• high-consequence workflow critique;
• AI proposal-versus-execution-authority critique.

Future labs should now be added selectively where a distinct learning gap is demonstrated rather than simply to increase lab count.

This reflects a shift from:

Build more examples

toward:

Identify missing reasoning
        ↓
Add only the material that closes that gap

Publication and Navigation Updates

This release updates the Learning publication surfaces to include the new material.

Changes include:

• Articles archive and navigation;
• Labs na...

Release 0.12.0

ASI Backbone Learning v0.12.0 is an advanced architecture release focused on what happens when governed execution extends beyond a single request, service, or policy boundary.

This release expands the Learning curriculum into cross-system authority, federated governance, distributed acknowledgment, human-readable decision explanation, adaptive risk and context drift, and durable decision evidence. It also substantially improves discovery of the repository's growing executable sample suite and publishes two new practitioner-oriented technical articles.

The recurring architectural question throughout this release is:

What must remain true when authority, context, policy, and execution are separated across systems or across time?

Highlights

Advanced Distributed Governance

Six substantial additions expand the Advanced learning area.

Cross-System Capability Exchange and Delegated Authority

Explores how narrowly scoped execution authority can cross a system boundary without becoming an ambient credential.

Topics include:

• delegated authority
• audience and resource binding
• least privilege
• trust relationships
• replay resistance
• downstream validation
• authority attenuation
• execution ownership

The material reinforces that transferring a representation of authority does not transfer unrestricted control.

---

Federated Governance and Independent Authority Coordination

Examines decisions involving multiple independently governed authorities.

Rather than assuming that every policy can be collapsed into one central rules engine, the material explores how independent authorities can coordinate while preserving their individual responsibility and decision boundaries.

Topics include:

• authority-set resolution
• independent policy ownership
• coordination semantics
• partial availability
• conflicting outcomes
• degraded operation
• evidence across authorities

---

Distributed Acknowledgment and Continuation Workflows

Extends acknowledgment beyond the simple synchronous:

Prompt
  ↓
User accepts
  ↓
Execute

The new material examines acknowledgment as a continuation boundary that may span processes or time.

It covers:

• acknowledgment records
• continuation state
• expiry
• policy re-evaluation
• context changes
• replay
• stale acknowledgment
• execution-time validation

Acknowledgment remains distinct from standing authorization and from final execution authority.

---

Decision Explainability for Human Operators

Introduces a deliberate separation between internal governance evidence and the explanation presented to a human operator.

A governance system may possess detailed internal diagnostics that should not automatically be disclosed verbatim.

The new material explores:

• explanation projection
• operator-safe reason information
• internal versus public detail
• structured explanation models
• decision provenance
• avoiding accidental disclosure of sensitive internal state

The goal is explainability without weakening the underlying trust boundary.

---

Adaptive Risk, Context Freshness, and Drift

A decision that was valid when issued may no longer be safe when execution occurs.

This material examines governance as a time-sensitive process in which:

Valid earlier
    ≠
Automatically valid now

Topics include:

• authoritative-context freshness
• policy drift
• risk changes
• resource changes
• freshness windows
• execution-time re-evaluation
• revocation
• stale authority
• fail-closed behavior when required facts can no longer be established

---

Durable Decision Ledgers and Cryptographic Audit Chains

Introduces a deeper treatment of durable governance evidence.

The material explores:

• canonical record encoding
• deterministic fingerprints
• chained decision records
• sequence validation
• checkpoints
• resumed verification
• broken-link detection
• verification confidence
• evidence continuity

The documentation deliberately distinguishes tamper-evident structures from stronger claims such as absolute immutability or guaranteed non-repudiation.

New Executable Advanced Samples

Version 0.12.0 adds runnable companion projects for the advanced material:

• cross-system-capability-exchange
• federated-governance-coordination
• distributed-acknowledgment-continuation
• decision-explainability
• adaptive-risk-context
• durable-decision-ledger-audit-chain

Each sample remains intentionally small enough to expose the architectural boundary being taught.

The learning pattern continues to be:

Concept
   ↓
Runnable Sample
   ↓
Observable Boundary
   ↓
Invariant Test

The examples are teaching systems, not production distributed-governance infrastructure.

New Hands-On Lab

Compare Competing Policy Architectures

Adds a new lab centered on architectural comparison rather than implementation of a predetermined pattern.

Learners evaluate competing approaches based on concerns such as:

• policy ownership
• enforcement location
• independent authority
• policy distribution
• availability
• freshness
• failure behavior
• operational complexity
• evidence requirements

The lab reinforces an established Learning principle:

Use the smallest architecture that preserves the boundaries you actually need.

New Practitioner Articles

When ASP.NET Core Authorization Is Not Enough

This new standalone article provides a decision guide for determining when ordinary ASP.NET Core authorization is sufficient and when a broader governed-execution workflow may be warranted.

It distinguishes ordinary authorization from concerns such as:

• acknowledgment
• delayed continuation
• policy re-evaluation
• scoped execution authority
• policy provenance
• execution-time context
• host-owned consequential side effects

ASP.NET Core authorization remains the preferred solution when it already models the required trust boundary.

---

Why an AI Tool Call Is a Proposal, Not Authority

This article expands one of the repository's central AI integration principles:

The model may propose. The host retains execution authority.

A syntactically valid tool call is not treated as permission to perform a side effect.

The host remains responsible for:

• tool registration and allowlisting
• schema and semantic validation
• authoritative resource identity
• caller context
• policy evaluation
• credential custody
• concurrency checks
• admission and rate controls
• retry and idempotency behavior
• final execution
• safe disclosure of failures

The core testing invariant remains:

Rejected or denied proposal
        ↓
Protected executor invocation count = 0

The article also distinguishes this from concurrency cases where an executor may legitimately be invoked but a conditional write refuses the final mutation.

Improved Executable Sample Discovery

The Executable Samples documentation has been substantially expanded to reflect the actual size of the sample suite.

The published experience now includes:

• a complete sample catalog
• architectural grouping of samples
• dedicated docs/samples/toc.yml navigation
• direct sample README links
• run and test commands
• links to related tutorials, labs, articles, and architecture material
• left-hand navigation for individual samples
• simplified breadcrumb behavior on the samples landing page

Samples are grouped broadly into areas such as:

• Foundational
• Governance and Policy Architecture
• Security and Trust Architecture
• ASP.NET Core Architecture

This makes the executable material easier to browse as a learning catalog rather than requiring readers to discover projects directly from the repository tree.

Roadmap and Navigation Updates

Version 0.12.0 refreshes:

• ROADMAP.md
• Advanced navigation
• Articles navigation
• Labs navigation
• Executable Samples navigation
• article backlog status
• related cross-references throughout the Learning material

These changes reflect the growing maturity of the repository and its movement from foundational governed-execution concepts toward distributed and time-sensitive governance problems.

Publication and Archival Metadata

Release metadata has been synchronized for the new educational snapshot:

• CITATION.cff → 0.12.0
• .zenodo.json → 0.12.0
• release date → 2026-08-28

This keeps GitHub release identity, citation metadata, and archival metadata aligned.

What v0.12.0 Represents

Earlier releases established the core governed-execution model:

Intent
   ↓
Authoritative Context
   ↓
Policy Decision
   ↓
Acknowledgment when required
   ↓
Scoped Authority
   ↓
Host-Owned Execution
   ↓
Evidence

Version 0.12.0 asks what happens when those boundaries become distributed:

Authority crosses systems
        ↓
Independent authorities coordinate
        ↓
Acknowledgment survives continuation
        ↓
Context changes over time
        ↓
Humans need understandable explanations
        ↓
Evidence must remain verifiable

This is the repository's strongest step yet into advanced governance architecture.

Release Scope

ASI Backbone Learning v0.12.0 remains an educational and architectural release.

It does not introduce:

• a production governance engine
• an interoperability or delegated-authorization standard
• a security certification
• a compliance guarantee
• an immutable-ledger guarantee
• an autonomous-agent runtime
• an AI model
• an AGI or ASI implementation

The executable projects are intentionally constrained teaching artifacts designed to make architectural boun...

Release 0.11.0

ASI Backbone Learning v0.11.0 is a substantial educational release focused on deepening the practical governed-execution curriculum.

This release expands the repository with new architecture case studies, a hands-on decision-pipeline refactoring lab and runnable sample, and a standalone practitioner article on proving that blocked operations never execute.

Highlights

New architecture case studies

v0.11.0 adds five substantial case studies that apply existing Learning concepts to fuller real-world scenarios:

• AI-Assisted API and Governed Tool Gateway
• Capability-Scoped Background Operation
• Human Acknowledgment Workflow
• Multi-Tenant and Regional Policy Overlay
• Simulated Robotics Command Governance Boundary

These case studies extend the repository beyond isolated patterns and into complete architectural reasoning around trust boundaries, continuation, scoped authority, policy overlays, execution ownership, and evidence.

New decision-pipeline refactoring lab

Adds the intermediate lab:

Refactor Scattered Governance Checks into an Explicit Decision Pipeline

The exercise begins with a deliberately flawed account.disable workflow where governance checks and side effects are distributed throughout the operation.

Learners refactor it toward an explicit sequence:

Intent
   ↓
Authoritative Context
   ↓
Decision
   ↓
Continuation Requirements
   ↓
Protected Executor
   ↓
Evidence

The core invariant is:

Blocked or incomplete outcome
        ↓
Protected execution = 0

New runnable sample and invariant tests

Adds the decision-pipeline-refactoring executable sample and xUnit test project.

The sample demonstrates:

• authoritative context construction;
• explicit decision outcomes;
• acknowledgment and escalation paths;
• a narrow protected executor;
• decision evidence;
• deliberately scattered governance as a starting point;
• zero-execution assertions for blocked outcomes.

Focused tests verify that:

• Denied never reaches execution;
• Deferred never reaches execution;
• AcknowledgmentRequired never reaches execution without satisfied continuation;
• EscalationRecommended never reaches execution;
• Allowed results in exactly one protected execution attempt.

New standalone technical article

Publishes:

How to Test That a Denied Operation Never Executes

The article addresses a common testing gap:

Assert.Equal(DecisionOutcome.Denied, decision.Outcome);

proves that the application returned a denial, but does not prove that protected work did not already occur.

The stronger invariant is:

Assert.Equal(DecisionOutcome.Denied, decision.Outcome);
Assert.Empty(executor.AccountIds);

The article covers:

• decision-result testing versus execution-invariant testing;
• recording fakes and mock verification;
• repository, external API, and event-publication boundaries;
• hidden pre-decision side effects;
• cancellation and asynchronous hazards;
• retries, concurrency, and race conditions;
• time-of-check/time-of-use concerns;
• acknowledgment continuation and re-evaluation;
• transactional side effects;
• compensation versus prevention;
• idempotency considerations;
• architecture enforcement and mutation testing;
• when ordinary authorization tests are sufficient.

The article is available through the normal Articles surface and RSS publication pipeline.

Roadmap updates

The roadmap has been refreshed to reflect the newly established material, including completion of the decision-pipeline refactoring objective and updated near-term priorities.

Publication and archival metadata

The release metadata has been synchronized for the new educational snapshot:

• CITATION.cff → 0.11.0
• .zenodo.json → 0.11.0
• Release date → 2026-08-26

This keeps GitHub, citation, and Zenodo release identity aligned.

Release scope

ASI Backbone Learning v0.11.0 remains an educational and architectural release.

It does not introduce a runtime compatibility line, production governance engine, AGI/ASI implementation, compliance guarantee, or security certification.

The release continues the project's core goal:

Teach architectural reasoning through patterns, examples, executable samples, labs, case studies, and practical tests.

Release 0.10.0

Release 0.10.0 expands the Learning repository with its first substantial set of Reference Architecture Case Studies, improves documentation discoverability, and refines the DocFX navigation experience.

Highlights

Reference Architecture Case Studies

A new case-study learning area now shows how multiple governance, security, authorization, evidence, and execution boundaries interact inside realistic—but simulated—systems.

This release adds:

• Governed Administrative Operation

  • follows a fictional account.disable operation
  • separates standing authorization, policy evaluation, acknowledgment, scoped execution authority, and host-owned execution
  • covers policy/resource drift, replay resistance, idempotency, correlated evidence, and partial failure

• Sensitive-Data Access Decision

  • compares ordinary resource authorization with a governed records.export operation
  • covers tenant boundaries, data classification, purpose and destination approval, acknowledgment, escalation, and short-lived export authority
  • emphasizes data minimization and keeping protected payloads out of governance evidence and operational logs

• Deployment Approval and Infrastructure Change Gates

  • examines application deployment and infrastructure automation as related but distinct governed workflows
  • distinguishes CI success, human approval, policy decisions, credentials, and execution authority
  • covers plan-versus-apply, environment-specific policy, approval expiry, separation of duties, stale-plan detection, rollback responsibility, and synthetic executors

Across the case studies, the recurring invariant remains:

No valid current decision
        or
No valid scoped execution authority
        ↓
Protected executor is not invoked

Discoverability Improvements

Release 0.10.0 strengthens how published Learning material is found and indexed.

• Adds automated XML sitemap generation and validation
• Generates canonical public URLs directly from the built DocFX site
• Adds source-history-based <lastmod> values
• Validates representative published pages and sitemap integrity
• Adds IndexNow support for incremental search-engine notification
• Publishes and validates the IndexNow verification key
• Tracks the last successfully deployed revision so notifications reflect actual published changes
• Keeps external IndexNow failures non-blocking for otherwise successful Pages deployments

Stronger Internal Linking

Standalone problem-oriented articles now connect more naturally into deeper Learning material.

Improvements include:

• clearer contextual links from articles into tutorials, architecture guidance, samples, labs, and security material
• reciprocal links where they genuinely help readers
• contribution guidance for keeping internal linking useful rather than turning it into boilerplate

Standalone Article Backlog

A new problem-oriented article backlog establishes prioritized future publication opportunities based on recognizable practitioner questions rather than project-specific terminology.

The backlog includes:

• ten candidate standalone articles
• four initial high-priority topics
• proposed permanent publication paths
• supporting Learning material
• guidance for promoting article ideas into implementation issues

Navigation Improvements

The DocFX top navigation has been simplified using the modern template's native dropdown support.

The previous flat menu is now organized around:

Home

Learn
  Getting Started
  Articles
  Tutorials

Architecture
  Architecture Overview
  Governance
  ASP.NET Core
  Security
  AI Integration

Practice
  Executable Samples
  Labs
  Reference Architecture Case Studies

Advanced

This reduces header crowding while preserving access to all existing Learning areas.

Documentation Fixes

• Repairs Mermaid sequence diagrams in the governed administrative and sensitive-data case studies
• Improves case-study publication and metadata validation
• Extends sitemap and IndexNow coverage to the new case-study section
• Keeps citation and Zenodo metadata synchronized for the 0.10.0 archival release

Release 0.9.0

Version 0.9.0 substantially expands the Architecture learning surface with a new series of practical comparisons showing how governed execution relates to established authorization, infrastructure, workflow, policy, agent, audit, and application-architecture patterns.

The central theme of this release is architectural boundary clarity: use the smallest mechanism that correctly represents the authority, trust, lifecycle, and execution boundary the application actually needs.

Highlights

Seven New Architecture Comparisons

This release adds seven substantial Alternative Pattern articles:

• Role-Based, Claims-Based, and Capability-Based Authorization

  • Separates standing authority from scoped continuation authority.
  • Explains when ordinary roles or claims are sufficient and when short-lived capabilities provide a clearer execution boundary.

• API Gateways, Service Meshes, Zero Trust, and Governed Execution

  • Distinguishes transport controls, workload identity, zero-trust verification, application policy, and execution ownership.
  • Shows how these layers can complement rather than replace one another.

• Workflow Engines, Human Approval Systems, and Governed Execution

  • Separates orchestration, approval, acknowledgment, governance decisions, and execution authority.
  • Includes AI-originated actions requiring acknowledgment, policy evaluation, and narrowly scoped host-owned execution authority.

• Policy Engines, Rules Engines, and Distributed Policy Enforcement

  • Distinguishes domain rules, policy decision points, policy enforcement points, and broader governance lifecycle responsibilities.
  • Covers policy distribution, freshness, caching, degraded operation, revocation, and distributed enforcement.

• Agent and Tool Authorization Models and Host-Owned Execution

  • Examines tool registration, model-visible tools, authorization, capability-scoped execution, credentials, and execution ownership.

  • Reinforces the core boundary:

  The model may propose. The host retains execution authority.

• Event Sourcing, Audit Trails, and Governance Decision Provenance

  • Separates operational logging, traditional audit history, event-sourced state, and governance decision evidence.
  • Explains why an event log does not automatically provide governance provenance—and why durable decision evidence does not require event sourcing.

• CQRS, Command/Query Separation, and Governed Execution

  • Shows where command handlers naturally serve as execution boundaries and where additional governance separation is justified.
  • Covers delayed execution, scoped authority, retries, idempotency, concurrency, and mediator pipelines.

Together, these additions bring the Architecture roadmap to nine published alternative-pattern comparisons.

Architectural Guidance

Across the new material, v0.9.0 reinforces several recurring principles:

• Canonical does not mean universal.
• Prefer ordinary authorization, workflow, infrastructure, or application patterns when they already satisfy the requirement.
• Introduce a separate governance boundary only when it protects a real distinction in policy ownership, authority, acknowledgment, delay, provenance, or execution.
• Authentication is not approval.
• Approval is not automatically transferable execution authority.
• Infrastructure identity and transport security are not substitutes for application-level policy decisions.
• Durable governance evidence and application state history are different concerns.
• AI and agent frameworks may propose actions, but consequential side effects remain owned by the host execution boundary.

Navigation and Cross-References

Architecture, Governance, and AI Integration navigation have been expanded to make the new comparisons easier to discover and to connect them with the existing Learning material.

ROADMAP.md has also been updated as each Alternative Pattern topic was completed.

Learning Brand Refresh

Version 0.9.0 also strengthens the repository's visual identity:

• Adds the established Learning social image to the repository README.
• Replaces the site icon with a Learning-specific connected-node/open-book design.
• Adds a matching multi-resolution favicon.
• Adds a dedicated 1280×640 GitHub social-preview asset.

These changes distinguish Learning visually from the main ASI Backbone repository while keeping the broader organization identity consistent.

Release Metadata

• Updates CITATION.cff to version 0.9.0.
• Sets the citation release date to 2026-08-24.
• Updates .zenodo.json to version 0.9.0.
• Keeps GitHub citation and Zenodo archival metadata synchronized.

Scope

This release is primarily an architecture education and documentation release. It does not introduce runtime changes to ASI Backbone packages or alter the behavior of executable Learning samples.

Upgrade Notes

No migration or compatibility work is required.

Users of v0.8.0 can move directly to v0.9.0 and use the expanded Architecture material as additional guidance for selecting, composing, or deliberately avoiding governance boundaries in real systems.

Release 0.8.0

Release 0.8.0 expands ASI Backbone Learning beyond its established tutorial and architecture curriculum with stronger publishing, observability, simulation, community, and repository-quality capabilities.

The release continues to emphasize explicit authority boundaries, host-owned execution, narrow architectural claims, practical .NET examples, and educational material that remains useful without requiring adoption of the AsiBackbone framework.

Highlights

Technical Articles and Publishing

Introduces a dedicated standalone technical-article surface under docs/articles/ with intentionally stable URLs and a publication model distinct from curriculum tutorials.

The first published articles are:

• Your Authorization Check Runs Too Late
• A Green CI Badge Does Not Prove Your .NET Package Is Trustworthy

The publishing surface is designed for direct linking, search, RSS consumption, citation, and external sharing without requiring prior familiarity with the Learning curriculum.

RSS and Discovery Improvements

Strengthens article and feed discovery with:

• RSS channel and item metadata improvements.
• Dedicated 144×144 feed identity imagery.
• 1200×630 article/social preview imagery.
• Open Graph metadata.
• X/Twitter large-image card metadata.
• RSS autodiscovery validation.
• Explicit article publication and update metadata.
• Additional feed-generation self-tests.

These changes make the publication surface more robust for readers arriving through search engines, feed readers, social links, and external references.

AI Governance Observability

Adds AI Governance Observability and End-to-End Decision Tracing, along with executable sample support.

The new material demonstrates tracing across:

AI/tool proposal
      ↓
Schema and proposal validation
      ↓
Host-built policy context
      ↓
Governance decision
      ↓
Acknowledgment / re-evaluation
      ↓
Scoped capability
      ↓
Host-owned execution
      ↓
Operational result
      ↓
Audit residue

The architecture preserves an important boundary:

Telemetry records what happened. Telemetry does not authorize what may happen.

The accompanying observability tests also received correlation-ID isolation so concurrent scenarios cannot contaminate one another's traces.

Policy Simulation Harness

Adds a deterministic policy simulation harness and focused tests.

The sample allows learners to evaluate synthetic policy scenarios across changes in:

• region;
• tenant;
• risk level;
• environment;
• policy version.

Simulation produces structured decision evidence without invoking a protected executor.

The core boundary remains:

Policy simulation evaluates what the decision would be. Policy simulation does not execute the governed operation.

Learning-Path and Assessment Improvements

Improves the educational experience with:

• a visual Learning Path Map;
• problem-oriented navigation;
• learner self-assessment guidance;
• reusable lab acceptance criteria;
• a lab acceptance-criteria template;
• clearer distinction between architectural understanding and merely running a program successfully.

The repository now more explicitly helps learners answer both:

Does the program run?

and:

Does the program preserve the architectural invariant the exercise was intended to teach?

Canonical Architecture Glossary

Adds a centralized architecture terminology glossary covering concepts such as:

• proposed intent;
• policy context;
• policy evaluation;
• explicit decision outcomes;
• acknowledgment;
• escalation;
• audit residue;
• decision provenance;
• scoped capabilities;
• execution authority;
• host-owned execution;
• AI tool proposals;
• trust boundaries;
• architectural invariants.

The glossary also reinforces distinctions such as:

Allow decision ≠ execution
Acknowledgment ≠ authorization
Tool proposal ≠ tool invocation
Scoped capability ≠ token format
Audit residue ≠ tamper-proof evidence

GitHub Discussions

Adds repository-level GitHub Discussions support with structured forms for:

• Q&A;
• Architecture & Patterns;
• Tutorial Ideas;
• Show and tell.

Contributor guidance now distinguishes clearly between exploratory discussion and concrete repository work while retaining organization-level Discussions for cross-repository topics.

Repository Security and Maintenance

Adds proportionate repository-maintenance controls including:

• Dependabot dependency updates.
• GitHub Actions dependency updates.
• CodeQL scanning for the C#/.NET executable surface.
• Expanded software supply-chain guidance.
• Additional documentation around the limits of CI, provenance, dependency controls, and security tooling.

These controls are presented as useful evidence and maintenance mechanisms, not as proof of security or trustworthiness.

Documentation and Architecture Quality

Release 0.8.0 also includes a broad quality pass across the Learning corpus, including:

• clearer architectural-status labels;
• stronger “when not to use this” guidance;
• improved ADR cross-references;
• refined advanced-content positioning;
• tighter README progressive disclosure;
• improved contributor guidance;
• expanded DocFX metadata validation;
• publication and template-maintenance improvements.

Release Metadata

This release updates:

• CITATION.cff
• .zenodo.json

to identify the repository as version 0.8.0, released 2026-08-23.

Scope

ASI Backbone Learning remains an educational and architectural resource.

It does not provide:

• compliance certification;
• a security guarantee;
• legal or regulatory approval;
• an AGI or ASI implementation;
• a robotics controller;
• a universally prescribed application architecture.

The material is intended to help developers examine architectural boundaries, compare patterns, test assumptions, and connect conceptual reasoning to runnable .NET examples.

Release 0.7.0

Version 0.7.0 expands the repository's AI Integration curriculum, improves problem-oriented navigation, consolidates repeated long-form architecture material, and strengthens maintenance controls around the customized DocFX site template.

This release completes the current Milestone 9 — Expanded AI Integration scope while preserving the repository's central architectural boundary:

The model may propose. The host retains execution authority.

Expanded AI Integration

Governed Multi-Tool Workflows and Recovery Boundaries

New advanced material extends the single-tool governance model into multi-step AI-assisted workflows.

Topics include:

• Whole-plan validation versus per-step authorization.
• Step-scoped policy evaluation and execution authority.
• Policy and resource drift between steps.
• Partial success and partial failure.
• Idempotency and replay considerations.
• Compensation and cancellation.
• Bounded replanning and recovery.
• Human escalation.
• Prevention of privilege accumulation across workflow steps.

A key invariant remains:

Step N is allowed
      ≠
Authority for Step N+1

AI Proposal Rejection, Uncertainty, and Recovery Patterns

A new focused architecture explanation addresses what happens when an AI-generated proposal cannot safely proceed.

The material distinguishes:

Invalid model output
        ≠
Valid proposal rejected by policy

and:

Low confidence
        ≠
No authority

It covers:

• Parse and schema failures.
• Unknown tools and invalid arguments.
• Host-authoritative context conflicts.
• Low-confidence and unavailable signals.
• Policy denial and acknowledgment outcomes.
• Infrastructure failures.
• Stable rejection reason codes.
• Safe model-visible feedback.
• Retry budgets and loop detection.
• Replanning, escalation, and terminal states.

The guidance explicitly rejects "retry until something passes" as a governance strategy.

Agent Memory and Governance Boundaries

This release adds a dedicated treatment of persistent and reusable AI memory.

The central lesson is:

Memory may inform a future proposal, but remembered information does not become authority merely because the system retained it.

The material covers:

• Session, workflow, and persistent memory.
• User-, host-, tool-, model-, and externally derived memory.
• Provenance and source identity.
• Freshness, expiration, retention, and deletion.
• User, tenant, workflow, and agent scope.
• Cross-agent memory sharing.
• Memory write and read policy.
• Host validation before persistence.
• Bounded retrieval.
• Sensitive-data minimization.
• Memory poisoning and persistent prompt injection.
• Stale and conflicting remembered facts.
• Audit evidence for consequential memory use.

Important distinctions include:

Remembered information
        ≠
Authoritative current fact

Prior decision
        ≠
Current decision

Prior approval
        ≠
Standing permission

Memory
        ≠
Capability

Memory
        ≠
Audit record

Memory
        ≠
Credential

The article also keeps stateless and session-only designs explicitly valid where persistent memory is unnecessary.

Milestone 9 Complete

With multi-tool workflows, bounded proposal recovery, uncertainty handling, and agent-memory governance now covered, the current Expanded AI Integration milestone is complete.

The established AI Integration path now includes:

• Typed AI-proposed intent and schema-validation boundaries.
• Host-authoritative context reconstruction.
• Deterministic and probabilistic policy inputs.
• Governed multi-tool workflows.
• Proposal rejection and bounded recovery.
• Agent memory and governance boundaries.
• Experimental multi-agent execution boundaries.
• Scoped host-owned execution.

Future work can now focus more heavily on executable companions, labs, threat-model exercises, architectural comparisons, and refinement of the established curriculum rather than filling foundational AI Integration gaps.

Problem-Oriented Learning Paths

A new Find Your Path page provides an alternative to reading the repository sequentially.

Readers can now begin from common architecture problems such as:

• Seeing the core decision-before-execution boundary quickly.
• Determining whether ASP.NET Core authorization is already sufficient.
• Governing a consequential administrative operation.
• Governing AI-proposed tool execution.
• Reasoning about trust boundaries and operational security.
• Preserving architectural decisions with ADRs.

Each route points to existing canonical tutorials, samples, labs, and simpler alternatives rather than creating a duplicate curriculum.

Editorial Consolidation

Selected Governance and Security material received a focused editorial pass to reduce repeated explanations while preserving architectural depth.

The consolidation improves information density around:

• Human-review boundaries.
• Escalation concepts.
• Risk-based governance.
• Deterministic and probabilistic policy inputs.
• Secret handling and secure logging.
• Threat-modeling comparisons.

Canonical cross-links are preferred where a concept already has a dedicated treatment.

DocFX Template Maintenance

The documentation platform now has explicit protection against drift between the pinned DocFX version and the repository's customized modern _master.tmpl.

The release adds:

• Machine-readable DocFX template baseline metadata.
• A template-baseline validation tool.
• CI and publishing validation for the baseline.
• A documented DocFX upgrade and synchronization procedure.
• Guidance to reconsider whether the full template override remains necessary during future DocFX upgrades.

This turns a previously documented maintenance obligation into a visible, reviewable validation step without introducing remote-template downloads into CI.

Documentation and Navigation

Navigation and cross-linking have been updated throughout the AI Integration and foundational material so the new articles are discoverable from their related architectural boundaries.

The repository continues to favor:

Depth before breadth.

New material is intended to strengthen established learning paths rather than create disconnected documentation.

Release Metadata

The release updates:

• CITATION.cff
• .zenodo.json

for version 0.7.0.

Scope

ASI Backbone Learning remains an educational architecture resource.

It provides tutorials, labs, samples, architectural comparisons, and working-reference links. It does not represent:

• A compliance certification.
• A security guarantee.
• A legal or regulatory standard.
• An AI model.
• An autonomous-agent platform.
• An AGI or ASI implementation.

Its purpose remains:

Teach architectural reasoning through patterns, examples, executable boundaries, tradeoffs, and working references.