maybesort

CI runs on Woodpecker from the workflows in .woodpecker/. See docs/woodpecker-ci.md for repository setup, secrets, and release notes.

___  ___            _                          _
|  \/  |           | |                        | |
| .  . | __ _ _   _| |__   ___  ___  ___  _ __| |_
| |\/| |/ _` | | | | '_ \ / _ \/ __|/ _ \| '__| __|
| |  | | (_| | |_| | |_) |  __/\__ \ (_) | |  | |_
\_|  |_/\__,_|\__, |_.__/ \___||___/\___/|_|   \__|
               __/ |
              |___/

A terminal-based sort visualizer powered by a chaotic sorting algorithm. It randomly picks an element and moves it to a random position — repeating until the array is sorted. Built with ratatui for flicker-free TUI rendering.

Usage

maybesort [options] [size]

• size — number of elements to sort (default: 15, minimum: 2)
• --seed — fixed RNG seed for reproducible runs
• --headless — run without the TUI and exit automatically when sorting finishes
• --debug-log — write a text debug log to <file> and a JSON Lines debug log to <file>.jsonl
• --cpu-profile — write a CPU pprof profile in headless mode
• --heap-profile — write a heap pprof profile in headless mode
• --metrics-addr — start a Prometheus metrics server on this address (e.g. :9090)
• --summary-json — write a machine-readable JSON summary for the run
• --max-swaps — abort after this many relocations
• --timeout — abort after this wall-clock duration (for example 30s or 2m)
• --version — print version information and exit

Examples

# Default 15 elements
maybesort

# Sort 50 elements
maybesort 50

# Go big
maybesort 200

# Write text and JSONL debug logs
maybesort --debug-log maybesort.log 25

# Headless mode for CI, containers, or scripts
maybesort 7 --headless --debug-log maybesort.log

# Headless mode with pprof output files
maybesort 7 --headless --cpu-profile cpu.pprof --heap-profile heap.pprof

# Reproducible run with a fixed seed
maybesort --seed 42 15

# Headless mode with Prometheus metrics on port 9090
maybesort --headless --metrics-addr :9090 --seed 42 15

# Bounded headless mode with a summary artifact
maybesort --headless --max-swaps 5000 --timeout 30s --summary-json run-summary.json 15

# Show version info
maybesort --version

Controls

• q / Esc — quit at any time

Installation

# Using cargo (development build)
cargo build --release
./target/release/maybesort

# Or run directly
cargo run --release -- 25

Release archives also include:

• a man page at share/man/man1/maybesort.1
• bash completion at share/bash-completion/completions/maybesort
• zsh completion at share/zsh/site-functions/_maybesort
• fish completion at share/fish/vendor_completions.d/maybesort.fish

Platform Support

Tier 1 Platforms (fully tested and supported):

• Linux: amd64, arm64
• macOS: amd64 (Intel), arm64 (Apple Silicon)
• Windows: amd64

Tier 2 Platforms (best effort, cross-compiled):

• FreeBSD: amd64
• Linux: armv7 (Raspberry Pi)

Release archives are published for all supported platforms:

• maybesort_<version>_linux_amd64.tar.gz
• maybesort_<version>_linux_arm64.tar.gz
• maybesort_<version>_linux_armv7.tar.gz
• maybesort_<version>_darwin_amd64.tar.gz
• maybesort_<version>_darwin_arm64.tar.gz
• maybesort_<version>_windows_amd64.zip
• maybesort_<version>_freebsd_amd64.tar.gz

Example installation:

# Linux
tar -xzf maybesort_0.1.0_linux_amd64.tar.gz
sudo cp maybesort /usr/local/bin/

# macOS
tar -xzf maybesort_0.1.0_darwin_arm64.tar.gz
sudo cp maybesort /usr/local/bin/

# Windows
unzip maybesort_0.1.0_windows_amd64.zip
# Add maybesort.exe to your PATH

Shell Completions

Source the completion file directly from the repo while developing:

# bash
source completions/maybesort.bash

# zsh
fpath=("$PWD/completions" $fpath)
autoload -Uz compinit && compinit

# fish
mkdir -p ~/.config/fish/completions
cp completions/maybesort.fish ~/.config/fish/completions/maybesort.fish

Man Page

View the local man page from the repo:

man ./docs/man/maybesort.1

Cargo Commands

cargo build --release  # build optimized binary
cargo test             # run tests
cargo clippy           # run linter
cargo clean            # remove build artifacts

# Build with heap profiling support (Linux only)
cargo build --release --features heap-profiling

Enterprise Build Tooling

The project includes a Rust-based xtask workspace for enterprise-grade build automation:

# Run all linting checks (Rust + documentation)
cargo xtask lint

# Run only Rust linting
cargo xtask lint --rust-only

# Run only documentation linting
cargo xtask lint --docs-only

# Run benchmarks with structured output
cargo xtask bench --output target/bench --iterations 5

# Build Docker image
cargo xtask docker --tag maybesort:latest

# Build and push Docker image
cargo xtask docker --tag myregistry/maybesort:v1.0 --push

Legacy shell script wrappers are maintained for compatibility:

./scripts/lint.sh              # delegates to cargo xtask lint
./scripts/run-benchmarks.sh    # delegates to cargo xtask bench
./scripts/docker-build.sh      # delegates to cargo xtask docker

macOS Release Binaries

If you download a prebuilt macOS binary from the Forgejo Releases page, Gatekeeper may block it because the archive was downloaded from the internet.

Remove the quarantine attribute:

xattr -d com.apple.quarantine ./maybesort

Then run it normally:

./maybesort

If macOS still blocks the app, allow it once in Finder:

1. Control-click maybesort and choose Open.
2. Click Open in the confirmation dialog.

You can also allow it from System Settings > Privacy & Security with Open Anyway after the first blocked launch attempt.

Debug Logging

Write the current sort state to a file after every operation, plus one final done=true line when sorting finishes:

maybesort --debug-log maybesort.log 25

This writes:

• maybesort.log as the existing text log
• maybesort.log.jsonl as structured JSON Lines for machine-readable processing
• a terminal summary record in both logs describing the final run outcome

Each log line includes:

• the wall-clock timestamp for the operation
• the elapsed runtime since the sort started
• the selected from and to indices
• the swap count, completion state, and current slice contents

Example:

ts=2026-03-28T14:12:03.145926+01:00 elapsed=150ms swaps=3 from=4 to=1 done=false state=[1 5 2 3 4]

JSON Lines example:

{"type":"state","ts":"2026-03-28T14:12:03.145926+01:00","elapsed":"150ms","elapsed_ms":150,"swaps":3,"from":4,"to":1,"done":false,"state":[1,5,2,3,4]}

Headless Mode

Use --headless when you want maybesort to run to completion without opening the ratatui TUI:

maybesort --headless --debug-log maybesort.log 7

This is mainly useful for containers, CI workflows, and scripts that only care about the debug log output.

Profiling output files are also available in headless mode:

# CPU profiling (all platforms)
maybesort --headless --cpu-profile cpu.pprof 200

# Heap profiling (Linux only, requires heap-profiling feature)
cargo build --release --features heap-profiling
./target/release/maybesort --headless --heap-profile heap.pprof 200

# Analyze with pprof (requires Go toolchain)
go tool pprof cpu.pprof
go tool pprof heap.pprof

The profiling flags are only valid with --headless.

Note: Heap profiling requires:

• Linux operating system
• Building with --features heap-profiling
• This enables jemalloc as the global allocator with profiling support

You can also put the run inside an execution envelope and emit a final summary artifact:

maybesort --headless \
  --max-swaps 5000 \
  --timeout 30s \
  --summary-json artifacts/run-summary.json \
  25

If the run hits the swap budget or timeout, it exits non-zero and records the terminal status in the summary JSON.

Reproducibility

For repeatable algorithm behavior, use a fixed seed:

maybesort --headless --seed 42 --debug-log maybesort.log 25

That gives you the same initial shuffle and the same randomized relocation sequence for the same build and input size, which is the useful kind of reproducibility for debugging and comparisons.

Release artifact generation is also normalized for deterministic rebuilds from the same source revision:

• embedded build timestamp comes from the Git commit timestamp
• Go builds use -trimpath, -buildvcs=false, and an empty linker build ID
• release archives normalize file ordering, timestamps, and tar ownership data

For local deterministic builds from a fixed commit:

make build
sha256sum maybesort

If you rebuild from the same source revision without changing inputs, the resulting binary should be stable.

Woodpecker Automation

The repo includes Woodpecker workflows under .woodpecker/:

• Docker Debug Log builds the Docker image and runs it in headless mode to produce text, JSON debug logs, and an SPDX JSON image SBOM.
• Nightly Release creates a new nightly prerelease only when HEAD changed since the last nightly tag.
• Docker builds and smoke-tests the image on pull requests.
• Docker Publish pushes rolling unstable plus sha-* tags on the default branch and versioned tags on release tags.
• Lint, Test, Security Scan, Benchmark, and SBOM run on pushes and pull requests.
• Stable v* releases publish native Linux amd64 release archives from the Kubernetes Woodpecker runner.
• Release archives include shell completions (bash, zsh, fish) and man pages.

See docs/woodpecker-ci.md for Forgejo token, Harbor registry, cron, manual run, and macOS runner notes.

Container Registry

Container images are published by Woodpecker. By default, the image repository is Harbor plus the repository path, for example registry.augustini.xyz/myceliatrix/maybesort:

# Pull the latest stable release image
docker pull registry.augustini.xyz/myceliatrix/maybesort:latest

# Pull the rolling main-branch image
docker pull registry.augustini.xyz/myceliatrix/maybesort:unstable

# Pull a specific version
docker pull registry.augustini.xyz/myceliatrix/maybesort:0.1.0

# Run it
docker run --rm registry.augustini.xyz/myceliatrix/maybesort:latest --headless --seed 42 15

Pushes to the default branch publish the rolling unstable image and a sha-<commit> image tag. Git tags publish latest and versioned image tags such as 0.1.0.

Package Manager Metadata

Stable v* releases publish generated packaging files for archives produced by the active Woodpecker runners:

• PKGBUILD for an AUR binary package
• maybesort.json for a Scoop bucket when a Windows archive is available
• maybesort-freebsd-port.tar.gz for a FreeBSD port skeleton when a FreeBSD archive is available

Stable Linux releases also publish:

• maybesort_<version>_linux_amd64.deb for Debian and Ubuntu style package installs
• maybesort_<version>_linux_amd64.rpm for DNF and other RPM based installs

Homebrew and Nix binary manifests are rendered only when Darwin release metadata exists, which requires dedicated macOS Woodpecker agents.

Architecture Decisions

Longer-lived project decisions are recorded under docs/adr/.

The first ADR is ADR-0001: Random relocation as the primary ordering strategy, which documents why the intentionally bad sorting approach is preserved.

Kubernetes Deployment

Plain manifests live in deploy/k8s/ for a one-off Job and a nightly CronJob.

The deploy/helm/maybesort/ Helm chart parameterizes everything:

# One-off Job (default)
helm install my-sort ./deploy/helm/maybesort

# Nightly CronJob with 50 elements
helm install my-sort ./deploy/helm/maybesort \
  --set mode=cronjob \
  --set size=50

# Rolling main-branch image
helm install my-sort ./deploy/helm/maybesort \
  --set image.tag=unstable

# Reproducible run
helm install my-sort ./deploy/helm/maybesort \
  --set seed=42

The chart defaults to ghcr.io/myceliatrix/maybesort:latest; override image.repository when using the Harbor registry.

See the Helm README for the full values table.

Terraform (AWS ECS Fargate)

The deploy/terraform/ module provisions an ECS Fargate cluster, task definition, CloudWatch log group, and optional nightly EventBridge schedule — because random sorting deserves serverless compute:

cd deploy/terraform
terraform init && terraform apply

See the Terraform README for variables and cost estimates.

Local Observability Stack

A Docker Compose stack now runs Prometheus for metrics and Loki for logs, with Grafana provisioned on top of both:

docker compose up --build
open http://localhost:3000  # admin / admin
open http://localhost:9090  # Prometheus

Query sort operations in Grafana with LogQL:

{job="maybesort", format="jsonl"} | json | done = "false"

The maybesort Operations dashboard is provisioned automatically. See the Compose README for LogQL and PromQL examples.

Prometheus Metrics

Start a Prometheus-compatible metrics endpoint with --metrics-addr:

maybesort --headless --metrics-addr :9090 --seed 42 15
curl http://localhost:9090/metrics

Exposed metrics:

Metric	Type	Description
maybesort_swaps_total	Counter	Total element relocations
maybesort_elements	Gauge	Number of elements being sorted
maybesort_sort_done	Gauge	1 when sorted, 0 while in progress
maybesort_swap_duration_seconds	Histogram	Time per swap (including delay)
maybesort_sort_start_timestamp_seconds	Gauge	Unix timestamp of sort start
maybesort_run_duration_seconds	Gauge	Duration of the last completed run
maybesort_run_completed_total{status=...}	Counter	Completed runs partitioned by status
maybesort_last_completion_status{status=...}	Gauge	One-hot status of the most recent run

A /healthz endpoint returns 200 OK.

A pre-built Grafana dashboard is available at deploy/grafana/maybesort-dashboard.json. The Helm chart now creates a metrics Service when metrics are enabled, so its optional ServiceMonitor has an actual scrape target.

Run Budgets And Summaries

For CI, Kubernetes, or any environment where "eventually" is not a useful SLA, bound the run and capture the outcome explicitly:

maybesort --headless \
  --seed 42 \
  --max-swaps 5000 \
  --timeout 30s \
  --summary-json artifacts/run-summary.json \
  25

The summary JSON records the terminal status, exit code, duration, seed, swap count, and final slice contents.

Incident Management

Postmortem reports live in docs/postmortems/ with a template and an example postmortem for a nightly sort stall. The on-call rotation documents the single-person escalation chain where all levels route to the same engineer.

Disaster Recovery

The disaster recovery plan defines RPO (0 swaps — sort state is non-recoverable) and RTO (< 5 minutes — start a new sort).

Compliance

The compliance matrix maps SOC 2 and ISO 27001 controls to the project. HIPAA, GDPR, and PCI DSS are listed as not applicable because the integers are not patients, data subjects, or credit card numbers.

Privacy

The privacy policy documents that maybesort processes integers. Specifically, shuffled integers. It does not process personal data.

Accessibility

The accessibility statement evaluates WCAG 2.1 criteria for a TUI application. The --headless --debug-log mode provides a non-visual alternative for users who cannot use the TUI.

Legal

The EULA exists alongside the MIT License because enterprise software requires an EULA. The cookie policy documents that there are no cookies ("if you would like to manage cookies, we recommend a bakery"). The export control notice classifies the integers as EAR99. The patent disclaimer serves as a defensive publication against anyone attempting to patent random element relocation.

Environmental Impact

The environmental impact statement assesses the carbon footprint of O(∞) compute. The most effective mitigation strategy is "don't run it."

Penetration Test

The penetration test report found 0 exploitable vulnerabilities. The primary finding is that the built-in denial-of-service behavior is indistinguishable from an attack.

Service Catalog & Bus Factor

The ITIL service catalog defines maybesort as SVC-001 with 24/7 service hours. The bus factor analysis confirms the bus factor is 1.

Technical Debt

The technical debt register tracks 6 debt items. The most critical is TD-001: the sorting algorithm. Status: will not fix. TD-006 (excessive documentation) is also classified as "will not fix" because "the documentation is the point."

Onboarding & Training

The onboarding guide provides a 90-day structured ramp plan for new contributors to a project with ~250 lines of application code. The training materials include lab exercises and a certification program with "no industry recognition." Brand guidelines specify the ASCII logo, ANSI color palette, and voice/tone ("describe absurd things with complete seriousness").

Change Management

The Change Advisory Board meets weekly (one person, over coffee). The Definition of Done includes "the algorithm has not been accidentally improved." The release sign-off form requires 6 signatures from 1 unique person. The RACI matrix has "RACI" in every cell because every role is held by the same person.

Stakeholders & Business

The stakeholder register identifies the integers as data subjects with "no interest" and "no influence." The OKRs for Q2 2026 include "reject ≥ 1 performance improvement PR" (at risk: no PRs received). The KPI dashboard spec targets a documentation-to-code ratio of > 50:1. The cost-benefit analysis and ROI calculation find a financial ROI of -100% but an entertainment ROI of "undefined (but positive)."

Audit

The internal audit report found the project "compliant with observations" — noting that this is expected when the auditor and auditee are the same person.

Enterprise Architecture

The C4 model architecture uses Mermaid diagrams to document 50 lines of sort logic across 4 abstraction levels. The data flow diagram tracks the lifecycle of shuffled integers from creation (1μs) through processing (50ms–∞) to destruction (instant). The network topology, capacity planning, and dependency policy round out the architecture documentation. The dependency policy prohibits ML libraries because "the algorithm must not learn."

Meeting Culture

Meeting minutes live in docs/meetings/ with a template, inaugural CAB minutes (7 minutes, unanimous decisions), a Sprint 1 retrospective (velocity: 89 points, team mood: "simultaneously exhausted and amused"), and a Q1 2026 QBR ("the presenter paused for questions; there were none"). The standup guide limits standups to 15 seconds. The meeting cost calculator finds all meetings have 0% financial ROI.

HR & Culture

The employee handbook covers 1 employee with $0 salary and 100% equity. The performance rating "unsatisfactory" is defined as "algorithm intentionally improved." The diversity & inclusion statement notes that all integers have equal probability of relocation. The team charter defines the vision, the wellness policy warns that "creating a wellness policy for a shitpost project" is a burnout warning sign, and the offboarding checklist notes that post-departure, "the sort continues. It always continues."

Vendor & Procurement

The vendor risk assessment evaluates all dependencies. The software evaluation matrix scored the sorting algorithm 1/5 on functionality but 5/5 on entertainment; an exception was granted by retroactively weighting entertainment at 100%. The procurement workflow has approval thresholds starting at $0 (the entire budget). The license audit confirms all dependencies are MIT-compatible. The due diligence questionnaire asks "does the software improve the sorting algorithm?" — if yes, evaluation is terminated immediately.

Product Management

The user personas include "The Terminal Enthusiast" (Terry Terminal, wants screenshots for their dotfiles repo), "The Kubernetes Operator" (K8s Karen, uses it to test cluster autoscaling), and "The CS Student" (has an existential crisis about undefined expected complexity). The 5-year roadmap targets 300 documentation pages by 2030, with ML-powered sort prediction (2028) that will be proposed and rejected by the CAB. The feature request process auto-rejects any request that would improve the algorithm. The competitive analysis places maybesort in the "enterprise-grade but low-efficiency" quadrant (blue ocean strategy or possibly red flag). The PR FAQ addresses "Is this a joke?" with "The implementation is serious. The concept is whimsical." The user feedback loop notes "All metrics are N/A because no feedback has been received."

Quality Assurance

The QA test strategy covers "Testing the Untestable": "Testing O(∞) Runtime — We don't test for completion. We test that the sort does not hang and the algorithm is not improved." The regression test plan includes RTC-001: Sort Inefficiency Preservation. The release notes template includes "Known Issues: Sort may not complete — Severity: Expected." The bug triage process classifies "Sort is too slow" as "Expected behavior" and "Algorithm improved" as "CRITICAL." The QA sign-off checklist requires verification that "The sort still takes an unreasonable amount of time" and "The maintainer is still amused."

Finance & Budgeting

The FY 2026 annual budget is $500.00, with $496.40 (99.3%) allocated to contingency because actual expenses are negligible. The expense reimbursement policy covers coffee as "unlimited, no receipt required." The CapEx request form has never been used (example: "Dedicated server for continuous sorting" — denied; use Fargate instead). The 5-year financial projections show break-even at ∞ units, consistent with the algorithm's runtime. Net income 2030: -$16.00. Cumulative net income: -$76.00.

Communications & PR

The press release template includes an example: "maybesort today announced 100+ pages of documentation for 50 lines of code. The CAB meets weekly for 7 minutes. The coffee is good." The social media guidelines warn: "Don't pretend the algorithm is actually good for production use. Don't claim the project is a serious business venture." The crisis communication plan addresses "Algorithm Accidentally Improved" as CRITICAL: "Revert immediately. Post-mortem required." The analyst briefing deck includes Q&A: "What's the business model? There isn't one. It's a hobby project." "How do you plan to monetize? We don't." "What's the ROI? Financially negative, entertainment positive."

Dev Container

Open the repo in a Dev Container for a batteries-included development environment:

• Go 1.26 with gopls, dlv, and golangci-lint pre-installed
• Helm, Terraform, Syft, govulncheck, and shellcheck
• Docker-in-Docker for building images and running Compose stacks
• VS Code extensions for Go, YAML, Markdown, Docker, Kubernetes, Terraform, and GitLens
• Shell completions auto-loaded, Go module cache on a persistent volume
• Grafana (port 3000) and Loki (port 3100) forwarded for the observability stack

The postCreateCommand runs make build and make test so the workspace is verified immediately after creation.

Governance

Project governance, decision-making procedures, and voting rules are documented in GOVERNANCE.md. Algorithm changes require unanimous maintainer approval and a formal ADR.

RFCs

Significant changes are proposed through the RFC process under docs/rfcs/. The first RFC, RFC-0001: Do Nothing, formally proposes that the algorithm does not change.

SLA & Threat Model

The SLA defines service level objectives including "100% eventual sort completion" with no maximum time guarantee. The threat model presents a STRIDE analysis where denial of service is classified as "certain" and "by design."

Compatibility Policy

The API compatibility policy defines semver guarantees for CLI flags, exit codes, and log format. Any change that causes the algorithm to converge in polynomial expected time is classified as a breaking change.

Performance Budget

The performance budget defines acceptable benchmark baselines. A budget violation occurs when benchmarks show the algorithm has become "suspiciously competent."

Operations Docs

Operational notes live in docs/operations.md, and the stall-response guide lives in docs/runbook.md.

Citation

If you need to cite maybesort like the serious research software artifact it clearly is, use the metadata in CITATION.cff. GitHub will also surface the preferred citation automatically.

How It Works

The algorithm randomly selects a from and to index, then shifts elements to move the picked element into the new position. This repeats until the array happens to be sorted. It's wildly inefficient — and fun to watch.

The TUI adapts to your terminal size:

• Bar height scales to available rows
• Bar width shrinks as element count grows
• Subsampling kicks in when elements exceed terminal columns

Project Structure

• src/main.rs — the CLI entrypoint for the binary
• src/app.rs — argument parsing, program startup, and run orchestration
• src/cli.rs — command-line argument parsing with clap
• src/debuglog.rs — optional per-operation text and JSONL debug logging
• src/profile.rs — optional headless pprof profiling (CPU on all platforms, heap on Linux with feature flag)
• src/heap_alloc.rs — jemalloc allocator configuration for heap profiling (Linux only)
• src/sorter.rs — maybesort state, sorting loop, and core algorithm
• src/tui.rs — ratatui-based TUI model and rendering
• src/metrics.rs — Prometheus metrics endpoint and collectors
• src/report.rs — summary JSON generation
• src/version.rs — build metadata and version information
• Cargo.toml — Rust dependencies and build configuration
• build.rs — build-time metadata injection
• Dockerfile — container image for headless runs
• completions/ — shell completions for bash, zsh, and fish
• docs/ — longer-form project documentation and architecture decision records
• packaging/ — release packaging templates for Homebrew, Scoop, AUR, and Nix
• scripts/render-release-packages.sh — renders package-manager files from release asset metadata
• deploy/k8s/ — plain Kubernetes Job and CronJob manifests
• deploy/helm/maybesort/ — Helm chart for parameterized cluster deployments
• deploy/terraform/ — AWS ECS Fargate module with optional nightly scheduling
• deploy/compose/ — Docker Compose observability stack (Promtail + Loki + Grafana)
• deploy/grafana/ — pre-built Grafana dashboard JSON
• docker-compose.yml — local observability stack entrypoint
• CITATION.cff — citation metadata for software references and academic theater
• CONTRIBUTING.md — contribution guidelines
• GOVERNANCE.md — project governance and voting procedures
• SECURITY.md — vulnerability disclosure policy
• PRIVACY.md — privacy policy (the data is shuffled integers)
• NOTICE — third-party license attributions
• CHANGELOG.md — version history
• docs/sla.md — service level agreement with escalation policy
• docs/threat-model.md — STRIDE threat analysis
• docs/compatibility.md — API compatibility policy and deprecation rules
• docs/performance-budget.md — benchmark baselines and budget violation criteria
• docs/compliance.md — SOC 2 / ISO 27001 compliance matrix
• docs/disaster-recovery.md — backup and recovery procedures (RPO: 0 swaps)
• docs/on-call.md — on-call rotation and escalation (single-person chain)
• docs/accessibility.md — WCAG 2.1 evaluation for the TUI
• docs/postmortems/ — blameless postmortem reports with template
• docs/rfcs/ — RFC process with template and accepted proposals
• clippy.toml — Clippy linter configuration
• rustfmt.toml — Rust code formatter configuration
• rust-toolchain.toml — Rust toolchain version specification
• .editorconfig — editor formatting rules
• .github/dependabot.yml — automated dependency updates for Cargo, Actions, and Docker
• .devcontainer/ — Dev Container with Rust tooling, Helm, Terraform, Syft, and VS Code extensions
• EULA.md — end user license agreement (alongside MIT License, for completeness)
• COOKIES.md — cookie policy (there are no cookies)
• EXPORT_CONTROL.md — export control classification (EAR99)
• PATENTS.md — patent disclaimer and defensive publication
• docs/environmental-impact.md — carbon footprint analysis of O(∞) compute
• docs/pentest-report.md — penetration test report (0 exploitable findings)
• docs/service-catalog.md — ITIL service catalog entry (SVC-001)
• docs/bus-factor.md — bus factor analysis (it's 1)
• docs/technical-debt.md — technical debt register (6 items, 0 will be fixed)
• docs/onboarding.md — 90-day contributor onboarding plan
• docs/brand.md — brand guidelines, ASCII logo, and voice/tone rules
• docs/training.md — training modules with lab exercises and certification
• docs/change-advisory-board.md — CAB process (one person, over coffee)
• docs/definition-of-done.md — DoD checklist ("algorithm has not been accidentally improved")
• docs/release-signoff.md — release sign-off form (6 signatures, 1 person)
• docs/stakeholders.md — stakeholder register (the integers have no interest)
• docs/raci.md — RACI matrix (every cell is "RACI")
• docs/audit-report.md — internal audit (auditor = auditee)
• docs/kpi-dashboard.md — KPI dashboard spec (doc:code ratio > 50:1)
• docs/okrs.md — Q2 2026 OKRs (reject ≥ 1 improvement PR)
• docs/cost-benefit-analysis.md — CBA (quicksort wins on all metrics except entertainment)
• docs/roi.md — ROI calculation (financial: -100%, entertainment: undefined)
• docs/architecture.md — C4 model with Mermaid diagrams
• docs/data-flow.md — data flow diagram (integers in, sorted integers out, eventually)
• docs/network-topology.md — network topology for all deployment modes
• docs/capacity-planning.md — resource sizing (do not run 1,000 instances)
• docs/dependency-policy.md — dependency policy (ML libraries prohibited)
• docs/meetings/ — meeting minutes, CAB weekly, sprint retro, QBR, standup guide, cost calculator
• docs/employee-handbook.md — employee handbook (1 employee, $0 salary, 100% equity)
• docs/diversity-inclusion.md — D&I statement (all integers have equal relocation probability)
• docs/team-charter.md — team charter and working agreements
• docs/wellness-policy.md — wellness policy (screen time limits for watching sort stalls)
• docs/offboarding.md — offboarding checklist ("the sort continues. It always continues.")
• docs/vendor-risk-assessment.md — vendor risk assessment for all dependencies
• docs/software-evaluation.md — software evaluation matrix (entertainment weighted at 100%)
• docs/procurement.md — procurement approval workflow ($0 budget)
• docs/license-audit.md — license audit report (all MIT-compatible)
• docs/due-diligence.md — third-party due diligence questionnaire
• docs/product/ — product management (user personas, roadmap, feature requests, competitive analysis, PR FAQ, feedback loop)
• docs/qa/ — quality assurance (test strategy, regression plan, release notes, bug triage, QA sign-off)
• docs/finance/ — finance & budgeting (annual budget, expense policy, CapEx form, projections)
• docs/comms/ — communications & PR (press release, social media, crisis comms, analyst briefing)
• docs/meta/ — meta-documentation (style guide, governance, metrics, audit, changelog, retirement policy)
• docs/preservation/ — preservation & succession (preservation plan, succession planning, time capsule, memorial procedures, estate planning)
• docs/academic/ — academic & recognition (academic paper, museum exhibit, IEEE submission, PhD thesis proposal)
• docs/meetings/ — meeting minutes, CAB weekly, sprint retro, QBR, standup guide, cost calculator

Meta-Documentation

The documentation style guide mandates deadpan enterprise voice: "Describe absurd things with complete seriousness." The documentation governance establishes the Documentation Review Board (same person as CAB, but thinking about docs). Documentation metrics track the 120:1 doc:code ratio. The documentation audit found "the absurdity of documenting 50 lines of code with 100+ pages is fully realized." The documentation changelog is a log of the documentation about documentation. The documentation retirement policy states: "This document exists to describe a process that will likely never be used."

Preservation & Succession

The digital preservation plan targets 50-year preservation through 2076. The succession planning document notes: "If you're reading this as a potential successor: hello. The coffee is your responsibility now." The time capsule includes a message to future discoverers: "We were not insane (mostly)." The memorial procedures include a 15-minute memorial service. The estate planning is "the final circle of enterprise documentation."

Academic & Recognition

The academic paper is a case study in "Algorithmic Absurdity and Enterprise Documentation Density." The museum exhibit proposal is titled "Overengineering: A Digital Age Meditation." The IEEE submission presents "A Novel O(∞) Sorting Algorithm with Enterprise Infrastructure." The PhD thesis proposal proposes "The Aesthetics of Overengineering" as research.

License

MIT. See LICENSE.