WillEhrendreich/SageFs

SageFs is a live development environment for F\# that enables interactive code evaluation, hot reloading, and real-time testing within a daemon-based architecture. It provides a rich set of IDE integrations for Visual Studio and VS Code, alongside a web dashboard and terminal interface, to support an iterative workflow where code changes are applied instantly without full restarts. The system also includes infrastructure for multi-agent coordination, formal verification of core components, and automated demo recording.

The extension now exposes an IStatusBarService that allows SDK components to update or clear the Visual Studio status bar text. This is implemented via a MEF-exported StatusBarService that wraps the IVsStatusbar interop, with a static bridge to allow other MEF components to access it without importing the interface directly.

sagefs-vs/SageFs.VisualStudio.Editor/StatusBar · high confidence

A new systemd user unit file (sagefs.service) is provided to run the SageFs daemon as a background service. The unit configures the daemon to start automatically on login, sets the working directory to a dedicated state directory (\~/.local/state/sagefs) to avoid watching the home directory, and ensures the .NET runtime is correctly located via environment variables. Users can install and enable the service by copying the file to \~/.config/systemd/user/ and running systemctl --user enable --now sagefs.

contrib · high confidence

This change introduces a new academic conference paper and its associated bibliography within the formal-verification/paper directory. The LaTeX document details the application of Lean 4 to formally verify the SageFs F\# live development environment, covering 177 theorems across nine core modules (such as the ring buffer, session state machine, and evaluation pipeline) and establishing a central 'evaluation-gate' theorem. The accompanying bibliography provides citations for the referenced tools and related work, including Lean 4, Mathlib, CompCert, and LiquidHaskell.

formal-verification/paper · high confidence

The documentation now includes a generated roadmap page that automatically tracks the status of planned features. Instead of manual updates, each roadmap item defines a 'landmark'—a specific file and symbol in the codebase. The system checks for the presence of these landmarks to automatically mark items as 'Built' or keep them open, ensuring the documentation stays in sync with the code. This change introduces the underlying model and renderer for this self-updating roadmap, along with the initial set of roadmap items covering areas like Hot Reload, Live Testing, and Agents.

scripts/roadmap · high confidence

A new compiled \sagefs-repl-guard\ hook intercepts \dotnet build\, \test\, \run\, and \fsi\ commands in F\# workspaces. When the SageFs daemon is running and a Ready session covers the current directory, the hook denies these commands to prevent memory drift, instructing the agent to use the REPL instead. For necessary final builds, a \SAGEFS\_FINAL\_GATE=1\ environment variable allows the command to proceed only after successfully acquiring an expensive-work lease from the daemon, distinguishing between a busy daemon and a broken one.

tools · high confidence

The Code City visualization feature is now available, introducing a procedural 3D city layout where code metrics (complexity, age, coverage) drive building shapes, colors, and placement. This change adds the core rendering engine (Program.fs) using Raylib and a squarified treemap algorithm for spatial layout, along with a comprehensive test suite (DomainTests.fs) validating the domain logic and geometry calculations.

viz-output · high confidence

Added a new deterministic simulation testing (DST) framework within SageFs.Simulation to verify critical subsystems through replayable, seeded scenarios. The harness includes generators and invariants for build confirmation (ensuring stale results are never applied and builds coalesce correctly), capability management (verifying token scoping, revocation, and expiry), and cohort landing (proving that failing or conflicting landings do not deadlock the serial queue). These simulations allow the system to be tested against chaos data and specific bug twins without external dependencies.

SageFs.Simulation · high confidence

The SageFs.Host project has been extracted as a standalone FSI host process, spawned by the daemon supervisor to run session projects. This host now owns the application lifecycle for \run\_app\, resolving managed dependencies in-process via a custom \AssemblyLoadContext\ resolver to prevent \FileNotFoundException\ for NuGet and project-reference dependencies. It injects a DevReload middleware into the ASP.NET Core pipeline using Harmony patches on \WebApplication.Run\, enabling hot-reload of F\# code changes in the running browser app. The host includes a dedicated delta route (\RunAppDelta\) to apply metadata deltas for live patches, and enforces security by vetting its own startup manifest and gating HTTP routes against cross-site requests.

SageFs.Host · high confidence

The formal-verification/lean directory now contains a complete Lean 4 project scaffold for the 'FVSquad' verification suite. This includes the project configuration (lakefile.toml, lake-manifest.json, lean-toolchain v4.30.0-rc2), a .gitignore for build artifacts, and the main FVSquad.lean module which aggregates imports for various verification components such as RingBuffer, HotReloadState, Theme, PhaseTransition, and TimeTravel.

formal-verification/lean · high confidence

The editor now displays real-time visual feedback directly in the code view. Cell highlighting automatically highlights the current code block as you move the cursor. Inline failure adornments show test failure details (such as expected vs. actual values) at the end of failing lines. Inline eval results display the output of evaluated code blocks with a clear distinction between fresh (active) and outdated (stale) results. Additionally, coverage glyphs appear in the margin to indicate line and branch coverage status.

sagefs-vs/SageFs.VisualStudio.Editor · high confidence

SageFs.Gui now provides a new graphical user interface powered by the Raylib library, offering an alternative to the existing terminal UI. This entry adds the core rendering infrastructure, including a window loop, immediate-mode drawing of the cell grid with box-drawing characters, and a comprehensive key-mapping system that translates Raylib input events into the application's existing editor actions. The GUI supports features such as font loading, theme cycling, density adjustments, and layout configuration, effectively mirroring the capabilities of the TUI in a windowed environment.

SageFs.Gui · high confidence

Adds the SageFs Visual Studio extension, providing a live F\# development environment with real-time test gutter markers, daemon-powered IntelliSense completions, a TypeExplorer tool window, and inline evaluation adornments. The extension initializes by detecting the SageFs daemon port, persisting the connection URL to a local configuration file, and registering core services such as the client, live testing subscriber, and session subscriber within the Visual Studio dependency injection container.

sagefs-vs/SageFs.VisualStudio · high confidence

Added a new IntelliSense provider for the SageFs FSI language that fetches completion items from the backend daemon. The implementation includes a completion source that triggers on explicit invocation, dot characters, or sufficient word length, sending a 2048-character context window to the daemon's /dashboard/completions endpoint with a 3-second timeout. A new mapper translates daemon kind strings (e.g., 'method', 'class') into Visual Studio completion item categories, ensuring correct icon and grouping display for users.

sagefs-vs/SageFs.VisualStudio.Editor/Completions · high confidence

Added SageFs/AgentGuidance.fs to provide MCP clients with structured instructions for the SageFs REPL loop, including a 'back to the REPL' prompt to correct agent drift. Added SageFs/AnsiEmitter.fs, a high-performance terminal renderer using arena buffers and run-length batching to minimize allocations. Added SageFs/CohortLandingVerify.fs to provide a blocking test-run primitive for cohort landing verification, ensuring landing decisions are based on the specific run's results rather than stale state.

SageFs · high confidence

This change adds the foundational modules for the Visual Studio extension, including DaemonManager for discovering and launching the SageFs daemon, DaemonTargetFinder for selecting the best project or solution file to open, and BufferChangeRequest for resolving which daemon session owns a specific document. It also introduces the LiveTesting subsystem (types, parser, subscriber, and glyph projection) to handle real-time test results via SSE, and the EvalService with a watchdog timer to manage code evaluation lifecycles and handle connection drops.

sagefs-vs/SageFs.VisualStudio.Core · high confidence

Added AgentActivityTracker to SageFs.Core, an in-memory, thread-safe module that records tool calls, file access, and intent for connected agents. This replaces the previous noop persistence stub and enables the daemon to detect file-overlap conflicts, manage occupancy cleanup, and provide session guidance based on real-time agent presence. The tracker supports both legacy string-keyed tool calls and new bound member identities, ensuring role classification is derived from connection type rather than name prefixes.

SageFs.Core · high confidence

SageFs now runs F\# code evaluation in a separate, isolated host process rather than in the main daemon. This host is compiled against the user's specific .NET SDK version, ensuring that compiler services and runtime behavior match the project exactly. The change introduces a strict, drift-proof wire protocol (FsiProtocol) to communicate between the daemon and the host, allowing features like live values, completions, diagnostics, and hot-reload to operate safely without the host process conflicting with the user's code or dependencies. The daemon no longer executes user config scripts or holds FCS objects; instead, it sends requests over a loopback socket and receives typed responses, improving stability and preventing hangs from blocked getters.

SageFs.FsiHost · high confidence

Added several new middleware modules to SageFs.Core/Middleware to support hot reload verification, safe code evaluation, and pipeline instrumentation. EntryProbes.fs implements a probe registry and stub generation to verify that patched function bodies are actually executed. GenericReload.fs handles the complex logic of detecting and patching generic method instantiations. ValueReadTracking.fs and ValueReads.fs work together to track module value reads via Harmony patches and IL analysis to determine if immutable values can be safely patched. CompilationContext.fs provides FCS-powered file structure parsing with content-hash caching. EvaluableSubmission.fs prevents sending empty module/namespace headers to FSI by classifying submissions before evaluation. Tracing.fs adds timing and outcome tracking to the evaluation pipeline.

SageFs.Core/Middleware · high confidence

The core now provides a pure \ActionPrioritizer\ module that merges coverage intelligence, impact forecasts, cell staleness, and observed friction signals into a ranked queue of developer actions (such as re-evaluating cells, writing tests for blind spots, or investigating failures) alongside a session health grade. This replaces the previous state where friction signals were detected but not fed into an actionable queue. Additionally, new modules \AffectedTests\ and \BuildConfirmation\ narrow test verification to only those tests affected by code changes using coverage bitmaps, and confirm test results against actual compiler builds to ensure accuracy.

SageFs.Core/Features · high confidence

The demo system now supports multiple, independently driven environments (Dashboard, VS Code, Neovim, App, and Agent) through a new \LiveActor\ dispatch seam. Instead of hard-coding interactions with a single dashboard, the \CellAgent\ now assembles a map of \LiveActor\ instances based on the scenario plan, allowing each actor to manage its own specific interface—such as Playwright for the dashboard, X11/P/Invoke for Neovim and native apps, or a hand-rolled MCP HTTP client for the Agent actor. This change enables complex, multi-window demo recordings where different tools can be observed and controlled simultaneously within the same sandboxed cell.

SageFs.Demos · high confidence

The lemmings harness now includes a new \run-matrix\ tool (LemMatrix) that executes batches of lemming trials defined by a plan file (fixture, task, model, repetitions). This tool manages concurrency, enforces a per-model quota limit to prevent hitting provider limits, and checks for version skew between the lemming's SageFs bridge and the shared daemon. It produces a structured report of outcomes, including skipped runs and unscored failures, providing a more robust way to evaluate models at scale compared to the previous single-run harness.

scripts/lemmings · high confidence

The SageFs Visual Studio extension now includes several new service components to enhance the developer experience. ErrorListBridge and TestDiagnosticsBridge route compiler diagnostics and live test failures directly to the VS Error List. EvalCodeLensProvider and TestCodeLensProvider add inline CodeLens actions, allowing users to evaluate F\# functions/methods or view live test status (pass/fail) directly in the editor. FSharpBufferChangedListener enables live testing by debouncing and sending buffer changes to the SageFs daemon. InfoBarService provides actionable notifications for daemon lifecycle events (start failures, disconnections) via the output channel, and SolutionDirectory correctly resolves the current solution path using the VS Extensibility SDK Workspaces API.

sagefs-vs/SageFs.VisualStudio/Services · high confidence

This change introduces four new Visual Studio tool windows accessible from the Extensions menu, providing dedicated UIs for core SageFs capabilities. The Hot Reload window allows users to watch/unwatch files and trigger reloads, displaying a summary of tracked files. The Live Testing window offers a dashboard to toggle live testing, run all tests, filter results by status (All, Failed, Running, Stale, Passed), search, and configure run policies by category. The Session Context window displays real-time session status, connection health, assemblies, namespaces, and hot reload info, updated via SSE. The Type Explorer window lets users browse namespaces and assemblies loaded in the warmup context, with search and refresh capabilities, and automatically refreshes on warmup context snapshots.

sagefs-vs/SageFs.VisualStudio/ToolWindows · high confidence

The FVSquad Lean library adds formal specifications and verified theorems for several SageFs core components. Affordances.lean defines the session state machine and proves which MCP tools are available in each state, including safety constraints like code submission being gated exclusively on the Ready phase. Composition.lean bridges the session lifecycle and affordances models to prove end-to-end properties, such as ensuring code submission is only possible when the session phase is Active-Idle. EvalPipeline.lean models the railway-oriented pipeline computation expression, verifying that stages are recorded correctly and that errors short-circuit the pipeline without invoking subsequent steps. FsiRewrite.lean specifies the logic for rewriting indented 'use' bindings to 'let' for FSI compatibility, proving idempotency and length preservation. HotReloadState.lean formalizes file-watching operations, proving invariants for watch, unwatch, and toggle actions. PhaseTransition.lean defines valid session phase transitions and proves safety invariants, such as preventing direct transitions from Faulted to Active states. RestartPolicy.lean models Erlang-style exponential backoff, verifying that back-off delays stay within configured bounds and that the give-up decision is idempotent.

formal-verification/lean/FVSquad · high confidence

A new Cloudflare Worker has been added to receive and store sanitized SageFs friction reports in an R2 bucket, with optional Discord notifications. The service accepts POST requests for report ingestion (open to all, with optional token validation) and provides owner-only read endpoints (list and get) protected by an OWNER\_TOKEN. It includes defense-in-depth sanitization to redact paths, IPs, emails, and session IDs, enforces a 64KB payload size limit, and validates the report schema before storage.

friction-receiver · high confidence

The SageFs Visual Studio extension now provides a comprehensive set of commands for interactive development and testing. Users can evaluate code via selection, specific ranges, or entire files using block-aware parsing (semicolon or blank-line delimited), with the ability to cancel long-running evaluations. Live testing features include running tests at the cursor, navigating between failing tests, and toggling run policies. Daemon management commands allow starting, stopping, and opening the dashboard, while hot reload commands enable file and directory watching. These commands are exposed in the Extensions menu and support keyboard shortcuts.

sagefs-vs/SageFs.VisualStudio/Commands · high confidence

The samples directory now includes a comprehensive set of new projects and documentation. This adds the F\# Koans interactive tutorial, language bridge samples (C\#, Python, Java, JS/TS, Rust, Jupyter), and several working demos: Raylib-based graphics and game applications (Star Catcher), a reactive web app using Falco and Datastar, and a Console Ticker for hot-reload demonstrations. The Raylib demos now support reproducible recordings via \SAGEFS\_DEMO\_WINDOW\ and \SAGEFS\_DEMO\_SEED\ environment variables. Additionally, Expecto test projects have been added for the Koans and the Console Ticker to verify core logic and hot-reload behavior.

samples · high confidence

The Visual Studio extension now displays real-time daemon status, test results, and session information directly in the status bar. This change introduces a new \StatusBarManager\ that subscribes to SSE events for live updates on test summaries, session states (including warmup progress and faulted states), and periodic vitals checks. It also includes an auto-start mechanism for the daemon upon extension activation and provides specific error notifications via info bars when the daemon disconnects or fails to start. A bridge component (\StatusBarBridge\) is added to support future unified-hosting scenarios between the MEF and SDK runtime components.

sagefs-vs/SageFs.VisualStudio/StatusBar · high confidence

The Tweak feature now supports editing F\# expressions and literals using structural addresses (module path, binding, and expression tree path) instead of line numbers, ensuring targets remain valid through reformatting or comments. Literal edits preserve the author's original formatting style (hex/octal/binary bases, underscore grouping, trailing dots, units of measure) and guarantee byte-for-byte reproduction when re-setting the same value. Expression edits parse new text, format it via Fantomas (limited to single-line snippets), and apply changes only to the specific range, leaving the rest of the file untouched. A side-effect classifier conservatively determines whether expressions are safe for live re-evaluation or require user release, and a transaction state machine manages the tweak lifecycle with distinct states for parsing, type-checking, evaluation, and journaling, including a new 'Stale' state for in-progress evaluations.

SageFs.Core/Features/Tweak · high confidence

The VS Code extension source has been converted from TypeScript to F\# using Fable. This change introduces a new architecture where pure logic modules (such as AppRunPure, CoverageViewPure, DensityPure, and ErrorPresentationPure) are tested independently under dotnet fsi, while Fable-specific shims (like CoverageView.fs and Extension.fs) handle VS Code API interop and JSON parsing.

sagefs-vscode/src · high confidence

A change to existing behaviour in (repo-wide) — 1688 commits (488 fixs), 22 files.

(repo-wide) · low confidence · unverified

The runtimes directory now includes .gitkeep files for the native folders of linux-arm64, linux-x64, osx-arm64, and osx-x64. This ensures these platform-specific native directories are tracked in version control, supporting the inclusion of cross-platform native libraries (such as tree-sitter) for these operating systems and architectures.

runtimes · high confidence

The demo recording infrastructure in scripts/demos has been rewritten in F\# (F\# Scripting) to replace the previous Bash implementation. This change introduces a shared common library (demo-common.fsx) for argument parsing, process management, and error handling, and updates the specific drivers (drive-cohort.fsx, drive-dashboard.fsx) and recorders (record-x11.fsx, record-terminal.fsx) to use this new F\# foundation. The record-orchestrator.fsx has also been updated to coordinate these F\#-based drivers, ensuring that the demo recording workflows for both the cohort landing-gate and dashboard scenarios run on the new stack.

scripts/demos · high confidence

The repository's automation scripts—including the local gate, pre-push hook, version bumping, smoke testing, and local daemon installation—have been rewritten in F\#. This change introduces a new, pure decision layer (ReleaseRules.fs and SmokeRules.fs) that separates business logic from I/O, allowing the same rules to be unit-tested in the main test suite. For developers, this means the local gate now runs on a clean checkout to ensure accurate results, the pre-push hook strictly enforces version bumps and gate passes on master, and the smoke test provides detailed diagnostics on daemon health and test discovery.

scripts · high confidence

The hot reload mechanism has shifted from requiring a full application restart to applying changes directly to the running process using .NET's metadata delta (Edit-and-Continue) capabilities. This new route is enabled by default for hot reload workers and is controlled by the \SAGEFS\_METADATA\_DELTA\ environment variable. When active, the system computes a delta between the current build and the running assembly, checks runtime constraints (such as the \DOTNET\_MODIFIABLE\_ASSEMBLIES=debug\ setting and debugger attachment), and applies the patch if supported. This allows the application to retain its state and avoids the overhead of a restart for compatible edits, while gracefully falling back to a restart for changes that the runtime cannot handle.

SageFs.Core/Features/MetadataDelta · high confidence

The SageFs dashboard now provides more reliable and informative feedback during development: the hot-reload system distinguishes between successful compilations, 'no-effect' saves (where a restart is required rather than a reload), and connection timeouts, displaying specific error diagnostics with source context and clickable editor links. Additionally, the dashboard now self-hosts the JetBrains Mono font instead of fetching it from Google Fonts, ensuring consistent typography and removing external network dependencies for the UI.

SageFs/Resources · high confidence

The SageFs.Demos/spike location has been refactored from bash to F\# to automate and prove the Phase-0 foundation. This includes a new cell supervisor (cell-init) and a cell-agent (cell-agent) that run inside bubblewrap-sealed cells to manage Xvfb, launch Chromium, and execute end-to-end scenarios. The spike now proves the control/data-plane boundary by piping a ScenarioPlan JSON into the cell's stdin and receiving a StepLog JSON on stdout, and it validates the XTEST input edge by P/Invoking libXtst to click a button in a real Chromium page and observing the result via Playwright. The stage scripts (stages 1–4) and shared logic (spike-common) are now F\# scripts, and a new HTML fixture (stage2.html) supports the GUI capture tests.

SageFs.Demos/spike · high confidence

A .gitkeep file was added to the mcp-sdk-nupkg directory to ensure the folder is tracked by version control, addressing the CI assumption that this local NuGet source directory always exists.

mcp-sdk-nupkg · low confidence

The SageFs VS Code extension has been converted from TypeScript to F\# using Fable, requiring new build tooling (esbuild) and configuration files (tsconfig.json, .gitignore, .vscodeignore) to manage the F\#-to-JS compilation pipeline. To ensure the extension works correctly in the real VS Code environment, a new integration test suite has been added under test-electron/; this suite is also written in F\# (compiled via Fable) and uses @vscode/test-electron to prove that extension commands actually reach the daemon and change its state, covering live testing and hot reload functionality.

sagefs-vscode · high confidence

The CI pipeline now runs test tiers for both .NET 10 and .NET 11 in parallel, with each tier isolated in its own private object directory and lock file to prevent build conflicts. This change ensures that the .NET 10 test build is restored and executed independently, avoiding issues with shared intermediate outputs and locked restore modes, while also implementing a mechanism to kill hung tiers and assign disjoint daemon port ranges to prevent resource contention.

build · high confidence

1543 commits adding/updating tests in SageFs.Tests; Added comprehensive unit tests for the Visual Studio Editor extension; Added formal verification correspondence tests for RingBuffer; Added test fixtures for SageFs evaluation and error handling; Added tests for the SageFs.Demos test harness; Added unit tests for StatusBarService exception handling and MEF registration; Added unit tests for Visual Studio Core domain logic; Contract tests for VS Code extension logic; Dashboard snapshot tests for diagnostics, sessions, and themes.

A .gitkeep file was added to the harmony-nupkg directory to ensure the folder is tracked in version control, likely in preparation for storing or committing the packed SageFs.Harmony nupkg.

harmony-nupkg · high confidence

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

• CAI 51 → 52 (+0.9)
• Rubric changed (rubric-2026.09.13 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 49 → 49 (-0.2)
• Architecture 98 → 87 (-11.0)
• Maturity 78 → 78 (-0.0)
• Readiness 42 → 42 (+0.5)
• Security 55 → 63 (+8.4)

• (anonymous)::onmessage (cognitive 18) (SageFs.Host/Resources/devreload.js)
• (anonymous)::onmessage (cognitive 18) (SageFs/Resources/devreload.js)
• (anonymous)::renderErrorPanel (cognitive 38) (SageFs.Host/Resources/devreload.js)
• (anonymous)::renderErrorPanel (cognitive 38) (SageFs/Resources/devreload.js)
• (anonymous)::renderErrorPanel (cyclomatic 24) (SageFs.Host/Resources/devreload.js)
• (anonymous)::renderErrorPanel (cyclomatic 24) (SageFs/Resources/devreload.js)
• Change coupling: SessionManager.fs ↔ SessionMode.fs (SageFs.Core/SessionManager.fs)
• Codec.decodeEvent (cognitive 28) (SageFs/McpFrictionRecorder.fs)
• Cohort.decide (cognitive 211) (SageFs.Core/Cohort.fs)
• Cohort.decide (cyclomatic 119) (SageFs.Core/Cohort.fs)
• CohortLandingVerify.runTestsInSession (cyclomatic 20) (SageFs/CohortLandingVerify.fs)
• CoverageViewModule.project (cognitive 17) (SageFs.Core/Features/LiveTestingTypes.fs)
• CoverageViewStateModule.fromCounts (cognitive 19) (SageFs.Core/Features/LiveTestingTypes.fs)
• DashboardFragments.renderHotReloadPanel (cyclomatic 20) (SageFs/DashboardFragments.fs)
• Documentation: no architecture or design documentation (docs/index.html)
• Documentation: no installation or build instructions (README.md)
• Documentation: no installation or build instructions (docs/index.html)
• Documentation: no usage examples (docs/index.html)
• ExpectoExecutor.executeReflected (cognitive 26) (SageFs.Core/Features/LiveTestingExecutors.fs)
• ExpectoExecutor.executeReflected (cyclomatic 19) (SageFs.Core/Features/LiveTestingExecutors.fs)
• …and 89 more

• Ansi.tokenize (cognitive 58) (scripts/lemmings/ui/nvim/Ansi.fs)
• Ansi.tokenize (cyclomatic 28) (scripts/lemmings/ui/nvim/Ansi.fs)
• Answer.planRipple (cyclomatic 16) (SageFs/McpAnalysis.fs)
• AppRunner.resolveProjectAssembly (cognitive 17) (SageFs.Host/AppRunner.fs)
• AppRunner.resolveProjectAssembly (cyclomatic 17) (SageFs.Host/AppRunner.fs)
• CapabilitySim.step (cognitive 59) (SageFs.Simulation/CapabilitySim.fs)
• CapabilitySim.step (cyclomatic 46) (SageFs.Simulation/CapabilitySim.fs)
• Change coupling: DaemonClient.fs ↔ Editor.fs (SageFs/DaemonClient.fs)
• Change coupling: Editor.fs ↔ RenderPipeline.fs (SageFs/Editor.fs)
• CliCommandModule.parse (cognitive 17) (SageFs/Program.fs)
• Cohort.decideRaw (cognitive 231) (SageFs.Core/Cohort.fs)
• Cohort.decideRaw (cyclomatic 127) (SageFs.Core/Cohort.fs)
• CohortGit.rebaseCommitsOnto (cognitive 32) (SageFs/CohortGit.fs)
• CohortGit.rebaseCommitsOnto (cyclomatic 16) (SageFs/CohortGit.fs)
• CohortStatusText.render (cognitive 23) (SageFs.Core/Features/CohortStatusText.fs)
• CohortStatusText.render (cyclomatic 16) (SageFs.Core/Features/CohortStatusText.fs)
• CompileOrderInsight.analyzeWithReferences (cognitive 19) (SageFs.Core/CompileOrderInsight.fs)
• CompileOrderInsight.analyzeWithReferences (cyclomatic 19) (SageFs.Core/CompileOrderInsight.fs)
• CoreEvidence.evidenceFor (cognitive 22) (SageFs.Core/CoreEvidence.fs)
• CoreEvidence.inspectProject (cognitive 48) (SageFs.Core/CoreEvidence.fs)
• …and 290 more

• 300 commits — 245 feature/other, 55 fixes

• (root) — 39 commits
• scripts/lemmings — 36 commits
• (repo) — 29 commits
• SageFs.Core/Features — 28 commits
• docs/decisions.md — 11 commits
• sagefs-vscode/src — 11 commits
• sagefs-vscode/tests — 11 commits
• SageFs.Tests/fixtures — 10 commits
• docs/roadmap.md — 9 commits
• SageFs.Core/Capability.fs — 3 commits
• SageFs.Tests/ArchitectureTests.fs — 3 commits
• SageFs.Tests/DashboardBrowserTests.fs — 3 commits
• SageFs.Tests/InputHashCoverageTests.fs — 3 commits
• SageFs.Tests/LiveBindingsBrowserTests.fs — 3 commits
• docs/configuration.md — 3 commits
• scripts/plugin-impact-baseline — 3 commits
• SageFs.Core/MachineCalibration.fs — 2 commits
• SageFs.Core/MachineProfile.fs — 2 commits
• SageFs.Core/MemberTable.fs — 2 commits
• SageFs.Core/SessionManager.fs — 2 commits

• fix: chore(scripts): delete fix-async.ps1 and launch_daemon_detached.py
• fix: chore(ship): move the plugin-impact baseline past the VS Code fixes merge
• fix: fix(analysis): read the val line behind the MCP result prefix
• fix: fix(build): build.fsx fails the test target on any non-zero exit
• fix: fix(cohort): a landing is verified against the files evaluated over the build, not coverage alone
• fix: fix(cohort): a member's public id is a fingerprint of the connection handle, not the handle
• fix: fix(dashboard): bound the eval result block, and keep a following output panel at the bottom when its own box changes size
• fix: fix(dashboard): give every held row of the live-bindings pane a signal of its own, and wait on the clicked row's mark
• fix: fix(dashboard): the live-bindings layout check judges the rows that have a box
• fix: fix(gate): a test whose coverage hit nothing has no cache key, so it is always run
• fix: fix(gate): a test's cache key sees the files coverage cannot, trustBeyond and seenFiles
• fix: fix(gate): gate-reap.fsx loads MachineTier.fs before Timeouts.fs
• fix: fix(hot-reload): keep the delta emitter inside two architecture ratchets, and make the child's protocol a closed set
• fix: fix(hot-reload): latency tier follows a patched save from its own compile, and takes the files as the journeys left them
• fix: fix(hot-reload): the REPL-freshness wiring fits the repo's ratchets and its wire shapes are pinned
• fix: fix(hot-reload): the emitter folds line numbers out of field and helper-method names, found by a real F# build
• fix: fix(hot-reload): the latency tier's restart row measures a restart, and a delta row measures the default route
• fix: fix(hygiene): the always-loaded skill stays under its word budget, and the browser journey disposes by await
• fix: fix(lemmings): Neovim harness types ;; whole, keeps the editor shell off the harness, and says what it needs
• fix: fix(lemmings): Neovim oracle follows what real runs showed
• …and 280 more

• 13 added · 0 removed (a removed endpoint is potentially breaking)

• GET /api/local-data
• GET /api/sessions/{sid}/live-values/mode
• POST /api/lease/release
• POST /api/lease/request
• POST /api/live-testing/debug
• POST /api/live-testing/debug/continue
• POST /api/live-testing/pause
• POST /api/live-testing/resume
• POST /api/live-testing/scope
• POST /api/local-data/clear
• POST /api/sessions/{sid}/live-values/evaluate
• POST /api/sessions/{sid}/live-values/mode
• POST /api/sessions/{sid}/workflow

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

WillEhrendreich/SageFs 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.