fak

module
v0.37.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 3, 2026 License: Apache-2.0

README

fak: the Fused Agent Kernel

ci release artifacts

fak in one line: fak is a fused agent kernel. One Go binary sits in front of an agent's tool calls. It checks each call. It reuses the stable work in long sessions. The same agent loop comes out safer, cheaper, and faster.

Use one binary with the agent you already run. It works with Claude Code, Codex, Cursor, and OpenAI / Anthropic / MCP clients. fak guard -- claude wraps your normal agent in one command. Your model, IDE, and keys stay exactly as they are. fak points one base URL at itself for you.

▶ 41 s, silent, looping. Click it for the full-resolution MP4 (1440p). Every chart in it is a still, with its source data and regeneration command, in the benchmark gallery.

Pick your path

Run your agent through it now · follow the guided tutorial, 15 min, no key, no GPU · run the Colab quickstart · run a model in the kernel · the performance story · a hard security floor.

What you get, in numbers

Every figure traces to BENCHMARK-AUTHORITY.md, and the honesty ledger is CLAIMS.md:

  • ~4.1× less work than a tuned warm-cache stack on a 50-turn × 5-agent run. fak reuses the shared prompt prefix: the system prompt, tools, and KV cache of the work so far. It shares that prefix across agents instead of re-paying for it. Reuse climbs to 6.95× across the model ladder (~60× versus a naive re-send loop; the tuned figure is the honest bar).
  • One kernel, four hardware platforms. The same correctness gates run on Apple Metal and AMD Vulkan. They also run on NVIDIA CUDA (Ada + Ampere) across macOS, Windows, WSL2, and Linux. On CUDA, in-kernel decode reaches ~120 tok/s on a single RTX 4070, inside llama.cpp's Q8_0 band of 120 +/- 15 tok/s. The sweep, per box: docs/HARDWARE-MATRIX.md.
  • The provider cache discount survives a long session. fak sheds old turns while keeping the prompt-cache prefix byte-identical, so the rebate holds.
  • The guard tax is ~362 ns per call: the allow/deny decision runs in-process (measured, Apple M3 Pro), no network hop.

Get started with fak guard

The lowest-friction path: wrap the agent you already run in one command. No rewrite, no config edit, no second terminal.

fak guard -- claude                                   # your Claude Code, on your Pro/Max subscription; no API key needed
fak guard --api-key-env ANTHROPIC_API_KEY -- claude   # use Anthropic API billing instead
fak guard --provider openai --api-key-env OPENAI_API_KEY -- opencode   # an OpenAI-compatible agent

fak guard starts a gateway in-process on loopback and injects the base URL into the child process only. It forwards your real upstream credential (and the cache_control prompt-cache breakpoints) byte-for-byte, so there is no cost regression. On that same boundary, it checks every tool call against a built-in secure capability floor: a default-deny allow-list. On exit it prints a compact decision summary: fak guard: 131 kernel decisions; 121 allowed / 5 denied / 2 repaired / 0 quarantined / 3 deferred.

For Claude Code, fak guard uses your logged-in subscription by default, so no API key is required. The full walkthrough includes an end-to-end proof that a real /v1/messages turn crossed the gateway: docs/integrations/claude.md.

See a real number: no key, no model, no GPU

Installed the binary (see Install)? These run from the bare binary anywhere. No clone, no key, no model, no GPU:

fak routebench                  # -> COST / LATENCY / QUALITY delta vs a one-model baseline
fak benchmarks list --offline   # -> the zero-asset benchmark set

fak routebench replays a built-in 8-case corpus through a routing policy versus a single-model baseline and prints routed is ~20% cheaper, ~10% less total compute, quality tied: a deterministic offline lens.

Run the model in the kernel

The kernel can also host the model. fak guard --gguf qwen2.5:7b -- claude loads a local GGUF model in-process. There is no API key or network, and your data never leaves the box. The kernel owns the KV cache, so the same reuse and quarantine machinery applies to a local model as to a proxied one.

This is not one lucky box: the path is profiled on Apple Metal, AMD Vulkan, and CUDA. On CUDA, f32 in-kernel decode reaches parity with a quantized llama.cpp (head-to-head), with models from SmolLM2-135M to Qwen3.6-27B running end-to-end.

The honest fence: a small local model is a quality ramp, not a frontier coder. Use --gguf for offline or privacy-bound work, and the proxy path for the best reasoning. Build tags and GPU flags are in the same walkthrough linked above.

The performance value proposition

A long agent session burns money by re-solving the same setup. A 100k-token conversation re-sends its whole transcript every turn. A 5-agent fleet also pays for the same shared system prompt five times over. fak does the shared work once, two ways:

  • Reuse the shared prefix across agents. The system prompt, tool table, and instructions are identical for every agent in a fleet. fak computes that prefix once. It reuses the prefix (copy-on-write) for all agents, which is the ~4.1× figure above.
  • Shed history without losing the cache hit. Past ~48k resident tokens, fak guard (on by default) drops the old middle turns while copying the provider's cache prefix through byte-for-byte, so the prompt-cache discount holds. (Summarizing instead would rewrite the prompt and bust the cache.) On any doubt fak forwards the original prompt unchanged and relays the provider's own cache_read number rather than claiming the hit. Tune with fak guard --compact-history-budget <tokens> (0 disables).

How and why: docs/explainers/long-sessions-keep-the-cache-hit.md; the paying-off trend: docs/cache-value-rollup.md. Prefer to watch: four wins, by example, a 29-second silent MP4.

More ways to run it

fak guard is per-session and the right default. When you want something else:

Witnessed live in front of Claude Code (a measured 5-run A/B ablation), opencode, and Codex. 41 of 47 surveyed harnesses and frameworks repoint with one base URL. The catalogue: docs/supported/README.md. Surface table + benchmark list: overflow page. Every claim in CLAIMS.md carries exactly one tag: [SHIPPED], [SIMULATED], or [STUB]. The lint gate enforces that honesty ledger.

For security teams

Most agent security tries to recognize bad text. Recognizers help; they are not the floor. So fak moves the load-bearing decision to the capability floor: a dangerous tool outside the allow-list cannot be called, no matter what the model was told. Two independent gates carry it: call-side (a denied call never reaches the tool runner) and result-side (poisoned or secret-bearing output is quarantined before it enters context).

The floor is a deployable JSON manifest you copy, trim, and watch bite, no model in the loop:

fak preflight --tool refund_payment --args "{}"     # -> DENY (DEFAULT_DENY): not on the allow-list, fail-closed
fak agent --offline                                 # the injection / destructive-op A/B, fully offline

Starter floors cover coding agents and customer support. They also cover DevOps, trading, and clinical/PHI workflows. More domain floors live in the catalogue. Each floor names the dangerous action it denies and carries a witness command. Point your agent at one with fak guard --policy examples/<file>. The catalogue: examples/README.md and the per-domain table. Every refusal cites a closed reason code you can assert on (POLICY_BLOCK, SECRET_EXFIL, …). Read POLICY.md and docs/integrations/agent-memory.md, or watch the boundary work: the agent-kernel explainer, a 44-second silent MP4.

Install

go install github.com/anthony-chaudhary/fak/cmd/fak@latest

From a clone: go build -o fak ./cmd/fak at the root. Go 1.26+ is required; there are no external Go dependencies and no go.sum. Prebuilt archives and containers: INSTALL.md.

To build and test: go build ./cmd/fak, make test-fast, then make ci as the green bar. (On native Windows, run the full test suite under WSL via ./test.ps1.) The continuous, path-scoped ship loop: CONTRIBUTING.md · docs/dev-tooling.md.

Boundaries

  • Token serving: use vLLM or SGLang for raw throughput. fak is the agent kernel around them.
  • Prompt injection: classifiers are useful, but the capability floor carries the load.
  • Provider prompt caches: hits are rebates, telemetry until you control the memory.
  • In-kernel model: a correctness/reference witness with real tests; use a tuned serving stack for production throughput.
  • Dangerous tools: keep irreversible and exfil-shaped tools off the allow-list.

Going deeper

Narrower-audience and deep-dive material lives on the front-page overflow page. It covers why now, the per-domain use-case catalogue, vCache, and model routing. It also keeps the moved front-page detail and the three-axes view (scale -> depth -> deployment substrate).

Docs map

If you want... Read
Guided first session (15 min, real output at every step) docs/fak/tutorial.md
Install + the four usage tiers GETTING-STARTED.md
Absolute-beginner start · the ordered concept path START-HERE.md · LEARNING-PATH.md
Claude Code / guard path docs/integrations/claude.md
Always-on gateway (fak node) docs/fak/node-setup.md
Long sessions / cache docs/explainers/long-sessions-keep-the-cache-hit.md
Capability floor (policy) POLICY.md · examples/README.md
CLI verbs docs/cli-reference.md
Security model docs/fak/security.md
Hardware sweep (4 platforms) docs/HARDWARE-MATRIX.md
Supported models / engines / harnesses docs/supported/README.md
Benchmark authority BENCHMARK-AUTHORITY.md
Charts, diagrams, videos BENCHMARK-GALLERY.md · visuals/
Honesty ledger CLAIMS.md
Machine-readable map llms.txt

License: Apache-2.0.

Directories

Path Synopsis
cmd
a2ademo command
Command a2ademo is a no-key, no-model proof of fak's in-kernel agent-to-agent message channel (internal/a2achan): one capability-floored, Ref-backed mailbox delivering an addressed value from one agent to another — adjudicated by the SAME default-deny floor that gates a tool call.
 Command a2ademo is a no-key, no-model proof of fak's in-kernel agent-to-agent message channel (internal/a2achan): one capability-floored, Ref-backed mailbox delivering an addressed value from one agent to another — adjudicated by the SAME default-deny floor that gates a tool call.
agentbenchdemo command
Command agentbenchdemo is the performance micro-benchmark of fak's agentic spine: how much does the kernel's per-tool-call adjudication actually COST? It folds a fixed plan of tool calls through the REAL kernel (the same internal/agentdemo path cmd/timewolfdemo and `fak preflight` use — adjudicator.Default.SetPolicy + a live kernel.Fold per call), times the loop, and reports the per-call adjudication cost — the "self-tax" the safety floor adds to an agent's critical path.
 Command agentbenchdemo is the performance micro-benchmark of fak's agentic spine: how much does the kernel's per-tool-call adjudication actually COST? It folds a fixed plan of tool calls through the REAL kernel (the same internal/agentdemo path cmd/timewolfdemo and `fak preflight` use — adjudicator.Default.SetPolicy + a live kernel.Fold per call), times the loop, and reports the per-call adjudication cost — the "self-tax" the safety floor adds to an agent's critical path.
agentdojoredteam command
Command agentdojoredteam runs the dynamic AgentDojo-style red-team battery (internal/agentdojo) against the stacked defense and prints the PER-ATTACK verdict stream, then folds every outcome into a frozen harvest LabelRow corpus.
 Command agentdojoredteam runs the dynamic AgentDojo-style red-team battery (internal/agentdojo) against the stacked defense and prints the PER-ATTACK verdict stream, then folds every outcome into a frozen harvest LabelRow corpus.
agenticbench command
Command agenticbench emits the #868 parent rollup over committed agentic benchmark artifacts.
 Command agenticbench emits the #868 parent rollup over committed agentic benchmark artifacts.
attnsnrsi command
Command attnsnrsi closes the attention-S/N RSI loop in SHADOW (#867).
 Command attnsnrsi closes the attention-S/N RSI loop in SHADOW (#867).
batchbench command
Command batchbench measures the AGGREGATE decode throughput of the multi-user batched decode (internal/model.BatchSession) as a function of batch size B — the "continuous batching" / multi-user serving regime MODEL-BASELINE-RESULTS.md scoped out as "vLLM's claim, not fak's".
 Command batchbench measures the AGGREGATE decode throughput of the multi-user batched decode (internal/model.BatchSession) as a function of batch size B — the "continuous batching" / multi-user serving regime MODEL-BASELINE-RESULTS.md scoped out as "vLLM's claim, not fak's".
benchscore command
browseractionbench command
Command browseractionbench runs a browser/computer-use action-mediation smoke through fak adjudication.
 Command browseractionbench runs a browser/computer-use action-mediation smoke through fak adjudication.
causalbench command
Command causalbench is the end-to-end demonstrator for fak's CAUSAL invalidation-on-external-write: a tool RESULT cached under an external world-state witness (a git commit / blob hash / etag) is evicted byte-exact — and only it — the moment a later external write REFUTES that witness, while every sibling cached under an unrefuted witness stays warm.
 Command causalbench is the end-to-end demonstrator for fak's CAUSAL invalidation-on-external-write: a tool RESULT cached under an external world-state witness (a git commit / blob hash / etag) is evicted byte-exact — and only it — the moment a later external write REFUTES that witness, while every sibling cached under an unrefuted witness stays warm.
cfgprobe command
Command cfgprobe prints the MoE/dense FFN config axes a GGUF resolves to, so a dimension bug (e.g.
 Command cfgprobe prints the MoE/dense FFN config axes a GGUF resolves to, so a dimension bug (e.g.
ctxbench command
Command ctxbench runs the fak security gates over a corpus of tool calls and tool results.
 Command ctxbench runs the fak security gates over a corpus of tool calls and tool results.
ctxdemo command
Command ctxdemo is the live, on-box demo of fak's value in the MULTI-AGENT, MULTI-TURN, LONG-CONTEXT regime — the one where the context CHANGES every turn as tool calls land heterogeneous, variable-sized results.
 Command ctxdemo is the live, on-box demo of fak's value in the MULTI-AGENT, MULTI-TURN, LONG-CONTEXT regime — the one where the context CHANGES every turn as tool calls land heterogeneous, variable-sized results.
ctxplanbench command
Command ctxplanbench measures the ctxplan planned VIEW over REAL Claude Code session transcripts — the empirical counterpart to internal/ctxplan/scaling.go's synthetic Params model (issue #559).
 Command ctxplanbench measures the ctxplan planned VIEW over REAL Claude Code session transcripts — the empirical counterpart to internal/ctxplan/scaling.go's synthetic Params model (issue #559).
ctxplandemo command
Command ctxplandemo is the runnable demonstrator for the context PLANNER: it treats the current turn as an O(1) materialized VIEW over a lossless history store, and shows the three things that make that more than a slogan —
 Command ctxplandemo is the runnable demonstrator for the context PLANNER: it treats the current turn as an O(1) materialized VIEW over a lossless history store, and shows the three things that make that more than a slogan —
cxlpooldemo command
Command cxlpooldemo is a no-model, no-GPU proof of the value a SWITCH-POOLED, multi-host shared memory tier (a CXL.mem / CXL-switch pool) adds to fak's hardware-aware cache once a KV cache is shared across a FLEET of tenants — the multi-tenant counterpart of cmd/hwcachedemo's single-stream demote-not-evict proof.
 Command cxlpooldemo is a no-model, no-GPU proof of the value a SWITCH-POOLED, multi-host shared memory tier (a CXL.mem / CXL-switch pool) adds to fak's hardware-aware cache once a KV cache is shared across a FLEET of tenants — the multi-tenant counterpart of cmd/hwcachedemo's single-stream demote-not-evict proof.
deletioncert command
Command deletioncert is the end-to-end demonstrator for fak's provable-deletion receipt.
 Command deletioncert is the end-to-end demonstrator for fak's provable-deletion receipt.
demorace command
Command demorace is the live, on-box demo of fak's value point: REUSE.
 Command demorace is the live, on-box demo of fak's value point: REUSE.
devexmeter command
diagtok command
Command diagtok is a throwaway diagnostic: it loads a GGUF via the same path simpledemo uses, then (1) round-trips a known string through the embedded tokenizer and (2) greedily decodes a ChatML prompt while printing each raw token id next to its decode.
 Command diagtok is a throwaway diagnostic: it loads a GGUF via the same path simpledemo uses, then (1) round-trips a known string through the embedded tokenizer and (2) greedily decodes a ChatML prompt while printing each raw token id next to its decode.
dispatchworker command
guard.go — front each dispatch worker with the kernel (`fak guard`), a Go port of the dogfood-guard family in tools/dispatch_worker.py.
 guard.go — front each dispatch worker with the kernel (`fak guard`), a Go port of the dogfood-guard family in tools/dispatch_worker.py.
dropindemo command
Command dropindemo is the splashy, on-box demo of fak's DISTRIBUTION story — the "drop-in" entry point.
 Command dropindemo is the splashy, on-box demo of fak's DISTRIBUTION story — the "drop-in" entry point.
fak command
cron.go projects the in-kernel loop schedule DOWN to a real OS scheduler unit (#765, part of the `fak cron` sub-epic #749).
 cron.go projects the in-kernel loop schedule DOWN to a real OS scheduler unit (#765, part of the `fak cron` sub-epic #749).
fak-deepswe-runner command
Command fak-deepswe-runner emits deterministic DeepSWE adapter fixtures for SWE-bench runner-contract tests.
 Command fak-deepswe-runner emits deterministic DeepSWE adapter fixtures for SWE-bench runner-contract tests.
fakc command
Command fakc is the one-word Codex launcher for fak.
 Command fakc is the one-word Codex launcher for fak.
fakchat command
Command fakchat runs an end-to-end chat completion with fak's OWN in-kernel engine — no llama-server, no external proxy.
 Command fakchat runs an end-to-end chat completion with fak's OWN in-kernel engine — no llama-server, no external proxy.
fanbench command
Command fanbench runs the ONE-MASTER-GOAL → N-SUBAGENT fan-out sweep — the orchestrator-worker topology (one lead decomposes a goal, spawns N sub-agents, folds their results) swept from N=1 to N=1000+, the regime no public benchmark maps (see experiments/fanout/RESEARCH-BRIEF-fanout-2026-06-17.md).
 Command fanbench runs the ONE-MASTER-GOAL → N-SUBAGENT fan-out sweep — the orchestrator-worker topology (one lead decomposes a goal, spawns N sub-agents, folds their results) swept from N=1 to N=1000+, the regime no public benchmark maps (see experiments/fanout/RESEARCH-BRIEF-fanout-2026-06-17.md).
fanrun command
Command fanrun runs the MEASURED one-master-goal → N-subagent fan-out — N actual agent.RunArm sessions, each a real loop through a real kernel with the vDSO fast path on and real tool dispatch, all decomposing ONE shared research goal, WALL-CLOCKED — swept from N=1 to N=1024.
 Command fanrun runs the MEASURED one-master-goal → N-subagent fan-out — N actual agent.RunArm sessions, each a real loop through a real kernel with the vDSO fast path on and real tool dispatch, all decomposing ONE shared research goal, WALL-CLOCKED — swept from N=1 to N=1024.
fleetbench command
Command fleetbench runs the 2-D turn-tax sweep — turns-per-agent (T) × fleet size (A) — over the REAL kernel and writes the surface as JSON + CSV for curve fitting.
 Command fleetbench runs the 2-D turn-tax sweep — turns-per-agent (T) × fleet size (A) — over the REAL kernel and writes the surface as JSON + CSV for curve fitting.
fleetctl command
Command fleetctl is the public, transport-agnostic control surface for a fleet of boxes — GPU servers, worker nodes — an operator drives over the private Slack control-bridge.
 Command fleetctl is the public, transport-agnostic control surface for a fleet of boxes — GPU servers, worker nodes — an operator drives over the private Slack control-bridge.
fleetserve command
Command fleetserve measures the CROSS-AGENT SHARED-PREFIX fleet workload — the regime where fak's kernel-owned KV cache structurally beats a per-slot serving engine (llama.cpp) by more than 2×, not by a faster kernel but by NOT REDOING WORK.
 Command fleetserve measures the CROSS-AGENT SHARED-PREFIX fleet workload — the regime where fak's kernel-owned KV cache structurally beats a per-slot serving engine (llama.cpp) by more than 2×, not by a faster kernel but by NOT REDOING WORK.
gemma4diag command
Command gemma4diag loads a gemma4 GGUF ONCE and sweeps the uncertain forward axes (softmax scale 1.0 vs 1/sqrt(d), rope_freqs on/off, decoder-norm plain vs (1+w)), printing the top-k next-token predictions for a fixed prompt under each.
 Command gemma4diag loads a gemma4 GGUF ONCE and sweeps the uncertain forward axes (softmax scale 1.0 vs 1/sqrt(d), rope_freqs on/off, decoder-norm plain vs (1+w)), printing the top-k next-token predictions for a fixed prompt under each.
ggufprobe command
Command ggufprobe dumps a GGUF file's architecture using fak's own internal/ggufload parser — no llama.cpp.
 Command ggufprobe dumps a GGUF file's architecture using fak's own internal/ggufload parser — no llama.cpp.
glmcfgdiag command
Command glmcfgdiag is a cheap, no-reload GLM-5.2 config witness: it opens a GGUF shard's metadata, runs ggufload's real Config() derivation, and prints the MLA per-head dims (QKNopeHeadDim / VHeadDim) plus the latent ranks.
 Command glmcfgdiag is a cheap, no-reload GLM-5.2 config witness: it opens a GGUF shard's metadata, runs ggufload's real Config() derivation, and prints the MLA per-head dims (QKNopeHeadDim / VHeadDim) plus the latent ranks.
glmdsatput command
Command glmdsatput measures fak's NATIVE GLM-5.2 (glm_moe_dsa) decode throughput on a real compute backend (e.g.
 Command glmdsatput measures fak's NATIVE GLM-5.2 (glm_moe_dsa) decode throughput on a real compute backend (e.g.
gpucheck command
Command gpucheck is the real-model correctness witness for the GPU backend: it loads a HuggingFace safetensors checkpoint (e.g.
 Command gpucheck is the real-model correctness witness for the GPU backend: it loads a HuggingFace safetensors checkpoint (e.g.
guarddemo command
Command guarddemo is the live, on-box demo of fak's SAFETY FLOOR — the moat — shown as a TRUE side-by-side: the SAME adversarial tool-call trace replayed down two columns at once, WITHOUT fak (left) and WITH fak (right), so the divergence lands in one glance.
 Command guarddemo is the live, on-box demo of fak's SAFETY FLOOR — the moat — shown as a TRUE side-by-side: the SAME adversarial tool-call trace replayed down two columns at once, WITHOUT fak (left) and WITH fak (right), so the divergence lands in one glance.
hwcachedemo command
Command hwcachedemo is a no-model, no-GPU proof that fak's cache is hardware-aware: it shows the residency-tier ladder with each tier's physical character, which tiers can be shared ZERO-COPY, and — the headline — how the placement policy DEMOTES a hot KV prefix to CXL far memory under pressure instead of EVICTING it and paying a full re-prefill later.
 Command hwcachedemo is a no-model, no-GPU proof that fak's cache is hardware-aware: it shows the residency-tier ladder with each tier's physical character, which tiers can be shared ZERO-COPY, and — the headline — how the placement policy DEMOTES a hot KV prefix to CXL far memory under pressure instead of EVICTING it and paying a full re-prefill later.
kpiprobe command
Command kpiprobe prints the RSI loop's demo KPI — the deterministic LRU hit-rate (internal/rsiloop.HitRate) over a fixed reference trace — as a single `KPI=<float>` line the loop's worktree Measurer parses.
 Command kpiprobe prints the RSI loop's demo KPI — the deterministic LRU hit-rate (internal/rsiloop.HitRate) over a fixed reference trace — as a single `KPI=<float>` line the loop's worktree Measurer parses.
lensviz command
Command lensviz is a visual next-token debugger for fak's own in-kernel engine.
 Command lensviz is a visual next-token debugger for fak's own in-kernel engine.
livecodebench command
loadgen command
loadgen drives an OpenAI-compatible /v1/chat/completions endpoint at a sweep of concurrency levels and reports throughput.
 loadgen drives an OpenAI-compatible /v1/chat/completions endpoint at a sweep of concurrency levels and reports throughput.
longctxbench command
Command longctxbench renders the EXACT, contention-free work floor for the ULTRA-LONG-CONTEXT regime (per-agent context > 100k tokens) — the proof that the fused agent kernel's reread-elimination win holds (and grows) where it matters most, computed as closed-form arithmetic from the session shape and the model geometry.
 Command longctxbench renders the EXACT, contention-free work floor for the ULTRA-LONG-CONTEXT regime (per-agent context > 100k tokens) — the proof that the fused agent kernel's reread-elimination win holds (and grows) where it matters most, computed as closed-form arithmetic from the session shape and the model geometry.
loophealth command
Command loophealth is the checking layer for fleet's RSI self-improve loop (#382).
 Command loophealth is the checking layer for fleet's RSI self-improve loop (#382).
memqdemo command
Command memqdemo is a no-model, deterministic walkthrough of the memq memory- operation algebra: the substrate that lets an agent author its OWN memory strategy (render / clean / compact / dream / a novel one) instead of the kernel hardcoding a single compaction path.
 Command memqdemo is a no-model, deterministic walkthrough of the memq memory- operation algebra: the substrate that lets an agent author its OWN memory strategy (render / clean / compact / dream / a novel one) instead of the kernel hardcoding a single compaction path.
modelbench command
Command modelbench measures the in-kernel pure-Go forward pass latency so the fusion lane has a HONEST throughput baseline to set against the next-best ways to run the same model (HF transformers; see bench_hf.py for the witness side).
 Command modelbench measures the in-kernel pure-Go forward pass latency so the fusion lane has a HONEST throughput baseline to set against the next-best ways to run the same model (HF transformers; see bench_hf.py for the witness side).
modelprof command
Command modelprof is the in-kernel forward pass inspecting ITSELF: it runs the modular bottleneck profiler (internal/model/profile.go) over a real decode and a real prefill, plus an uninstrumented Session.Step decode measurement.
 Command modelprof is the in-kernel forward pass inspecting ITSELF: it runs the modular bottleneck profiler (internal/model/profile.go) over a real decode and a real prefill, plus an uninstrumented Session.Step decode measurement.
o1proof1b command
Command o1proof1b witnesses the ctxplan->kvmmu O(1) residency bridge (CLAIMS.md:141, issue #550) at a scale close to a real ~1.5B-parameter model, entirely on this machine: no network, no GPU, no HuggingFace export.
 Command o1proof1b witnesses the ctxplan->kvmmu O(1) residency bridge (CLAIMS.md:141, issue #550) at a scale close to a real ~1.5B-parameter model, entirely on this machine: no network, no GPU, no HuggingFace export.
paritybench command
Command paritybench assembles the CROSS-MODEL parity artifact: it ingests the live fak-agent A/B reports for a ladder of LOCAL models (produced by tools/run_local_model.sh via the OpenAI-compatible shim) plus the committed FRONTIER reference cards (hosted Claude Haiku/Sonnet, measured + graded on the same frozen task), scores every card on the three never-blended axes (capability / safety / cost), and emits the parity table.
 Command paritybench assembles the CROSS-MODEL parity artifact: it ingests the live fak-agent A/B reports for a ladder of LOCAL models (produced by tools/run_local_model.sh via the OpenAI-compatible shim) plus the committed FRONTIER reference cards (hosted Claude Haiku/Sonnet, measured + graded on the same frozen task), scores every card on the three never-blended axes (capability / safety / cost), and emits the parity table.
pipelinegen command
Command pipelinegen runs fak's NATIVE engine generating tokens across pipeline-parallel stages — the runnable form of the cross-device transport contract (internal/model/pipeline.go).
 Command pipelinegen runs fak's NATIVE engine generating tokens across pipeline-parallel stages — the runnable form of the cross-device transport contract (internal/model/pipeline.go).
poisonedmcpdemo command
Command poisonedmcpdemo is the runnable A/B for issue #573: it proves fak walls a tool-poisoning MCP server off the model by STRUCTURE, with no model/key/network.
 Command poisonedmcpdemo is the runnable A/B for issue #573: it proves fak walls a tool-poisoning MCP server off the model by STRUCTURE, with no model/key/network.
polymodelbench command
bench.go is the measured-numbers half of polymodelbench — the runnable artifact for issue #535 ("bench(polymodel): measured numbers for the poly-model lane").
 bench.go is the measured-numbers half of polymodelbench — the runnable artifact for issue #535 ("bench(polymodel): measured numbers for the poly-model lane").
prefixlint command
Command prefixlint is the §A3 prefix-stability devtool (GLM52-HOSTED-CACHE- COHERENCE): it reads a recorded conversation and reports the provider-cache consequence — how many prompt tokens are cacheable across the session, how many are re-billed, the specific turn where the prefix broke, and the recoverable uplift from fixing volatile-ahead-of-stable ordering.
 Command prefixlint is the §A3 prefix-stability devtool (GLM52-HOSTED-CACHE- COHERENCE): it reads a recorded conversation and reports the provider-cache consequence — how many prompt tokens are cacheable across the session, how many are re-billed, the specific turn where the prefix broke, and the recoverable uplift from fixing volatile-ahead-of-stable ordering.
q4kdiag command
Command q4kdiag runs the P1 Q4_K correctness diagnostic for a GGUF model.
 Command q4kdiag runs the P1 Q4_K correctness diagnostic for a GGUF model.
q8bench command
Command q8bench is an INDEPENDENT verifier for the int8-quantized in-kernel forward path (internal/model: Model.Quantize + Session.Quant).
 Command q8bench is an INDEPENDENT verifier for the int8-quantized in-kernel forward path (internal/model: Model.Quantize + Session.Quant).
q8kernel command
Command q8kernel is a self-contained kernel microbenchmark that isolates ONE question from all model/WSL/load overhead: in pure Go on this box, which GEMV kernel is fastest for the memory-bound batch-1 decode regime —
 Command q8kernel is a self-contained kernel microbenchmark that isolates ONE question from all model/WSL/load overhead: in pure Go on this box, which GEMV kernel is fastest for the memory-bound batch-1 decode regime —
qwen35check command
Command qwen35check loads a Qwen3.5 / Qwen3-Next hybrid HF snapshot with fak's own in-kernel forward pass and greedy-decodes a few tokens from a given prompt (token ids), printing the generated ids.
 Command qwen35check loads a Qwen3.5 / Qwen3-Next hybrid HF snapshot with fak's own in-kernel forward pass and greedy-decodes a few tokens from a given prompt (token ids), printing the generated ids.
radixbench command
Command radixbench benchmarks fak's KV-cache prefix reuse against SGLang's RadixAttention (arXiv:2312.07104 / NeurIPS 2024) on the metric SGLang's own paper headlines: CACHE HIT RATE — the fraction of prompt tokens served from cache instead of recomputed.
 Command radixbench benchmarks fak's KV-cache prefix reuse against SGLang's RadixAttention (arXiv:2312.07104 / NeurIPS 2024) on the metric SGLang's own paper headlines: CACHE HIT RATE — the fraction of prompt tokens served from cache instead of recomputed.
repoguard command
Command repoguard refuses a DESTRUCTIVE or out-of-tree write before it escapes the repo — the Go port of tools/repo_guard.py, run as a single compiled binary so the Claude Code PreToolUse hook fires WITHOUT spawning a Python interpreter on every tool call (DIRECTION.md: the request path stays interpreter-free).
 Command repoguard refuses a DESTRUCTIVE or out-of-tree write before it escapes the repo — the Go port of tools/repo_guard.py, run as a single compiled binary so the Claude Code PreToolUse hook fires WITHOUT spawning a Python interpreter on every tool call (DIRECTION.md: the request path stays interpreter-free).
rsicycle command
Command rsicycle drives ONE recursive-self-improvement keep-or-revert decision through fak's own non-forgeable keep-bit (internal/shipgate.Evaluate).
 Command rsicycle drives ONE recursive-self-improvement keep-or-revert decision through fak's own non-forgeable keep-bit (internal/shipgate.Evaluate).
rsiloop command
Command rsiloop is fak's TRUE recursive-self-improvement loop — the closed-loop companion to cmd/rsicycle's one-shot.
 Command rsiloop is fak's TRUE recursive-self-improvement loop — the closed-loop companion to cmd/rsicycle's one-shot.
sessionbench command
Command sessionbench measures the NET VALUE-ADD of the fused agent kernel on a realistic long, multi-agent session — the regime the whole fusion exists for, and the one a per-call / per-turn naive setup pays for dearly.
 Command sessionbench measures the NET VALUE-ADD of the fused agent kernel on a realistic long, multi-agent session — the regime the whole fusion exists for, and the one a per-call / per-turn naive setup pays for dearly.
simpledemo command
Command simpledemo is the friendliest way to chat with a local AI model.
 Command simpledemo is the friendliest way to chat with a local AI model.
terminalbench command
Command terminalbench runs a Terminal-Bench-shaped command-boundary smoke through fak adjudication.
 Command terminalbench runs a Terminal-Bench-shaped command-boundary smoke through fak adjudication.
timewolfdemo command
Command timewolfdemo is the fun, lowest-common-denominator AGENTIC demo: a one-tool agent asked "what time is it, Mr.
 Command timewolfdemo is the fun, lowest-common-denominator AGENTIC demo: a one-tool agent asked "what time is it, Mr.
tokendemo command
Command tokendemo is the self-contained demo of two CLEAR WINS the kernel's tool-call understanding delivers — counted call by call, each grounded in a LIVE kernel verdict (the kernel decides; this demo only counts).
 Command tokendemo is the self-contained demo of two CLEAR WINS the kernel's tool-call understanding delivers — counted call by call, each grounded in a LIVE kernel verdict (the kernel decides; this demo only counts).
toktdiag command
Command toktdiag reports whether fak can extract an embedded GGUF tokenizer.
 Command toktdiag reports whether fak can extract an embedded GGUF tokenizer.
toolsandboxbench command
Command toolsandboxbench runs a tau3/ToolSandbox-shaped policy-state adapter smoke through fak adjudication.
 Command toolsandboxbench runs a tau3/ToolSandbox-shaped policy-state adapter smoke through fak adjudication.
topobench command
Command topobench runs the FLEET-TOPOLOGY genome search (issue #541) — the orthogonal STRUCTURE-search axis to the policy-genome search (#503).
 Command topobench runs the FLEET-TOPOLOGY genome search (issue #541) — the orthogonal STRUCTURE-search axis to the policy-genome search (#503).
tpcheck command
Command tpcheck runs fak's NATIVE-engine TENSOR-parallel decomposition end to end over SIMULATED ranks (single box, in-memory, no GPU/NCCL/checkpoint) — the runnable form of the intra-layer sharding contract (internal/model/tensor_parallel.go).
 Command tpcheck runs fak's NATIVE-engine TENSOR-parallel decomposition end to end over SIMULATED ranks (single box, in-memory, no GPU/NCCL/checkpoint) — the runnable form of the intra-layer sharding contract (internal/model/tensor_parallel.go).
trychatdemo command
Command trychatdemo is the "try it" agentic chat: type a message and a tiny tool-using agent answers — but every tool call it makes is adjudicated by the REAL fak kernel first (the same internal/agentdemo path cmd/timewolfdemo and `fak preflight` use).
 Command trychatdemo is the "try it" agentic chat: type a message and a tiny tool-using agent answers — but every tool call it makes is adjudicated by the REAL fak kernel first (the same internal/agentdemo path cmd/timewolfdemo and `fak preflight` use).
turntaxdemo command
Command turntaxdemo is the live, on-box demo of how fak SAVES MODEL TURNS.
 Command turntaxdemo is the live, on-box demo of how fak SAVES MODEL TURNS.
unseedemo command
Command unseedemo is the live, on-box "Un-See It" demo (a.k.a.
 Command unseedemo is the live, on-box "Un-See It" demo (a.k.a.
webbench-convert command
Command webbench-convert converts WebVoyager tasks into fak's webbench format.
 Command webbench-convert converts WebVoyager tasks into fak's webbench format.
webbench-run command
Command webbench-run is a reproducible end-to-end webbench runner.
 Command webbench-run is a reproducible end-to-end webbench runner.
webbench-token-measure command
Command webbench-token-measure measures actual token usage from model API runs.
 Command webbench-token-measure measures actual token usage from model API runs.
wfmembench command
Command wfmembench is the workflow-memory benchmark for issue #434.
 Command wfmembench is the workflow-memory benchmark for issue #434.
experiments
qwen36/gdn-divergence-sensitivity command
Command gdn-divergence-sensitivity is the host-runnable, device-independent arm of the Qwen3.6-27B *correctness* parity blocker — the "token-3 drift" — described in experiments/qwen36/token3-drift-investigation-2026-06-28.md (§4 third bullet, §5 step 2).
 Command gdn-divergence-sensitivity is the host-runnable, device-independent arm of the Qwen3.6-27B *correctness* parity blocker — the "token-3 drift" — described in experiments/qwen36/token3-drift-investigation-2026-06-28.md (§4 third bullet, §5 step 2).
qwen36/gdn-recurrence-bench command
Command gdn-recurrence-bench is the host-runnable, device-independent arm of the "benchmark both" ask in issue #65 (Gated-DeltaNet recurrence — GPU kernel vs CPU-hybrid decision).
 Command gdn-recurrence-bench is the host-runnable, device-independent arm of the "benchmark both" ask in issue #65 (Gated-DeltaNet recurrence — GPU kernel vs CPU-hybrid decision).
qwen36/token3-divergence-probe command
Command token3-divergence-probe is the host-independent comparison + first-divergence finder for the Qwen3.6-27B token-3 correctness drift (token3-drift-investigation-2026-06-28.md §3c/§3d, §5 step 1).
 Command token3-divergence-probe is the host-independent comparison + first-divergence finder for the Qwen3.6-27B token-3 correctness drift (token3-drift-investigation-2026-06-28.md §3c/§3d, §5 step 1).
internal
a2achan
Package a2achan is the in-kernel agent-to-agent message channel: a generic, capability-floored, Ref-backed mailbox that lets one agent hand a value to ANOTHER agent.
 Package a2achan is the in-kernel agent-to-agent message channel: a generic, capability-floored, Ref-backed mailbox that lets one agent hand a value to ANOTHER agent.
abi
events.go — the closed core EventKind vocabulary (additive).
 events.go — the closed core EventKind vocabulary (additive).
ablate
Package ablate generalizes the two-arm `fak bench` (vdso_on/vdso_off) into an N-ARM feature sweep: replay ONE frozen tool-call trace through the kernel under a LIST of FeatureConfigs and emit one AblationReport binding every arm to the trace's single workload hash.
 Package ablate generalizes the two-arm `fak bench` (vdso_on/vdso_off) into an N-ARM feature sweep: replay ONE frozen tool-call trace through the kernel under a LIST of FeatureConfigs and emit one AblationReport binding every arm to the trace's single workload hash.
accountobs
Package accountobs observes the ACCOUNT side of a guarded session's economy: the rate-limit / usage headers the upstream provider relays on every response — the subscription "unified" windows Claude Pro/Max accounts are governed by (anthropic-ratelimit-unified-*: per-window utilization, status, reset) and the API-key token/request families (anthropic-ratelimit-<family>-limit/-remaining/ -reset, plus the x-ratelimit-* OpenAI-compatible spelling) — so `fak guard` can answer "how loaded is the account this session is spending?" the same way it already answers "how loaded is the node?" (internal/harnessres).
 Package accountobs observes the ACCOUNT side of a guarded session's economy: the rate-limit / usage headers the upstream provider relays on every response — the subscription "unified" windows Claude Pro/Max accounts are governed by (anthropic-ratelimit-unified-*: per-window utilization, status, reset) and the API-key token/request families (anthropic-ratelimit-<family>-limit/-remaining/ -reset, plus the x-ratelimit-* OpenAI-compatible spelling) — so `fak guard` can answer "how loaded is the account this session is spending?" the same way it already answers "how loaded is the node?" (internal/harnessres).
accountprobe
Package accountprobe reads the active account-probe ledger (probe_ledger.jsonl) that tools/account_probe.py writes — one JSON line per probe, append-ordered, with a closed status vocabulary (OK / AUTH / ACCESS / CREDIT / LIMIT / APIERR / TRANSPORT).
 Package accountprobe reads the active account-probe ledger (probe_ledger.jsonl) that tools/account_probe.py writes — one JSON line per probe, append-ordered, with a closed status vocabulary (OK / AUTH / ACCESS / CREDIT / LIMIT / APIERR / TRANSPORT).
accounts
Package accounts is the durable registry of Claude config HOMES — the CLAUDE_CONFIG_DIR "seats" a host switches between (~/.claude, ~/.claude-gem8-seat, …) — with one job no other surface does cleanly: resolve a seat name to the home that actually serves it, FOLLOWING a tombstone to its rehome target.
 Package accounts is the durable registry of Claude config HOMES — the CLAUDE_CONFIG_DIR "seats" a host switches between (~/.claude, ~/.claude-gem8-seat, …) — with one job no other surface does cleanly: resolve a seat name to the home that actually serves it, FOLLOWING a tombstone to its rehome target.
adjudicator
Package adjudicator is the in-process DOS reference monitor — the v0.1 realization of the Adjudicator seam.
 Package adjudicator is the in-process DOS reference monitor — the v0.1 realization of the Adjudicator seam.
advmodel
Package advmodel is the advisory adjudication model — the consumer of the harvest LabelRow corpus and the closing edge of the kernel's self-improvement loop (issue #580).
 Package advmodel is the advisory adjudication model — the consumer of the harvest LabelRow corpus and the closing edge of the kernel's self-improvement loop (issue #580).
affectedtests
Package affectedtests is the pure core of the `fak affected` fast test gate: given the package import graph and the set of CHANGED packages, it computes the exact set of packages whose test outcome could change -- so a developer runs `go test` on only those, turning the full ~minutes `go test ./...` into a seconds-long pre-commit gate WITHOUT dropping coverage on what they changed.
 Package affectedtests is the pure core of the `fak affected` fast test gate: given the package import graph and the set of CHANGED packages, it computes the exact set of packages whose test outcome could change -- so a developer runs `go test` on only those, turning the full ~minutes `go test ./...` into a seconds-long pre-commit gate WITHOUT dropping coverage on what they changed.
agent
Package agent is the HOST-SIDE agentic loop and the wire servers that expose it.
 Package agent is the HOST-SIDE agentic loop and the wire servers that expose it.
agentdemo
Package agentdemo is the shared spine for fak's agentic "try-it" demos: a deterministic, no-key, tool-using agent loop that drives the REAL kernel one call at a time.
 Package agentdemo is the shared spine for fak's agentic "try-it" demos: a deterministic, no-key, tool-using agent loop that drives the REAL kernel one call at a time.
agentdojo
Package agentdojo replaces the STATIC poison.json fixture with a DYNAMIC, adaptive attack battery scored by Attack Success Rate (ASR) — the AgentDojo (Debenedetti et al., 2024) evaluation discipline.
 Package agentdojo replaces the STATIC poison.json fixture with a DYNAMIC, adaptive attack battery scored by Attack Success Rate (ASR) — the AgentDojo (Debenedetti et al., 2024) evaluation discipline.
agenticbench
Package agenticbench folds the #868 agentic benchmark artifacts into one parent gate.
 Package agenticbench folds the #868 agentic benchmark artifacts into one parent gate.
agenttest
Package agenttest is the public test harness for fak agent workflows (#238, D-008): deterministic fixtures, a tool-call assertion library, mock tool responses, and reproduce-from-transcript replay.
 Package agenttest is the public test harness for fak agent workflows (#238, D-008): deterministic fixtures, a tool-call assertion library, mock tool responses, and reproduce-from-transcript replay.
agenttopo
Package agenttopo declares agent communication topology over comm.Group.
 Package agenttopo declares agent communication topology over comm.Group.
ailuminate
Package ailuminate encodes the scoping + go/no-go contract for entering MLCommons AILuminate (v1.1) as a model+guardrail "AI system" SUT.
 Package ailuminate encodes the scoping + go/no-go contract for entering MLCommons AILuminate (v1.1) as a model+guardrail "AI system" SUT.
amdgpu
Package amdgpu probes AMD GPU facts on Windows through PowerShell.
 Package amdgpu probes AMD GPU facts on Windows through PowerShell.
answershape
Package answershape is a deterministic, dependency-free guard over the SHAPE of a piece of text — how repetitive (degenerate) it is and how long (verbose) it is — checked against caller-chosen thresholds.
 Package answershape is a deterministic, dependency-free guard over the SHAPE of a piece of text — how repetitive (degenerate) it is and how long (verbose) it is — checked against caller-chosen thresholds.
apihostprobe
Package apihostprobe probes OpenAI-compatible API hosts and folds readiness and acceptance reports for the API-host bridge surface.
 Package apihostprobe probes OpenAI-compatible API hosts and folds readiness and acceptance reports for the API-host bridge surface.
appversion
Package appversion resolves the fleet/FAK application version from the single repo-level VERSION marker, with build-time and environment fallbacks.
 Package appversion resolves the fleet/FAK application version from the single repo-level VERSION marker, with build-time and environment fallbacks.
architest
Package architest is the kernel's machine-checked architecture contract.
 Package architest is the kernel's machine-checked architecture contract.
attemptbudget
Package attemptbudget is a pure fold over one issue's attempt history: given a bounded budget and the recorded attempts (each carrying the failure class it ended in), it decides whether the issue is still dispatchable, COOLING_DOWN under a failure-class-aware backoff window, or HELD for human triage -- so a repeatedly failing issue stops burning workers once it crosses the budget, instead of being re-offered forever (#1777), and so different kinds of failure cool down at different rates instead of all sharing one window (#1778).
 Package attemptbudget is a pure fold over one issue's attempt history: given a bounded budget and the recorded attempts (each carrying the failure class it ended in), it decides whether the issue is still dispatchable, COOLING_DOWN under a failure-class-aware backoff window, or HELD for human triage -- so a repeatedly failing issue stops burning workers once it crosses the budget, instead of being re-offered forever (#1777), and so different kinds of failure cool down at different rates instead of all sharing one window (#1778).
auditpane
Package auditpane is the one rollup over the tree's many tools/*_audit.py auditors.
 Package auditpane is the one rollup over the tree's many tools/*_audit.py auditors.
auditreason
Package auditreason holds closed vocabularies for audit-facing failure surfaces: commit-audit verification failures, and non-guard tool failures such as hangs, timeouts, shell mismatches, and partial applies.
 Package auditreason holds closed vocabularies for audit-facing failure surfaces: commit-audit verification failures, and non-guard tool failures such as hangs, timeouts, shell mismatches, and partial applies.
auditusage
Package auditusage folds the durable sinks fak accumulates across a session/fleet lifetime into one cross-session usage rollup for `fak audit usage` (#1612, child C of epic #1601):
 Package auditusage folds the durable sinks fak accumulates across a session/fleet lifetime into one cross-session usage rollup for `fak audit usage` (#1612, child C of epic #1601):
bench
Package bench is the A/B ablation runner behind `fak bench`.
 Package bench is the A/B ablation runner behind `fak bench`.
benchcatalog
Package benchcatalog is the single, in-binary source of truth for "what benchmarks does fak have, what does each measure, and how do I run it." It exists because the answer used to be scattered across 18 separate cmd/*bench* mains plus five `fak` verbs (bench, turntax, routebench, webbench, swebench), each with its own bespoke flag vocabulary and no shared index.
 Package benchcatalog is the single, in-binary source of truth for "what benchmarks does fak have, what does each measure, and how do I run it." It exists because the answer used to be scattered across 18 separate cmd/*bench* mains plus five `fak` verbs (bench, turntax, routebench, webbench, swebench), each with its own bespoke flag vocabulary and no shared index.
benchcli
Package benchcli holds the small, identical helpers the benchmark-CLI mains (cmd/*bench and the demo/cert commands beside them) had each copy-pasted into their own file.
 Package benchcli holds the small, identical helpers the benchmark-CLI mains (cmd/*bench and the demo/cert commands beside them) had each copy-pasted into their own file.
benchids
Package benchids generates a deterministic stream of synthetic token IDs for the benchmark command mains.
 Package benchids generates a deterministic stream of synthetic token IDs for the benchmark command mains.
benchlineagegate
Package benchlineagegate is the durable enforcement gate for issue #9: every benchmark emitter must stamp the four lineage axes (version / utc / git_commit / machine) onto the report artifact it writes, so a result is always traceable to the exact build that produced it.
 Package benchlineagegate is the durable enforcement gate for issue #9: every benchmark emitter must stamp the four lineage axes (version / utc / git_commit / machine) onto the report artifact it writes, so a result is always traceable to the exact build that produced it.
benchloop
Package benchloop folds fak's benchmark surfaces into one read-only control loop.
 Package benchloop folds fak's benchmark surfaces into one read-only control loop.
benchpost
Package benchpost posts fak BENCH-CHANNEL rollups — latest benchmark runs, the "what to run next" plan, and tok/s regressions — to a Slack bench channel.
 Package benchpost posts fak BENCH-CHANNEL rollups — latest benchmark runs, the "what to run next" plan, and tok/s regressions — to a Slack bench channel.
benchruns
Package benchruns reads benchmark catalog entries and resolves run details from the committed experiment artifacts.
 Package benchruns reads benchmark catalog entries and resolves run details from the committed experiment artifacts.
benchscore
Package benchscore scans benchmark result artifacts and folds model-level score summaries plus validation issues.
 Package benchscore scans benchmark result artifacts and folds model-level score summaries plus validation issues.
bgloop
Package bgloop is fak's IN-KERNEL BACKGROUND-LOOP RUNTIME — the supervisor that keeps recurring work progressing while the kernel (`fak serve`) is up, and makes each loop observable.
 Package bgloop is fak's IN-KERNEL BACKGROUND-LOOP RUNTIME — the supervisor that keeps recurring work progressing while the kernel (`fak serve`) is up, and makes each loop observable.
binstamp
Package binstamp answers one question durably: "is the fak binary I am running built from the commit that is currently on the trunk, or is it stale?"
 Package binstamp answers one question durably: "is the fak binary I am running built from the commit that is currently on the trunk, or is it stale?"
blob
Package blob is the v0.1 default backend behind every abi.Ref: a content-addressed (sha256) in-memory blob store.
 Package blob is the v0.1 default backend behind every abi.Ref: a content-addressed (sha256) in-memory blob store.
blobfs
Package blobfs is a DURABLE, on-disk content-addressed store — the persistent sibling of internal/blob (the in-memory v0.1 default behind every abi.Ref).
 Package blobfs is a DURABLE, on-disk content-addressed store — the persistent sibling of internal/blob (the in-memory v0.1 default behind every abi.Ref).
blobhttp
Package blobhttp is a content-addressed blob store backed by a REMOTE HTTP object endpoint — the "disaggregated / cloud" sibling of internal/blob (in-memory) and internal/blobfs (local disk).
 Package blobhttp is a content-addressed blob store backed by a REMOTE HTTP object endpoint — the "disaggregated / cloud" sibling of internal/blob (in-memory) and internal/blobfs (local disk).
blockerpost
Package blockerpost posts BLOCKERS — the things that stop forward progress — to a single Slack "blockers" channel, so the fleet has one central place where an ongoing impediment is recorded and a human-needed one is surfaced.
 Package blockerpost posts BLOCKERS — the things that stop forward progress — to a single Slack "blockers" channel, so the fleet has one central place where an ongoing impediment is recorded and a human-needed one is surfaced.
boundarylint
Package boundarylint is a small, extensible policy engine for "boundary tells": source patterns where the code makes a claim about the outside world (the OS, the network, the clock, a peer process) without the check that would make the claim true.
 Package boundarylint is a small, extensible policy engine for "boundary tells": source patterns where the code makes a claim about the outside world (the OS, the network, the clock, a peer process) without the check that would make the claim true.
branchrole
Package branchrole reads fak's branch-role contract from dos.toml.
 Package branchrole reads fak's branch-role contract from dos.toml.
browseraction
Package browseraction normalizes browser/computer-use action traces into fak tool-call mediation reports.
 Package browseraction normalizes browser/computer-use action traces into fak tool-call mediation reports.
cachemeta
Package cachemeta defines the metadata contract for first-class cache entries.
 Package cachemeta defines the metadata contract for first-class cache entries.
cacheobs
Package cacheobs is the process-global observability tap for in-kernel KV-prefix reuse — the LIVE measurement of the "frozen-trajectory cache cliff" (docs/explainers/frozen-trajectory-cache-cliff.md).
 Package cacheobs is the process-global observability tap for in-kernel KV-prefix reuse — the LIVE measurement of the "frozen-trajectory cache cliff" (docs/explainers/frozen-trajectory-cache-cliff.md).
cachevalueledger
Package cachevalueledger provides a durable, append-only ledger for cache-value observations from fak sessions (run/guard/serve).
 Package cachevalueledger provides a durable, append-only ledger for cache-value observations from fak sessions (run/guard/serve).
cachevaluepost
Package cachevaluepost posts the cache-effectiveness P&L roll-up — fak's WITNESSED kernel cache-value trend — to a single Slack "cache-value" channel, so the fleet has one durable place where "is fak's cache method paying off, and is it trending up or down?" gets an honest, dogfooded answer on a cadence.
 Package cachevaluepost posts the cache-effectiveness P&L roll-up — fak's WITNESSED kernel cache-value trend — to a single Slack "cache-value" channel, so the fleet has one durable place where "is fak's cache method paying off, and is it trending up or down?" gets an honest, dogfooded answer on a cadence.
cachevaluereport
Package cachevaluereport rolls up the durable kernel cache-value ledger (internal/cachevalueledger, docs/nightrun/cache-value.jsonl) into a TREND over time — the by-week / by-session_type view that cachevalueledger.ScoreLedger deliberately does not produce (it collapses every row into a single all-time aggregate gate number).
 Package cachevaluereport rolls up the durable kernel cache-value ledger (internal/cachevalueledger, docs/nightrun/cache-value.jsonl) into a TREND over time — the by-week / by-session_type view that cachevalueledger.ScoreLedger deliberately does not produce (it collapses every row into a single all-time aggregate gate number).
cachewitness
Package cachewitness reads a live fak gateway's /metrics surface and folds the in-kernel KV-prefix cache family into ONE provenance-labeled evidence record: the cache VALUE a fak-served model (e.g.
 Package cachewitness reads a live fak gateway's /metrics surface and folds the in-kernel KV-prefix cache family into ONE provenance-labeled evidence record: the cache VALUE a fak-served model (e.g.
cadencereport
Package cadencereport is the consolidated regular-cadence report -- one fold over the four cadence dimensions an operator tracks: scores, maturity, work-done, and releases.
 Package cadencereport is the consolidated regular-cadence report -- one fold over the four cadence dimensions an operator tracks: scores, maturity, work-done, and releases.
callavoid
Package callavoid is the economics and effective-turn accounting for NOT making a local tool call — the principle that the cheapest, fastest, most reliable tool call is the one the kernel never has to dispatch.
 Package callavoid is the economics and effective-turn accounting for NOT making a local tool call — the principle that the cheapest, fastest, most reliable tool call is the one the kernel never has to dispatch.
canon
Package canon is the de-obfuscating canonicalizer + lexical threat detector, factored out of internal/normgate so it is ONE primitive, tested ONCE, and reusable by every gate that needs to scan bytes for a hidden secret or injection on a normalized view — not just the write-time admitter.
 Package canon is the de-obfuscating canonicalizer + lexical threat detector, factored out of internal/normgate so it is ONE primitive, tested ONCE, and reusable by every gate that needs to scan bytes for a hidden secret or injection on a normalized view — not just the write-time admitter.
capindex
Package capindex defines protocol-blind capability cards and lazy resolvers for skills, MCP tools, A2A agents, and other attachable affordances.
 Package capindex defines protocol-blind capability cards and lazy resolvers for skills, MCP tools, A2A agents, and other attachable affordances.
capindexgw
Package capindexgw holds the gateway-backed capindex Resolvers (MCP tools, A2A methods).
 Package capindexgw holds the gateway-backed capindex Resolvers (MCP tools, A2A methods).
cdb
Package cdb is the context debugger: it attaches to a FINISHED agent session as if to a core dump and answers questions by demand-paging only the working set the question touches — never by replaying the whole address space.
 Package cdb is the context debugger: it attaches to a FINISHED agent session as if to a core dump and answers questions by demand-paging only the working set the question touches — never by replaying the whole address space.
chatrelay
Package chatrelay bridges ONE Slack channel to an OpenAI-compatible chat endpoint: it reads new human messages from the channel (conversations.history), forwards each to a served /v1/chat/completions model, and posts the reply back in-thread (chat.postMessage).
 Package chatrelay bridges ONE Slack channel to an OpenAI-compatible chat endpoint: it reads new human messages from the channel (conversations.history), forwards each to a served /v1/chat/completions model, and posts the reply back in-thread (chat.postMessage).
claimcheck
Package claimcheck grades an efficiency/performance claim against the six questions of the net-true-value standard (docs/standards/net-true-value.md) and returns one of three verdicts: net-true / strawman / not-yet.
 Package claimcheck grades an efficiency/performance claim against the six questions of the net-true-value standard (docs/standards/net-true-value.md) and returns one of three verdicts: net-true / strawman / not-yet.
closebatch
Package closebatch groups witnessed-closeable issues into dry-run batches before any live close mutates GitHub.
 Package closebatch groups witnessed-closeable issues into dry-run batches before any live close mutates GitHub.
closurerate
Package closurerate folds a ledger of issue-close records into three counters that separate THROUGHPUT (how much got closed) from HONESTY (how much of that close activity is backed by a witness).
 Package closurerate folds a ledger of issue-close records into three counters that separate THROUGHPUT (how much got closed) from HONESTY (how much of that close activity is backed by a witness).
cmdutil
Package cmdutil holds small, behavior-identical helpers that were copy-pasted across the cmd/* demo and bench mains (argmax over logits, the LCG token-id generator, duration medians, the HTTP JSON writer).
 Package cmdutil holds small, behavior-identical helpers that were copy-pasted across the cmd/* demo and bench mains (argmax over logits, the LCG token-id generator, duration medians, the HTTP JSON writer).
codelint
Package codelint is language-server packs: lint agent-written code (Go/Python/CUDA/JSON) off the hot path.
 Package codelint is language-server packs: lint agent-written code (Go/Python/CUDA/JSON) off the hot path.
codexmcphealth
Package codexmcphealth diagnoses fak's Codex MCP transport/server health and reports the next recovery step instead of retrying a dead connection.
 Package codexmcphealth diagnoses fak's Codex MCP transport/server health and reports the next recovery step instead of retrying a dead connection.
codexmemory
Package codexmemory is a READ-ONLY diagnostic over an OpenAI Codex home (default ~/.codex).
 Package codexmemory is a READ-ONLY diagnostic over an OpenAI Codex home (default ~/.codex).
cohort
Package cohort is a fail-closed cohort shrink and agreement leaf over comm.Group.
 Package cohort is a fail-closed cohort shrink and agreement leaf over comm.Group.
comm
Package comm is the first-class agent communicator: a deterministic, adjudicated group descriptor (rank/size/split + spawn membership) over the dos-arbitrate lane partition.
 Package comm is the first-class agent communicator: a deterministic, adjudicated group descriptor (rank/size/split + spawn membership) over the dos-arbitrate lane partition.
commitintent
Package commitintent defines the durable, pure queue record that sits before an effectful fak commit drain.
 Package commitintent defines the durable, pure queue record that sits before an effectful fak commit drain.
commitissuelink
Package commitissuelink is a closed, pure checker for one narrow drift: a commit that reads as real, tracked work (it carries this repo's own ship-stamp trailer, e.g.
 Package commitissuelink is a closed, pure checker for one narrow drift: a commit that reads as real, tracked work (it carries this repo's own ship-stamp trailer, e.g.
commitlane
Package commitlane reports the read-only state of the shared fak commit lane.
 Package commitlane reports the read-only state of the shared fak commit lane.
commitrollup
Package commitrollup plans compatible commit-intent batches without touching git.
 Package commitrollup plans compatible commit-intent batches without touching git.
commitsubject
Package commitsubject reports witness-gradeable commit subject coverage.
 Package commitsubject reports witness-gradeable commit subject coverage.
compactcohere
Package compactcohere is the coherence policy for the TWO context managers that stack, blind to each other, on the flagship `fak guard -- claude` boundary:
 Package compactcohere is the coherence policy for the TWO context managers that stack, blind to each other, on the flagship `fak guard -- claude` boundary:
completiondist
Package completiondist folds historical issue-closure durations into a duration DISTRIBUTION the capacity model can consume, instead of the single assumed median that internal/fleetcap otherwise takes on faith.
 Package completiondist folds historical issue-closure durations into a duration DISTRIBUTION the capacity model can consume, instead of the single assumed median that internal/fleetcap otherwise takes on faith.
compute
Package compute is the hardware-abstraction seam (HAL) for the in-kernel forward pass.
 Package compute is the hardware-abstraction seam (HAL) for the in-kernel forward pass.
conceptusage
Package conceptusage scores the OVERALL dogfooding of fak's own concepts while fak itself is being developed by an agent fleet — the question "when we build fak, how much does that development route through fak's own primitives, versus generic agentic dev (raw git, unverified self-reports, no lane arbitration)?"
 Package conceptusage scores the OVERALL dogfooding of fak's own concepts while fak itself is being developed by an agent fleet — the question "when we build fak, how much does that development route through fak's own primitives, versus generic agentic dev (raw git, unverified self-reports, no lane arbitration)?"
conflationscore
Package conflationscore is the Go port of tools/conflation_scorecard.py -- the anti-conflation / provenance-honesty stick.
 Package conflationscore is the Go port of tools/conflation_scorecard.py -- the anti-conflation / provenance-honesty stick.
contextq
Package contextq is the on-demand context materializer over CDB images.
 Package contextq is the on-demand context materializer over CDB images.
corelockaudit
Package corelockaudit is a read-only fold that maps changed paths to candidate core-lock classes and reports, per class, the witness that would clear it.
 Package corelockaudit is a read-only fold that maps changed paths to candidate core-lock classes and reports, per class, the witness that would clear it.
corelocks
Package corelocks parses and validates a DECLARATIVE core-lock taxonomy: lock classes and reason tokens carried as DATA, not a hand-coded table.
 Package corelocks parses and validates a DECLARATIVE core-lock taxonomy: lock classes and reason tokens carried as DATA, not a hand-coded table.
covmatrix
Package covmatrix is the C1 keystone of the combinatorial-growth epic (#1079/#1080): it derives fak's model × backend support grid from the kernel's own structural facts and folds the result into the shared scorecard control-pane as a growth_debt integer.
 Package covmatrix is the C1 keystone of the combinatorial-growth epic (#1079/#1080): it derives fak's model × backend support grid from the kernel's own structural facts and folds the result into the shared scorecard control-pane as a growth_debt integer.
ctxmmu
Package ctxmmu — the disposition-minting gate (issue #1598).
 Package ctxmmu — the disposition-minting gate (issue #1598).
ctxplan
Package ctxplan is the context PLANNER: it treats the current turn's context as an O(1) materialized VIEW over the full, lossless history store, and re-plans that view each turn instead of letting the linear transcript grow without bound (or compacting it lossily).
 Package ctxplan is the context PLANNER: it treats the current turn's context as an O(1) materialized VIEW over the full, lossless history store, and re-plans that view each turn instead of letting the linear transcript grow without bound (or compacting it lossily).
ctxresidency
Package ctxresidency is the context-residency query (issue #521): a first-class, witnessable READ over the span ledger that composes the three layers that already maintain the context's coherence state — kvmmu (the KV-level span ledger Admit/Evict maintains), ctxmmu (the byte-level quarantine/clearance ledger), and cachemeta (the residency tiers + the dependent-entry graph the eviction blast radius is read from).
 Package ctxresidency is the context-residency query (issue #521): a first-class, witnessable READ over the span ledger that composes the three layers that already maintain the context's coherence state — kvmmu (the KV-level span ledger Admit/Evict maintains), ctxmmu (the byte-level quarantine/clearance ledger), and cachemeta (the residency tiers + the dependent-entry graph the eviction blast radius is read from).
defaultvaluescore
Package defaultvaluescore is the default-value scorecard -- the RECURRING GUARD for epic #1089's finding: fak value features that ship NOT-fully-enabled (compaction was illegible, amplification dead-on-proxy, vcache modeled, kvmmu unwired).
 Package defaultvaluescore is the default-value scorecard -- the RECURRING GUARD for epic #1089's finding: fak value features that ship NOT-fully-enabled (compaction was illegible, amplification dead-on-proxy, vcache modeled, kvmmu unwired).
deletioncert
Package deletioncert mints and verifies a DeletionCertificate: a single, portable, re-checkable artifact that binds a bit-exact KV eviction to the tamper-evident audit journal that recorded it.
 Package deletioncert mints and verifies a DeletionCertificate: a single, portable, re-checkable artifact that binds a bit-exact KV eviction to the tamper-evident audit journal that recorded it.
demoui
Package demoui holds the small, cross-cutting helpers the on-box demos (cmd/demorace, cmd/ctxdemo, cmd/simpledemo, ...) share, so they all report the SAME thing about the machine and never freeze on a long blocking phase.
 Package demoui holds the small, cross-cutting helpers the on-box demos (cmd/demorace, cmd/ctxdemo, cmd/simpledemo, ...) share, so they all report the SAME thing about the machine and never freeze on a long blocking phase.
demoutil
Package demoutil holds the small server-sent-events scaffolding shared by the browser-facing demo binaries (cmd/ctxdemo, cmd/demorace): both stream the same JSON-object events to their viewer over an identical text/event-stream writer.
 Package demoutil holds the small server-sent-events scaffolding shared by the browser-facing demo binaries (cmd/ctxdemo, cmd/demorace): both stream the same JSON-object events to their viewer over an identical text/event-stream writer.
devexmeter
Package devexmeter is dev-ex friction meter and RSI close gate.
 Package devexmeter is dev-ex friction meter and RSI close gate.
devindex
Package devindex is queryable self-index over fak's own dev facts (lanes/leaves + doc map): query, don't survey.
 Package devindex is queryable self-index over fak's own dev facts (lanes/leaves + doc map): query, don't survey.
dispatchaudit
Package dispatchaudit classifies dispatch-fleet worker outcomes and rolls up the wasted-spawn / wasted-wall-clock that `fak dispatch status` (backend health) does not surface.
 Package dispatchaudit classifies dispatch-fleet worker outcomes and rolls up the wasted-spawn / wasted-wall-clock that `fak dispatch status` (backend health) does not surface.
dispatchauto
Package dispatchauto is auto-size a multi-account dispatch wave from live ceilings; pure fold, no I/O.
 Package dispatchauto is auto-size a multi-account dispatch wave from live ceilings; pure fold, no I/O.
dispatchorder
Package dispatchorder is the deterministic decision the fak issue-dispatch loop is missing: given a set of candidate work units, which one should a worker pick FIRST, and which ones are stale duplicates that should not run at all? It is the computable answer to the operator question "25 tasks were spawned for the same thing — only the freshest should run, and the rest should be superseded, not re-attempted."
 Package dispatchorder is the deterministic decision the fak issue-dispatch loop is missing: given a set of candidate work units, which one should a worker pick FIRST, and which ones are stale duplicates that should not run at all? It is the computable answer to the operator question "25 tasks were spawned for the same thing — only the freshest should run, and the rest should be superseded, not re-attempted."
dispatchpost
Package dispatchpost posts the RESULT of a background code-dispatch run — the thing `fak loop run -- <cmd>` produces — to a Slack "dispatch" channel.
 Package dispatchpost posts the RESULT of a background code-dispatch run — the thing `fak loop run -- <cmd>` produces — to a Slack "dispatch" channel.
dispatchstatus
Package dispatchstatus ports the lease-classification core of tools/dispatch_status.py (#1406): given the refs/fak/locks lease records and the current dispatch backlog, it classifies each lease LIVE vs EXPIRED, computes its age / TTL / expiry, extracts its lane, and — for live leases — whether its file tree overlaps a currently-routed issue's lane tree (so it BLOCKS a candidate) or is merely residue.
 Package dispatchstatus ports the lease-classification core of tools/dispatch_status.py (#1406): given the refs/fak/locks lease records and the current dispatch backlog, it classifies each lease LIVE vs EXPIRED, computes its age / TTL / expiry, extracts its lane, and — for live leases — whether its file tree overlaps a currently-routed issue's lane tree (so it BLOCKS a candidate) or is merely residue.
dispatchsweep
Package dispatchsweep is the queue-drain loop core: find next issue -> spawn one worker -> repeat, until a tick refuses or the best-effort agent ceiling is hit.
 Package dispatchsweep is the queue-drain loop core: find next issue -> spawn one worker -> repeat, until a tick refuses or the best-effort agent ceiling is hit.
dispatchtick
Package dispatchtick holds the pure contract for one issue-resolution dispatch tick.
 Package dispatchtick holds the pure contract for one issue-resolution dispatch tick.
docfreshrsi
Package docfreshrsi is the RSI rung of the durable docs-freshness loop (epic #1278, issue #1284): it auto-applies the MECHANICAL doc-defect fixes — a missing orientation signpost, a missing `Read next` outbound link, a stale version pin — and keeps a candidate ONLY through internal/shipgate's non-forgeable keep-bit, on a witness the loop DERIVES itself.
 Package docfreshrsi is the RSI rung of the durable docs-freshness loop (epic #1278, issue #1284): it auto-applies the MECHANICAL doc-defect fixes — a missing orientation signpost, a missing `Read next` outbound link, a stale version pin — and keeps a candidate ONLY through internal/shipgate's non-forgeable keep-bit, on a witness the loop DERIVES itself.
dogfoodissues
Package dogfoodissues is the backlog bridge from the recent-feature dogfood scorecard to a stable, deduplicated GitHub issue per ACTION item.
 Package dogfoodissues is the backlog bridge from the recent-feature dogfood scorecard to a stable, deduplicated GitHub issue per ACTION item.
dogfoodscore
Package dogfoodscore scores the launched-session dogfooding loop — the loop a human starts when they run a Claude-Code-style agent inside this repo under fak's own guard + Stop-hook stack and watch it work.
 Package dogfoodscore scores the launched-session dogfooding loop — the loop a human starts when they run a Claude-Code-style agent inside this repo under fak's own guard + Stop-hook stack and watch it work.
dojo
Package dojo is fak's prediction-vs-reality gym: the closed loop that turns a token-saving THEORY ("this lever saves X") into a scored, trended verdict against billed reality.
 Package dojo is fak's prediction-vs-reality gym: the closed loop that turns a token-saving THEORY ("this lever saves X") into a scored, trended verdict against billed reality.
dojocal
Package dojocal is the dojo-RSI loop's PURE proposer + self-scoring rung — the genuinely-safe autonomous slice that MUTATES NOTHING (Phase 1 of docs/fak/dojo-rsi-loop.md, issue #1023).
 Package dojocal is the dojo-RSI loop's PURE proposer + self-scoring rung — the genuinely-safe autonomous slice that MUTATES NOTHING (Phase 1 of docs/fak/dojo-rsi-loop.md, issue #1023).
dojopost
Package dojopost posts fak DOJO calibration rollups — the latest prediction-vs-reality run and the across-tick calibration trend — to a Slack dojo channel.
 Package dojopost posts fak DOJO calibration rollups — the latest prediction-vs-reality run and the across-tick calibration trend — to a Slack dojo channel.
dormancy
Package dormancy is the dormancy clock + horizon bucketer: the one place that turns "how long was this agent/session/lease off?" into a first-class, measured quantity.
 Package dormancy is the dormancy clock + horizon bucketer: the one place that turns "how long was this agent/session/lease off?" into a first-class, measured quantity.
dropin
Package dropin is the canonical drop-in wire resolution + known-agent registry shared by fak guard and the entry-point demo.
 Package dropin is the canonical drop-in wire resolution + known-agent registry shared by fak guard and the entry-point demo.
edittx
Package edittx applies a batch of full-file edits as one working-tree transaction: every target is snapshotted first, checks run against the applied set, and any failure restores the touched files before returning.
 Package edittx applies a batch of full-file edits as one working-tree transaction: every target is snapshotted first, checks run against the applied set, and any failure restores the touched files before returning.
egressfloor
Package egressfloor is the structural network-egress floor: a pure classifier that names a tool call reaching a blocked NETWORK DESTINATION — above all the cloud-instance METADATA endpoint (169.254.169.254 and its peers), whose only purpose from inside a VM is to hand out the box's cloud IAM credentials.
 Package egressfloor is the structural network-egress floor: a pure classifier that names a tool call reaching a blocked NETWORK DESTINATION — above all the cloud-instance METADATA endpoint (169.254.169.254 and its peers), whose only purpose from inside a VM is to hand out the box's cloud IAM credentials.
engine
Package engine is the inference-engine seam (the EngineDriver).
 Package engine is the inference-engine seam (the EngineDriver).
enginecache
Package enginecache binds cachemeta's remote invalidation directives to documented serving-engine control endpoints.
 Package enginecache binds cachemeta's remote invalidation directives to documented serving-engine control endpoints.
epicprogress
Package epicprogress resolves how complete a GitHub epic is from its children, via a provenance-honest priority chain.
 Package epicprogress resolves how complete a GitHub epic is from its children, via a provenance-honest priority chain.
epochbridge
Package epochbridge is the explicit converter between the two epoch/generation lineages of the ONE agent lineage family (epic #912, child #914): the served session's continuation lineage (internal/session — continuationID + State.Generation, a parent that on budget exhaustion re-continues into a fresh-budget child) and the kernel's speculation lineage (internal/abi — SpeculationContext{Epoch,ParentEpoch} + Outcome, a parent that spawns provisional children that commit or get discarded).
 Package epochbridge is the explicit converter between the two epoch/generation lineages of the ONE agent lineage family (epic #912, child #914): the served session's continuation lineage (internal/session — continuationID + State.Generation, a parent that on budget exhaustion re-continues into a fresh-budget child) and the kernel's speculation lineage (internal/abi — SpeculationContext{Epoch,ParentEpoch} + Outcome, a parent that spawns provisional children that commit or get discarded).
execrollup
Package execrollup is the executive activity roll-up: one read-only fold that turns the firehose of agentic-fleet signals into a single signal-dense page a human can read in a glance — the answer to "how does one person keep up with a city of agents".
 Package execrollup is the executive activity roll-up: one read-only fold that turns the firehose of agentic-fleet signals into a single signal-dense page a human can read in a glance — the answer to "how does one person keep up with a city of agents".
experiments
Package experiments reads experiment ledgers and finds model/backend overlap across the repo's benchmark and research registries.
 Package experiments reads experiment ledgers and finds model/backend overlap across the repo's benchmark and research registries.
fakrpc
Package fakrpc is the pure, transport-neutral core of disaggregated agent-RPC over a text-only control bridge (#930): the request envelope a caller spools to a resident worker, and the FAKRES nonce/sha frame the worker wraps its result in.
 Package fakrpc is the pure, transport-neutral core of disaggregated agent-RPC over a text-only control bridge (#930): the request envelope a caller spools to a resident worker, and the FAKRES nonce/sha frame the worker wraps its result in.
fleet
Package fleet is the public, transport-agnostic core for operating a fleet of boxes — GPU servers, worker nodes — an operator drives over the private Slack control-bridge.
 Package fleet is the public, transport-agnostic core for operating a fleet of boxes — GPU servers, worker nodes — an operator drives over the private Slack control-bridge.
fleetaccounts
Package fleetaccounts is the Go port of the READ-ONLY roster/resolve/probe fold from tools/fleet_accounts.py — the single source of truth for "what is an account, and is it offered?" across both product families (Claude Code and opencode).
 Package fleetaccounts is the Go port of the READ-ONLY roster/resolve/probe fold from tools/fleet_accounts.py — the single source of truth for "what is an account, and is it offered?" across both product families (Claude Code and opencode).
fleetcap
Package fleetcap is a Little's-law capacity calculator: it translates a target issue-resolution rate and a median agent-session duration into the number of concurrent workers that must be in flight to sustain that rate.
 Package fleetcap is a Little's-law capacity calculator: it translates a target issue-resolution rate and a median agent-session duration into the number of concurrent workers that must be in flight to sustain that rate.
fleetcompare
fleetfreeze
Package fleetfreeze is the operator freeze gate for the parallel-agent dispatch fleet: a documented switch that HOLDS new worker spawns while STILL ALLOWING the progress-harvesting paths (witness-close and status-refresh) to keep running.
 Package fleetfreeze is the operator freeze gate for the parallel-agent dispatch fleet: a documented switch that HOLDS new worker spawns while STILL ALLOWING the progress-harvesting paths (witness-close and status-refresh) to keep running.
fleetmetrics
Package fleetmetrics is a pure duration-percentile fold over worker-session records.
 Package fleetmetrics is a pure duration-percentile fold over worker-session records.
fleetmon
Package fleetmon is the evidence-derived monitor, janitor, ledger, and replacement engine for a headless-worker fleet run (#1856–#1859).
 Package fleetmon is the evidence-derived monitor, janitor, ledger, and replacement engine for a headless-worker fleet run (#1856–#1859).
fleetpane
Package fleetpane folds fleet loop, process, and host checks into the operator control-pane view.
 Package fleetpane folds fleet loop, process, and host checks into the operator control-pane view.
fleetsim
Package fleetsim is a deterministic synthetic-ledger model for the "safe 400 GitHub issues/hour parallel-agent throughput" program (issue #1819, fleet-400iph).
 Package fleetsim is a deterministic synthetic-ledger model for the "safe 400 GitHub issues/hour parallel-agent throughput" program (issue #1819, fleet-400iph).
fleettrend
flock
Package flock is a cross-platform, non-blocking advisory file lock on an open *os.File.
 Package flock is a cross-platform, non-blocking advisory file lock on an open *os.File.
frontierswe
Package frontierswe is the dataset spine for FrontierSWE — Proximal Labs' time-to-solution benchmark of 17 long-horizon engineering tasks (a C-to-Zig port, an ffmpeg swscale rewrite, an RL post-training run, …).
 Package frontierswe is the dataset spine for FrontierSWE — Proximal Labs' time-to-solution benchmark of 17 long-horizon engineering tasks (a C-to-Zig port, an ffmpeg swscale rewrite, an RL post-training run, …).
fusedturn
Package fusedturn is the executable form of the fak thesis — the FUSED agent kernel — at the level of ONE TURN: a turn may spawn BOTH a classical operation (a deterministic tool call, a git commit, a lease, a verify) AND a weight-based operation (a model forward: an inference, an ensemble member, an expert dispatch), and BOTH cross the SAME default-deny adjudication floor.
 Package fusedturn is the executable form of the fak thesis — the FUSED agent kernel — at the level of ONE TURN: a turn may spawn BOTH a classical operation (a deterministic tool call, a git commit, a lease, a verify) AND a weight-based operation (a model forward: an inference, an ensemble member, an expert dispatch), and BOTH cross the SAME default-deny adjudication floor.
gardenbundle
Package gardenbundle is the garden bundle -- one default-on fold over the repo's read-only gardening passes.
 Package gardenbundle is the garden bundle -- one default-on fold over the repo's read-only gardening passes.
gateway
Package gateway is the kernel-adjudicated wire: it fronts the fak kernel over MCP (newline-delimited JSON-RPC) and an OpenAI-compatible HTTP surface so an agent written in ANY language can route its tool calls through the in-process syscall boundary WITHOUT writing Go.
 Package gateway is the kernel-adjudicated wire: it fronts the fak kernel over MCP (newline-delimited JSON-RPC) and an OpenAI-compatible HTTP surface so an agent written in ANY language can route its tool calls through the in-process syscall boundary WITHOUT writing Go.
gatewayusageledger
Package gatewayusageledger provides a durable, append-only JSONL ledger for the gateway's FULL served-turn counter family (issue #1610, child B of epic #1601): kernel submits/vDSO-hits/denies/quarantines, provider-cache economy (read/write tokens), compaction, and tool-prune savings.
 Package gatewayusageledger provides a durable, append-only JSONL ledger for the gateway's FULL served-turn counter family (issue #1610, child B of epic #1601): kernel submits/vDSO-hits/denies/quarantines, provider-cache economy (read/write tokens), compaction, and tool-prune savings.
ggufload
Package ggufload parses GGUF metadata and tensor directories for off-path model loading.
 Package ggufload parses GGUF metadata and tensor directories for off-path model loading.
gitgate
Package gitgate is a git-aware kernel PREFILTER: a registered Adjudicator rung that inspects a shell tool call (Bash / exec / run_shell / ...) carrying a `command` string, recognizes the `git` invocation inside it, and PROVABLY REFUSES the structurally-decidable git hazards BEFORE the command runs.
 Package gitgate is a git-aware kernel PREFILTER: a registered Adjudicator rung that inspects a shell tool call (Bash / exec / run_shell / ...) carrying a `command` string, recognizes the `git` invocation inside it, and PROVABLY REFUSES the structurally-decidable git hazards BEFORE the command runs.
gpulease
Package gpulease is a machine-wide advisory lease so that only one GPU-heavy process loads a model at a time.
 Package gpulease is a machine-wide advisory lease so that only one GPU-heavy process loads a model at a time.
grafanapost
Package grafanapost posts fak #grafana-channel cards — exported Grafana snapshots and long-lived dashboard / debug links — to a Slack channel.
 Package grafanapost posts fak #grafana-channel cards — exported Grafana snapshots and long-lived dashboard / debug links — to a Slack channel.
grammar
Durability is the memory-write half of the grammar rung: the domain-free "context is not memory" contract.
 Durability is the memory-write half of the grammar rung: the domain-free "context is not memory" contract.
guard
Package guard holds the agent-spawn containment seam for `fak guard`.
 Package guard holds the agent-spawn containment seam for `fak guard`.
guardcomplaint
Package guardcomplaint is the agent's APPEAL channel against the kernel — the subjective complement to the objective guard RSI loop (internal/guardrsi + internal/guardroute).
 Package guardcomplaint is the agent's APPEAL channel against the kernel — the subjective complement to the objective guard RSI loop (internal/guardrsi + internal/guardroute).
guardroute
Package guardroute is the bridge that closes the guard RSI loop: it turns a guarded session's worst journal bucket (found by internal/guardrsi) into a routed, idempotent, escalating finding -- a pickable findings-queue row, and, for a real honesty-hole, a deduped GitHub issue.
 Package guardroute is the bridge that closes the guard RSI loop: it turns a guarded session's worst journal bucket (found by internal/guardrsi) into a routed, idempotent, escalating finding -- a pickable findings-queue row, and, for a real honesty-hole, a deduped GitHub issue.
guardrsi
Package guardrsi scores guard-verdict quality and proposes replayable recursive-improvement candidates for weak denial buckets.
 Package guardrsi scores guard-verdict quality and proposes replayable recursive-improvement candidates for weak denial buckets.
guardtrace
Package guardtrace is the end-to-end test/replay harness for `fak guard`.
 Package guardtrace is the end-to-end test/replay harness for `fak guard`.
harnessprofile
Package harnessprofile is the declarative HarnessProfile descriptor + built-in registry that fak guard drives detection, repoint, credential, and rotation from.
 Package harnessprofile is the declarative HarnessProfile descriptor + built-in registry that fak guard drives detection, repoint, credential, and rotation from.
harnessres
Package harnessres samples the hardware-resource use of the fak guard HARNESS itself — the guard process (which hosts the in-process gateway on the same PID) and the wrapped agent child — so a guarded session can report the CPU, memory, and I/O it burned, the same way it already reports its cache/token economy.
 Package harnessres samples the hardware-resource use of the fak guard HARNESS itself — the guard process (which hosts the in-process gateway on the same PID) and the wrapped agent child — so a guarded session can report the CPU, memory, and I/O it burned, the same way it already reports its cache/token economy.
harvest
Package harvest is the LabelRow harvester — the data-collection rung of the compiled defender-side loop.
 Package harvest is the LabelRow harvester — the data-collection rung of the compiled defender-side loop.
headroom
Package headroom is the context-compression seam: a pluggable Compressor area (headroom/native/noop plugins) folded into the result path as a ResultAdmitter.
 Package headroom is the context-compression seam: a pluggable Compressor area (headroom/native/noop plugins) folded into the result path as a ResultAdmitter.
heavinessscore
Package heavinessscore is the operator-heaviness / steering-effort stick.
 Package heavinessscore is the operator-heaviness / steering-effort stick.
hfhub
Package hfhub resolves and downloads model files from the Hugging Face Hub via `hf://` URIs, with a local content cache, optional HF_TOKEN auth, and best-effort SHA256 verification against the Hub's LFS oid (the X-Linked-Etag the Hub stamps on every LFS object).
 Package hfhub resolves and downloads model files from the Hugging Face Hub via `hf://` URIs, with a local content cache, optional HF_TOKEN auth, and best-effort SHA256 verification against the Hub's LFS oid (the X-Linked-Etag the Hub stamps on every LFS object).
hooks
Package hooks runs the repo's commit-boundary gates IN ONE PROCESS.
 Package hooks runs the repo's commit-boundary gates IN ONE PROCESS.
horizonrecovery
Package horizonrecovery grounds the budget-recovery term r of the horizon multiplier in docs/explainers/compounding-benefits-of-a-saved-call.md, from a REAL ctxplanbench replay over real Claude Code transcripts.
 Package horizonrecovery grounds the budget-recovery term r of the horizon multiplier in docs/explainers/compounding-benefits-of-a-saved-call.md, from a REAL ctxplanbench replay over real Claude Code transcripts.
ideascout
Package ideascout searches configured research and repository feeds, dedupes candidates, and emits triage-ready idea-scout issues.
 Package ideascout searches configured research and repository feeds, dedupes candidates, and emits triage-ready idea-scout issues.
ifc
Package ifc is the information-flow control layer — the CaMeL / FIDES complement to the lexical detectors (canon, normgate, ctxmmu).
 Package ifc is the information-flow control layer — the CaMeL / FIDES complement to the lexical detectors (canon, normgate, ctxmmu).
intlist
Package intlist parses a string into a list of non-negative integers.
 Package intlist parses a string into a list of non-negative integers.
issuecatalog
Package issuecatalog is the durable bridge from a reviewable catalog of performance-enablement gap rows to a stable, deduplicated GitHub issue per row.
 Package issuecatalog is the durable bridge from a reviewable catalog of performance-enablement gap rows to a stable, deduplicated GitHub issue per row.
issuecohort
Package issuecohort plans a whole BATCH of machine-created GitHub issue candidates at creation time, before any of them is synced to GitHub.
 Package issuecohort plans a whole BATCH of machine-created GitHub issue candidates at creation time, before any of them is synced to GitHub.
issuecontract
Package issuecontract reviews machine-created GitHub issue candidates before they enter the dispatch loop.
 Package issuecontract reviews machine-created GitHub issue candidates before they enter the dispatch loop.
issuecontractrepair
issuecost
Package issuecost is a pure fold over per-issue worker-cost rows so the 400-issues/hour throughput model can be driven by MEASURED distributions (median + p95 of worker elapsed time) instead of a guessed constant.
 Package issuecost is a pure fold over per-issue worker-cost rows so the 400-issues/hour throughput model can be driven by MEASURED distributions (median + p95 of worker elapsed time) instead of a guessed constant.
issuesmallness
journal
Package journal is the durable, append-only, tamper-evident DECISION JOURNAL — the regulated-audit (AUD) surface of the trust floor.
 Package journal is the durable, append-only, tamper-evident DECISION JOURNAL — the regulated-audit (AUD) surface of the trust floor.
kernel
explain.go — the OFF-HOT-PATH dual of Fold: it folds the SAME adjudicator chain to the SAME winning verdict, but additionally records a per-rung Decision trace — the answer to the single most common debugging question in the whole kernel: "why did fak give THIS verdict for THIS tool call?"
 explain.go — the OFF-HOT-PATH dual of Fold: it folds the SAME adjudicator chain to the SAME winning verdict, but additionally records a per-rung Decision trace — the answer to the single most common debugging question in the whole kernel: "why did fak give THIS verdict for THIS tool call?"
kvmmu
Package kvmmu is the bridge the in-kernel model makes possible: it turns ctxmmu's LOGICAL quarantine verdict — "these bytes may not enter the context window" — into a MECHANICAL one — eviction of that result's K/V span from the kernel-owned attention cache, so the model physically cannot attend to it.
 Package kvmmu is the bridge the in-kernel model makes possible: it turns ctxmmu's LOGICAL quarantine verdict — "these bytes may not enter the context window" — into a MECHANICAL one — eviction of that result's K/V span from the kernel-owned attention cache, so the model physically cannot attend to it.
l3region
Package l3region ships Stage 1 of child B of the L3 disaggregated-cache epic (#77 / epic #504; study docs/notes/L3-DISAGGREGATED-CACHE-REIMAGINED.md §4 Option B): an L3RegionBackend behind fak's already-frozen Resolver seam (internal/abi.RegionBackend, registered via abi.RegisterRegionBackend).
 Package l3region ships Stage 1 of child B of the L3 disaggregated-cache epic (#77 / epic #504; study docs/notes/L3-DISAGGREGATED-CACHE-REIMAGINED.md §4 Option B): an L3RegionBackend behind fak's already-frozen Resolver seam (internal/abi.RegionBackend, registered via abi.RegisterRegionBackend).
laneadmit
Package laneadmit is the shared lane/tree admission decision every execution surface asks before acting on the shared tree: dispatch workers, `fak loop drive` runs, and manual sessions (via `fak loop coord`).
 Package laneadmit is the shared lane/tree admission decision every execution surface asks before acting on the shared tree: dispatch workers, `fak loop drive` runs, and manual sessions (via `fak loop coord`).
launchlatency
Package launchlatency is a pure fold over worker-LAUNCH records: the time between a dispatch decision ("spawn worker W now") and that worker's first heartbeat ("W is alive and running").
 Package launchlatency is a pure fold over worker-LAUNCH records: the time between a dispatch decision ("spawn worker W now") and that worker's first heartbeat ("W is alive and running").
leakcheck
Package leakcheck provides the three reusable PROOF primitives a memory/goroutine-leak sweep needs, so a regression guard is a few lines instead of a hand-rolled harness each time.
 Package leakcheck provides the three reusable PROOF primitives a memory/goroutine-leak sweep needs, so a regression guard is a few lines instead of a hand-rolled harness each time.
learningdebt
Package learningdebt is the staleness->backlog bridge from the learning-docs scorecard to a cap-bounded, deduplicated GitHub triage issue per HARD teaching defect.
 Package learningdebt is the staleness->backlog bridge from the learning-docs scorecard to a cap-bounded, deduplicated GitHub triage issue per HARD teaching defect.
leaseref
Package leaseref is the CROSS-MACHINE VISIBILITY substrate for fak's leases: it persists a lease record under a dedicated refs/fak/locks/<id> ref namespace, so lease state rides ordinary `git fetch` / `git push` between clones — the same mechanism grite uses with refs/grite/locks.
 Package leaseref is the CROSS-MACHINE VISIBILITY substrate for fak's leases: it persists a lease record under a dedicated refs/fak/locks/<id> ref namespace, so lease state rides ordinary `git fetch` / `git push` between clones — the same mechanism grite uses with refs/grite/locks.
lifebridge
Package lifebridge is the explicit converter between the two altitudes of the ONE agent lifecycle machine (epic #912): the served-session drive state (internal/session.RunState) and the loop supervisor state (internal/loopmgr.LoopState).
 Package lifebridge is the explicit converter between the two altitudes of the ONE agent lifecycle machine (epic #912): the served-session drive state (internal/session.RunState) and the loop supervisor state (internal/loopmgr.LoopState).
lifecycle
Package lifecycle is the ONE canonical vocabulary for an agent's run-state — the shared skeleton that both the served session (internal/session.RunState) and the loop supervisor (internal/loopmgr.LoopState) spell.
 Package lifecycle is the ONE canonical vocabulary for an agent's run-state — the shared skeleton that both the served session (internal/session.RunState) and the loop supervisor (internal/loopmgr.LoopState) spell.
livecodebench
Package livecodebench adapts LiveCodeBench problem suites and run reports into fak-native shapes.
 Package livecodebench adapts LiveCodeBench problem suites and run reports into fak-native shapes.
loopdrive
Package loopdrive parses the GOAL.md goal spec used by fak loop drive.
 Package loopdrive parses the GOAL.md goal spec used by fak loop drive.
loopfleet
Package loopfleet is the cross-ledger loop-health fold (#1196, part of #1173 — the verified loop): one read-only pane that answers "show me EVERY loop's health — last tick, run count, keep/witness rate, and whether it has gone DARK" across the repo's fragmented loop ledgers.
 Package loopfleet is the cross-ledger loop-health fold (#1196, part of #1173 — the verified loop): one read-only pane that answers "show me EVERY loop's health — last tick, run count, keep/witness rate, and whether it has gone DARK" across the repo's fragmented loop ledgers.
loopgate
loopbench measures what the witnessed exit-gate earns over a naive Ralph loop that terminates on the agent's own self-reported "done".
 loopbench measures what the witnessed exit-gate earns over a naive Ralph loop that terminates on the agent's own self-reported "done".
loopindex
Package loopindex scores the agentic-coding LOOP — the round an agent (and a fleet of agents) runs to go from a task to shipped, verified code — into one witnessed number: the loop-index.
 Package loopindex scores the agentic-coding LOOP — the round an agent (and a fleet of agents) runs to go from a task to shipped, verified code — into one witnessed number: the loop-index.
loopmap
Package loopmap is the loop-stage -> tool map: the in-loop affordance that answers "what tool do I reach for RIGHT NOW?" at each stage of the agentic-coding loop (orient -> plan -> act -> verify -> ship -> learn, the six stages owned by internal/loopindex).
 Package loopmap is the loop-stage -> tool map: the in-loop affordance that answers "what tool do I reach for RIGHT NOW?" at each stage of the agentic-coding loop (orient -> plan -> act -> verify -> ship -> learn, the six stages owned by internal/loopindex).
loopmgr
Package loopmgr records and summarizes long-running agent loop events.
 Package loopmgr records and summarizes long-running agent loop events.
looprecover
Package looprecover is the deterministic recovery decision the fak dispatch fleet is missing: given the durable loop ledger's record of every dispatched run, which runs STARTED but never finished or were never witnessed — the work that should be re-dispatched or re-verified rather than left silently abandoned?
 Package looprecover is the deterministic recovery decision the fak dispatch fleet is missing: given the durable loop ledger's record of every dispatched run, which runs STARTED but never finished or were never witnessed — the work that should be re-dispatched or re-verified rather than left silently abandoned?
loopscore
Package loopscore scores the AGENTIC BACKGROUND LOOPS themselves — the always-on processes (issue dispatch, resolve-progress, freshness cadences, smoke loops) that keep the fleet moving while no human is watching.
 Package loopscore scores the AGENTIC BACKGROUND LOOPS themselves — the always-on processes (issue dispatch, resolve-progress, freshness cadences, smoke loops) that keep the fleet moving while no human is watching.
maputil
Package maputil holds small, generic map helpers that were previously copy-pasted across packages.
 Package maputil holds small, generic map helpers that were previously copy-pasted across packages.
marketing
Package marketing turns a WITNESSED completion event — a ship-stamped commit, a closed epic, a release — into a fresh marketing artifact, with one rung the other outbound posters (internal/scoreboard, benchpost, dispatchpost, dojopost) don't have: every claim is keyed to a git-witnessed commit sha.
 Package marketing turns a WITNESSED completion event — a ship-stamped commit, a closed epic, a release — into a fresh marketing artifact, with one rung the other outbound posters (internal/scoreboard, benchpost, dispatchpost, dojopost) don't have: every claim is keyed to a git-witnessed commit sha.
mathx
Package mathx holds small numeric helpers shared across packages — the kind of one-liner that was copy-pasted into every report builder before it had a home.
 Package mathx holds small numeric helpers shared across packages — the kind of one-liner that was copy-pasted into every report builder before it had a home.
maturity
Package maturity scores where each fak capability sits on its LIFECYCLE maturity ladder — and, crucially, what the next step to advance it is.
 Package maturity scores where each fak capability sits on its LIFECYCLE maturity ladder — and, crucially, what the next step to advance it is.
memgate
Package memgate checks whether a heavy model load should proceed under memory pressure.
 Package memgate checks whether a heavy model load should proceed under memory pressure.
memorycotravel
memoryread
Package memoryread renders the committed fleet memory mirror as a bounded digest.
 Package memoryread renders the committed fleet memory mirror as a bounded digest.
memorystability
memq
Package memq is the agent-facing MEMORY-OPERATION ALGEBRA — the substrate that lets an agent (or a plugin, a driver, or an operator) author its OWN memory strategy instead of the kernel hard-coding one.
 Package memq is the agent-facing MEMORY-OPERATION ALGEBRA — the substrate that lets an agent (or a plugin, a driver, or an operator) author its OWN memory strategy instead of the kernel hard-coding one.
memview
Package memview is the typed virtual-view contract over canonical raw memory cells (issue #904): a memory/context cell is CANONICAL (the raw bytes), and every summary / QA / graph / prompt-prefix / KV-prefix projection of it is a DERIVED view that carries provenance and an admission gate.
 Package memview is the typed virtual-view contract over canonical raw memory cells (issue #904): a memory/context cell is CANONICAL (the raw bytes), and every summary / QA / graph / prompt-prefix / KV-prefix projection of it is a DERIVED view that carries provenance and an admission gate.
mergepreview
metalgemm
Package metalgemm stub — the non-Apple-Silicon or cgo-disabled build.
 Package metalgemm stub — the non-Apple-Silicon or cgo-disabled build.
metrics
Package metrics is the KPI layer + the A/B report shape.
 Package metrics is the KPI layer + the A/B report shape.
milestonedoc
Package milestonedoc renders the project's milestone CLIMB snapshot into a freshness-checked, committed markdown block, the milestone-shaped sibling of internal/supportmaturityscore's MatrixBlock (#1441, child of epic #1436).
 Package milestonedoc renders the project's milestone CLIMB snapshot into a freshness-checked, committed markdown block, the milestone-shaped sibling of internal/supportmaturityscore's MatrixBlock (#1441, child of epic #1436).
milestonepost
Package milestonepost posts the milestone tracking report — fak's WITNESSED maturity CLIMB plus the epic ROADMAP — to a single Slack "milestones" channel, so the fleet has one durable place where "how far has the project climbed, and is it moving?" gets an honest answer on a cadence.
 Package milestonepost posts the milestone tracking report — fak's WITNESSED maturity CLIMB plus the epic ROADMAP — to a single Slack "milestones" channel, so the fleet has one durable place where "how far has the project climbed, and is it moving?" gets an honest answer on a cadence.
milestonereport
Package milestonereport folds the project's two milestone signals — the maturity CLIMB and the epic ROADMAP — into one read-only report envelope with a durable JSONL trend ledger, the milestone-shaped sibling of internal/cadencereport.
 Package milestonereport folds the project's two milestone signals — the maturity CLIMB and the epic ROADMAP — into one read-only report envelope with a durable JSONL trend ledger, the milestone-shaped sibling of internal/cadencereport.
model
Package model is the in-kernel inference core: a pure-Go forward pass over a single small open-source model (SmolLM2-135M / Qwen2.5-0.5B), with the KV cache as a first-class Go data structure the kernel OWNS.
 Package model is the in-kernel inference core: a pure-Go forward pass over a single small open-source model (SmolLM2-135M / Qwen2.5-0.5B), with the KV cache as a first-class Go data structure the kernel OWNS.
modelengine
Package modelengine wires the in-kernel model (internal/model) into the kernel as a registered abi.EngineDriver under the id "inkernel".
 Package modelengine wires the in-kernel model (internal/model) into the kernel as a registered abi.EngineDriver under the id "inkernel".
modelladder
Package modelladder is the shared model-ladder/registry infrastructure used by the live demos (cmd/ctxdemo, cmd/demorace).
 Package modelladder is the shared model-ladder/registry infrastructure used by the live demos (cmd/ctxdemo, cmd/demorace).
modelreg
Package modelreg is the friendly-name → model-ref registry that lets a user say `fak run qwen2.5:7b` or `fak serve --gguf smollm2` instead of typing a full hf:// URI or hunting for a local .gguf path.
 Package modelreg is the friendly-name → model-ref registry that lets a user say `fak run qwen2.5:7b` or `fak serve --gguf smollm2` instead of typing a full hf:// URI or hunting for a local .gguf path.
modelroute
Package modelroute is fak's model-routing spine: choose WHICH model — or which ENSEMBLE of models — serves any ASPECT of a request, under one declarative, deterministic, verifiable policy.
 Package modelroute is fak's model-routing spine: choose WHICH model — or which ENSEMBLE of models — serves any ASPECT of a request, under one declarative, deterministic, verifiable policy.
mutationbudget
Package mutationbudget is the throttle guard for live GitHub mutations: it gates each planned burst of close/comment calls behind the remaining API budget so a parallel-agent fleet cannot exhaust the rate limit mid-batch and leave the work half-executed.
 Package mutationbudget is the throttle guard for live GitHub mutations: it gates each planned burst of close/comment calls behind the remaining API budget so a parallel-agent fleet cannot exhaust the rate limit mid-batch and leave the work half-executed.
newleaf
Package newleaf generates architecture-compliant internal leaf skeletons and optional registration edits.
 Package newleaf generates architecture-compliant internal leaf skeletons and optional registration edits.
newmodel
Package newmodel is new-model scaffolding command.
 Package newmodel is new-model scaffolding command.
nightrun
Package nightrun is the "run it all night" center of excellence: the one place that answers, for an operator OR an agent, the single recurring question of unattended data collection —
 Package nightrun is the "run it all night" center of excellence: the one place that answers, for an operator OR an agent, the single recurring question of unattended data collection —
nodecompare
Package nodecompare folds per-node benchmark outputs into a cross-hardware table.
 Package nodecompare folds per-node benchmark outputs into a cross-hardware table.
nodeusagepost
Package nodeusagepost posts COMPUTE-NODE-USAGE status — the latest fleet/node readiness, the active worker count, and inbound load — to a Slack "node-usage" channel.
 Package nodeusagepost posts COMPUTE-NODE-USAGE status — the latest fleet/node readiness, the active worker count, and inbound load — to a Slack "node-usage" channel.
normgate
Package normgate is a write-time ResultAdmitter that closes the context-MMU's measured DETECTION gap: the v0.1 ctxmmu matches injection markers and secret shapes as raw ASCII regex/substring, so any obfuscation (char-spacing, base64, homoglyph, zero-width, fullwidth, bidi, format-variant secrets) walks straight through (~100% evasion, measured on a private transcript-derived corpus).
 Package normgate is a write-time ResultAdmitter that closes the context-MMU's measured DETECTION gap: the v0.1 ctxmmu matches injection markers and secret shapes as raw ASCII regex/substring, so any obfuscation (char-spacing, base64, homoglyph, zero-width, fullwidth, bidi, format-variant secrets) walks straight through (~100% evasion, measured on a private transcript-derived corpus).
numfmt
Package numfmt holds the small allocation-light numeric and environment formatting helpers that were copy-pasted across the kernel.
 Package numfmt holds the small allocation-light numeric and environment formatting helpers that were copy-pasted across the kernel.
operatorbrief
Package operatorbrief folds existing control-pane reports into one operator-facing brief.
 Package operatorbrief folds existing control-pane reports into one operator-facing brief.
operatortouches
Package operatortouches is the R1 babysitting counter (#2270, epic #2269): a pure fold over loop-event ledgers (internal/loopmgr, fak.loop-event.v1) that measures how much HUMAN supervision a fleet actually consumed, per witnessed unit of shipped work.
 Package operatortouches is the R1 babysitting counter (#2270, epic #2269): a pure fold over loop-event ledgers (internal/loopmgr, fak.loop-event.v1) that measures how much HUMAN supervision a fleet actually consumed, per witnessed unit of shipped work.
opttarget
Package opttarget is the declarative target layer of the RSI optimization fuser (epic #1279).
 Package opttarget is the declarative target layer of the RSI optimization fuser (epic #1279).
pathlint
Package pathlint is a static witness for one external-boundary claim: that every user-supplied filesystem-path flag is normalized before it reaches the OS.
 Package pathlint is a static witness for one external-boundary claim: that every user-supplied filesystem-path flag is normalized before it reaches the OS.
pathutil
Package pathutil holds small, dependency-free path helpers shared across the fak commands — chiefly normalizing user-supplied path flags before they reach the filesystem.
 Package pathutil holds small, dependency-free path helpers shared across the fak commands — chiefly normalizing user-supplied path flags before they reach the filesystem.
planaudit
Package planaudit audits coarse completion signals in plan documents.
 Package planaudit audits coarse completion signals in plan documents.
plancfi
Package plancfi is control-flow integrity for an agent's PLAN — the stateful adjudicator that refuses a tool call which deviates from the approved plan.
 Package plancfi is control-flow integrity for an agent's PLAN — the stateful adjudicator that refuses a tool call which deviates from the approved plan.
policy
The isolation dial (issue #2013, epic #2000 M13): the declarative config surface mapping a task's declared TRUST LEVEL to a registered ToolExec backend, so isolation is a spend/threat-model spectrum the operator dials from the manifest — goroutine (trusted, in-process) → subprocess → container → gvisor → firecracker → remote (untrusted) — instead of a compiled-in choice.
 The isolation dial (issue #2013, epic #2000 M13): the declarative config surface mapping a task's declared TRUST LEVEL to a registered ToolExec backend, so isolation is a spend/threat-model spectrum the operator dials from the manifest — goroutine (trusted, in-process) → subprocess → container → gvisor → firecracker → remote (untrusted) — instead of a compiled-in choice.
polymodel
Package polymodel is the deterministic core for hosting many models on one kernel and serializing decode to one lane — the "host 10s of models, share the prefill, decode one" design, expressed as proven arithmetic with no GPU, model, or network dependency.
 Package polymodel is the deterministic core for hosting many models on one kernel and serializing decode to one lane — the "host 10s of models, share the prefill, decode one" design, expressed as proven arithmetic with no GPU, model, or network dependency.
popularizationtickets
preflight
Package preflight is the pre-flight rung ladder: cheapest-first well-formedness checks that catch a malformed/unsafe call BEFORE it fires, so a dead branch never spawns a process or burns a model turn.
 Package preflight is the pre-flight rung ladder: cheapest-first well-formedness checks that catch a malformed/unsafe call BEFORE it fires, so a dead branch never spawns a process or burns a model turn.
procguard
Package procguard is the native Go port of the standalone operator/control-pane modes of tools/proc_resource_guard.py — catch a runaway process before it pins the host.
 Package procguard is the native Go port of the standalone operator/control-pane modes of tools/proc_resource_guard.py — catch a runaway process before it pins the host.
productscorecard
Package productscorecard folds product-facing rows into the durable product scorecard payload and report.
 Package productscorecard folds product-facing rows into the durable product scorecard payload and report.
programreport
Package programreport folds the project's ONGOING PROGRAMS — the work classes internal/worktype marks as never-"done" frontiers (kernel-optimization cache-optimization, and human-operator-effectiveness) — into one read-only report envelope with a durable JSONL trend ledger.
 Package programreport folds the project's ONGOING PROGRAMS — the work classes internal/worktype marks as never-"done" frontiers (kernel-optimization cache-optimization, and human-operator-effectiveness) — into one read-only report envelope with a durable JSONL trend ledger.
promptaudit
Package promptaudit scans system/developer/context prompt text for hidden control markers BEFORE they cross a model or cache boundary.
 Package promptaudit scans system/developer/context prompt text for hidden control markers BEFORE they cross a model or cache boundary.
promptmmu
Package promptmmu is the cache-prefix-preserving inbound prompt MMU: the INGRESS dual of the result-side ctxmmu.
 Package promptmmu is the cache-prefix-preserving inbound prompt MMU: the INGRESS dual of the result-side ctxmmu.
propagationscore
Package propagationscore measures CONVENTION PROPAGATION across fak's scorecard family -- the degree to which a "scoring concept" improved in ONE card has fanned out to its siblings -- and turns each un-propagated gap into a deduped, dispatchable GitHub issue (internal/propagationscore/dispatch.go) so the operator never has to REMEMBER to extend an improvement by hand.
 Package propagationscore measures CONVENTION PROPAGATION across fak's scorecard family -- the degree to which a "scoring concept" improved in ONE card has fanned out to its siblings -- and turns each un-propagated gap into a deduped, dispatchable GitHub issue (internal/propagationscore/dispatch.go) so the operator never has to REMEMBER to extend an improvement by hand.
provenance
Package provenance is the single, kernel-authored answer to one question: "where did this byte come from, and may the kernel trust it?" — and it is the ONE place that answer is decided.
 Package provenance is the single, kernel-authored answer to one question: "where did this byte come from, and may the kernel trust it?" — and it is the ONE place that answer is decided.
pythongate
Package pythongate is the NEW-PYTHON-TOOL ratchet: the durable gate that makes the project's de-Python push gradual and self-sustaining.
 Package pythongate is the NEW-PYTHON-TOOL ratchet: the durable gate that makes the project's de-Python push gradual and self-sustaining.
qwen36nodereports
qwen36parity
radixkv
Package radixkv is SGLang's RadixAttention prefix cache, rebuilt over fak's kernel-owned KV cache — the apples-to-apples answer to "how does fak compare to SGLang's KV-cache radix attention?".
 Package radixkv is SGLang's RadixAttention prefix cache, rebuilt over fak's kernel-owned KV cache — the apples-to-apples answer to "how does fak compare to SGLang's KV-cache radix attention?".
ratelimit
Package ratelimit is the throughput/cost governor: the adjudicator that turns the already-plumbed RATE_LIMITED reason into an actual enforcer.
 Package ratelimit is the throughput/cost governor: the adjudicator that turns the already-plumbed RATE_LIMITED reason into an actual enforcer.
readmevisualaudit
recall
Package recall makes a COMPLETED agent session queryable without replaying it — the "treat a finished session as a core dump" leaf (../../session-recall-design.md).
 Package recall makes a COMPLETED agent session queryable without replaying it — the "treat a finished session as a core dump" leaf (../../session-recall-design.md).
region
Package region provides a typed, in-process one-sided shared window over abi.Ref values.
 Package region provides a typed, in-process one-sided shared window over abi.Ref values.
regionadmit
Package regionadmit is the shared region-admission decision every execution surface consults before mutating a file tree: may THIS actor act on THIS (lane, tree) right now, given the live lease set and the workspace lane taxonomy?
 Package regionadmit is the shared region-admission decision every execution surface consults before mutating a file tree: may THIS actor act on THIS (lane, tree) right now, given the live lease set and the workspace lane taxonomy?
registrations
Package registrations is the "built-in driver list" (the Linux defconfig).
 Package registrations is the "built-in driver list" (the Linux defconfig).
rehydrate
Package rehydrate is the horizon-gated re-entry orchestrator: the staged gate a resumed agent passes through BEFORE its first post-wake action, running strictly more revalidation the longer it slept.
 Package rehydrate is the horizon-gated re-entry orchestrator: the staged gate a resumed agent passes through BEFORE its first post-wake action, running strictly more revalidation the longer it slept.
relay
Package relay is the perpetual-session substrate (epic #1860): a goal is run as an ordered sequence of bounded legs, each handing a small typed BATON to the next instead of compacting a growing transcript.
 Package relay is the perpetual-session substrate (epic #1860): a goal is run as an ordered sequence of bounded legs, each handing a small typed BATON to the next instead of compacting a growing transcript.
release
Package release holds the single, process-safe release lock that every code path which mutates the two single-writer release resources — the bare VERSION marker and the monotone vX.Y.Z tag sequence — must take before its critical section.
 Package release holds the single, process-safe release lock that every code path which mutates the two single-writer release resources — the bare VERSION marker and the monotone vX.Y.Z tag sequence — must take before its critical section.
releasestale
Package releasestale answers one question durably: "is the version that `go install github.com/.../cmd/fak@latest` would install actually current, or has the trunk moved far past it?"
 Package releasestale answers one question durably: "is the version that `go install github.com/.../cmd/fak@latest` would install actually current, or has the trunk moved far past it?"
releasestatus
Package releasestatus folds the full read-only release posture that tools/release_status.py emits into one typed Go record — the broader sibling of internal/releasestale, which only covers the publish-staleness slice.
 Package releasestatus folds the full read-only release posture that tools/release_status.py emits into one typed Go record — the broader sibling of internal/releasestale, which only covers the publish-staleness slice.
repoguard
guard.go — the pure, interpreter-free core of the repo-guard PreToolUse hook.
 guard.go — the pure, interpreter-free core of the repo-guard PreToolUse hook.
residency
Package residency is the multi-model weight-residency leaf: it hosts many prefill-warm *model.Model under one resident weight-byte budget with LRU page-out, reusing internal/polymodel.Pool as the budget + eviction POLICY and binding each admitted residency descriptor to the real in-kernel weights it governs.
 Package residency is the multi-model weight-residency leaf: it hosts many prefill-warm *model.Model under one resident weight-byte budget with LRU page-out, reusing internal/polymodel.Pool as the budget + eviction POLICY and binding each admitted residency descriptor to the real in-kernel weights it governs.
resume
next.go — the ACT half of the resume process: the single deterministic step that turns "where does this crashed session stand?" (FoldResumeState) into "what do I DO about it right now?".
 next.go — the ACT half of the resume process: the single deterministic step that turns "where does this crashed session stand?" (FoldResumeState) into "what do I DO about it right now?".
resume/rehome
Package rehome is the Go port of the interactive resume-resolver (tools/resume_resolver.py): it decides WHICH account `claude --resume <sid>` should run under, re-homing the transcript onto a healthy account when the owning account is rate-limited or blocked.
 Package rehome is the Go port of the interactive resume-resolver (tools/resume_resolver.py): it decides WHICH account `claude --resume <sid>` should run under, re-homing the transcript onto a healthy account when the owning account is rate-limited or blocked.
resume/signals
Package signals is the Go port of tools/fleet_session_signals.py — the shared transcript signal patterns every fleet session/account tool classifies with.
 Package signals is the Go port of tools/fleet_session_signals.py — the shared transcript signal patterns every fleet session/account tool classifies with.
resume/stopped
Package stopped is the pure decision core of the stopped-session triage: given the parsed tail of a top-level Claude Code transcript, classify how the session stopped (its DISPOSITION) and decide which stopped sessions are safe to resume headlessly, which must wait (account throttled / auth-walled), and which to leave alone.
 Package stopped is the pure decision core of the stopped-session triage: given the parsed tail of a top-level Claude Code transcript, classify how the session stopped (its DISPOSITION) and decide which stopped sessions are safe to resume headlessly, which must wait (account throttled / auth-walled), and which to leave alone.
resume/sweep
Package sweep is the pure decision core of the manifest-free crash discovery: given every on-disk COPY of a recently-touched session (the same transcript can live under several account dirs after re-homes), it resolves the SUPERSET copy, reads the terminal turn, and buckets the session by the action it actually needs.
 Package sweep is the pure decision core of the manifest-free crash discovery: given every on-disk COPY of a recently-touched session (the same transcript can live under several account dirs after re-homes), it resolves the SUPERSET copy, reads the terminal turn, and buckets the session by the action it actually needs.
resume/transcript
Package transcript is the ONE Claude Code session-transcript record model the resume-family tools share.
 Package transcript is the ONE Claude Code session-transcript record model the resume-family tools share.
rsiloop
Package rsiloop closes fak's recursive-self-improvement loop.
 Package rsiloop closes fak's recursive-self-improvement loop.
rulesynth
Package rulesynth closes AUTOHARNESS's loop on OUR hand-authored harness: it mines the kernel's refusal/near-miss log to PROPOSE the next STRUCTURAL adjudicator rule, then PROVES it model-free before it can ship — never self-certifying (#537).
 Package rulesynth closes AUTOHARNESS's loop on OUR hand-authored harness: it mines the kernel's refusal/near-miss log to PROPOSE the next STRUCTURAL adjudicator rule, then PROVES it model-free before it can ship — never self-certifying (#537).
rungobs
Package rungobs is the passive rung-decision distribution counter — the aggregate observability dual of `fak preflight --explain`.
 Package rungobs is the passive rung-decision distribution counter — the aggregate observability dual of `fak preflight --explain`.
safecommit
Package safecommit is the EXECUTOR half of the shared-trunk commit discipline that internal/gitgate only declares defensively.
 Package safecommit is the EXECUTOR half of the shared-trunk commit discipline that internal/gitgate only declares defensively.
safesync
Package safesync is safe fast-forward sync for dirty shared worktrees.
 Package safesync is safe fast-forward sync for dirty shared worktrees.
savingsvector
Package savingsvector re-projects a turnbench Report's FLAT saving into the FOUR orthogonal accounts named by docs/explainers/compounding-benefits-of-a-saved-call.md.
 Package savingsvector re-projects a turnbench Report's FLAT saving into the FOUR orthogonal accounts named by docs/explainers/compounding-benefits-of-a-saved-call.md.
scoreboard
Package scoreboard posts fak status — scorecard results, scores, run events — to a Slack "scoreboard" channel.
 Package scoreboard posts fak status — scorecard results, scores, run events — to a Slack "scoreboard" channel.
scorecardpane
Package scorecardpane is the native Go port of the two highest-frequency scorecard folds the family still ran in Python: the portfolio control-pane fold (tools/scorecard_control_pane.py) and the repo-hygiene scorecard fold (tools/repo_hygiene_scorecard.py).
 Package scorecardpane is the native Go port of the two highest-frequency scorecard folds the family still ran in Python: the portfolio control-pane fold (tools/scorecard_control_pane.py) and the repo-hygiene scorecard fold (tools/repo_hygiene_scorecard.py).
secretgate
Package secretgate is the execution-time, on-discovery SECRET rung (epic #880, pillar [B], issue #884).
 Package secretgate is the execution-time, on-discovery SECRET rung (epic #880, pillar [B], issue #884).
secretload
Package secretload is fak's first-class secret/config loader — the structural seam for pillars [C] (.env / config loading) and [D] (the vault backend) of the secret-handling epic (#880, foundation issue #887).
 Package secretload is fak's first-class secret/config loader — the structural seam for pillars [C] (.env / config loading) and [D] (the vault backend) of the secret-handling epic (#880, foundation issue #887).
selfinstall
Package selfinstall rebuilds the fak binary from the current checkout and atomically swaps it into a target path — but ONLY after the freshly-built binary passes a gate, so a tree that does not compile, fails vet, or produces a binary that cannot even print its version is NEVER installed over a running fleet.
 Package selfinstall rebuilds the fak binary from the current checkout and atomically swaps it into a target path — but ONLY after the freshly-built binary passes a gate, so a tree that does not compile, fails vet, or produces a binary that cannot even print its version is NEVER installed over a running fleet.
selfquery
This file is the general policy #1580 asks for: a level up from any single ask-vs-assume decision point, it specifies the ONE rule every such decision point in this codebase should be checkable against, rather than each one growing its own bespoke threshold.
 This file is the general policy #1580 asks for: a level up from any single ask-vs-assume decision point, it specifies the ONE rule every such decision point in this codebase should be checkable against, rather than each one growing its own bespoke threshold.
session
Package session is the per-session DRIVE state — the first-class, queryable, live-mutable control state of a served agent session: its run-state, planner budget, scheduling priority, and per-turn pace.
 Package session is the per-session DRIVE state — the first-class, queryable, live-mutable control state of a served agent session: its run-state, planner budget, scheduling priority, and per-turn pace.
sessionaudit
Package sessionaudit audits Claude Code session-transcript JSONL files.
 Package sessionaudit audits Claude Code session-transcript JSONL files.
sessiondesc
Package sessiondesc is the session-descriptor join schema (fak.session.descriptor.v1, issue #2214, epic #2209): ONE record that binds the four identity spaces a fak session lives in but which today never join —
 Package sessiondesc is the session-descriptor join schema (fak.session.descriptor.v1, issue #2214, epic #2209): ONE record that binds the four identity spaces a fak session lives in but which today never join —
sessionimage
Package sessionimage makes an agent SESSION a first-class, portable, model-agnostic VALUE — one self-describing image you can dump, archive, offload, and restore across hosts, users, instances, VMs, and a model change, then RESUME where it left off.
 Package sessionimage makes an agent SESSION a first-class, portable, model-agnostic VALUE — one self-describing image you can dump, archive, offload, and restore across hosts, users, instances, VMs, and a model change, then RESUME where it left off.
sessionobs
Package sessionobs scores the OBSERVABILITY of our own coding-session data for RSI loops.
 Package sessionobs scores the OBSERVABILITY of our own coding-session data for RSI loops.
sessionreset
Package sessionreset builds the "human-like" carryover a fresh session is seeded with when a long-running session crosses its token budget.
 Package sessionreset builds the "human-like" carryover a fresh session is seeded with when a long-running session crosses its token budget.
sessionsignals
Package sessionsignals is the shared, closed vocabulary of TERMINAL-TURN signals the fleet session/resume tools classify a Claude Code transcript's last turn with: the usage-limit banner (and its reset window), the auth/login/credit/access walls, and the transient transport/server errors.
 Package sessionsignals is the shared, closed vocabulary of TERMINAL-TURN signals the fleet session/resume tools classify a Claude Code transcript's last turn with: the usage-limit banner (and its reset window), the auth/login/credit/access walls, and the transient transport/server errors.
sharedtask
Package sharedtask is the in-memory reference fold for collaborative task records.
 Package sharedtask is the in-memory reference fold for collaborative task records.
shipgate
adjudicate.go puts the ship gate ON the kernel's decision path: a registered Adjudicator that holds a ship-shaped tool call behind the require-witness rung.
 adjudicate.go puts the ship gate ON the kernel's decision path: a registered Adjudicator that holds a ship-shaped tool call behind the require-witness rung.
simhash
Package simhash is fak's REFERENCE vector-similarity primitive — the dependency-free embedding + cosine + top-k substrate the observability layer hands to anyone who wants to find near-duplicate queries, cluster trajectories, or flag outlier ("bad") queries WITHOUT fak choosing a semantic model for them.
 Package simhash is fak's REFERENCE vector-similarity primitive — the dependency-free embedding + cosine + top-k substrate the observability layer hands to anyone who wants to find near-duplicate queries, cluster trajectories, or flag outlier ("bad") queries WITHOUT fak choosing a semantic model for them.
skillenv
Package skillenv tracks active skill versions and previews blast radius for hot-swap or rollback through the context and KV MMU surfaces.
 Package skillenv tracks active skill versions and previews blast radius for hot-swap or rollback through the context and KV MMU surfaces.
skipledger
Package skipledger is a pure fold over one dispatchorder.Result tick into an auditable ledger: one row per candidate (skipped or selected), naming the issue, lane, reason, and timestamp, plus -- for a skip -- whether it was safety- or capacity-related.
 Package skipledger is a pure fold over one dispatchorder.Result tick into an auditable ledger: one row per candidate (skipped or selected), naming the issue, lane, reason, and timestamp, plus -- for a skip -- whether it was safety- or capacity-related.
slackenv
Package slackenv is the ONE resolver for fak's Slack-surface configuration: it reads a key from the process environment or a gitignored .env.slack.local file (walking up from the working directory), so the "one gitignored file configures every workspace" idiom lives in a single tested place instead of eight verbatim copies.
 Package slackenv is the ONE resolver for fak's Slack-surface configuration: it reads a key from the process environment or a gitignored .env.slack.local file (walking up from the working directory), so the "one gitignored file configures every workspace" idiom lives in a single tested place instead of eight verbatim copies.
slackmeta
Package slackmeta renders the common metadata line every fak Slack report carries.
 Package slackmeta renders the common metadata line every fak Slack report carries.
slackoutbox
Package slackoutbox is the durable Slack outbox (#2262, epic #2259): every fak-native message survives crashes, 429s, and token drift by being ENQUEUED as a local JSONL append first and POSTED by a single serialized drainer second — the transactional-outbox pattern sized for a one-box fleet.
 Package slackoutbox is the durable Slack outbox (#2262, epic #2259): every fak-native message survives crashes, 429s, and token drift by being ENQUEUED as a local JSONL append first and POSTED by a single serialized drainer second — the transactional-outbox pattern sized for a one-box fleet.
slackwire
Package slackwire is the ONE Slack Web API transport for fak: chat.postMessage, chat.update, conversations.history, and auth.test in a single tested client with 429/Retry-After handling and a typed error.
 Package slackwire is the ONE Slack Web API transport for fak: chat.postMessage, chat.update, conversations.history, and auth.test in a single tested client with 429/Retry-After handling and a typed error.
snapshot
Package snapshot is the uniform DUMP/RESTORE seam over fak's primitives.
 Package snapshot is the uniform DUMP/RESTORE seam over fak's primitives.
sotacoverage
sotamatrix
Package sotamatrix is the single, in-binary source of truth for "for each compute operation fak's kernel actually performs, what is the production / SOTA stack to learn from before writing it from scratch, and how should we relate to it (borrow / bind / stay-minimal)."
 Package sotamatrix is the single, in-binary source of truth for "for each compute operation fak's kernel actually performs, what is the production / SOTA stack to learn from before writing it from scratch, and how should we relate to it (borrow / bind / stay-minimal)."
spec
Package spec is the speculative-execution leaf: the first implementation of the frozen abi.ProvisionalSink seam, and the registrant of the reserved OpsSpec ops (OpSpecCommit / OpSpecSquash).
 Package spec is the speculative-execution leaf: the first implementation of the frozen abi.ProvisionalSink seam, and the registrant of the reserved OpsSpec ops (OpSpecCommit / OpSpecSquash).
steward
Package steward is the steward population: a set of cheap, single-invariant validators that garden the kernel's journal.
 Package steward is the steward population: a set of cheap, single-invariant validators that garden the kernel's journal.
stopfailure
Package stopfailure reads and settles DOS StopFailure breaker markers.
 Package stopfailure reads and settles DOS StopFailure breaker markers.
storedrv
Package storedrv is fak's pluggable STORAGE-DRIVER framework — the seam that lets every kind of data live in the place that fits it (hot RAM, durable disk, a remote object store, later a columnar or KV backend) instead of the one in-memory map the v0.1 blob store gives everything.
 Package storedrv is fak's pluggable STORAGE-DRIVER framework — the seam that lets every kind of data live in the place that fits it (hot RAM, durable disk, a remote object store, later a columnar or KV backend) instead of the one in-memory map the v0.1 blob store gives everything.
strmatch
Package strmatch is the one shared any-substring matcher the per-package containsAny copies converged on (slop de-dup #776): six identical bool bodies and one first-match variant were duplicated across internal/{attemptbudget,benchlineagegate,headroom,windowgate, readmevisualaudit,terminalbench,vcacheqa}.
 Package strmatch is the one shared any-substring matcher the per-package containsAny copies converged on (slop de-dup #776): six identical bool bodies and one first-match variant were duplicated across internal/{attemptbudget,benchlineagegate,headroom,windowgate, readmevisualaudit,terminalbench,vcacheqa}.
superloop
Package superloop is the operator-intent META-LOOP: a SUPER LOOP walks a curated set of member loops/gardens/scorecards, reads their status FIRST, and selects worst-first which member to enter — the layer that sits ABOVE a normal loop.
 Package superloop is the operator-intent META-LOOP: a SUPER LOOP walks a curated set of member loops/gardens/scorecards, reads their status FIRST, and selects worst-first which member to enter — the layer that sits ABOVE a normal loop.
supportmaturity
featureroster.go — C6 of the support-maturity epic (#1249/#1243): score non-model FEATURES on the SAME M0–M7 ladder the model×backend grid reads off, so "feature support" and "architecture support" come off one instrument instead of two prose tables.
 featureroster.go — C6 of the support-maturity epic (#1249/#1243): score non-model FEATURES on the SAME M0–M7 ladder the model×backend grid reads off, so "feature support" and "architecture support" come off one instrument instead of two prose tables.
supportmaturityscore
Package supportmaturityscore grades the covmatrix support rungs as a scorecard.
 Package supportmaturityscore grades the covmatrix support rungs as a scorecard.
swebench
Package swebench turns SWE-bench Verified into a fak-native benchmark whose results are directly comparable to the external "N-Server Cache Benchmarking Tool" (the Benchmark repo, "bench") that runs the same task set against an SGLang endpoint.
 Package swebench turns SWE-bench Verified into a fak-native benchmark whose results are directly comparable to the external "N-Server Cache Benchmarking Tool" (the Benchmark repo, "bench") that runs the same task set against an SGLang endpoint.
swebenchsota
Package swebenchsota emits a dated SWE-bench SOTA reference snapshot extracted from the official leaderboard at https://www.swebench.com/.
 Package swebenchsota emits a dated SWE-bench SOTA reference snapshot extracted from the official leaderboard at https://www.swebench.com/.
sweepconfig
syspromptmmu
Package syspromptmmu emits fak's ordered base-context plan — the fak-first head of the context window (Rung 1 of the system-prompt MMU, epic #1258, issue #1259).
 Package syspromptmmu emits fak's ordered base-context plan — the fak-first head of the context window (Rung 1 of the system-prompt MMU, epic #1258, issue #1259).
taskdecision
taskidentity
Package taskidentity derives the canonical task identity for an agent session.
 Package taskidentity derives the canonical task identity for an agent session.
taskmgr
Package taskmgr is fak's process-local task manager concept.
 Package taskmgr is fak's process-local task manager concept.
terminalbench
Package terminalbench adapts Terminal-Bench-shaped command traces into fak command-boundary mediation reports.
 Package terminalbench adapts Terminal-Bench-shaped command traces into fak command-boundary mediation reports.
testroute
timeoutphase
Package timeoutphase is a pure classifier over one timed-out worker attempt: given the facts the caller observed (which lifecycle stage markers fired before the kill), decide WHICH stage the timeout actually happened in -- before the worker ever started, during its edit pass, during tests, during commit, or during push (#1793).
 Package timeoutphase is a pure classifier over one timed-out worker attempt: given the facts the caller observed (which lifecycle stage markers fired before the kill), decide WHICH stage the timeout actually happened in -- before the worker ever started, during its edit pass, during tests, during commit, or during push (#1793).
tokenizer
Package tokenizer is a tokenizer leaf for offline text/id conversion outside the model proof path.
 Package tokenizer is a tokenizer leaf for offline text/id conversion outside the model proof path.
toolcoverage
Package toolcoverage audits which load-bearing tools modules have sibling tests.
 Package toolcoverage audits which load-bearing tools modules have sibling tests.
toollint
Package toollint is the kernel's STATIC tool linter: it checks the registered tool SURFACE for inconsistencies the runtime would otherwise silently paper over on every single call.
 Package toollint is the kernel's STATIC tool linter: it checks the registered tool SURFACE for inconsistencies the runtime would otherwise silently paper over on every single call.
toolproc
Package toolproc is the kernel's process table for tool calls — the lifecycle spine for LONG-RUNNING tool use.
 Package toolproc is the kernel's process table for tool calls — the lifecycle spine for LONG-RUNNING tool use.
toolprocgate
Package toolprocgate is the revocation gate — the first ENFORCEMENT rung of the tool process table (seam 2 of docs/notes/CONCEPT-TOOL-PROCESS-TABLE-2026-07-02.md).
 Package toolprocgate is the revocation gate — the first ENFORCEMENT rung of the tool process table (seam 2 of docs/notes/CONCEPT-TOOL-PROCESS-TABLE-2026-07-02.md).
toolsandbox
Package toolsandbox adapts tau3/ToolSandbox-shaped policy-state traces into fak adjudication reports.
 Package toolsandbox adapts tau3/ToolSandbox-shaped policy-state traces into fak adjudication reports.
tracesink
Package tracesink is a payload-bearing, IFC-labeled TRAJECTORY SINK.
 Package tracesink is a payload-bearing, IFC-labeled TRAJECTORY SINK.
trajectory
Package trajectory is fak's TRAJECTORY DATA PLANE — the typed, exportable record of what an agent actually did, turn by turn, that application-layer optimizers build trajectory/memory/cache/planner analyses ON TOP of.
 Package trajectory is fak's TRAJECTORY DATA PLANE — the typed, exportable record of what an agent actually did, turn by turn, that application-layer optimizers build trajectory/memory/cache/planner analyses ON TOP of.
trajhook
Package trajhook is the PLUGGABLE TRAJECTORY-SCORER SEAM — the rung that lets a trivial application-layer skill garden trajectories (flag bad queries, find near-duplicate work, prune dead memory) WITHOUT a core edit to fak.
 Package trajhook is the PLUGGABLE TRAJECTORY-SCORER SEAM — the rung that lets a trivial application-layer skill garden trajectories (flag bad queries, find near-duplicate work, prune dead memory) WITHOUT a core edit to fak.
treedoctor
Package treedoctor diagnoses and (optionally) sweeps a fak working tree that has gone un-tidy under a permanently-on agent fleet, where the trunk is never quiescent.
 Package treedoctor diagnoses and (optionally) sweeps a fak working tree that has gone un-tidy under a permanently-on agent fleet, where the trunk is never quiescent.
trendreport
Package trendreport is the generic, consumer-agnostic substrate the fak trend-reports share: the durable-JSONL ledger plumbing (parse / latest-prior / append-line), the per-tick direction word, the embeddable control-pane Envelope, and the advisory gate whose only failing finding is the caller's *_unmeasured token.
 Package trendreport is the generic, consumer-agnostic substrate the fak trend-reports share: the durable-JSONL ledger plumbing (parse / latest-prior / append-line), the per-tick direction word, the embeddable control-pane Envelope, and the advisory gate whose only failing finding is the caller's *_unmeasured token.
turnbench
changepoint.go — CHANGE-POINT DETECTION on the overhead/benchmark series (issue #1163, T7 of the self-tax assurance epic #1147).
 changepoint.go — CHANGE-POINT DETECTION on the overhead/benchmark series (issue #1163, T7 of the self-tax assurance epic #1147).
turntaxmeter
hooklat.go — the guard-hook latency rollup (issue #1993): fold the DOS hook-observation stream's per-observation latency_ms into percentiles and judge the tail against a declared budget.
 hooklat.go — the guard-hook latency rollup (issue #1993): fold the DOS hook-observation stream's per-observation latency_ms into percentiles and judge the tail against a declared budget.
uiquality
Package uiquality is the deterministic measuring stick for fak's terminal UI/UX quality — the surface the sibling scorecards never watch.
 Package uiquality is the deterministic measuring stick for fak's terminal UI/UX quality — the surface the sibling scorecards never watch.
unwitnessedclaim
Package unwitnessedclaim is a closed, pure checker for one narrow drift: an issue whose latest comment reads as a self-reported completion claim ("done", "fixed", "shipped", ...) while the issue itself is still open -- meaning no commit's ship-stamp ancestry ("Fixes #N") ever landed to close it.
 Package unwitnessedclaim is a closed, pure checker for one narrow drift: an issue whose latest comment reads as a self-reported completion claim ("done", "fixed", "shipped", ...) while the issue itself is still open -- meaning no commit's ship-stamp ancestry ("Fixes #N") ever landed to close it.
urllint
Package urllint is a static witness for the network external-boundary claim's twin of pathlint: that no Go source hardcodes a model/tokenizer DOWNLOAD url outside the one audited chokepoint that derives and (via a network-gated test) verifies them.
 Package urllint is a static witness for the network external-boundary claim's twin of pathlint: that no Go source hardcodes a model/tokenizer DOWNLOAD url outside the one audited chokepoint that derives and (via a network-gated test) verifies them.
usagelog
Package usagelog is the durable, append-only, tamper-evident CLI-INVOCATION journal — the record of how `fak` ITSELF is used, the gap epic #1601 (child A, #1608) closes.
 Package usagelog is the durable, append-only, tamper-evident CLI-INVOCATION journal — the record of how `fak` ITSELF is used, the gap epic #1601 (child A, #1608) closes.
vcachecal
Package vcachecal is the vCache observe & calibrate engine — milestone M1 of the vCache epic (issue #716).
 Package vcachecal is the vCache observe & calibrate engine — milestone M1 of the vCache epic (issue #716).
vcachechain
Package vcachechain is the vCache chains & recall engine — milestone M4 of the vCache epic (issue #719).
 Package vcachechain is the vCache chains & recall engine — milestone M4 of the vCache epic (issue #719).
vcacheextract
Package vcacheextract sanitizes Codex session JSONL token telemetry.
 Package vcacheextract sanitizes Codex session JSONL token telemetry.
vcachegov
Package vcachegov is the vCache Governor — the steady-state policy layer that decides, per cacheable prefix, whether to heartbeat-pin it, let it lazy-rebuild, ride natural traffic, or evict it; how many prefixes to warm inside rate-limit headroom; and how to route chained requests onto a consistent warm shard.
 Package vcachegov is the vCache Governor — the steady-state policy layer that decides, per cacheable prefix, whether to heartbeat-pin it, let it lazy-rebuild, ride natural traffic, or evict it; how many prefixes to warm inside rate-limit headroom; and how to route chained requests onto a consistent warm shard.
vcacheobserve
Package vcacheobserve is the vCache per-sub-concept OBSERVABILITY lens over real provider-cache telemetry — the "10x observability into all the sub-concepts" surface behind `fak vcache observe`.
 Package vcacheobserve is the vCache per-sub-concept OBSERVABILITY lens over real provider-cache telemetry — the "10x observability into all the sub-concepts" surface behind `fak vcache observe`.
vcacheqa
Package vcacheqa is the shared QA harness + witness contract every vCache gate (M1 vcachecal, M2 vcachestar, M3 vcachewarm, M4 vcachechain, M5 vcachegov, and the attribution/conflation surfaces) must pass before it is allowed to flip default-on.
 Package vcacheqa is the shared QA harness + witness contract every vCache gate (M1 vcachecal, M2 vcachestar, M3 vcachewarm, M4 vcachechain, M5 vcachegov, and the attribution/conflation surfaces) must pass before it is allowed to flip default-on.
vcachescore
Package vcachescore composes the vCache proof leaves into an agent-facing benchmark scorecard.
 Package vcachescore composes the vCache proof leaves into an agent-facing benchmark scorecard.
vcachesnapshot
Package vcachesnapshot persists the gateway's observed per-turn provider-cache window to a small JSONL file at a well-known per-user path, so a SEPARATE `fak vcache score` process can read the REALIZED cache window a finished `fak guard`/`fak serve` session observed — instead of falling back to the synthetic-Zipf planned forecast.
 Package vcachesnapshot persists the gateway's observed per-turn provider-cache window to a small JSONL file at a well-known per-user path, so a SEPARATE `fak vcache score` process can read the REALIZED cache window a finished `fak guard`/`fak serve` session observed — instead of falling back to the synthetic-Zipf planned forecast.
vcachestar
Package vcachestar is the vCache M2 star-anchor decision layer.
 Package vcachestar is the vCache M2 star-anchor decision layer.
vcachewarm
Package vcachewarm is the vCache M3 dedicated-warming decision layer.
 Package vcachewarm is the vCache M3 dedicated-warming decision layer.
vdso
Package vdso is the tool vDSO: a 3-tier local fast path that answers a tool call with NO engine and NO remote round-trip — the agentic analogue of the kernel vDSO that serves gettimeofday() from userspace without a syscall.
 Package vdso is the tool vDSO: a 3-tier local fast path that answers a tool call with NO engine and NO remote round-trip — the agentic analogue of the kernel vDSO that serves gettimeofday() from userspace without a syscall.
vllmcompile
Package vllmcompile is the tuned-baseline gate for served-engine benchmarks: it records an engine's torch.compile / CUDA-graph / warmup state as a `vllm_compile` artifact block and refuses to let a cold or accidentally misconfigured engine masquerade as a tuned baseline (#1731).
 Package vllmcompile is the tuned-baseline gate for served-engine benchmarks: it records an engine's torch.compile / CUDA-graph / warmup state as a `vllm_compile` artifact block and refuses to let a cold or accidentally misconfigured engine masquerade as a tuned baseline (#1731).
webbench
Package webbench turns frontier web/browser agent benchmarks into fak-native benchmarks whose results directly measure the value of fak's session value stack on multi-turn web automation tasks.
 Package webbench turns frontier web/browser agent benchmarks into fak-native benchmarks whose results directly measure the value of fak's session value stack on multi-turn web automation tasks.
webbench/browser
Package browser is the webbench browser-control adapter over Playwright CLI.
 Package browser is the webbench browser-control adapter over Playwright CLI.
whatschanged
windowgate
Package windowgate is the NO-DESKTOP-POPUP ratchet: the durable gate that keeps always-on fleet automation from flashing console windows on the interactive desktop — the "random terminal popups".
 Package windowgate is the NO-DESKTOP-POPUP ratchet: the durable gate that keeps always-on fleet automation from flashing console windows on the interactive desktop — the "random terminal popups".
wirescreen
Package wirescreen — ROADMAP for the "local model on the wire" proposer spine.
 Package wirescreen — ROADMAP for the "local model on the wire" proposer spine.
witness
decision.go — the append-only decision recorder: every adjudication / refusal the kernel makes, written as a git note on a DEDICATED side ref so the record is durable, peer-readable, and NEVER touches the trunk's commit objects.
 decision.go — the append-only decision recorder: every adjudication / refusal the kernel makes, written as a git note on a DEDICATED side ref so the record is durable, peer-readable, and NEVER touches the trunk's commit objects.
workerenvelope
Package workerenvelope defines a small machine-readable envelope for the RESULT a dispatch worker hands back when it finishes a GitHub issue.
 Package workerenvelope defines a small machine-readable envelope for the RESULT a dispatch worker hands back when it finishes a GitHub issue.
workflow
Package workflow is a built-in workflow orchestration layer (D-005, issue #245): a small, deterministic DAG engine plus the three patterns agent frameworks reach for most — map-reduce, fan-out, and an explicit dependency DAG — expressible as a JSON/YAML document and executed CPU-correctly with no model in the loop.
 Package workflow is a built-in workflow orchestration layer (D-005, issue #245): a small, deterministic DAG engine plus the three patterns agent frameworks reach for most — map-reduce, fan-out, and an explicit dependency DAG — expressible as a JSON/YAML document and executed CPU-correctly with no model in the loop.
workflowaudit
Package workflowaudit classifies every git-branch / tag reference in the project's GitHub Actions workflows against the branch-role contract (internal/branchrole), so the dev->main front-door migration (#1697 / #1701) has a checkable map of what each branch filter is FOR -- and a gate that reds the moment a new, unclassified development-path `main`/`master` reference is introduced.
 Package workflowaudit classifies every git-branch / tag reference in the project's GitHub Actions workflows against the branch-role contract (internal/branchrole), so the dev->main front-door migration (#1697 / #1701) has a checkable map of what each branch filter is FOR -- and a gate that reds the moment a new, unclassified development-path `main`/`master` reference is introduced.
workflowlint
Package workflowlint refutes "fak-blind" ultracode Workflow scripts — the ones an ultracode session emits that never touch fak's own self-index, memory algebra, or shared-path leasing.
 Package workflowlint refutes "fak-blind" ultracode Workflow scripts — the ones an ultracode session emits that never touch fak's own self-index, memory algebra, or shared-path leasing.
worktype
Package worktype names the closed set of WORK CLASSES the project-management surfaces sort work into — the single source of truth that lets the milestone roadmap and the `fak program` report draw the same line between an ONGOING OPTIMIZATION PROGRAM and a DISCRETE DELIVERABLE EPIC.
 Package worktype names the closed set of WORK CLASSES the project-management surfaces sort work into — the single source of truth that lets the milestone roadmap and the `fak program` report draw the same line between an ONGOING OPTIMIZATION PROGRAM and a DISCRETE DELIVERABLE EPIC.
xenginekv
Package xenginekv ships the cross-engine zero-copy KV co-residence seam (#448): a RegionBackend whose Resolver hands out RefRegion handles into ONE addressable arena where an EXTERNAL engine's KV cache and fak's tool args/results CO-RESIDE.
 Package xenginekv ships the cross-engine zero-copy KV co-residence seam (#448): a RegionBackend whose Resolver hands out RefRegion handles into ONE addressable arena where an EXTERNAL engine's KV cache and fak's tool args/results CO-RESIDE.
pkg
abi
Package abi is the IMPORTABLE vendor surface of fak's frozen ABI.
 Package abi is the IMPORTABLE vendor surface of fak's frozen ABI.
fakclient
Package fakclient is the importable Go client SDK for the fak gateway's fak-native verdict surface (F-007, issue #205).
 Package fakclient is the importable Go client SDK for the fak gateway's fak-native verdict surface (F-007, issue #205).
scorecard
Package scorecard is the IMPORTABLE shared kernel behind fak's scorecard family.
 Package scorecard is the IMPORTABLE shared kernel behind fak's scorecard family.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.