CanineCC/unfold.canine.dev

Unfold is a SaaS platform that generates deterministic .NET solutions using Domain-Driven Design and Vertical Slice Architecture. It guides users through a workflow of describing business logic, classifying invariants, and visualizing domain models on an interactive board before producing buildable code. The system integrates with GitHub to push generated repositories and employs local LLMs to fill implementation stubs while enforcing architectural rules via static analyzers.

A new AppHost project has been introduced to streamline local development by orchestrating the Unfold.Web application alongside a Keycloak identity provider container. This setup enables a one-command startup experience, automatically configuring the Keycloak container (version 26.2) with a development realm, binding it to localhost:8080, and wiring the Unfold.Web service to use it for authentication. The AppHost also includes an Aspire Dashboard for observability and handles secret substitution for GitHub OAuth credentials during local runs, though it is explicitly noted as a development-only tool not included in production deployments.

src/Unfold.AppHost · high confidence

The generator now runs in-process within the web application, eliminating the need for a separate CLI process. It produces a complete, build-green .NET solution that includes an optional admin back-office interface for managing bounded contexts. The system features an iterative 'fill' workflow where an AI model implements code stubs, followed by automated verification using compiler checks and generated unit tests. Additionally, the generator now emits a static OpenAPI contract for headless API access, manages opt-in architectural decision records (ADRs) with corresponding source analyzers, and tracks design decisions to ensure regeneration is safe and drift-aware.

src/Unfold.Generator · high confidence

The web application now presents a structured user journey: a public Home page introduces the service, while the /app landing page is protected by an authentication policy, requiring users to sign in via GitHub to proceed. New interactive pages include /describe for the initial business description and interview, /board for an infinite-canvas view of the generated project model where users can add and edit items, and /login for GitHub authentication. The /app page is explicitly gated to challenge anonymous visitors to sign in, ensuring that the core interactive features (project listing, board editing, and repo push) are accessible only to authenticated users, while public-facing pages like Home and Describe remain open.

src/Unfold.Web/Components/Pages · high confidence

This change adds a proof-of-concept harness in \PoCs/poc1-scoped-codegen\ that generates a tightly scoped prompt for an LLM to implement a specific event-sourced aggregate (the \Subscription\ lifecycle). The harness reads a \slice-graph.json\ definition to construct a prompt containing only the relevant frozen scaffold, domain rules (DDR/ADR), and BDD scenarios, then sends it to a local Qwen3.6-35B model via vLLM to fill in the missing method bodies. It includes the necessary C\# domain primitives, the frozen aggregate scaffold with \MODEL\_FILL\ stubs, and a Reqnroll-based test suite to verify the generated code against the acceptance criteria.

PoCs/poc1-scoped-codegen · high confidence

The GitHub App integration now supports discovering and selecting repositories across multiple connected accounts (organizations and user accounts). It uses a user OAuth token to discover installations and list repositories, ensuring that installation tokens are minted using the App JWT and scoped specifically to the selected repositories, adhering to least-privilege principles. This allows users to see and pick repos from every connected account and create new repositories within chosen organizations.

PoCs/github-app-api · high confidence

The web application now uses a new Blazor-based frontend structure. This change introduces the main application layout (App.razor) which sets up the HTML head, loads theme and board JavaScript assets, and applies the Fjeld design system styles. It also adds the core routing configuration (Routes.razor) to handle navigation and layout wrapping, along with global imports (\_Imports.razor) for necessary Blazor and authorization namespaces.

src/Unfold.Web/Components · high confidence

This change introduces three new static-analysis rules to the Unfold analyzer suite. The CQRS analyzer (UF0004A) requires that all command and query messages be declared as immutable records (reference records or readonly record structs) with no settable properties, preventing mutable state leakage across the application boundary. The cross-bounded-context analyzer (UF0099A) enforces architectural isolation by flagging direct type references between different bounded contexts' internal layers (Domain, Application, Infrastructure), requiring integration to occur exclusively through the target context's .Contracts surface or via exemption attributes. Additionally, the common analyzer infrastructure now includes a test harness for golden-compilation testing and shared utilities for parsing bounded-context namespaces and resolving Guid invocations, supporting these and future domain-purity rules.

src/Analyzers · high confidence

The Unfold.Web project introduces a Blazor Interactive Server application that serves as the new SaaS product surface. It exposes a headless HTTP API (/api/board, /generate, /classify, /edit) that reuses existing core logic for generating codebases and classifying requirements, replacing the previous CLI-only workflow. The application enforces GitHub sign-in (via OAuth or Keycloak identity broker) for all /api and /app endpoints, ensuring that generated code is pushed to the user's own repository. It also includes OpenTelemetry observability, background job processing for long-running builds, and resilience handlers for external service calls.

src/Unfold.Web · high confidence

Unfold.Core now includes three new rendering and analysis components that expand the system's output and visualization. The AreaProposer introduces a deterministic, rule-based engine that partitions a single bounded context into multiple areas (bounded contexts) based on structural evidence like shared references and vocabulary, while also providing a 'Collapse' function to merge them back into a single area. The BddRenderer generates executable Reqnroll/Gherkin feature files and corresponding C\# step bindings for capacity guards and creation slices, ensuring that feature text and step patterns bind unambiguously to prevent test drift. Finally, the BoardRenderer and BoardLayouter provide an interactive, spatial EventStorming board visualization; this includes a change-highlighting system (BoardDiff) that visually distinguishes new, modified, and removed domain elements by comparing the current model against a previous baseline, supporting pan/zoom interactions via absolute coordinate layout.

src/Unfold.Core · high confidence

The \PoCs/register-eval\ directory now includes a new \eval.cs\ script and a corpus of 10 test cases (including Continuum and eight blind-authored scenarios) to measure the extraction engine's capability and reliability. This scorecard drives \Classifier.ClassifyAsync\ (and the double-pass \ClassifyUnionAsync\) over engine-register prose, reporting metrics for thing recall, property coverage, rule-capture recall, and action recall. It runs multiple iterations per case to distinguish best-case capability from worst-case reliability, providing a transparent baseline for the extraction system's performance on principle-dialect rules and obliquely-stated properties.

PoCs/register-eval · high confidence

This change adds a new proof-of-concept harness in \PoCs/poc2-failure-hunt\ designed to stress-test code generation by intentionally targeting failure modes. It introduces a \run.sh\ script and Python helpers (\assemble.py\, \fill.py\) that implement a regenerate-on-fail loop, feeding compiler errors and test failures back to the model to drive convergence. The harness includes a ticketing domain scaffold (\TicketOrder\, \RefundCalculator\) with frozen signatures and scoped BDD scenarios. Crucially, it adds \SystemInvariantTests\ to verify a cross-aggregate capacity rule that is explicitly excluded from the model's scoped prompt, confirming that locally correct slices can still violate system-level invariants.

PoCs/poc2-failure-hunt · high confidence

This change adds a new proof-of-concept harness in PoCs/poc5-invariant-detection that demonstrates an automated workflow: a Python script (detect.py) classifies business invariants as per-aggregate or cross-aggregate from natural language, and for cross-aggregate rules (like venue capacity limits), it scaffolds a reservation aggregate (SeatInventory) to enforce the invariant locally. The harness includes a build-and-test loop (run.sh) that uses a local LLM to fill the scaffolded code and verifies the result with system-level BDD scenarios (Capacity.feature) ensuring overbooking is rejected. The entry also includes a README that corrects previous overclaims, noting this PoC proves the pattern works in isolation but does not yet wire end-to-end order confirmation.

PoCs/poc5-invariant-detection · high confidence

This change adds a new proof-of-concept (PoC \#6) that demonstrates atomic, cross-aggregate coordination to prevent overbooking. It introduces a \ConfirmOrderHandler\ that enforces venue matching and ensures seat reservation happens before order confirmation, so that if a reservation fails (e.g., due to capacity limits), the order remains pending and the inventory is unchanged. The entry includes the domain aggregates (\TicketOrder\, \SeatInventory\), the application handler, and a comprehensive test suite (BDD scenarios and unit tests) that verifies this atomic behavior, including rehydration from event streams and venue isolation.

PoCs/poc6-end-to-end · high confidence

This change adds a proof-of-concept demonstrating that concurrency, idempotency, and rehydration can be handled by a frozen, opinionated framework rather than the domain model. The \SeatInventory\ aggregate in \src/PoC7/Domain\ is kept simple and concurrency-naive, while \src/PoC7/Infrastructure\ provides an \OptimisticRepository\ that enforces optimistic concurrency control (version-checked appends with retry) and an \IdempotentReserveHandler\ that deduplicates requests. Tests in \tests/PoC7.Tests\ verify that the same domain logic safely prevents overbooking under concurrent access when using the optimistic repository, whereas a naive repository fails, proving the safety is a framework property.

PoCs/poc7-concurrency-persistence · high confidence

A new proof-of-concept script in the PoCs/fill-step directory demonstrates an end-to-end workflow where a solution skeleton is generated with placeholder markers, and a real local AI model (via vLLM) is used to implement the logic, verifying that the resulting code compiles and passes generated tests.

PoCs/fill-step · high confidence

The PoCs/enforcement-harness directory now provides a real-world verification suite for the ADR analyzer stack, replacing previous bash-based scripts with a single-file C\# harness (run.cs). This harness generates actual solutions from graph definitions (bookstore, ticketing, messaging, multi) and validates that the enforcement stack works end-to-end: it ensures clean builds produce zero false-positive diagnostics and that deliberate violations trigger the correct project-local ADR diagnostic IDs. Additionally, the PoCs/integration-events-runtime directory introduces a runtime proof for the transactional outbox pattern, verifying that integration events are committed atomically with domain events and correctly cross bounded-context boundaries using a real Postgres database.

PoCs/enforcement-harness · high confidence

A new proof-of-concept harness in the readmodel-runtime location validates that the generated CQRS read side functions correctly against a live Postgres database via Marten. The single-file C\# script (run.cs) orchestrates the generation of read-model code, starts an ephemeral Postgres container, and runs a probe that asserts the inline projection correctly folds events into a denormalized read model and that the generated query handler serves the expected view models. This confirms the architectural seam where the persistence-ignorant write side is paired with a Marten-backed read side.

PoCs/readmodel-runtime · high confidence

The web application now supports a least-privilege GitHub App authentication flow, allowing users to select and push code to specific repositories across multiple connected accounts (personal and organization) using scoped installation tokens. This is enabled by new services that manage access resolution, token caching, and state persistence for interactive Blazor circuits. Additionally, the code generation process has been moved in-process, where the system now generates and compiles the codebase directly on the server to verify it builds successfully before pushing to the user's repository or offering a download.

src/Unfold.Web/Services · high confidence

Added a proof-of-concept harness in PoCs/poc4-invariant-classifier that uses a local 35B model to classify business rules as either 'per-aggregate' (checkable within a single instance and its children) or 'cross-aggregate' (requiring coordination across multiple instances). The classifier is evaluated against a 18-rule multi-domain corpus containing deliberate traps to prevent false positives, achieving 100% accuracy with a strict gate that rejects degenerate baseline models, demonstrating the viability of using local LLMs for this specific architectural decision in the pipeline.

PoCs/poc4-invariant-classifier · high confidence

A new proof-of-concept in PoCs/gating-poc demonstrates a generated state machine that enforces workflow gating rules, including multi-step approval chains (Submit → Check → Approve), four-eyes separation of duties, and event-sourced replay. The included graph definition and proof script verify that illegal state transitions are rejected with domain exceptions and that the system correctly tracks actor history, proving the underlying gating specification compiles and behaves as intended.

PoCs/gating-poc · high confidence

The Event Storming utility in src/Utilities/Unfold.Utilities.EventStorming has been completely removed. The diff shows the deletion of all application, domain, infrastructure, and UI files, including the removal of the Marten event sourcing dependency and the MudBlazor-based UI components. This change eliminates the collaborative event storming session management capability from the product.

src/Utilities/Unfold.Utilities.EventStorming · high confidence

The \Unfold.Services.PromptQueueWorker\ background service has been deleted. This removal eliminates the component responsible for polling PostgreSQL for prompt jobs, rendering Scriban templates, invoking the Ollama LLM, and publishing completion or failure events.

src/Services · high confidence

The Aspire-based development orchestrator for the Unfold system has been removed. This deletes the AppHost project files (Program.cs, launch settings, documentation, and package references), eliminating the automatic provisioning of PostgreSQL and pgAdmin containers, the orchestration of ServiceHost and WebHost, and the local Aspire dashboard for monitoring and observability.

src/Hosts/Unfold.AspireHost · high confidence

The Unfold.ServiceHost project has been removed from the codebase. This change eliminates the background worker infrastructure that previously handled asynchronous processing, such as the PromptQueueWorkerService and PostgreSQL NOTIFY/LISTEN event listening. Additionally, the Marten document database library, which was used for storing prompt queues and conversation events, is no longer referenced by this host.

src/Hosts/Unfold.ServiceHost · high confidence

The debug access and monitoring features within the Unfold.Admin bounded context have been removed, including the DebugAccessService, DebugModeService, DebugSession aggregate, and the SignalR DebugHub used for real-time log streaming. Additionally, the entire Unfold.Focus.How bounded context has been deleted, eliminating the technical architecture conversation engine, its 22 classification-specific templates, quality gates, and the associated service registrations and context providers.

src/BoundedContexts · high confidence

The entire Unfold.Kernel.Core library has been deleted, removing the foundational building blocks for Domain-Driven Design, CQRS, event-driven architecture, and multi-tenancy. This change eliminates core interfaces and types including DDD primitives (Entity, AggregateRoot, ValueObject), CQRS contracts (ICommand, IQuery, and their handlers), event infrastructure (DomainEventDispatcher, IntegrationEventBus), and multi-tenancy support (TenantContext, TenantResolutionMiddleware). It also removes strongly-typed ID structs (AggregateId, UserId, etc.), EF Core conventions and converters, and the EdgeType taxonomy for knowledge graph relationships.

src/Kernel · high confidence

The Dashboard, Event Storming, Home, Login, Onboarding, Onboarding Conversation, and Register Razor pages have been deleted from the application. This removes the previous web-based user interface for authentication, tenant provisioning, and initial product setup, indicating a shift away from this specific web navigation and onboarding model.

src/Hosts/Unfold.WebHost/Components/Pages · high confidence

The Unfold.WebHost project has been completely removed from the codebase. This eliminates the Blazor Server application entry point, the MudBlazor theme configuration, the dependency on the Marten event store, and the associated static assets and configuration files that previously served as the thin glue layer for the web interface.

src/Hosts/Unfold.WebHost · high confidence

The Unfold.AppHost project now explicitly references MessagePack version 2.5.301 to address the [GHSA redacted] vulnerability (LZ4 decompression AccessViolationException), overriding the vulnerable 2.5.192 version previously pulled transitively. Additionally, the solution has removed the centralized package management file (Directory.Packages.props) and deleted the legacy Unfold.Analyzers project, replacing it with a modular structure of individual analyzer projects (e.g., Unfold.Analyzers.Cqrs, Unfold.Analyzers.Determinism) that reference Microsoft.CodeAnalysis.CSharp 4.8.0 directly.

(dependencies) · high confidence

The web interface now uses the Fjeld design system, introducing a consistent visual identity across the application. This includes a new CSS token sheet for colors, typography, and spacing, along with a light/dark theme toggle that defaults to the user's OS preference. The update also brings a unified button and chip component system, updated navigation styling, and the integration of the Canine Development brand assets (badge and wordmark) into the header.

src/Unfold.Web/wwwroot · high confidence

The command-line tool for generating code scaffolds has been updated to use a new internal harness utility (tools/gen.cs) that replaces the previously deleted scaffolder. This change ensures the CLI continues to function by mirroring the original behavior—processing graph specifications and producing decisions and migration files—while utilizing the underlying Unfold.Generator library for verification and corpus generation.

tools · high confidence

The classifier evaluation tooling in PoCs/classify-eval has been ported from Python/bash to a single-file C\# script, introducing a comprehensive safety and accuracy scorecard. The harness now runs an 18-case business-prose corpus and an adversarial red-team suite designed to catch cross-instance rules disguised as self-contained checks, ensuring that dangerous rules are never silently passed as 'clean'. A hardened transport layer now throws on server-side truncation or connection drops rather than degrading to empty results, preventing infrastructure failures from being misinterpreted as model accuracy. Additionally, deterministic fixes for reserved-name collisions (e.g., 'Event') and capacity-guard name clashes (e.g., 'Sailing') have been implemented to improve stability and recall.

PoCs/classify-eval · high confidence

The conversation utility has removed its dependency on the Marten event-store library. This change deletes the \ConversationEngine\ facade, the \ConversationSession\ aggregate, and all associated Marten-specific persistence code, including the \ConversationRepository\ and domain event handlers (e.g., \KnowledgeConfirmedDomainHandler\, \SessionRevertedHandler\). It also removes the entire \Application/EventListeners\ directory, which previously handled integration events for translation, language detection, question evaluation, and prompt completion. The 6-stage parallel extraction pipeline and its Scriban templates have been removed, along with the documentation (\AGENTS.md\) that described the event-sourced architecture.

src/Utilities/Unfold.Utilities.Conversation · high confidence

The generator now produces an in-process admin back-office (AdminPages.cs.scriban) that maps routes for listing, viewing, and modifying domain entities. A key behavioral change is the error handling: if the PostgreSQL database is unreachable, the admin UI displays a user-friendly "Not connected" guidance page with setup instructions instead of returning a raw 500 error. The generated code also includes basic HTML layout, entity-specific pages, and forms for creating and acting on entities, all styled with a provided CSS file.

src/Unfold.Generator/Templates · high confidence

A new proof-of-concept script (run.cs) validates that the Unfold.Generator library can produce a customer's codebase directly within the current process, eliminating the need for a separate scaffolder subprocess. This change confirms that the generator correctly resolves embedded resources—such as Scriban templates, vendored analyzers, and the ADR library—from the application's base directory and that the generated solution builds successfully. It also verifies idempotency, ensuring that a second generation run on the same directory results in no file rewrites.

PoCs/inprocess-gen · high confidence

The application now features an interactive infinite canvas for EventStorming, replacing the previous read-only iframe view with a pan/zoom surface where users can drag to reposition sticky notes, double-click to add new ones, and toggle full-screen mode. Background jobs are no longer obscured by a static loading overlay; instead, a live progress indicator displays the current phase and elapsed time. Additionally, a new shared BrandLockup component standardizes the display of the Unfold logo and the 'by Canine Development' byline across the header, footer, and authentication cards.

src/Unfold.Web/Components/Shared · high confidence

The PoC harness in \PoCs/classify-map\ now executes a complete, in-process pipeline that takes natural language prose, classifies it into a domain graph, validates the result against a deterministic graph gate, and renders a plain-language map. This replaces previous bash-based harnesses with single-file C\# scripts (using \Unfold.PocKit\ for orchestration) to verify that the classifier correctly identifies cross-aggregate rules (such as capacity guards) and that the output remains jargon-free. The entry includes the core \Proc\ helper for process management and sample inputs for theatre, events, and workshops scenarios to demonstrate the end-to-end flow.

PoCs/classify-map · high confidence

The web application now uses a unified MainLayout component that structures the site with a header containing the BrandLockup, navigation links (including 'My projects' and 'Try it'), and a light/dark theme toggle button that respects OS preferences. The footer follows the canine.dev family pattern with copyright, legal links, and contact info. A scoped CSS file handles the Blazor framework error UI styling.

src/Unfold.Web/Components/Layout · high confidence

This change adds a proof-of-concept harness that extracts a domain model from business prose and renders a plain-language reflect-back map. It implements three safeguards to fix a known classifier gap where cross-aggregate rules (like seat uniqueness) were incorrectly tagged as per-aggregate: a boundary-aware topology probe, a monotone override that upgrades per-to-cross only, and a deterministic graph-gate. The PoC demonstrates that these safeguards close the critical gap (5/5 critical cross-tag accuracy, 0 over-flagging) and proves that rule scope is boundary-dependent, requiring explicit aggregate-boundary context for reliable classification.

PoCs/poc8-reflect-back-map · high confidence

The DatabaseInitializer hosted service, which previously managed the creation of database schemas for Identity, Admin, and the Marten event store at application startup, has been removed. This eliminates the automatic schema creation and initialization logic for the Marten document store.

src/Hosts/Unfold.WebHost/Infrastructure · high confidence

The LlmResponseListener hosted service, which previously bridged PostgreSQL NOTIFY events to SignalR clients for real-time LLM responses, has been removed from the web host. This change eliminates the dedicated background thread and event-driven notification channel used to route assistant messages to specific user sessions.

src/Hosts/Unfold.WebHost/Workers · high confidence

The SignalR-based implementation for broadcasting conversation events (such as extraction, validation, and mode changes) to session-scoped groups has been removed from the web host infrastructure. This deletion indicates a shift away from using SignalR hubs for these specific real-time conversation notifications, likely as part of the broader refactoring for the new conversation model.

src/Hosts/Unfold.WebHost/Infrastructure/SignalR · high confidence

The application has removed several legacy Razor components from the layout structure: MainLayout, OnboardingLayout, ConnectionIndicator, and ErrorBoundaryContent. This cleanup eliminates the previous app bar, drawer navigation, and SignalR connection status indicator, as well as the custom error boundary UI that previously displayed a 'Try Again' button on unexpected errors. Users will no longer see these specific UI elements or the associated theme-watching logic in these files, reflecting a shift in how the application's shell and error states are managed.

src/Hosts/Unfold.WebHost/Components/Layout · high confidence

The application no longer uses the previous centralized routing setup or global component imports. Specifically, the \Routes.razor\ file, which configured the Blazor Router with specific additional assemblies and a custom 404 page, has been removed. Additionally, the \\_Imports.razor\ file, which globally imported namespaces like MudBlazor and layout/theme components, has been deleted. This indicates a shift in how routing and shared component dependencies are managed within the web host.

src/Hosts/Unfold.WebHost/Components · high confidence

Users can now sign in through Keycloak as an identity broker, which federates to GitHub and allows the application to retrieve the user's GitHub access token for pushing code. Additionally, the system supports a GitHub App configuration that provides least-privilege, short-lived installation tokens scoped only to the repositories the user selects, narrowing access compared to the previous default of full OAuth repository permissions. The infrastructure also includes codified Keycloak persistence with daily volume backups to ensure data durability.

infra · high confidence

The repository has been refactored from a conversational knowledge-discovery platform into a deterministic golden-path factory that generates DDD + Vertical Slice Architecture solutions. The product surface is now the \Unfold.Web\ Blazor app (replacing the previous \Unfold.WebHost\), which serves as the SaaS interface for describing business logic and downloading generated code. The solution structure is significantly simplified: the previous modular monolith with numerous \BoundedContexts\ (e.g., \Unfold.Focus.\*\) and \Utilities\ has been replaced by three core projects (\Unfold.Core\, \Unfold.Generator\, \Unfold.Web\) and a new \Unfold.AppHost\. The event store implementation has moved from Marten to a custom 'DIY eventstore'. The analyzer library has been expanded and split into multiple specific analyzers (e.g., \Unfold.Analyzers.Cqrs\, \Unfold.Analyzers.Determinism\). Configuration files like \.editorconfig\, \BannedSymbols.txt\, and \Directory.Build.props\ have been removed, and the solution file (\Unfold.slnx\) now reflects the new, flatter project structure.

(repo-wide) · high confidence

Added integration tests for the solution generator; Added validation script for Keycloak broker token parsing; Deterministic unit tests for classification, generation safety, and rendering; End-to-end publish verification for generated codebases; Generator verification harness added; GitHub repository service validation and mock tests; New browser-based e2e smoke tests for the describe-to-board flow; New end-to-end test suite for SaaS API and interactive UI; New offline scope-eval smoke test for the ScopeGate; Removal of Unfold.Tests.Infrastructure test suite; Removed DI validation integration test.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 81 → 82 (+0.8)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 87 → 87 (-0.0)
• Architecture 95 → 93 (-1.3)
• Maturity 91 → 90 (-1.1)
• Readiness 74 → 79 (+5.4)
• Security 83 → 84 (+0.5)
• Domain Modelling 80 (new)
• Event Sourcing 100 (new)
• Accessibility 100 → 100 (+0.0)

• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Hotspot: src/Unfold.Core/WikiRenderer.cs (src/Unfold.Core/WikiRenderer.cs)
• Inconsistent naming convention for test methods: one uses snake_case (Board_change_highlights...) while the other uses sentence case with spaces (Board_without_baseline...).
• No test project references Unfold.AppHost (src/Unfold.AppHost/Unfold.AppHost.csproj)
• Repeated repair: src/Unfold.Core/BddRenderer.cs (src/Unfold.Core/BddRenderer.cs)

• Cross-context type ConfirmPlan (Unfold.Core → Unfold.Web)
• Cross-context type DecisionSpec (Unfold.Core → Unfold.Generator)
• Cross-context type DecisionSpec (Unfold.Core → Unfold.Web)
• Cross-context type DecisionSpec (Unfold.Core → Unfold.Web)
• Cross-context type DecisionSpec (Unfold.Core → Unfold.Web)
• Cross-context type DecisionSpec (Unfold.Core → Unfold.Web)
• Cross-context type InterviewFact (Unfold.Core → Unfold.Web)
• Cross-context type Migration (Unfold.Core → Unfold.Generator)
• Cross-context type ReviewNote (Unfold.Core → Unfold.Web)
• Cross-context type SolutionSpec (Unfold.Core → Unfold.Generator)
• Cross-context type SolutionSpec (Unfold.Core → Unfold.Web)
• Cross-context type SolutionSpec (Unfold.Core → Unfold.Web)
• Cross-context type SolutionSpec (Unfold.Core → Unfold.Web)
• Cross-context type SolutionSpec (Unfold.Core → Unfold.Web)
• Cross-context type SolutionSpec (Unfold.Core → Unfold.Web)
• Cross-context type SolutionSpec (Unfold.Core → Unfold.Web)
• Cross-context type SolutionSpec (Unfold.Core → Unfold.Web)
• Cross-context type SolutionSpec (Unfold.Core → Unfold.Web)
• Cross-context type SolutionSpec (Unfold.Core → Unfold.Web)
• Cross-context type SolutionSpec (Unfold.Core → Unfold.Web)
• …and 18 more

• Unchanged — 7 HTTP endpoints

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

CanineCC/unfold.canine.dev was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.