IF Commons GitHub

Commons libraries

0027Draft

0027-commons-libraries · owner if · domain commons · part of 0003-mizan

What a library is

FR-001checkfailing

A library of commons MUST be a top-level folder commons/<name>/ that holds a spec kit of its own at commons/<name>/spec-kit/ in the form 0003-mizan gives every harness (registry.tsv, enforcement.tsv, mizan.baseline.txt and specs/NNNN-slug/spec.md), a package.json whose name is @intellectual-frontiers/<name>, an about.ts, a manifest library.ts (FR-012) and a verify script, so that it is checked, tested and documented with nothing of commons but the packages it imports.

Enforced (check): .github: bun test ./tests/ — commons-libraries.test.ts: every commons/*/spec-kit is in a folder with registry.tsv, enforcement.tsv, mizan.baseline.txt, specs/, a package.json named @intellectual-frontiers/<folder>, an about.ts and a verify script

Tests: failed: tests/commons-libraries.test.ts this repository's libraries have no finding, and commons/data is one; passed: tests/commons-libraries.test.ts a library without an about.ts, or with another package name, is found

FR-002checkpassing

A library's specifications MUST be numbered from 0001 in its own registry, and its requirements MUST belong to it: this repository's registry (commons/spec-kit/registry.tsv) MUST NOT list a specification of a library, and a library's enforcement.tsv MUST have one row for each of its own requirements and none for a requirement of this repository.

Enforced (check): .github: bun test ./tests/ — commons-libraries.test.ts: the registry here lists no specification of a library, and a library numbers its own from 0001 with a gapless registry

Tests: passed: tests/commons-libraries.test.ts a specification of a library listed in commons' registry, or a registry that does not star

FR-003checkno test run

A citation in a library's files (a // Spec: line, a proves( call, the spec of an ontology term) MUST be read against that library's spec kit alone, so that a slug both have (their numbers are independent) means the library's.

Enforced (check): .github: cd commons/data && bun run verify — commons/data suite/trace.test.ts: a citation of a specification that exists only in commons is unknown to the library's trace, and one of its own is known

FR-004checkfailing

A library MUST import the packages of commons it uses by package name (0005-typescript-practice FR-076), and MUST NOT import by a relative path a file outside its own folder.

Enforced (check): .github: bun test ./tests/ — commons-libraries.test.ts: no file of a library imports by a relative path a file outside its folder, and one that does is found

Tests: failed: tests/commons-libraries.test.ts a library file that imports by a relative path outside its folder is found, and one inside

FR-005checkpassing

A library's verify script MUST run from the library's folder with no argument, and MUST fail if any of its parts fails: the TypeScript compiler on the library, the specification checker on its spec kit (bun ../tools/mizan-check.ts --root spec-kit), the Mizan rules on it at the level its manifest declares (bun ../libraries/src/check.ts --root spec-kit, with --level where the level is below L3, 0028-conformance-levels FR-013) and the library's tests.

Enforced (check): .github: bun test ./tests/ — commons-libraries.test.ts: the verify script of each library runs the compiler, the specification checker and the rules on its spec kit, and its tests; one that leaves a part out is found

Tests: passed: tests/commons-libraries.test.ts a verify that leaves out the compiler, a checker or the tests is found

FR-006checkpassing

A library's verify script MUST also run tools/check.ts, the trace of its sources and tests to its own specifications (0015-trace) and the check of its layers, whose findings are held by a baseline of its own (trace.baseline.txt).

Enforced (check): .github: bun test ./tests/ — commons-libraries.test.ts: a verify that does not run tools/check.ts is found; commons/data's tools/check.ts holds its trace and layers findings against trace.baseline.txt

Tests: passed: tests/commons-libraries.test.ts a verify that does not run the trace and layers check is found

What this repository knows

FR-007checkfailing

This repository MUST know each library by its manifest (FR-012) as exactly one requirement of this specification, in the section "The libraries", named by the library's folder, whose enforcement is the library's own verify (a check row that runs cd commons/<name> && bun run verify); no requirement of a library MUST be a requirement of this repository (amended 2026-11-18: the requirement is made from the manifest, FR-011, and no longer written by hand).

Enforced (check): .github: bun test ./tests/ — commons-libraries.test.ts: each library is named by one requirement of this specification, and that requirement is a check row that runs the verify of its folder

Tests: failed: tests/commons-libraries.test.ts this repository's libraries have no finding, and commons/data is one; passed: tests/commons-libraries.test.ts a requirement for a library whose enforcement is not its verify is found

Cited by: Generated workflows

FR-008checkfailing

A test of this repository MUST find every folder commons/* that has a manifest or a spec kit and fail where a spec kit has no manifest, where the section "The libraries" or its rows are not what the manifests make (FR-011), where a manifest and its folder disagree (FR-013), where a library lacks a part FR-001 names, where its verify lacks a part FR-005 names, where a file of the library imports by a relative path outside its folder (FR-004), or where the specification checker finds anything in its spec kit (amended 2026-11-18).

Enforced (check): .github: bun test ./tests/ — commons-libraries.test.ts: a folder no requirement names, a requirement naming no folder, a missing part, a verify without a part, an escaping import and a finding of the specification checker are each found, on a copy, by the real tool

Tests: passed: suite/libraries.test.ts this repository's manifests agree with their folders, and its section and rows are what th; passed: suite/libraries.test.ts a folder with a spec kit and no manifest is found, a manifest that cannot be read is found; failed: tests/commons-libraries.test.ts this repository's libraries have no finding, and commons/data is one; passed: tests/commons-libraries.test.ts a finding of the specification checker in a library's spec kit is found, and the real tool; passed: tests/commons-libraries.test.ts a folder with a spec kit that no requirement names is found, with the parts it lacks and 1 more

FR-009checkpassing

The documentation of commons (commons/docs.config.ts) MUST name each library's spec kit among its spec kits, so that the specifications of a library are published with those of commons and none is published twice.

Enforced (check): .github: bun test ./tests/ — commons-libraries.test.ts: docs.config.ts names the spec kit of each library once

Tests: passed: tests/commons-libraries.test.ts a library whose spec kit the documentation does not name once is found

FR-010checkfailing

Each library MUST be proved by the one workflow .github/workflows/ci.auto.yml, made from the manifests (0030-generated-workflows FR-006): it plans which libraries a push or a pull request affects and runs the verify of each of those, on every push and pull request that changes commons, on Linux and the runtimes 0005-typescript-practice names, and on Windows and macOS for the libraries whose record of CI names them; a library MUST NOT have a workflow of its own.

Enforced (check): .github: bun test ./tests/ — commons-libraries.test.ts: the libraries are proved by the one workflow ci, which plans and runs verify; a missing one, one that does not plan or run verify, and a library with a workflow of its own are found

Tests: failed: tests/commons-libraries.test.ts the libraries are proved by the one workflow ci, which plans and runs verify; a missing on

The manifest

FR-011checkpassing

The section "The libraries" of this specification, and the rows of its requirements in enforcement.tsv, MUST be generated from the manifests by commons/libraries/src/libraries.ts: one requirement and one row for each library, numbered from FR-101 and keeping the number a library was given, between the markers <!-- libraries:begin --> and <!-- libraries:end -->; with --check it MUST write nothing and exit 1 where either file is not what the manifests make.

Enforced (check): .github: cd commons/libraries && bun test suite/ — libraries.test.ts: the section and its rows are made from the manifests, keep a library's number, number a new one from FR-101 after the greatest, are written again byte for byte, and a hand edit or a specification with no markers is found; this repository's section is what its manifests make

Proved by: data/suite/governance-vocabularies.test.ts

Tests: passed: suite/libraries.test.ts this repository's manifests agree with their folders, and its section and rows are what th; passed: suite/libraries.test.ts the section and its rows are made from the manifests, keep a library's number, number a ne; passed: suite/libraries.test.ts a checkout with CRLF line ends (a Windows one) finds the markers and the section as it doe; passed: tests/commons-libraries.test.ts the table of the libraries in the root README is what the manifests make: a library added,

Cited by: Libraries, libraries, Libraries

FR-012checkpassing

A library MUST declare itself with commons/<name>/library.ts, whose only export is library, an object literal of data that a program reads as data and never runs (0026-works-versioning FR-008 reads a record so): name (its folder), level (L0, L1, L2 or L3; L1 where it declares none, 0028-conformance-levels), specKit (the path of its spec kit from its folder, which a level above L0 MUST have), verify (the command that proves it, bun run verify), version and exports (the keys of the package's exports), and it MAY carry summary, distribution (FR-015), kanon (0033-kanon FR-010) and family (FR-023); an unknown field or a wrong type MUST be an error that names the field.

Enforced (check): .github: cd commons/libraries && bun test suite/ — libraries.test.ts: a manifest is read as data (L1 where it declares no level), and an unknown field, a level that is not one of the four, a name that is not lower-case, exports that are not a list, a second export and a value that is not a literal are each an error that names what is wrong

Tests: passed: suite/libraries.test.ts a folder with a spec kit and no manifest is found, a manifest that cannot be read is found; passed: suite/libraries.test.ts a manifest is read as data: its fields, L1 where it declares no level, and an error that n

Cited by: generate-workflows, libraries, workflows/definitions, levels, Conformance levels, Generated workflows, Libraries by concern, Kanon

FR-013checkpassing

A manifest MUST agree with its folder: its name is the folder's, the package is named @intellectual-frontiers/<name>, its version is the package's, its exports are the keys of the package's exports, its verify is a script of the package, its specKit has a registry.tsv, and the verify script runs the Mizan check with --level of its level where the level is L1 or L2; a test MUST fail where any of these differs.

Enforced (check): .github: cd commons/libraries && bun test suite/ — libraries.test.ts: a name, a package name, a version, an export, a verify script, a spec kit and a level in the verify script that disagree with the manifest are each named

Tests: passed: suite/libraries.test.ts this repository's manifests agree with their folders, and its section and rows are what th; passed: suite/libraries.test.ts a manifest that agrees with its folder and package has no finding, and each disagreement i

Cited by: libraries, Conformance levels, Kanon

FR-014checkpassing

Registering a library MUST be adding a folder commons/<name>/ with its manifest, its package, its spec kit and its workflow, and running the generator (FR-011): no requirement of this specification is written by hand for it.

Enforced (check): .github: cd commons/libraries && bun test suite/ — libraries.test.ts: a folder with a manifest and its package is registered by the generator alone, as a new requirement and a new row, with no line written by hand

Tests: passed: suite/libraries.test.ts the section and its rows are made from the manifests, keep a library's number, number a ne

Cited by: Libraries, libraries

Where a library is published

FR-015checkpassing

In per-library distribution mode (0036-distribution FR-019) a library MUST be published as a package of the GitHub package registry of this organization, public or private, named @intellectual-frontiers/<name>, and its manifest MUST declare it in distribution with the registry github; in single mode, the mode of this repository, every library MUST be published inside the one package @intellectual-frontiers/commons under its name (@intellectual-frontiers/commons/<name>, 0036-distribution FR-021), to the GitHub package registry, and its manifest MUST still declare its distribution, which the mode of the repository does not change.

Enforced (check): .github: cd commons/libraries && bun test suite/ — libraries.test.ts: a library is published to GitHub and, where a decision says so, to npm as well; the default, the refusals and the registries in the requirement

Tests: passed: suite/libraries.test.ts a library is published to GitHub and, where a decision says so, to npm as well: the defaul

Cited by: Onboarding, Licensing, Distribution

FR-016checkpassing

In per-library mode a library MAY also be published to npm, which a decision about that one package makes, when it needs what npm gives and the GitHub package registry does not (installation with no token, discovery, trusted publishing); the library MUST remain published to the GitHub package registry as well, so that every package is available there. In single mode the one package is sent to the registries of SINGLE_TARGETS (0036-distribution FR-028), which is the GitHub package registry alone while the npm target is off.

Enforced (check): .github: cd commons/libraries && bun test suite/ — libraries.test.ts: a library is published to GitHub and, where a decision says so, to npm as well; the default, the refusals and the registries in the requirement

Tests: passed: suite/libraries.test.ts a library is published to GitHub and, where a decision says so, to npm as well: the defaul

Cited by: Onboarding

FR-017checkpassing

A manifest MUST declare where its library is published in distribution, a list of registries from github and npm, each once, which is ["github"] where the manifest declares none, and the section "The libraries" MUST name the registries in each requirement.

Enforced (check): .github: cd commons/libraries && bun test suite/ — libraries.test.ts: a library is published to GitHub and, where a decision says so, to npm as well; the default, the refusals and the registries in the requirement

Tests: passed: suite/libraries.test.ts a library is published to GitHub and, where a decision says so, to npm as well: the defaul

FR-018checkpassing

A manifest and this specification MUST name a registry by its kind alone (github, npm) and MUST NOT name the host of a private registry, a token or a credential; the configuration a consumer needs to install from a registry belongs in the consumer's own repository.

Enforced (check): .github: cd commons/libraries && bun test suite/ — libraries.test.ts: a library is published to GitHub and, where a decision says so, to npm as well; the default, the refusals and the registries in the requirement

Tests: passed: suite/libraries.test.ts a library is published to GitHub and, where a decision says so, to npm as well: the defaul

Cited by: libraries, Libraries, Licensing, Distribution

What a change affects

FR-019checkpassing

A library's dependencies on other folders of commons MUST be read from its package.json, a dependency whose version is a link:, file: or workspace: path, and MUST NOT be written a second time in its manifest.

Enforced (check): .github: cd commons/libraries && bun test suite/ — affected.test.ts: a dependency by link:, file: or workspace: path is read from the package, with a dependency library, and a registry version is none

Tests: passed: suite/affected.test.ts a library's dependencies are read from its package (link: to a folder, a registry version

Cited by: affected, Libraries, Libraries, Generated workflows

FR-020checkpassing

The inputs of a library, the files its checks read, MUST be its folder, commons/tools/**, .github/actions/**, the workflow ci, the entries of each dependency that its sources import (the file that the dependency's exports gives each import) and the paths to other folders that its scripts run, and every file that those files import by a relative path, followed file by file; an import that the dependency's exports does not give MUST take the whole dependency.

Enforced (check): .github: cd commons/libraries && bun test suite/ — affected.test.ts: a library's inputs are its folder, the shared tools, the entries it imports and what they import by relative paths, the files its scripts run, and a whole dependency where an import has no export

Tests: passed: suite/affected.test.ts a library's dependencies are read from its package (link: to a folder, a registry version

FR-021checkpassing

commons/libraries/src/affected.ts MUST print, for the files changed (--base REF from Git, from the merge base with the head, or --files), the libraries they affect as {"include":[{"name","folder","verify"}]} in the order of the folders' names, where a library is affected if a changed file is among its inputs or a library it depends on is affected, and MUST print every library with --all and where Git cannot say what changed.

Enforced (check): .github: cd commons/libraries && bun test suite/ — affected.test.ts: a changed file affects the libraries that read it and those that depend on them, a shared file every library, and a file no library reads none; the matrix, --files, --all and a base Git does not know

Tests: passed: suite/affected.test.ts a changed file affects the libraries that read it and those that depend on them, a shared

FR-022checkpassing

The libraries that CI runs for a change MUST be the libraries this planner affects (0030-generated-workflows FR-006, FR-007), so that what CI runs and what the planner affects are the same, and the development loop (commons 0001-libraries FR-011) MUST read the same planner with the narrower reach of a library's own code: its folder and the packages its own sources import, which is what its types and its tests read.

Enforced (check): .github: cd commons/libraries && bun test suite/ — affected.test.ts: the development loop reads the same planner with the reach of a library's own code (what its sources import and who imports it), and neither a tool its scripts run nor a workflow; plan.test.ts: CI runs the libraries the planner affects

Tests: passed: suite/affected.test.ts the development loop reads the same planner with the reach of a library's own code: what i

Cited by: affected, Libraries, Libraries, Generated workflows

FR-023checkno test run

A manifest MAY carry family, the host (a library's name) and the role of the library in that family (host, dialect or plugin), which is how a family of libraries (a host, a dialect for each tool and a plugin for each noun, 0033-kanon FR-019 to FR-021) is one thing to the register: the check of the manifests MUST hold the two sides of a family together, a member named as the host's kanon table's family rule reads it and declared by that table and registered by a manifest that names the host, a host named as its family and a member whose own table says extends the host's package.

Enforced (check): .github: cd commons/libraries && bun test suite/ — family.test.ts in commons/libraries: the family field and the two sides of a family held together by the check of the manifests

Cited by: family, Libraries, Kanon

FR-024checkno test run

The names that no library may take until the library they are held for exists MUST be reserved as data of the check of the manifests, each an exact name or a prefix with the host whose family may hold it, never by an empty folder: a library whose name a reservation holds MUST be refused by the check unless its manifest declares that host's family. The names held are archon, archon-*, signing, gitops and estate (intellectual-frontiers/.github#11). content and content-* are held for the host content, Kanon for content, until it exists (intellectual-frontiers/.github#22).

Enforced (check): .github: cd commons/libraries && bun test suite/ — family.test.ts in commons/libraries: the reserved names are found from data with no folder, and a library of the family may hold them

Cited by: family, Libraries, Kanon

FR-025checkpassing

A library MAY have a folder named acceptance, oat, uat or aat of acceptance kits (testing by people or by agents acting as people, for the experience beyond the code, with synthetic data), each kit a folder of it and the folder having a spec kit of its own at <folder>/spec-kit. Such a folder is not a library: the check of the libraries, the documentation's list of spec kits and the library's trace MUST NOT treat it as one, and no specification of the repository or of the library MUST name a specification of a kit. The folder's own checks are run apart from the library's verify.

Enforced (check): .github: bun test ./tests/ — commons-libraries.test.ts: the acceptance kits of a library are not libraries: no list of the libraries, no spec kit of the documentation and no specification of the library or the repository names one

Tests: passed: tests/commons-libraries.test.ts the acceptance kits of a library are not libraries: no list of the libraries, no spec kit

Cited by: pack-commons, Documentation

The libraries

The requirements below are generated (FR-011); change a manifest and run bun commons/libraries/src/libraries.ts, never this section.

<!-- libraries:begin -->

FR-101checkno test run

commons/data MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/arcactl at version 0.10.1, its spec kit at commons/data/spec-kit, exporting ./engine, ./governance, ./sql/logical, ./sql/physical, ./models/arca, ./issues, ./models/arca-tenancy, ./models/identity, ./models/identity-access, ./models/identity-abac, ./models/identity-rebac, ./models/identity-pki, ./models/identity-machine, ./models/identity-device, ./models/identity-delegation, ./models/identity-agent, ./models/issues, ./models/flow, ./models/proof, ./models/operations, ./models/contract, ./models/meaning, ./sql/dialects/postgres, ./sql/dialects/sqlite, ./sql/dialects/duckdb, ./sql/lifecycle, ./sql/extensions/documentation, ./sql/extensions/views, ./sql/extensions/access, ./sql/extensions/routines, ./sql/extensions/partitions, ./sql/extensions/generators, ./sql/extensions/idempotency, ./sql/extensions/protected-access, ./sql/extensions/safety, ./sql/extensions/plan-report, ./sql/extensions/rewrite, ./sql/extensions/history, ./sql/extensions/convergence, ./sql/extensions/rollout, ./sql/extensions/integrations, ./sql/extensions/transforms, ./sql/extensions/queries, ./sql/extensions/target, ./sql/extensions/kinds, ./sql/extensions/osquery-atc, ./sql/extensions/operations, ./sql/extensions/invariants, ./sql/extensions/objects, ./sql/extensions/assertions, ./sql/extensions/osquery, ./sql/quality, ./sql/drivers, ./sql/typed, ./sql/loads, ./sql/describe, ./sql/federate, ./sql/flow, ./sql/proof, ./sql/operations, ./sql/contract, ./sql/meaning, ./sql/typed/generate, ./sql/typed/models, ./sql/extensions/issues, ./sql/presets and ./sql/cli, published to the GitHub package registry and npm, proved by cd commons/data && bun run verify. A governance layer, a logical schema and a physical schema, and the extensions to each, produce SQL for PostgreSQL, SQLite and DuckDB; its own specifications say what it does.

Enforced (check): .github: cd commons/data && bun run verify — commons/data: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

Cited by: Libraries

FR-102checkno test run

commons/ergonex MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/ergonex at version 0.5.7, its spec kit at commons/ergonex/spec-kit, exporting ., published to the GitHub package registry and npm, proved by cd commons/ergonex && bun run verify. The workspaces management of Intellectual Frontiers: one command, ergonex, that sets up and operates a team's repositories, tools and shell on Windows, macOS and Linux, with its own specifications.

Enforced (check): .github: cd commons/ergonex && bun run verify — commons/ergonex: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-103checkno test run

commons/core MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/core at version 0.2.1, its spec kit at commons/core/spec-kit, exporting . and ./about, published to the GitHub package registry and npm, proved by cd commons/core && bun run verify. The foundation of commons: errors as values, exhaustive matching, branded types, decoders from unknown, pure text helpers, type-level tests, graphs of work and exact optional objects, with no dependency and no host.

Enforced (check): .github: cd commons/core && bun run verify — commons/core: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-104checkno test run

commons/rdf MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/rdf at version 0.2.1, its spec kit at commons/rdf/spec-kit, exporting ., published to the GitHub package registry and npm, proved by cd commons/rdf && bun run verify. RDF as algebraically typed values: branded IRIs, namespaces, typed vocabularies, class schemas, code lists, and the writers of N-Triples, N-Quads, canonical Turtle and JSON-LD, with no host.

Enforced (check): .github: cd commons/rdf && bun run verify — commons/rdf: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-105checkno test run

commons/terminal MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/terminal at version 0.2.1, its spec kit at commons/terminal/spec-kit, exporting ., ./args, ./commands, ./palette, ./vt and ./width, published to the GitHub package registry and npm, proved by cd commons/terminal && bun run verify. The terminal as pure code: a typed command-line parser and command trees, the one palette of colour roles and marks, display width and cutting by columns, and a terminal emulator for snapshot tests, with no host.

Enforced (check): .github: cd commons/terminal && bun run verify — commons/terminal: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-106checkno test run

commons/crypto MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/crypto at version 0.2.3, its spec kit at commons/crypto/spec-kit, exporting ., ./cms, ./cose, ./crypt, ./dsse, ./md5, ./sha256, ./sigv4, ./uuid and ./webauthn, published to the GitHub package registry and npm, proved by cd commons/crypto && bun run verify. The digests, signatures and envelopes of commons in pure code on Web Crypto: SHA-256 (branded), MD5, SHA-512 crypt, UUIDs, AWS Signature Version 4, CMS encrypted content, in-toto statements in DSSE envelopes, COSE keys and WebAuthn for a relying party; dependencies: core and formats.

Enforced (check): .github: cd commons/crypto && bun run verify — commons/crypto: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-107checkno test run

commons/formats MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/formats at version 0.2.3, its spec kit at commons/formats/spec-kit, exporting ., ./archive, ./base64, ./cbor, ./csv, ./der, ./glob, ./hex, ./http, ./json5, ./media-types, ./png, ./semver, ./toml, ./ts-literal, ./xml, ./xz and ./yaml, published to the GitHub package registry and npm, proved by cd commons/formats && bun run verify. The file and wire formats of commons, read and written in pure code: JSON5, YAML, TOML, XML, CSV, base64, hexadecimal, ASN.1 DER, CBOR, tar, gzip, xz and zip archives, PNG and ICO pictures, TypeScript literals, glob patterns, semantic versions, media types and HTTP headers; one dependency, core.

Enforced (check): .github: cd commons/formats && bun run verify — commons/formats: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-108checkno test run

commons/system MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/system at version 0.2.5, its spec kit at commons/system/spec-kit, exporting ., ./errors, ./fs, ./path, ./dirs, ./lock, ./watch, ./discover, ./proc, ./git, ./compile, ./schedule, ./job-plan, ./tty and ./stdio, published to the GitHub package registry and npm, proved by cd commons/system && bun run verify. The host system as one typed library: files, paths and the folders of a program, one run at a time, file watching, programs found by prefix, processes and their streams, Git, a program built into one binary, the operating system's scheduled jobs and the standard streams; dependencies: core, formats and crypto.

Enforced (check): .github: cd commons/system && bun run verify — commons/system: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-109checkno test run

commons/telemetry MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/telemetry at version 0.2.7, its spec kit at commons/telemetry/spec-kit, exporting ., ./otel, ./otlp, ./signals, ./render, ./query, ./host/query, ./host, ./host/otel and ./host/console, published to the GitHub package registry and npm, proved by cd commons/telemetry && bun run verify. OpenTelemetry-native signals written from the specification itself: the data model, W3C Trace Context, OTLP/HTTP JSON, typed signals, a pure renderer of the console, and a host that exports, journals and shows them.

Enforced (check): .github: cd commons/telemetry && bun run verify — commons/telemetry: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-110checkno test run

commons/net MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/net at version 0.2.7, its spec kit at commons/net/spec-kit, exporting ., ./net, ./tcp, ./dns, ./http-client, ./serve and ./acme, published to the GitHub package registry and npm, proved by cd commons/net && bun run verify. The network as one typed library: downloads that retry and resume, an HTTP server over web Request and Response, typed HTTP clients with recorded transports and AWS signing, TCP and TLS, DNS records, and ACME certificates by DNS-01.

Enforced (check): .github: cd commons/net && bun run verify — commons/net: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-111checkno test run

commons/test MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/test at version 0.2.7, its spec kit at commons/test/spec-kit, exporting . and ./record, published to the GitHub package registry and npm, proved by cd commons/test && bun run verify. Tests that run unchanged under bun test and node --test and are recorded as evidence by their own code: the assertions under short plain names, proves (which names the requirements a test proves), only, steps, and the record of every test as an OpenTelemetry span and log record on the installation record.

Enforced (check): .github: cd commons/test && bun run verify — commons/test: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-112checkno test run

commons/lint MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/lint at version 0.2.5, its spec kit at commons/lint/spec-kit, exporting ., ./rule and ./test-rule, published to the GitHub package registry and npm, proved by cd commons/lint && bun run verify. The lint plugin of Intellectual Frontiers in the ESLint plugin format that bun lint --plugin loads: the rules every harness wants, the typed way to define a rule of its own and the way to run a rule against code in a test.

Enforced (check): .github: cd commons/lint && bun run verify — commons/lint: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-113checkno test run

commons/grc MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/grc at version 0.3.7, its spec kit at commons/grc/spec-kit, exporting ., ./governance, ./logical, ./physical, ./conformance, ./standard, ./serializers/oscal, ./serializers/ocsf, ./serializers/sarif, ./serializers/cyclonedx, ./serializers/intoto, ./runners/sql, ./runners/file, ./runners/api, ./runners/remote, ./runners/manual, ./runners/external, ./stores/memory, ./stores/files, ./stores/git, ./stores/gitref, ./stores/object, ./signers/dsse, ./signers/sshsig, ./surfaces/headless and ./surfaces/query, published to the GitHub package registry and npm, proved by cd commons/grc && bun run verify. Governance, risk and compliance in three layers: governance (frameworks, crosswalks, policies, checks, requirements, evidence policy and exceptions as data), the logical model (results, findings, evidence, attestations, assessments and the pure computations over them, as self-describing versioned documents) and the physical layer (registries of typed ports with conformance suites: runners, evidence stores, signers, serializers), with the headless verbs grc check, assess, explain and evidence.

Enforced (check): .github: cd commons/grc && bun run verify — commons/grc: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-114checkno test run

commons/githost MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/githost at version 0.2.7, its spec kit at commons/githost/spec-kit, exporting ., ./types, ./capabilities, ./remote, ./github, ./gitlab and ./git, published to the GitHub package registry and npm, proved by cd commons/githost && bun run verify. The Git hosts behind one typed interface: GitHub, GitLab (groups to any depth) and plain Git held to the same conformance tests, and the reading of a remote in any form a person writes it.

Enforced (check): .github: cd commons/githost && bun run verify — commons/githost: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-115checkno test run

commons/mizan MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/mizan at version 0.2.7, its spec kit at commons/mizan/spec-kit, exporting ., ./changes, ./changes/capability-trace, ./changes/capability-view, ./changes/commit-message, ./changes/declaration, ./changes/git-log, ./changes/issue-body, ./changes/plugin, ./changes/rules, ./changes/strict, ./changes/terms-file, ./changes/trace, ./harness, ./host/trace, ./integrations, ./integrations/host/import, ./integrations/pure/export, ./integrations/pure/export-dcat, ./integrations/pure/export-html, ./integrations/pure/export-owl, ./integrations/pure/export-rdfxml, ./integrations/pure/import-json-schema, ./integrations/pure/import-oscal-catalog, ./integrations/pure/import-vocabulary, ./integrations/pure/provenance, ./integrations/pure/read-json-ld, ./integrations/pure/read-rdf, ./integrations/pure/read-rdf-xml, ./integrations/pure/registry, ./integrations/pure/types, ./layers, ./levels, ./rules, ./spec-files, ./spec-terms, ./standards, ./query, ./host/query, ./trace, ./versions, ./versions/cite, ./versions/gate, ./versions/git, ./versions/judge, ./versions/ledger, ./versions/notes, ./versions/plugin, ./versions/record, ./versions/rules, ./versions/scan, ./versions/scheme and ./versions/works, published to the GitHub package registry and npm, proved by cd commons/mizan && bun run verify. Mizan, the IF Spec Profile, as code: the rules a specification is held to as plugins of one harness against a baseline that only shrinks, the levels of conformance, the importers and exporters of standards, the change-control rules and the release rules as plugins of the same harness, and the trace of requirements to code and tests.

Enforced (check): .github: cd commons/mizan && bun run verify — commons/mizan: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-116checkno test run

commons/ontology MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/ontology at version 0.4.3, its spec kit at commons/ontology/spec-kit, exporting ., ./audit, ./audit/packaging, ./ifccm, ./ifccm/ifccm, ./ifqs, ./ifqs/ifqs, ./oto, ./oto/oto, ./planning, ./planning/planning, ./ifr, ./ifr/audit, ./ifr/ifr, ./kanon, ./kanon/kanon, ./mizan, ./mizan/mizan, ./standards/nist-sp-800-53/controls.auto, ./supply-chain/commands, ./supply-chain/downloads, ./supply-chain/packaging, ./supply-chain/packaging/families, ./supply-chain/packaging/managers, ./supply-chain/packaging/packaging, ./supply-chain/packaging/pins, ./supply-chain/packaging/programs, ./supply-chain/packaging/record, ./supply-chain/packaging/rules and ./supply-chain/packaging/schema.auto, published to the GitHub package registry and npm, proved by cd commons/ontology && bun run verify. The ontologies of Intellectual Frontiers Commons as typed TypeScript values over the RDF of the library rdf: Mizan, IFCCM, IFQS, IFR, Kanon, the audit of packaging and the software supply chain, each with its classes, properties, code lists and decisions.

Enforced (check): .github: cd commons/ontology && bun run verify — commons/ontology: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-117checkno test run

commons/quality MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/quality at version 0.3.7, its spec kit at commons/quality/spec-kit, exporting ., ./assessor/host, ./assessor/pack, ./assessor/verify, ./assessor/verify-pack, ./attestation/agents, ./attestation/host, ./attestation/mutation, ./attestation/plan, ./attestation/rules, ./attestation/sample, ./commands, ./host/archive, ./host/branch, ./host/declaration, ./host/gather, ./host/git, ./host/ledger-branch, ./host/report, ./host/test-run, ./pure/chain, ./pure/chain-files, ./pure/freshness, ./pure/index-file, ./pure/ladder, ./pure/ledger, ./pure/names, ./pure/objectives, ./pure/record, ./pure/render, ./pure/retention, ./pure/tier, ./pure/tier2-events, ./pure/time, ./quality, ./query, ./host/runs, ./test-cli, ./test-report, ./tier2-commands, ./trust/audience, ./trust/host, ./trust/html, ./trust/requirement-text and ./trust/view, published to the GitHub package registry and npm, proved by cd commons/quality && bun run verify. The quality system of Intellectual Frontiers: the run of a suite of tests as evidence, the canonical record of a run and its renderings, the append-only quality branch, the evidence ladder, freshness, nonconformances and CAPA, objectives, the tiers, and the Trust page and the signed assessor pack.

Enforced (check): .github: cd commons/quality && bun run verify — commons/quality: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-118checkno test run

commons/libraries MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/libraries at version 0.5.9, its spec kit at commons/libraries/spec-kit, exporting ., ./affected, ./changes, ./ci/collect, ./ci/findings, ./ci/history, ./ci/inventory, ./ci/parsers, ./ci/policy, ./ci/release-gate, ./ci/step, ./check, ./dev, ./distribution, ./family, ./generate-ontology, ./generate-workflows, ./libraries, ./license, ./link, ./metapackages, ./newer, ./oscal-register, ./pack, ./pack-commons, ./pack-metapackage, ./pins, ./releasing, ./plan, ./publish-ontology, ./readme, ./scan, ./versions, ./workflows, ./workflows/definitions, ./workflows/model and ./workflows/render, published to the GitHub package registry and npm, proved by cd commons/libraries && bun run verify. The libraries of a repository of commons as code: the manifest of a library and the checks of it, which libraries a change affects, the typed GitHub Actions workflows and their generator, the pinned Bun, the packer of a library for npm with its declarations, and the commands that hold a repository to Mizan.

Enforced (check): .github: cd commons/libraries && bun run verify — commons/libraries: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-119checkno test run

commons/headless MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/headless at version 0.5.7, its spec kit at commons/headless/spec-kit, exporting ., ./governance, ./logical, ./cli, ./targets/local, ./targets/ssh, ./targets/container, ./ssh-inbound, ./otel, ./askpass, ./mcp, ./rest and ./describe, published to the GitHub package registry and npm, proved by cd commons/headless && bun run verify. Headless programs as one contract in layers: the governance of an action (kind, effect, audience, confirmation, problems, exit statuses, redaction), the logical layer (the command model, the typed outcome, the closing block, JSON and SARIF, explain, hints, nested runs) and the command-line surface (calm output, prompts, the run log, signals, help, completions, man pages), with composition of a host and plugins into one program, audience tiers, a credential prompt port, plan-versus-apply execution with a signable plan hash, a tool server and a REST skeleton generated from governance, and an OpenTelemetry adapter of its own.

Enforced (check): .github: cd commons/headless && bun run verify — commons/headless: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-120checkno test run

commons/kanon MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/kanon at version 0.3.5, its spec kit at commons/kanon/spec-kit, exporting ., ./check and ./host, published to the GitHub package registry and npm, proved by cd commons/kanon && bun run verify. Kanon, the pattern of a library built in three layers (governance, logical, physical): the type of a library's table of layers, the import check that holds it, the check that no annotation of governance is dropped (for each instance), the instances, plugins and family of a host and the check of the packages that extend it, the matrix of requirement by instance, the relations and the vocabulary of a model with their findings, members of another scope, a pure verification of a published bundle, and the types-only LayeredModel contract; one rule, projected down, nothing lost.

Enforced (check): .github: cd commons/kanon && bun run verify — commons/kanon: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-121checkno test run

commons/integrations MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/integrations at version 0.2.7, its spec kit at commons/integrations/spec-kit, exporting ., ./governance, ./logical, ./http, ./transport and ./headless, published to the GitHub package registry and npm, proved by cd commons/integrations && bun run verify. Integrations on one skeleton of Kanon layers (governance, logical, physical): connectors that observe the outside world read-only into observations and entities, and exchanges of messages and documents under standards and partner agreements, each standard a plugin package behind a typed codec port and a conformance suite.

Enforced (check): .github: cd commons/integrations && bun run verify — commons/integrations: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-122checkno test run

commons/integrations-fhir MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/integrations-fhir at version 0.2.7, its spec kit at commons/integrations-fhir/spec-kit, exporting ., published to the GitHub package registry and npm, proved by cd commons/integrations-fhir && bun run verify. The FHIR plugin of Integrations: R4 and US Core as registry entries with their licence as data, a codec for FHIR JSON and NDJSON to the abstract typed tree, a loader of StructureDefinitions, CodeSystems and ValueSets the user supplies, and the acknowledgement port of OperationOutcome.

Enforced (check): .github: cd commons/integrations-fhir && bun run verify — commons/integrations-fhir: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-123checkno test run

commons/integrations-github MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/integrations-github at version 0.2.7, its spec kit at commons/integrations-github/spec-kit, exporting ., published to the GitHub package registry and npm, proved by cd commons/integrations-github && bun run verify. The reference connector of Integrations for the posture of one organization of a code host: read-only, with its governance as data, its posture policies in the vocabulary of GRC, its records and entities, proved by the conformance suite over made-up recorded answers.

Enforced (check): .github: cd commons/integrations-github && bun run verify — commons/integrations-github: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-124checkno test run

commons/integrations-x12 MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/integrations-x12 at version 0.2.7, its spec kit at commons/integrations-x12/spec-kit, exporting ., published to the GitHub package registry and npm, proved by cd commons/integrations-x12 && bun run verify. The X12 envelope and acknowledgement skeleton of Integrations: the entries of X12 and of the HIPAA 5010 and purchasing transaction sets with their licence as data, a codec for the fixed-width ISA envelope and its ISA, GS and ST levels, control counts checked as findings, TA1 and 999 made and read, and a loader of a schema from the user's own transcription of a licensed guide. It embeds no standard.

Enforced (check): .github: cd commons/integrations-x12 && bun run verify — commons/integrations-x12: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-133checkno test run

commons/repoctl MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/repoctl at version 0.2.8, its spec kit at commons/repoctl/spec-kit, exporting ., ./governance, ./logical and ./physical, published to the GitHub package registry and npm, proved by cd commons/repoctl && bun run verify. The operations program, repoctl, of any repository: a generic host driven by the typed repoctl.config.ts at the repository's root. It makes the generated files in dependency order and checks them, merges without hand-resolving a generated file, runs every named check in one calm report, makes the commit with the repository's identity and trailers, and says what is wrong with a checkout; where the configuration turns them on it also tells the version of each library in the repository, on npm and in its tag, plans and publishes a release behind a typed confirmation, scaffolds a library, proves a change by its blast radius and builds, checks and serves the documentation site, in the layers of Kanon on Headless, with a tool server by audience tier.

Enforced (check): .github: cd commons/repoctl && bun run verify — commons/repoctl: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-134checkno test run

commons/commons MUST be a library at conformance level L0 (mz:Registered): the package @intellectual-frontiers/commons, a metapackage with no code of its own (the set commons, 0036-distribution FR-005) at version 0.4.1, exporting ., published to the GitHub package registry and npm, proved by cd commons/commons && bun run verify. Every library of commons as one package at one version: the compiled libraries, their declarations and sources, one exports map and the union of their dependencies. The whole of commons for a repository that uses it.

Enforced (check): .github: cd commons/commons && bun run verify — commons/commons: the verify of the library (its manifest); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-135checkno test run

commons/foundation MUST be a library at conformance level L0 (mz:Registered): the package @intellectual-frontiers/foundation, a metapackage with no code of its own (the set foundation, 0036-distribution FR-005) at version 0.1.7, exporting ., published to the GitHub package registry and npm, proved by cd commons/foundation && bun run verify. The foundation libraries as one install, each at an exact version. Errors as values and decoders, formats, cryptography, the system, the terminal, telemetry, the network, the test runtime, RDF, the Git host and the lint rules.

Enforced (check): .github: cd commons/foundation && bun run verify — commons/foundation: the verify of the library (its manifest); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-136checkno test run

commons/patterns MUST be a library at conformance level L0 (mz:Registered): the package @intellectual-frontiers/patterns, a metapackage with no code of its own (the set patterns, 0036-distribution FR-005) at version 0.1.7, exporting ., published to the GitHub package registry and npm, proved by cd commons/patterns && bun run verify. The pattern libraries as one install, each at an exact version. The headless program pattern and the layers of Kanon.

Enforced (check): .github: cd commons/patterns && bun run verify — commons/patterns: the verify of the library (its manifest); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-137checkno test run

commons/programs MUST be a library at conformance level L0 (mz:Registered): the package @intellectual-frontiers/programs, a metapackage with no code of its own (the set programs, 0036-distribution FR-005) at version 0.1.9, exporting ., published to the GitHub package registry and npm, proved by cd commons/programs && bun run verify. The program libraries as one install, each at an exact version. The operations program of a repository, workspaces, data, integrations and the other programs.

Enforced (check): .github: cd commons/programs && bun run verify — commons/programs: the verify of the library (its manifest); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-138checkno test run

commons/standards MUST be a library at conformance level L0 (mz:Registered): the package @intellectual-frontiers/standards, a metapackage with no code of its own (the set standards, 0036-distribution FR-005) at version 0.1.7, exporting ., published to the GitHub package registry and npm, proved by cd commons/standards && bun run verify. The standards libraries as one install, each at an exact version. Mizan, the ontologies, the quality standards and the standards of integrations.

Enforced (check): .github: cd commons/standards && bun run verify — commons/standards: the verify of the library (its manifest); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-139checkno test run

commons/archon MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/archon at version 0.1.6, its spec kit at commons/archon/spec-kit, exporting ., ./governance, ./logical, ./dialect and ./cli, published to the GitHub package registry and npm, proved by cd commons/archon && bun run verify. Archon in the layers of Kanon: what a server, a device, a workstation or a cloud account must be, said once as requirements, the order and the plan made from them, and the port that a package for each tool (Ansible, OpenTofu, Microsoft DSC, cloud-init) implements; assurance profiles match the approval of a change to the fleet.

Enforced (check): .github: cd commons/archon && bun run verify — commons/archon: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-140checkno test run

commons/archon-dialect-apt MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/archon-dialect-apt at version 0.1.0, its spec kit at commons/archon-dialect-apt/spec-kit, exporting ., published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the archon libraries together, when the first fleet runs on them), proved by cd commons/archon-dialect-apt && bun run verify. The dialect of tools for Archon that installs them with apt (Debian and Ubuntu's package manager, which checks the signed index of its repositories); it holds the data of the manager (what it guarantees, how it writes an exact version, what its check answers) and gets everything else from the kit of the manager dialects.

Enforced (check): .github: cd commons/archon-dialect-apt && bun run verify — commons/archon-dialect-apt: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-141checkno test run

commons/archon-dialect-homebrew MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/archon-dialect-homebrew at version 0.1.0, its spec kit at commons/archon-dialect-homebrew/spec-kit, exporting ., published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the archon libraries together, when the first fleet runs on them), proved by cd commons/archon-dialect-homebrew && bun run verify. The dialect of tools for Archon that installs them with Homebrew (Homebrew, which installs the current bottle of a formula in a folder of the user's own, checked by the SHA-256 of the bottle); it holds the data of the manager (what it guarantees, how it writes an exact version, what its check answers) and gets everything else from the kit of the manager dialects.

Enforced (check): .github: cd commons/archon-dialect-homebrew && bun run verify — commons/archon-dialect-homebrew: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-142checkno test run

commons/archon-dialect-mise MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/archon-dialect-mise at version 0.1.6, its spec kit at commons/archon-dialect-mise/spec-kit, exporting ., published to the GitHub package registry and npm, proved by cd commons/archon-dialect-mise && bun run verify. The dialect of tools for Archon that installs them with mise (mise, which installs the tools of an account in the account's own folder at the versions it is told); it holds the data of the manager (what it guarantees, how it writes an exact version, what its check answers) and gets everything else from the kit of the manager dialects.

Enforced (check): .github: cd commons/archon-dialect-mise && bun run verify — commons/archon-dialect-mise: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-143checkno test run

commons/archon-dialect-native-pinned MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/archon-dialect-native-pinned at version 0.1.6, its spec kit at commons/archon-dialect-native-pinned/spec-kit, exporting ., ./install and ./pin, published to the GitHub package registry and npm, proved by cd commons/archon-dialect-native-pinned && bun run verify. The default dialect of tools for Archon: the programs a computer needs, as their publishers released them, pinned by the SHA-256 of the artifact, in a folder of the user's own, with no administrator rights and no package manager; never built from source.

Enforced (check): .github: cd commons/archon-dialect-native-pinned && bun run verify — commons/archon-dialect-native-pinned: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-144checkno test run

commons/archon-dialect-winget MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/archon-dialect-winget at version 0.1.0, its spec kit at commons/archon-dialect-winget/spec-kit, exporting ., published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the archon libraries together, when the first fleet runs on them), proved by cd commons/archon-dialect-winget && bun run verify. The dialect of tools for Archon that installs them with WinGet (WinGet, whose manifests carry the SHA-256 of each installer, which it checks before it runs one); it holds the data of the manager (what it guarantees, how it writes an exact version, what its check answers) and gets everything else from the kit of the manager dialects.

Enforced (check): .github: cd commons/archon-dialect-winget && bun run verify — commons/archon-dialect-winget: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-145checkno test run

commons/archon-tool MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/archon-tool at version 0.1.0, its spec kit at commons/archon-tool/spec-kit, exporting ., published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the archon libraries together, when the first fleet runs on them), proved by cd commons/archon-tool && bun run verify. The plugin of archon for tools: archon tool list|show|ensure|doctor|clean over a catalog of tools and the dialects a fleet chose, with the plan of what would change before anything is installed and the same approval as any other change.

Enforced (check): .github: cd commons/archon-tool && bun run verify — commons/archon-tool: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-146checkno test run

commons/package-managers MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/package-managers at version 0.1.6, its spec kit at commons/package-managers/spec-kit, exporting ., ./governance, ./logical and ./physical, published to the GitHub package registry and npm, proved by cd commons/package-managers && bun run verify. The shared kit of the dialects that drive a package manager for Archon and Toolchain: the commands of the packaging ontology as argument vectors (no shell), the exact version written as each manager writes it, the jobs a tool asks of a manager, the plan file, the observation of what is installed, and the dialect made from a manager's data.

Enforced (check): .github: cd commons/package-managers && bun run verify — commons/package-managers: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-147checkno test run

commons/toolchain MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/toolchain at version 0.1.6, its spec kit at commons/toolchain/spec-kit, exporting ., ./governance, ./logical and ./ontology, published to the GitHub package registry and npm, proved by cd commons/toolchain && bun run verify. Toolchain in the layers of Kanon: which programs a computer needs to do its work, declared once (a pinned version, a pin policy, a scope, the phase that needs it, and the bindings by which each dialect obtains it), resolved to the dialect that carries each out and planned; dialects are packages on the port of Archon.

Enforced (check): .github: cd commons/toolchain && bun run verify — commons/toolchain: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-148checkno test run

commons/docs MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/docs at version 0.3.7, its spec kit at commons/docs/spec-kit, exporting ., ./lens/layered, ./lens/program, ./lens/guides, ./lens/releases and ./lens/repo-ops, published to the GitHub package registry and npm, proved by cd commons/docs && bun run verify. The generator of a repository's documentation site, made from its TypeScript and its spec kit alone: a typed configuration, an API reference for every export, the specifications with the tests that prove each requirement, lenses for layered models, programs, guides and releases, Markdown and JSON beside every page, presentations other than the site (the AsciiDoc of the volumes of a book of erga), and one command, ifc-docs, that builds or checks them.

Enforced (check): .github: cd commons/docs && bun run verify — commons/docs: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-149checkno test run

commons/estate MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/estate at version 0.1.0, its spec kit at commons/estate/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the libraries of the fleet work together, when the first fleet runs on them), proved by cd commons/estate && bun run verify. Estate in the layers of Kanon: the assets of an organization (machines, services, accounts) as discovered, adopted or managed, the capabilities each state offers with the reason for each it does not, what each is declared to be against what is observed of it, and which system owns each capability, and the fleet store that keeps all of it as typed documents in a store of AnyFS: a host reached by SSH is the system of record, with a Git branch, a bucket or a folder as mirrors.

Enforced (check): .github: cd commons/estate && bun run verify — commons/estate: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-150checkno test run

commons/machine-probe MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/machine-probe at version 0.1.0, its spec kit at commons/machine-probe/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the libraries of the fleet work together, when the first fleet runs on them), proved by cd commons/machine-probe && bun run verify. The probe a machine runs for its fleet: the three read-only requests it answers (facts, version, one osquery SELECT), the key line that restricts a key to them, the facts as a typed observation, and the policy pack that judges an observation with the NIST SP 800-53 controls each gives evidence for.

Enforced (check): .github: cd commons/machine-probe && bun run verify — commons/machine-probe: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-151checkno test run

commons/lab MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/lab at version 0.1.0, its spec kit at commons/lab/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, tests only: a library of disposable machines that no program of ours depends on at run time), proved by cd commons/lab && bun run verify. Disposable machines for tests: a systemd and sshd container rendered from a typed description, started and removed per test with a throwaway key, and what a container can and cannot stand in for.

Enforced (check): .github: cd commons/lab && bun run verify — commons/lab: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-152checkno test run

commons/evidence-capture MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/evidence-capture at version 0.1.0, its spec kit at commons/evidence-capture/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the libraries of the fleet work together, when the first fleet runs on them), proved by cd commons/evidence-capture && bun run verify. The unattended capture of evidence: which assets are due, the canonical state of each kept on a branch of Git with a commit only where it changed, a hash-chained journal of every look, batched commits and a push that is configured, never forced.

Enforced (check): .github: cd commons/evidence-capture && bun run verify — commons/evidence-capture: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-153checkno test run

commons/catalog-nist-csf-2 MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/catalog-nist-csf-2 at version 0.1.0, its spec kit at commons/catalog-nist-csf-2/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the libraries of the fleet work together, when the first fleet runs on them), proved by cd commons/catalog-nist-csf-2 && bun run verify. The NIST Cybersecurity Framework 2.0 as a grc catalog package: its functions, categories and 106 active subcategories as framework data, with where it came from, its licence and the digest of the source.

Enforced (check): .github: cd commons/catalog-nist-csf-2 && bun run verify — commons/catalog-nist-csf-2: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-154checkno test run

commons/anyfs-bridge MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/anyfs-bridge at version 0.1.0, its spec kit at commons/anyfs-bridge/spec-kit, exporting ., ./governance, ./logical, ./conformance, ./mirror and ./exchange, published to no registry (not released, unfinished (missing its first consumer, the fleet store): built and verified but not released until the fleet store runs on it; lifted when the fleet store runs on it), proved by cd commons/anyfs-bridge && bun run verify. The bridge of AnyFS: copy, sync, move, check, two-way sync and mirror between any two stores. Every transfer is a plan first, in a fixed order with a hash, that says how each file was compared and what the destination would not keep; an apply refuses a plan that is not the one approved, guards every write by the revision the plan saw, and checks what it wrote. The rails (filters, limits, never-overwrite, protected paths) are code, and nothing here touches a file system or a network except through a store.

Enforced (check): .github: cd commons/anyfs-bridge && bun run verify — commons/anyfs-bridge: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-155checkno test run

commons/anyfs-ssh MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/anyfs-ssh at version 0.1.0, its spec kit at commons/anyfs-ssh/spec-kit, exporting . and ./helper, published to no registry (not released, unfinished (missing its first consumer, the fleet store): built and verified but not released until the first consumer, the fleet store, runs on it; lifted when the first consumer, the fleet store, runs on it), proved by cd commons/anyfs-ssh && bun run verify. The SSH backend of AnyFS: a store over a folder on a host reached by SSH, the fleet's system of record, with a revision on every read and a stated expectation on every write, reached only through the safe executor of Headless and a small POSIX helper whose SHA-256 is pinned.

Enforced (check): .github: cd commons/anyfs-ssh && bun run verify — commons/anyfs-ssh: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-156checkno test run

commons/anyfs-posix MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/anyfs-posix at version 0.1.0, its spec kit at commons/anyfs-posix/spec-kit, exporting ., ./governance, ./logical, ./physical and ./conformance, published to no registry (not released, unfinished (missing its first consumers, the command line and the servers): built and verified but not released until the first consumers, the command line and the servers, run on it; lifted when the first consumers, the command line and the servers, run on it), proved by cd commons/anyfs-posix && bun run verify. The POSIX view of any AnyFS store: directories derived from prefixes, handles with write-back, and every operation labelled native, emulated or refused, so a command line, a WebDAV or NFS server or a mount can treat any store as a file system without pretending.

Enforced (check): .github: cd commons/anyfs-posix && bun run verify — commons/anyfs-posix: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-157checkno test run

commons/anyfs-git MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/anyfs-git at version 0.1.0, its spec kit at commons/anyfs-git/spec-kit, exporting ., ./governance and ./physical, published to no registry (not released, unfinished (missing its first consumer, the fleet store): built and verified but not released until the fleet store runs on it; lifted when the fleet store runs on it), proved by cd commons/anyfs-git && bun run verify. The Git stores of AnyFS: a branch of a repository kept as a store, written with Git's plumbing so that the working tree, the index and the branch a person has checked out are never touched, and a working tree kept as a store that can commit what it holds. A revision is the digest of the bytes; a batch is one commit; a write is guarded by the revision it saw and by the tip it was made on; the branch, and only it, is pushed and never forced.

Enforced (check): .github: cd commons/anyfs-git && bun run verify — commons/anyfs-git: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-158checkno test run

commons/lang-sql MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/lang-sql at version 0.1.4, its spec kit at commons/lang-sql/spec-kit, exporting ., ./aide/catalog, ./aide/exec, ./aide/guard, ./aide/introspect, ./aide/normalize, ./aide/plan, ./aide/profile, ./aide/relational, ./aide/text, ./dialects/athena, ./dialects/bigquery, ./dialects/clickhouse, ./dialects/databricks, ./dialects/doris, ./dialects/dremio, ./dialects/drill, ./dialects/druid, ./dialects/duckdb, ./dialects/dune, ./dialects/exasol, ./dialects/fabric, ./dialects/hive, ./dialects/materialize, ./dialects/mysql, ./dialects/oracle, ./dialects/postgres, ./dialects/presto, ./dialects/redshift, ./dialects/risingwave, ./dialects/singlestore, ./dialects/snowflake, ./dialects/solr, ./dialects/spark, ./dialects/spark2, ./dialects/sqlite, ./dialects/starrocks, ./dialects/teradata, ./dialects/trino, ./dialects/tsql, ./extensions/docs, ./extensions/plpgsql, ./extensions/query and ./extensions/unist, published to the GitHub package registry and npm, proved by cd commons/lang-sql && bun run verify. A small, fast, portable multi-dialect SQL language library: a lexer, a closed syntax tree and a parser for thirty dialects, comments as first-class nodes, and extensions for queries, unist, documentation and PL/pgSQL.

Enforced (check): .github: cd commons/lang-sql && bun run verify — commons/lang-sql: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-159checkno test run

commons/anyfs-cli MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/anyfs-cli at version 0.1.0, its spec kit at commons/anyfs-cli/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, unfinished (missing its first consumers, the fleet store and the servers): built and verified but not released until the first consumers, the fleet store and the servers, run on it; lifted when the first consumers, the fleet store and the servers, run on it), proved by cd commons/anyfs-cli && bun run verify. The anyfs program: POSIX-style access to any AnyFS store (ls, cat, cp, rm, find, grep, diff) and the bridge verbs (sync, bisync, mirror, check, merge, sync-medium), serve (WebDAV) and the keys of signed merges (keygen, roster) from the command line, a tool server and a REST description, with every operation saying how it was carried out and every destruction a plan first.

Enforced (check): .github: cd commons/anyfs-cli && bun run verify — commons/anyfs-cli: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-160checkno test run

commons/anyfs-s3 MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/anyfs-s3 at version 0.1.0, its spec kit at commons/anyfs-s3/spec-kit, exporting ., published to no registry (not released, unfinished (missing its first consumer): built and verified but not released until the first consumer runs on it; lifted when the first consumer runs on it), proved by cd commons/anyfs-s3 && bun run verify. The S3 backend of AnyFS: a store over a bucket and a prefix of any S3-compatible service, with a revision on every read and a stated expectation on every write, signed by Signature Version 4 and held to the same conformance suite as every backend.

Enforced (check): .github: cd commons/anyfs-s3 && bun run verify — commons/anyfs-s3: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-162checkno test run

commons/anyfs-query MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/anyfs-query at version 0.1.0, its spec kit at commons/anyfs-query/spec-kit, exporting ., ./governance and ./logical, published to no registry (not released, unfinished (missing its first consumer, the fleet store): built and verified but not released until the fleet store runs on it; lifted when the fleet store runs on it), proved by cd commons/anyfs-query && bun run verify. The query language of AnyFS: read-only SQL over the files, places, revisions and content of any AnyFS store, planned so that a query lists only what its filter can match and reads only what its metadata leaves, within budgets it reports and the consent it was given.

Enforced (check): .github: cd commons/anyfs-query && bun run verify — commons/anyfs-query: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-163checkno test run

commons/anyfs-githost MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/anyfs-githost at version 0.1.0, its spec kit at commons/anyfs-githost/spec-kit, exporting ., ./governance and ./physical, published to no registry (not released, unfinished (missing its first consumer, the fleet store): built and verified but not released until the fleet store runs on it; lifted when the fleet store runs on it), proved by cd commons/anyfs-githost && bun run verify. The Git host backend of AnyFS: a branch of a repository on GitHub or GitLab (gitlab.com or a self-managed server) kept as a store through the host's REST API, with a revision on every read and a stated expectation on every write, a batch that is one commit, and a branch that is the compare-and-swap of every writer.

Enforced (check): .github: cd commons/anyfs-githost && bun run verify — commons/anyfs-githost: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-164checkno test run

commons/archon-converge MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/archon-converge at version 0.1.0, its spec kit at commons/archon-converge/spec-kit, exporting ., published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the archon libraries together, when the first fleet runs on them), proved by cd commons/archon-converge && bun run verify. The plugin of archon for convergence: archon converge plan|apply over the dialect a fleet chose, which observes a machine by reading only, plans, shows the plan with its hash and applies exactly the plan that was approved, then shows that the next plan is empty.

Enforced (check): .github: cd commons/archon-converge && bun run verify — commons/archon-converge: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-165checkno test run

commons/archon-dialect-ansible MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/archon-dialect-ansible at version 0.1.0, its spec kit at commons/archon-dialect-ansible/spec-kit, exporting ., published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the archon libraries together, when the first fleet runs on them), proved by cd commons/archon-dialect-ansible && bun run verify. The dialect of Archon that converges a Linux host with Ansible: it renders an order and its plan to an inventory and a playbook of the modules of ansible-core, gives the steps that check (with the difference) and apply, and says what it guarantees as data.

Enforced (check): .github: cd commons/archon-dialect-ansible && bun run verify — commons/archon-dialect-ansible: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-166checkno test run

commons/archon-dialect-cloud-init MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/archon-dialect-cloud-init at version 0.1.0, its spec kit at commons/archon-dialect-cloud-init/spec-kit, exporting ., published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the archon libraries together, when the first fleet runs on them), proved by cd commons/archon-dialect-cloud-init && bun run verify. The dialects of Archon for the unattended install of a machine from nothing: they render an order to Ubuntu's autoinstall user-data and meta-data (no secret in it, a blank-disk guard first, key-only sign-in) or to a Debian preseed from the same facts, and the script that converges the machine from its signed repository.

Enforced (check): .github: cd commons/archon-dialect-cloud-init && bun run verify — commons/archon-dialect-cloud-init: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-167checkno test run

commons/archon-dns MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/archon-dns at version 0.1.0, its spec kit at commons/archon-dns/spec-kit, exporting ., published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the archon libraries together, when the first fleet runs on them), proved by cd commons/archon-dns && bun run verify. The plugin of archon for DNS: archon dns plan|apply over the provider a fleet chose, which reads the records of a zone, plans what the profile wants (changing only the records it claims), shows the plan with its hash and applies exactly the plan that was approved, then shows that the next plan is empty.

Enforced (check): .github: cd commons/archon-dns && bun run verify — commons/archon-dns: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-168checkno test run

commons/catalog-nist-sp800 MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/catalog-nist-sp800 at version 0.1.0, its spec kit at commons/catalog-nist-sp800/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the libraries of the fleet work together, when the first fleet runs on them), proved by cd commons/catalog-nist-sp800 && bun run verify. NIST SP 800-53 Rev 5.2.0 and SP 800-171 Rev 3 as grc catalog packages, with the controls, the assessment objectives of SP 800-53A and SP 800-171A as controls of their own, and where they came from, their licence and the digest of each source.

Enforced (check): .github: cd commons/catalog-nist-sp800 && bun run verify — commons/catalog-nist-sp800: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-169checkno test run

commons/linux-observe MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/linux-observe at version 0.1.0, its spec kit at commons/linux-observe/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/linux-observe && bun run verify. What a Linux machine is, read with no change: the resources that an Archon requirement declares (a package, a user, a group, a file, a directory, a service, an authorized key, a system setting) observed in the shape the requirement declares them, through any way of running a program.

Enforced (check): .github: cd commons/linux-observe && bun run verify — commons/linux-observe: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-170checkno test run

commons/linux-services MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/linux-services at version 0.1.0, its spec kit at commons/linux-services/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/linux-services && bun run verify. The services a Linux machine runs, said as data: a PostgreSQL instance, a send-only mail relay, a certificate and a set of DNS records, each a profile that becomes the requirements of Archon (packages, files, directories and services), with the secret never in the model.

Enforced (check): .github: cd commons/linux-services && bun run verify — commons/linux-services: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-171checkno test run

commons/netboot MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/netboot at version 0.1.0, its spec kit at commons/netboot/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/netboot && bun run verify. The network boot of a blank machine: the TFTP and HTTP servers that PXE firmware and Ubuntu's installer speak, the GRUB menus, the pinned boot files, the arming of a host for one install, the blank-disk guard's decision, and the install's progress.

Enforced (check): .github: cd commons/netboot && bun run verify — commons/netboot: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-172checkno test run

commons/archon-boot MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/archon-boot at version 0.1.0, its spec kit at commons/archon-boot/spec-kit, exporting ., published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the archon libraries together, when the first fleet runs on them), proved by cd commons/archon-boot && bun run verify. The plugin of archon for the network install of a blank machine: archon boot prepare|arm|disarm|status|serve, which renders the machine's install and playbook (given the fleet's dialects) without a secret in them, says which asset a network boot may install and serves the boot over TFTP and HTTP from pinned files.

Enforced (check): .github: cd commons/archon-boot && bun run verify — commons/archon-boot: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-173checkno test run

commons/anyfs-serve MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/anyfs-serve at version 0.1.0, its spec kit at commons/anyfs-serve/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, unfinished (missing its first consumer, the command line): built and verified but not released until the command line runs a server on it; lifted when the command line runs a server on it), proved by cd commons/anyfs-serve && bun run verify. AnyFS over HTTP and NFS: any AnyFS store served as WebDAV, class 1 and 2, or as NFS version 3 on the loopback, on the POSIX view, so an operating system mounts it, and every response says whether it was native, emulated or refused.

Enforced (check): .github: cd commons/anyfs-serve && bun run verify — commons/anyfs-serve: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-174checkno test run

commons/anyfs-sql MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/anyfs-sql at version 0.1.0, its spec kit at commons/anyfs-sql/spec-kit, exporting ., ./governance, ./physical, ./sqlite, ./libsql, ./pg, ./pglite and ./duckdb, published to no registry (not released, unfinished (missing its first consumer, the fleet store): built and verified but not released until the fleet store runs on it; lifted when the fleet store runs on it), proved by cd commons/anyfs-sql && bun run verify. The SQL stores of AnyFS: objects kept in a table of any SQL-speaking database (a SQLite file by default, PostgreSQL and DuckDB too, and libSQL and Turso as drivers of SQLite), with a revision on every object, a native transaction for a batch, a history of revisions and search where the engine has an index for it, and the layout of the tables documented for a catalog.

Enforced (check): .github: cd commons/anyfs-sql && bun run verify — commons/anyfs-sql: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-175checkno test run

commons/estate-query MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/estate-query at version 0.1.0, its spec kit at commons/estate-query/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/estate-query && bun run verify. SQL over the estate: what an estate holds (its assets, the capabilities of each and who owns them, what is declared and observed, the policies judged, the risks accepted, the operational truth and the invariants broken) as relations with a catalog that is data, asked with one read-only statement through the guard and the engine of lang-sql, with no secret in a relation.

Enforced (check): .github: cd commons/estate-query && bun run verify — commons/estate-query: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-176checkno test run

commons/change-control MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/change-control at version 0.1.0, its spec kit at commons/change-control/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/change-control && bun run verify. Change control for a fleet's repository: each change is accepted only if a signer of the fleet signed it, a change to a controlled path is blocked until a different signer of an approving role approves it, and what is refused or blocked is said with the reason; the signers are the fleet's own and the check reads Git with its own signature verification.

Enforced (check): .github: cd commons/change-control && bun run verify — commons/change-control: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-177checkno test run

commons/estate-iac MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/estate-iac at version 0.1.0, its spec kit at commons/estate-iac/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/estate-iac && bun run verify. Reads infrastructure as code (OpenTofu and Terraform plans and state as JSON, CloudFormation templates, Kubernetes manifests, Compose files, Pulumi stack exports) into assets and links of the estate, with where each came from, and compares what the code says with what a cloud shows. It reads files and runs no tool.

Enforced (check): .github: cd commons/estate-iac && bun run verify — commons/estate-iac: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-178checkno test run

commons/estate-endpoints MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/estate-endpoints at version 0.1.0, its spec kit at commons/estate-endpoints/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/estate-endpoints && bun run verify. Finds the endpoints of an estate from what describes or shows them: OpenAPI and GraphQL descriptions, Android and iOS manifests, DNS zone files, certificates and the listening ports a machine reports, as assets and links of the estate with where each came from. It reads files and text and reaches no network.

Enforced (check): .github: cd commons/estate-endpoints && bun run verify — commons/estate-endpoints: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-179checkno test run

commons/pentest MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/pentest at version 0.1.0, its spec kit at commons/pentest/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/pentest && bun run verify. The rules of an authorized security test of an estate: an engagement (who authorized it, the window, the scope as a question asked of the estate, the techniques allowed and the ones never allowed, who tests and who to call), the judgement of whether it is authorized now and whether one action on one asset is allowed, and the passive checks that need no engagement because they reach nothing. It decides and runs no test.

Enforced (check): .github: cd commons/pentest && bun run verify — commons/pentest: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-181checkno test run

commons/planning MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/planning at version 0.1.0, its spec kit at commons/planning/spec-kit, exporting ., ./governance, ./logical, ./records and ./physical, published to the GitHub package registry and npm, proved by cd commons/planning && bun run verify. Planning content from many places as one item each with one stable id, its history as append-only events and its state a fold of them, with every act of an agent made on behalf of a person; sources are lenses over the places, and a write goes back in the place's own form.

Enforced (check): .github: cd commons/planning && bun run verify — commons/planning: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-182checkno test run

commons/anyfs MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/anyfs at version 0.1.0, its spec kit at commons/anyfs/spec-kit, exporting ., ./governance, ./logical, ./physical, ./layers, ./conformance, ./memory, ./local, ./merge, ./memory-merge, ./docs and ./docs/formats, published to the GitHub package registry and npm, proved by cd commons/anyfs && bun run verify. One typed interface to every place bytes live: paths and places as types, a revision on every read and a stated expectation on every write, the capabilities of a store in its type so that code needing one cannot be given a store without it, attenuation, mounts, composable layers and one conformance suite that every backend passes; and a merge by nature: the files of a store are a view of immutable version rows, so any two replicas, or any two SQL dumps of them, merge by taking the union of their rows, with no conflict and in any order.

Enforced (check): .github: cd commons/anyfs && bun run verify — commons/anyfs: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-183checkno test run

commons/archon-dialect-opentofu MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/archon-dialect-opentofu at version 0.1.0, its spec kit at commons/archon-dialect-opentofu/spec-kit, exporting ., published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the archon libraries together, when the first fleet runs on them), proved by cd commons/archon-dialect-opentofu && bun run verify. The dialect of Archon for cloud resources with OpenTofu: it renders an order of cloud-resource requirements to a JSON configuration with pinned providers and no credential, the state kept outside the repository, and the steps that init, plan to a saved plan and apply exactly that plan. It renders and says what to run; it runs nothing.

Enforced (check): .github: cd commons/archon-dialect-opentofu && bun run verify — commons/archon-dialect-opentofu: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-184checkno test run

commons/findings MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/findings at version 0.1.0, its spec kit at commons/findings/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/findings && bun run verify. Test results from other tools (SARIF, OWASP ZAP, Burp Suite and Nessus reports) read into findings that keep where they came from, with a lifecycle (open, triaged, accepted for a time, fixed, verified or reopened by a retest) worked out from a log of events, and the NIST SP 800-53 controls each finding is evidence against. It reads reports and runs no tool.

Enforced (check): .github: cd commons/findings && bun run verify — commons/findings: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-185checkno test run

commons/scanners MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/scanners at version 0.1.0, its spec kit at commons/scanners/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/scanners && bun run verify. Runs security scanners (a built-in TLS and header check, nuclei, nmap, trivy, grype, semgrep, checkov and ZAP's baseline scan) the safe way: only after the engagement allows the action, only a binary whose SHA-256 is the one pinned for it, with a command line made from validated parts and no shell, in an empty working folder with a bare environment, and a record of every run. What they print is read into findings.

Enforced (check): .github: cd commons/scanners && bun run verify — commons/scanners: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-186checkno test run

commons/catalog-soc2 MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/catalog-soc2 at version 0.1.0, its spec kit at commons/catalog-soc2/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the libraries of the fleet work together, when the first fleet runs on them), proved by cd commons/catalog-soc2 && bun run verify. SOC 2 Trust Services Criteria as a grc catalog package, in our own words: the criteria of security, availability, processing integrity, confidentiality and privacy, with where they came from and why the AICPA text is not carried.

Enforced (check): .github: cd commons/catalog-soc2 && bun run verify — commons/catalog-soc2: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-187checkno test run

commons/assessment MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/assessment at version 0.1.0, its spec kit at commons/assessment/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/assessment && bun run verify. Assessment-objective evidence: what a framework's objectives (SP 800-171A, SP 800-53A) ask, the evidence recorded against each (examine, interview, test; by a tool or a person; with a validity), how each objective and requirement stands from it, and why a tool alone never determines an objective a person must.

Enforced (check): .github: cd commons/assessment && bun run verify — commons/assessment: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-188checkno test run

commons/tenancy MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/tenancy at version 0.1.0, its spec kit at commons/tenancy/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/tenancy && bun run verify. Tenancy for service providers: the parties (an operator and its clients), the engagements between them with roles and dates, deny-by-default authorization of what a principal may do to which client, portfolio views that carry only what a principal may see, and the shared-responsibility matrix that says who answers for each requirement, with inheritance from a provider.

Enforced (check): .github: cd commons/tenancy && bun run verify — commons/tenancy: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-189checkno test run

commons/gate MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/gate at version 0.1.0, its spec kit at commons/gate/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/gate && bun run verify. A policy gate: policies written as code over the subjects of a change (assets, resources, endpoints), evaluated on what a change adds or alters, with severities that block or warn, waivers that a person grants for a reason and a time, and a verdict that CI and a merge can act on, also as SARIF.

Enforced (check): .github: cd commons/gate && bun run verify — commons/gate: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-190checkno test run

commons/posture-report MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/posture-report at version 0.1.0, its spec kit at commons/posture-report/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified but not released: the owner publishes the fleet libraries together, when the first fleet runs on them), proved by cd commons/posture-report && bun run verify. A read-only static report site for a compliance posture: an index of how each requirement stands, a page for each requirement with its objectives, the evidence and its grade, and who answers for it, as plain HTML and one stylesheet with no script and no request to anywhere, the same bytes for the same posture.

Enforced (check): .github: cd commons/posture-report && bun run verify — commons/posture-report: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-191checkno test run

commons/integrations-identity MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/integrations-identity at version 0.1.0, its spec kit at commons/integrations-identity/spec-kit, exporting ., ./governance, ./logical and ./physical, published to no registry (not released, owner-blocked: built and verified against recorded, made-up answers and never against a live tenant: the owner publishes the fleet libraries together, when a first customer tenant has been read), proved by cd commons/integrations-identity && bun run verify. Read-only connectors for the identity and device posture of a managed service provider's customers: a Microsoft Entra tenant (who has multifactor authentication, whether a policy requires it), Microsoft Intune managed devices (compliance, encryption, staleness) and a Google Workspace domain (two-step verification, administrators), each written against the read port of Integrations, with its governance as data and a conformance run over recorded answers.

Enforced (check): .github: cd commons/integrations-identity && bun run verify — commons/integrations-identity: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-192checkno test run

commons/anyfs-onedrive MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/anyfs-onedrive at version 0.1.0, its spec kit at commons/anyfs-onedrive/spec-kit, exporting ., published to no registry (not released, unfinished (missing a run against a live Microsoft Graph tenant): built and verified against an in-process fake of Microsoft Graph and the documented response shapes, and not yet run against a live tenant, which needs a test tenant and an account from the owner; lifted when the suite has run against a test tenant and its findings are in the issue), proved by cd commons/anyfs-onedrive && bun run verify. The OneDrive backend of AnyFS: a store over a drive and a folder of Microsoft Graph, with a revision on every read and a stated expectation on every write, held to the same conformance suite as every backend.

Enforced (check): .github: cd commons/anyfs-onedrive && bun run verify — commons/anyfs-onedrive: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-193checkno test run

commons/anyfs-gdrive MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/anyfs-gdrive at version 0.1.0, its spec kit at commons/anyfs-gdrive/spec-kit, exporting ., published to no registry (not released, unfinished (missing a run against a live Google Drive account): built and verified against an in-process fake of the Drive API and the documented response shapes, and not yet run against a live account, which needs a test account from the owner; lifted when the suite has run against a test account and its findings are in the issue), proved by cd commons/anyfs-gdrive && bun run verify. The Google Drive backend of AnyFS: a store over a folder of Google Drive, with a revision on every read and a stated expectation on every write, held to the same conformance suite as every backend.

Enforced (check): .github: cd commons/anyfs-gdrive && bun run verify — commons/anyfs-gdrive: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

FR-194checkno test run

commons/planning-query MUST be a library at conformance level L1 (mz:Core): the package @intellectual-frontiers/planning-query at version 0.1.0, its spec kit at commons/planning-query/spec-kit, exporting ., ./governance, ./logical and ./physical, published to the GitHub package registry and npm, proved by cd commons/planning-query && bun run verify. The items of Planning as read-only SQL relations: issues, events, links and traces, with a catalog that is data made from the same list of columns as the rows, asked with one read-only statement through the guard and the engine of lang-sql, a proposed item counted only where the question says so.

Enforced (check): .github: cd commons/planning-query && bun run verify — commons/planning-query: the verify of the library (its compiler, specification checker, rules and tests); the manifest library.ts agrees with the folder and the package (commons-libraries.test.ts)

<!-- libraries:end -->

Acceptance scenarios

  1. Given a folder commons/example/ with a package, a spec kit, a workflow and a manifest at L1, When libraries.ts runs, Then the section "The libraries" gains one requirement numbered from FR-101 and enforcement.tsv one check row that runs the library's verify, per FR-011 and FR-014.
  2. Given a manifest whose version is not its package's, When libraries.ts --check runs, Then it exits 1 and names the library and both versions, per FR-013.
  3. Given a library with a spec kit and no library.ts, When the test of this repository runs, Then it fails and names the folder, per FR-008 and FR-012.
  4. Given a manifest that declares L0 and no spec kit, When it is read, Then it is accepted and no verify of the Mizan check is asked of it, per FR-012 and FR-013.
  5. Given a manifest whose distribution is ["npm"], When it is read, Then it is refused and the field is named, and a manifest of ["github", "npm"] is accepted and its requirement says it is published to the GitHub package registry and npm, per FR-015 to FR-017.
  6. Given a library that imports one file of the kernel, which imports another, When the other file changes, Then the library is affected, and when a file of the runtime that it does not import changes, it is not, per FR-020 and FR-021.
  7. Given a library whose package depends on another library by path, When the other library is affected, Then it is too, per FR-019 and FR-021.
  8. Given a change, When CI plans it, Then the libraries it runs are those the planner affects and no other, per FR-022.

Out of scope

  • What a library does: its own specifications say so, never this one.
  • The existing folders of commons (ts, docs, ontology, tools, generated, spec-kit): their specifications stay in this repository's spec kit and they are not libraries in this sense (OQ-1).
  • How a library is published or consumed from another repository: 0036-distribution.

Edge cases

  • A folder commons/<name>/spec-kit/ with no library.ts: found by the test, per FR-008.
  • A manifest that names another folder, another version than the package's, or exports the package does not have: found, per FR-013.
  • A manifest with a field it does not know, or level: "L9": refused with the field named, per FR-012.
  • A library at L0 with no spec kit: accepted, per FR-012.
  • A manifest at L1 whose verify script runs the Mizan check at L3: found, per FR-013.
  • The section "The libraries" edited by hand: libraries.ts --check names the file, per FR-011.
  • A new library with a manifest and no generated requirement: found and written by the generator, per FR-014.
  • A generated requirement that names commons/nope, which does not exist: not what the manifests make, found per FR-011.
  • A specification of a library listed in this repository's registry.tsv: found, per FR-002.
  • An enforcement.tsv of a library with a row for a requirement of this repository: the specification checker names it as a row for a requirement that does not exist, per FR-002.
  • A library specification whose slug is also a slug here, cited by a library file: it means the library's, per FR-003.
  • A library file that imports ../../core/src/mod.ts: found, per FR-004.
  • A library whose verify leaves out the specification checker: found, per FR-005.
  • A library whose verify does not run tools/check.ts: found, per FR-006.
  • A manifest whose distribution leaves out github, lists a registry twice, is empty or names a registry that is neither github nor npm: refused with the field named, per FR-015 to FR-017.
  • A dependency by a registry version (^1.0.0) or outside commons: not a dependency on a folder of commons, per FR-019.
  • An import of a dependency that its exports does not give: the whole dependency is an input, per FR-020.
  • A script that runs bun ../libraries/src/check.ts: that file and what it imports are inputs, per FR-020.
  • A change to .github/actions/** or commons/tools/**: every library is affected, per FR-021.
  • A change to a file that no library reads: no library is affected and the matrix is empty, per FR-021.
  • A library whose dependency library is affected by a change: affected too, per FR-021.
  • A base that Git does not know: every library is affected, and the reason is said, per FR-021.
  • A library with a workflow of its own, or a repository with no ci workflow: found, per FR-010.
  • A library's spec kit that the documentation does not name: published without it, found, per FR-009.

Assumptions

  • tools/check.ts of a library is the library's own: commons/data reads its trace and layers with commons' kernel and runtime, and another library may keep a different check as long as its verify runs it under that name.
  • A library imports another by package name through a path link (link:../<name> in its devDependencies): link: makes a symbolic link, which Node resolves to the real path, where file: makes a copy under node_modules, which Node 26 refuses to strip types from.
  • Publishing is to the GitHub package registry for public and private libraries alike, and to npm as well only by a decision about one package; every consumer today is inside the organization, and installing from the GitHub package registry needs a token even for a public package, which is the reason a package that outsiders install is put on npm too (FR-016).
  • The existing folders of commons migrate to this form later, after what commons/data teaches (OQ-1).

Open questions

OQ-1open question

Which of ts, docs, ontology and tools become libraries, and how their specifications move: to be settled from what commons/data teaches and carried out before 2026-12-31.

Key entities

  • Library - a top-level folder of commons with a manifest, a spec kit, a package, documentation and checks of its own.
  • Manifest - commons/<name>/library.ts: the library's name, level, spec kit, verify command, version and exports, read as data.
  • Library spec kit - commons/<name>/spec-kit/, numbered from 0001, whose requirements belong to the library.
  • Verify - the one script that proves a library, which this repository's enforcement register names.

Success criteria

SC-001success criterion

A library can be checked, tested and documented from its own folder, and this repository's checks never read inside its spec kit except to run the specification checker on it.

SC-002success criterion

This repository's register names every library as one requirement, and no requirement of a library appears in it.

Review & acceptance checklist

  • [x] Every requirement is testable (MUST / MUST NOT), not aspirational
  • [x] No company fact is asserted here
  • [x] Every open item is marked, not silently decided

Cited by

affected, family, generate-workflows, Libraries, libraries, pack-commons, workflows/definitions, levels, Intellectual Frontiers Commons, Libraries, Onboarding, Documentation, Conformance levels, Subject profiles, Generated workflows, Libraries by concern, Kanon, Archon, Licensing, Distribution

Titles, headings, exports, tables, columns and requirements. Esc closes.