libLogit

libLogit Burndown

This burndown takes libLogit from the current prototype into a cross-language logging SDK built around user-instantiated LOGIT objects.

Product Goal

libLogit should let a developer add one SDK to their project, define one or more LOGIT objects by filling in a portable structure, and immediately start keeping useful logs. Each LOGIT owns the path, level threshold, sinks, formatting, metadata, buffering, database storage, retention/rotation length, and failure behavior needed to log for one application, module, service, or subsystem.

Terminology decision: call the full product an SDK. The SDK includes the library code, the public API, language bindings, config/schema, examples, package metadata, and the log viewer. Use “API” only for the calls users write, such as LOGIT(), .localPath, .level, and .log(). Use “binding” for a language-specific SDK surface.

The fully functional v1 alpha is intentionally smaller than the end-state vision, but it should be a working example of what the project can do: users should be able to include libLogit in their app, instantiate a LOGIT, emit logs, keep a bounded rotating local log store, and inspect those logs through SQL or a minimal viewer. Alpha does not need true support for every language, OS, desktop environment, and hardware profile. It needs to prove the LOGIT model and desktop logging workflow across the MVP language set: Python, C++, C, C#, Java, JavaScript, Go, and Kotlin.

The target mental model is:

LOGIT LogIT = [
  PATH = "C:/logs/app.log",
  LEVEL = DEBUG
]

LogIT(DEBUG) << "This is a test log"

The exact syntax will vary by language, but the concept must not. A LOGIT means the same thing in Python, C++, C, C#, Java, JavaScript, Go, Kotlin, beta-track Ada, and any future binding.

Alpha database/viewer vocabulary:

Current State

Milestone Definitions

v1 Alpha

The project reaches v1 alpha when:

v1 Beta

The project reaches v1 beta when:

Latest Progress Snapshot

Updated 2026-06-12 for the Beta documentation and planning completion pass; the v1 Alpha readiness snapshot below preserves the prior release-candidate evidence.

Long-Term Vision

The long-term goal is support for every practical OOP language. That means native-feeling APIs for each language, not one awkward syntax forced everywhere. The shared promise is the LOGIT object model, not identical punctuation.

Candidate language families after beta include TypeScript, Swift, Objective-C, Rust with object-oriented API patterns, PHP, Ruby, Scala, Dart, Delphi/Object Pascal, and additional JVM/.NET languages.

Target API Shape

Canonical pseudo-syntax:

LOGIT AuditLog = [
  PATH = "C:/logs/audit.log",
  LEVEL = INFO,
  TIMESTAMP = true,
  FORMAT = "text",
  TAG_LEVEL = true,
  SINKS = [CONSOLE, FILE]
]

AuditLog(DEBUG) << "ignored below threshold"
AuditLog(INFO) << "user signed in"

Python target:

from liblogit import Logit, DEBUG, INFO

AuditLog = Logit(path="C:/logs/audit.log", level=INFO)
AuditLog(INFO) << "user signed in"

C++ target:

#include <liblogit/logit.hpp>

auto AuditLog = liblogit::LOGIT{
    .path = "C:/logs/audit.log",
    .level = liblogit::Level::INFO
};

AuditLog(liblogit::Level::INFO) << "user signed in";

JVM target:

Logit auditLog = Logit.builder()
    .path("C:/logs/audit.log")
    .level(Level.INFO)
    .build();

auditLog.at(Level.INFO).append("user signed in").commit();

Language Strategy

Alpha MVP targets eight languages. Python remains the reference implementation, C and C++ prove native embeddability and streaming syntax, C# and Java cover the largest managed OOP ecosystems, JavaScript and Go cover modern application/service stacks, and Kotlin validates an idiomatic JVM facade.

Language Alpha Role Why It Belongs In Alpha
Python Reference implementation Existing package and tests already exist; fastest place to refine the model.
C++ Canonical streaming syntax Best match for LogIT(DEBUG) << "message" and useful for native consumers.
C Native minimal API Provides the lowest-level ABI surface and a practical bridge for other runtimes.
C# .NET binding Covers the primary OOP language in the .NET ecosystem and desktop/service users.
Java Main JVM binding Large OOP user base and a practical proving ground for builder-style APIs.
JavaScript Web and Node binding Gives immediate reach into frontend tooling, Node services, and package consumers.
Go Service binding Covers a major backend deployment language with an idiomatic object-style adapter.
Kotlin JVM idiomatic layer Shares much of Java’s implementation effort while testing a more expressive syntax.

Ada remains valuable as an exploratory binding because this repo already has Ada sketches, but it should not block v1 alpha. It moves to the beta expansion track unless there is a strong user need to keep it in the initial set.

The beta language expansion should use a repeatable playbook: choose a language, map the LOGIT object into that language’s idioms, implement the conformance fixtures, publish a minimal package, then graduate it from experimental to supported.

LOGIT Structure Contract

Every binding must support these core fields:

Field Required Purpose
name No Stable identifier when loaded from config.
path No Primary file destination. May be a file path or directory depending on path_mode.
path_mode No file or directory; controls whether libLogit appends to a file or creates named files inside a directory.
level Yes Minimum severity threshold: trace, debug, info, warn, error, fatal.
enabled No Fast toggle for disabling a LOGIT without code changes.
sinks No Destinations such as console, file, network, memory, or future custom sinks.
timestamp No Include or suppress timestamp metadata.
timezone No local, utc, or IANA timezone where supported.
tag_level No Include or suppress the level label in text output.
format No text, json, or named/custom template.
template No Text format template for advanced users.
metadata No Static key/value metadata such as app, module, component, tenant, or environment.
redaction No Rules for masking secrets, tokens, PII, or field patterns.
rotation No Max bytes, max files, daily/hourly policy, or disabled.
buffering No Sync/async mode, batch size, flush interval, and shutdown behavior.
failure_policy No What to do when a sink fails: warn, drop, raise, retry, or fallback.
encoding No File encoding, defaulting to UTF-8.
newline No Platform default, LF, or CRLF.

Config V2 Draft

The shared config should evolve from one global logger into a registry of named LOGIT objects:

{
  "version": "0.2",
  "defaults": {
    "level": "info",
    "timestamp": true,
    "tag_level": true,
    "format": "text",
    "sinks": ["console"]
  },
  "logits": {
    "AppLog": {
      "path": "logs/app.log",
      "level": "debug",
      "sinks": ["console", "file"]
    },
    "AuditLog": {
      "path": "logs/audit.log",
      "level": "info",
      "format": "json",
      "metadata": {
        "component": "audit"
      }
    }
  }
}

Backward compatibility requirement:

Architecture Target

The implementation should converge on these layers:

  1. spec/
    • Versioned written contract for LOGIT, levels, event fields, sinks, formatters, error handling, and conformance expectations.
  2. schema/
    • JSON Schema for config files and example payloads.
  3. liblogit/ reference implementation
    • Python implementation of the core model, parser, sinks, formatters, and user API.
  4. include/ or cpp/
    • C++ implementation with streaming syntax and direct LOGIT instantiation.
  5. languages/
    • Language bindings/adapters that map native syntax to the shared contract.
  6. tests/conformance/
    • Golden fixtures shared by all bindings.
  7. examples/
    • Minimal real applications showing one-logit and multi-logit setup.

Burndown Summary

Initial total scope: 210 story points after clarifying that Alpha must include a functional database-backed desktop showcase.

This total covers the road from the current repo through v1 alpha and into the first beta expansion pass. The v1 alpha cut line is the first working SDK milestone: include the SDK, instantiate a LOGIT, route logs through it in Python, C++, C, C#, Java, JavaScript, Go, and Kotlin, and demonstrate a bounded SQLite log store plus minimal viewer. Work beyond that cut line prepares the mad dash toward true OS, hardware, and language agnostic logging.

Phase Focus Points Exit Signal
0 Repo baseline and project framing 10 Current state documented and tests reproducible.
1 LOGIT product specification 20 Versioned object contract approved.
2 Config v2 and migration 22 Named LOGIT config schema validates and v0.1 still works.
3 Python reference implementation 30 Python supports direct and config-loaded LOGIT objects.
4 Core sinks, formatting, and runtime behavior 28 Alpha has console/file/text/JSON behavior plus Python redaction, buffering, failure policies, and thread-safety coverage; beta track covers cross-binding runtime parity.
4A Desktop log store and viewer showcase 20 Alpha proves bounded SQL-readable logs and a minimal viewer window.
5 C++ implementation 22 C++ supports target streaming syntax.
6 Alpha language bindings and beta binding playbook 24 C, C#, Java, JavaScript, Go, and Kotlin consume the same contract; Ada and future languages have an expansion path.
7 Conformance and CI 18 Cross-language golden tests run in CI.
8 Documentation, packaging, and release 16 Release candidate is installable and documented.
Milestone Included Work Remaining Scope After Milestone
v1 alpha Phases 0-5, Phase 4A, C/C#/Java/JavaScript/Go/Kotlin alpha binding work, alpha conformance, alpha docs/packages. True OS/hardware/language agnostic hardening, advanced runtime features, and broader packaging.
v1 beta Binding playbook, additional language onboarding, expanded conformance, CI hardening, OS/hardware validation. Long-tail OOP language support and ecosystem polish.
Long-term Every practical OOP language has a native-feeling LOGIT API. Ongoing maintenance and community-driven bindings.

Target burndown:

SP
190 |######################################
180 |####################################
160 |################################
138 |############################
108 |######################
 80 |################
 58 |############
 34 |#######
 16 |###
  0 +--------------------------------------> Phase
     S    0    1    2    3    4    5    6    7    8
Point In Plan Remaining SP
Start 190
Phase 0 complete 180
Phase 1 complete 160
Phase 2 complete 138
Phase 3 complete 108
Phase 4 complete 80
Phase 5 complete 58
Phase 6 complete 34
Phase 7 complete 16
Phase 8 complete 0

Phase 0 - Repo Baseline And Framing

ID Step Deliverable Acceptance Criteria Points Depends On Status
P0-01 Capture current implementation inventory. Current-state inventory in this burndown. Repo state is described accurately, including Python package, schema, C++ header, language sketches, and tests. 2 None Done
P0-02 Run current test suite and document baseline. Test results in release notes or development notes. pytest result is known; failures are triaged or captured. 2 None Done
P0-03 Decide canonical repo layout. Layout ADR. New directories for spec, conformance, examples, and bindings are accepted. 2 P0-01 Done
P0-04 Define contribution workflow. CONTRIBUTING.md. Local setup, test commands, style expectations, and release branching are documented. 2 P0-01 Done
P0-05 Add issue labels and milestone taxonomy. Backlog labels. Work can be tracked by phase, binding, spec, sink, test, and docs. 2 P0-01 Done

Phase 1 - LOGIT Product Specification

ID Step Deliverable Acceptance Criteria Points Depends On Status
S1-01 Define LOGIT terminology. spec/logit-object.md. Terms such as LOGIT, event, sink, formatter, threshold, path, and registry have unambiguous meanings. 3 P0-01 Done
S1-02 Define severity semantics. spec/levels.md. Every binding maps trace, debug, info, warn, error, and fatal consistently. 2 S1-01 Done
S1-03 Define the minimum LOGIT structure. Spec table and examples. Required and optional fields are listed with defaults and validation rules. 4 S1-01 Done
S1-04 Define direct-instantiation behavior. Spec examples for Python, C++, C, C#, Java, JavaScript, Go, Kotlin, and the future binding template. Users can create a LOGIT without a config file. 3 S1-03 Done
S1-05 Define config-loaded registry behavior. Registry section in spec. Named LOGIT objects can be loaded and retrieved from config. 3 S1-03 Done
S1-06 Define streaming behavior. spec/streaming-api.md. Commit rules, destructor/finalizer behavior, explicit flush, empty messages, and exceptions are specified. 2 S1-04 Done
S1-07 Define compatibility policy. spec/compatibility.md. v0.1 global config migration and deprecation messaging are explicit. 3 S1-03 Done

Phase 2 - Config V2 And Migration

ID Step Deliverable Acceptance Criteria Points Depends On Status
C2-01 Draft config v2 schema. schema/logit.v2.schema.json. Schema supports version, defaults, and logits map. 4 S1-03, S1-05 Done
C2-02 Preserve v0.1 schema. schema/logit.v1.schema.json. Existing config contract remains versioned and testable. 2 C2-01 Done
C2-03 Add schema examples. examples/config/*.json. Valid and invalid config fixtures cover simple, multi-logit, JSON format, rotation, and migration cases. 3 C2-01 Done
C2-04 Define path rules. Schema and docs update. File path, directory path, relative path, Windows path, POSIX path, and empty path behavior are defined. 3 S1-03 Done
C2-05 Add config migration rules. Migration spec and tests. v0.1 config loads as default; v2 config loads named objects. 4 C2-01, C2-02 Done
C2-06 Define environment override rules. Spec and parser tests. Overrides can change level, enabled state, and path without editing config. 2 C2-01 Done
C2-07 Update sample config. liblogit/data/logit.sample.json. Bundled sample shows config v2 while legacy sample remains available. 2 C2-05 Done
C2-08 Document configuration. docs/configuration.md. User-facing docs explain direct objects, config files, defaults, and migration. 2 C2-07 Done

Phase 3 - Python Reference Implementation

ID Step Deliverable Acceptance Criteria Points Depends On Status
PY-01 Split Python package into modules. liblogit/config.py, levels.py, logit.py, events.py, sinks/, formatters/. Public imports still work and internals are no longer packed into __init__.py. 4 P0-03 Done
PY-02 Implement Level enum. liblogit/levels.py. String parsing, aliases, ordering, and formatting are covered by tests. 2 S1-02 Done
PY-03 Implement LogitConfig data model. liblogit/config.py. Direct structure validation matches the spec and schema. 3 C2-01 Done
PY-04 Implement LogEvent data model. liblogit/events.py. Event includes level, message, timestamp, logger name, metadata, and rendered fields. 3 S1-03 Done
PY-05 Implement Logit object. liblogit/logit.py. Logit(path=..., level=...) can be called as Logit(DEBUG) << "message". 5 PY-02, PY-03, PY-04 Done
PY-06 Implement builder/stream lifecycle. LogBuilder tests. Explicit commit, ENDL, destructor fallback, empty messages, and exceptions behave as specified. 3 S1-06, PY-05 Done
PY-07 Implement registry loader. load_logits(path) and get_logit(name). Multi-logit config returns named Logit objects with defaults applied. 4 C2-05, PY-05 Done
PY-08 Maintain compatibility API. Existing init_from_config, LOG, and ENDL. Current tests pass and legacy users receive equivalent behavior. 3 PY-07 Done
PY-09 Add structured payload support. JSON serialization tests. Dict/list payloads render correctly in text and JSON formats. 2 PY-04, PY-06 Done
PY-10 Add type hints and public exports. Typed public API. py.typed is included and public objects are documented. 1 PY-05 Done

Phase 4 - Sinks, Formatting, And Runtime Behavior

Alpha requirement: console sink, file sink, text formatter, JSON-lines formatter, level filtering, timestamp toggle, static metadata, and basic failure handling. Metadata merging, redaction, rotation, async buffering, richer failure policies, and thread-safety are important; Python now covers metadata merging, redaction, size rotation, async/batched buffering, warn/drop/raise/retry/fallback failure policies, and concurrent file/buffered output.

ID Step Deliverable Acceptance Criteria Points Depends On Status
RT-01 Define sink interface. liblogit/sinks/base.py and spec update. All sinks accept LogEvent, support close/flush where relevant, and report failures consistently. 3 PY-04 Done
RT-02 Implement console sink. Console sink tests. Console output honors level, timestamp, level tag, metadata, and format. 2 RT-01 Done
RT-03 Implement file sink. File sink tests. File paths are created safely and logs append with configured encoding/newline. 3 RT-01, C2-04 Done
RT-04 Implement directory path mode. Path mode tests. Directory mode creates stable filenames from LOGIT name or configured filename rule. 2 RT-03 Done
RT-05 Implement text formatter. Golden format tests. Text output is deterministic when timestamp is fixed. 2 PY-04 Done
RT-06 Implement alpha JSON-lines formatter. JSON golden tests. JSON logs are valid one-line JSON objects with stable field names. 3 PY-04 Done
RT-07 Implement metadata merging. Metadata tests. Static LOGIT metadata and per-message metadata combine with deterministic precedence. 2 PY-04 Done
RT-08 Implement redaction hooks. Redaction tests. Configured patterns and keys are masked before any sink receives an event. 3 PY-04 Done
RT-09 Implement rotation. Rotation tests. Max-size and max-files rotation work for file sink. 3 RT-03 Done
RT-10 Implement buffering and flush. Buffering tests. Sync mode writes immediately; async/batched mode flushes on interval, manual flush, and shutdown. 3 RT-01 Done
RT-11 Implement failure policies. Failure policy tests. warn, drop, raise, retry, and fallback behaviors are covered. 3 RT-01 Done
RT-12 Add thread-safety guarantees. Concurrency tests. Concurrent logging does not interleave or corrupt messages. 2 RT-03, RT-10 Done

Phase 4A - Desktop Log Store And Viewer Showcase

Alpha requirement: prove the product direction with a SQL-readable bounded log store and a minimal desktop viewer. SQLite is the default alpha store because it is embedded, local-first, and readable from standard SQL tooling. True database server targets, cloud transports, and deep UI polish are beta-track.

ID Step Deliverable Acceptance Criteria Points Depends On Status
DB-01 Define SQLite log store schema. spec/log-store.md and SQL schema. Events have stable columns for id, timestamp, logger, level, message, metadata, sink/source, and sequence. 2 S1-03, PY-04 Done
DB-02 Define retention and rotation policy. Config fields and tests for length, max bytes, max age, and eviction order. Users can choose a bounded history policy and the oldest records are removed deterministically. 3 DB-01, C2-04 Done
DB-03 Implement Python SQLite sink. Python sqlite/database sink tests. A LOGIT can write to a local SQLite store while console/file sinks still work. 5 DB-01, DB-02, RT-01 Done
DB-04 Add SQL interface examples. Example SQL queries and docs. Users can inspect logs through standard SQLite/SQL tools without the viewer. 2 DB-03 Done
UI-01 Build minimal desktop log viewer. Viewer prototype. A user can open the alpha SQLite store in a window and see recent log rows. 5 DB-03 Done
UI-02 Add viewer filters. Level/logger/time/text filters. Viewer can filter by logger, level, time window, and message search. 3 UI-01 Done

Phase 5 - C++ Implementation

ID Step Deliverable Acceptance Criteria Points Depends On Status
CPP-01 Move C++ code into a durable layout. include/liblogit/ and cpp/ or documented header-only layout. Build instructions are clear and current libLogit.h consumers have a migration path. 3 P0-03 Done
CPP-02 Implement C++ Level. C++ level tests. Parsing and ordering match the spec and Python behavior. 2 S1-02 Done
CPP-03 Implement C++ LOGIT object. C++ API and examples. User can instantiate LOGIT with path and level structure. 5 S1-04, CPP-02 Done
CPP-04 Implement C++ streaming call syntax. C++ streaming tests. AuditLog(Level::INFO) << "message" emits once and honors threshold. 4 CPP-03, S1-06 Done
CPP-05 Implement config v2 loader. C++ config tests. Named LOGIT objects load from the same fixtures as Python. 3 C2-03, CPP-03 Done
CPP-06 Implement C++ sinks and formatters. Console/file/text/json parity tests. C++ output matches golden fixtures where timestamps are fixed. 3 RT-01, CPP-03 Done
CPP-07 Add CMake build. CMakeLists.txt. Library, examples, and tests build on Windows, Linux, and macOS. 2 CPP-01 Done

Phase 6 - Alpha Language Bindings And Beta Expansion

ID Step Deliverable Acceptance Criteria Points Depends On Status
LANG-01 Define binding compliance checklist. tests/conformance/README.md. Each binding has required features, optional features, and skipped-feature rules. 3 S1-01, C2-03 Done
LANG-02 Decide implementation strategy. ADR for per-language implementation vs shared native core. Tradeoffs for portability, packaging, and API ergonomics are captured. 3 LANG-01 Done
LANG-03 Add C binding. C LOGIT API. C can instantiate direct and config-loaded LOGIT objects through an idiomatic struct/function API. 3 LANG-01, C2-05 Done
LANG-04 Add C# binding. C# Logit API. C# can instantiate direct and config-loaded LOGIT objects. 3 LANG-01, C2-05 Done
LANG-05 Update Java binding. Java Logit API. Java can instantiate direct and config-loaded LOGIT objects. 3 LANG-01, C2-05 Done
LANG-06 Add JavaScript binding. JavaScript Logit API. JavaScript can instantiate direct and config-loaded LOGIT objects in Node-compatible environments. 3 LANG-01, C2-05 Done
LANG-07 Add Go binding. Go Logit API. Go can instantiate direct and config-loaded LOGIT objects with idiomatic structs and methods. 3 LANG-01, C2-05 Done
LANG-08 Update Kotlin facade. Kotlin idiomatic API. Kotlin supports direct construction and shl streaming behavior. 2 LANG-05 Done
LANG-09 Move Ada to beta-track binding. Ada gap list and beta plan. Existing Ada sketches are preserved, but Ada does not block v1 alpha. 1 LANG-01 Done
LANG-10 Define future binding template. docs/bindings/new-language.md. Adding TypeScript, Swift, PHP, Ruby, Scala, Dart, Rust-style APIs, or other OOP languages has a documented path. 2 LANG-02 Done
LANG-11 Add alpha binding examples. examples/c, examples/cpp, examples/csharp, examples/java, examples/javascript, examples/go, examples/kotlin. Each alpha binding example logs one direct LOGIT and one config-loaded LOGIT. 3 LANG-03, LANG-04, LANG-05, LANG-06, LANG-07, LANG-08 Done
LANG-12 Add package metadata plan. Packaging ADR. NuGet/npm/Maven/Gradle/Go/C/C++/Python distribution requirements are known before alpha release; Ada and future language packaging is beta-track. 1 LANG-02 Done
LANG-13 Build beta language intake list. Prioritized beta language backlog. Candidate OOP languages are ranked by user demand, implementation cost, ecosystem fit, and package distribution difficulty. 1 LANG-10 Done

Phase 7 - Conformance, Quality, And CI

ID Step Deliverable Acceptance Criteria Points Depends On Status
QA-01 Create golden fixtures. tests/conformance/fixtures/. Fixtures include configs, messages, fixed clocks, and expected output. 4 C2-03, RT-05, RT-06 Done
QA-02 Add Python conformance runner. Python conformance tests. Python passes all required fixtures. 2 PY-07, QA-01 Done
QA-03 Add C++ conformance runner. C++ conformance tests. C++ passes required fixtures. 3 CPP-06, QA-01 Done
QA-04 Add managed and service binding conformance runners. C#, Java, JavaScript, Go, and Kotlin tests. Managed/service bindings pass required fixtures. 3 LANG-04, LANG-05, LANG-06, LANG-07, LANG-08, QA-01 Done
QA-05 Add Ada conformance runner. Ada tests or documented manual runner. Ada passes required fixtures or has explicit temporary gaps. 2 LANG-09, QA-01 Done
QA-06 Add CI matrix. GitHub Actions workflow. CI runs Python tests, schema validation, C++ build/tests, and available binding tests. 3 QA-02, QA-03 Done
QA-07 Add static checks. Lint/type/test commands. Python type checks, formatting checks, schema validation, and C++ formatting are automated. 1 QA-06 Done

Phase 8 - Documentation, Packaging, And Release

ID Step Deliverable Acceptance Criteria Points Depends On Status
REL-01 Rewrite README around LOGIT. README quick start. First screen shows direct LOGIT creation and logging call. 2 PY-05, CPP-03 Done
REL-02 Add migration guide. docs/migration-v0.1-to-v0.2.md. Existing users can move from global LOG to named LOGIT objects. 2 C2-05, PY-08 Done
REL-03 Add API docs. docs/api/. Public API is documented for every alpha MVP language. 3 PY-10, CPP-04, LANG-11 Done
REL-04 Add tutorial examples. examples/README.md. Alpha examples cover single logit, multiple logits, and text logs; beta examples cover JSON logs, rotation, and failure policy. 2 RT-11, LANG-11 Done
REL-05 Prepare Python package release. PyPI-ready package. Metadata, files, type hints, samples, and tests are packaged correctly. 2 QA-02, REL-01 Done
REL-06 Prepare C++ distribution. CMake install/export or header-only release artifact. C++ consumers can install or vendor the library cleanly. 2 CPP-07, QA-03 Done
REL-07 Prepare alpha binding distribution plan. NuGet/npm/Maven/Gradle/Go module checklist. C#, JavaScript, Java, Kotlin, and Go artifacts have naming, versioning, and publication steps. 1 LANG-12, QA-04 Done
REL-08 Cut alpha release candidate. v1.0.0-alpha.1. Release notes list features, limitations, migration notes, and known beta-track gaps. 2 REL-05, REL-06, QA-06 In progress

Cross-Cutting Decisions To Make Early

Blockers And Constraints

Date Area Blocker Action Taken Status
2026-05-23 Go binding verification go is not available on PATH in the current local environment. Go was installed on 2026-05-24 and go test ./... now passes. Resolved
2026-05-23 C/C++ binding verification gcc and MSVC cl are not available on PATH in the current local environment. LLVM/clang and MSVC Build Tools were installed on 2026-05-24; C smoke compile and C++ header syntax check now pass. Resolved
2026-05-23 C# release target Local .NET install has SDK/runtime 10.0 but not .NET 8 runtime. Alpha NuGet package now targets net10.0; beta should revisit multi-targeting after the API is steadier. Documented
2026-05-23 Kotlin binding verification kotlinc is not available on PATH in the current local environment. Kotlin compiler was installed on 2026-05-24 and Kotlin facade compile/test now passes. Resolved
2026-05-23 JVM packaging verification mvn is not available on PATH in the current local environment. Maven was installed on 2026-05-24 and reports version successfully. Resolved
2026-05-24 Tooling Go, LLVM/clang, CMake, Ninja, MSVC Build Tools, Maven, Kotlin compiler, vcpkg, nlohmann-json, Node, Python, pytest, and Python jsonschema were installed. Local verification can now use installed tools with refreshed PATH; older missing-tool blockers above can be closed on the next burndown cleanup. Resolved
2026-05-24 C++ source clang++ -fsyntax-only found a malformed character literal in libLogit.h around line 269. Fixed newline write in Logger::write_to_file; syntax check passes. Resolved
2026-05-24 Kotlin source kotlinc found the existing Kotlin facade referenced legacy LibLogIt and used an invalid operator fun shl declaration. Reworked Kotlin facade around the new Java Logit object and an infix shl; compile/test passes. Resolved
2026-05-24 Python file sink cleanup A quick README sample run on Windows showed a direct LOGIT file sink can keep its file handle open long enough to block temporary directory cleanup. Added close-after-emit file handler behavior plus handler cleanup tolerance; Python regression tests pass. Resolved
2026-05-24 Windows verification script Direct .\scripts\verify-alpha.ps1 execution is blocked by the local PowerShell execution policy. Verified with powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-alpha.ps1; CI runs in GitHub Actions and is unaffected. Documented
2026-05-24 CMake package export The installed C++ CMake target referenced nlohmann_json::nlohmann_json before the package config loaded that dependency. Added find_dependency(nlohmann_json CONFIG) to the generated package config and added an installed-consumer verification step. Resolved
2026-05-24 Sandboxed local verification The workspace sandbox blocked .NET from reading user NuGet config, Go from using its build cache, and CMake/Ninja from executing the user-installed Ninja path. Re-ran the full Alpha verifier outside the sandbox after approval; the matrix passed. GitHub hosted CI is not expected to share this local sandbox restriction. Resolved
2026-05-24 Java package build Maven package build surfaced a broken legacy LibLogIt.java sketch that the direct Java tests did not compile. Replaced the legacy class with a compatibility facade over the Alpha Logit object; javac, Java tests, and mvn package pass. Resolved
2026-05-24 npm package verification Windows PowerShell blocked npm.ps1, and the sandbox blocked npm cache writes. Local verifier now calls npm.cmd on Windows with a temporary cache, and final verification ran outside the sandbox. Resolved
2026-05-24 Kotlin Maven package build Maven package initially failed because the companion POM did not include Kotlin stdlib. Added the kotlin-stdlib dependency, set JVM target 17, install the Java artifact before Kotlin package verification, and confirmed mvn package passes. Resolved
2026-05-24 Generated pytest cleanup A focused sandboxed pytest run created build/pytest-cache and build/pytest-tmp owned by the sandbox identity; this user context cannot delete those directories even after approval. Added .gitignore entries for generated build/cache/log output and kept the verifier on removable temp directories outside the workspace. Documented
2026-05-24 Python type checking mypy, pyright, and ruff were not available in the local toolchain. Installed mypy and ruff; scripts/verify-static.ps1 now runs Python syntax, lint, type, whitespace, schema/config, and C/C++ formatting checks. Resolved
2026-05-24 Hosted CI observation GitHub CLI is installed but not authenticated in this environment, so hosted Actions status cannot be observed locally. Added scripts/check-hosted-ci.ps1 and docs/releases/v1.0.0-alpha.1-checklist.md; after push and gh auth login, run the script and record the hosted workflow URL before final RC promotion. Documented
2026-05-25 Hosted CI observation scripts/check-hosted-ci.ps1 still cannot observe GitHub Actions because GitHub CLI reports You are not logged into any GitHub hosts. Added docs/releases/v1.0.0-alpha.1-rc-evidence.md with the local verifier, artifact sanity evidence, package metadata sanity, exact hosted-CI failure text, authenticated handoff steps, optional head-SHA pinning, and required-job validation. Documented
2026-05-25 Sandboxed Maven dependency resolution After native exit-code checks were added, the full Alpha verifier and later RC-integrated Java artifact inspection correctly failed in the sandbox because Maven could not download plugins from Maven Central (Permission denied: getsockopt). Reran the affected verifier commands with approved network access; Java Maven install/package and Kotlin Maven package passed where included. Resolved for local verification; hosted CI still needs observation

Verification Log

Date Command Result
2026-05-23 python -m pytest using bundled Python 14 passed
2026-05-23 node languages/javascript/test/liblogit.test.js using bundled Node Passed with shared fixtures
2026-05-23 dotnet run --project languages/csharp/LibLogit.Tests/LibLogit.Tests.csproj Passed with shared fixtures
2026-05-23 javac + java dev.liblogit.LogitTest Passed with shared fixtures
2026-05-23 Go scaffold verification Blocked: go not available on PATH
2026-05-24 python -m pytest using installed Python 14 passed
2026-05-24 node languages/javascript/test/liblogit.test.js using installed Node Passed with shared fixtures
2026-05-24 dotnet run --project languages/csharp/LibLogit.Tests/LibLogit.Tests.csproj Passed with shared fixtures
2026-05-24 go test ./... in languages/go Passed
2026-05-24 javac + java dev.liblogit.LogitTest using installed Java Passed with shared fixtures
2026-05-24 clang C smoke compile Passed
2026-05-24 cl through vcvars64.bat Available
2026-05-24 kotlinc -version, mvn --version, cmake --version, ninja --version Available
2026-05-24 clang++ -std=c++20 -fsyntax-only against libLogit.h Passed
2026-05-24 kotlinc + kotlin dev.liblogit.LibLogItKTestKt Passed
2026-05-24 clang -std=c17 -Wall -Wextra languages/c/liblogit.c languages/c/test_logit.c Passed
2026-05-24 clang++ -std=c++20 -Wall -Wextra languages/cpp/test_logit.cpp Passed direct, config-loaded, JSON, and shared fixture behavior
2026-05-24 C and C++ basic examples compiled and ran with clang/clang++ Passed
2026-05-24 Full local alpha matrix: Python, C++, C, C#, Java, JavaScript, Go, Kotlin Passed
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py 15 passed
2026-05-24 kotlinc + kotlin dev.liblogit.LibLogItKTestKt Passed with shared fixtures
2026-05-24 Kotlin basic example compiled and ran Passed
2026-05-24 Full local alpha matrix after Python lifecycle and Kotlin fixture updates Passed
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py after SQLite sink work 17 passed
2026-05-24 python examples/python/database.py Passed; wrote direct and config-loaded SQLite events
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py after viewer query module 18 passed
2026-05-24 python -m liblogit.viewer logs/app-logit.sqlite --print --level info --limit 2 Passed
2026-05-24 Full local alpha matrix after SQLite store and viewer query module Passed
2026-05-24 clang -std=c17 -Wall -Wextra languages/c/liblogit.c languages/c/test_logit.c after C config loader Passed direct/config/shared-scenario behavior
2026-05-24 C basic example with direct and config-loaded logging Passed
2026-05-24 Full local alpha matrix after C config loader Passed
2026-05-24 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-alpha.ps1 Passed Python, JavaScript, C#, Go, Java, Kotlin, C, and C++ checks
2026-05-24 Schema validation using Python jsonschema against alpha config examples Passed; valid v1/v2 examples accepted and invalid extra-key example rejected
2026-05-24 git diff --check -- .github/workflows/alpha-matrix.yml scripts/verify-alpha.ps1 docs/burndown.md Passed with CRLF warning only
2026-05-24 CMake native package path: configure, build, ctest, install, and compile installed examples Passed
2026-05-24 Installed CMake consumer using find_package(libLogit CONFIG REQUIRED) with libLogit::c and libLogit::cpp Passed
2026-05-24 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-alpha.ps1 after native package work Passed Python, JavaScript, C#, Go, Java, Kotlin, C, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 git diff --check over native package, CI, verifier, README, ADR, and burndown changes Passed with CRLF warnings only
2026-05-24 pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py with workspace temp/cache 19 passed
2026-05-24 setup.py sdist bdist_wheel for Python package Passed; generated sdist and wheel with expected setuptools deprecation warning for direct setup.py invocation
2026-05-24 Python wheel metadata inspection Passed; wheel contains py.typed, viewer module, sample config, schema/config data files, and liblogit-viewer entry point
2026-05-24 Installed-wheel smoke test using pip install --no-index --find-links dist --target build/package-smoke liblogit==0.1.0 Passed
2026-05-24 Full Alpha verifier after Python packaging work Passed outside sandbox: Python, JavaScript, C#, Go, Java, Kotlin, C, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 dotnet pack languages/csharp/LibLogit/LibLogit.csproj --configuration Release Passed; produced LibLogit.0.1.0-alpha.0.nupkg
2026-05-24 npm.cmd pack --dry-run in languages/javascript Passed; package includes README, package metadata, and src/liblogit.js
2026-05-24 mvn -B -DskipTests package in languages/java Passed; produced liblogit-0.1.0-alpha.0.jar
2026-05-24 Full Alpha verifier after managed/package metadata work Passed outside sandbox: Python, JavaScript, npm pack, C#, NuGet pack, Go, Java, Maven package, Kotlin, C, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 mvn -B -DskipTests install in languages/java Passed; installed the Java Alpha artifact for Kotlin package resolution
2026-05-24 mvn -B -DskipTests package in languages/kotlin Passed; produced liblogit-kotlin-0.1.0-alpha.0.jar
2026-05-24 Full Alpha verifier after Kotlin Maven package work Passed outside sandbox: Python, JavaScript, npm pack, C#, NuGet pack, Go, Java install, Kotlin Maven package, C, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 clang -std=c17 -Wall -Wextra languages/c/liblogit.c languages/c/test_logit.c after C shared fixture runner Passed; C now enumerates and runs the JSON conformance fixtures
2026-05-24 Full Alpha verifier after C shared fixture runner Passed outside sandbox: Python, JavaScript, npm pack, C#, NuGet pack, Go, Java install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after viewer time filters 19 passed
2026-05-24 Full Alpha verifier after viewer filter polish Passed outside sandbox: Python, JavaScript, npm pack, C#, NuGet pack, Go, Java install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 Changed Alpha examples: JavaScript, C#, Java, and Go direct plus config-loaded examples Passed locally; Go example verified from languages/go module context
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after v2 bundled sample update 19 passed
2026-05-24 Full Alpha verifier after release docs, v2 sample, and example updates Passed outside sandbox: Python, JavaScript, npm pack, C#, NuGet pack, Go, Java install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 Bundled liblogit/data/logit.sample.json validated against schema/logit.v2.schema.json Passed with installed Python jsonschema outside sandbox
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after pathMode work 21 passed
2026-05-24 Config schema validation after v2-directory-path.json and pathMode schema additions Passed v1 legacy, all v2 valid examples, bundled v2 sample, and invalid-extra-key rejection
2026-05-24 Full Alpha verifier after pathMode behavior and schema/docs updates Passed outside sandbox: Python, JavaScript, npm pack, C#, NuGet pack, Go, Java install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 setup.py sdist bdist_wheel after package data updates Passed; sdist and wheel include logit.v1.sample.json and v2-directory-path.json
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after environment override support 25 passed
2026-05-24 Full Alpha verifier after Python environment override support Passed outside sandbox: Python, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after SQLite age/logical-byte retention 27 passed
2026-05-24 Config schema validation after retention schema expansion Passed all v2 config examples and bundled v2 sample with installed Python jsonschema
2026-05-24 Full Alpha verifier after SQLite age/logical-byte retention Passed outside sandbox: Python, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-static.ps1 Passed Python syntax, whitespace diff, parser-backed schema/config validation, and C/C++ clang-format checks inside sandbox
2026-05-24 Full Alpha verifier after static/schema/native-format gate Passed outside sandbox: Python, static checks with JSON Schema validation, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-static.ps1 after Python lint/type tooling Passed outside sandbox: Python syntax, ruff, mypy --explicit-package-bases, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-24 Full Alpha verifier after adding Python lint/type tooling to static gate Passed outside sandbox: Python, ruff, mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after explicit v0.1 load_logits() migration coverage 28 passed
2026-05-24 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-static.ps1 after migration spec/test update Passed ruff, mypy, JSON Schema validation, whitespace diff, and C/C++ clang-format checks
2026-05-24 Full Alpha verifier after marking config migration and Python registry/compatibility gates done Passed outside sandbox: Python 28 tests, ruff, mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-static.ps1 after contribution/layout/taxonomy docs Passed ruff, mypy, JSON Schema validation, whitespace diff, and C/C++ clang-format checks
2026-05-24 Full Alpha verifier after contribution workflow, layout ADR, and issue taxonomy docs Passed outside sandbox: Python 28 tests, ruff, mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 GitHub Actions static-gate parity update Added hosted static job for Python syntax, ruff, mypy, whitespace, JSON Schema/config validation, and C/C++ clang-format checks
2026-05-24 Full Alpha verifier after hosted static-gate parity update Passed outside sandbox: Python 28 tests, ruff, mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 Hosted CI release-candidate check helper Added scripts/check-hosted-ci.ps1 and alpha.1 promotion checklist; GitHub CLI auth is required before the hosted run can be observed
2026-05-24 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-static.ps1 after hosted CI helper/checklist work Passed outside sandbox: Python syntax, ruff, mypy --explicit-package-bases, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-24 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\check-hosted-ci.ps1 Blocked as documented: GitHub CLI is installed but not authenticated in this environment
2026-05-24 Full Alpha verifier after release-candidate checklist and hosted CI helper work Passed outside sandbox: Python 28 tests, ruff, mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 Binding strategy and beta intake documentation Added ADR 0003, the reusable new-binding template, Ada beta-track gap plan, beta language intake ranking, and refreshed conformance status table
2026-05-24 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-static.ps1 after binding strategy and beta intake docs Passed outside sandbox: Python syntax, ruff, mypy --explicit-package-bases, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-24 Python Level, LogEvent, structured payload, and formatter module slice Added liblogit/levels.py, liblogit/events.py, liblogit/formatters.py, and liblogit/sinks/base.py; public imports still work and dict/list/tuple payloads render deterministically
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after Python event/level/payload work 31 passed
2026-05-24 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-static.ps1 after Python event/level/payload work Passed outside sandbox: Python syntax, ruff, mypy across 12 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-24 Full Alpha verifier after Python event/level/payload work Passed outside sandbox: Python 31 tests, static checks with ruff/mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 Python LogitConfig, liblogit.logit, builder lifecycle, and sink spec slice Added public liblogit/config.py, stable object submodule liblogit/logit.py, explicit builder lifecycle tests, and spec/sinks.md
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after LogitConfig and builder lifecycle work 36 passed
2026-05-24 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-static.ps1 after LogitConfig and builder lifecycle work Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-24 Full Alpha verifier after LogitConfig and builder lifecycle work Passed outside sandbox: Python 36 tests, static checks with ruff/mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 Final static verifier after LogitConfig, sink spec, API docs, and burndown updates Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-24 Python console/file sink behavior and text-level labels Added focused tests for console threshold/timestamp/level labels, console JSON metadata, file parent directory creation, UTF-8 append behavior, and FATAL text output
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after console/file sink tests 39 passed
2026-05-24 Full Alpha verifier after console/file sink tests Passed outside sandbox: Python 39 tests, static checks with ruff/mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 Final static verifier after level spec and console/file sink burndown updates Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-24 Python per-message metadata merging Added log(..., metadata={...}), streaming .with_metadata({...}), deterministic static/event metadata precedence, JSON-lines coverage, SQLite metadata_json coverage, and invalid metadata validation
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after metadata merging 41 passed
2026-05-24 Full Alpha verifier after metadata merging Passed outside sandbox: Python 41 tests, static checks with ruff/mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 Final static verifier after metadata docs and burndown updates Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-24 Python size-based file rotation Added rotation.maxBytes and rotation.maxFiles to Python config/runtime, schema, docs, and examples; file sinks rotate to numbered backups before a write exceeds the active-file byte limit
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after file rotation 43 passed
2026-05-24 Full Alpha verifier after file rotation Passed outside sandbox: Python 43 tests, static checks with ruff/mypy, JSON Schema validation including v2-rotation.json, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 Final static verifier after file-rotation burndown update Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-24 Python redaction hooks Added redaction.keys, redaction.patterns, and redaction.mask to Python config/runtime, schema, bundled sample, examples, docs, and sink spec; messages, structured payload fields, static metadata, and per-message metadata are masked before console, file, network-file, or SQLite sinks receive events
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after redaction 46 passed
2026-05-24 Static verifier after redaction Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation including v2-redaction.json, and C/C++ clang-format checks
2026-05-24 Full Alpha verifier after redaction Passed outside sandbox: Python 46 tests, static checks with ruff/mypy, JSON Schema validation including v2-redaction.json, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 Final static verifier after redaction burndown update Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-24 Python async/batched buffering Added buffering.mode, buffering.capacity, and buffering.flushIntervalSeconds to Python config/runtime, schema, examples, docs, and sink spec; sync mode writes immediately, async mode flushes on capacity, timer interval, manual flush(), and close()
2026-05-24 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after buffering 49 passed
2026-05-24 Static verifier after buffering Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation including v2-buffering.json, and C/C++ clang-format checks
2026-05-24 Full Alpha verifier after buffering Passed outside sandbox: Python 49 tests, static checks with ruff/mypy, JSON Schema validation including v2-buffering.json, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-24 Final static verifier after buffering burndown update Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Python failure policies Added failurePolicy.mode, retryAttempts, retryDelaySeconds, and fallbackPath to Python config/runtime, schema, bundled sample, examples, docs, and sink spec; per-event sink failures now support warn, drop, raise, retry, and fallback file output
2026-05-25 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after failure policies 51 passed
2026-05-25 Static verifier after failure policies Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation including v2-failure-policy.json, and C/C++ clang-format checks
2026-05-25 Full Alpha verifier after failure policies Passed outside sandbox: Python 51 tests, static checks with ruff/mypy, JSON Schema validation including v2-failure-policy.json, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-25 Final static verifier after failure-policy burndown update Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Python thread-safety guarantees Added object-level locking around Python LOGIT configure/log/flush/close and concurrent file plus buffered logging tests that assert complete, non-interleaved event output
2026-05-25 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after thread-safety work 53 passed
2026-05-25 Static verifier after thread-safety work Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Full Alpha verifier after thread-safety work Passed outside sandbox: Python 53 tests, static checks with ruff/mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-25 Final static verifier after thread-safety burndown update Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 C++ durable layout documentation Added docs/bindings/cpp.md covering the root libLogit.h vendoring path, installed <liblogit/logit.hpp> include, libLogit::cpp CMake target, dependency notes, and migration path for existing C++ users
2026-05-25 Static verifier after C++ durable layout documentation Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Full Alpha verifier after C++ durable layout documentation Passed outside sandbox: Python 53 tests, static checks with ruff/mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-25 Final static verifier after C++ layout burndown update Passed outside sandbox: Python syntax, ruff, mypy across 14 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Python redaction module split Extracted runtime redaction helpers into liblogit/redaction.py as continued PY-01 package-split progress; the package root now imports those helpers while existing message, structured payload, and metadata masking behavior remains intact
2026-05-25 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after redaction module split 54 passed
2026-05-25 Static verifier after redaction module split Passed outside sandbox: Python syntax, ruff, mypy across 15 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Full Alpha verifier after redaction module split Passed outside sandbox: Python 54 tests, static checks with ruff/mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-25 Final static verifier after redaction module burndown update Passed outside sandbox: Python syntax, ruff, mypy across 15 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Python runtime handler split Extracted JSON/text log formatters, close-after-emit file handling, SQLite store handling, buffering, failure policies, sink-failure warnings, and the shared configuration error type into liblogit/runtime.py and liblogit/errors.py while preserving the package-root API and test monkeypatch hooks
2026-05-25 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after runtime handler split 55 passed
2026-05-25 Static verifier after runtime handler split Passed outside sandbox: Python syntax, ruff, mypy across 17 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Full Alpha verifier after runtime handler split Passed outside sandbox: Python 55 tests, static checks with ruff/mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-25 Final static verifier after runtime handler burndown update Passed outside sandbox: Python syntax, ruff, mypy across 17 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Python internal config split Extracted the internal _Config dataclass, v1/v2 config parsing, environment override handling, and normalization for sinks, retention, rotation, redaction, buffering, and failure policies into liblogit/internal_config.py; liblogit/__init__.py now keeps the public object/registry/builder surface instead of the parser body
2026-05-25 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after internal config split 56 passed
2026-05-25 Static verifier after internal config split Passed outside sandbox: Python syntax, ruff, mypy across 18 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Full Alpha verifier after internal config split Passed outside sandbox: Python 56 tests, static checks with ruff/mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-25 Final static verifier after internal config burndown update Passed outside sandbox: Python syntax, ruff, mypy across 18 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Python state and builder module split Extracted logger state/path routing/socket handling/per-message metadata validation into liblogit/state.py and streaming LOG(level) << ... << ENDL helpers into liblogit/builder.py; liblogit/__init__.py now acts as the public facade while preserving LOG, ENDL, _LoggerState, _LogBuilder, _Config, and the root file-handler monkeypatch hook
2026-05-25 python -m pytest tests/test_python_logging.py tests/test_python_conformance.py tests/test_python_packaging.py after state/builder split 57 passed
2026-05-25 Static verifier after state/builder split Passed outside sandbox after one typing fix: Python syntax, ruff, mypy across 20 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Full Alpha verifier after state/builder split Passed outside sandbox: Python 57 tests, static checks with ruff/mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-25 Final static verifier after state/builder burndown update Passed outside sandbox: Python syntax, ruff, mypy across 20 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Fixed-clock golden fixture contract Added clock.fixed_at to every shared conformance fixture, documented the fixture clock contract, and added Python fixture-contract tests that require config, messages, fixed clocks, and expected file output
2026-05-25 python -m pytest tests/test_python_conformance.py tests/test_python_logging.py tests/test_python_packaging.py after fixed-clock fixture contract 60 passed
2026-05-25 Static verifier after fixed-clock fixture contract Passed outside sandbox: Python syntax, ruff, mypy across 20 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Full Alpha verifier after fixed-clock fixture contract Passed outside sandbox: Python 60 tests, static checks with ruff/mypy, JSON Schema validation, C/C++ clang-format, JavaScript, npm pack, C#, NuGet pack, Go, Java Maven install, Kotlin Maven package, C shared fixtures, C++, CMake, CTest, install, and installed-consumer checks
2026-05-25 Final static verifier after fixed-clock fixture burndown update Passed outside sandbox: Python syntax, ruff, mypy across 20 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Hosted CI helper check Blocked outside sandbox: scripts/check-hosted-ci.ps1 reports GitHub CLI is not authenticated and asks for gh auth login; hosted workflow URL still needs authenticated observation before final RC promotion
2026-05-25 Python release artifact sanity Built dist\liblogit-0.1.0.tar.gz and dist\liblogit-0.1.0-py3-none-any.whl with bundled Python; inspected wheel/sdist contents for py.typed, liblogit-viewer, bundled configs, schema data, examples, split Python modules, conformance fixtures, and release notes
2026-05-25 Alpha RC evidence handoff Added docs/releases/v1.0.0-alpha.1-rc-evidence.md, updated the alpha.1 checklist with completed local gates, and linked the evidence from the draft release notes
2026-05-25 Final static verifier after RC evidence handoff Passed outside sandbox: Python syntax, ruff, mypy across 20 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 Passed outside sandbox: full Alpha matrix, package metadata sanity for Python/C#/JavaScript/Java/Kotlin/Go, and temp-copy Python wheel/source-distribution inspection without adding generated files to the worktree
2026-05-25 Final static verifier after repeatable RC verifier docs Passed: Python syntax, ruff, mypy across 20 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Hosted alpha workflow parity hardening Expanded .github/workflows/alpha-matrix.yml to validate all v2 config examples, bundled samples, shared fixture configs, package metadata, split Python wheel modules, and sdist release contents before hosted RC promotion
2026-05-25 Final static verifier after hosted workflow parity hardening Passed: Python syntax, ruff, mypy across 20 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Hosted CI observation helper hardening Updated scripts/check-hosted-ci.ps1 to support -HeadSha, inspect job details with gh run view, and require every Alpha job to complete successfully before release-candidate promotion
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\check-hosted-ci.ps1 after helper hardening Blocked as documented: script parses and reaches GitHub CLI auth check, then reports You are not logged into any GitHub hosts
2026-05-25 Final static verifier after hosted CI helper hardening Passed: Python syntax, ruff, mypy across 20 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 PowerShell script syntax gate Added parser-backed syntax validation for every scripts/*.ps1 file to scripts/verify-static.ps1, covering the local alpha verifier, static verifier, RC verifier, and hosted CI helper
2026-05-25 Final static verifier after PowerShell syntax gate Passed: PowerShell script parsing, Python syntax, ruff, mypy across 20 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Hosted PowerShell syntax parity Added a pwsh parser step to the hosted Static checks job so GitHub Actions validates release PowerShell script syntax before Alpha RC promotion
2026-05-25 Final static verifier after hosted PowerShell syntax parity Passed: PowerShell script parsing, Python syntax, ruff, mypy across 20 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Alpha package version alignment Aligned Python package metadata to 1.0.0a1 and C#, JavaScript, Java, and Kotlin metadata to 1.0.0-alpha.1; updated release notes, RC evidence, package ADR, local RC verifier expectations, hosted workflow checks, and Python package version coverage
2026-05-25 Focused Python tests after package version alignment First direct pytest run hit the documented Windows temp permission issue at C:\Users\Aryns\AppData\Local\Temp\pytest-of-Aryns; reran with explicit temp/cache directories and passed 61 tests
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 after package version alignment Passed outside sandbox: 61 Python tests, PowerShell/Python/schema/native static checks, JavaScript 1.0.0-alpha.1 npm pack, C# LibLogit.1.0.0-alpha.1.nupkg, Java/Kotlin 1.0.0-alpha.1 Maven packages, Go, C, C++, native CMake, and Python liblogit-1.0.0a1 wheel/source-distribution inspection
2026-05-25 Final static verifier after package version alignment Passed: PowerShell script parsing, Python syntax, ruff, mypy across 20 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Native CMake package version alignment Updated CMakeLists.txt project version to 1.0.0, added local/hosted package metadata checks for that version, and documented the native C/C++ CMake package config version in release notes, RC evidence, checklist, and packaging ADR
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 after native CMake version alignment Passed outside sandbox: 61 Python tests, PowerShell/Python/schema/native static checks, v1.0.0-alpha.1 package metadata checks, JavaScript/npm, C#/NuGet, Go, Java/Kotlin Maven, C, C++, native CMake configure/build/test/install, installed examples, installed CMake consumer checks, and Python liblogit-1.0.0a1 artifact inspection
2026-05-25 Final static verifier after native CMake version alignment Passed: PowerShell script parsing, Python syntax, ruff, mypy across 20 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Strict clean-worktree RC gate Added -RequireCleanWorktree to scripts/verify-rc-local.ps1 and documented the post-commit release gate in the checklist, release notes, RC evidence, and latest readiness snapshot
2026-05-25 Static verifier after strict RC gate docs Passed: PowerShell script parsing, Python syntax, ruff, mypy across 20 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 -SkipAlphaMatrix after strict RC gate docs Passed: package metadata sanity and temp-copy Python liblogit-1.0.0a1 wheel/source-distribution inspection; strict clean-worktree mode remains reserved for the post-commit final RC check
2026-05-25 Installed Python wheel smoke gate Added an isolated virtual-environment smoke test to scripts/verify-rc-local.ps1 so the generated wheel must install and immediately log through console, local file, remote-path-as-file, SQLite, viewer API, and installed liblogit-viewer CLI paths
2026-05-25 First installed-wheel smoke verifier run Failed usefully: the product emitted the expected console JSON lines, but the smoke test captured stdout while Python logging’s console handler writes stderr by default; adjusted the verifier to capture stderr
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 -SkipAlphaMatrix after installed-wheel smoke gate Passed: package metadata sanity, temp-copy Python liblogit-1.0.0a1 wheel/source-distribution inspection, isolated wheel install, console output, local file output, remote-path-as-file output, SQLite rows with merged metadata, viewer API filtering, and installed liblogit-viewer CLI output
2026-05-25 Shared local/hosted wheel smoke script Extracted artifact inspection and installed-wheel smoke coverage into scripts/verify-python-wheel-smoke.py, included release scripts in the source distribution, and updated the hosted Python workflow to call the same smoke proof as the local RC verifier
2026-05-25 Static verifier after shared wheel smoke script Passed: PowerShell script parsing, Python syntax, ruff, mypy across 21 source files including scripts, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 -SkipAlphaMatrix after shared wheel smoke script Passed: package metadata sanity, temp-copy Python liblogit-1.0.0a1 wheel/source-distribution inspection including release scripts, isolated wheel install, console output, local file output, remote-path-as-file output, SQLite rows with merged metadata, viewer API filtering, and installed liblogit-viewer CLI output
2026-05-25 JavaScript installed npm tarball smoke gate Added scripts/verify-javascript-package-smoke.js, wired it into scripts/verify-alpha.ps1 and hosted JavaScript CI, and verified it packs @liblogit/liblogit@1.0.0-alpha.1, installs the tarball into a fresh consumer, and immediately logs to console, local file, remote-path-as-file, and config-loaded file output
2026-05-25 Static verifier after JavaScript package smoke gate Passed: PowerShell script parsing, JavaScript syntax parsing, Python syntax, ruff, mypy across 21 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 Full Alpha verifier after adding native exit-code checks Correctly failed under sandboxed network at Java Maven install with Maven Central Permission denied: getsockopt; this confirmed the verifier now rejects native command failures instead of reporting a false pass
2026-05-25 Full Alpha verifier after native exit-code checks with network access Passed outside sandbox: 61 Python tests, static checks with PowerShell and JavaScript syntax parsing, JavaScript tests, npm pack dry-run, installed npm tarball smoke, C#/NuGet, Go, Java Maven install, Kotlin Maven package, C, C++, native CMake configure/build/test/install, installed examples, and installed CMake consumer checks
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 -SkipAlphaMatrix after JavaScript smoke script source-distribution coverage Passed: package metadata sanity, temp-copy Python liblogit-1.0.0a1 wheel/source-distribution inspection including scripts/verify-python-wheel-smoke.py and scripts/verify-javascript-package-smoke.js, isolated wheel install, console output, local file output, remote-path-as-file output, SQLite rows with merged metadata, viewer API filtering, and installed liblogit-viewer CLI output
2026-05-25 Hosted JavaScript syntax parity and RC wrapper exit-code hardening Added Node-backed JavaScript syntax parsing to the hosted static job and made scripts/verify-rc-local.ps1 fail if the child full Alpha verifier exits non-zero before package metadata or artifact promotion checks run
2026-05-25 Static verifier after hosted JavaScript syntax parity and RC wrapper hardening Passed: PowerShell script parsing, JavaScript syntax parsing, Python syntax, ruff, mypy across 21 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 -SkipAlphaMatrix after hosted JavaScript syntax parity and RC wrapper hardening Passed: package metadata sanity, temp-copy Python liblogit-1.0.0a1 wheel/source-distribution inspection, isolated wheel install, console output, local file output, remote-path-as-file output, SQLite rows with merged metadata, viewer API filtering, installed liblogit-viewer CLI output, and release smoke script source-distribution coverage
2026-05-25 Direct JavaScript installed-package smoke after hosted syntax parity Passed: packed @liblogit/liblogit@1.0.0-alpha.1, installed it into a fresh consumer, and verified console, local file, remote-path-as-file, and config-loaded file output
2026-05-25 Hosted workflow/helper release-gate parity check Added a static verifier step that confirms .github/workflows/alpha-matrix.yml exposes every job required by scripts/check-hosted-ci.ps1 and still wires the hosted Python wheel plus JavaScript npm installed-package smoke gates
2026-05-25 Static verifier after hosted workflow/helper parity check Passed: PowerShell script parsing, JavaScript syntax parsing, hosted workflow/helper required-job parity, hosted installed-package smoke wiring, Python syntax, ruff, mypy across 21 source files, whitespace diff, JSON Schema validation, and C/C++ clang-format checks
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 -SkipAlphaMatrix after hosted workflow/helper parity check Passed: package metadata sanity, temp-copy Python liblogit-1.0.0a1 wheel/source-distribution inspection, isolated wheel install, console output, local file output, remote-path-as-file output, SQLite rows with merged metadata, viewer API filtering, installed liblogit-viewer CLI output, and release smoke script source-distribution coverage
2026-05-25 Direct JavaScript installed-package smoke after hosted workflow/helper parity check Passed: packed @liblogit/liblogit@1.0.0-alpha.1, installed it into a fresh consumer, and verified console, local file, remote-path-as-file, and config-loaded file output
2026-05-25 Static-gated development-mode RC artifact checks Updated scripts/verify-rc-local.ps1 -SkipAlphaMatrix so it runs scripts/verify-static.ps1 before package metadata and artifact checks instead of allowing artifact promotion after a static-gate regression
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 -SkipAlphaMatrix after static-gated artifact mode Passed: static release gates with PowerShell parsing, JavaScript syntax parsing, hosted workflow/helper parity, Python syntax/lint/type checks, whitespace diff, config validation, and clang-format; then package metadata sanity, temp-copy Python liblogit-1.0.0a1 wheel/source-distribution inspection, isolated wheel install, console output, local file output, remote-path-as-file output, SQLite rows with merged metadata, viewer API filtering, and installed liblogit-viewer CLI output
2026-05-25 Direct JavaScript installed-package smoke after static-gated artifact mode Passed: packed @liblogit/liblogit@1.0.0-alpha.1, installed it into a fresh consumer, and verified console, local file, remote-path-as-file, and config-loaded file output
2026-05-25 Expanded Python source-distribution release manifest checks Hardened scripts/verify-python-wheel-smoke.py so the sdist must include release notes, promotion checklist, RC evidence, packaging ADR, all shared conformance fixtures, and the full release verification script set
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 -SkipAlphaMatrix after expanded sdist release manifest checks Passed: static release gates, package metadata sanity, temp-copy Python liblogit-1.0.0a1 wheel/source-distribution inspection with release docs, packaging ADR, all shared conformance fixtures, and the full release verification script set, isolated wheel install, console output, local file output, remote-path-as-file output, SQLite rows with merged metadata, viewer API filtering, and installed liblogit-viewer CLI output
2026-05-25 Direct JavaScript installed-package smoke after expanded sdist release manifest checks Passed: packed @liblogit/liblogit@1.0.0-alpha.1, installed it into a fresh consumer, and verified console, local file, remote-path-as-file, and config-loaded file output
2026-05-25 Built artifact metadata assertions Hardened scripts/verify-python-wheel-smoke.py to require exact liblogit-1.0.0a1 wheel/sdist filenames and internal metadata, and hardened scripts/verify-javascript-package-smoke.js to require exact npm pack name/version/tarball name plus installed package metadata
2026-05-25 Focused smoke after built artifact metadata assertions Passed: JavaScript installed-package smoke with tarball and installed metadata assertions, and static verifier with PowerShell parsing, JavaScript syntax parsing, hosted workflow/helper parity, Python syntax/lint/type checks, whitespace diff, config validation, and clang-format
2026-05-25 First RC verifier run after built artifact metadata assertions Failed usefully: the new sdist metadata check matched both top-level PKG-INFO and liblogit.egg-info/PKG-INFO; narrowed the check to the top-level source-distribution metadata file
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 -SkipAlphaMatrix after fixing sdist metadata selector Passed: static release gates, package metadata sanity, exact Python wheel/sdist filenames, wheel METADATA, top-level sdist PKG-INFO, release docs/fixtures/verifier scripts in the source distribution, isolated wheel install, console output, local file output, remote-path-as-file output, SQLite rows with merged metadata, viewer API filtering, and installed liblogit-viewer CLI output
2026-05-25 Direct JavaScript installed-package smoke after built artifact metadata assertions Passed: exact npm pack name/version/tarball name, installed package metadata, and console, local file, remote-path-as-file, and config-loaded file output
2026-05-25 RC-integrated JavaScript release artifact smoke Wired scripts/verify-javascript-package-smoke.js into scripts/verify-rc-local.ps1 so the local RC verifier directly packs @liblogit/liblogit, installs it into a fresh consumer, checks npm pack and installed package metadata, and proves immediate console, local file, remote-path-as-file, and config-loaded file output before Python artifact checks
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 -SkipAlphaMatrix after RC-integrated JavaScript artifact smoke Passed: static release gates, package metadata sanity, JavaScript liblogit-liblogit-1.0.0-alpha.1.tgz pack/install metadata and smoke coverage, exact Python wheel/sdist filenames, wheel METADATA, top-level sdist PKG-INFO, release docs/fixtures/verifier scripts in the source distribution, isolated wheel install, console output, local file output, remote-path-as-file output, SQLite rows with merged metadata, viewer API filtering, and installed liblogit-viewer CLI output
2026-05-25 Strict npm pack metadata assertion handling Tightened scripts/verify-javascript-package-smoke.js so parse fallback only handles unparseable npm output; package name, version, tarball name, and packed file-list metadata mismatches now fail the release smoke instead of being swallowed by the fallback path
2026-05-25 Focused verification after strict npm metadata handling Passed: JavaScript installed-package smoke with exact pack/install metadata checks, and static verifier with PowerShell parsing, JavaScript syntax parsing, hosted workflow/helper parity, Python syntax/lint/type checks, whitespace diff, JSON Schema validation, and clang-format
2026-05-25 RC-integrated C# NuGet artifact inspection Added a C# release artifact step to scripts/verify-rc-local.ps1 that packs LibLogit.1.0.0-alpha.1.nupkg from a temp copy and checks exact package filename, .nuspec id/version/license/readme/description/target framework metadata, packaged README, and lib/net10.0/LibLogit.dll
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 -SkipAlphaMatrix after C# NuGet artifact inspection Passed: static release gates, package metadata sanity, JavaScript pack/install metadata and smoke coverage, C# LibLogit.1.0.0-alpha.1.nupkg metadata and payload inspection, exact Python wheel/sdist filenames, wheel METADATA, top-level sdist PKG-INFO, release docs/fixtures/verifier scripts in the source distribution, isolated wheel install, console output, local file output, remote-path-as-file output, SQLite rows with merged metadata, viewer API filtering, and installed liblogit-viewer CLI output
2026-05-25 RC-integrated Java Maven artifact inspection Added a Java release artifact step to scripts/verify-rc-local.ps1 that packages liblogit-1.0.0-alpha.1.jar from a temp copy and checks runtime classes, embedded POM group/artifact/version/package/description metadata, and Maven properties group/artifact/version metadata
2026-05-25 First RC verifier run after Java Maven artifact inspection Failed as expected in the sandbox at Maven Central plugin resolution with Permission denied: getsockopt; reran the same verifier with approved network access
2026-05-25 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 -SkipAlphaMatrix after Java Maven artifact inspection Passed with approved network access: static release gates, package metadata sanity, JavaScript pack/install metadata and smoke coverage, C# NuGet metadata and payload inspection, Java liblogit-1.0.0-alpha.1.jar metadata and payload inspection, exact Python wheel/sdist filenames, wheel METADATA, top-level sdist PKG-INFO, release docs/fixtures/verifier scripts in the source distribution, isolated wheel install, console output, local file output, remote-path-as-file output, SQLite rows with merged metadata, viewer API filtering, and installed liblogit-viewer CLI output
2026-06-12 v1 Beta documentation pass Added and linked the public docs home, Beta overview, getting-started guide, developer instructions, binding playbook, refreshed Beta language intake, Alpha API Beta-direction note, README Beta framing, and this multiphase Beta burndown
2026-06-12 Terminology scan for API/library and broad language promises Passed review: no stale API/library wording found; remaining every language hits are explicit caveats or historical ADR wording rather than public overpromises
2026-06-12 git diff --check Passed after removing one extra blank line at EOF in docs/project/beta-language-intake.md; Git reported normal CRLF conversion warnings for edited Markdown files
2026-06-12 First powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-static.ps1 Failed because the active Python environment did not have ruff; installed ruff and mypy into the active Python environment and reran
2026-06-12 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-static.ps1 after tooling install Passed: PowerShell syntax, JavaScript syntax, hosted workflow release gate, Python syntax, ruff, mypy, whitespace diff, parser-backed config validation, and clang-format checks
2026-06-12 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-rc-local.ps1 -SkipAlphaMatrix Passed: static release gates, package metadata sanity, JavaScript installed npm tarball smoke, C# NuGet artifact inspection, Java Maven jar inspection, Python wheel/sdist inspection, sdist docs inclusion including docs/beta, isolated wheel install, console/local-file/remote-path-as-file/SQLite/viewer smoke, and installed liblogit-viewer output
2026-06-12 python -m pytest tests\test_python_logging.py -k "output_directory or directory_path_mode or logit_config_rejects_invalid_structure" Passed: direct LOGIT construction, outputDirectory alias behavior, directory-mode file naming, and conflicting pathMode rejection
2026-06-12 python -m pytest tests\test_python_conformance.py after outputDirectory contract work Passed: existing Python conformance fixtures remained green after the new local directory alias support
2026-06-12 python -m pytest tests\test_python_logging.py tests\test_python_conformance.py tests\test_python_packaging.py Passed: 64 Python tests covering logging behavior, conformance fixtures, and packaging expectations
2026-06-12 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-static.ps1 after outputDirectory implementation Passed: PowerShell syntax, JavaScript syntax, hosted workflow release gate, Python syntax/lint/type checks, whitespace diff, parser-backed schema/config validation, and clang-format checks
2026-06-12 node languages\javascript\test\liblogit.test.js after outputDirectory implementation Passed: JavaScript binding direct logging, config loading, JSON output, shared fixtures, outputDirectory alias behavior, and conflicting pathMode rejection
2026-06-12 mvn -q test in languages\java after outputDirectory implementation Passed: Java binding tests including blank declaration, config loading, JSON output, conformance fixtures, and new outputDirectory contract coverage
2026-06-12 javac + java dev.liblogit.LogitTest from repo root after outputDirectory implementation Passed: manual Java smoke compiled the binding and test harness from source and exercised the same outputDirectory contract behavior outside Maven
2026-06-12 dotnet run --project languages\csharp\LibLogit.Tests\LibLogit.Tests.csproj after outputDirectory implementation Passed: C# binding tests now cover blank declaration, config loading, JSON output, shared fixtures, outputDirectory alias behavior, and conflicting pathMode rejection
2026-06-12 go test ./... in languages\go after outputDirectory implementation Passed: Go binding tests now cover blank declaration, shared fixtures, outputDirectory alias behavior, and conflicting pathMode rejection
2026-06-12 mvn -q install in languages\java before Kotlin wrapper verification Passed: refreshed the locally installed Java artifact so Kotlin compiles against the updated outputDirectory and pathMode API surface
2026-06-12 mvn test in languages\kotlin after Java artifact refresh Passed: Kotlin wrapper compiles against the updated Java binding and package build succeeds with exposed outputDirectory and pathMode properties
2026-06-12 build\c-test-logit.exe after outputDirectory implementation Passed: C binding direct logging, shared fixtures, outputDirectory alias behavior, and conflicting pathMode config rejection
2026-06-12 cmake -S . -B build\native-outputdir plus cmake --build build\native-outputdir --config Release after native outputDirectory implementation Passed after adding a CMake fallback include-path hint for nlohmann/json.hpp, allowing the native C and C++ targets, tests, and examples to build on this workstation
2026-06-12 build\native-outputdir\Release\liblogit_cpp_tests.exe after outputDirectory implementation Passed: C++ binding direct logging, config loading, JSON output, shared fixtures, outputDirectory alias behavior, and conflicting pathMode rejection
2026-06-12 build\native-outputdir\Release\liblogit_cpp_basic.exe after outputDirectory implementation Passed: C++ example binary runs with the Beta-style output-directory setup and configured logging path
2026-06-12 ctest --test-dir build\native-outputdir -C Release --output-on-failure after native build Partial: liblogit.c passed, but Visual Studio generator test discovery did not locate liblogit_cpp_tests.exe even though the built executable exists and passes when invoked directly
2026-06-12 Shared directory_mode conformance fixture Added a new shared fixture for outputDirectory-driven derived file naming and updated Python, JavaScript, Java, C#, Go, Kotlin, C, and C++ fixture runners to rewrite directory-style paths correctly in temporary test roots
2026-06-12 python -m pytest tests\test_python_conformance.py after shared directory-mode fixture Passed: 8 Python conformance tests, including the new shared directory-mode fixture
2026-06-12 node languages\javascript\test\liblogit.test.js after shared directory-mode fixture Passed: JavaScript direct/config/shared-fixture coverage now includes the shared directory-mode case
2026-06-12 mvn -q test in languages\java after shared directory-mode fixture Passed: Java binding conformance now includes the shared directory-mode case
2026-06-12 dotnet run --project languages\csharp\LibLogit.Tests\LibLogit.Tests.csproj after shared directory-mode fixture Passed: C# binding conformance now includes the shared directory-mode case
2026-06-12 go test ./... in languages\go after shared directory-mode fixture Passed: Go binding conformance now includes the shared directory-mode case
2026-06-12 build\c-test-logit.exe after rebuilding for shared directory-mode fixture Passed: C binding shared fixtures now include the derived-name output-directory case
2026-06-12 cmake --build build\native-outputdir --config Release plus build\native-outputdir\Release\liblogit_cpp_tests.exe after shared directory-mode fixture Passed: rebuilding native tests exposed and then verified a C++ config-loader ordering fix so implicit directory mode now applies before outputDirectory conflict validation
2026-06-12 ctest --test-dir build\native-outputdir -C Release --output-on-failure after rebuilding native tests Passed: both native C and C++ CTest targets now run green with the shared directory-mode fixture in place
2026-06-12 Shared remote_path_file conformance fixture Added a new shared fixture for Alpha remote-path-as-file behavior and documented the current baseline versus advanced fixture tiers in tests/conformance/README.md
2026-06-12 python -m pytest tests\test_python_conformance.py after shared remote-path fixture Passed: 10 Python conformance tests, including the shared remote-path-as-file case
2026-06-12 node languages\javascript\test\liblogit.test.js after shared remote-path fixture Passed: JavaScript direct/config/shared-fixture coverage now includes the shared remote-path-as-file case
2026-06-12 mvn -q test in languages\java after shared remote-path fixture Passed: Java binding conformance now includes the shared remote-path-as-file case
2026-06-12 dotnet run --project languages\csharp\LibLogit.Tests\LibLogit.Tests.csproj after shared remote-path fixture Passed: C# binding conformance now includes the shared remote-path-as-file case
2026-06-12 go test ./... in languages\go after shared remote-path fixture Passed: Go binding conformance now includes the shared remote-path-as-file case
2026-06-12 build\c-test-logit.exe after shared remote-path fixture Passed: C binding shared fixtures now include the remote-path-as-file case
2026-06-12 cmake --build build\native-outputdir --config Release plus build\native-outputdir\Release\liblogit_cpp_tests.exe after shared remote-path fixture Passed: native C++ shared fixtures now include the remote-path-as-file case
2026-06-12 ctest --test-dir build\native-outputdir -C Release --output-on-failure after shared remote-path fixture Passed: native C and C++ CTest targets remain green after adding the remote-path-as-file shared fixture
2026-06-12 Blank-LOGIT baseline contract Added explicit blank-default semantics to spec/logit-object.md, mirrored the Beta direction in docs/api/README.md, and documented in tests/conformance/README.md that blank-constructor behavior is currently verified by direct binding tests rather than config-driven fixtures
2026-06-12 python -m pytest tests\test_python_logging.py -k blank_logit_can_be_configured_with_attributes Passed: Python blank LOGIT defaults now prove default name, unset local/remote paths, pathMode = file, level = info, and console in sinks before startup mutation
2026-06-12 node languages\javascript\test\liblogit.test.js after blank-LOGIT baseline assertions Passed: JavaScript blank LOGIT defaults now prove the shared startup baseline before file/path mutation
2026-06-12 mvn -q test in languages\java after blank-LOGIT baseline assertions Passed: Java blank LOGIT defaults now prove the shared startup baseline before file/path mutation
2026-06-12 dotnet run --project languages\csharp\LibLogit.Tests\LibLogit.Tests.csproj after blank-LOGIT baseline assertions Passed: C# blank LOGIT defaults now prove the shared startup baseline before file/path mutation
2026-06-12 go test ./... in languages\go after blank-LOGIT baseline assertions Passed: Go blank LOGIT defaults now prove the shared startup baseline before file/path mutation
2026-06-12 mvn test in languages\kotlin after blank-LOGIT baseline assertions Passed: Kotlin wrapper defaults now prove the shared startup baseline exposed through the wrapper surface
2026-06-12 build\c-test-logit.exe after blank-LOGIT baseline assertions Passed: C blank liblogit_logit_default() now proves the shared startup baseline before file/path mutation
2026-06-12 build\native-outputdir\Release\liblogit_cpp_tests.exe plus ctest --test-dir build\native-outputdir -C Release --output-on-failure after blank-LOGIT baseline assertions Passed: C++ blank liblogit::LOGIT{} now proves the shared startup baseline and native C/C++ test targets remain green
2026-06-12 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-static.ps1 after blank-LOGIT baseline assertions Passed after formatting the native tests with clang-format: PowerShell syntax, JavaScript syntax, hosted workflow gate, Python syntax/lint/type checks, whitespace diff, parser-backed config validation, and native formatting checks
2026-06-12 Conformance runner contract Added tests/conformance/runner-contract.md with required report fields, the current baseline command map, and the Beta direction for local-versus-hosted reporting
2026-06-12 Local machine-readable conformance report wrapper Added scripts/report-conformance.py, which discovers shared fixtures, executes the Alpha MVP binding runners, and emits a JSON report with commands, working directories, exit codes, durations, fixture tiers, discovered fixtures, and tail summaries
2026-06-12 python scripts\report-conformance.py --pretty --output logs\conformance-report.json Passed: generated a JSON conformance report showing passed status for Python, JavaScript, C#, Java, Go, Kotlin, C, and C++ against the current baseline fixture set
2026-06-12 powershell -NoProfile -ExecutionPolicy Bypass -File .\scripts\verify-static.ps1 after conformance report wrapper Passed: the new wrapper satisfies Python syntax, ruff, mypy, whitespace diff, parser-backed config validation, and native formatting checks
2026-06-12 Feature-level conformance status vocabulary Expanded tests/conformance/runner-contract.md so machine-readable reports now define passed, waived, and unverified feature statuses, evidence-source categories, and baseline versus advanced feature groups
2026-06-12 Feature-level conformance report rows Expanded scripts/report-conformance.py so each binding now reports per-feature status for blank defaults, config registry, text/file output, level filtering, JSON metadata, directory mode, remote-path-as-file, and advanced Python-only reference features versus waived cross-binding features
2026-06-12 python scripts\report-conformance.py --pretty --output logs\conformance-report.json after feature-level drift expansion Passed: regenerated the local JSON report with per-binding feature rows, baseline-vs-advanced feature tiers, Python advanced-feature passed rows backed by local tests, and explicit waived advanced rows for the other Alpha MVP bindings

v1 Beta Multiphase Burndown

This burndown is contract-first. A Beta task is not complete because a document claims the SDK is language agnostic; it is complete when the repository contains the spec, binding implementation, fixture, package artifact, verification gate, or release evidence named in the acceptance criteria.

Detailed Beta Execution Ladder

This section is the explicit “from here to any-language SDK” checklist. It is deliberately repetitive. The goal is to leave as little ambiguity as possible about what still has to happen.

Phase-by-Phase Step List

Phase B0: Public Documentation And Product Framing

  1. Keep the root README aligned with the real product promise.
  2. Keep terminology consistent: SDK, API, binding, sink, viewer, rotating store.
  3. Show the shortest possible happy path: create LOGIT, set output, set level, log.
  4. Keep at least one accurate example for every Alpha MVP language.
  5. Publish a docs home that routes evaluators, users, and contributors to the right pages quickly.
  6. Publish Beta overview, getting-started, install status, architecture, language matrix, limitations, and binding rules.
  7. Make every page honest about what exists today versus what is still Beta work.
  8. Keep docs links stable so package pages and GitHub can point at them.

Phase B1: Freeze The Portable LOGIT Contract

  1. Inventory every current public field and method in every binding.
  2. Mark each item as core, optional, legacy, Alpha-only, or internal.
  3. Decide the canonical field names.
  4. Decide alias behavior such as path versus localPath.
  5. Decide directory-mode semantics such as outputDirectory.
  6. Decide blank-construction defaults.
  7. Decide how direct logging, builder logging, and streaming logging map to one event model.
  8. Decide flush and close requirements.
  9. Decide what unsupported fields must do: reject, no-op with documentation, or defer behind a feature level.
  10. Publish the contract so new bindings stop guessing.

Phase B2: Freeze Config, Schema, And Overrides

  1. Compare the current schema to the frozen contract.
  2. Remove fields that only exist by accident.
  3. Add fields that the contract now requires.
  4. Define precedence: defaults, per-logger config, and environment overrides.
  5. Decide invalid-value behavior.
  6. Lock migration rules from v0.1 and Alpha v0.2 shapes.
  7. Publish example configs for single logger, multi-logger, directory mode, JSON, database, and remote path.
  8. Add schema validation to release gates.

Phase B3: Expand Shared Conformance

  1. Name the minimum baseline fixtures every supported binding must pass.
  2. Name advanced fixtures every mature binding should pass or explicitly waive.
  3. Add fixtures for blank construction defaults.
  4. Add fixtures for directory mode and outputDirectory.
  5. Add fixtures for remote-path-as-file behavior.
  6. Add fixtures for JSON-lines metadata merging.
  7. Add fixtures for database and retained-store behavior where portable.
  8. Make every runner rewrite temporary paths correctly.
  9. Make every runner produce machine-readable pass/fail output.
  10. Publish a drift report so divergence becomes visible immediately.

Phase B4: Make Installation Real

  1. Give every supported binding a public package identity.
  2. Give every supported binding a normal install command.
  3. Prove that install in a fresh consumer environment.
  4. Keep one direct example and one config-loaded example in that consumer environment.
  5. Inspect artifact metadata, names, and payload contents.
  6. Record artifact verification in release evidence.
  7. Make the install docs short enough that a new user can succeed on the first try.

Phase B5: Harden Local Output, Rotation, And Retention

  1. Verify exact-file path behavior.
  2. Verify directory-derived path behavior.
  3. Verify parent-directory creation rules.
  4. Verify UTF-8 append behavior.
  5. Verify no unexpected truncation.
  6. Freeze size-rotation semantics.
  7. Freeze file-count rotation semantics where supported.
  8. Freeze database retention semantics by records, age, and byte budget.
  9. Verify explicit flush and close behavior for persisted sinks.

Phase B6: Decide What “Remote” Means

  1. Keep remote-path-as-file working as the Alpha baseline.
  2. Decide whether Beta includes true network transports or only the transport plan.
  3. If true transport support is in scope, freeze serialization, retry, timeout, auth, TLS, and shutdown rules.
  4. Build local fake-server tests so no transport gate depends on an external service.
  5. Publish security guidance before shipping any real remote transport.

Phase B7: Finish The Viewer And SQL Story

  1. Freeze the SQLite schema and migration plan.
  2. Keep starter SQL queries in public docs.
  3. Verify the viewer opens the retained store reliably.
  4. Verify logger, level, text, and time filtering.
  5. Improve empty-state and error-state UX.
  6. Package the viewer command as part of the public story where supported.

Phase B8: Prove Platform Breadth

  1. Name the supported OS/runtime/compiler matrix.
  2. Run the package and conformance gates on Windows.
  3. Run them on Linux.
  4. Run them on macOS.
  5. Test representative low-resource hardware profiles.
  6. Document any intentionally unsupported environments.

Phase B9: Grow Beyond The MVP Languages

  1. Keep the Alpha baseline languages healthy first.
  2. Use the intake process for each new candidate language.
  3. Write the language proposal before implementation.
  4. Map the portable contract into that language’s idioms.
  5. Build the minimal direct logger.
  6. Build config loading.
  7. Build fixture running.
  8. Build package metadata and install docs.
  9. Promote only after conformance and release evidence exist.

Phase B10: Turn The Checks Into A Release System

  1. Keep the static verifier strict.
  2. Add markdown/docs sanity where useful.
  3. Make one local Beta verifier command.
  4. Make hosted CI match that command.
  5. Publish the required jobs list.
  6. Keep release gating dirty-worktree safe.
  7. Record artifact manifests and checksums.

Phase B11: Polish The Developer Experience

  1. Keep a clean examples index.
  2. Keep startup guides per language.
  3. Improve error messages around paths, levels, config loading, and package setup.
  4. Publish honest limitations.
  5. Keep the docs readable for evaluators, not just maintainers.

Phase B12: Declare Beta Without Hand-Waving

  1. Define the Beta readiness rubric.
  2. Gather hosted CI evidence for the release commit.
  3. Gather package artifact evidence.
  4. Gather conformance evidence.
  5. Gather platform evidence.
  6. Publish release notes with supported bindings and known limits.
  7. Confirm the README, docs, examples, and package pages all agree.
  8. Only then call the SDK Beta-ready.

B0 Documentation Foundation

Task ID Dependencies Outputs Acceptance Criteria Status
B0-01 Docs home Existing docs/ tree docs/README.md Public docs home links Beta overview, getting started, developer instructions, API reference, config guide, migration guide, and burndown. Done
B0-02 README Beta framing Public README Updated README.md README leads with install/import, create LOGIT, set output path/directory and level, then log; terminology uses SDK/API/binding consistently. Done
B0-03 Beta overview B0-01 docs/beta/README.md Overview states Beta promise, non-promises, audiences, support tiers, and roadmap shape without claiming all languages ship immediately. Done
B0-04 Getting started B0-03 docs/beta/getting-started.md Guide shows the same LOGIT pattern for Python, C++, C, C#, Java, JavaScript, Go, and Kotlin. Done
B0-05 Developer instructions B0-03 docs/beta/developer-instructions.md Instructions cover install/import status, blank LOGIT creation, output locations, levels, sinks, rotation/retention, SQL storage, remote paths, and troubleshooting. Done
B0-06 Binding playbook B0-03 docs/beta/binding-playbook.md Playbook defines support tiers, required API surface, package expectations, conformance expectations, promotion gates, and design rules. Done
B0-07 Planning terminology refresh B0-06 docs/project/beta-language-intake.md Intake doc separates supported Alpha baseline, incubating Beta candidates, and future/community bindings. Done
B0-08 Burndown expansion B0-01 through B0-07 This section Every Beta phase has task IDs, dependencies, outputs, acceptance criteria, and status. Done

B1 LOGIT Contract Stabilization

Task ID Dependencies Outputs Acceptance Criteria Status
B1-01 Contract inventory Alpha API docs, spec/ drafts Contract gap report Every existing binding field/method is mapped to the shared LOGIT contract or marked legacy/internal. Done
B1-02 Freeze core fields B1-01 Versioned LOGIT contract spec name, localPath, path, pathMode, remotePath, level, format, metadata, sinks, rotation, and retention have stable names and semantics. In progress
B1-03 Define default blank LOGIT behavior B1-02 Spec update plus fixtures A blank LOGIT has documented default level, console behavior, disabled file/database behavior, and flush/close lifecycle. In progress
B1-04 Define call semantics B1-02 Streaming/direct-call spec Direct .log() and idiomatic call/streaming APIs map to one event model across bindings. Done
B1-05 Define lifecycle semantics B1-03 Lifecycle spec Construct, configure, log, flush, close, and dispose/destruct behavior is documented per binding style. Done
B1-06 Define unsupported-field behavior B1-02 Compatibility rules Bindings must either implement a field, reject it clearly, or document a no-op; silent false support is disallowed. Done

B2 Config/Schema Stabilization

Task ID Dependencies Outputs Acceptance Criteria Status
B2-01 Schema audit B1-02, existing schemas Schema gap report v1/v2 schemas are compared against the Beta contract and every mismatch is classified. Done
B2-02 Beta schema version B2-01 schema/logit.beta.schema.json or versioned successor Schema validates named LOGIT registries, defaults, local paths, remote paths, levels, sinks, rotation, retention, metadata, and formatter settings. In progress
B2-03 Config migration rules B2-02 Migration doc/tests Legacy v0.1 and Alpha v0.2 configs have deterministic migration or rejection behavior. In progress
B2-04 Environment override rules B2-02 Spec/tests Override names, precedence, supported fields, and invalid-value behavior are documented and verified. In progress
B2-05 Config examples B2-02 Example config set Examples cover single logger, named registry, directory mode, JSON output, SQLite storage, and remote-path-as-file. In progress

B3 Cross-Language Conformance

Task ID Dependencies Outputs Acceptance Criteria Status
B3-01 Fixture manifest B1-02, B2-02 Versioned fixture manifest Fixture set names required, optional, and advanced cases with expected output semantics. In progress
B3-02 Binding runner contract B3-01 Runner interface doc Every binding can expose a local command that consumes fixtures and emits a machine-readable result. Done
B3-03 Baseline parity suite B3-02 Shared tests Python, C++, C, C#, Java, JavaScript, Go, and Kotlin all prove blank LOGIT, level filtering, console, file, and config-loaded output. In progress
B3-04 Advanced parity suite B3-03 Advanced fixtures JSON-lines, metadata merging, redaction, buffering, failure policy, directory mode, database, and retention cases are verified or explicitly waived per binding. In progress
B3-05 Drift report B3-03 Generated conformance report CI publishes which bindings pass, fail, waive, or lack each contract feature. In progress

B4 Package/Install Maturity

Task ID Dependencies Outputs Acceptance Criteria Status
B4-01 Package inventory Existing package metadata Package status matrix Each Alpha baseline binding has package name, version, artifact type, install command, and release verification status. Done
B4-02 Python package gate B4-01 Wheel/sdist release gate Isolated install proves import, direct LOGIT, local file, remote-path-as-file, SQLite, and viewer CLI behavior. In progress
B4-03 Native package gate B4-01 C/C++ install gate CMake install/export and consumer project pass on supported platforms. In progress
B4-04 Managed package gates B4-01 NuGet/Maven/Kotlin gates C#, Java, and Kotlin packages build, inspect metadata, install where practical, and run smoke examples. In progress
B4-05 JavaScript package gate B4-01 npm package gate Packed tarball installs into a fresh consumer and proves direct/config-loaded output with metadata checks. Done
B4-06 Go package gate B4-01 Go module release gate Module path, docs, examples, and go test release smoke are stable. In progress

B5 Local Output/Rotation Parity

Task ID Dependencies Outputs Acceptance Criteria Status
B5-01 Path rules parity B1-02, B3-01 Path fixtures Exact file mode and directory-derived mode are tested on Windows and POSIX-style paths. In progress
B5-02 File append parity B5-01 File sink tests Supported bindings append UTF-8 text without truncating existing logs unless rotation requires it. In progress
B5-03 Rotation contract B5-02 Rotation spec/tests Size and file-count rotation behavior is documented and verified where supported. In progress
B5-04 Retention contract B2-02 Retention spec/tests Record count, age, and byte-budget retention rules are stable for database storage. In progress
B5-05 Flush/close parity B1-05 Lifecycle tests Supported bindings guarantee deterministic file/database flush behavior on explicit close. Not started

B6 Remote Output/Transport Plan

Task ID Dependencies Outputs Acceptance Criteria Status
B6-01 Remote-path baseline B1-02, B5-01 Remote path fixtures Network-share-style paths are treated as file destinations and tested without hardcoded machine dependencies. In progress
B6-02 Transport requirements B6-01 Remote transport design doc HTTP/TCP/UDP or other future transports have named use cases, auth needs, retry behavior, and failure modes. Not started
B6-03 Transport sink interface B6-02 Interface spec Transport sinks share event serialization, timeout, retry, backoff, and shutdown semantics. Not started
B6-04 Local fake server tests B6-03 Test harness Remote transport tests run locally and in CI without external services. Not started
B6-05 Security checklist B6-02 Security doc Secrets, tokens, TLS, redaction, and network error logging rules are documented before any real transport is promoted. Not started

B7 Viewer/SQL Tooling

Task ID Dependencies Outputs Acceptance Criteria Status
B7-01 SQLite schema freeze B2-02, B5-04 Versioned database schema Table names, columns, indexes, metadata encoding, and migration/version rules are documented. In progress
B7-02 SQL inspection guide B7-01 Docs/examples Users can open retained logs with standard SQL tooling and run useful starter queries. Done
B7-03 Viewer packaging B4-02, B7-01 Viewer install gate Viewer command is included in package artifacts where supported and smoke-tested after install. In progress
B7-04 Viewer filter parity B7-01 Viewer tests Logger, level, text, and time filters are verified against fixture data. In progress
B7-05 Viewer UX polish B7-04 UI update notes/tests Empty states, errors, large stores, and path selection are handled clearly. Not started

B8 OS/Hardware Validation

Task ID Dependencies Outputs Acceptance Criteria Status
B8-01 Platform matrix B4 package gates OS/architecture matrix Supported OS, CPU architecture, shell, compiler/runtime, and package manager combinations are named. Not started
B8-02 Windows validation B8-01 Windows CI/local evidence Package, conformance, path, viewer, and artifact gates pass on Windows. In progress
B8-03 Linux validation B8-01 Linux CI evidence Package, conformance, path, and artifact gates pass on Linux. Not started
B8-04 macOS validation B8-01 macOS CI evidence Package, conformance, path, viewer where available, and artifact gates pass on macOS. Not started
B8-05 Hardware/resource profile B8-01 Performance/resource report Representative low-resource and normal desktop profiles are tested for startup, write throughput, rotation, and viewer load. Not started

B9 Language Expansion

Task ID Dependencies Outputs Acceptance Criteria Status
B9-01 Intake governance B0-07, B0-06 Intake checklist New languages use supported/incubating/future terminology and the binding proposal template. Done
B9-02 TypeScript path B4-05 TypeScript plan/artifact TS declarations or source package strategy is chosen and tested against JavaScript package shape. Not started
B9-03 Rust-style path B0-06 Rust proposal Ownership, sync/async, package, and fixture runner design are documented before implementation. Not started
B9-04 Swift/macOS path B8-04 Swift proposal Swift package and macOS CI requirements are documented. Not started
B9-05 Community binding kit B0-06, B3-02 Template repo/doc A contributor can scaffold docs, fixtures, examples, and package metadata for a new binding. Not started

B10 CI/Release Gates

Task ID Dependencies Outputs Acceptance Criteria Status
B10-01 Static gate expansion B0 docs, existing static verifier Static verifier updates Markdown links, stale terminology checks, schema checks, script parsing, lint/type checks, and package metadata checks run locally. In progress
B10-02 Alpha-to-Beta release wrapper B4 gates, B3 gates Beta verifier script One local command can run static gates, package gates, conformance, and artifact checks for Beta candidates. Not started
B10-03 Hosted workflow parity B10-02 CI workflow/report Hosted required jobs match local release gates and fail on missing required steps. In progress
B10-04 Release artifact manifest B4 gates Artifact manifest Every release artifact name, version, checksum/signature policy, and inspection result is recorded. Not started
B10-05 Clean-worktree final gate B10-02 Release gate Final promotion refuses dirty worktrees or untracked generated artifacts unless explicitly allowed. In progress

B11 Developer Experience Polish

Task ID Dependencies Outputs Acceptance Criteria Status
B11-01 Example index B0 docs, B4 package gates Examples landing page Users can find direct, structure-fed, config-loaded, database, and viewer examples by language. Done
B11-02 Error message review B1-06 Error taxonomy Common setup failures produce actionable messages across supported bindings. In progress
B11-03 Starter project guides B4 gates Per-language starter docs Each supported binding has a minimal project setup guide using that ecosystem’s normal tooling. Done
B11-04 Troubleshooting expansion B0-05 Troubleshooting guide File permissions, missing directories, level filters, package install failures, remote paths, and viewer/database mismatches are covered. In progress
B11-05 Public limitations page B1-06, B3-05 Limitations doc Known unsupported fields and binding-specific gaps are listed without marketing ambiguity. Done

B12 Beta Exit/Public Release

Task ID Dependencies Outputs Acceptance Criteria Status
B12-01 Beta readiness rubric B1 through B11 Rubric doc The project has explicit percentage criteria and required evidence for declaring Beta. Done
B12-02 Public release notes B12-01 Beta release notes Notes describe supported bindings, install commands, known limitations, migration notes, and verification evidence. In progress
B12-03 Hosted CI observation B10-03 CI evidence log Required hosted workflows pass for the release commit and are recorded with commit SHA. Not started
B12-04 Release candidate promotion B12-02, B12-03 RC evidence doc Artifacts, docs, conformance, packages, and clean-worktree gate are recorded for the Beta RC. In progress
B12-05 Beta announcement readiness B12-04 Public launch checklist README, docs home, package pages, examples, and issue templates are ready for public developer traffic. In progress

Risk Register

Risk Impact Mitigation
Operator streaming syntax cannot be identical in every language. API may feel inconsistent. Define canonical semantics and idiomatic equivalents per binding.
Config schema grows too fast. Harder to implement all bindings. Mark advanced fields optional and gate them through conformance levels.
Per-language implementations drift. Users see different behavior. Golden fixtures and conformance runners are required before release.
Destructor/finalizer commits behave differently. Messages may emit unpredictably. Prefer explicit commit/flush and document best-effort finalizer behavior.
File and path rules differ by OS. Cross-platform bugs. Add Windows/POSIX path fixtures and normalize only where the spec says to.
Async logging adds complexity. Race conditions or lost logs. Ship sync first; add async behind explicit config and shutdown tests.

Beta Execution Ledger

This appendix is intentionally more granular than the phase tables above. It is the “do every remaining thing” checklist for moving from the current project state to a Beta-supported SDK.

B1 Contract Tasks

B2 Schema Tasks

B3 Conformance Tasks

B4 Package Tasks

B5 Local Output Tasks

B6 Remote Tasks

B7 Viewer And SQL Tasks

B8 Platform Tasks

B9 Language Expansion Tasks

B10 CI And Release Tasks

B11 Developer Experience Tasks

B12 Beta Exit Tasks

Suggested First Sprint

Start with the path that unlocks the whole project:

  1. Write spec/logit-object.md.
  2. Draft schema/logit.v2.schema.json.
  3. Refactor Python internals into modules.
  4. Implement Python Logit(path=..., level=...).
  5. Preserve init_from_config and LOG as compatibility shims.
  6. Add tests proving direct LOGIT creation and v0.1 config migration.

Exit criteria for the first sprint: